~noskcaj/ubuntu/saucy/sflphone/merge-1.2.3-2

//------------------------------------------------------------------------------

// File: AMVideo.cpp

//

// Desc: DirectShow base classes - implements helper functions for

//       bitmap formats.

//

// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.

//------------------------------------------------------------------------------

#include <pjmedia-videodev/config.h>

#if defined(PJMEDIA_VIDEO_DEV_HAS_DSHOW) && PJMEDIA_VIDEO_DEV_HAS_DSHOW != 0

#include <streams.h>

#include <limits.h>

// These are bit field masks for true colour devices

const DWORD bits555[] = {0x007C00,0x0003E0,0x00001F};

const DWORD bits565[] = {0x00F800,0x0007E0,0x00001F};

const DWORD bits888[] = {0xFF0000,0x00FF00,0x0000FF};

// This maps bitmap subtypes into a bits per pixel value and also a

// name. unicode and ansi versions are stored because we have to

// return a pointer to a static string.

const struct {

    const GUID *pSubtype;

    WORD BitCount;

    CHAR *pName;

    WCHAR *wszName;

} BitCountMap[] =  { &MEDIASUBTYPE_RGB1,        1,   "RGB Monochrome",     L"RGB Monochrome",

                     &MEDIASUBTYPE_RGB4,        4,   "RGB VGA",            L"RGB VGA",

                     &MEDIASUBTYPE_RGB8,        8,   "RGB 8",              L"RGB 8",

                     &MEDIASUBTYPE_RGB565,      16,  "RGB 565 (16 bit)",   L"RGB 565 (16 bit)",

                     &MEDIASUBTYPE_RGB555,      16,  "RGB 555 (16 bit)",   L"RGB 555 (16 bit)",

                     &MEDIASUBTYPE_RGB24,       24,  "RGB 24",             L"RGB 24",

                     &MEDIASUBTYPE_RGB32,       32,  "RGB 32",             L"RGB 32",

                     &MEDIASUBTYPE_ARGB32,    32,  "ARGB 32",             L"ARGB 32",

                     &MEDIASUBTYPE_Overlay,     0,   "Overlay",            L"Overlay",

                     &GUID_NULL,                0,   "UNKNOWN",            L"UNKNOWN"

};

// Return the size of the bitmap as defined by this header

STDAPI_(DWORD) GetBitmapSize(const BITMAPINFOHEADER *pHeader)

{

    return DIBSIZE(*pHeader);

}

// This is called if the header has a 16 bit colour depth and needs to work

// out the detailed type from the bit fields (either RGB 565 or RGB 555)

STDAPI_(const GUID) GetTrueColorType(const BITMAPINFOHEADER *pbmiHeader)

{

    BITMAPINFO *pbmInfo = (BITMAPINFO *) pbmiHeader;

    ASSERT(pbmiHeader->biBitCount == 16);

    // If its BI_RGB then it's RGB 555 by default

    if (pbmiHeader->biCompression == BI_RGB) {

        return MEDIASUBTYPE_RGB555;

    }

    // Compare the bit fields with RGB 555

    DWORD *pMask = (DWORD *) pbmInfo->bmiColors;

    if (pMask[0] == bits555[0]) {

        if (pMask[1] == bits555[1]) {

            if (pMask[2] == bits555[2]) {

                return MEDIASUBTYPE_RGB555;

            }

        }

    }

    // Compare the bit fields with RGB 565

    pMask = (DWORD *) pbmInfo->bmiColors;

    if (pMask[0] == bits565[0]) {

        if (pMask[1] == bits565[1]) {

            if (pMask[2] == bits565[2]) {

                return MEDIASUBTYPE_RGB565;

            }

        }

    }

    return GUID_NULL;

}

// Given a BITMAPINFOHEADER structure this returns the GUID sub type that is

// used to describe it in format negotiations. For example a video codec fills

// in the format block with a VIDEOINFO structure, it also fills in the major

// type with MEDIATYPE_VIDEO and the subtype with a GUID that matches the bit

// count, for example if it is an eight bit image then MEDIASUBTYPE_RGB8

STDAPI_(const GUID) GetBitmapSubtype(const BITMAPINFOHEADER *pbmiHeader)

{

    ASSERT(pbmiHeader);

    // If it's not RGB then create a GUID from the compression type

    if (pbmiHeader->biCompression != BI_RGB) {

        if (pbmiHeader->biCompression != BI_BITFIELDS) {

            FOURCCMap FourCCMap(pbmiHeader->biCompression);

            return (const GUID) FourCCMap;

        }

    }

    // Map the RGB DIB bit depth to a image GUID

    switch(pbmiHeader->biBitCount) {

        case 1    :   return MEDIASUBTYPE_RGB1;

        case 4    :   return MEDIASUBTYPE_RGB4;

        case 8    :   return MEDIASUBTYPE_RGB8;

        case 16   :   return GetTrueColorType(pbmiHeader);

        case 24   :   return MEDIASUBTYPE_RGB24;

        case 32   :   return MEDIASUBTYPE_RGB32;

    }

    return GUID_NULL;

}

// Given a video bitmap subtype we return the number of bits per pixel it uses

// We return a WORD bit count as thats what the BITMAPINFOHEADER uses. If the

// GUID subtype is not found in the table we return an invalid USHRT_MAX

