colormap.c

linux下的一款播放器

/* ***** BEGIN LICENSE BLOCK *****
 * Source last modified: $Id: colormap.c,v 1.6.24.1 2004/07/09 01:59:48 hubbe Exp $
 * 
 * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
 * 
 * The contents of this file, and the files included with this file,
 * are subject to the current version of the RealNetworks Public
 * Source License (the "RPSL") available at
 * http://www.helixcommunity.org/content/rpsl unless you have licensed
 * the file under the current version of the RealNetworks Community
 * Source License (the "RCSL") available at
 * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
 * will apply. You may also obtain the license terms directly from
 * RealNetworks.  You may not use this file except in compliance with
 * the RPSL or, if you have a valid RCSL with RealNetworks applicable
 * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
 * the rights, obligations and limitations governing use of the
 * contents of the file.
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL") in which case the provisions of the GPL are applicable
 * instead of those above. If you wish to allow use of your version of
 * this file only under the terms of the GPL, and not to allow others
 * to use your version of this file under the terms of either the RPSL
 * or RCSL, indicate your decision by deleting the provisions above
 * and replace them with the notice and other provisions required by
 * the GPL. If you do not delete the provisions above, a recipient may
 * use your version of this file under the terms of any one of the
 * RPSL, the RCSL or the GPL.
 * 
 * This file is part of the Helix DNA Technology. RealNetworks is the
 * developer of the Original Code and owns the copyrights in the
 * portions it created.
 * 
 * This file, and the files included with this file, is distributed
 * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
 * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
 * ENJOYMENT OR NON-INFRINGEMENT.
 * 
 * Technology Compatibility Kit Test Suite(s) Location:
 *    http://www.helixcommunity.org/content/tck
 * 
 * Contributor(s):
 * 
 * ***** END LICENSE BLOCK ***** */

#include "hxtypes.h"
#if defined(_WIN32) && !defined(_WINCE)
/* Windows include files: */
#include <windows.h>
#include <vfw.h>
#include <ddraw.h>
#include "hxtypes.h"
#elif defined(_WINCE)
#include "hxwintyp.h"
#include <windows.h>
#include "hxcom.h"
//#undef _WIN32
#include "hxvsurf.h"
#endif

#include "hxcom.h"
#include "hlxclib/string.h"
#include "hxtypes.h"
#include "hxwintyp.h"
#include "hxvsurf.h"

/* Color IDs:*/
#include "colormap.h"

/*
 * FOURCC codes (in addition to what is defined in wingdi.h):
 */

/* standard YUV formats: */
#define BI_I420         MAKEFOURCC('I','4','2','0') /* planar YCrCb   */
#define BI_YUVA         MAKEFOURCC('Y','U','V','A') /* planar YVU 420 plus alpha plane */
#define BI_YV12         MAKEFOURCC('Y','V','1','2') /* planar YVU 420 */
#define BI_YVU9         MAKEFOURCC('Y','V','U','9') /* planar YVU 420 */
#define BI_YUY2         MAKEFOURCC('Y','U','Y','2') /* packed YVU 422 */
#define BI_UYVY         MAKEFOURCC('U','Y','V','Y') /* packed YVU 422 */
#define BI_DVPF         MAKEFOURCC('D','V','P','F') /* planar YCrCb in structure */

/* Xing decoder's YUV format */
#define BI_XING         MAKEFOURCC('X','I','N','G')

/* MPEG-2 pre-decoded formats: */
#define BI_MC12         MAKEFOURCC('M','C','1','2') /* ATI MPEG-2 M/C */
#define BI_MCAM         MAKEFOURCC('M','C','A','M') /* ATI MPEG-2 M/C */
#define BI_MCS3         MAKEFOURCC('M','C','S','3') /* S3 MPEG-2 M/C  */
#define BI_IGOR         MAKEFOURCC('I','G','O','R') /* Intel i810 M/C */

