//*@@@+++@@@@****************************************************************** // // Copyright © Microsoft Corp. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // // • Redistributions of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // • Redistributions in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE // POSSIBILITY OF SUCH DAMAGE. // //*@@@---@@@@****************************************************************** #include #include #include //================================================================ // PKFormatConverter //================================================================ #define HLF_MIN 0.00006103515625f #define HLF_MAX 65504.0f #define HLF_MIN_BITS 0x0400 #define HLF_MAX_BITS 0x7bff #define HLF_MIN_BITS_NEG (HLF_MIN_BITS | 0x8000) #define HLF_MAX_BITS_NEG (HLF_MAX_BITS | 0x8000) #define HLF_QNaN_BITZS 0x7fff // simple and slow implementation of half <-> float conversion static U32 Convert_Half_To_Float(U16 u16) { // 1s5e10m -> 1s8e23m const U32 s = (u16 >> 15) & 0x0001; const U32 e = (u16 >> 10) & 0x001f; const U32 m = (u16 >> 0) & 0x03ff; if (0 == e) // 0, denorm { return s << 31; } else if (~(~0 << 5) == e) // inf, snan, qnan { return (s << 31) | ~(~0 << 8) << 23| (m << 13); } return (s << 31) | ((e - 15 + 127) << 23) | (m << 13); // norm } static U16 Convert_Float_To_Half(float f) { // 1s5e10m -> 1s8e23m const U32 iFloat = *(U32*)&f; // Convert float to U32 if (f != f) { return (U16)(iFloat | HLF_QNaN_BITZS); // +QNaN, -QNaN } else if (f < -HLF_MAX) { return HLF_MAX_BITS_NEG; } else if (HLF_MAX < f) { return HLF_MAX_BITS; } else if (-HLF_MIN < f && f < HLF_MIN) { return (U16)((iFloat >> 16) & 0x8000); // +0, -0 } // Cut-and-paste from C++, introduce scope so we can decl more vars { const U32 s = (iFloat >> 31) & 0x00000001; const U32 e = (iFloat >> 23) & 0x000000ff; const U32 m = (iFloat >> 0) & 0x007fffff; return (U16) ((s << 15) | ((e - 127 + 15) << 10) | (m >> 13)); } } static U8 Convert_Float_To_U8(float f) { // convert from linear scRGB to non-linear sRGB if (f <= 0) { return 0; } else if (f <= 0.0031308f) { return (U8)((255.0f * f * 12.92f) + 0.5f); } else if (f < 1.0f) { return (U8)((255.0f * ((1.055f * (float)pow(f, 1.0 / 2.4)) - 0.055f)) + 0.5f); } else { return 255; } } static U8 Convert_AlphaFloat_To_U8(float f) { // alpha is converted differently than RGB in scRGB if (f <= 0) { return 0; } else if (f < 1.0f) { return (U8)((255.0f * f) + 0.5f); } else { return 255; } } ERR RGB24_BGR24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { I32 i = 0, j = 0; UNREFERENCED_PARAMETER( pFC ); for (i = 0; i < pRect->Height; ++i) { for (j = 0; j < pRect->Width * 3; j += 3) { // swap red with blue U8 t = pb[j]; pb[j] = pb[j + 2]; pb[j + 2] = t; } pb += cbStride; } return WMP_errSuccess; } ERR BGR24_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { return RGB24_BGR24(pFC, pRect, pb, cbStride); } ERR RGB24_BGR32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { I32 i = 0, j = 0; UNREFERENCED_PARAMETER( pFC ); for (i = 0; i < pRect->Height; ++i) { for (j = 0; j < pRect->Width; j++) { // swap red with blue U8 t = pb[3*j]; pb[4*j] = pb[3*j + 2]; pb[4*j + 1] = pb[3*j + 1]; pb[4*j + 2] = t; } pb += cbStride; } return WMP_errSuccess; } ERR BGR32_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { I32 i = 0, j = 0; UNREFERENCED_PARAMETER( pFC ); for (i = 0; i < pRect->Height; ++i) { for (j = 0; j < pRect->Width; j++) { // swap red with blue U8 t = pb[4*j]; pb[3*j] = pb[4*j + 2]; pb[3*j + 1] = pb[4*j + 1]; pb[3*j + 2] = t; } pb += cbStride; } return WMP_errSuccess; } ERR RGB24_Gray8(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { I32 i = 0, j = 0, k = 0; UNREFERENCED_PARAMETER( pFC ); for (i = 0; i < pRect->Height; ++i) { for (j = 0, k = 0; j < pRect->Width * 3; j += 3, ++k) { U8 r = pb[j]; U8 g = pb[j + 1]; U8 b = pb[j + 2]; pb[k] = r / 4 + g / 2 + b / 8 + 16; } pb += cbStride; } return WMP_errSuccess; } ERR BGR24_Gray8(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { ERR err = WMP_errSuccess; Call(BGR24_RGB24(pFC, pRect, pb, cbStride)); Call(RGB24_Gray8(pFC, pRect, pb, cbStride)); Cleanup: return err; } ERR Gray8_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { I32 i = 0, j = 0, k = 0; UNREFERENCED_PARAMETER( pFC ); for (i = 0; i < pRect->Height; ++i) { for (j = pRect->Width - 1, k = 3 * j; 0 <= j; j--, k -= 3) { U8 v = pb[j]; pb[k] = v; pb[k + 1] = v; pb[k + 2] = v; } pb += cbStride; } return WMP_errSuccess; } ERR Gray8_BGR24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { return Gray8_RGB24(pFC, pRect, pb, cbStride); } #if 0 ERR RGB48_BGR48(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { ERR err = WMP_errSuccess; I32 i = 0, j = 0; UNREFERENCED_PARAMETER( pFC ); Call(PKFormatConverter_Copy(pFC, pRect, pb, cbStride)); for (i = 0; i < pRect->Height; ++i) { for (j = 0; j < pRect->Width; j += 3) { U16* ps = (U16*)pb; // swap red with blue U16 t = ps[j]; ps[j] = ps[j + 2]; ps[j + 2] = t; } pb += cbStride; } Cleanup: return err; } ERR BGR48_RGB48(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { return RGB48_BGR48(pFC, pRect, pb, cbStride); } ERR RGB48_Gray16(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { ERR err = WMP_errSuccess; I32 i = 0, j = 0, k = 0; UNREFERENCED_PARAMETER( pFC ); Call(PKFormatConverter_Copy(pFC, pRect, pb, cbStride)); for (i = 0; i < pRect->Height; ++i) { for (j = 0, k = 0; j < pRect->Width; j += 3, ++k) { U16* ps = (U16*)pb; // Y = r / 4 + g / 2 + b / 8 + 16 U16 r = ps[j]; U16 g = ps[j + 1]; U16 b = ps[j + 2]; ps[k] = r / 4 + g / 2 + b / 8 + 16; } pb += cbStride; } Cleanup: return err; } #endif ERR RGBA128Fixed_RGBA128Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX4 = 4 * pRect->Width; // 4 == R, G, B, A const float fltCvtFactor = 1.0F / (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const I32 *piSrcPixel = (I32*)pfltDstPixel; for (x = 0; x < iWidthX4; x++) pfltDstPixel[x] = piSrcPixel[x] * fltCvtFactor; } return WMP_errSuccess; } ERR RGBA128Float_RGBA128Fixed(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX4 = 4 * pRect->Width; // 4 == R, G, B, A const float fltCvtFactor = (float)(1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; I32 *piDstPixel = (I32*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidthX4; x++) piDstPixel[x] = (I32) (pfltSrcPixel[x] * fltCvtFactor + 0.5F); } return WMP_errSuccess; } ERR RGB96Fixed_RGB96Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX3 = 3 * pRect->Width; // 3 == R, G, B const float fltCvtFactor = 1.0F / (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const I32 *piSrcPixel = (I32*)pfltDstPixel; for (x = 0; x < iWidthX3; x++) pfltDstPixel[x] = piSrcPixel[x] * fltCvtFactor; } return WMP_errSuccess; } ERR RGB128Fixed_RGB96Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const I32 *piSrcPixel = (I32*)pfltDstPixel; for (x = 0; x < iWidth; x++) { pfltDstPixel[3*x] = piSrcPixel[4*x] * fltCvtFactor; pfltDstPixel[3*x+1] = piSrcPixel[4*x+1] * fltCvtFactor; pfltDstPixel[3*x+2] = piSrcPixel[4*x+2] * fltCvtFactor; } } return WMP_errSuccess; } ERR RGB96Float_RGB96Fixed(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX3 = 3 * pRect->Width; // 3 == R, G, B const float fltCvtFactor = (float) (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; I32 *piDstPixel = (I32*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidthX3; x++) piDstPixel[x] = (I32)(pfltSrcPixel[x] * fltCvtFactor + 0.5F); } return WMP_errSuccess; } ERR RGB96Float_RGB128Fixed(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = (float) (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); assert(iWidth > 2); // Otherwise, we corrupt source data in inner loop for (y = iHeight - 1; y >= 0; y--) { I32 x; I32 *piDstPixel = (I32*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = iWidth - 1; x >= 0; x--) { piDstPixel[4*x] = (I32)(pfltSrcPixel[3*x] * fltCvtFactor + 0.5F); piDstPixel[4*x+1] = (I32)(pfltSrcPixel[3*x+1] * fltCvtFactor + 0.5F); piDstPixel[4*x+2] = (I32)(pfltSrcPixel[3*x+2] * fltCvtFactor + 0.5F); piDstPixel[4*x+3] = 0; // Zero out the alpha channel } } return WMP_errSuccess; } ERR RGB96Float_RGB128Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); assert(iWidth > 2); // Otherwise, we corrupt source data in inner loop for (y = iHeight - 1; y >= 0; y--) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)pfltDstPixel; for (x = iWidth - 1; x >= 0; x--) { pfltDstPixel[4*x] = pfltSrcPixel[3*x]; pfltDstPixel[4*x+1] = pfltSrcPixel[3*x+1]; pfltDstPixel[4*x+2] = pfltSrcPixel[3*x+2]; pfltDstPixel[4*x+3] = 0.0F; // Zero out the alpha channel } } return WMP_errSuccess; } ERR RGB128Float_RGB96Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)pfltDstPixel; for (x = 0; x < iWidth; x++) { pfltDstPixel[3*x] = pfltSrcPixel[4*x]; pfltDstPixel[3*x+1] = pfltSrcPixel[4*x+1]; pfltDstPixel[3*x+2] = pfltSrcPixel[4*x+2]; } } return WMP_errSuccess; } ERR RGB48Half_RGB64Half(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); assert(iWidth > 2); // Otherwise, we corrupt source data in inner loop for (y = iHeight - 1; y >= 0; y--) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)piDstPixel; for (x = iWidth - 1; x >= 0; x--) { piDstPixel[4*x] = piSrcPixel[3*x]; piDstPixel[4*x+1] = piSrcPixel[3*x+1]; piDstPixel[4*x+2] = piSrcPixel[3*x+2]; piDstPixel[4*x+3] = 0; // Zero out the alpha channel } } return WMP_errSuccess; } ERR RGB64Half_RGB48Half(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const short *piSrcPixel = (I16*)piDstPixel; for (x = 0; x < iWidth; x++) { piDstPixel[3*x] = piSrcPixel[4*x]; piDstPixel[3*x+1] = piSrcPixel[4*x+1]; piDstPixel[3*x+2] = piSrcPixel[4*x+2]; } } return WMP_errSuccess; } ERR BGR24_BGR32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); assert(iWidth > 2); // Otherwise, we corrupt source data in inner loop for (y = iHeight - 1; y >= 0; y--) { I32 x; U8 *piDstPixel = pb + cbStride*y; const U8 *piSrcPixel = piDstPixel; for (x = iWidth - 1; x >= 0; x--) { piDstPixel[4*x] = piSrcPixel[3*x]; piDstPixel[4*x+1] = piSrcPixel[3*x+1]; piDstPixel[4*x+2] = piSrcPixel[3*x+2]; piDstPixel[4*x+3] = 0; // Zero out the alpha channel } } return WMP_errSuccess; } ERR BGR32_BGR24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = pb + cbStride*y; const U8 *piSrcPixel = piDstPixel; for (x = 0; x < iWidth; x++) { piDstPixel[3*x] = piSrcPixel[4*x]; piDstPixel[3*x+1] = piSrcPixel[4*x+1]; piDstPixel[3*x+2] = piSrcPixel[4*x+2]; } } return WMP_errSuccess; } ERR Gray32Fixed_Gray32Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const I32 *piSrcPixel = (I32*)pfltDstPixel; for (x = 0; x < iWidth; x++) pfltDstPixel[x] = piSrcPixel[x] * fltCvtFactor; } return WMP_errSuccess; } ERR Gray32Float_Gray32Fixed(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = (float) (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; I32 *piDstPixel = (I32*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) piDstPixel[x] = (I32)(pfltSrcPixel[x] * fltCvtFactor + 0.5F); } return WMP_errSuccess; } ERR Gray16Fixed_Gray32Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = iWidth - 1; x >= 0; x--) pfltDstPixel[x] = piSrcPixel[x] * fltCvtFactor; } return WMP_errSuccess; } ERR Gray32Float_Gray16Fixed(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = (float) (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) piDstPixel[x] = (I16)(pfltSrcPixel[x] * fltCvtFactor + 0.5F); } return WMP_errSuccess; } ERR RGB48Fixed_RGB96Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX3 = 3 * pRect->Width; const float fltCvtFactor = 1.0F / (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = iWidthX3 - 1; x >= 0; x--) pfltDstPixel[x] = piSrcPixel[x] * fltCvtFactor; } return WMP_errSuccess; } ERR RGB96Float_RGB48Fixed(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX3 = 3 * pRect->Width; const float fltCvtFactor = (float)(1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidthX3; x++) piDstPixel[x] = (I16)(pfltSrcPixel[x] * fltCvtFactor + 0.5F); } return WMP_errSuccess; } ERR RGB64Fixed_RGB96Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = iWidth - 1; x >= 0; x--) { pfltDstPixel[3*x] = piSrcPixel[4*x] * fltCvtFactor; pfltDstPixel[3*x+1] = piSrcPixel[4*x+1] * fltCvtFactor; pfltDstPixel[3*x+2] = piSrcPixel[4*x+2] * fltCvtFactor; } } return WMP_errSuccess; } ERR RGB96Float_RGB64Fixed(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = (float)(1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) { piDstPixel[4*x] = (I16)(pfltSrcPixel[3*x] * fltCvtFactor + 0.5F); piDstPixel[4*x+1] = (I16)(pfltSrcPixel[3*x+1] * fltCvtFactor + 0.5F); piDstPixel[4*x+2] = (I16)(pfltSrcPixel[3*x+2] * fltCvtFactor + 0.5F); piDstPixel[4*x+3] = 0; // Zero out the alpha channel } } return WMP_errSuccess; } ERR RGBA64Fixed_RGBA128Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX4 = 4 * pRect->Width; const float fltCvtFactor = 1.0F / (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = iWidthX4 - 1; x >= 0; x--) pfltDstPixel[x] = piSrcPixel[x] * fltCvtFactor; } return WMP_errSuccess; } ERR RGBA128Float_RGBA64Fixed(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX4 = 4 * pRect->Width; const float fltCvtFactor = (float)(1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidthX4; x++) piDstPixel[x] = (I16)(pfltSrcPixel[x] * fltCvtFactor + 0.5F); } return WMP_errSuccess; } ERR RGBE_RGB96Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; float *pfltDstPixel = (float*)(pb + cbStride*y); const U8 *piSrcPixel = (U8*)pfltDstPixel; for (x = iWidth - 1; x >= 0; x--) { // First read the exponent const U8 rawExp = piSrcPixel[4*x+3]; if (0 == rawExp) { pfltDstPixel[3*x] = 0.0F; pfltDstPixel[3*x+1] = 0.0F; pfltDstPixel[3*x+2] = 0.0F; } else { const I32 adjExp = (I32)rawExp - 128 - 8; // Can be negative float fltExp; if (adjExp > -32 && adjExp < 32) { fltExp = (float) (((U32)1) << abs(adjExp)); if (adjExp < 0) fltExp = 1.0F / fltExp; } else { fltExp = (float)ldexp(1.0F, adjExp); } pfltDstPixel[3*x] = piSrcPixel[4*x] * fltExp; pfltDstPixel[3*x + 1] = piSrcPixel[4*x + 1] * fltExp; pfltDstPixel[3*x + 2] = piSrcPixel[4*x + 2] * fltExp; } } } return WMP_errSuccess; } ERR RGB96Float_RGBE(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); assert(iWidth > 2); // Otherwise, we corrupt source data in inner loop // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) { // We clamp source RGB values at zero (don't allow negative numbers) const float fltRed = max(pfltSrcPixel[3*x], 0.0F); const float fltGreen = max(pfltSrcPixel[3*x+1], 0.0F); const float fltBlue = max(pfltSrcPixel[3*x+2], 0.0F); float fltMaxPos = fltRed; if (fltGreen > fltMaxPos) fltMaxPos = fltGreen; if (fltBlue > fltMaxPos) fltMaxPos = fltBlue; if (fltMaxPos < 1e-32) { piDstPixel[4*x] = 0; // R piDstPixel[4*x+1] = 0; // G piDstPixel[4*x+2] = 0; // B piDstPixel[4*x+3] = 0; // E } else { int e; const float fltScale = (float)frexp(fltMaxPos, &e) * 256 / fltMaxPos; // rounding SHOULD NOT be added - it has the potential to roll over to zero (and yes, 256 is the correct multiplier above) piDstPixel[4*x] = (U8)(fltRed * fltScale); // R piDstPixel[4*x+1] = (U8)(fltGreen * fltScale); // G piDstPixel[4*x+2] = (U8)(fltBlue * fltScale); // B piDstPixel[4*x+3] = (U8)(e + 128); // E } } } return WMP_errSuccess; } ERR RGBA64Half_RGBA128Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX4 = 4 * pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; U32 *pfltDstPixel = (U32*)(pb + cbStride*y); // It's really float, but use U32 ptr const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = iWidthX4 - 1; x >= 0; x--) pfltDstPixel[x] = Convert_Half_To_Float(piSrcPixel[x]); } return WMP_errSuccess; } ERR RGBA128Float_RGBA64Half(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX4 = 4 * pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidthX4; x++) piDstPixel[x] = Convert_Float_To_Half(pfltSrcPixel[x]); } return WMP_errSuccess; } ERR RGB64Half_RGB96Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; U32 *pfltDstPixel = (U32*)(pb + cbStride*y); // It's really float, but use U32 ptr const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = iWidth - 1; x >= 0; x--) { pfltDstPixel[3*x] = Convert_Half_To_Float(piSrcPixel[4*x]); pfltDstPixel[3*x+1] = Convert_Half_To_Float(piSrcPixel[4*x+1]); pfltDstPixel[3*x+2] = Convert_Half_To_Float(piSrcPixel[4*x+2]); } } return WMP_errSuccess; } ERR RGB96Float_RGB64Half(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) { piDstPixel[4*x] = Convert_Float_To_Half(pfltSrcPixel[3*x]); piDstPixel[4*x+1] = Convert_Float_To_Half(pfltSrcPixel[3*x+1]); piDstPixel[4*x+2] = Convert_Float_To_Half(pfltSrcPixel[3*x+2]); piDstPixel[4*x+3] = 0; // Zero out the alpha channel } } return WMP_errSuccess; } ERR RGB48Half_RGB96Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX3 = 3*pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; U32 *pfltDstPixel = (U32*)(pb + cbStride*y); // It's really float, but use U32 ptr const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = iWidthX3 - 1; x >= 0; x--) pfltDstPixel[x] = Convert_Half_To_Float(piSrcPixel[x]); } return WMP_errSuccess; } ERR RGB96Float_RGB48Half(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX3 = 3*pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidthX3; x++) piDstPixel[x] = Convert_Float_To_Half(pfltSrcPixel[x]); } return WMP_errSuccess; } ERR Gray16Half_Gray32Float(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; U32 *pfltDstPixel = (U32*)(pb + cbStride*y); // It's really float, but use U32 ptr const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = iWidth - 1; x >= 0; x--) pfltDstPixel[x] = Convert_Half_To_Float(piSrcPixel[x]); } return WMP_errSuccess; } ERR Gray32Float_Gray16Half(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; I16 *piDstPixel = (I16*)(pb + cbStride*y); const float *pfltSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) piDstPixel[x] = Convert_Float_To_Half(pfltSrcPixel[x]); } return WMP_errSuccess; } ERR RGB555_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; U8 *piDstPixel = (pb + cbStride*y); const U16 *piSrcPixel = (U16*)piDstPixel; for (x = iWidth - 1; x >= 0; x--) { const U16 v = piSrcPixel[x]; const unsigned int r = ((v >> 10) & 0x1f); const unsigned int g = ((v >> 5) & 0x1f); const unsigned int b = (v & 0x1f); piDstPixel[3*x] = (U8)(r << 3); // R piDstPixel[3*x+1] = (U8)(g << 3); // G piDstPixel[3*x+2] = (U8)(b << 3); // B } } return WMP_errSuccess; } ERR RGB101010_RGB48(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; U16 *piDstPixel = (U16*)(pb + cbStride*y); const U32 *piSrcPixel = (U32*)piDstPixel; for (x = iWidth - 1; x >= 0; x--) { const U32 v = piSrcPixel[x]; const unsigned int r = ((v >> 20) & 0x3FF); const unsigned int g = ((v >> 10) & 0x3FF); const unsigned int b = (v & 0x3FF); piDstPixel[3*x] = (U16)(r << 6); // R piDstPixel[3*x+1] = (U16)(g << 6); // G piDstPixel[3*x+2] = (U16)(b << 6); // B } } return WMP_errSuccess; } ERR RGB24_RGB555(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U16 *piDstPixel = (U16*)(pb + cbStride*y); const U8 *piSrcPixel = (U8*)piDstPixel; for (x = 0; x < iWidth; x++) { const unsigned int r = piSrcPixel[3*x]; const unsigned int g = piSrcPixel[3*x+1]; const unsigned int b = piSrcPixel[3*x+2]; piDstPixel[x] = (U16) ( ((r & 0xF8) << 7) | ((g & 0xF8) << 2) | (b >> 3)); } } return WMP_errSuccess; } ERR RGB48_RGB101010(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U32 *piDstPixel = (U32*)(pb + cbStride*y); const U16 *piSrcPixel = (U16*)piDstPixel; for (x = 0; x < iWidth; x++) { const unsigned int r = piSrcPixel[3*x]; const unsigned int g = piSrcPixel[3*x+1]; const unsigned int b = piSrcPixel[3*x+2]; piDstPixel[x] = (3 << 30) | // For compatibility with D3D's 2-10-10-10 format. ((r & 0x0000FFC0) << 14) | ((g & 0x0000FFC0) << 4) | (b >> 6); } } return WMP_errSuccess; } ERR RGB565_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; U8 *piDstPixel = (pb + cbStride*y); const U16 *piSrcPixel = (U16*)piDstPixel; for (x = iWidth - 1; x >= 0; x--) { const U16 v = piSrcPixel[x]; const unsigned int r = ((v >> 11) & 0x1f); const unsigned int g = ((v >> 5) & 0x3f); const unsigned int b = (v & 0x1f); piDstPixel[3*x] = (U8)(r << 3); // R piDstPixel[3*x+1] = (U8)(g << 2); // G piDstPixel[3*x+2] = (U8)(b << 3); // B } } return WMP_errSuccess; } ERR RGB24_RGB565(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U16 *piDstPixel = (U16*)(pb + cbStride*y); const U8 *piSrcPixel = (U8*)piDstPixel; for (x = 0; x < iWidth; x++) { const unsigned int r = piSrcPixel[3*x]; const unsigned int g = piSrcPixel[3*x+1]; const unsigned int b = piSrcPixel[3*x+2]; piDstPixel[x] = (U16) ( ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3)); } } return WMP_errSuccess; } ERR RGBA32_BGRA32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidthX4 = 4 * pRect->Width; // 4 == R, G, B, A I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *piPixel = (U8*)(pb + cbStride*y); for (x = 0; x < iWidthX4; x += 4) { // Swap R and B U8 bTemp = piPixel[x]; piPixel[x] = piPixel[x+2]; piPixel[x+2] = bTemp; } } return WMP_errSuccess; } ERR BGRA32_RGBA32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { return RGBA32_BGRA32(pFC, pRect, pb, cbStride); } ERR BlackWhite_Gray8(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; Bool bBlackWhite = pFC->pDecoder->WMP.wmiSCP.bBlackWhite; I32 y; // Stride is assumed to be same for src/dst for (y = iHeight - 1; y >= 0; y--) { I32 x; I32 n; U8 *piDstPixel = (pb + cbStride*y); const U8 *piSrcPixel = (U8*)piDstPixel; if (iWidth % 8 != 0) { const U8 v = piSrcPixel[iWidth / 8]; for (n = 0; n < iWidth % 8; n++) { piDstPixel[iWidth/8*8+n] = (((v >> (7 - n)) & 0x1) != 0) ^ bBlackWhite ? 0xFF : 0x00; } } for (x = iWidth / 8 - 1; x >= 0; x--) { const U8 v = piSrcPixel[x]; for (n = 0; n < 8; n++) { piDstPixel[8*x+n] = (((v >> (7 - n)) & 0x1) != 0) ^ bBlackWhite ? 0xFF : 0x00; } } } return WMP_errSuccess; } ERR Gray16_Gray8(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { I32 i = 0, j = 0; UNREFERENCED_PARAMETER( pFC ); for (i = 0; i < pRect->Height; ++i) { for (j = 0; j < pRect->Width; ++j) { U16 v = ((U16*)pb)[j]; pb[j] = v >> 8; } pb += cbStride; } return WMP_errSuccess; } ERR RGB48_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const U16 *piSrcPixel = (U16*)piDstPixel; for (x = 0; x < iWidth; x++) { const U16 r = piSrcPixel[3*x]; const U16 g = piSrcPixel[3*x+1]; const U16 b = piSrcPixel[3*x+2]; piDstPixel[3*x] = r >> 8; piDstPixel[3*x+1] = g >> 8; piDstPixel[3*x+2] = b >> 8; } } return WMP_errSuccess; } ERR RGBA64_RGBA32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const U16 *piSrcPixel = (U16*)piDstPixel; for (x = 0; x < iWidth; x++) { const U16 r = piSrcPixel[4*x]; const U16 g = piSrcPixel[4*x+1]; const U16 b = piSrcPixel[4*x+2]; const U16 a = piSrcPixel[4*x+3]; piDstPixel[4*x] = r >> 8; piDstPixel[4*x+1] = g >> 8; piDstPixel[4*x+2] = b >> 8; piDstPixel[4*x+3] = a >> 8; } } return WMP_errSuccess; } ERR Gray32Float_Gray8(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const float *piSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) { const float v = piSrcPixel[x]; piDstPixel[x] = Convert_Float_To_U8(v); } } return WMP_errSuccess; } ERR RGB96Float_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const float *piSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) { const float r = piSrcPixel[3*x]; const float g = piSrcPixel[3*x+1]; const float b = piSrcPixel[3*x+2]; piDstPixel[3*x] = Convert_Float_To_U8(r); piDstPixel[3*x+1] = Convert_Float_To_U8(g); piDstPixel[3*x+2] = Convert_Float_To_U8(b); } } return WMP_errSuccess; } ERR RGB128Float_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const float *piSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) { const float r = piSrcPixel[4*x]; const float g = piSrcPixel[4*x+1]; const float b = piSrcPixel[4*x+2]; piDstPixel[3*x] = Convert_Float_To_U8(r); piDstPixel[3*x+1] = Convert_Float_To_U8(g); piDstPixel[3*x+2] = Convert_Float_To_U8(b); } } return WMP_errSuccess; } ERR RGBA128Float_RGBA32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const float *piSrcPixel = (float*)piDstPixel; for (x = 0; x < iWidth; x++) { const float r = piSrcPixel[4*x]; const float g = piSrcPixel[4*x+1]; const float b = piSrcPixel[4*x+2]; const float a = piSrcPixel[4*x+3]; piDstPixel[4*x] = Convert_Float_To_U8(r); piDstPixel[4*x+1] = Convert_Float_To_U8(g); piDstPixel[4*x+2] = Convert_Float_To_U8(b); piDstPixel[4*x+3] = Convert_AlphaFloat_To_U8(a); } } return WMP_errSuccess; } ERR Gray16Fixed_Gray8(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)piDstPixel; for (x = 0; x < iWidth; x++) { piDstPixel[x] = Convert_Float_To_U8(piSrcPixel[x] * fltCvtFactor); } } return WMP_errSuccess; } ERR Gray32Fixed_Gray8(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const I32 *piSrcPixel = (I32*)piDstPixel; for (x = 0; x < iWidth; x++) { piDstPixel[x] = Convert_Float_To_U8(piSrcPixel[x] * fltCvtFactor); } } return WMP_errSuccess; } ERR RGB48Fixed_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = 0; x < iWidth; x++) { pfltDstPixel[3*x] = Convert_Float_To_U8(piSrcPixel[3*x] * fltCvtFactor); pfltDstPixel[3*x+1] = Convert_Float_To_U8(piSrcPixel[3*x+1] * fltCvtFactor); pfltDstPixel[3*x+2] = Convert_Float_To_U8(piSrcPixel[3*x+2] * fltCvtFactor); } } return WMP_errSuccess; } ERR RGB64Fixed_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = 0; x < iWidth; x++) { pfltDstPixel[3*x] = Convert_Float_To_U8(piSrcPixel[4*x] * fltCvtFactor); pfltDstPixel[3*x+1] = Convert_Float_To_U8(piSrcPixel[4*x+1] * fltCvtFactor); pfltDstPixel[3*x+2] = Convert_Float_To_U8(piSrcPixel[4*x+2] * fltCvtFactor); } } return WMP_errSuccess; } ERR RGB96Fixed_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const I32 *piSrcPixel = (I32*)pfltDstPixel; for (x = 0; x < iWidth; x++) { pfltDstPixel[3*x] = Convert_Float_To_U8(piSrcPixel[3*x] * fltCvtFactor); pfltDstPixel[3*x+1] = Convert_Float_To_U8(piSrcPixel[3*x+1] * fltCvtFactor); pfltDstPixel[3*x+2] = Convert_Float_To_U8(piSrcPixel[3*x+2] * fltCvtFactor); } } return WMP_errSuccess; } ERR RGB128Fixed_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const I32 *piSrcPixel = (I32*)pfltDstPixel; for (x = 0; x < iWidth; x++) { pfltDstPixel[3*x] = Convert_Float_To_U8(piSrcPixel[4*x] * fltCvtFactor); pfltDstPixel[3*x+1] = Convert_Float_To_U8(piSrcPixel[4*x+1] * fltCvtFactor); pfltDstPixel[3*x+2] = Convert_Float_To_U8(piSrcPixel[4*x+2] * fltCvtFactor); } } return WMP_errSuccess; } ERR RGBA64Fixed_RGBA32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 13); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const I16 *piSrcPixel = (I16*)pfltDstPixel; for (x = 0; x < iWidth; x++) { pfltDstPixel[4*x] = Convert_Float_To_U8(piSrcPixel[4*x] * fltCvtFactor); pfltDstPixel[4*x+1] = Convert_Float_To_U8(piSrcPixel[4*x+1] * fltCvtFactor); pfltDstPixel[4*x+2] = Convert_Float_To_U8(piSrcPixel[4*x+2] * fltCvtFactor); pfltDstPixel[4*x+3] = Convert_AlphaFloat_To_U8(piSrcPixel[4*x+3] * fltCvtFactor); } } return WMP_errSuccess; } ERR RGBA128Fixed_RGBA32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; const float fltCvtFactor = 1.0F / (1 << 24); I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const I32 *piSrcPixel = (I32*)pfltDstPixel; for (x = 0; x < iWidth; x++) { pfltDstPixel[4*x] = Convert_Float_To_U8(piSrcPixel[4*x] * fltCvtFactor); pfltDstPixel[4*x+1] = Convert_Float_To_U8(piSrcPixel[4*x+1] * fltCvtFactor); pfltDstPixel[4*x+2] = Convert_Float_To_U8(piSrcPixel[4*x+2] * fltCvtFactor); pfltDstPixel[4*x+3] = Convert_AlphaFloat_To_U8(piSrcPixel[4*x+3] * fltCvtFactor); } } return WMP_errSuccess; } ERR Gray16Half_Gray8(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const U16 *piSrcPixel = (U16*)piDstPixel; for (x = 0; x < iWidth; x++) { const U32 v = Convert_Half_To_Float(piSrcPixel[x]); piDstPixel[x] = Convert_Float_To_U8(*(float*)&v); } } return WMP_errSuccess; } ERR RGB48Half_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const U16 *piSrcPixel = (U16*)pfltDstPixel; for (x = 0; x < iWidth; x++) { const U32 r = Convert_Half_To_Float(piSrcPixel[3*x]); const U32 g = Convert_Half_To_Float(piSrcPixel[3*x+1]); const U32 b = Convert_Half_To_Float(piSrcPixel[3*x+2]); pfltDstPixel[3*x] = Convert_Float_To_U8(*(float*)&r); pfltDstPixel[3*x+1] = Convert_Float_To_U8(*(float*)&g); pfltDstPixel[3*x+2] = Convert_Float_To_U8(*(float*)&b); } } return WMP_errSuccess; } ERR RGB64Half_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const U16 *piSrcPixel = (U16*)pfltDstPixel; for (x = 0; x < iWidth; x++) { const U32 r = Convert_Half_To_Float(piSrcPixel[4*x]); const U32 g = Convert_Half_To_Float(piSrcPixel[4*x+1]); const U32 b = Convert_Half_To_Float(piSrcPixel[4*x+2]); pfltDstPixel[3*x] = Convert_Float_To_U8(*(float*)&r); pfltDstPixel[3*x+1] = Convert_Float_To_U8(*(float*)&g); pfltDstPixel[3*x+2] = Convert_Float_To_U8(*(float*)&b); } } return WMP_errSuccess; } ERR RGBA64Half_RGBA32(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); for (y = 0; y < iHeight; y++) { I32 x; U8 *pfltDstPixel = (U8*)(pb + cbStride*y); const U16 *piSrcPixel = (U16*)pfltDstPixel; for (x = 0; x < iWidth; x++) { const U32 r = Convert_Half_To_Float(piSrcPixel[4*x]); const U32 g = Convert_Half_To_Float(piSrcPixel[4*x+1]); const U32 b = Convert_Half_To_Float(piSrcPixel[4*x+2]); const U32 a = Convert_Half_To_Float(piSrcPixel[4*x+3]); pfltDstPixel[4*x] = Convert_Float_To_U8(*(float*)&r); pfltDstPixel[4*x+1] = Convert_Float_To_U8(*(float*)&g); pfltDstPixel[4*x+2] = Convert_Float_To_U8(*(float*)&b); pfltDstPixel[4*x+3] = Convert_AlphaFloat_To_U8(*(float*)&a); } } return WMP_errSuccess; } ERR RGB101010_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { const I32 iHeight = pRect->Height; const I32 iWidth = pRect->Width; I32 y; UNREFERENCED_PARAMETER( pFC ); // Stride is assumed to be same for src/dst for (y = 0; y < iHeight; y++) { I32 x; U8 *piDstPixel = (U8*)(pb + cbStride*y); const U32 *piSrcPixel = (U32*)piDstPixel; for (x = 0; x < iWidth; x++) { const U32 v = piSrcPixel[x]; const unsigned int r = ((v >> 20) & 0x3FF); const unsigned int g = ((v >> 10) & 0x3FF); const unsigned int b = (v & 0x3FF); piDstPixel[3*x] = (U8) (r >> 2); piDstPixel[3*x+1] = (U8) (g >> 2); piDstPixel[3*x+2] = (U8) (b >> 2); } } return WMP_errSuccess; } ERR RGBE_RGB24(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { I32 i = 0, j = 0; UNREFERENCED_PARAMETER( pFC ); for (i = 0; i < pRect->Height; ++i) { for (j = 0; j < pRect->Width; j++) { // First read the exponent const U8 rawExp = pb[4*j+3]; if (0 == rawExp) { pb[3*j] = 0; pb[3*j+1] = 0; pb[3*j+2] = 0; } else { const I32 adjExp = (I32)rawExp - 128 - 8; // Can be negative float fltExp; if (adjExp > -32 && adjExp < 32) { fltExp = (float) (((U32)1) << abs(adjExp)); if (adjExp < 0) fltExp = 1.0F / fltExp; } else { fltExp = (float)ldexp(1.0F, adjExp); } pb[3*j] = Convert_Float_To_U8(pb[4*j] * fltExp); pb[3*j + 1] = Convert_Float_To_U8(pb[4*j + 1] * fltExp); pb[3*j + 2] = Convert_Float_To_U8(pb[4*j + 2] * fltExp); } } pb += cbStride; } return WMP_errSuccess; } //================================================================ typedef struct tagPKPixelConverterInfo { const PKPixelFormatGUID* pGUIDPixFmtFrom; const PKPixelFormatGUID* pGUIDPixFmtTo; ERR (*Convert)(PKFormatConverter*, const PKRect*, U8*, U32); } PKPixelConverterInfo; static PKPixelConverterInfo s_pcInfo[] = { {&GUID_PKPixelFormat24bppRGB, &GUID_PKPixelFormat24bppBGR, RGB24_BGR24}, // Fwd {&GUID_PKPixelFormat24bppBGR, &GUID_PKPixelFormat24bppRGB, BGR24_RGB24}, // Rev {&GUID_PKPixelFormat24bppRGB, &GUID_PKPixelFormat32bppBGR, RGB24_BGR32}, // Fwd {&GUID_PKPixelFormat32bppBGR, &GUID_PKPixelFormat24bppRGB, BGR32_RGB24}, // Rev // The following are not to be exposed when building the Adobe Photoshop plugin #ifndef ADOBE_PS_PLUGIN {&GUID_PKPixelFormat24bppRGB, &GUID_PKPixelFormat8bppGray, RGB24_Gray8}, // Fwd {&GUID_PKPixelFormat8bppGray, &GUID_PKPixelFormat24bppRGB, Gray8_RGB24}, // Rev {&GUID_PKPixelFormat24bppBGR, &GUID_PKPixelFormat8bppGray, BGR24_Gray8}, // Fwd {&GUID_PKPixelFormat8bppGray, &GUID_PKPixelFormat24bppBGR, Gray8_BGR24}, // Rev #endif // ADOBE_PS_PLUGIN {&GUID_PKPixelFormat128bppRGBAFixedPoint, &GUID_PKPixelFormat128bppRGBAFloat, RGBA128Fixed_RGBA128Float}, // Fwd {&GUID_PKPixelFormat128bppRGBAFloat, &GUID_PKPixelFormat128bppRGBAFixedPoint, RGBA128Float_RGBA128Fixed}, // Rev {&GUID_PKPixelFormat96bppRGBFixedPoint, &GUID_PKPixelFormat96bppRGBFloat, RGB96Fixed_RGB96Float}, // Fwd {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat96bppRGBFixedPoint, RGB96Float_RGB96Fixed}, // Rev {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat128bppRGBFloat, RGB96Float_RGB128Float}, // Fwd {&GUID_PKPixelFormat128bppRGBFloat, &GUID_PKPixelFormat96bppRGBFloat, RGB128Float_RGB96Float}, // Rev {&GUID_PKPixelFormat96bppRGBFixedPoint, &GUID_PKPixelFormat128bppRGBFixedPoint, RGB96Float_RGB128Float}, // Fwd {&GUID_PKPixelFormat128bppRGBFixedPoint, &GUID_PKPixelFormat96bppRGBFixedPoint, RGB128Float_RGB96Float}, // Rev {&GUID_PKPixelFormat64bppRGBHalf, &GUID_PKPixelFormat48bppRGBHalf, RGB64Half_RGB48Half}, // Fwd {&GUID_PKPixelFormat48bppRGBHalf, &GUID_PKPixelFormat64bppRGBHalf, RGB48Half_RGB64Half}, // Rev {&GUID_PKPixelFormat64bppRGBFixedPoint, &GUID_PKPixelFormat48bppRGBFixedPoint, RGB64Half_RGB48Half}, // Fwd {&GUID_PKPixelFormat48bppRGBFixedPoint, &GUID_PKPixelFormat64bppRGBFixedPoint, RGB48Half_RGB64Half}, // Rev {&GUID_PKPixelFormat32bppBGR, &GUID_PKPixelFormat24bppBGR, BGR32_BGR24}, // Fwd {&GUID_PKPixelFormat24bppBGR, &GUID_PKPixelFormat32bppBGR, BGR24_BGR32}, // Rev {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat128bppRGBFixedPoint, RGB96Float_RGB128Fixed}, // Fwd {&GUID_PKPixelFormat128bppRGBFixedPoint, &GUID_PKPixelFormat96bppRGBFloat, RGB128Fixed_RGB96Float}, // Rev {&GUID_PKPixelFormat32bppGrayFixedPoint, &GUID_PKPixelFormat32bppGrayFloat, Gray32Fixed_Gray32Float}, // Fwd {&GUID_PKPixelFormat32bppGrayFloat, &GUID_PKPixelFormat32bppGrayFixedPoint, Gray32Float_Gray32Fixed}, // Rev {&GUID_PKPixelFormat16bppGrayFixedPoint, &GUID_PKPixelFormat32bppGrayFloat, Gray16Fixed_Gray32Float}, // Fwd {&GUID_PKPixelFormat32bppGrayFloat, &GUID_PKPixelFormat16bppGrayFixedPoint, Gray32Float_Gray16Fixed}, // Rev {&GUID_PKPixelFormat48bppRGBFixedPoint, &GUID_PKPixelFormat96bppRGBFloat, RGB48Fixed_RGB96Float}, // Fwd {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat48bppRGBFixedPoint, RGB96Float_RGB48Fixed}, // Rev {&GUID_PKPixelFormat64bppRGBFixedPoint, &GUID_PKPixelFormat96bppRGBFloat, RGB64Fixed_RGB96Float}, // Fwd {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat64bppRGBFixedPoint, RGB96Float_RGB64Fixed}, // Rev {&GUID_PKPixelFormat64bppRGBAFixedPoint, &GUID_PKPixelFormat128bppRGBAFloat, RGBA64Fixed_RGBA128Float}, // Fwd {&GUID_PKPixelFormat128bppRGBAFloat, &GUID_PKPixelFormat64bppRGBAFixedPoint, RGBA128Float_RGBA64Fixed}, // Rev {&GUID_PKPixelFormat32bppRGBE, &GUID_PKPixelFormat96bppRGBFloat, RGBE_RGB96Float}, // Fwd {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat32bppRGBE, RGB96Float_RGBE}, // Rev {&GUID_PKPixelFormat64bppRGBAHalf, &GUID_PKPixelFormat128bppRGBAFloat, RGBA64Half_RGBA128Float}, // Fwd {&GUID_PKPixelFormat128bppRGBAFloat, &GUID_PKPixelFormat64bppRGBAHalf, RGBA128Float_RGBA64Half}, // Rev {&GUID_PKPixelFormat64bppRGBHalf, &GUID_PKPixelFormat96bppRGBFloat, RGB64Half_RGB96Float}, // Fwd {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat64bppRGBHalf, RGB96Float_RGB64Half}, // Rev {&GUID_PKPixelFormat48bppRGBHalf, &GUID_PKPixelFormat96bppRGBFloat, RGB48Half_RGB96Float}, // Fwd {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat48bppRGBHalf, RGB96Float_RGB48Half}, // Rev {&GUID_PKPixelFormat16bppGrayHalf, &GUID_PKPixelFormat32bppGrayFloat, Gray16Half_Gray32Float}, // Fwd {&GUID_PKPixelFormat32bppGrayFloat, &GUID_PKPixelFormat16bppGrayHalf, Gray32Float_Gray16Half}, // Rev {&GUID_PKPixelFormat16bppRGB555, &GUID_PKPixelFormat24bppRGB, RGB555_RGB24}, // Fwd {&GUID_PKPixelFormat24bppRGB, &GUID_PKPixelFormat16bppRGB555, RGB24_RGB555}, // Rev {&GUID_PKPixelFormat16bppRGB565, &GUID_PKPixelFormat24bppRGB, RGB565_RGB24}, // Fwd {&GUID_PKPixelFormat24bppRGB, &GUID_PKPixelFormat16bppRGB565, RGB24_RGB565}, // Rev {&GUID_PKPixelFormat32bppRGB101010, &GUID_PKPixelFormat48bppRGB, RGB101010_RGB48}, // Fwd {&GUID_PKPixelFormat48bppRGB, &GUID_PKPixelFormat32bppRGB101010, RGB48_RGB101010}, // Rev {&GUID_PKPixelFormat32bppRGBA, &GUID_PKPixelFormat32bppBGRA, RGBA32_BGRA32}, // Fwd {&GUID_PKPixelFormat32bppBGRA, &GUID_PKPixelFormat32bppRGBA, BGRA32_RGBA32}, // Rev {&GUID_PKPixelFormat32bppPRGBA, &GUID_PKPixelFormat32bppPBGRA, RGBA32_BGRA32}, // Fwd {&GUID_PKPixelFormat32bppPBGRA, &GUID_PKPixelFormat32bppPRGBA, BGRA32_RGBA32}, // Rev // conversions to 8bppGray / 24bppRGB / 32bppRGBA {&GUID_PKPixelFormatBlackWhite, &GUID_PKPixelFormat8bppGray, BlackWhite_Gray8}, {&GUID_PKPixelFormat16bppGray, &GUID_PKPixelFormat8bppGray, Gray16_Gray8}, {&GUID_PKPixelFormat48bppRGB, &GUID_PKPixelFormat24bppRGB, RGB48_RGB24}, {&GUID_PKPixelFormat64bppRGBA, &GUID_PKPixelFormat32bppRGBA, RGBA64_RGBA32}, {&GUID_PKPixelFormat32bppGrayFloat, &GUID_PKPixelFormat8bppGray, Gray32Float_Gray8}, {&GUID_PKPixelFormat96bppRGBFloat, &GUID_PKPixelFormat24bppRGB, RGB96Float_RGB24}, {&GUID_PKPixelFormat128bppRGBFloat, &GUID_PKPixelFormat24bppRGB, RGB128Float_RGB24}, {&GUID_PKPixelFormat128bppRGBAFloat, &GUID_PKPixelFormat32bppRGBA, RGBA128Float_RGBA32}, {&GUID_PKPixelFormat16bppGrayFixedPoint, &GUID_PKPixelFormat8bppGray, Gray16Fixed_Gray8}, {&GUID_PKPixelFormat32bppGrayFixedPoint, &GUID_PKPixelFormat8bppGray, Gray32Fixed_Gray8}, {&GUID_PKPixelFormat48bppRGBFixedPoint, &GUID_PKPixelFormat24bppRGB, RGB48Fixed_RGB24}, {&GUID_PKPixelFormat64bppRGBFixedPoint, &GUID_PKPixelFormat24bppRGB, RGB64Fixed_RGB24}, {&GUID_PKPixelFormat96bppRGBFixedPoint, &GUID_PKPixelFormat24bppRGB, RGB96Fixed_RGB24}, {&GUID_PKPixelFormat128bppRGBFixedPoint, &GUID_PKPixelFormat24bppRGB, RGB128Fixed_RGB24}, {&GUID_PKPixelFormat64bppRGBAFixedPoint, &GUID_PKPixelFormat32bppRGBA, RGBA64Fixed_RGBA32}, {&GUID_PKPixelFormat128bppRGBAFixedPoint, &GUID_PKPixelFormat32bppRGBA, RGBA128Fixed_RGBA32}, {&GUID_PKPixelFormat16bppGrayHalf, &GUID_PKPixelFormat8bppGray, Gray16Half_Gray8}, {&GUID_PKPixelFormat48bppRGBHalf, &GUID_PKPixelFormat24bppRGB, RGB48Half_RGB24}, {&GUID_PKPixelFormat64bppRGBHalf, &GUID_PKPixelFormat24bppRGB, RGB64Half_RGB24}, {&GUID_PKPixelFormat64bppRGBAHalf, &GUID_PKPixelFormat32bppRGBA, RGBA64Half_RGBA32}, {&GUID_PKPixelFormat32bppRGB101010, &GUID_PKPixelFormat24bppRGB, RGB101010_RGB24}, {&GUID_PKPixelFormat32bppRGBE, &GUID_PKPixelFormat24bppRGB, RGBE_RGB24} }; /* auxiliary data structure and hack to support valid encoding from/to configurations that // don't actually require any color conversion. This is a conservative approach, where we // include as few formats as necessary to encode situations that we're currently aware of. */ typedef struct tagPKPixelConverter2Info { const PKPixelFormatGUID* pGUIDPixFmtFrom; const PKPixelFormatGUID* pGUIDPixFmtTo; } PKPixelConverter2Info; static PKPixelConverter2Info s_pcInfo2[] = { // This allows us to view an RGBA input file as RGB, for when we create a planar alpha file {&GUID_PKPixelFormat128bppRGBFloat, &GUID_PKPixelFormat128bppRGBAFloat}, // 16- and 32-bpp RGB input files are given the "DontCare" GUID, so the next three // from/to combinations are ok, and allowed on encoding: {&GUID_PKPixelFormatDontCare, &GUID_PKPixelFormat16bppRGB555}, {&GUID_PKPixelFormatDontCare, &GUID_PKPixelFormat16bppRGB565}, {&GUID_PKPixelFormatDontCare, &GUID_PKPixelFormat32bppBGRA} }; ERR PKFormatConverter_Initialize(PKFormatConverter* pFC, PKImageDecode* pID, char *pExt, PKPixelFormatGUID enPF) { ERR err; PKPixelFormatGUID enPFFrom; Call(pID->GetPixelFormat(pID, &enPFFrom)); Call(PKFormatConverter_InitializeConvert(pFC, enPFFrom, pExt, enPF)); pFC->pDecoder = pID; Cleanup: return err; } extern int PKStrnicmp(const char* s1, const char* s2, size_t c); ERR PKFormatConverter_InitializeConvert(PKFormatConverter* pFC, const PKPixelFormatGUID enPFFrom, char *pExt, PKPixelFormatGUID enPFTo) { ERR err = WMP_errSuccess; //================================ pFC->enPixelFormat = enPFTo; if (pExt != NULL && IsEqualGUID(&enPFTo, &GUID_PKPixelFormat24bppRGB) && 0 == PKStrnicmp(pExt, ".bmp", strlen(pExt))) enPFTo = GUID_PKPixelFormat24bppBGR; if (pExt != NULL && (0 == PKStrnicmp(pExt, ".tif", strlen(pExt)) || 0 == PKStrnicmp(pExt, ".tiff", strlen(pExt)))) { if (IsEqualGUID(&enPFTo, &GUID_PKPixelFormat32bppBGRA)) enPFTo = GUID_PKPixelFormat32bppRGBA; if (IsEqualGUID(&enPFTo, &GUID_PKPixelFormat32bppPBGRA)) enPFTo = GUID_PKPixelFormat32bppPRGBA; } //================================ if (!IsEqualGUID(&enPFFrom, &enPFTo)) { size_t i = 0; for (i = 0; i < sizeof2(s_pcInfo); ++i) { PKPixelConverterInfo* pPCI = s_pcInfo + i; if (IsEqualGUID(&enPFFrom, pPCI->pGUIDPixFmtFrom) && IsEqualGUID(&enPFTo, pPCI->pGUIDPixFmtTo)) { pFC->Convert= pPCI->Convert; goto Cleanup; } } // Bugfix to allow legitimate encoding from/to combinations that don't actually // involve color conversions. for (i = 0; i < sizeof2(s_pcInfo2); ++i) { PKPixelConverter2Info* pPCI = s_pcInfo2 + i; if (IsEqualGUID(&enPFFrom, pPCI->pGUIDPixFmtFrom) && IsEqualGUID(&enPFTo, pPCI->pGUIDPixFmtTo)) { goto Cleanup; } } // If we failed the original check, and this bugfix check, then exit with error Call(WMP_errUnsupportedFormat); } Cleanup: return err; } ERR PKFormatConverter_EnumConversions(const PKPixelFormatGUID *pguidSourcePF, const U32 iIndex, const PKPixelFormatGUID **ppguidTargetPF) { U32 iCurrIdx = 0; U32 i; ERR errResult = WMP_errIndexNotFound; *ppguidTargetPF = &GUID_PKPixelFormatDontCare; // Init return value for (i = 0; i < sizeof2(s_pcInfo); i++) { if (IsEqualGUID(s_pcInfo[i].pGUIDPixFmtFrom, pguidSourcePF)) { if (iCurrIdx == iIndex) { // Found our target errResult = WMP_errSuccess; *ppguidTargetPF = s_pcInfo[i].pGUIDPixFmtTo; break; } iCurrIdx += 1; } } return errResult; } ERR PKFormatConverter_GetPixelFormat(PKFormatConverter* pFC, PKPixelFormatGUID* pPF) { *pPF = pFC->enPixelFormat; return WMP_errSuccess; } ERR PKFormatConverter_GetSourcePixelFormat(PKFormatConverter* pFC, PKPixelFormatGUID* pPF) { return pFC->pDecoder->GetPixelFormat(pFC->pDecoder, pPF); } ERR PKFormatConverter_GetSize(PKFormatConverter* pFC, I32* piWidth, I32* piHeight) { return pFC->pDecoder->GetSize(pFC->pDecoder, piWidth, piHeight); } ERR PKFormatConverter_GetResolution(PKFormatConverter* pFC, Float* pfrX, Float* pfrY) { return pFC->pDecoder->GetResolution(pFC->pDecoder, pfrX, pfrY); } ERR PKFormatConverter_Copy(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { ERR err = WMP_errSuccess; Call(pFC->pDecoder->Copy(pFC->pDecoder, pRect, pb, cbStride)); Call(pFC->Convert(pFC, pRect, pb, cbStride)); Cleanup: return err; } ERR PKFormatConverter_Convert(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride) { UNREFERENCED_PARAMETER( pFC ); UNREFERENCED_PARAMETER( pRect ); UNREFERENCED_PARAMETER( pb ); UNREFERENCED_PARAMETER( cbStride ); return WMP_errSuccess; } ERR PKFormatConverter_Release(PKFormatConverter** ppFC) { ERR err = WMP_errSuccess; Call(PKFree((void **) ppFC)); Cleanup: return err; }