STDAPI_(WORD) GetBitCount(const GUID *pSubtype)

{

    ASSERT(pSubtype);

    const GUID *pMediaSubtype;

    INT iPosition = 0;

    // Scan the mapping list seeing if the source GUID matches any known

    // bitmap subtypes, the list is terminated by a GUID_NULL entry

    while (TRUE) {

        pMediaSubtype = BitCountMap[iPosition].pSubtype;

        if (IsEqualGUID(*pMediaSubtype,GUID_NULL)) {

            return USHRT_MAX;

        }

        if (IsEqualGUID(*pMediaSubtype,*pSubtype)) {

            return BitCountMap[iPosition].BitCount;

        }

        iPosition++;

    }

}

// Given a bitmap subtype we return a description name that can be used for

// debug purposes. In a retail build this function still returns the names

// If the subtype isn't found in the lookup table we return string UNKNOWN

int LocateSubtype(const GUID *pSubtype)

{

    ASSERT(pSubtype);

    const GUID *pMediaSubtype;

    INT iPosition = 0;

    // Scan the mapping list seeing if the source GUID matches any known

    // bitmap subtypes, the list is terminated by a GUID_NULL entry

    while (TRUE) {

        pMediaSubtype = BitCountMap[iPosition].pSubtype;

        if (IsEqualGUID(*pMediaSubtype,*pSubtype) ||

            IsEqualGUID(*pMediaSubtype,GUID_NULL)

            )

        {

            break;

        }

        iPosition++;

    }

    return iPosition;

}

STDAPI_(WCHAR *) GetSubtypeNameW(const GUID *pSubtype)

{

    return BitCountMap[LocateSubtype(pSubtype)].wszName;

}

STDAPI_(CHAR *) GetSubtypeNameA(const GUID *pSubtype)

{

    return BitCountMap[LocateSubtype(pSubtype)].pName;

}

#ifndef GetSubtypeName

#error wxutil.h should have defined GetSubtypeName

#endif

#undef GetSubtypeName

// this is here for people that linked to it directly; most people

// would use the header file that picks the A or W version.

STDAPI_(CHAR *) GetSubtypeName(const GUID *pSubtype)

{

    return GetSubtypeNameA(pSubtype);

}

// The mechanism for describing a bitmap format is with the BITMAPINFOHEADER

// This is really messy to deal with because it invariably has fields that

// follow it holding bit fields, palettes and the rest. This function gives

// the number of bytes required to hold a VIDEOINFO that represents it. This

// count includes the prefix information (like the rcSource rectangle) the

// BITMAPINFOHEADER field, and any other colour information on the end.

//

// WARNING If you want to copy a BITMAPINFOHEADER into a VIDEOINFO always make

// sure that you use the HEADER macro because the BITMAPINFOHEADER field isn't

// right at the start of the VIDEOINFO (there are a number of other fields),

//

//     CopyMemory(HEADER(pVideoInfo),pbmi,sizeof(BITMAPINFOHEADER));

//

STDAPI_(LONG) GetBitmapFormatSize(const BITMAPINFOHEADER *pHeader)

{

    // Everyone has this to start with this

    LONG Size = SIZE_PREHEADER + pHeader->biSize;

    ASSERT(pHeader->biSize >= sizeof(BITMAPINFOHEADER));

    // Does this format use a palette, if the number of colours actually used

    // is zero then it is set to the maximum that are allowed for that colour

    // depth (an example is 256 for eight bits). Truecolour formats may also

    // pass a palette with them in which case the used count is non zero

    // This would scare me.

    ASSERT(pHeader->biBitCount <= iPALETTE || pHeader->biClrUsed == 0);

    if (pHeader->biBitCount <= iPALETTE || pHeader->biClrUsed) {

        LONG Entries = (DWORD) 1 << pHeader->biBitCount;

        if (pHeader->biClrUsed) {

            Entries = pHeader->biClrUsed;

        }

        Size += Entries * sizeof(RGBQUAD);

    }

    // Truecolour formats may have a BI_BITFIELDS specifier for compression

    // type which means that room for three DWORDs should be allocated that

    // specify where in each pixel the RGB colour components may be found

    if (pHeader->biCompression == BI_BITFIELDS) {

        Size += SIZE_MASKS;

    }

    // A BITMAPINFO for a palettised image may also contain a palette map that

    // provides the information to map from a source palette to a destination

    // palette during a BitBlt for example, because this information is only

    // ever processed during drawing you don't normally store the palette map

    // nor have any way of knowing if it is present in the data structure

    return Size;

}

// Returns TRUE if the VIDEOINFO contains a palette

STDAPI_(BOOL) ContainsPalette(const VIDEOINFOHEADER *pVideoInfo)

{

    if (PALETTISED(pVideoInfo) == FALSE) {

        if (pVideoInfo->bmiHeader.biClrUsed == 0) {

            return FALSE;

        }

    }

    return TRUE;

}

// Return a pointer to the first entry in a palette

STDAPI_(const RGBQUAD *) GetBitmapPalette(const VIDEOINFOHEADER *pVideoInfo)

{

    if (pVideoInfo->bmiHeader.biCompression == BI_BITFIELDS) {

        return TRUECOLOR(pVideoInfo)->bmiColors;

    }

    return COLORS(pVideoInfo);

}

#endif /* PJMEDIA_VIDEO_DEV_HAS_DSHOW */