You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

1242 lines
36 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
///////////////////////////////////////////////////////////////////////////////
// //
// hsDXTDirectXCodec Class Functions //
// DirectX-based codec functions //
// Cyan, Inc. //
// //
//// Version History //////////////////////////////////////////////////////////
// //
// 6.8.2001 mcn - Got a much-needed Plasma 2.0/DX8 update. //
// //
///////////////////////////////////////////////////////////////////////////////
#include "hsConfig.h"
#include "hsWindows.h"
#include <ddraw.h>
#include <d3d9.h>
#include "hsTypes.h"
#include "hsDXTDirectXCodec.h"
#include "plMipmap.h"
#include "hsCodecManager.h"
#include "plPipeline/hsGDDrawDllLoad.h"
namespace {
typedef HRESULT(WINAPI * DIRECTDRAWCREATEEX)( GUID*, VOID**, REFIID, IUnknown* );
}
enum
{
D3DTEXTURE_FMT_ARGB32_8888 = 0x00000002, // No. 2: 8888 ARGB (32-bit) format.
D3DTEXTURE_FMT_FOURCC_DXT1 = 0x00002000, // No.14: DXTn FourCC (DXT1), format.
D3DTEXTURE_FMT_FOURCC_DXT5 = 0x00020000, // No.18: DXTn FourCC (DXT5), format.
};
hsBool hsDXTDirectXCodec::fRegistered = false;
//// Small Init Functions /////////////////////////////////////////////////////
hsDXTDirectXCodec& hsDXTDirectXCodec::Instance()
{
static hsDXTDirectXCodec the_instance;
return the_instance;
}
hsDXTDirectXCodec::hsDXTDirectXCodec() : fDirectDraw( nil ), fDDLibraryInstance( nil ), fFlags( 0 )
{
}
hsDXTDirectXCodec::~hsDXTDirectXCodec()
{
if ((fFlags & kExternalInit) == 0)
{
if (fDirectDraw)
{
fDirectDraw->Release();
}
if (fDDLibraryInstance)
{
FreeLibrary(fDDLibraryInstance);
}
}
fDirectDraw = nil;
fDDLibraryInstance = nil;
}
hsBool hsDXTDirectXCodec::Register()
{
return hsCodecManager::Instance().Register( &(Instance()), plMipmap::kDirectXCompression, 500 );
}
//// Initialize ///////////////////////////////////////////////////////////////
void hsDXTDirectXCodec::Initialize( IDirect3DDevice8 *directDraw )
{
/* if (directDraw)
{
fFlags |= (kInitialized | kExternalInit);
}
else
{
fFlags &= ~(kInitialized | kExternalInit);
}
fDirectDraw = directDraw;
*/
// Don't do anything--force IInitialize to run
}
//// IInitialize //////////////////////////////////////////////////////////////
// Gotta initialize D3D ourself and create a device and everything. This is
// a LOT messier than it was in DX7, since this time we got D3D to deal with
hsBool hsDXTDirectXCodec::IInitialize()
{
fFlags |= kInitialized;
// if( hsGDDrawDllLoad::GetDDrawDll() == nil )
// return false;
DIRECTDRAWCREATEEX DirectDrawCreateEx = 0;
// Initialize DirectDraw
HRESULT hr;
DirectDrawCreateEx = (DIRECTDRAWCREATEEX)GetProcAddress( hsGDDrawDllLoad::GetD3DDll(), "DirectDrawCreateEx" );
if( DirectDrawCreateEx == nil )
return false;
/// Using EMULATIONONLY here usually fails--using NULL forces the
/// use of the standard display driver, which DOES work.
if (FAILED(hr = DirectDrawCreateEx((GUID FAR *)NULL/*DDCREATE_EMULATIONONLY*/, (VOID**)&fDirectDraw, IID_IDirectDraw7, NULL)))
return false;
if (FAILED(hr = fDirectDraw->SetCooperativeLevel(NULL, DDSCL_NORMAL)))
return false;
return true;
}
//// CreateCompressedMipmap ///////////////////////////////////////////////////
// Updated 8.15.2000 mcn to generate uncompressed mipmaps down to 1x1 (the
// decompressor better know how to deal with this!) Also cleaned up so I can
// read it :)
plMipmap *hsDXTDirectXCodec::CreateCompressedMipmap( plMipmap *uncompressed )
{
const plMipmap *b = uncompressed;
plMipmap *compressed = nil;
UInt32 numLevels = 1, numCompLevels;
UInt32 compFormat, totalSize, compSize;
Int32 width, height, blockSize, i;
/// Sanity checks, initialization, etc.
if( !Initialized() )
{
if( !IInitialize() )
return nil;
}
hsAssert( fRegistered, "Calling member of unregistered codec." );
hsAssert( !uncompressed->IsCompressed(), "Trying to re-compress compressed bitmap." );
if( !fDirectDraw )
return nil;
/// Check width and height
if( ( uncompressed->GetWidth() | uncompressed->GetHeight() ) & 0x03 )
return nil; /// Width and height must be multiple of 4
/// This used to be checked later--but WHY? We can check it now and
/// potentially avoid a lot of headache
compFormat = ICompressedFormat( b );
if( !compFormat )
return nil;
/// Precalc this
blockSize = ( compFormat == D3DTEXTURE_FMT_FOURCC_DXT1 ) ? 8 : 16;
{
compSize = 0;
numCompLevels = 0;
width = uncompressed->GetWidth();
height = uncompressed->GetHeight();
/// Count the levels we're going to compress
for( i = 0; i < uncompressed->GetNumLevels(); i++ )
{
if( ( width | height ) & 0x03 )
break;
numCompLevels++;
compSize += blockSize * width * height >> 4;
width >>= 1;
height >>= 1;
}
/// NEW 8.15.2000 mcn - Now count up remaining levels down to 1x1
totalSize = compSize;
numLevels = numCompLevels;
for( ; i < uncompressed->GetNumLevels(); i++ )
{
totalSize += uncompressed->GetLevelSize( (UInt8)i );
width >>= 1;
height >>= 1;
numLevels++;
}
}
/// Create source DirectDraw surface
IDirectDrawSurface7 *srcSurface = IMakeDirect3DSurface( D3DTEXTURE_FMT_ARGB32_8888,
numCompLevels, uncompressed->GetWidth(),
uncompressed->GetHeight() );
IFillSurface( (hsRGBAColor32 *)uncompressed->GetImage(), numCompLevels, srcSurface );
/// Create destination DirectDraw surface
IDirectDrawSurface7 *destSurface = IMakeDirect3DSurface( compFormat, numCompLevels,
uncompressed->GetWidth(),
uncompressed->GetHeight() );
ICopySurface( destSurface, srcSurface, numCompLevels );
/// Now set up the data structures
compressed = TRACKED_NEW plMipmap( uncompressed->GetWidth(), uncompressed->GetHeight(), plMipmap::kARGB32Config,
uncompressed->GetNumLevels(), plMipmap::kDirectXCompression,
( compFormat == D3DTEXTURE_FMT_FOURCC_DXT1 ) ?
plMipmap::DirectXInfo::kDXT1 : plMipmap::DirectXInfo::kDXT5 );
/// Copy compressed data back from the surface
IFillFromSurface( (hsRGBAColor32 *)compressed->GetImage(), numCompLevels, destSurface );
/// Finally, copy back any remaining data
if( numCompLevels < numLevels )
{
/// Now copy the rest straight over
for( i = numCompLevels; i < numLevels; i++ )
{
memcpy( compressed->GetLevelPtr( (UInt8)i ), uncompressed->GetLevelPtr( (UInt8)i ),
uncompressed->GetLevelSize( (UInt8)i ) );
}
}
/// All done!
return compressed;
}
//// CreateUncompressedMipmap /////////////////////////////////////////////////
// Updated 8.15.2000 mcn to support mipmaps down to 1x1. See
// CreateCompressedMipmap(). Also cleaned up the code a bit (too tired to
// clean it ALL up)
plMipmap *hsDXTDirectXCodec::CreateUncompressedMipmap( plMipmap *compressed,
UInt8 bitDepth )
{
/// Use software decompression ALWAYS
return nil;
/*
plMipmap *uncompressed = nil;
UInt32 mmlvs, formatType, numCompLevels;
Int32 totalSize, width, height, i;
/// Check bit depth--if it's 16 bit, we don't support it (for now)
if( ( bitDepth & hsCodecManager::kBitDepthMask ) != hsCodecManager::k16BitDepth )
return nil;
if( !Initialized() )
{
if( !IInitialize() )
return nil;
}
/// Sanity checks
hsAssert( fRegistered, "Calling member of unregistered codec." );
hsAssert( compressed->fFlags & hsGMipmap::kCompressed, "Trying to uncompress already uncompressed bitmap." );
hsAssert( compressed->fCompressionFormat == hsGMipmap::kDirectXCompression, "Uncompressing wrong format." );
hsAssert( ( compressed->fDirectXInfo.fCompressionType == hsGMipmap::DirectXInfo::kDXT1 ) ||
( compressed->fDirectXInfo.fCompressionType == hsGMipmap::DirectXInfo::kDXT5 ),
"Unsupported directX compression format." );
if( !fDirectDraw )
return nil;
if( compressed->fDirectXInfo.fCompressionType == hsGMipmap::DirectXInfo::kDXT5 )
{
// Fall out since directX software decompressor doesn't work...
return nil;
}
if( compressed->fFlags & hsGMipmap::kMipMap )
{
mmCompressed->SetLevel( 0 );
mmlvs = mmCompressed->GetNumLevels();
for( i = 0, numCompLevels = 0; i < mmlvs; i++ )
{
mmCompressed->SetLevel( i );
if( ( mmCompressed->fWidth | mmCompressed->fHeight ) & 0x03 )
break;
numCompLevels++;
}
mmCompressed->SetLevel( 0 );
}
else
{
mmlvs = numCompLevels = 1;
}
/// Get format type
formatType = ( compressed->fDirectXInfo.fCompressionType == hsGMipmap::DirectXInfo::kDXT1 ) ?
D3DTEXTURE_FMT_FOURCC_DXT1 : D3DTEXTURE_FMT_FOURCC_DXT5;
/// Make the surfaces (decompress in the process)
IDirectDrawSurface7 *srcSurface = IMakeDirect3DSurface( formatType, numCompLevels,
compressed->fWidth, compressed->fHeight );
IFillSurface( (hsRGBAColor32 *)compressed->fImage, numCompLevels, srcSurface );
IDirectDrawSurface7 *destSurface = IMakeDirect3DSurface( D3DTEXTURE_FMT_ARGB32_8888, numCompLevels,
compressed->fWidth, compressed->fHeight );
ICopySurface( destSurface, srcSurface, numCompLevels );
/// Set up the uncompressed data structure
if( compressed->fFlags & hsGMipmap::kMipMap )
{
mmUncompressed = TRACKED_NEW hsGMipmapClass;
uncompressed = mmUncompressed;
}
else
{
uncompressed = TRACKED_NEW plMipmap;
mmUncompressed = nil;
}
uncompressed->fWidth = compressed->fWidth;
uncompressed->fHeight = compressed->fHeight;
uncompressed->fPixelSize = 32;
uncompressed->fRowBytes = uncompressed->fWidth * uncompressed->fPixelSize >> 3;
uncompressed->fFlags = compressed->fFlags & ~hsGMipmap::kCompressed;
uncompressed->fCompressionFormat = 0;
uncompressed->fDirectXInfo.fBlockSize = 0;
uncompressed->fDirectXInfo.fCompressionType = hsGMipmap::DirectXInfo::kError;
/// Handle mipmaps or single image?
if( mmUncompressed )
{
totalSize = 0;
width = compressed->fWidth;
height = compressed->fHeight;
for( i = 0; i < mmlvs; i++ )
{
totalSize += width * height * uncompressed->fPixelSize >> 3;
width >>= 1;
height >>= 1;
}
mmUncompressed->fImage = HSMemory::New( totalSize );
mmUncompressed->SetData( mmUncompressed->fImage );
mmUncompressed->SetNumLevels( mmlvs );
}
else
{
uncompressed->fImage = HSMemory::New( uncompressed->fWidth * uncompressed->fHeight *
uncompressed->fPixelSize >> 3 );
}
/// Copy over compressed levels
IFillFromSurface( (hsRGBAColor32 *)uncompressed->fImage, numCompLevels, destSurface );
/// Now take care of the remainder levels
if( mmUncompressed )
{
for( i = numCompLevels; i < mmlvs; i++ )
{
mmUncompressed->SetLevel( i );
mmCompressed->SetLevel( i );
memcpy( mmUncompressed->fImage, mmCompressed->fImage, mmCompressed->ImageSize() );
}
mmUncompressed->SetLevel( 0 );
mmCompressed->SetLevel( 0 );
}
/// All done!
return uncompressed;
*/
}
UInt32 hsDXTDirectXCodec::ICompressedFormat(const plMipmap *uncompressed)
{
if( uncompressed->GetFlags() & plMipmap::kAlphaChannelFlag )
return D3DTEXTURE_FMT_FOURCC_DXT5;
return D3DTEXTURE_FMT_FOURCC_DXT1;
}
//// IFindTextureFormat ///////////////////////////////////////////////////////
// Changed to a local function 6.8.2001 to avoid certain annoying problems
// with headers and the compiler.
DDPIXELFORMAT IFindTextureFormat(UInt32 formatType)
{
DDPIXELFORMAT ddPixelFormat;
memset( &ddPixelFormat, 0x00, sizeof(DDPIXELFORMAT) );
ddPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
switch (formatType)
{
case D3DTEXTURE_FMT_ARGB32_8888:
ddPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
ddPixelFormat.dwFourCC = 0;
ddPixelFormat.dwRGBBitCount = 32;
ddPixelFormat.dwRBitMask = 0x00ff0000;
ddPixelFormat.dwGBitMask = 0x0000ff00;
ddPixelFormat.dwBBitMask = 0x000000ff;
ddPixelFormat.dwRGBAlphaBitMask = 0xff000000;
return ddPixelFormat;
case D3DTEXTURE_FMT_FOURCC_DXT1:
ddPixelFormat.dwFlags = DDPF_FOURCC;
ddPixelFormat.dwFourCC = FOURCC_DXT1;
return ddPixelFormat;
case D3DTEXTURE_FMT_FOURCC_DXT5:
ddPixelFormat.dwFlags = DDPF_FOURCC;
ddPixelFormat.dwFourCC = FOURCC_DXT5;
return ddPixelFormat;
default:
hsAssert(false, "Unknown texture format selected");
return ddPixelFormat;
}
}
IDirectDrawSurface7 *hsDXTDirectXCodec::IMakeDirect3DSurface(UInt32 formatType, UInt32 mipMapLevels,
UInt32 width, UInt32 height)
{
DDSURFACEDESC2 ddsd2;
memset( &ddsd2, 0x00, sizeof(DDSURFACEDESC2) );
ddsd2.dwSize = sizeof(DDSURFACEDESC2);
ddsd2.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
ddsd2.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
if(mipMapLevels > 1 )
{
ddsd2.dwFlags |= DDSD_MIPMAPCOUNT;
ddsd2.ddsCaps.dwCaps |= DDSCAPS_MIPMAP|DDSCAPS_COMPLEX;
}
ddsd2.dwMipMapCount = mipMapLevels;
ddsd2.dwWidth = width;
ddsd2.dwHeight = height;
ddsd2.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
ddsd2.ddpfPixelFormat = IFindTextureFormat(formatType);
IDirectDrawSurface7 *lpDDsTex;
HRESULT res = fDirectDraw->CreateSurface( &ddsd2, &lpDDsTex, NULL );
if( S_OK != res )
CheckErrorCode(res);
return lpDDsTex;
}
void hsDXTDirectXCodec::IFillSurface(hsRGBAColor32* src, UInt32 mmlvs, IDirectDrawSurface7 *pddsDest)
{
UInt8 *pTexDat = (UInt8*)src;
UInt32 cap = 0;
HRESULT hr;
DDSCAPS2 ddsCaps2;
for( WORD wNum=0; wNum < mmlvs; wNum++ )
{
DDSURFACEDESC2 ddsd2;
memset( &ddsd2, 0x00, sizeof(DDSURFACEDESC2) );
ddsd2.dwSize = sizeof( DDSURFACEDESC2 );
hr = pddsDest->Lock( NULL, &ddsd2, DDLOCK_WAIT | DDLOCK_WRITEONLY | DDLOCK_DISCARDCONTENTS, NULL );
if (ddsd2.ddpfPixelFormat.dwFlags == DDPF_FOURCC)
{
Int32 blockSize = (ddsd2.ddpfPixelFormat.dwFourCC == FOURCC_DXT1) ? 8 : 16;
cap = ddsd2.dwHeight * ddsd2.dwWidth * blockSize >> 4;
memcpy( (char*)ddsd2.lpSurface, pTexDat, cap );
pTexDat += cap;
}
else
{
hsAssert(ddsd2.ddpfPixelFormat.dwRGBBitCount == 32, "Format not supported.");
Int32* dest = (Int32*)ddsd2.lpSurface;
Int32 pixelCount = ddsd2.dwHeight * ddsd2.dwWidth;
Int32 j;
for (j = 0; j < pixelCount; ++j)
{
dest[j] = ( ( src->a << 24 ) | ( src->r << 16 ) | ( src->g << 8 ) | src->b );
src++;
}
}
hr = pddsDest->Unlock( NULL );
memset( &ddsCaps2, 0x00, sizeof(DDSCAPS2) );
ddsCaps2.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP;
if( SUCCEEDED( pddsDest->GetAttachedSurface( &ddsCaps2, &pddsDest ) ) )
pddsDest->Release();
}
}
void hsDXTDirectXCodec::IFillFromSurface(hsRGBAColor32* dest, UInt32 mmlvs, IDirectDrawSurface7 *pddsSrc)
{
UInt8 *pTexDat = (UInt8 *)dest;
UInt32 cap = 0;
HRESULT hr;
DDSCAPS2 ddsCaps2;
DDSURFACEDESC2 ddsd2;
for( WORD wNum = 0; wNum < mmlvs; wNum++ )
{
memset( &ddsd2, 0, sizeof( DDSURFACEDESC2 ) );
ddsd2.dwSize = sizeof( DDSURFACEDESC2 );
hr = pddsSrc->Lock( NULL, &ddsd2, DDLOCK_WAIT | DDLOCK_READONLY |
DDLOCK_DISCARDCONTENTS, NULL );
if( ddsd2.ddpfPixelFormat.dwFlags == DDPF_FOURCC )
{
Int32 blockSize = ( ddsd2.ddpfPixelFormat.dwFourCC == FOURCC_DXT1 ) ? 8 : 16;
cap = ddsd2.dwHeight * ddsd2.dwWidth * blockSize >> 4;
memcpy( pTexDat, (char*)ddsd2.lpSurface, cap );
pTexDat += cap;
}
else
{
hsAssert( ddsd2.ddpfPixelFormat.dwRGBBitCount == 32, "Format not supported." );
Int32* src = (Int32*)ddsd2.lpSurface;
Int32 pixelCount = ddsd2.dwHeight * ddsd2.dwWidth;
Int32 j;
for (j = 0; j < pixelCount; ++j)
{
dest->a = (UInt8)((src[j] >> 24) & 0xff);
dest->r = (UInt8)((src[j] >> 16) & 0xff);
dest->g = (UInt8)((src[j] >> 8) & 0xff);
dest->b = (UInt8)((src[j]) & 0xff);
dest++;
}
}
hr = pddsSrc->Unlock( NULL );
memset( &ddsCaps2, 0, sizeof( DDSCAPS2 ) );
ddsCaps2.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP;
if( SUCCEEDED( pddsSrc->GetAttachedSurface( &ddsCaps2, &pddsSrc ) ) )
pddsSrc->Release();
}
}
void hsDXTDirectXCodec::ICopySurface(IDirectDrawSurface7 *dest, IDirectDrawSurface7 *src, Int32 mipMapLevels)
{
DDSURFACEDESC2 ddsd2;
memset( &ddsd2, 0x00, sizeof(DDSURFACEDESC2) );
ddsd2.dwSize = sizeof( DDSURFACEDESC2 );
DDSCAPS2 ddsCaps;
ZeroMemory(&ddsCaps, sizeof(ddsCaps));
ddsCaps.dwCaps = DDSCAPS_TEXTURE;
if (mipMapLevels > 1)
ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
IDirectDrawSurface7 *lpSrc = src;
IDirectDrawSurface7 *lpDst = dest;
int mmlvs = mipMapLevels;
HRESULT hr;
int i;
for( i = 0; i < mmlvs; i++ )
{
if( FAILED(hr = lpDst->Blt(NULL, lpSrc, NULL, DDBLT_WAIT, NULL)) )
{
hsAssert(false, "Uh oh!");
}
if (FAILED(hr = lpSrc->GetAttachedSurface(&ddsCaps, &lpSrc))
||FAILED(hr = lpDst->GetAttachedSurface(&ddsCaps, &lpDst)))
{
break;
}
lpSrc->Release();
lpDst->Release();
}
}
void hsDXTDirectXCodec::CheckErrorCode(HRESULT res)
{
switch( res )
{
// This object is already initialized
case DDERR_ALREADYINITIALIZED:
hsAssert(false, "DDERR_ALREADYINITIALIZED.");
break;
// This surface can not be attached to the requested surface.
case DDERR_CANNOTATTACHSURFACE:
hsAssert(false, "DDERR_CANNOTATTACHSURFACE.");
break;
// This surface can not be detached from the requested surface.
case DDERR_CANNOTDETACHSURFACE:
hsAssert(false, "DDERR_CANNOTDETACHSURFACE.");
break;
// Support is currently not available.
case DDERR_CURRENTLYNOTAVAIL:
hsAssert(false, "DDERR_CURRENTLYNOTAVAIL.");
break;
// An exception was encountered while performing the requested operation
case DDERR_EXCEPTION:
hsAssert(false, "DDERR_EXCEPTION.");
break;
// Generic failure.
case DDERR_GENERIC:
hsAssert(false, "DDERR_GENERIC.");
break;
// Height of rectangle provided is not a multiple of reqd alignment
case DDERR_HEIGHTALIGN:
hsAssert(false, "DDERR_HEIGHTALIGN.");
break;
// Unable to match primary surface creation request with existing
// primary surface.
case DDERR_INCOMPATIBLEPRIMARY:
hsAssert(false, "DDERR_INCOMPATIBLEPRIMARY.");
break;
// One or more of the caps bits passed to the callback are incorrect.
case DDERR_INVALIDCAPS:
hsAssert(false, "DDERR_INVALIDCAPS.");
break;
// DirectDraw does not support provided Cliplist.
case DDERR_INVALIDCLIPLIST:
hsAssert(false, "DDERR_INVALIDCLIPLIST.");
break;
// DirectDraw does not support the requested mode
case DDERR_INVALIDMODE:
hsAssert(false, "DDERR_INVALIDMODE.");
break;
// DirectDraw received a pointer that was an invalid DIRECTDRAW object.
case DDERR_INVALIDOBJECT:
hsAssert(false, "DDERR_INVALIDOBJECT.");
break;
// One or more of the parameters passed to the callback function are
// incorrect.
case DDERR_INVALIDPARAMS:
hsAssert(false, "DDERR_INVALIDPARAMS.");
break;
// pixel format was invalid as specified
case DDERR_INVALIDPIXELFORMAT:
hsAssert(false, "DDERR_INVALIDPIXELFORMAT.");
break;
// Rectangle provided was invalid.
case DDERR_INVALIDRECT:
hsAssert(false, "DDERR_INVALIDRECT.");
break;
// Operation could not be carried out because one or more surfaces are locked
case DDERR_LOCKEDSURFACES:
hsAssert(false, "DDERR_LOCKEDSURFACES.");
break;
// There is no 3D present.
case DDERR_NO3D:
hsAssert(false, "DDERR_NO3D.");
break;
// Operation could not be carried out because there is no alpha accleration
// hardware present or available.
case DDERR_NOALPHAHW:
hsAssert(false, "DDERR_NOALPHAHW.");
break;
// no clip list available
case DDERR_NOCLIPLIST:
hsAssert(false, "DDERR_NOCLIPLIST.");
break;
// Operation could not be carried out because there is no color conversion
// hardware present or available.
case DDERR_NOCOLORCONVHW:
hsAssert(false, "DDERR_NOCOLORCONVHW.");
break;
// Create function called without DirectDraw object method SetCooperativeLevel
// being called.
case DDERR_NOCOOPERATIVELEVELSET:
hsAssert(false, "DDERR_NOCOOPERATIVELEVELSET.");
break;
// Surface doesn't currently have a color key
case DDERR_NOCOLORKEY:
hsAssert(false, "DDERR_NOCOLORKEY.");
break;
// Operation could not be carried out because there is no hardware support
// of the dest color key.
case DDERR_NOCOLORKEYHW:
hsAssert(false, "DDERR_NOCOLORKEYHW.");
break;
// No DirectDraw support possible with current display driver
case DDERR_NODIRECTDRAWSUPPORT:
hsAssert(false, "DDERR_NODIRECTDRAWSUPPORT.");
break;
// Operation requires the application to have exclusive mode but the
// application does not have exclusive mode.
case DDERR_NOEXCLUSIVEMODE:
hsAssert(false, "DDERR_NOEXCLUSIVEMODE.");
break;
// Flipping visible surfaces is not supported.
case DDERR_NOFLIPHW:
hsAssert(false, "DDERR_NOFLIPHW.");
break;
// There is no GDI present.
case DDERR_NOGDI:
hsAssert(false, "DDERR_NOGDI.");
break;
// Operation could not be carried out because there is no hardware present
// or available.
case DDERR_NOMIRRORHW:
hsAssert(false, "DDERR_NOMIRRORHW.");
break;
// Requested item was not found
case DDERR_NOTFOUND:
hsAssert(false, "DDERR_NOTFOUND.");
break;
// Operation could not be carried out because there is no overlay hardware
// present or available.
case DDERR_NOOVERLAYHW:
hsAssert(false, "DDERR_NOOVERLAYHW.");
break;
// Operation could not be carried out because the source and destination
// rectangles are on the same surface and overlap each other.
case DDERR_OVERLAPPINGRECTS:
hsAssert(false, "DDERR_OVERLAPPINGRECTS.");
break;
// Operation could not be carried out because there is no appropriate raster
// op hardware present or available.
case DDERR_NORASTEROPHW:
hsAssert(false, "DDERR_NORASTEROPHW.");
break;
// Operation could not be carried out because there is no rotation hardware
// present or available.
case DDERR_NOROTATIONHW:
hsAssert(false, "DDERR_NOROTATIONHW.");
break;
// Operation could not be carried out because there is no hardware support
// for stretching
case DDERR_NOSTRETCHHW:
hsAssert(false, "DDERR_NOSTRETCHHW.");
break;
// DirectDrawSurface is not in 4 bit color palette and the requested operation
// requires 4 bit color palette.
case DDERR_NOT4BITCOLOR:
hsAssert(false, "DDERR_NOT4BITCOLOR.");
break;
// DirectDrawSurface is not in 4 bit color index palette and the requested
// operation requires 4 bit color index palette.
case DDERR_NOT4BITCOLORINDEX:
hsAssert(false, "DDERR_NOT4BITCOLORINDEX.");
break;
// DirectDraw Surface is not in 8 bit color mode and the requested operation
// requires 8 bit color.
case DDERR_NOT8BITCOLOR:
hsAssert(false, "DDERR_NOT8BITCOLOR.");
break;
// Operation could not be carried out because there is no texture mapping
// hardware present or available.
case DDERR_NOTEXTUREHW:
hsAssert(false, "DDERR_NOTEXTUREHW.");
break;
// Operation could not be carried out because there is no hardware support
// for vertical blank synchronized operations.
case DDERR_NOVSYNCHW:
hsAssert(false, "DDERR_NOVSYNCHW.");
break;
// Operation could not be carried out because there is no hardware support
// for zbuffer blting.
case DDERR_NOZBUFFERHW:
hsAssert(false, "DDERR_NOZBUFFERHW.");
break;
// Overlay surfaces could not be z layered based on their BltOrder because
// the hardware does not support z layering of overlays.
case DDERR_NOZOVERLAYHW:
hsAssert(false, "DDERR_NOZOVERLAYHW.");
break;
// The hardware needed for the requested operation has already been
// allocated.
case DDERR_OUTOFCAPS:
hsAssert(false, "DDERR_OUTOFCAPS.");
break;
// DirectDraw does not have enough memory to perform the operation.
case DDERR_OUTOFMEMORY:
hsAssert(false, "DDERR_OUTOFMEMORY.");
break;
// DirectDraw does not have enough memory to perform the operation.
case DDERR_OUTOFVIDEOMEMORY:
hsAssert(false, "DDERR_OUTOFVIDEOMEMORY.");
break;
// hardware does not support clipped overlays
case DDERR_OVERLAYCANTCLIP:
hsAssert(false, "DDERR_OVERLAYCANTCLIP.");
break;
// Can only have ony color key active at one time for overlays
case DDERR_OVERLAYCOLORKEYONLYONEACTIVE:
hsAssert(false, "DDERR_OVERLAYCOLORKEYONLYONEACTIVE.");
break;
// Access to this palette is being refused because the palette is already
// locked by another thread.
case DDERR_PALETTEBUSY:
hsAssert(false, "DDERR_PALETTEBUSY.");
break;
// No src color key specified for this operation.
case DDERR_COLORKEYNOTSET:
hsAssert(false, "DDERR_COLORKEYNOTSET.");
break;
// This surface is already attached to the surface it is being attached to.
case DDERR_SURFACEALREADYATTACHED:
hsAssert(false, "DDERR_SURFACEALREADYATTACHED.");
break;
// This surface is already a dependency of the surface it is being made a
// dependency of.
case DDERR_SURFACEALREADYDEPENDENT:
hsAssert(false, "DDERR_SURFACEALREADYDEPENDENT.");
break;
// Access to this surface is being refused because the surface is already
// locked by another thread.
case DDERR_SURFACEBUSY:
hsAssert(false, "DDERR_SURFACEBUSY.");
break;
// Access to this surface is being refused because no driver exists
// which can supply a pointer to the surface.
// This is most likely to happen when attempting to lock the primary
// surface when no DCI provider is present.
// Will also happen on attempts to lock an optimized surface.
case DDERR_CANTLOCKSURFACE:
hsAssert(false, "DDERR_CANTLOCKSURFACE.");
break;
// Access to Surface refused because Surface is obscured.
case DDERR_SURFACEISOBSCURED:
hsAssert(false, "DDERR_SURFACEISOBSCURED.");
break;
// Access to this surface is being refused because the surface is gone.
// The DIRECTDRAWSURFACE object representing this surface should
// have Restore called on it.
case DDERR_SURFACELOST:
hsAssert(false, "DDERR_SURFACELOST.");
break;
// The requested surface is not attached.
case DDERR_SURFACENOTATTACHED:
hsAssert(false, "DDERR_SURFACENOTATTACHED.");
break;
// Height requested by DirectDraw is too large.
case DDERR_TOOBIGHEIGHT:
hsAssert(false, "DDERR_TOOBIGHEIGHT.");
break;
// Size requested by DirectDraw is too large -- The individual height and
// width are OK.
case DDERR_TOOBIGSIZE:
hsAssert(false, "DDERR_TOOBIGSIZE.");
break;
// Width requested by DirectDraw is too large.
case DDERR_TOOBIGWIDTH:
hsAssert(false, "DDERR_TOOBIGWIDTH.");
break;
// Action not supported.
case DDERR_UNSUPPORTED:
hsAssert(false, "DDERR_UNSUPPORTED.");
break;
// FOURCC format requested is unsupported by DirectDraw
case DDERR_UNSUPPORTEDFORMAT:
hsAssert(false, "DDERR_UNSUPPORTEDFORMAT.");
break;
// Bitmask in the pixel format requested is unsupported by DirectDraw
case DDERR_UNSUPPORTEDMASK:
hsAssert(false, "DDERR_UNSUPPORTEDMASK.");
break;
// The specified stream contains invalid data
case DDERR_INVALIDSTREAM:
hsAssert(false, "DDERR_INVALIDSTREAM.");
break;
// vertical blank is in progress
case DDERR_VERTICALBLANKINPROGRESS:
hsAssert(false, "DDERR_VERTICALBLANKINPROGRESS.");
break;
// Informs DirectDraw that the previous Blt which is transfering information
// to or from this Surface is incomplete.
case DDERR_WASSTILLDRAWING:
hsAssert(false, "DDERR_WASSTILLDRAWING.");
break;
// Rectangle provided was not horizontally aligned on reqd. boundary
case DDERR_XALIGN:
hsAssert(false, "DDERR_XALIGN.");
break;
// The GUID passed to DirectDrawCreate is not a valid DirectDraw driver
// identifier.
case DDERR_INVALIDDIRECTDRAWGUID:
hsAssert(false, "DDERR_INVALIDDIRECTDRAWGUID.");
break;
// A DirectDraw object representing this driver has already been created
// for this process.
case DDERR_DIRECTDRAWALREADYCREATED:
hsAssert(false, "DDERR_DIRECTDRAWALREADYCREATED.");
break;
// A hardware only DirectDraw object creation was attempted but the driver
// did not support any hardware.
case DDERR_NODIRECTDRAWHW:
hsAssert(false, "DDERR_NODIRECTDRAWHW.");
break;
// this process already has created a primary surface
case DDERR_PRIMARYSURFACEALREADYEXISTS:
hsAssert(false, "DDERR_PRIMARYSURFACEALREADYEXISTS.");
break;
// software emulation not available.
case DDERR_NOEMULATION:
hsAssert(false, "DDERR_NOEMULATION.");
break;
// region passed to Clipper::GetClipList is too small.
case DDERR_REGIONTOOSMALL:
hsAssert(false, "DDERR_REGIONTOOSMALL.");
break;
// an attempt was made to set a clip list for a clipper objec that
// is already monitoring an hwnd.
case DDERR_CLIPPERISUSINGHWND:
hsAssert(false, "DDERR_CLIPPERISUSINGHWND.");
break;
// No clipper object attached to surface object
case DDERR_NOCLIPPERATTACHED:
hsAssert(false, "DDERR_NOCLIPPERATTACHED.");
break;
// Clipper notification requires an HWND or
// no HWND has previously been set as the CooperativeLevel HWND.
case DDERR_NOHWND:
hsAssert(false, "DDERR_NOHWND.");
break;
// HWND used by DirectDraw CooperativeLevel has been subclassed,
// this prevents DirectDraw from restoring state.
case DDERR_HWNDSUBCLASSED:
hsAssert(false, "DDERR_HWNDSUBCLASSED.");
break;
// The CooperativeLevel HWND has already been set.
// It can not be reset while the process has surfaces or palettes created.
case DDERR_HWNDALREADYSET:
hsAssert(false, "DDERR_HWNDALREADYSET.");
break;
// No palette object attached to this surface.
case DDERR_NOPALETTEATTACHED:
hsAssert(false, "DDERR_NOPALETTEATTACHED.");
break;
// No hardware support for 16 or 256 color palettes.
case DDERR_NOPALETTEHW:
hsAssert(false, "DDERR_NOPALETTEHW.");
break;
// If a clipper object is attached to the source surface passed into a
// BltFast call.
case DDERR_BLTFASTCANTCLIP:
hsAssert(false, "DDERR_BLTFASTCANTCLIP.");
break;
// No blter.
case DDERR_NOBLTHW:
hsAssert(false, "DDERR_NOBLTHW.");
break;
// No DirectDraw ROP hardware.
case DDERR_NODDROPSHW:
hsAssert(false, "DDERR_NODDROPSHW.");
break;
// returned when GetOverlayPosition is called on a hidden overlay
case DDERR_OVERLAYNOTVISIBLE:
hsAssert(false, "DDERR_OVERLAYNOTVISIBLE.");
break;
// returned when GetOverlayPosition is called on a overlay that UpdateOverlay
// has never been called on to establish a destionation.
case DDERR_NOOVERLAYDEST:
hsAssert(false, "DDERR_NOOVERLAYDEST.");
break;
// returned when the position of the overlay on the destionation is no longer
// legal for that destionation.
case DDERR_INVALIDPOSITION:
hsAssert(false, "DDERR_INVALIDPOSITION.");
break;
// returned when an overlay member is called for a non-overlay surface
case DDERR_NOTAOVERLAYSURFACE:
hsAssert(false, "DDERR_NOTAOVERLAYSURFACE.");
break;
// An attempt was made to set the cooperative level when it was already
// set to exclusive.
case DDERR_EXCLUSIVEMODEALREADYSET:
hsAssert(false, "DDERR_EXCLUSIVEMODEALREADYSET.");
break;
// An attempt has been made to flip a surface that is not flippable.
case DDERR_NOTFLIPPABLE:
hsAssert(false, "DDERR_NOTFLIPPABLE.");
break;
// Can't duplicate primary & 3D surfaces, or surfaces that are implicitly
// created.
case DDERR_CANTDUPLICATE:
hsAssert(false, "DDERR_CANTDUPLICATE.");
break;
// Surface was not locked. An attempt to unlock a surface that was not
// locked at all, or by this process, has been attempted.
case DDERR_NOTLOCKED:
hsAssert(false, "DDERR_NOTLOCKED.");
break;
// Windows can not create any more DCs, or a DC was requested for a paltte-indexed
// surface when the surface had no palette AND the display mode was not palette-indexed
// (in this case DirectDraw cannot select a proper palette into the DC)
case DDERR_CANTCREATEDC:
hsAssert(false, "DDERR_CANTCREATEDC.");
break;
// No DC was ever created for this surface.
case DDERR_NODC:
hsAssert(false, "DDERR_NODC.");
break;
// This surface can not be restored because it was created in a different
// mode.
case DDERR_WRONGMODE:
hsAssert(false, "DDERR_WRONGMODE.");
break;
// This surface can not be restored because it is an implicitly created
// surface.
case DDERR_IMPLICITLYCREATED:
hsAssert(false, "DDERR_IMPLICITLYCREATED.");
break;
// The surface being used is not a palette-based surface
case DDERR_NOTPALETTIZED:
hsAssert(false, "DDERR_NOTPALETTIZED.");
break;
// The display is currently in an unsupported mode
case DDERR_UNSUPPORTEDMODE:
hsAssert(false, "DDERR_UNSUPPORTEDMODE.");
break;
// Operation could not be carried out because there is no mip-map
// texture mapping hardware present or available.
case DDERR_NOMIPMAPHW:
hsAssert(false, "DDERR_NOMIPMAPHW.");
break;
// The requested action could not be performed because the surface was of
// the wrong type.
case DDERR_INVALIDSURFACETYPE:
hsAssert(false, "DDERR_INVALIDSURFACETYPE.");
break;
// Device does not support optimized surfaces, therefore no video memory optimized surfaces
case DDERR_NOOPTIMIZEHW:
hsAssert(false, "DDERR_NOOPTIMIZEHW.");
break;
// Surface is an optimized surface, but has not yet been allocated any memory
case DDERR_NOTLOADED:
hsAssert(false, "DDERR_NOTLOADED.");
break;
// Attempt was made to create or set a device window without first setting
// the focus window
case DDERR_NOFOCUSWINDOW:
hsAssert(false, "DDERR_NOFOCUSWINDOW.");
break;
// A DC has already been returned for this surface. Only one DC can be
// retrieved per surface.
case DDERR_DCALREADYCREATED:
hsAssert(false, "DDERR_DCALREADYCREATED.");
break;
// An attempt was made to allocate non-local video memory from a device
// that does not support non-local video memory.
case DDERR_NONONLOCALVIDMEM:
hsAssert(false, "DDERR_NONONLOCALVIDMEM.");
break;
// The attempt to page lock a surface failed.
case DDERR_CANTPAGELOCK:
hsAssert(false, "DDERR_CANTPAGELOCK.");
break;
// The attempt to page unlock a surface failed.
case DDERR_CANTPAGEUNLOCK:
hsAssert(false, "DDERR_CANTPAGEUNLOCK.");
break;
// An attempt was made to page unlock a surface with no outstanding page locks.
case DDERR_NOTPAGELOCKED:
hsAssert(false, "DDERR_NOTPAGELOCKED.");
break;
// There is more data available than the specified buffer size could hold
case DDERR_MOREDATA:
hsAssert(false, "DDERR_MOREDATA.");
break;
// The data has expired and is therefore no longer valid.
case DDERR_EXPIRED:
hsAssert(false, "DDERR_EXPIRED.");
break;
// The video port is not active
case DDERR_VIDEONOTACTIVE:
hsAssert(false, "DDERR_VIDEONOTACTIVE.");
break;
// Surfaces created by one direct draw device cannot be used directly by
// another direct draw device.
case DDERR_DEVICEDOESNTOWNSURFACE:
hsAssert(false, "DDERR_DEVICEDOESNTOWNSURFACE.");
break;
// An attempt was made to invoke an interface member of a DirectDraw object
// created by CoCreateInstance() before it was initialized.
case DDERR_NOTINITIALIZED:
hsAssert(false, "DDERR_NOTINITIALIZED.");
break;
default:
hsAssert(false, "Unknown error.");
break;
}
}
hsBool hsDXTDirectXCodec::ColorizeCompMipmap( plMipmap *bMap, const UInt8 *colorMask )
{
return false;
}