/* RMA proprietary formats: */
#ifndef HXCOLOR_RGB3_ID
#define HXCOLOR_RGB3_ID     MAKEFOURCC('3','B','G','R') /* RGB-32 ??      */
#define HXCOLOR_RGB24_ID    MAKEFOURCC('B','G','R',' ') /* top-down RGB-24*/
#define HXCOLOR_RGB565_ID   MAKEFOURCC('6','B','G','R') /* RGB-16 565     */
#define HXCOLOR_RGB555_ID   MAKEFOURCC('5','B','G','R') /* RGB-16 555     */
#define HXCOLOR_8BIT_ID     MAKEFOURCC('T','I','B','8') /* RGB-8 w. pal-e */
#define HXCOLOR_YUV420_ID   MAKEFOURCC('2','V','U','Y') /* planar YCrCb   */
#define HXCOLOR_YUV411_ID   MAKEFOURCC('1','V','U','Y') /* ???            */
#define HXCOLOR_YUVRAW_ID   MAKEFOURCC('R','V','U','Y') /* ???            */
#endif

/*
 * Color format tables:
 */

/* control flags: */
#define _FOURCC   0x01
#define _BITCOUNT 0x02
#define _BITMASK  0x04

/* color format descriptor: */

struct _greg
{
    ULONG32 dwFlags;              /* indicates valid fields       */
    ULONG32 dwFourCC;             /* FourCC code                  */
    ULONG32 dwBitCount;           /* number of bits/pixel         */
    ULONG32 dwBitMask [3];        /* RGB bit masks                */
};

typedef struct _greg  CIDD;
typedef struct _greg* LPCIDD;

/* color format descriptors to use with YUV bitmaps: */
static const CIDD ciddI420      = {_FOURCC,                    BI_I420,       12, {       0,        0,        0}};
static const CIDD ciddYUVA      = {_FOURCC,                    BI_YUVA,       20, {       0,        0,        0}};
static const CIDD ciddYV12      = {_FOURCC,                    BI_YV12,       12, {       0,        0,        0}};
static const CIDD ciddYVU9      = {_FOURCC,                    BI_YVU9,        9, {       0,        0,        0}};
static const CIDD ciddYUY2      = {_FOURCC,                    BI_YUY2,       16, {       0,        0,        0}};
static const CIDD ciddUYVY      = {_FOURCC,                    BI_UYVY,       16, {       0,        0,        0}};
static const CIDD ciddDVPF      = {_FOURCC,                    BI_DVPF,       12, {       0,        0,        0}};
static const CIDD ciddXING      = {_FOURCC,                    BI_XING,       16, {       0,        0,        0}};


/* color format descriptors to use with GDI RGB bitmaps: */
static const CIDD ciddBmpRGB32  = {_FOURCC+_BITCOUNT,          BI_RGB,        32, {       0,        0,        0}};
static const CIDD ciddBmpARGB32 = {_FOURCC+_BITCOUNT,          HX_ARGB,      32, {       0,        0,        0}};
static const CIDD ciddBmpRGB24  = {_FOURCC+_BITCOUNT,          BI_RGB,        24, {       0,        0,        0}};
static const CIDD ciddBmpRGB565 = {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,  16, {  0xF800,   0x07E0,   0x001F}};
static const CIDD ciddBmpRGB555 = {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,  16, {  0x7C00,   0x03E0,   0x001F}};
static const CIDD ciddBmpRGB8   = {_FOURCC+_BITCOUNT,          BI_RGB,         8, {       0,        0,        0}};

/* color format descriptors to use with DirectDraw RGB surfaces: */
static const CIDD ciddDDrRGB32  = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        32, {0xFF0000, 0x00FF00, 0x0000FF}};
static const CIDD ciddDDrARGB32 = {_FOURCC+_BITCOUNT+_BITMASK, HX_ARGB,      32, {0xFF0000, 0x00FF00, 0x0000FF}};
static const CIDD ciddDDrRGB24  = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        24, {0xFF0000, 0x00FF00, 0x0000FF}};
static const CIDD ciddDDrRGB565 = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        16, {  0xF800,   0x07E0,   0x001F}};
static const CIDD ciddDDrRGB555 = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        16, {  0x7C00,   0x03E0,   0x001F}};
static const CIDD ciddDDrRGB8   = {_FOURCC+_BITCOUNT,          BI_RGB,         8, {       0,        0,        0}};

/* color format descriptors to use with BRG bitmaps: */
static const CIDD ciddBGR32     = {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,  32, {0x0000FF, 0x00FF00, 0xFF0000}};
static const CIDD ciddBGR24     = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        24, {0x0000FF, 0x00FF00, 0xFF0000}};

