minifmt.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:9k
源码类别:

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 "hxcom.h"
  36. #include "hlxclib/string.h"
  37. #include "hxtypes.h"
  38. #include "hxwintyp.h"
  39. #include "hxvsurf.h"
  40. #include "ciddefs.h"
  41. #include "minifmt.h"
  42. #define _FOURCC         1
  43. #define _BITCOUNT       2
  44. #define _BITMASK        4
  45. CFmtObj::CFmtObj()
  46.  :  m_pFmtList(NULL)
  47. {
  48.     CreateFmtList();
  49. }
  50. CFmtObj::~CFmtObj()
  51. {
  52.     DestroyFmtList();
  53. }
  54. int CFmtObj::MakeBitmap(HXBitmapInfo* lpbi,
  55.                         int nBISize, int cid,
  56.                         ULONG32 dwWidth, ULONG32 dwHeight,
  57.                         void* lppe, int nColors)
  58. {
  59.     int setPalette, bitmapinfoSize;
  60.     // check input parameters
  61.     if (!lpbi ||
  62.        (int)dwWidth <= 0 ||  (int)dwHeight <= 0 ||
  63.         !m_pFmtList)
  64.         return 0;
  65.     memset( lpbi, 0, sizeof(*lpbi) );
  66.     
  67.     // find entry
  68.     FmtEntry* p = FindEntry(cid);
  69.     if (!p)
  70.         return 0;
  71.     // calculate bitmapinfo size
  72.     setPalette = 0;
  73.     bitmapinfoSize = sizeof(HXBitmapInfoHeader);
  74.     if (p->dwFlags & _BITMASK)
  75.     {
  76.         bitmapinfoSize += 3 * sizeof(ULONG32);
  77.     }
  78.     else if ((p->dwFlags & (_FOURCC|_BITCOUNT)) == (_FOURCC|_BITCOUNT) &&
  79.               p->dwFourCC == BI_RGB && p->dwBitCount <= 8 &&
  80.               nColors)
  81.     {
  82.         // check palette parameters
  83.         if (lppe == NULL || nColors < 0 || nColors > 256)
  84.             return 0;
  85. #ifdef _WIN32        
  86.         bitmapinfoSize += nColors * sizeof(PALETTEENTRY);
  87.         setPalette = 1;
  88. #endif        
  89.     }
  90.     // check if we have sufficient amount of memory
  91.     if (nBISize < bitmapinfoSize)
  92.         return 0;
  93.     // initialize bitmapinfo structure
  94.     memset(lpbi, 0, bitmapinfoSize);
  95.     lpbi->bmiHeader.biSize = sizeof(HXBitmapInfoHeader);
  96.     // set image parameters
  97.     lpbi->bmiHeader.biWidth = dwWidth;
  98.     lpbi->bmiHeader.biHeight = dwHeight;
  99.     lpbi->bmiHeader.biPlanes = 1;
  100.     lpbi->bmiHeader.biSizeImage = ImageSize (cid, dwWidth, dwHeight);
  101.     // set color format
  102.     SetBitmapColor (lpbi, cid);
  103. #ifdef _WIN32
  104.     /* set palette: */
  105. //    if (setPalette)
  106. //        SetBitmapPalette (lpbi, lppe, nColors);
  107. #endif
  108.     
  109.     return bitmapinfoSize;  /* the number of bytes written */
  110. }
  111. int CFmtObj::SetBitmapColor(HXBitmapInfo* lpHXbi, int cid)
  112. {
  113.     // check input parameters
  114.     if (!lpHXbi || !m_pFmtList)
  115.         return -1;
  116.     // find entry
  117.     FmtEntry* p = FindEntry(cid);
  118.     if (!p)
  119.         return -1;
  120.     // set color-format releated fields in BITMAPINFO
  121.     lpHXbi->bmiHeader.biCompression = p->dwFourCC;
  122.     lpHXbi->bmiHeader.biBitCount    = (UINT16)p->dwBitCount;
  123.     // set color masks
  124.     if (p->dwFlags & _BITMASK)
  125.     {
  126.         // get offset of color masks in the bitmap
  127.         ULONG32 *lpColors = (ULONG32*)&lpHXbi->un.dwBitMask[0];
  128.         lpColors[0] = p->dwBitMask[0];
  129.         lpColors[1] = p->dwBitMask[1];
  130.         lpColors[2] = p->dwBitMask[2];
  131.     }
  132.     return 0;
  133. }
  134. int CFmtObj::ImageSize (int cid, ULONG32 dwWidth, ULONG32 dwHeight)
  135. {
  136.     FmtEntry* p = FindEntry(cid);
  137.     if (!p)
  138.         return 0;
  139.     
  140.     int pitch = dwWidth * p->dwBitCount / 8;
  141.     if (p->dwFlags & _BITCOUNT)
  142.         pitch = (pitch + 3) & ~3;
  143.     return dwHeight * pitch;
  144. }
  145. int CFmtObj::GetBitmapPitch (HXBitmapInfo* lpbi)
  146. {
  147.     register int cid, pitch;
  148.     // check bitmap pointer & format
  149.     cid = GetBitmapColor (lpbi);
  150.     
  151.     if (cid == -1)
  152.         return 0;
  153.     if (cid == CID_XING)
  154.         return 768;
  155.     
  156.     // find entry
  157.     FmtEntry* p = FindEntry(cid);
  158.     if (!p)
  159.         return 0;
  160.     
  161.     // calculate image pitch
  162.     pitch = lpbi->bmiHeader.biWidth * p->nBPP;
  163.     
  164.     if (cid == BI_RGB || cid == BI_BITFIELDS)
  165. #if defined(_MACINTOSH) || defined(_UNIX)
  166.         pitch = ((pitch + 3) & ~3);
  167. #else
  168.         pitch = -((pitch + 3) & ~3);
  169. #endif
  170.     // return pitch
  171.     return pitch;
  172. }
  173. int CFmtObj::GetBitmapColor(HXBitmapInfo* lpHXbi)
  174. {
  175.     int cid = -1;
  176.     // check bitmap pointer/size
  177.     if (lpHXbi == NULL)
  178.         return CID_UNKNOWN;
  179.     // get bitmap parameters to compare
  180.     for (FmtEntry* p=m_pFmtList; p; p=p->pNext)
  181.     {
  182.         if (ChkColor (p, 
  183.                       lpHXbi->bmiHeader.biCompression,
  184.                       lpHXbi->bmiHeader.biBitCount, 
  185.                       (ULONG32*)&lpHXbi->un.dwBitMask[0]))
  186.         {
  187.             cid = p->cid;
  188.             break;
  189.         }
  190.     }
  191.     
  192.     return cid;
  193. }
  194. int CFmtObj::ChkColor (FmtEntry* p,
  195.                        ULONG32 dwFourCC,
  196.                        ULONG32 dwBitCount,
  197.                        ULONG32 *lpBitMask)
  198. {
  199.     // clear match flags
  200.     ULONG32 dwMatch = 0;
  201.     // check FourCC
  202.     if ((p->dwFlags & _FOURCC) && p->dwFourCC == dwFourCC)
  203.         dwMatch |= _FOURCC;
  204.     // check BitCount
  205.     if ((p->dwFlags & _BITCOUNT) && p->dwBitCount == dwBitCount)
  206.         dwMatch |= _BITCOUNT;
  207.     // check BitMasks
  208.     if ((p->dwFlags & _BITMASK) && lpBitMask &&
  209.          p->dwBitMask[0] == lpBitMask[0] &&
  210.          p->dwBitMask[1] == lpBitMask[1] &&
  211.          p->dwBitMask[2] == lpBitMask[2])
  212.          dwMatch |= _BITMASK;
  213.     // combine results
  214.     return dwMatch == p->dwFlags;
  215. }
  216. void CFmtObj::CreateFmtList()
  217. {
  218.     CreateFmtEntry( _FOURCC, MAKEFOURCC('I','4','2','0'),    CID_I420, 12, 1);
  219.     CreateFmtEntry( _FOURCC, MAKEFOURCC('Y', 'V', '1', '2'), CID_YV12, 12, 1);
  220.     CreateFmtEntry( _FOURCC, MAKEFOURCC('Y','U','Y','2'),    CID_YUY2, 16, 2);
  221.     CreateFmtEntry( _FOURCC, MAKEFOURCC('U', 'Y', 'V', 'Y'), CID_UYVY, 16, 2);
  222.     
  223.     CreateFmtEntry( _FOURCC+_BITCOUNT, BI_RGB,  CID_RGB32,   32, 4);
  224.     CreateFmtEntry( _FOURCC+_BITCOUNT, HX_ARGB, CID_ARGB32,  32, 4); 
  225.     CreateFmtEntry( _FOURCC+_BITCOUNT, BI_RGB,  CID_RGB24,   24, 3);
  226.     CreateFmtEntry( _FOURCC+_BITCOUNT, BI_RGB,  CID_RGB444,  12, 2);
  227.     
  228.     CreateFmtEntry( _FOURCC+_BITCOUNT+_BITMASK,BI_BITFIELDS, CID_RGB565, 16, 2, 0xF800,0x07E0,0x001F);
  229.     CreateFmtEntry( _FOURCC+_BITCOUNT+_BITMASK,BI_BITFIELDS, CID_RGB555, 16, 2, 0x7C00,0x03E0,0x001F);
  230.     CreateFmtEntry( _FOURCC+_BITCOUNT+_BITMASK,BI_BITFIELDS, CID_RGB444, 16, 2, 0x0F00,0x00F0,0x000F);
  231.         
  232. }
  233. void CFmtObj::DestroyFmtList()
  234. {
  235.     if (!m_pFmtList)
  236.         return;
  237.     for (FmtEntry* p=m_pFmtList; p; m_pFmtList=p)
  238.     {
  239.         p = p->pNext;
  240.         delete m_pFmtList;
  241.     }
  242. }
  243. FmtEntry* CFmtObj::CreateFmtEntry( ULONG32 dwFlags,
  244.                                    ULONG32 dwFourCC,
  245.                                    int     cid,
  246.                                    ULONG32 dwBitCount,
  247.                                    ULONG32 nBPP,
  248.                                    ULONG32 dwBitMask1,
  249.                                    ULONG32 dwBitMask2,
  250.                                    ULONG32 dwBitMask3
  251.                                    )
  252.  {
  253.     FmtEntry* pEntry = new FmtEntry;
  254.     
  255.     if (pEntry)
  256.     {
  257.         memset(pEntry, 0, sizeof(*pEntry));
  258.         if (!m_pFmtList)
  259.             m_pFmtList = pEntry;
  260.         else
  261.         {
  262.             FmtEntry* p;
  263.             for (p=m_pFmtList; p->pNext; p=p->pNext)
  264.                 ;
  265.             p->pNext = pEntry;
  266.         }
  267.     }
  268.     pEntry->dwFlags      = dwFlags;
  269.     pEntry->dwFourCC     = dwFourCC;
  270.     pEntry->cid          = cid;
  271.     pEntry->dwBitCount   = dwBitCount;
  272.     pEntry->nBPP         = nBPP;
  273.     pEntry->dwBitMask[0] = dwBitMask1;
  274.     pEntry->dwBitMask[1] = dwBitMask2;
  275.     pEntry->dwBitMask[2] = dwBitMask3;
  276.         
  277.     return pEntry;
  278. }
  279. FmtEntry* CFmtObj::FindEntry(int cid)
  280. {
  281.     FmtEntry* p;
  282.     for (p=m_pFmtList; p && p->cid != cid; p=p->pNext)
  283.         ;
  284.     
  285.     return p;
  286. }