hyzboy/TexConv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
TexConv/CMP_CompressonatorLib/Buffer/Codecbuffer.cpp
hyzboy 8df1199ba4 add AMD CompressionLib
2020-07-31 11:31:32 +08:00

2892 lines
75 KiB
C++
Raw Blame History

//===============================================================================
// Copyright (c) 2007-2016 Advanced Micro Devices, Inc. All rights reserved.
// Copyright (c) 2004-2006 ATI Technologies Inc.
//===============================================================================
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
//
// File Name: CodecBuffer.cpp
// Description: implementation of the CCodecBuffer class
//
//////////////////////////////////////////////////////////////////////////////
#include "Common.h"
#include "CodecBuffer.h"
#include "CodecBuffer_RGBA8888.h"
#include "CodecBuffer_RGB888.h"
#include "CodecBuffer_RG8.h"
#include "CodecBuffer_R8.h"
#include "CodecBuffer_RGBA2101010.h"
#include "CodecBuffer_RGBA16.h"
#include "CodecBuffer_RG16.h"
#include "CodecBuffer_R16.h"
#include "CodecBuffer_RGBA32.h"
#include "CodecBuffer_RG32.h"
#include "CodecBuffer_R32.h"
#include "CodecBuffer_RGBA16F.h"
#include "CodecBuffer_RG16F.h"
#include "CodecBuffer_R16F.h"
#include "CodecBuffer_RGBA32F.h"
#include "CodecBuffer_RG32F.h"
#include "CodecBuffer_R32F.h"
#include "CodecBuffer_Block.h"
#include "CodecBuffer_RGB9995EF.h"
CCodecBuffer* CreateCodecBuffer(CodecBufferType nCodecBufferType,
CMP_BYTE nBlockWidth, CMP_BYTE nBlockHeight, CMP_BYTE nBlockDepth,
CMP_DWORD dwWidth, CMP_DWORD dwHeight, CMP_DWORD dwPitch, CMP_BYTE* pData,
CMP_DWORD dwDataSize)
{
#ifdef USE_DBGTRACE
DbgTrace(("nCodecBufferType %d dwWidth %d dwHeight %d dwPitch %d pData [%x]",nCodecBufferType,dwWidth, dwHeight, dwPitch, pData));
#endif
switch(nCodecBufferType)
{
case CBT_RGBA8888:
case CBT_BGRA8888:
case CBT_ARGB8888:
return new CCodecBuffer_RGBA8888(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RGB888:
return new CCodecBuffer_RGB888(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RG8:
return new CCodecBuffer_RG8(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_R8:
return new CCodecBuffer_R8(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RGBA2101010:
return new CCodecBuffer_RGBA2101010(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RGBA16:
return new CCodecBuffer_RGBA16(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RG16:
return new CCodecBuffer_RG16(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_R16:
return new CCodecBuffer_R16(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RGBA16F:
return new CCodecBuffer_RGBA16F(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RG16F:
return new CCodecBuffer_RG16F(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_R16F:
return new CCodecBuffer_R16F(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RGBA32:
return new CCodecBuffer_RGBA32(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RG32:
return new CCodecBuffer_RG32(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_R32:
return new CCodecBuffer_R32(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RGBA32F:
return new CCodecBuffer_RGBA32F(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RG32F:
return new CCodecBuffer_RG32F(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_R32F:
return new CCodecBuffer_R32F(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_RGBE32F:
return new CCodecBuffer_RGB9995EF(nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_4x4Block_2BPP:
case CBT_4x4Block_4BPP:
case CBT_4x4Block_8BPP:
case CBT_4x4Block_16BPP:
return new CCodecBuffer_Block(nCodecBufferType, nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_8x8Block_2BPP:
case CBT_8x8Block_4BPP:
case CBT_8x8Block_8BPP:
case CBT_8x8Block_16BPP:
return new CCodecBuffer_Block(nCodecBufferType, nBlockWidth, nBlockHeight, nBlockDepth, dwWidth, dwHeight, dwPitch, pData,dwDataSize);
case CBT_Unknown:
default:
assert(0);
return NULL;
}
}
CodecBufferType GetCodecBufferType(CMP_FORMAT format)
{
CodecBufferType CBT_type;
#ifdef USE_DBGTRACE
DbgTrace(("IN : CMP_FORMAT %d",format));
#endif
// ToDo Expand the CBT data types listed below so that CMP_FORMAT maps to a single CBT_ type
switch(format)
{
case CMP_FORMAT_ARGB_32F:
case CMP_FORMAT_ABGR_32F:
case CMP_FORMAT_RGBA_32F:
case CMP_FORMAT_BGRA_32F:
CBT_type = CBT_RGBA32F;
break;
case CMP_FORMAT_RG_32F:
CBT_type = CBT_RG32F;
break;
case CMP_FORMAT_R_32F:
CBT_type = CBT_R32F;
break;
case CMP_FORMAT_ARGB_16F:
case CMP_FORMAT_ABGR_16F:
case CMP_FORMAT_RGBA_16F:
case CMP_FORMAT_BGRA_16F:
CBT_type = CBT_RGBA16F;
break;
case CMP_FORMAT_RGBE_32F:
CBT_type = CBT_RGBE32F;
break;
case CMP_FORMAT_RG_16F:
CBT_type = CBT_RG16F;
break;
case CMP_FORMAT_R_16F:
CBT_type = CBT_R16F;
break;
case CMP_FORMAT_ARGB_16:
case CMP_FORMAT_ABGR_16:
case CMP_FORMAT_RGBA_16:
case CMP_FORMAT_BGRA_16:
CBT_type = CBT_RGBA16;
break;
case CMP_FORMAT_RG_16:
CBT_type = CBT_RG16;
break;
case CMP_FORMAT_R_16:
CBT_type = CBT_R16;
break;
#ifdef ARGB_32_SUPPORT
case TI_TC_FORMAT_ARGB_32:
CBT_type = CBT_RGBA32;
break;
case TI_TC_FORMAT_RG_32:
CBT_type = CBT_RG32;
break;
case TI_TC_FORMAT_R_32:
CBT_type = CBT_R32;
break;
#endif // ARGB_32_SUPPORT
case CMP_FORMAT_ARGB_2101010:
CBT_type = CBT_RGBA2101010;
break;
case CMP_FORMAT_ARGB_8888: // Need to expand on this format
case CMP_FORMAT_BGRA_8888: // Need to expand on this format
case CMP_FORMAT_RGBA_8888:
CBT_type = CBT_RGBA8888;
break;
case CMP_FORMAT_BGR_888: // Need to expand on this format
case CMP_FORMAT_RGB_888:
CBT_type = CBT_RGB888;
break;
case CMP_FORMAT_RG_8:
CBT_type = CBT_RG8;
break;
case CMP_FORMAT_R_8:
CBT_type = CBT_R8;
break;
default:
CBT_type = CBT_Unknown;
break;
}
#ifdef USE_DBGTRACE
DbgTrace(("OUT: %d",CBT_type));
#endif
return CBT_type;
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CCodecBuffer::CCodecBuffer(
CMP_BYTE nBlockWidth, CMP_BYTE nBlockHeight, CMP_BYTE nBlockDepth,
CMP_DWORD dwWidth, CMP_DWORD dwHeight, CMP_DWORD dwPitch, CMP_BYTE* pData,CMP_DWORD dwDataSize)
{
#ifdef USE_DBGTRACE
DbgTrace(("dwWidth %d,dwHeight %d,dwPitch %d pData [%x]",dwWidth,dwHeight,dwPitch,pData));
#endif
m_dwWidth = dwWidth;
m_dwHeight = dwHeight;
m_dwPitch = dwPitch;
m_nBlockWidth = nBlockWidth <4?4:nBlockWidth;
m_nBlockHeight= nBlockHeight<4?4:nBlockHeight;
m_nBlockDepth = nBlockDepth <1?1:nBlockDepth;
m_pData = pData;
m_bUserAllocedData = (pData != NULL);
m_DataSize = dwDataSize;
m_bPerformingConversion = false;
m_bSwizzle = false;
}
CCodecBuffer::~CCodecBuffer()
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
if(m_pData && !m_bUserAllocedData)
{
free(m_pData);
m_pData = NULL;
}
}
void CCodecBuffer::Copy(CCodecBuffer& srcBuffer)
{
#ifdef USE_DBGTRACE
DbgTrace(("srcBuffer [%x]",srcBuffer));
#endif
if(GetWidth() != srcBuffer.GetWidth() || GetHeight() != srcBuffer.GetHeight())
return;
const CMP_DWORD dwBlocksX = ((GetWidth() + 3) >> 2);
const CMP_DWORD dwBlocksY = ((GetHeight() + 3) >> 2);
for(CMP_DWORD j = 0; j < dwBlocksY; j++)
{
for(CMP_DWORD i = 0; i < dwBlocksX; i++)
{
float block[BLOCK_SIZE_4X4X4];
srcBuffer.ReadBlockRGBA(i*4, j*4, 4, 4, block);
WriteBlockRGBA(i*4, j*4, 4, 4, block);
}
}
}
#define MAX_BLOCK_WIDTH 8
#define MAX_BLOCK_HEIGHT 8
#define MAX_BLOCK MAX_BLOCK_WIDTH*MAX_BLOCK_HEIGHT
#define ATTEMPT_BLOCK_READ(b, c, t) \
{ \
t block[MAX_BLOCK]; \
if(ReadBlock##c(x, y, w, h, block)) \
{ \
ConvertBlock(b, block, w * h); \
m_bPerformingConversion = false; \
return true; \
} \
}
bool CCodecBuffer::ReadBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(cBlock, R, double);
ATTEMPT_BLOCK_READ(cBlock, R, float);
ATTEMPT_BLOCK_READ(cBlock, R, CMP_HALF);
ATTEMPT_BLOCK_READ(cBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_READ(cBlock, R, CMP_WORD);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(cBlock, G, double);
ATTEMPT_BLOCK_READ(cBlock, G, float);
ATTEMPT_BLOCK_READ(cBlock, G, CMP_HALF);
ATTEMPT_BLOCK_READ(cBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_READ(cBlock, G, CMP_WORD);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(cBlock, B, double);
ATTEMPT_BLOCK_READ(cBlock, B, float);
ATTEMPT_BLOCK_READ(cBlock, B, CMP_HALF);
ATTEMPT_BLOCK_READ(cBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_READ(cBlock, B, CMP_WORD);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(cBlock, A, double);
ATTEMPT_BLOCK_READ(cBlock, A, float);
ATTEMPT_BLOCK_READ(cBlock, A, CMP_HALF);
ATTEMPT_BLOCK_READ(cBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_READ(cBlock, A, CMP_WORD);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(wBlock, R, double);
ATTEMPT_BLOCK_READ(wBlock, R, float);
ATTEMPT_BLOCK_READ(wBlock, R, CMP_HALF);
ATTEMPT_BLOCK_READ(wBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_READ(wBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(wBlock, G, double);
ATTEMPT_BLOCK_READ(wBlock, G, float);
ATTEMPT_BLOCK_READ(wBlock, G, CMP_HALF);
ATTEMPT_BLOCK_READ(wBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_READ(wBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(wBlock, B, double);
ATTEMPT_BLOCK_READ(wBlock, B, float);
ATTEMPT_BLOCK_READ(wBlock, B, CMP_HALF);
ATTEMPT_BLOCK_READ(wBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_READ(wBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(wBlock, A, double);
ATTEMPT_BLOCK_READ(wBlock, A, float);
ATTEMPT_BLOCK_READ(wBlock, A, CMP_HALF);
ATTEMPT_BLOCK_READ(wBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_READ(wBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(dwBlock, R, double);
ATTEMPT_BLOCK_READ(dwBlock, R, float);
ATTEMPT_BLOCK_READ(dwBlock, R, CMP_HALF);
ATTEMPT_BLOCK_READ(dwBlock, R, CMP_WORD);
ATTEMPT_BLOCK_READ(dwBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(dwBlock, G, double);
ATTEMPT_BLOCK_READ(dwBlock, G, float);
ATTEMPT_BLOCK_READ(dwBlock, G, CMP_HALF);
ATTEMPT_BLOCK_READ(dwBlock, G, CMP_WORD);
ATTEMPT_BLOCK_READ(dwBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(dwBlock, B, double);
ATTEMPT_BLOCK_READ(dwBlock, B, float);
ATTEMPT_BLOCK_READ(dwBlock, B, CMP_HALF);
ATTEMPT_BLOCK_READ(dwBlock, B, CMP_WORD);
ATTEMPT_BLOCK_READ(dwBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(dwBlock, A, double);
ATTEMPT_BLOCK_READ(dwBlock, A, float);
ATTEMPT_BLOCK_READ(dwBlock, A, CMP_HALF);
ATTEMPT_BLOCK_READ(dwBlock, A, CMP_WORD);
ATTEMPT_BLOCK_READ(dwBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(hBlock, R, double);
ATTEMPT_BLOCK_READ(hBlock, R, float);
ATTEMPT_BLOCK_READ(hBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_READ(hBlock, R, CMP_WORD);
ATTEMPT_BLOCK_READ(hBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(hBlock, G, double);
ATTEMPT_BLOCK_READ(hBlock, G, float);
ATTEMPT_BLOCK_READ(hBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_READ(hBlock, G, CMP_WORD);
ATTEMPT_BLOCK_READ(hBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(hBlock, B, double);
ATTEMPT_BLOCK_READ(hBlock, B, float);
ATTEMPT_BLOCK_READ(hBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_READ(hBlock, B, CMP_WORD);
ATTEMPT_BLOCK_READ(hBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(hBlock, A, double);
ATTEMPT_BLOCK_READ(hBlock, A, float);
ATTEMPT_BLOCK_READ(hBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_READ(hBlock, A, CMP_WORD);
ATTEMPT_BLOCK_READ(hBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(fBlock, R, double);
ATTEMPT_BLOCK_READ(fBlock, R, CMP_HALF);
ATTEMPT_BLOCK_READ(fBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_READ(fBlock, R, CMP_WORD);
ATTEMPT_BLOCK_READ(fBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(fBlock, G, double);
ATTEMPT_BLOCK_READ(fBlock, G, CMP_HALF);
ATTEMPT_BLOCK_READ(fBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_READ(fBlock, G, CMP_WORD);
ATTEMPT_BLOCK_READ(fBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(fBlock, B, double);
ATTEMPT_BLOCK_READ(fBlock, B, CMP_HALF);
ATTEMPT_BLOCK_READ(fBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_READ(fBlock, B, CMP_WORD);
ATTEMPT_BLOCK_READ(fBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(fBlock, A, double);
ATTEMPT_BLOCK_READ(fBlock, A, CMP_HALF);
ATTEMPT_BLOCK_READ(fBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_READ(fBlock, A, CMP_WORD);
ATTEMPT_BLOCK_READ(fBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(dBlock, R, float);
ATTEMPT_BLOCK_READ(dBlock, R, CMP_HALF);
ATTEMPT_BLOCK_READ(dBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_READ(dBlock, R, CMP_WORD);
ATTEMPT_BLOCK_READ(dBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(dBlock, G, float);
ATTEMPT_BLOCK_READ(dBlock, G, CMP_HALF);
ATTEMPT_BLOCK_READ(dBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_READ(dBlock, G, CMP_WORD);
ATTEMPT_BLOCK_READ(dBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(dBlock, B, float);
ATTEMPT_BLOCK_READ(dBlock, B, CMP_HALF);
ATTEMPT_BLOCK_READ(dBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_READ(dBlock, B, CMP_WORD);
ATTEMPT_BLOCK_READ(dBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_READ(dBlock, A, float);
ATTEMPT_BLOCK_READ(dBlock, A, CMP_HALF);
ATTEMPT_BLOCK_READ(dBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_READ(dBlock, A, CMP_WORD);
ATTEMPT_BLOCK_READ(dBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
#define ATTEMPT_BLOCK_WRITE(b, c, t) \
{ \
t block[MAX_BLOCK]; \
ConvertBlock(block, b, w * h); \
if(WriteBlock##c(x, y, w, h, block)) \
{ \
m_bPerformingConversion = false; \
return true; \
} \
}
bool CCodecBuffer::WriteBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(cBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(cBlock, R, CMP_WORD);
ATTEMPT_BLOCK_WRITE(cBlock, R, double);
ATTEMPT_BLOCK_WRITE(cBlock, R, float);
ATTEMPT_BLOCK_WRITE(cBlock, R, CMP_HALF);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(cBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(cBlock, G, CMP_WORD);
ATTEMPT_BLOCK_WRITE(cBlock, G, double);
ATTEMPT_BLOCK_WRITE(cBlock, G, float);
ATTEMPT_BLOCK_WRITE(cBlock, G, CMP_HALF);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(cBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(cBlock, B, CMP_WORD);
ATTEMPT_BLOCK_WRITE(cBlock, B, double);
ATTEMPT_BLOCK_WRITE(cBlock, B, float);
ATTEMPT_BLOCK_WRITE(cBlock, B, CMP_HALF);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(cBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(cBlock, A, CMP_WORD);
ATTEMPT_BLOCK_WRITE(cBlock, A, double);
ATTEMPT_BLOCK_WRITE(cBlock, A, float);
ATTEMPT_BLOCK_WRITE(cBlock, A, CMP_HALF);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(wBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(wBlock, R, double);
ATTEMPT_BLOCK_WRITE(wBlock, R, float);
ATTEMPT_BLOCK_WRITE(wBlock, R, CMP_HALF);
ATTEMPT_BLOCK_WRITE(wBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(wBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(wBlock, G, double);
ATTEMPT_BLOCK_WRITE(wBlock, G, float);
ATTEMPT_BLOCK_WRITE(wBlock, G, CMP_HALF);
ATTEMPT_BLOCK_WRITE(wBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(wBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(wBlock, B, double);
ATTEMPT_BLOCK_WRITE(wBlock, B, float);
ATTEMPT_BLOCK_WRITE(wBlock, B, CMP_HALF);
ATTEMPT_BLOCK_WRITE(wBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(wBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(wBlock, A, double);
ATTEMPT_BLOCK_WRITE(wBlock, A, float);
ATTEMPT_BLOCK_WRITE(wBlock, A, CMP_HALF);
ATTEMPT_BLOCK_WRITE(wBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(dwBlock, R, double);
ATTEMPT_BLOCK_WRITE(dwBlock, R, float);
ATTEMPT_BLOCK_WRITE(dwBlock, R, CMP_HALF);
ATTEMPT_BLOCK_WRITE(dwBlock, R, CMP_WORD);
ATTEMPT_BLOCK_WRITE(dwBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(dwBlock, G, double);
ATTEMPT_BLOCK_WRITE(dwBlock, G, float);
ATTEMPT_BLOCK_WRITE(dwBlock, G, CMP_HALF);
ATTEMPT_BLOCK_WRITE(dwBlock, G, CMP_WORD);
ATTEMPT_BLOCK_WRITE(dwBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(dwBlock, B, double);
ATTEMPT_BLOCK_WRITE(dwBlock, B, float);
ATTEMPT_BLOCK_WRITE(dwBlock, B, CMP_HALF);
ATTEMPT_BLOCK_WRITE(dwBlock, B, CMP_WORD);
ATTEMPT_BLOCK_WRITE(dwBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(dwBlock, A, double);
ATTEMPT_BLOCK_WRITE(dwBlock, A, float);
ATTEMPT_BLOCK_WRITE(dwBlock, A, CMP_HALF);
ATTEMPT_BLOCK_WRITE(dwBlock, A, CMP_WORD);
ATTEMPT_BLOCK_WRITE(dwBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(hBlock, R, double);
ATTEMPT_BLOCK_WRITE(hBlock, R, float);
ATTEMPT_BLOCK_WRITE(hBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(hBlock, R, CMP_WORD);
ATTEMPT_BLOCK_WRITE(hBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(hBlock, G, double);
ATTEMPT_BLOCK_WRITE(hBlock, G, float);
ATTEMPT_BLOCK_WRITE(hBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(hBlock, G, CMP_WORD);
ATTEMPT_BLOCK_WRITE(hBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(hBlock, B, double);
ATTEMPT_BLOCK_WRITE(hBlock, B, float);
ATTEMPT_BLOCK_WRITE(hBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(hBlock, B, CMP_WORD);
ATTEMPT_BLOCK_WRITE(hBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(hBlock, A, double);
ATTEMPT_BLOCK_WRITE(hBlock, A, float);
ATTEMPT_BLOCK_WRITE(hBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(hBlock, A, CMP_WORD);
ATTEMPT_BLOCK_WRITE(hBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(fBlock, R, double);
ATTEMPT_BLOCK_WRITE(fBlock, R, CMP_HALF);
ATTEMPT_BLOCK_WRITE(fBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(fBlock, R, CMP_WORD);
ATTEMPT_BLOCK_WRITE(fBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(fBlock, G, double);
ATTEMPT_BLOCK_WRITE(fBlock, G, CMP_HALF);
ATTEMPT_BLOCK_WRITE(fBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(fBlock, G, CMP_WORD);
ATTEMPT_BLOCK_WRITE(fBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(fBlock, B, double);
ATTEMPT_BLOCK_WRITE(fBlock, B, CMP_HALF);
ATTEMPT_BLOCK_WRITE(fBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(fBlock, B, CMP_WORD);
ATTEMPT_BLOCK_WRITE(fBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(fBlock, A, double);
ATTEMPT_BLOCK_WRITE(fBlock, A, CMP_HALF);
ATTEMPT_BLOCK_WRITE(fBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(fBlock, A, CMP_WORD);
ATTEMPT_BLOCK_WRITE(fBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockR(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(dBlock, R, float);
ATTEMPT_BLOCK_WRITE(dBlock, R, CMP_HALF);
ATTEMPT_BLOCK_WRITE(dBlock, R, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(dBlock, R, CMP_WORD);
ATTEMPT_BLOCK_WRITE(dBlock, R, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockG(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(dBlock, G, float);
ATTEMPT_BLOCK_WRITE(dBlock, G, CMP_HALF);
ATTEMPT_BLOCK_WRITE(dBlock, G, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(dBlock, G, CMP_WORD);
ATTEMPT_BLOCK_WRITE(dBlock, G, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockB(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(dBlock, B, float);
ATTEMPT_BLOCK_WRITE(dBlock, B, CMP_HALF);
ATTEMPT_BLOCK_WRITE(dBlock, B, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(dBlock, B, CMP_WORD);
ATTEMPT_BLOCK_WRITE(dBlock, B, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
ATTEMPT_BLOCK_WRITE(dBlock, A, float);
ATTEMPT_BLOCK_WRITE(dBlock, A, CMP_HALF);
ATTEMPT_BLOCK_WRITE(dBlock, A, CMP_DWORD);
ATTEMPT_BLOCK_WRITE(dBlock, A, CMP_WORD);
ATTEMPT_BLOCK_WRITE(dBlock, A, CMP_BYTE);
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
CMP_DWORD dwBlock[MAX_BLOCK*4];
ConvertBlock(dwBlock, cBlock, w*h*4);
SwizzleBlock(dwBlock, w*h);
if(WriteBlockRGBA(x, y, w, h, dwBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK*4];
ConvertBlock(wBlock, cBlock, w*h*4);
SwizzleBlock(wBlock, w*h);
if(WriteBlockRGBA(x, y, w, h, wBlock))
{
m_bPerformingConversion = false;
return true;
}
double dBlock[MAX_BLOCK*4];
ConvertBlock(dBlock, cBlock, w*h*4);
SwizzleBlock(dBlock, w*h);
if(WriteBlockRGBA(x, y, w, h, dBlock))
{
m_bPerformingConversion = false;
return true;
}
float fBlock[MAX_BLOCK*4];
ConvertBlock(fBlock, cBlock, w*h*4);
SwizzleBlock(fBlock, w*h);
if(WriteBlockRGBA(x, y, w, h, fBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
ConvertBlock(hBlock, cBlock, w*h*4);
SwizzleBlock(hBlock, w*h);
if(WriteBlockRGBA(x, y, w, h, hBlock))
{
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_BYTE cBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, dBlock))
{
SwizzleBlock(dBlock, w*h);
ConvertBlock(cBlock, dBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
float fBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, fBlock))
{
SwizzleBlock(fBlock, w*h);
ConvertBlock(cBlock, fBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, hBlock))
{
SwizzleBlock(hBlock, w*h);
ConvertBlock(cBlock, hBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, dwBlock))
{
SwizzleBlock(dwBlock, w*h);
ConvertBlock(cBlock, dwBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, wBlock))
{
SwizzleBlock(wBlock, w*h);
ConvertBlock(cBlock, wBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
ConvertBlock(dBlock, dwBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, dBlock))
{
m_bPerformingConversion = false;
return true;
}
float fBlock[MAX_BLOCK*4];
ConvertBlock(fBlock, dwBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, fBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
ConvertBlock(hBlock, dwBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, hBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK];
SwizzleBlock(dwBlock, w*h);
ConvertBlock(wBlock, dwBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, wBlock))
{
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_DWORD dwBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, dBlock))
{
ConvertBlock(dwBlock, dBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
float fBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, fBlock))
{
ConvertBlock(dwBlock, fBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, hBlock))
{
ConvertBlock(dwBlock, hBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
unsigned char cBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, cBlock))
{
ConvertBlock(dwBlock, cBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK];
if(ReadBlockRGBA(x, y, w, h, dwBlock))
{
ConvertBlock(dwBlock, wBlock, w*h*4);
SwizzleBlock(dwBlock, w*h);
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
ConvertBlock(dBlock, wBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, dBlock))
{
m_bPerformingConversion = false;
return true;
}
float fBlock[MAX_BLOCK*4];
ConvertBlock(fBlock, wBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, fBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
ConvertBlock(hBlock, wBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, hBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK];
SwizzleBlock(wBlock, w*h);
ConvertBlock((CMP_BYTE*) dwBlock, wBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, dwBlock))
{
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_WORD wBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, dBlock))
{
ConvertBlock(wBlock, dBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
float fBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, fBlock))
{
ConvertBlock(wBlock, fBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, hBlock))
{
ConvertBlock(wBlock, hBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK];
if(ReadBlockRGBA(x, y, w, h, dwBlock))
{
ConvertBlock(wBlock, (CMP_BYTE*) dwBlock, w*h*4);
SwizzleBlock(wBlock, w*h);
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
ConvertBlock(dBlock, hBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, dBlock))
{
m_bPerformingConversion = false;
return true;
}
float fBlock[MAX_BLOCK*4];
ConvertBlock(fBlock, hBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, fBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK*4];
ConvertBlock(wBlock, hBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, wBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK];
SwizzleBlock(hBlock, w*h);
ConvertBlock((CMP_BYTE*) dwBlock, hBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, dwBlock))
{
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, CMP_HALF hBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, dBlock))
{
ConvertBlock(hBlock, dBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
float fBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, fBlock))
{
ConvertBlock(hBlock, fBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, wBlock))
{
ConvertBlock(hBlock, wBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK];
if(ReadBlockRGBA(x, y, w, h, dwBlock))
{
ConvertBlock(hBlock, (CMP_BYTE*) dwBlock, w*h*4);
SwizzleBlock(hBlock, w*h);
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
ConvertBlock(dBlock, fBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, dBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
ConvertBlock(hBlock, fBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, hBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK*4];
ConvertBlock(wBlock, fBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, wBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK];
SwizzleBlock(fBlock, w*h);
ConvertBlock((CMP_BYTE*) dwBlock, fBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, dwBlock))
{
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, float fBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
double dBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, dBlock))
{
ConvertBlock(fBlock, dBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, hBlock))
{
ConvertBlock(fBlock, hBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, wBlock))
{
ConvertBlock(fBlock, wBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK];
if(ReadBlockRGBA(x, y, w, h, dwBlock))
{
ConvertBlock(fBlock, (CMP_BYTE*) dwBlock, w*h*4);
SwizzleBlock(fBlock, w*h);
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
float fBlock[MAX_BLOCK*4];
ConvertBlock(fBlock, dBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, fBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
ConvertBlock(hBlock, dBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, hBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK*4];
ConvertBlock(wBlock, dBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, wBlock))
{
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK];
SwizzleBlock(dBlock, w*h);
ConvertBlock((CMP_BYTE*) dwBlock, dBlock, w*h*4);
if(WriteBlockRGBA(x, y, w, h, dwBlock))
{
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::ReadBlockRGBA(CMP_DWORD x, CMP_DWORD y, CMP_BYTE w, CMP_BYTE h, double dBlock[])
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
// Ok, so we don't support this format
// So we try other formats to find one that is supported
if(m_bPerformingConversion)
{
return false;
}
else
{
m_bPerformingConversion = true;
float fBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, fBlock))
{
ConvertBlock(dBlock, fBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_HALF hBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, hBlock))
{
ConvertBlock(dBlock, hBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_WORD wBlock[MAX_BLOCK*4];
if(ReadBlockRGBA(x, y, w, h, wBlock))
{
ConvertBlock(dBlock, wBlock, w*h*4);
m_bPerformingConversion = false;
return true;
}
CMP_DWORD dwBlock[MAX_BLOCK];
if(ReadBlockRGBA(x, y, w, h, dwBlock))
{
ConvertBlock(dBlock, (CMP_BYTE*) dwBlock, w*h*4);
SwizzleBlock(dBlock, w*h);
m_bPerformingConversion = false;
return true;
}
assert(0);
m_bPerformingConversion = false;
return false;
}
}
bool CCodecBuffer::WriteBlock(CMP_DWORD /*x*/, CMP_DWORD /*y*/, CMP_DWORD* /*pBlock*/, CMP_DWORD /*dwBlockSize*/)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(0);
return false;
}
bool CCodecBuffer::ReadBlock(CMP_DWORD /*x*/, CMP_DWORD /*y*/, CMP_DWORD* /*pBlock*/, CMP_DWORD /*dwBlockSize*/)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(0);
return false;
}
void CCodecBuffer::ConvertBlock(double dBlock[], float fBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dBlock);
assert(fBlock);
assert(dwBlockSize);
if(dBlock && fBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dBlock[i] = fBlock[i];
}
}
void CCodecBuffer::ConvertBlock(double dBlock[], CMP_HALF hBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dBlock);
assert(hBlock);
assert(dwBlockSize);
if(dBlock && hBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dBlock[i] = hBlock[i];
}
}
void CCodecBuffer::ConvertBlock(double dBlock[], CMP_DWORD dwBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dBlock);
assert(dwBlock);
assert(dwBlockSize);
if(dBlock && dwBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dBlock[i] = CONVERT_DWORD_TO_FLOAT(dwBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(double dBlock[], CMP_WORD wBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dBlock);
assert(wBlock);
assert(dwBlockSize);
if(dBlock && wBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dBlock[i] = CONVERT_WORD_TO_FLOAT(wBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(double dBlock[], CMP_BYTE cBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dBlock);
assert(cBlock);
assert(dwBlockSize);
if(dBlock && cBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dBlock[i] = CONVERT_BYTE_TO_FLOAT(cBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(float fBlock[], double dBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(fBlock);
assert(dBlock);
assert(dwBlockSize);
if(fBlock && dBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
fBlock[i] = (float) dBlock[i];
}
}
void CCodecBuffer::ConvertBlock(float fBlock[], CMP_HALF hBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(fBlock);
assert(hBlock);
assert(dwBlockSize);
if(fBlock && hBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
fBlock[i] = (float) hBlock[i];
}
}
void CCodecBuffer::ConvertBlock(float fBlock[], CMP_DWORD dwBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(fBlock);
assert(dwBlock);
assert(dwBlockSize);
if(fBlock && dwBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
fBlock[i] = CONVERT_DWORD_TO_FLOAT(dwBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(float fBlock[], CMP_WORD wBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(fBlock);
assert(wBlock);
assert(dwBlockSize);
if(fBlock && wBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
fBlock[i] = CONVERT_WORD_TO_FLOAT(wBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(float fBlock[], CMP_BYTE cBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(fBlock);
assert(cBlock);
assert(dwBlockSize);
if(fBlock && cBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
fBlock[i] = CONVERT_BYTE_TO_FLOAT(cBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_HALF hBlock[], double dBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(hBlock);
assert(dBlock);
assert(dwBlockSize);
if(hBlock && dBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
hBlock[i] = (float) dBlock[i];
}
}
void CCodecBuffer::ConvertBlock(CMP_HALF hBlock[], float fBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(hBlock);
assert(fBlock);
assert(dwBlockSize);
if(hBlock && fBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
hBlock[i] = (float) fBlock[i];
}
}
void CCodecBuffer::ConvertBlock(CMP_HALF hBlock[], CMP_DWORD dwBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(hBlock);
assert(dwBlock);
assert(dwBlockSize);
if(hBlock && dwBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
hBlock[i] = CONVERT_DWORD_TO_FLOAT(dwBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_HALF hBlock[], CMP_WORD wBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(hBlock);
assert(wBlock);
assert(dwBlockSize);
if(hBlock && wBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
hBlock[i] = CONVERT_WORD_TO_FLOAT(wBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_HALF hBlock[], CMP_BYTE cBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(hBlock);
assert(cBlock);
assert(dwBlockSize);
if(hBlock && cBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
hBlock[i] = CONVERT_BYTE_TO_FLOAT(cBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_DWORD dwBlock[], double dBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dwBlock);
assert(dBlock);
assert(dwBlockSize);
if(dwBlock && dBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dwBlock[i] = CONVERT_FLOAT_TO_DWORD(dBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_DWORD dwBlock[], float fBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dwBlock);
assert(fBlock);
assert(dwBlockSize);
if(dwBlock && fBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dwBlock[i] = CONVERT_FLOAT_TO_DWORD(fBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_DWORD dwBlock[], CMP_HALF hBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dwBlock);
assert(hBlock);
assert(dwBlockSize);
if(dwBlock && hBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dwBlock[i] = CONVERT_FLOAT_TO_DWORD(hBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_DWORD dwBlock[], CMP_WORD wBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dwBlock);
assert(wBlock);
assert(dwBlockSize);
if(dwBlock && wBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dwBlock[i] = CONVERT_WORD_TO_DWORD(wBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_DWORD dwBlock[], CMP_BYTE cBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dwBlock);
assert(cBlock);
assert(dwBlockSize);
if(dwBlock && cBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
dwBlock[i] = CONVERT_BYTE_TO_DWORD(cBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_WORD wBlock[], double dBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(wBlock);
assert(dBlock);
assert(dwBlockSize);
if(wBlock && dBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
wBlock[i] = CONVERT_FLOAT_TO_WORD(dBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_WORD wBlock[], float fBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(wBlock);
assert(fBlock);
assert(dwBlockSize);
if(wBlock && fBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
wBlock[i] = CONVERT_FLOAT_TO_WORD(fBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_WORD wBlock[], CMP_HALF hBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(wBlock);
assert(hBlock);
assert(dwBlockSize);
if(wBlock && hBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
wBlock[i] = CONVERT_FLOAT_TO_WORD(hBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_WORD wBlock[], CMP_DWORD dwBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(wBlock);
assert(dwBlock);
assert(dwBlockSize);
if(wBlock && dwBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
wBlock[i] = CONVERT_DWORD_TO_WORD(dwBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_WORD wBlock[], CMP_BYTE cBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(wBlock);
assert(cBlock);
assert(dwBlockSize);
if(wBlock && cBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
wBlock[i] = CONVERT_BYTE_TO_WORD(cBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_BYTE cBlock[], double dBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(cBlock);
assert(dBlock);
assert(dwBlockSize);
if(cBlock && dBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
cBlock[i] = CONVERT_FLOAT_TO_BYTE(dBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_BYTE cBlock[], float fBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(cBlock);
assert(fBlock);
assert(dwBlockSize);
if(cBlock && fBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
cBlock[i] = CONVERT_FLOAT_TO_BYTE(fBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_BYTE cBlock[], CMP_HALF hBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(cBlock);
assert(hBlock);
assert(dwBlockSize);
if(cBlock && hBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
cBlock[i] = CONVERT_FLOAT_TO_BYTE(hBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_BYTE cBlock[], CMP_DWORD dwBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(cBlock);
assert(dwBlock);
assert(dwBlockSize);
if(cBlock && dwBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
cBlock[i] = CONVERT_DWORD_TO_BYTE(dwBlock[i]);
}
}
void CCodecBuffer::ConvertBlock(CMP_BYTE cBlock[], CMP_WORD wBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(cBlock);
assert(wBlock);
assert(dwBlockSize);
if(cBlock && wBlock && dwBlockSize)
{
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
cBlock[i] = CONVERT_WORD_TO_BYTE(wBlock[i]);
}
}
void CCodecBuffer::SwizzleBlock(double dBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dBlock);
assert(dwBlockSize);
if(dBlock && dwBlockSize)
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
SWAP_DOUBLES(dBlock[(i* 4)], dBlock[(i* 4) + 2]);
}
void CCodecBuffer::SwizzleBlock(float fBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(fBlock);
assert(dwBlockSize);
if(fBlock && dwBlockSize)
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
SWAP_FLOATS(fBlock[(i* 4)], fBlock[(i* 4) + 2]);
}
void CCodecBuffer::SwizzleBlock(CMP_HALF hBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(hBlock);
assert(dwBlockSize);
if(hBlock && dwBlockSize)
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
SWAP_HALFS(hBlock[(i* 4)], hBlock[(i* 4) + 2]);
}
void CCodecBuffer::SwizzleBlock(CMP_DWORD dwBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(dwBlock);
assert(dwBlockSize);
if(dwBlock && dwBlockSize)
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
SWAP_DWORDS(dwBlock[(i* 4)], dwBlock[(i* 4) + 2]);
}
void CCodecBuffer::SwizzleBlock(CMP_WORD wBlock[], CMP_DWORD dwBlockSize)
{
#ifdef USE_DBGTRACE
DbgTrace(());
#endif
assert(wBlock);
assert(dwBlockSize);
if(wBlock && dwBlockSize)
for(CMP_DWORD i = 0; i < dwBlockSize; i++)
SWAP_WORDS(wBlock[(i* 4)], wBlock[(i* 4) + 2]);
}
Reference in New Issue View Git Blame Copy Permalink