diff options
Diffstat (limited to 'third_party/BaseClasses/amvideo.cpp')
| -rw-r--r-- | third_party/BaseClasses/amvideo.cpp | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/third_party/BaseClasses/amvideo.cpp b/third_party/BaseClasses/amvideo.cpp new file mode 100644 index 00000000..42fe446d --- /dev/null +++ b/third_party/BaseClasses/amvideo.cpp @@ -0,0 +1,275 @@ +//------------------------------------------------------------------------------
+// File: AMVideo.cpp
+//
+// Desc: DirectShow base classes - implements helper functions for
+// bitmap formats.
+//
+// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.
+//------------------------------------------------------------------------------
+
+
+#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);
+}
|