/* color format descriptors to use with QuickTime byte swapped formats: */
static const CIDD ciddRGB32S    = {_FOURCC+_BITCOUNT+_BITMASK, BI_RGB,        32, {0x00FF00, 0xFF0000, 0xFF000000}};

/* color format descriptors to use with embedded device formats: */
static const CIDD ciddRGB444    = {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,  16, {  0x0F00,   0x00F0,   0x000F}};

/* color format descriptors to use with MPEG bitmaps: */
static const CIDD ciddMC12      = {_FOURCC,                    BI_MC12,       12, {       0,        0,        0}};
static const CIDD ciddMCAM      = {_FOURCC,                    BI_MCAM,       12, {       0,        0,        0}};
static const CIDD ciddMCS3      = {_FOURCC,                    BI_MCS3,       12, {       0,        0,        0}};
static const CIDD ciddIGOR      = {_FOURCC,                    BI_IGOR,       12, {       0,        0,        0}};

/* non-standard descriptors we should support: */
struct _stColors
{
    int cid;                    /* image format ID              */
    CIDD  cidd;                 /* color format descriptor      */
};

static const struct _stColors ciddlOtherColors [] = {
    {CID_I420, {_FOURCC,                    HXCOLOR_YUV420_ID, 12, {         0,          0,          0}}},
    {CID_YUVA,              {_FOURCC,                    HXCOLOR_YUVA_ID,   20, {         0,          0,          0}}},
    {CID_RGB32,             {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,      32, {0xFF000000, 0x00FF0000, 0x0000FF00}}}, 
    {CID_RGB565,            {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,      16, {0x0000f800, 0x000007c0, 0x0000003e}}}, 
    {CID_RGB32,             {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,      32, {  0xFF0000,   0x00FF00,   0x0000FF}}},
    {CID_RGB32,             {_FOURCC+_BITCOUNT,          HXCOLOR_RGB3_ID,   32, {         0,          0,          0}}},
    {CID_RGB24,             {_FOURCC+_BITCOUNT+_BITMASK, BI_BITFIELDS,      24, {  0xFF0000,   0x00FF00,   0x0000FF}}},
    {CID_RGB24,             {_FOURCC+_BITCOUNT,          HXCOLOR_RGB3_ID,   24, {         0,          0,          0}}},
    {CID_RGB24,             {_FOURCC,                    HXCOLOR_RGB24_ID,  24, {         0,          0,          0}}},
    {CID_RGB565,            {_FOURCC,                    HXCOLOR_RGB565_ID, 16, {         0,          0,          0}}},
    {CID_RGB555,            {_FOURCC+_BITCOUNT,          BI_RGB,            16, {         0,          0,          0}}},
    {CID_RGB555,            {_FOURCC,                    HXCOLOR_RGB555_ID, 16, {         0,          0,          0}}},
    {CID_RGB8,              {_FOURCC,                    HXCOLOR_8BIT_ID,    8, {         0,          0,          0}}},
    {CID_UNKNOWN,           {0      ,                    0,                  0, {         0,          0,          0}}}
};

/* color format attributes: */
#define _BITMAP         0x0001  /* has bitmap descriptor        */
#define _DIRECTDRAW     0x0002  /* has DirectDraw descriptor    */
#define _RGB            0x0100  /* normal RGB format            */
#define _BGR            0x0200  /* B/R flipped RGB format       */
#define _YUV            0x0400  /* YUV format                   */
#define _MPEG           0x0800  /* MPEG pre-decoded format      */
#define _RGBS           0x1000  /* Byte swapped RGB format      */

/* the main color descriptors' table: */
struct _stColorTable
{
    ULONG32 dwFlags;               /* general format properties    */
    const struct _greg * lpBitmapCIDD;     /* bitmap format descriptor     */
    const struct _greg * lpDirectDrawCIDD; /* DirectDraw format descriptor */
    int     nBPP;                  /* bytes per pixel              */
};

