Initial publish

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
+