summaryrefslogtreecommitdiff
path: root/video/pixlib/pixel.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'video/pixlib/pixel.cpp')
-rw-r--r--video/pixlib/pixel.cpp695
1 files changed, 695 insertions, 0 deletions
diff --git a/video/pixlib/pixel.cpp b/video/pixlib/pixel.cpp
new file mode 100644
index 00000000..a1599e63
--- /dev/null
+++ b/video/pixlib/pixel.cpp
@@ -0,0 +1,695 @@
+/*==========================================================================;
+ *
+ * Copyright (C) 1999-2002 Microsoft Corporation. All Rights Reserved.
+ *
+ * File: pixel.cpp
+ * Content: Utility class for working with pixel formats
+ *
+ *
+ ***************************************************************************/
+
+#include "strsafe.h"
+#include "pixel.hpp"
+
+#ifndef DXPIXELVER
+#define DXPIXELVER 100
+#endif
+
+IHVFormatInfo *CPixel::m_pFormatList = 0;
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::Cleanup"
+void CPixel::Cleanup()
+{
+ while(m_pFormatList != 0)
+ {
+ IHVFormatInfo *t = m_pFormatList->m_pNext;
+ delete m_pFormatList;
+ m_pFormatList = t;
+ }
+}
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::BytesPerPixel"
+
+UINT CPixel::BytesPerPixel(D3DFORMAT Format)
+{
+ switch (DWORD(Format))
+ {
+ case D3DFMT_DXT1:
+ // Size is negative to indicate DXT; and indicates
+ // the size of the block
+ return (UINT)(-8);
+ case D3DFMT_DXT2:
+ case D3DFMT_DXT3:
+ case D3DFMT_DXT4:
+ case D3DFMT_DXT5:
+ // Size is negative to indicate DXT; and indicates
+ // the size of the block
+ return (UINT)(-16);
+
+
+#if (DXPIXELVER > 8)
+ case D3DFMT_A32B32G32R32F:
+ return 16;
+
+ case D3DFMT_A16B16G16R16:
+ case D3DFMT_Q16W16V16U16:
+ case D3DFMT_A16B16G16R16F:
+ case D3DFMT_G32R32F:
+ case D3DFMT_MULTI2_ARGB8:
+ return 8;
+#endif
+
+ case D3DFMT_A8R8G8B8:
+ case D3DFMT_X8R8G8B8:
+ case D3DFMT_D32:
+ case D3DFMT_D24S8:
+ case D3DFMT_S8D24:
+ case D3DFMT_X8L8V8U8:
+ case D3DFMT_X4S4D24:
+ case D3DFMT_D24X4S4:
+ case D3DFMT_Q8W8V8U8:
+ case D3DFMT_V16U16:
+ case D3DFMT_A2W10V10U10:
+ case D3DFMT_A2B10G10R10:
+ case D3DFMT_A8B8G8R8:
+ case D3DFMT_X8B8G8R8:
+ case D3DFMT_G16R16:
+ case D3DFMT_D24X8:
+ case D3DFMT_X8D24:
+ case D3DFMT_W11V11U10:
+#if (DXPIXELVER > 8)
+ case D3DFMT_A2R10G10B10:
+ case D3DFMT_G16R16F:
+ case D3DFMT_R32F:
+ case D3DFMT_D32F_LOCKABLE:
+ case D3DFMT_D24FS8:
+ case D3DFMT_D32_LOCKABLE:
+#endif
+ return 4;
+
+ case D3DFMT_R8G8B8:
+ return 3;
+
+ case D3DFMT_R5G6B5:
+ case D3DFMT_X1R5G5B5:
+ case D3DFMT_A1R5G5B5:
+ case D3DFMT_A4R4G4B4:
+ case D3DFMT_A8L8:
+ case D3DFMT_V8U8:
+ case D3DFMT_L6V5U5:
+ case D3DFMT_D16:
+ case D3DFMT_D16_LOCKABLE:
+ case D3DFMT_D15S1:
+ case D3DFMT_S1D15:
+ case D3DFMT_A8P8:
+ case D3DFMT_A8R3G3B2:
+ case D3DFMT_UYVY:
+ case D3DFMT_YUY2:
+ case D3DFMT_X4R4G4B4:
+#if (DXPIXELVER > 8)
+ case D3DFMT_CxV8U8:
+ case D3DFMT_L16:
+ case D3DFMT_R16F:
+ case D3DFMT_R8G8_B8G8:
+ case D3DFMT_G8R8_G8B8:
+#endif
+ return 2;
+
+ case D3DFMT_P8:
+ case D3DFMT_L8:
+ case D3DFMT_R3G3B2:
+ case D3DFMT_A4L4:
+ case D3DFMT_A8:
+#if (DXPIXELVER > 8)
+ case D3DFMT_A1:
+ case D3DFMT_S8_LOCKABLE:
+#endif
+ return 1;
+
+ default:
+ return 0;
+ };
+}; // BytesPerPixel
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputePixelStride"
+
+UINT CPixel::ComputePixelStride(D3DFORMAT Format)
+{
+ UINT BPP = BytesPerPixel(Format);
+ if (BPP == 0)
+ {
+ for(IHVFormatInfo *p = m_pFormatList; p != 0; p = p->m_pNext)
+ {
+ if (p->m_Format == Format)
+ {
+ return p->m_BPP >> 3;
+ }
+ }
+ }
+ return BPP;
+}; // ComputePixelStride
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeSurfaceStride"
+
+// Figure out a stride for a particular surface based on format and width
+inline UINT CPixel::ComputeSurfaceStride(UINT cpWidth, UINT cbPixel)
+{
+ UINT uStride = 0;
+ ComputeSurfaceStrideChecked(cpWidth, cbPixel, &uStride);
+ return uStride;
+}; // ComputeSurfaceStride
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeSurfaceStrideChecked"
+
+// Figure out a stride for a particular surface based on format and width
+inline BOOL CPixel::ComputeSurfaceStrideChecked(UINT cpWidth, UINT cbPixel, UINT *pStride)
+{
+ // Figure out basic (linear) stride;
+ UINT64 u64Stride = (UINT64)cpWidth * (UINT64)cbPixel;
+
+ // Round up to multiple of 4 (for NT; but makes sense to maximize
+ // cache hits and reduce unaligned accesses)
+ //
+ // NOTE: Also necessary for UYVY and YUY2 formats that this round
+ // up by at least a multiple of 4.
+ u64Stride = (u64Stride + 3) & ~3; //safe since cbPixel cannot be 4G
+
+ if (u64Stride <= MAXALLOCSIZE)
+ {
+ *pStride = (UINT)u64Stride;
+ return TRUE;
+ }
+ return FALSE;
+}; // ComputeSurfaceStride
+
+
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeSurfaceSize"
+
+UINT CPixel::ComputeSurfaceSize(UINT cpWidth,
+ UINT cpHeight,
+ UINT cbPixel)
+{
+ UINT uSize;
+ ComputeSurfaceSizeChecked(cpWidth, cpHeight, cbPixel, &uSize);
+ return uSize;
+} // ComputeSurfaceSize
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeSurfaceSizeChecked"
+
+BOOL CPixel::ComputeSurfaceSizeChecked(UINT cpWidth,
+ UINT cpHeight,
+ UINT cbPixel,
+ UINT *pSize)
+
+{
+ UINT uStride;
+ UINT64 uSize64;
+ if (ComputeSurfaceStrideChecked(cpWidth, cbPixel, &uStride))
+ {
+ uSize64 = (UINT64)cpHeight * (UINT64)uStride;
+ if (uSize64 <= MAXALLOCSIZE)
+ {
+ *pSize = (UINT)uSize64;
+ return TRUE;
+ }
+ }
+
+ *pSize = 0U;
+ return FALSE;
+} // ComputeSurfaceSize
+
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeMipMapSize"
+
+UINT CPixel::ComputeMipMapSize(UINT cpWidth,
+ UINT cpHeight,
+ UINT cLevels,
+ D3DFORMAT Format)
+{
+ UINT uSize = 0; // initialize to zero to keep prefix happy win7: 185027
+ ComputeMipMapSizeChecked(cpWidth, cpHeight, cLevels, Format, &uSize);
+ return uSize;
+} // ComputeMipMapSize
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeMipMapSizeChecked"
+
+BOOL CPixel::ComputeMipMapSizeChecked(UINT cpWidth,
+ UINT cpHeight,
+ UINT cLevels,
+ D3DFORMAT Format,
+ UINT *pSize)
+{
+ UINT cbPixel = ComputePixelStride(Format);
+
+ // Adjust pixel->block if necessary
+ BOOL isDXT = IsDXT(cbPixel);
+ if (isDXT)
+ cbPixel *= (UINT)-1;
+
+ UINT64 cbSize = 0;
+ if (cpWidth > MAXALLOCSIZE-3 || cpHeight > MAXALLOCSIZE-3)
+ return FALSE;
+
+ for (UINT i = 0; i < cLevels; i++)
+ {
+ UINT cbMipSize;
+ // Figure out the size for
+ // each level of the mip-map
+ if (isDXT)
+ {
+ if (!ComputeSurfaceSizeChecked((cpWidth+3)/4, (cpHeight+3)/4, cbPixel, &cbMipSize))
+ return FALSE;
+ }
+ else
+ {
+ if (!ComputeSurfaceSizeChecked(cpWidth, cpHeight, cbPixel, &cbMipSize))
+ return FALSE;
+ }
+ cbSize += cbMipSize;
+ // Shrink width and height by half; clamp to 1 pixel
+ if (cpWidth > 1)
+ cpWidth >>= 1;
+ if (cpHeight > 1)
+ cpHeight >>= 1;
+ }
+ if (cbSize <= MAXALLOCSIZE)
+ {
+ *pSize = (UINT)cbSize;
+ return TRUE;
+ }
+ return FALSE;
+
+} // ComputeMipMapSize
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeMipVolumeSize"
+
+UINT CPixel::ComputeMipVolumeSize(UINT cpWidth,
+ UINT cpHeight,
+ UINT cpDepth,
+ UINT cLevels,
+ D3DFORMAT Format)
+{
+ UINT uSize = 0; // To keep prefix happy win7: 185029
+ ComputeMipVolumeSizeChecked(cpWidth, cpHeight, cpDepth, cLevels, Format, &uSize);
+ return uSize;
+} // ComputeMipVolumeSize
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeMipVolumeSizeChecked"
+
+BOOL CPixel::ComputeMipVolumeSizeChecked(UINT cpWidth,
+ UINT cpHeight,
+ UINT cpDepth,
+ UINT cLevels,
+ D3DFORMAT Format,
+ UINT *pSize)
+{
+ UINT cbPixel = ComputePixelStride(Format);
+
+ // Adjust pixel->block if necessary
+ BOOL isDXT = IsDXT(cbPixel);
+
+ if (isDXT)
+ cbPixel *= (UINT)-1;
+
+ UINT64 cbSize = 0;
+
+ if (cpWidth > MAXALLOCSIZE-3 || cpHeight > MAXALLOCSIZE-3 || cpDepth > MAXALLOCSIZE-3)
+ return FALSE;
+
+ for (UINT i = 0; i < cLevels; i++)
+ {
+ // Figure out the size for
+ // each level of the mip-volume
+ UINT Depth = cpDepth;
+ UINT64 cbLevelSize;
+ UINT cbSliceSize;
+ if (isDXT)
+ {
+ if (!ComputeSurfaceSizeChecked((cpWidth+3)/4, (cpHeight+3)/4, cbPixel, &cbSliceSize))
+ return FALSE;
+ }
+ else
+ {
+ if (!ComputeSurfaceSizeChecked(cpWidth, cpHeight, cbPixel, &cbSliceSize))
+ return FALSE;
+ }
+ cbLevelSize = (UINT64)Depth * (UINT64)cbSliceSize;
+ if (cbLevelSize > MAXALLOCSIZE)
+ return FALSE;
+ cbSize += cbLevelSize;
+
+ // Shrink width and height by half; clamp to 1 pixel
+ if (cpWidth > 1)
+ cpWidth >>= 1;
+ if (cpHeight > 1)
+ cpHeight >>= 1;
+ if (cpDepth > 1)
+ cpDepth >>= 1;
+ }
+
+ if (cbSize <= MAXALLOCSIZE)
+ {
+ *pSize = (UINT)cbSize;
+ return TRUE;
+ }
+ return FALSE;
+
+} // ComputeMipVolumeSize
+
+// Given a surface desc, a level, and pointer to
+// bits (pBits in the LockedRectData) and a sub-rect,
+// this will fill in the pLockedRectData structure
+void CPixel::ComputeMipMapOffset(const D3DSURFACE_DESC *pDescTopLevel,
+ UINT iLevel,
+ BYTE *pBits,
+ CONST RECT *pRect,
+ D3DLOCKED_RECT *pLockedRectData)
+{
+ DXGASSERT(pBits != NULL);
+ DXGASSERT(pLockedRectData != NULL);
+ DXGASSERT(iLevel < 32);
+ DXGASSERT(pDescTopLevel != NULL);
+ DXGASSERT(0 != ComputePixelStride(pDescTopLevel->Format));
+ DXGASSERT(pDescTopLevel->Width > 0);
+ DXGASSERT(pDescTopLevel->Height > 0);
+
+ // CONSIDER: This is slow; and we can do a much better
+ // job for the non-compressed/wacky cases.
+ UINT cbOffset = 0;
+ UINT cbPixel = ComputePixelStride(pDescTopLevel->Format);
+ UINT cpWidth = pDescTopLevel->Width;
+ UINT cpHeight = pDescTopLevel->Height;
+
+ // Adjust pixel->block if necessary
+ BOOL isDXT = IsDXT(cbPixel);
+ if (isDXT)
+ cbPixel *= (UINT)-1;
+ BOOL OneBitPerPixelFormat = FALSE;
+#if (DXPIXELVER > 8)
+ OneBitPerPixelFormat = pDescTopLevel->Format == D3DFMT_A1;
+ if (OneBitPerPixelFormat)
+ {
+ cbPixel = 1;
+ }
+#endif
+ for (UINT i = 0; i < iLevel; i++)
+ {
+ if (isDXT)
+ cbOffset += ComputeSurfaceSize((cpWidth+3)/4, (cpHeight+3)/4, cbPixel);
+ else
+ if (OneBitPerPixelFormat)
+ cbOffset += ComputeSurfaceSize((cpWidth + 7) >> 3, cpHeight, cbPixel);
+ else
+ cbOffset += ComputeSurfaceSize(cpWidth, cpHeight, cbPixel);
+
+ // Shrink width and height by half; clamp to 1 pixel
+ if (cpWidth > 1)
+ cpWidth >>= 1;
+ if (cpHeight > 1)
+ cpHeight >>= 1;
+ }
+ if (isDXT)
+ cpWidth = (cpWidth+3)/4;
+ else
+ if (OneBitPerPixelFormat)
+ cpWidth = (cpWidth+7)/8;
+
+
+ // For DXTs, the pitch is the number of bytes
+ // for a single row of blocks; which is the same
+ // thing as the normal routine
+ pLockedRectData->Pitch = ComputeSurfaceStride(cpWidth,
+ cbPixel);
+ DXGASSERT(pLockedRectData->Pitch != 0);
+
+ // Don't adjust for Rect for DXT formats
+ if (pRect)
+ {
+ if (isDXT)
+ {
+ DXGASSERT((pRect->top & 3) == 0);
+ DXGASSERT((pRect->left & 3) == 0);
+ cbOffset += (pRect->top / 4) * pLockedRectData->Pitch +
+ (pRect->left / 4) * cbPixel;
+ }
+ else
+ if (OneBitPerPixelFormat)
+ {
+ // Assume that left is always 8 pixels aligned
+ cbOffset += pRect->top * pLockedRectData->Pitch +
+ (pRect->left >> 3);
+ }
+ else
+ {
+ cbOffset += pRect->top * pLockedRectData->Pitch +
+ pRect->left * cbPixel;
+ }
+ }
+
+ pLockedRectData->pBits = pBits + cbOffset;
+
+} // ComputeMipMapOffset
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::ComputeMipVolumeOffset"
+
+// MipVolume version of ComputeMipMapOffset
+void CPixel::ComputeMipVolumeOffset(const D3DVOLUME_DESC *pDescTopLevel,
+ UINT iLevel,
+ BYTE *pBits,
+ CONST D3DBOX *pBox,
+ D3DLOCKED_BOX *pLockedBoxData)
+{
+ DXGASSERT(pBits != NULL);
+ DXGASSERT(pLockedBoxData != NULL);
+ DXGASSERT(iLevel < 32);
+ DXGASSERT(pDescTopLevel != NULL);
+ DXGASSERT(0 != ComputePixelStride(pDescTopLevel->Format));
+ DXGASSERT(pDescTopLevel->Width > 0);
+ DXGASSERT(pDescTopLevel->Height > 0);
+ DXGASSERT(pDescTopLevel->Depth > 0);
+
+ UINT cbOffset = 0;
+ UINT cbPixel = ComputePixelStride(pDescTopLevel->Format);
+ UINT cpWidth = pDescTopLevel->Width;
+ UINT cpHeight = pDescTopLevel->Height;
+ UINT cpDepth = pDescTopLevel->Depth;
+
+ // Adjust pixel->block if necessary
+ BOOL isDXT = IsDXT(cbPixel);
+
+ if (isDXT)
+ cbPixel *= (UINT)-1;
+
+ for (UINT i = 0; i < iLevel; i++)
+ {
+ UINT Depth = cpDepth;
+ if (isDXT)
+ cbOffset += Depth * ComputeSurfaceSize((cpWidth+3)/4, (cpHeight+3)/4, cbPixel);
+ else
+ cbOffset += Depth * ComputeSurfaceSize(cpWidth, cpHeight, cbPixel);
+
+ // Shrink width and height by half; clamp to 1 pixel
+ if (cpWidth > 1)
+ cpWidth >>= 1;
+ if (cpHeight > 1)
+ cpHeight >>= 1;
+ if (cpDepth > 1)
+ cpDepth >>= 1;
+ }
+
+ if (isDXT)
+ {
+ cpWidth = (cpWidth+3)/4;
+ cpHeight = (cpHeight+3)/4;
+ }
+
+ // For DXTs, the row pitch is the number of bytes
+ // for a single row of blocks; which is the same
+ // thing as the normal routine
+ pLockedBoxData->RowPitch = ComputeSurfaceStride(cpWidth,
+ cbPixel);
+ DXGASSERT(pLockedBoxData->RowPitch != 0);
+
+ // For DXVs the slice pitch is the number of bytes
+ // for a single plane of blocks; which is the same thing
+ // as the normal routine
+ pLockedBoxData->SlicePitch = ComputeSurfaceSize(cpWidth,
+ cpHeight,
+ cbPixel);
+ DXGASSERT(pLockedBoxData->SlicePitch != 0);
+
+ // Adjust for Box
+ if (pBox)
+ {
+ UINT iStride = pLockedBoxData->RowPitch;
+ UINT iSlice = pLockedBoxData->SlicePitch;
+ if (isDXT)
+ {
+ cbOffset += (pBox->Front) * iSlice;
+
+ DXGASSERT((pBox->Top & 3) == 0);
+ DXGASSERT((pBox->Left & 3) == 0);
+ cbOffset += (pBox->Top / 4) * iStride +
+ (pBox->Left / 4) * cbPixel;
+ }
+ else
+ {
+ cbOffset += pBox->Front * iSlice +
+ pBox->Top * iStride +
+ pBox->Left * cbPixel;
+ }
+ }
+
+ pLockedBoxData->pBits = pBits + cbOffset;
+
+} // ComputeMipVolumeOffset
+
+
+#undef DPF_MODNAME
+#define DPF_MODNAME "CPixel::Register"
+
+HRESULT CPixel::Register(D3DFORMAT Format, DWORD BPP)
+{
+ DXGASSERT(BPP != 0);
+
+ // Do not register duplicates
+ IHVFormatInfo *p;
+ for(p = m_pFormatList; p != 0; p = p->m_pNext)
+ {
+ if (p->m_Format == Format)
+ {
+ return S_OK;
+ }
+ }
+
+ // Not found, add to registry.
+ // This allocation will be leaked, but since
+ // we don't expect to have a large number of
+ // IHV formats, the leak is not a big deal.
+ // Also, the leak will be immediately recovered
+ // upon process exit.
+ IHVFormatInfo *p2 = new IHVFormatInfo;
+ if (p2 == 0)
+ {
+ return E_OUTOFMEMORY;
+ }
+ p2->m_Format = Format;
+ p2->m_BPP = BPP;
+ p2->m_pNext = m_pFormatList;
+ m_pFormatList = p2;
+
+ return S_OK;
+}
+
+
+extern "C" UINT CPixel__ComputeSurfaceSize(UINT cpWidth,
+ UINT cpHeight,
+ D3DFORMAT Format)
+{
+ return CPixel::ComputeSurfaceSize(cpWidth, cpHeight, Format);
+}
+
+extern "C" UINT CPixel__ComputeVolumeSize(UINT cpWidth,
+ UINT cpHeight,
+ UINT cpDepth,
+ D3DFORMAT Format)
+{
+ return CPixel::ComputeVolumeSize(cpWidth, cpHeight, cpDepth, Format);
+}
+
+extern "C" UINT CPixel__ComputeMipMapSize(UINT cpWidth,
+ UINT cpHeight,
+ UINT cLevels,
+ D3DFORMAT Format)
+{
+ return CPixel::ComputeMipMapSize(cpWidth, cpHeight, cLevels, Format);
+}
+
+extern "C" UINT CPixel__ComputeMipVolumeSize(UINT cpWidth,
+ UINT cpHeight,
+ UINT cpDepth,
+ UINT cLevels,
+ D3DFORMAT Format)
+{
+ return CPixel::ComputeMipVolumeSize(cpWidth, cpHeight, cpDepth, cLevels, Format);
+}
+
+extern "C" void CPixel__ComputeMipMapOffset(const D3DSURFACE_DESC *pDescTopLevel,
+ UINT iLevel,
+ BYTE *pBits,
+ CONST RECT *pRect,
+ D3DLOCKED_RECT *pLockedRectData)
+{
+ CPixel::ComputeMipMapOffset(pDescTopLevel, iLevel, pBits, pRect, pLockedRectData);
+}
+
+extern "C" void CPixel__ComputeMipVolumeOffset(const D3DVOLUME_DESC *pDescTopLevel,
+ UINT iLevel,
+ BYTE *pBits,
+ CONST D3DBOX *pBox,
+ D3DLOCKED_BOX *pLockedBoxData)
+{
+ CPixel::ComputeMipVolumeOffset(pDescTopLevel, iLevel, pBits, pBox, pLockedBoxData);
+}
+
+extern "C" void CPixel__ComputeSurfaceOffset(const D3DSURFACE_DESC *pDesc,
+ BYTE *pBits,
+ CONST RECT *pRect,
+ D3DLOCKED_RECT *pLockedRectData)
+{
+ CPixel::ComputeSurfaceOffset(pDesc, pBits, pRect, pLockedRectData);
+}
+
+extern "C" UINT CPixel__ComputePixelStride(D3DFORMAT Format)
+{
+ return CPixel::ComputePixelStride(Format);
+}
+
+extern "C" void CPixel__AdjustForDXT(UINT *pcpWidth,
+ UINT *pcpHeight,
+ UINT *pcbPixel)
+{
+ CPixel::AdjustForDXT(pcpWidth, pcpHeight, pcbPixel);
+}
+
+extern "C" BOOL CPixel__IsDXT(D3DFORMAT Format)
+{
+ return CPixel::IsDXT(Format);
+}
+
+extern "C" UINT CPixel__BytesPerPixel(D3DFORMAT Format)
+{
+ return CPixel::BytesPerPixel(Format);
+}
+
+extern "C" HRESULT CPixel__Register(D3DFORMAT Format, DWORD BPP)
+{
+ return CPixel::Register(Format, BPP);
+}
+
+extern "C" void CPixel__Cleanup()
+{
+ CPixel::Cleanup();
+}
+
+extern "C" UINT CPixel__ComputeSurfaceStride(UINT cpWidth, UINT cbPixel)
+{
+ return CPixel::ComputeSurfaceStride(cpWidth, cbPixel);
+}
+
+
+// End of file : pixel.cpp
+
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-16 23:28:16 +0000