static const struct _stColorTable  ciddTbl[NFORMATS] = {
    {_BITMAP+_YUV,              &ciddI420,      (const struct _greg*)NULL,    1}, /* CID_I420   */
    {_BITMAP+_DIRECTDRAW+_YUV,  &ciddYV12,      &ciddYV12,      1}, /* CID_YV12   */
    {_BITMAP+_DIRECTDRAW+_YUV,  &ciddYVU9,      &ciddYVU9,      1}, /* CID_YVU9   */
    {_BITMAP+_DIRECTDRAW+_YUV,  &ciddYUY2,      &ciddYUY2,      2}, /* CID_YUY2   */
    {_BITMAP+_DIRECTDRAW+_YUV,  &ciddUYVY,      &ciddUYVY,      2}, /* CID_UYVY   */
    {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB32,  &ciddDDrRGB32,  4}, /* CID_RGB32  */
    {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB24,  &ciddDDrRGB24,  3}, /* CID_RGB24  */
    {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB565, &ciddDDrRGB565, 2}, /* CID_RGB565 */
    {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB555, &ciddDDrRGB555, 2}, /* CID_RGB555 */
    {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpRGB8,   &ciddDDrRGB8,   1}, /* CID_RGB8   */
    {_BITMAP+_DIRECTDRAW+_YUV,  &ciddXING,      &ciddXING,      1}, /* CID_XING   */
    {_BITMAP+_DIRECTDRAW+_RGB,  &ciddBmpARGB32, &ciddDDrARGB32, 4}, /* CID_ARGB32 */
    {_BITMAP+_YUV,              &ciddYUVA,      NULL,           1}, /* CID_YUVA   */
    {_BITMAP+_YUV,              &ciddYUY2,      &ciddYUY2,      2}, /* CID_YUYU   */
    {0,                         NULL,           NULL,           0}, /* CID_UNKNOWN*/
    {_BITMAP+_BGR,              &ciddBGR32,     NULL,           4}, /* CID_BGR32  */
    {_BITMAP+_BGR,              &ciddBGR24,     NULL,           3}, /* CID_BGR24  */
    {_BITMAP+_RGBS,             &ciddRGB32S,    NULL,           4}, /* CID_RGB32S */
    {_BITMAP+_RGB,              &ciddRGB444,    NULL,           2}, /* CID_RGB444 */
    {_BITMAP+_DIRECTDRAW+_MPEG, &ciddMC12,      &ciddMC12,      1}, /* CID_MC12   */
    {_BITMAP+_DIRECTDRAW+_MPEG, &ciddMCAM,      &ciddMCAM,      1}, /* CID_MCAM   */
    {_BITMAP+_DIRECTDRAW+_MPEG, &ciddMCS3,      &ciddMCS3,      1}, /* CID_MCS3   */
    {_BITMAP+_DIRECTDRAW+_MPEG, &ciddIGOR,      &ciddIGOR,      1}, /* CID_IGOR   */
    {_BITMAP+_DIRECTDRAW+_YUV,  &ciddDVPF,      &ciddDVPF,      1}  /* CID_DVPF   */
};

                                                 
/*********************************
 *  _TEXT segment :-)
 *********************************/
int MapFourCCtoCID(ULONG32 dwFourCC)
{
    int i;

    //for (i=0; i<CID_UNKNOWN; i++)
    for (i=0; i<NFORMATS; i++)
    {
        if (ciddTbl[i].lpBitmapCIDD &&
            ciddTbl[i].lpBitmapCIDD->dwFourCC == dwFourCC)
	    {
	        return i;
	    }
    }

    return CID_UNKNOWN;
}

int MapCIDtoFourCC(ULONG32 CID)
{
    if (CID < NFORMATS)
        return ciddTbl[CID].lpBitmapCIDD->dwFourCC;
    else
        return 0;
}


/*
 * Check color format:
 */
static int ChkColor (const struct _greg* pcidd, ULONG32 dwFourCC, ULONG32 dwBitCount, ULONG32 *lpBitMask)
{
    /* clear match flags: */
    ULONG32 dwMatch = 0;

    /* check FourCC: */
    if ((pcidd->dwFlags & _FOURCC) && pcidd->dwFourCC == dwFourCC)
        dwMatch |= _FOURCC;

    /* check BitCount: */
    if ((pcidd->dwFlags & _BITCOUNT) && pcidd->dwBitCount == dwBitCount)
        dwMatch |= _BITCOUNT;

    /* check BitMasks: */
    if ((pcidd->dwFlags & _BITMASK) && lpBitMask &&
        pcidd->dwBitMask[0] == lpBitMask[0] &&
        pcidd->dwBitMask[1] == lpBitMask[1] &&
        pcidd->dwBitMask[2] == lpBitMask[2])
        dwMatch |= _BITMASK;

    /* combine results: */
    return dwMatch == pcidd->dwFlags;
}

