colormap.c
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:28k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "hxtypes.h"
  36. #if defined(_WIN32) && !defined(_WINCE)
  37. /* Windows include files: */
  38. #include <windows.h>
  39. #include <vfw.h>
  40. #include <ddraw.h>
  41. #include "hxtypes.h"
  42. #elif defined(_WINCE)
  43. #include "hxwintyp.h"
  44. #include <windows.h>
  45. #include "hxcom.h"
  46. //#undef _WIN32
  47. #include "hxvsurf.h"
  48. #endif
  49. #include "hxcom.h"
  50. #include "hlxclib/string.h"
  51. #include "hxtypes.h"
  52. #include "hxwintyp.h"
  53. #include "hxvsurf.h"
  54. /* Color IDs:*/
  55. #include "colormap.h"
  56. /*
  57.  * FOURCC codes (in addition to what is defined in wingdi.h):
  58.  */
  59. /* standard YUV formats: */
  60. #define BI_I420         MAKEFOURCC('I','4','2','0') /* planar YCrCb   */
  61. #define BI_YUVA         MAKEFOURCC('Y','U','V','A') /* planar YVU 420 plus alpha plane */
  62. #define BI_YV12         MAKEFOURCC('Y','V','1','2') /* planar YVU 420 */
  63. #define BI_YVU9         MAKEFOURCC('Y','V','U','9') /* planar YVU 420 */
  64. #define BI_YUY2         MAKEFOURCC('Y','U','Y','2') /* packed YVU 422 */
  65. #define BI_UYVY         MAKEFOURCC('U','Y','V','Y') /* packed YVU 422 */
  66. #define BI_DVPF         MAKEFOURCC('D','V','P','F') /* planar YCrCb in structure */
  67. /* Xing decoder's YUV format */
  68. #define BI_XING         MAKEFOURCC('X','I','N','G')
  69. /* MPEG-2 pre-decoded formats: */
  70. #define BI_MC12         MAKEFOURCC('M','C','1','2') /* ATI MPEG-2 M/C */
  71. #define BI_MCAM         MAKEFOURCC('M','C','A','M') /* ATI MPEG-2 M/C */
  72. #define BI_MCS3         MAKEFOURCC('M','C','S','3') /* S3 MPEG-2 M/C  */
  73. #define BI_IGOR         MAKEFOURCC('I','G','O','R') /* Intel i810 M/C */
  74. /* RMA proprietary formats: */
  75. #ifndef HXCOLOR_RGB3_ID
  76. #define HXCOLOR_RGB3_ID     MAKEFOURCC('3','B','G','R') /* RGB-32 ??      */
  77. #define HXCOLOR_RGB24_ID    MAKEFOURCC('B','G','R',' ') /* top-down RGB-24*/
  78. #define HXCOLOR_RGB565_ID   MAKEFOURCC('6','B','G','R') /* RGB-16 565     */
  79. #define HXCOLOR_RGB555_ID   MAKEFOURCC('5','B','G','R') /* RGB-16 555     */
  80. #define HXCOLOR_8BIT_ID     MAKEFOURCC('T','I','B','8') /* RGB-8 w. pal-e */
  81. #define HXCOLOR_YUV420_ID   MAKEFOURCC('2','V','U','Y') /* planar YCrCb   */
  82. #define HXCOLOR_YUV411_ID   MAKEFOURCC('1','V','U','Y') /* ???            */
  83. #define HXCOLOR_YUVRAW_ID   MAKEFOURCC('R','V','U','Y') /* ???            */
  84. #endif
  85. /*
  86.  * Color format tables:
  87.  */
  88. /* control flags: */
  89. #define _FOURCC   0x01
  90. #define _BITCOUNT 0x02
  91. #define _BITMASK  0x04
  92. /* color format descriptor: */
  93. struct _greg
  94. {
  95.     ULONG32 dwFlags;              /* indicates valid fields       */
  96.     ULONG32 dwFourCC;             /* FourCC code                  */
  97.     ULONG32 dwBitCount;           /* number of bits/pixel         */
  98.     ULONG32 dwBitMask [3];        /* RGB bit masks                */
  99. };
  100. typedef struct _greg  CIDD;
  101. typedef struct _greg* LPCIDD;
  102. /* color format descriptors to use with YUV bitmaps: */
  103. static const CIDD ciddI420      = {_FOURCC,                    BI_I420,       12, {       0,        0,        0}};
  104. static const CIDD ciddYUVA      = {_FOURCC,                    BI_YUVA,       20, {       0,        0,        0}};
  105. static const CIDD ciddYV12      = {_FOURCC,                    BI_YV12,       12, {       0,        0,        0}};
  106. static const CIDD ciddYVU9      = {_FOURCC,                    BI_YVU9,        9, {       0,        0,        0}};
  107. static const CIDD ciddYUY2      = {_FOURCC,                    BI_YUY2,       16, {       0,        0,        0}};
  108. static const CIDD ciddUYVY      = {_FOURCC,                    BI_UYVY,       16, {       0,        0,        0}};
  109. static const CIDD ciddDVPF      = {_FOURCC,                    BI_DVPF,       12, {       0,        0,        0}};
  110. static const CIDD ciddXING      = {_FOURCC,                    BI_XING,       16, {       0,        0,        0}};
  111. /* color format descriptors to use with GDI RGB bitmaps: */
  112. static const CIDD ciddBmpRGB32  = {_FOURCC+_BITCOUNT,          BI_RGB,        32, {       0,        0,        0}};
  113. static const CIDD ciddBmpARGB32 = {_FOURCC+_BITCOUNT,          HX_ARGB,      32, {       0,        0,        0}};
  114. static const CIDD ciddBmpRGB24  = {_FOURCC+_BITCOUNT,          BI_RGB,        24, {       0,        0,        0}};
  115. static const CIDD ciddBmpRGB565 = {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,  16, {  0xF800,   0x07E0,   0x001F}};
  116. static const CIDD ciddBmpRGB555 = {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,  16, {  0x7C00,   0x03E0,   0x001F}};
  117. static const CIDD ciddBmpRGB8   = {_FOURCC+_BITCOUNT,          BI_RGB,         8, {       0,        0,        0}};
  118. /* color format descriptors to use with DirectDraw RGB surfaces: */
  119. static const CIDD ciddDDrRGB32  = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        32, {0xFF0000, 0x00FF00, 0x0000FF}};
  120. static const CIDD ciddDDrARGB32 = {_FOURCC+_BITCOUNT+_BITMASK, HX_ARGB,      32, {0xFF0000, 0x00FF00, 0x0000FF}};
  121. static const CIDD ciddDDrRGB24  = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        24, {0xFF0000, 0x00FF00, 0x0000FF}};
  122. static const CIDD ciddDDrRGB565 = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        16, {  0xF800,   0x07E0,   0x001F}};
  123. static const CIDD ciddDDrRGB555 = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        16, {  0x7C00,   0x03E0,   0x001F}};
  124. static const CIDD ciddDDrRGB8   = {_FOURCC+_BITCOUNT,          BI_RGB,         8, {       0,        0,        0}};
  125. /* color format descriptors to use with BRG bitmaps: */
  126. static const CIDD ciddBGR32     = {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,  32, {0x0000FF, 0x00FF00, 0xFF0000}};
  127. static const CIDD ciddBGR24     = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        24, {0x0000FF, 0x00FF00, 0xFF0000}};
  128. /* color format descriptors to use with QuickTime byte swapped formats: */
  129. static const CIDD ciddRGB32S    = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        32, {0x00FF00, 0xFF0000, 0xFF000000}};
  130. /* color format descriptors to use with embedded device formats: */
  131. static const CIDD ciddRGB444    = {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,  16, {  0x0F00,   0x00F0,   0x000F}};
  132. /* color format descriptors to use with MPEG bitmaps: */
  133. static const CIDD ciddMC12      = {_FOURCC,                    BI_MC12,       12, {       0,        0,        0}};
  134. static const CIDD ciddMCAM      = {_FOURCC,                    BI_MCAM,       12, {       0,        0,        0}};
  135. static const CIDD ciddMCS3      = {_FOURCC,                    BI_MCS3,       12, {       0,        0,        0}};
  136. static const CIDD ciddIGOR      = {_FOURCC,                    BI_IGOR,       12, {       0,        0,        0}};
  137. /* non-standard descriptors we should support: */
  138. struct _stColors
  139. {
  140.     int cid;                    /* image format ID              */
  141.     CIDD  cidd;                 /* color format descriptor      */
  142. };
  143. static const struct _stColors ciddlOtherColors [] = {
  144.     {CID_I420, {_FOURCC,                    HXCOLOR_YUV420_ID, 12, {         0,          0,          0}}},
  145.     {CID_YUVA,              {_FOURCC,                    HXCOLOR_YUVA_ID,   20, {         0,          0,          0}}},
  146.     {CID_RGB32,             {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,      32, {0xFF000000, 0x00FF0000, 0x0000FF00}}}, 
  147.     {CID_RGB565,            {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,      16, {0x0000f800, 0x000007c0, 0x0000003e}}}, 
  148.     {CID_RGB32,             {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,      32, {  0xFF0000,   0x00FF00,   0x0000FF}}},
  149.     {CID_RGB32,             {_FOURCC+_BITCOUNT,          HXCOLOR_RGB3_ID,   32, {         0,          0,          0}}},
  150.     {CID_RGB24,             {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,      24, {  0xFF0000,   0x00FF00,   0x0000FF}}},
  151.     {CID_RGB24,             {_FOURCC+_BITCOUNT,          HXCOLOR_RGB3_ID,   24, {         0,          0,          0}}},
  152.     {CID_RGB24,             {_FOURCC,                    HXCOLOR_RGB24_ID,  24, {         0,          0,          0}}},
  153.     {CID_RGB565,            {_FOURCC,                    HXCOLOR_RGB565_ID, 16, {         0,          0,          0}}},
  154.     {CID_RGB555,            {_FOURCC+_BITCOUNT,          BI_RGB,            16, {         0,          0,          0}}},
  155.     {CID_RGB555,            {_FOURCC,                    HXCOLOR_RGB555_ID, 16, {         0,          0,          0}}},
  156.     {CID_RGB8,              {_FOURCC,                    HXCOLOR_8BIT_ID,    8, {         0,          0,          0}}},
  157.     {CID_UNKNOWN,           {0      ,                    0,                  0, {         0,          0,          0}}}
  158. };
  159. /* color format attributes: */
  160. #define _BITMAP         0x0001  /* has bitmap descriptor        */
  161. #define _DIRECTDRAW     0x0002  /* has DirectDraw descriptor    */
  162. #define _RGB            0x0100  /* normal RGB format            */
  163. #define _BGR            0x0200  /* B/R flipped RGB format       */
  164. #define _YUV            0x0400  /* YUV format                   */
  165. #define _MPEG           0x0800  /* MPEG pre-decoded format      */
  166. #define _RGBS           0x1000  /* Byte swapped RGB format      */
  167. /* the main color descriptors' table: */
  168. struct _stColorTable
  169. {
  170.     ULONG32 dwFlags;               /* general format properties    */
  171.     const struct _greg * lpBitmapCIDD;     /* bitmap format descriptor     */
  172.     const struct _greg * lpDirectDrawCIDD; /* DirectDraw format descriptor */
  173.     int     nBPP;                  /* bytes per pixel              */
  174. };
  175. static const struct _stColorTable  ciddTbl[NFORMATS] = {
  176.     {_BITMAP+_YUV,              &ciddI420,      (const struct _greg*)NULL,    1}, /* CID_I420   */
  177.     {_BITMAP+_DIRECTDRAW+_YUV,  &ciddYV12,      &ciddYV12,      1}, /* CID_YV12   */
  178.     {_BITMAP+_DIRECTDRAW+_YUV,  &ciddYVU9,      &ciddYVU9,      1}, /* CID_YVU9   */
  179.     {_BITMAP+_DIRECTDRAW+_YUV,  &ciddYUY2,      &ciddYUY2,      2}, /* CID_YUY2   */
  180.     {_BITMAP+_DIRECTDRAW+_YUV,  &ciddUYVY,      &ciddUYVY,      2}, /* CID_UYVY   */
  181.     {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB32,  &ciddDDrRGB32,  4}, /* CID_RGB32  */
  182.     {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB24,  &ciddDDrRGB24,  3}, /* CID_RGB24  */
  183.     {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB565, &ciddDDrRGB565, 2}, /* CID_RGB565 */
  184.     {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB555, &ciddDDrRGB555, 2}, /* CID_RGB555 */
  185.     {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB8,   &ciddDDrRGB8,   1}, /* CID_RGB8   */
  186.     {_BITMAP+_DIRECTDRAW+_YUV,  &ciddXING,      &ciddXING,      1}, /* CID_XING   */
  187.     {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpARGB32, &ciddDDrARGB32, 4}, /* CID_ARGB32 */
  188.     {_BITMAP+_YUV,              &ciddYUVA,      NULL,           1}, /* CID_YUVA   */
  189.     {_BITMAP+_YUV,              &ciddYUY2,      &ciddYUY2,      2}, /* CID_YUYU   */
  190.     {0,                         NULL,           NULL,           0}, /* CID_UNKNOWN*/
  191.     {_BITMAP+_BGR,              &ciddBGR32,     NULL,           4}, /* CID_BGR32  */
  192.     {_BITMAP+_BGR,              &ciddBGR24,     NULL,           3}, /* CID_BGR24  */
  193.     {_BITMAP+_RGBS,             &ciddRGB32S,    NULL,           4}, /* CID_RGB32S */
  194.     {_BITMAP+_RGB,              &ciddRGB444,    NULL,           2}, /* CID_RGB444 */
  195.     {_BITMAP+_DIRECTDRAW+_MPEG, &ciddMC12,      &ciddMC12,      1}, /* CID_MC12   */
  196.     {_BITMAP+_DIRECTDRAW+_MPEG, &ciddMCAM,      &ciddMCAM,      1}, /* CID_MCAM   */
  197.     {_BITMAP+_DIRECTDRAW+_MPEG, &ciddMCS3,      &ciddMCS3,      1}, /* CID_MCS3   */
  198.     {_BITMAP+_DIRECTDRAW+_MPEG, &ciddIGOR,      &ciddIGOR,      1}, /* CID_IGOR   */
  199.     {_BITMAP+_DIRECTDRAW+_YUV,  &ciddDVPF,      &ciddDVPF,      1}  /* CID_DVPF   */
  200. };
  201.                                                  
  202. /*********************************
  203.  *  _TEXT segment :-)
  204.  *********************************/
  205. int MapFourCCtoCID(ULONG32 dwFourCC)
  206. {
  207.     int i;
  208.     //for (i=0; i<CID_UNKNOWN; i++)
  209.     for (i=0; i<NFORMATS; i++)
  210.     {
  211.         if (ciddTbl[i].lpBitmapCIDD &&
  212.             ciddTbl[i].lpBitmapCIDD->dwFourCC == dwFourCC)
  213.     {
  214.         return i;
  215.     }
  216.     }
  217.     return CID_UNKNOWN;
  218. }
  219. int MapCIDtoFourCC(ULONG32 CID)
  220. {
  221.     if (CID < NFORMATS)
  222.         return ciddTbl[CID].lpBitmapCIDD->dwFourCC;
  223.     else
  224.         return 0;
  225. }
  226. /*
  227.  * Check color format:
  228.  */
  229. static int ChkColor (const struct _greg* pcidd, ULONG32 dwFourCC, ULONG32 dwBitCount, ULONG32 *lpBitMask)
  230. {
  231.     /* clear match flags: */
  232.     ULONG32 dwMatch = 0;
  233.     /* check FourCC: */
  234.     if ((pcidd->dwFlags & _FOURCC) && pcidd->dwFourCC == dwFourCC)
  235.         dwMatch |= _FOURCC;
  236.     /* check BitCount: */
  237.     if ((pcidd->dwFlags & _BITCOUNT) && pcidd->dwBitCount == dwBitCount)
  238.         dwMatch |= _BITCOUNT;
  239.     /* check BitMasks: */
  240.     if ((pcidd->dwFlags & _BITMASK) && lpBitMask &&
  241.         pcidd->dwBitMask[0] == lpBitMask[0] &&
  242.         pcidd->dwBitMask[1] == lpBitMask[1] &&
  243.         pcidd->dwBitMask[2] == lpBitMask[2])
  244.         dwMatch |= _BITMASK;
  245.     /* combine results: */
  246.     return dwMatch == pcidd->dwFlags;
  247. }
  248. /*
  249.  * Get color format ID.
  250.  * Use:
  251.  *  int GetBitmapColor (LPBITMAPINFO lpbi);
  252.  *  int GetDirectDrawColor (LPDDPIXELFORMAT lpddpf);
  253.  * Input:
  254.  *  lpbi - pointer to BITMAPINFO structure containing image format
  255.  *  lpddpf - pointer to a DirectDraw DDPIXELFORMAT structure
  256.  * Returns:
  257.  *  ID of the specified format, if found;
  258.  *  CID_UNKNOWN, if not supported.
  259.  */
  260. #ifdef _WIN32
  261. int GetBitmapColor (LPBITMAPINFO lpbi)
  262. #else
  263. int GetBitmapColor (HXBitmapInfo* lpHXbi)
  264. #endif
  265. {
  266.     ULONG32 dwFourCC, dwBitCount, *lpColors;
  267.     register int i;
  268. #ifdef _WIN32
  269.     HXBitmapInfo* lpHXbi;
  270.     if (!lpbi)
  271.     {
  272. return CID_UNKNOWN;
  273.     }
  274.     lpHXbi = (HXBitmapInfo*) lpbi;
  275. #endif
  276.     /* check bitmap pointer/size... */
  277.     if (lpHXbi == NULL)
  278.         return CID_UNKNOWN;
  279.     /* get bitmap parameters to compare: */
  280.     dwFourCC = lpHXbi->bmiHeader.biCompression;
  281.     dwBitCount = lpHXbi->bmiHeader.biBitCount;
  282.     lpColors = (ULONG32*)&lpHXbi->un.dwBitMask[0];
  283.     /* scan standard bitmap formats: */
  284.     for (i=0; i<NFORMATS; i++)
  285.         if ((ciddTbl[i].dwFlags & _BITMAP) && ciddTbl[i].lpBitmapCIDD &&
  286.             ChkColor (ciddTbl[i].lpBitmapCIDD, dwFourCC, dwBitCount, lpColors))
  287.             return i;
  288.     
  289.     /* scan our proprietary formats: */
  290.     for (i=0; ; i++)
  291.         if (ChkColor (&(ciddlOtherColors[i].cidd), dwFourCC, dwBitCount, lpColors))
  292.             break;
  293.     /* return color ID: */
  294.     return ciddlOtherColors[i].cid;
  295. }
  296. #if defined(_WIN32) && !defined(WINCE)
  297. int GetDirectDrawColor (LPDDPIXELFORMAT lpddpf)
  298. {
  299.     /* check bitmap pointer... */
  300.     if (lpddpf != NULL && lpddpf->dwSize >= sizeof(DDPIXELFORMAT)) {
  301.         /* scan DirectDraw formats: */
  302.         register int i;
  303.         for (i=0; i<NFORMATS; i++)
  304.             if ((ciddTbl[i].dwFlags & _DIRECTDRAW) && ciddTbl[i].lpDirectDrawCIDD &&
  305.                 ChkColor (ciddTbl[i].lpDirectDrawCIDD, lpddpf->dwFourCC, lpddpf->dwRGBBitCount, &(lpddpf->dwRBitMask)))
  306.                 return i;
  307.     }
  308.     return CID_UNKNOWN;
  309. }
  310. #endif
  311. /*
  312.  * Set color format.
  313.  * Use:
  314.  *  void SetBitmapColor (LPBITMAPINFO lpbi, int cid);
  315.  *  void SetDirectDrawColor (LPDDPIXELFORMAT lpddpf, int cid);
  316.  * Input:
  317.  *  lpbi - pointer to BITMAPINFO structure containing image format
  318.  *  lpddpf - pointer to a DirectDraw DDPIXELFORMAT structure
  319.  *  cid - color format to set
  320.  * Returns:
  321.  *  0, if success,
  322.  *  !0 if wrong color format ID passed
  323.  */
  324. #ifdef _WIN32
  325. int SetBitmapColor (LPBITMAPINFO lpbi, int cid)
  326. #else
  327. int SetBitmapColor (HXBitmapInfo* lpHXbi, int cid)
  328. #endif
  329. {
  330.     const struct _greg* lpcidd;
  331. #ifdef _WIN32
  332.     HXBitmapInfo* lpHXbi;
  333.     if (!lpbi)
  334.     {
  335. return CID_UNKNOWN;
  336.     }
  337.     lpHXbi = (HXBitmapInfo*) lpbi;
  338. #endif
  339.     /* check input parameters: */
  340.     if (lpHXbi == NULL ||
  341.         cid < 0 || cid > NFORMATS || !(ciddTbl[cid].dwFlags & _BITMAP) ||
  342.         (lpcidd = ciddTbl[cid].lpBitmapCIDD) == NULL)
  343.         return -1;
  344.     /* set color-format releated fields in BITMAPINFO: */
  345.     lpHXbi->bmiHeader.biCompression = lpcidd->dwFourCC;
  346.     lpHXbi->bmiHeader.biBitCount    = (UINT16)lpcidd->dwBitCount;
  347.     /* set color masks: */
  348.     if (lpcidd->dwFlags & _BITMASK) {
  349.         /* get offset of color masks in the bitmap: */
  350.         ULONG32 *lpColors = (ULONG32*)&lpHXbi->un.dwBitMask[0];
  351.         lpColors[0] = lpcidd->dwBitMask[0];
  352.         lpColors[1] = lpcidd->dwBitMask[1];
  353.         lpColors[2] = lpcidd->dwBitMask[2];
  354.     }
  355.     /* success: */
  356.     return 0;
  357. }
  358. /*
  359.  * Calculates the size of an image with a given color format.
  360.  */
  361. static int ImageSize (int cid, ULONG32 dwWidth, ULONG32 dwHeight)
  362. {
  363.     int pitch, size;
  364.     /* do it in a lazy way: */
  365.     switch (cid) {
  366.         /* planar YUV 4:2:0 formats: */
  367.         case CID_I420:
  368.         case CID_YV12:
  369.             size = dwHeight * dwWidth * 3 / 2;
  370.             break;
  371.         /* YUV 9 format: */
  372.        case CID_YUVA:
  373.            size = (dwHeight * dwWidth) * 5 / 2;
  374.            break;
  375.         case CID_YVU9:
  376.             size = dwHeight * dwWidth * 9 / 8;
  377.             break;
  378.         /* packet YUV 4:2:2 formats: */
  379.         case CID_YUY2:
  380.         case CID_UYVY:
  381.             size = dwHeight * dwWidth * 2;
  382.             break;
  383.         /* RGB formats: */
  384.         case CID_RGB32:
  385.         case CID_ARGB32:
  386.         case CID_RGB24:
  387.         case CID_RGB565:
  388.         case CID_RGB555:
  389.         case CID_RGB8:
  390.         case CID_BGR32:
  391.         case CID_BGR24:
  392.         case CID_RGB32S:
  393.         case CID_RGB444:
  394.             pitch = dwWidth * ciddTbl[cid].nBPP;
  395.             pitch = (pitch + 3) & ~3;
  396.             size = dwHeight * pitch;
  397. break;
  398.         /* the other formats: */
  399.         default:
  400.             size = 0; /* no idea what size should be??? */
  401.     }
  402.     return size;
  403. }
  404. /*
  405.  * Get pitch of the bitmap image.
  406.  * Use:
  407.  *  int GetBitmapPitch (LPBITMAPINFO lpbi);
  408.  * Input:
  409.  *  lpbi - pointer to BITMAPINFO structure containing image format
  410.  * Returns:
  411.  *  !0 -- pitch of the bitmap image; <0 if bottom-up bitmap
  412.  *  0 - unrecognized bitmap format
  413.  */
  414. #ifdef _WIN32
  415. int GetBitmapPitch (LPBITMAPINFO lpbi)
  416. #else      
  417. int GetBitmapPitch (HXBitmapInfo* lpbi)
  418. #endif      
  419. {
  420.     register int cid, pitch;
  421.     /* check bitmap pointer & format: */
  422.     cid = GetBitmapColor (lpbi);
  423.     if (cid == CID_UNKNOWN || !(ciddTbl[cid].dwFlags & _BITMAP))
  424.         return 0;
  425.     if (cid == CID_XING)
  426.         return 768;
  427.     
  428.     /* calculate image pitch: */
  429.     pitch = lpbi->bmiHeader.biWidth * ciddTbl[cid].nBPP;
  430.     if (ciddTbl[cid].dwFlags & (_RGB|_BGR))
  431. #if defined(_MACINTOSH) || defined(_UNIX)
  432.         pitch = ((pitch + 3) & ~3);
  433. #else
  434.         pitch = -((pitch + 3) & ~3);
  435. #endif
  436.     /* return pitch: */
  437.     return pitch;
  438. }
  439. /*
  440.  * Get size of the bitmap image.
  441.  * Use:
  442.  *  int GetBitmapImageSize (LPBITMAPINFO lpbi);
  443.  * Input:
  444.  *  lpbi - pointer to BITMAPINFO structure containing image format
  445.  * Returns:
  446.  *  !0 -- size of the bitmap image
  447.  *  0 - unrecognized bitmap format
  448.  */
  449. #ifdef _WIN32
  450. int GetBitmapImageSize (LPBITMAPINFO lpbi)
  451. #else      
  452. int GetBitmapImageSize (HXBitmapInfo* lpbi)
  453. #endif      
  454. {
  455.     /* check bitmap pointer & format: */
  456.     register int cid = GetBitmapColor (lpbi);
  457.     if (cid == CID_UNKNOWN ||
  458.         !(ciddTbl[cid].dwFlags & _BITMAP) ||
  459.         lpbi->bmiHeader.biWidth <= 0 ||
  460.         lpbi->bmiHeader.biHeight <= 0 ||
  461.         lpbi->bmiHeader.biPlanes != 1)
  462.         return 0;
  463.     return ImageSize (cid, lpbi->bmiHeader.biWidth, lpbi->bmiHeader.biHeight);
  464. }
  465. /*
  466.  * Build a bitmap structure.
  467.  * Use:
  468.  *  int MakeBitmap (LPBITMAPINFO lpbi, int nBISize,
  469.  *   int cid, ULONG32 dwWidth, ULONG32 dwHeight, LPPALETTEENTRY lppe, int nColors);
  470.  * Input:
  471.  *  lpbi - pointer to BITMAPINFO structure to contain image format
  472.  *  nBISize - size of memory block allocated for BITMAPINFO structure
  473.  *  cid - color format to use for bitmap
  474.  *  dwWidth, dwHeight - image width/height
  475.  *  lppe, nColors - palette info
  476.  * Returns:
  477.  *  !0 - bitmap has been successfully created
  478.  *  0 - invalid bitmap parameters
  479.  */
  480. #ifdef _WIN32
  481. int MakeBitmap (LPBITMAPINFO lpbi, int nBISize,
  482.     int cid, ULONG32 dwWidth, ULONG32 dwHeight, LPPALETTEENTRY lppe, int nColors)
  483. #else
  484. int MakeBitmap(HXBitmapInfo* lpbi, int nBISize, int cid, ULONG32 dwWidth,
  485.                ULONG32 dwHeight, void* lppe, int nColors)
  486. #endif      
  487. {
  488.     const struct _greg* lpcidd;
  489.     int setPalette, bitmapinfoSize;
  490.     /* check input parameters: */
  491.     if (lpbi == NULL ||
  492.         cid < 0 || cid > NFORMATS || !(ciddTbl[cid].dwFlags & _BITMAP) ||
  493.         (lpcidd = ciddTbl[cid].lpBitmapCIDD) == NULL ||
  494.         (int)dwWidth <= 0 || (int)dwHeight <= 0)
  495.         return 0;
  496.     /* calculate bitmapinfo size: */
  497.     setPalette = 0;
  498. #ifdef _WIN32    
  499.     bitmapinfoSize = sizeof(BITMAPINFOHEADER);
  500. #else
  501.     bitmapinfoSize = sizeof(HXBitmapInfoHeader);
  502. #endif    
  503.     if (lpcidd->dwFlags & _BITMASK)
  504.         bitmapinfoSize += 3 * sizeof(ULONG32);
  505.     else
  506.     if ((lpcidd->dwFlags & (_FOURCC|_BITCOUNT)) == (_FOURCC|_BITCOUNT) &&
  507.         lpcidd->dwFourCC == BI_RGB && lpcidd->dwBitCount <= 8 &&
  508.         nColors) {
  509.         /* check palette parameters: */
  510.         if (lppe == NULL || nColors < 0 || nColors > 256)
  511.             return 0;
  512. #ifdef _WIN32        
  513.         bitmapinfoSize += nColors * sizeof(PALETTEENTRY);
  514.         setPalette = 1;
  515. #endif        
  516.     }
  517.     /* check if we have sufficient amount of memory: */
  518.     if (nBISize < bitmapinfoSize)
  519.         return 0;
  520.     /* initialize bitmapinfo structure: */
  521.     memset((void *)lpbi, 0, bitmapinfoSize);
  522. #ifdef _WIN32    
  523.     lpbi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  524. #else
  525.     lpbi->bmiHeader.biSize = sizeof(HXBitmapInfoHeader);
  526. #endif
  527.     
  528.     /* set image parameters: */
  529.     lpbi->bmiHeader.biWidth = dwWidth;
  530.     lpbi->bmiHeader.biHeight = dwHeight;
  531.     lpbi->bmiHeader.biPlanes = 1;
  532.     lpbi->bmiHeader.biSizeImage = ImageSize (cid, dwWidth, dwHeight);
  533.     /* set color format: */
  534.     SetBitmapColor (lpbi, cid);
  535. #ifdef _WIN32
  536.     /* set palette: */
  537.     if (setPalette)
  538.         SetBitmapPalette (lpbi, lppe, nColors);
  539. #endif
  540.     return bitmapinfoSize;  /* the number of bytes written */
  541. }
  542. #ifdef _WIN32
  543. #ifndef WINCE
  544. int SetDirectDrawColor (LPDDPIXELFORMAT lpddpf, int cid)
  545. {
  546.     LPCIDD lpcidd;
  547.     /* check input parameters: */
  548.     if (lpddpf == NULL ||
  549.         lpddpf->dwSize < sizeof(DDPIXELFORMAT) ||
  550.         cid < 0 || cid > NFORMATS || !(ciddTbl[cid].dwFlags & _DIRECTDRAW) ||
  551.         (lpcidd = ciddTbl[cid].lpDirectDrawCIDD) == NULL)
  552.         return -1;
  553.     /* set color-format releated fields in DDPIXELFORMAT: */
  554.     lpddpf->dwFourCC      = lpcidd->dwFourCC;
  555.     lpddpf->dwRGBBitCount = lpcidd->dwBitCount;
  556.     lpddpf->dwRBitMask    = lpcidd->dwBitMask[0];
  557.     lpddpf->dwGBitMask    = lpcidd->dwBitMask[1];
  558.     lpddpf->dwBBitMask    = lpcidd->dwBitMask[2];
  559.     /* set control flags: */
  560.     lpddpf->dwFlags = (lpddpf->dwFourCC == BI_RGB)? DDPF_RGB: DDPF_FOURCC;
  561.     /* success: */
  562.     return 0;
  563. }
  564. #endif
  565. /*
  566.  * Get bitmap palette.
  567.  * Use:
  568.  *  int GetBitmapPalette (LPBITMAPINFO lpbi, LPPALETTEENTRY lppe);
  569.  * Input:
  570.  *  lpbi - pointer to BITMAPINFO structure
  571.  *  lppe - pointer to a buffer to contain palette entries
  572.  * Returns:
  573.  *  the number of colors in palette
  574.  *  0, if bitmap does not use palette.
  575.  */
  576. int GetBitmapPalette (LPBITMAPINFO lpbi, LPPALETTEENTRY lppe)
  577. {
  578.     int i, n = 0;
  579.     /* check input parameters: */
  580.     if (lpbi != NULL && lppe != NULL &&
  581.         lpbi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) &&
  582.         lpbi->bmiHeader.biCompression == BI_RGB &&
  583.         lpbi->bmiHeader.biBitCount <= 8) {
  584.         /* get pointer to palette entries: */
  585.         RGBQUAD *prgb = (RGBQUAD*)((BYTE*)lpbi + lpbi->bmiHeader.biSize);
  586.         /* get number of entries to process: */
  587.         n = lpbi->bmiHeader.biClrUsed;
  588.         if (!n) n = 1U << lpbi->bmiHeader.biBitCount; /* !!! */
  589.         /* a DIB color table has its colors stored BGR not RGB
  590.          * so flip them around: */
  591.         for (i = 0; i < n; i ++) {
  592.             lppe[i].peRed   = prgb[i].rgbRed;
  593.             lppe[i].peGreen = prgb[i].rgbGreen;
  594.             lppe[i].peBlue  = prgb[i].rgbBlue;
  595.             lppe[i].peFlags = 0;
  596.         }
  597.     }
  598.     /* return # of colors extracted */
  599.     return n;
  600. }
  601. /*
  602.  * Set bitmap palette.
  603.  * Use:
  604.  *  int SetBitmapPalette (LPBITMAPINFO lpbi, LPPALETTEENTRY lppe, int n);
  605.  * Input:
  606.  *  lpbi - pointer to BITMAPINFO structure
  607.  *  lppe - pointer to a buffer containing palette entries
  608.  *  n    - the total number of colors in palette
  609.  * Returns:
  610.  *  the number of colors set
  611.  *  0, if bitmap does not use palette.
  612.  */
  613. int SetBitmapPalette (LPBITMAPINFO lpbi, LPPALETTEENTRY lppe, int nColors)
  614. {
  615.     int i, m, n = 0;
  616.     /* check input parameters: */
  617.     if (lpbi != NULL && lppe != NULL && nColors > 0 && nColors <= 256 &&
  618.         lpbi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) &&
  619.         lpbi->bmiHeader.biCompression == BI_RGB &&
  620.         lpbi->bmiHeader.biBitCount <= 8) {
  621.         /* get pointer to palette entries: */
  622.         RGBQUAD *prgb = (RGBQUAD*)((BYTE*)lpbi + lpbi->bmiHeader.biSize);
  623.         /* check the number of entries to copy: */
  624.         m = 1U << lpbi->bmiHeader.biBitCount; /* !!! */
  625.         n = nColors; if (n > m) n = m;
  626.         /* a DIB color table has its colors stored BGR not RGB
  627.          * so flip them around: */
  628.         for (i = 0; i < n; i ++) {
  629.             prgb[i].rgbRed      = lppe[i].peRed;
  630.             prgb[i].rgbGreen    = lppe[i].peGreen;
  631.             prgb[i].rgbBlue     = lppe[i].peBlue;
  632.             prgb[i].rgbReserved = 0;
  633.         }
  634.         /* set number of palette entries copied: */
  635.         if (i == m) i = 0;  /* !!! */
  636.         lpbi->bmiHeader.biClrUsed = i;
  637.         lpbi->bmiHeader.biClrImportant = i;
  638.     }
  639.     /* return # of colors set */
  640.     return n;
  641. }
  642. /*
  643.  * Check the validity of a bitmap structure.
  644.  * Use:
  645.  *  int CheckBitmap (LPBITMAPINFO lpbi);
  646.  * Input:
  647.  *  lpbi - pointer to BITMAPINFO structure to check
  648.  * Returns:
  649.  *  !0 - bitmap parameters are correct
  650.  *  0 - otherwise
  651.  */
  652. int CheckBitmap (LPBITMAPINFO lpbi)
  653. {
  654.     /* check bitmap pointer & format: */
  655.     register int cid = GetBitmapColor (lpbi);
  656.     if (cid == CID_UNKNOWN ||
  657.         !(ciddTbl[cid].dwFlags & _BITMAP) ||
  658.         lpbi->bmiHeader.biWidth <= 0 ||
  659.         lpbi->bmiHeader.biHeight <= 0 ||
  660.         lpbi->bmiHeader.biPlanes != 1 ||
  661.         lpbi->bmiHeader.biSizeImage != ImageSize (cid, lpbi->bmiHeader.biWidth, lpbi->bmiHeader.biHeight))
  662.         return 0;
  663.     /* check if image should contain a palette: */
  664.     if (lpbi->bmiHeader.biCompression == BI_RGB &&
  665.         lpbi->bmiHeader.biBitCount <= 8) {
  666.         /* check ## of palette entries: */
  667.         unsigned int m = 1U << lpbi->bmiHeader.biBitCount;
  668.         if (lpbi->bmiHeader.biClrUsed > m ||
  669.             lpbi->bmiHeader.biClrImportant > lpbi->bmiHeader.biClrUsed)
  670.             return 0;
  671.     } else /* no palette: */
  672.     if (lpbi->bmiHeader.biClrUsed != 0 ||
  673.         lpbi->bmiHeader.biClrImportant != 0)
  674.         return 0;
  675.     /* all tests passed... */
  676.     return 1;
  677. }
  678. #endif //_WIN32
  679. /* colormap.c -- end of file */