/*
 * Get color format ID.
 * Use:
 *  int GetBitmapColor (LPBITMAPINFO lpbi);
 *  int GetDirectDrawColor (LPDDPIXELFORMAT lpddpf);
 * Input:
 *  lpbi - pointer to BITMAPINFO structure containing image format
 *  lpddpf - pointer to a DirectDraw DDPIXELFORMAT structure
 * Returns:
 *  ID of the specified format, if found;
 *  CID_UNKNOWN, if not supported.
 */
#ifdef _WIN32
int GetBitmapColor (LPBITMAPINFO lpbi)
#else
int GetBitmapColor (HXBitmapInfo* lpHXbi)
#endif
{
    ULONG32 dwFourCC, dwBitCount, *lpColors;
    register int i;

#ifdef _WIN32
    HXBitmapInfo* lpHXbi;

    if (!lpbi)
    {
	return CID_UNKNOWN;
    }
    lpHXbi = (HXBitmapInfo*) lpbi;
#endif

    /* check bitmap pointer/size... */
    if (lpHXbi == NULL)
        return CID_UNKNOWN;

    /* get bitmap parameters to compare: */
    dwFourCC = lpHXbi->bmiHeader.biCompression;
    dwBitCount = lpHXbi->bmiHeader.biBitCount;
    lpColors = (ULONG32*)&lpHXbi->un.dwBitMask[0];

    /* scan standard bitmap formats: */
    for (i=0; i<NFORMATS; i++)
        if ((ciddTbl[i].dwFlags & _BITMAP) && ciddTbl[i].lpBitmapCIDD &&
            ChkColor (ciddTbl[i].lpBitmapCIDD, dwFourCC, dwBitCount, lpColors))
            return i;
    
    /* scan our proprietary formats: */
    for (i=0; ; i++)
        if (ChkColor (&(ciddlOtherColors[i].cidd), dwFourCC, dwBitCount, lpColors))
            break;

    /* return color ID: */
    return ciddlOtherColors[i].cid;
}

#if defined(_WIN32) && !defined(WINCE)
int GetDirectDrawColor (LPDDPIXELFORMAT lpddpf)
{
    /* check bitmap pointer... */
    if (lpddpf != NULL && lpddpf->dwSize >= sizeof(DDPIXELFORMAT)) {

        /* scan DirectDraw formats: */
        register int i;
        for (i=0; i<NFORMATS; i++)
            if ((ciddTbl[i].dwFlags & _DIRECTDRAW) && ciddTbl[i].lpDirectDrawCIDD &&
                ChkColor (ciddTbl[i].lpDirectDrawCIDD, lpddpf->dwFourCC, lpddpf->dwRGBBitCount, &(lpddpf->dwRBitMask)))
                return i;
    }
    return CID_UNKNOWN;
}
#endif


/*
 * Set color format.
 * Use:
 *  void SetBitmapColor (LPBITMAPINFO lpbi, int cid);
 *  void SetDirectDrawColor (LPDDPIXELFORMAT lpddpf, int cid);
 * Input:
 *  lpbi - pointer to BITMAPINFO structure containing image format
 *  lpddpf - pointer to a DirectDraw DDPIXELFORMAT structure
 *  cid - color format to set
 * Returns:
 *  0, if success,
 *  !0 if wrong color format ID passed
 */
#ifdef _WIN32
int SetBitmapColor (LPBITMAPINFO lpbi, int cid)
#else
int SetBitmapColor (HXBitmapInfo* lpHXbi, int cid)
#endif
{
    const struct _greg* lpcidd;

#ifdef _WIN32
    HXBitmapInfo* lpHXbi;

    if (!lpbi)
    {
	return CID_UNKNOWN;
    }
    lpHXbi = (HXBitmapInfo*) lpbi;
#endif

    /* check input parameters: */
    if (lpHXbi == NULL ||