archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/enduser/netmeeting/av/codecs/intel/h261/dxbase.cpp

1417 lines
44 KiB
Raw Permalink Blame History

/* *************************************************************************
** INTEL Corporation Proprietary Information
**
** This listing is supplied under the terms of a license
** agreement with INTEL Corporation and may not be copied
** nor disclosed except in accordance with the terms of
** that agreement.
**
** Copyright (c) 1995 Intel Corporation.
** All Rights Reserved.
**
** *************************************************************************
*/
//
// $Author: mbodart $
// $Date: 24 Mar 1997 15:00:34 $
// $Archive: S:\h26x\src\dec\dxbase.cpv $
// $Header: S:\h26x\src\dec\dxbase.cpv 1.46 24 Mar 1997 15:00:34 mbodart $
// $Log: S:\h26x\src\dec\dxbase.cpv $
//
// Rev 1.46 24 Mar 1997 15:00:34 mbodart
// Fix PVCS tracker bug 150 in the H.263 bug base: allow a change of
// dimensions in "redundant" DecompressBegin's.
//
// Rev 1.45 18 Mar 1997 16:21:10 MDUDA
// Commented out call to H263TermColorConvertor in DecompressEnd.
// This fixes a Graphedt problem where starts and stops cause a hang.
//
// Rev 1.44 18 Mar 1997 10:43:28 mbodart
// Quick one-line fix to previous change. Note that there are still problems
// in graphedt, when trying a bunch of play-pause-stop-play... combinations.
// We need to re-evaluate how DecompressBegin/DecompressEnd deal with
// memory allocation and initialization.
//
// Also rearranged some DbgLog messages in DecompressQuery to give more
// condensed information.
//
// Rev 1.43 14 Mar 1997 19:01:36 JMCVEIGH
// Removed H263TermDecoderInstance from DecompressEnd. Some apps.
// send a DecompressEnd, but then restart decompressing at the
// middle of the sequence (i.e., not a the previous keyframe). We
// therefore need to retain the reference frame. The instance is
// free in DrvClose.
//
// Rev 1.42 07 Mar 1997 09:07:42 mbodart
// Added a missing '#ifndef H261' in DecompressQuery.
// Added a call to _clearfp() in the Decompress exception handler, so that
// the exception will not reoccur in the caller's code.
//
// Rev 1.41 14 Jan 1997 11:16:22 JMCVEIGH
// Put flag for old still-frame mode backward compatibility under
// #ifdef H263P
//
// Rev 1.40 13 Jan 1997 10:51:14 JMCVEIGH
// Added NULL pointer checks in all functions that interface with
// application.
//
// Rev 1.39 10 Jan 1997 18:30:24 BECHOLS
// Changed decompress query so that it will accept negative heights.
//
// Rev 1.38 06 Jan 1997 17:40:24 JMCVEIGH
// Added support to ensure backward compatibility with old
// still-frame mode (crop CIF image to 320x240). Since 320x240 size
// is valid with arbitrary frame size support in H.263+, we check
// for this case by either comparing the source/destination header
// sizes or the source header size and the size contained in the
// picture header of the bitstream.
//
// Rev 1.37 03 Jan 1997 15:05:16 JMCVEIGH
// Re-inserted check in DecompressQuery that allows a H263 bitstream
// with frame dimensions 320x240 in non-prime decoder to be
// supported. This undos the elimination of this check in rev. 1.33.
//
// Rev 1.36 11 Dec 1996 16:02:34 MBODART
//
// In Decompress, catch any exceptions and return an error code. This gives
// upstream active movie filters a chance to recover gracefully.
//
// Rev 1.35 09 Dec 1996 18:02:10 JMCVEIGH
// Added support for arbitrary frame sizes.
//
// Rev 1.34 27 Nov 1996 13:55:18 MBODART
// Added a comment to DecompressQuery that explicitly enumerates the
// formats and transformations that H.261 supports.
//
// Rev 1.33 21 Nov 1996 17:27:18 MDUDA
// Disables YUV12 output zoom by 2 and removed 160x120, 240x180,
// and 320x240 acceptance of H263 input.
//
// Rev 1.32 15 Nov 1996 08:39:56 MDUDA
// Added 640x480 frame size for H263 and FOURCC_YUV12.
//
// Rev 1.31 14 Nov 1996 09:22:34 MBODART
// Disable the ability to select a DCI color convertor, they don't exist!
// However, DCI col. conv. initialization does exist, and differs from
// non-DCI initialization.
//
// Rev 1.30 13 Nov 1996 10:58:32 RHAZRA
// H.261 YUV12 decoder now accepts CIF, QCIF, 160x120, 320x240 and 640x480
//
// Rev 1.29 12 Nov 1996 08:47:12 JMCVEIGH
// Removed initial arbitrary frame size support, i.e., reverted back
// to rev 1.27. Will hold off on custom picture format support until
// branch for release candidate for PS 3.0.
//
// Rev 1.28 11 Nov 1996 11:51:14 JMCVEIGH
// Added initial support for arbitrary frame sizes (H.263+ draft,
// document LBC-96-263). Define H263P to allow frame sizes from
// 4 <= width <= 352 and 4 <= height <= 288, where both width and
// height are multiples of 4.
//
// Rev 1.27 20 Oct 1996 13:31:46 AGUPTA2
// Changed DBOUT into DbgLog. ASSERT is not changed to DbgAssert.
//
//
// Rev 1.26 26 Sep 1996 09:46:00 BECHOLS
//
// Turned on Snapshot for H263. This code merely sets up for the Snapshot
// copy, and waits on an event for the decoder to do the copy. When the
// event is signaled, the Snapshot trigger wakes up and returns the status
// of the copy to the caller.
//
// Rev 1.25 25 Sep 1996 17:30:32 BECHOLS
// changed the snapshot code to wait on an event while the decoder
// does the snapshot copy.
//
// Rev 1.24 24 Sep 1996 13:51:42 BECHOLS
//
// Added Snapshot() implementation.
//
// Rev 1.23 03 Sep 1996 16:29:22 CZHU
// enable DDRAW, removed define
//
// Rev 1.22 18 Jul 1996 09:24:36 KLILLEVO
// implemented YUV12 color convertor (pitch changer) in assembly
// and added it as a normal color convertor function, via the
// ColorConvertorCatalog() call.
//
// Rev 1.21 01 Jul 1996 10:05:10 RHAZRA
//
// Turn off aspect ratio correction for YUY2 color conversion.
//
// Rev 1.20 19 Jun 1996 16:38:54 RHAZRA
//
// Added a #ifdef to coditionally disable DDRAW (YUY2) support
//
// Rev 1.19 19 Jun 1996 14:26:28 RHAZRA
// Added code to (i) accept YUY2 as a valid output format (ii) select
// YUY2 color convertor in SelectColorConvertor()
//
// Rev 1.18 30 May 1996 17:08:52 RHAZRA
// Added SQCIF support for H263.
//
// Rev 1.17 30 May 1996 15:16:38 KLILLEVO
// added YUV12 output
//
// Rev 1.16 30 May 1996 10:13:00 KLILLEVO
//
// removed one cluttering debug statement
//
// Rev 1.15 01 Apr 1996 10:26:34 BNICKERS
// Add YUV12 to RGB32 color convertors. Disable IF09.
//
// Rev 1.14 09 Feb 1996 10:09:22 AKASAI
// Added ifndef RING0 around code in DecompressGetPalette to eliminate
// warning in building RING0 release version of codec.
//
// Rev 1.13 11 Jan 1996 16:59:14 DBRUCKS
//
// cleaned up DecompressQuery
// added setting of bProposedCorrectAspectRatio (in Query) and
// bCorrectAspectRatio (in Begin) if the source dimensions are SQCIF,
// QCIF, or CIF and the destination dimensions are the aspect ratio
// sizes with a possible zoom by two.
//
// Rev 1.12 18 Dec 1995 12:51:38 RMCKENZX
// added copyright notice
//
// Rev 1.11 13 Dec 1995 13:22:54 DBRUCKS
//
// Add assertions to verify that the source size is not changing on
// a begin.
//
// Rev 1.10 07 Dec 1995 13:02:52 DBRUCKS
// fix spx release build
//
// Rev 1.9 17 Nov 1995 15:22:30 BECHOLS
//
// Added ring 0 stuff.
//
// Rev 1.8 15 Nov 1995 15:57:24 AKASAI
// Remove YVU9 from decompress and decompress_query.
// (Integration point)
//
// Rev 1.7 25 Oct 1995 18:12:36 BNICKERS
// Add YUV12 color convertors. Eliminate YUV9 looking glass support.
//
// Rev 1.6 17 Oct 1995 17:31:24 CZHU
//
// Fixed a bug in DecompressQuery related to YUV12
//
// Rev 1.5 18 Sep 1995 08:40:50 CZHU
//
// Added support for YUV12
//
// Rev 1.4 08 Sep 1995 12:11:12 CZHU
// Output compressed size for debugging
//
// Rev 1.3 25 Aug 1995 13:58:06 DBRUCKS
// integrate MRV R9 changes
//
// Rev 1.2 23 Aug 1995 12:25:12 DBRUCKS
// Turn on the color converters
//
// Rev 1.1 01 Aug 1995 12:27:38 DBRUCKS
// add PSC parsing
//
// Rev 1.0 31 Jul 1995 13:00:12 DBRUCKS
// Initial revision.
//
// Rev 1.0 17 Jul 1995 14:46:14 CZHU
// Initial revision.
//
// Rev 1.0 17 Jul 1995 14:14:26 CZHU
// Initial revision.
;////////////////////////////////////////////////////////////////////////////
#include "precomp.h"
extern BYTE PalTable[236*4];
#define WIDTHBYTES(bits) (((bits) + 31) / 32 * 4)
/***************************************************************************
*
* Build16bitModeID().
*
* given red, green and blue values showing their maximum value,
* count the bits standing and then form a decimal digit which lists
* the number of red bits in the hundreds position, green in the tens
* position and blue in the ones position.
*
* This code is used when the RGB16 table is built so the correct
* field size will be used.
*
* returns the 16 bit mode ID
*
* Prototype in rgb16cct.h
*
***************************************************************************/
int Build16bitModeID(I32 red, I32 green, I32 blue)
{
int rval;
int Rbits, Gbits, Bbits;
U32 i;
for (Rbits = 0,i = 1; i < (1L << 30); i = i << 1)
Rbits += (red & i) ? 1 : 0;
for (Gbits = 0,i = 1; i < (1L << 30); i = i << 1)
Gbits += (green & i) ? 1 : 0;
for (Bbits = 0,i = 1; i < (1L << 30); i = i << 1)
Bbits += (blue & i) ? 1 : 0;
rval = Rbits * 100 + Gbits * 10 + Bbits;
return(rval);
}
/***********************************************************************
* SelectConvertor(LPDECINST, BOOL);
* History: 03/18/94 -BEN-
***********************************************************************/
static UINT SelectConvertor(
LPDECINST lpInst,
LPBITMAPINFOHEADER lpbiDst,
BOOL bIsDCI)
{
UINT uiCnvtr = 0xFFFF;
DWORD FAR * pDW = (DWORD FAR *)((LPBYTE)lpbiDst+sizeof(BITMAPINFOHEADER));
int RequestedMode;
/* Force off the DCI color converters because we can not be sure that the
* archive data has not changed.
* Also, we have no DCI color convertors, so don't select one!
*/
bIsDCI = 0;
switch(lpInst->outputDepth)
{
case 12:
if ((lpbiDst->biCompression == FOURCC_YUV12) || (lpbiDst->biCompression == FOURCC_IYUV))
{
DBOUT("SelectConvertor:YUV12 selected \n");
uiCnvtr = YUV12NOPITCH; // YUV12 output
}
break;
case 8:
if (lpInst->UseActivePalette==0)
{
switch(lpInst->XScale)
{
case 1:
if(bIsDCI == TRUE)
{
uiCnvtr = CLUT8DCI;
DBOUT("SelectConvertor:CLUT8DCI selected \n");
}
else
{
DBOUT("SelectConvertor:CLUT8 selected \n");
uiCnvtr = CLUT8;
}
break;
case 2:
if(bIsDCI == TRUE)
{
DBOUT("SelectConvertor:CLUT8DCIx2 selected \n");
uiCnvtr = CLUT8ZoomBy2DCI;
}
else
{
uiCnvtr = CLUT8ZoomBy2;
DBOUT("SelectConvertor:CLUT8x2 selected \n");
}
break;
}
}
else
{
switch(lpInst->XScale)
{
case 1:
if(bIsDCI == TRUE)
{
DBOUT("SelectConvertor:CLUT8APDCI selected \n");
uiCnvtr = CLUT8APDCI;
}
else
{
DBOUT("SelectConvertor:CLUT8AP selected \n");
uiCnvtr = CLUT8APDCI;
}
break;
case 2:
if(bIsDCI == TRUE)
{
DBOUT("SelectConvertor:CLUT8APDCIx2 selected \n");
uiCnvtr = CLUT8APZoomBy2DCI;
}
else
{
DBOUT("SelectConvertor:CLUT8APDCIx2 selected \n");
uiCnvtr = CLUT8APZoomBy2DCI;
}
break;
}
}
break;
case 16:
// check which mode is
if (lpbiDst->biCompression == FOURCC_YUY2)
{
DBOUT("SelectConvertor:YUY2 selected \n");
uiCnvtr = YUY2DDRAW;
break;
}
else
{
if (lpbiDst->biCompression == BI_RGB)
RequestedMode = 555; /* default rgb16 mode */
else //if (lpbiDst->biCompression == BI_BITFIELDS)
RequestedMode = Build16bitModeID(pDW[0], pDW[1], pDW[2]);
switch (RequestedMode)
{
case 555:
switch(lpInst->XScale)
{
case 1:
DBOUT("SelectConvertor:RGB16,555 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB16555DCI;
else
uiCnvtr = RGB16555;
break;
case 2:
DBOUT("SelectConvertor:RGB16x2,555 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB16555ZoomBy2DCI;
else
uiCnvtr = RGB16555ZoomBy2;
break;
} //end of 555
break;
case 664:
switch(lpInst->XScale)
{
case 1:
DBOUT("SelectConvertor:RGB16,664 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB16664DCI;
else
uiCnvtr = RGB16664;
break;
case 2:
DBOUT("SelectConvertor:RGB16x2,664 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB16664ZoomBy2DCI;
else
uiCnvtr = RGB16664ZoomBy2;
break;
} //end of 664
break;
case 565:
switch(lpInst->XScale)
{
case 1:
DBOUT("SelectConvertor:RGB16,565 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB16565DCI;
else
uiCnvtr = RGB16565;
break;
case 2:
DBOUT("SelectConvertor:RGB16x2,565 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB16565ZoomBy2DCI;
else
uiCnvtr = RGB16565ZoomBy2;
break;
} //end of 565
break;
case 655:
switch(lpInst->XScale)
{
case 1:
DBOUT("SelectConvertor:RGB16,655 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB16655DCI;
else
uiCnvtr = RGB16655;
break;
case 2:
DBOUT("SelectConvertor:RGB16x2,655 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB16655ZoomBy2DCI;
else
uiCnvtr = RGB16655ZoomBy2;
break;
} //end of 655
break;
default:
break;
} // switch
} // else
break;
case 24:
switch(lpInst->XScale)
{
case 1:
DBOUT("SelectConvertor:RGB24 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB24DCI;
else
uiCnvtr = RGB24;
break;
case 2:
DBOUT("SelectConvertor:RGB24x2 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB24ZoomBy2DCI;
else
uiCnvtr = RGB24ZoomBy2;
break;
}
break;
case 32:
switch(lpInst->XScale)
{
case 1:
DBOUT("SelectConvertor:RGB32 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB32DCI;
else
uiCnvtr = RGB32;
break;
case 2:
DBOUT("SelectConvertor:RGB32x2 selected \n");
if(bIsDCI == TRUE)
uiCnvtr = RGB32ZoomBy2DCI;
else
uiCnvtr = RGB32ZoomBy2;
break;
}
break;
}
return(uiCnvtr);
}
/***********************************************************************
* DWORD PASCAL DecompressQuery(LPDECINST, ICDECOMPRESSEX FAR *, BOOL);
* History: 02/18/94 -BEN-
*
* The following table summarizes the transformations that the H.261 decoder
* and I420 color convertor support.
*
* H.261 Decoder Inputs and Outputs
*
+--------------------------+-------------------------------------------------+
| Input Format | Supported Output Formats for this Input Format |
+--------------------------+-------------------------------------------------+
| H.261 FCIF (352 x 288) | 352 x 288 RGBnn, YUV12 or YUY2 |
| or | 352 x 264 RGBnn (aspect ratio correction) |
| YUV12 FCIF (352 x 288) | 704 x 576 RGBnn (zoom by 2) |
| | 704 x 528 RGBnn (zoom by 2, aspect ratio corr.) |
+--------------------------+-------------------------------------------------+
| H.261 QCIF (176 x 144) | 176 x 144 RGBnn, YUV12 or YUY2 |
| or | 176 x 132 RGBnn (aspect ratio correction) |
| YUV12 QCIF (176 x 144) | 352 x 288 RGBnn (zoom by 2) |
| | 352 x 264 RGBnn (zoom by 2, aspect ratio corr.) |
+--------------------------+-------------------------------------------------+
| YUV12 640 x 480 | 640 x 480 RGBnn, YUV12 or YUY2 |
| | 1280 x 960 RGBnn (zoom by 2) |
+--------------------------+-------------------------------------------------+
| YUV12 320 x 240 | 320 x 240 RGBnn, YUV12 or YUY2 |
| | 640 x 480 RGBnn (zoom by 2) |
+--------------------------+-------------------------------------------------+
| YUV12 160 x 120 | 160 x 120 RGBnn, YUV12 or YUY2 |
| | 320 x 240 RGBnn (zoom by 2) |
+--------------------------+-------------------------------------------------+
*
* Notes:
* o RGBnn represents RGB8, RGB16, RGB24 and RGB32.
* o Zoom by 2 and aspect ratio correction are not supported with YUY2 and
* YUV12 *output*.
* o Aspect ratio correction on output is only supported
* when the *input* resolution is exactly QCIF or FCIF.
*
***********************************************************************/
DWORD PASCAL DecompressQuery(
LPDECINST lpInst,
ICDECOMPRESSEX FAR * lpicDecEx,
BOOL bIsDCI)
{
LPBITMAPINFOHEADER lpbiSrc;
LPBITMAPINFOHEADER lpbiDst;
int iSrcWidth;
int iSrcHeight;
int iDstWidth;
int iDstHeight;
BOOL bSupportedSrcDimensions;
if ((lpicDecEx == NULL) || (lpicDecEx->lpbiSrc == NULL))
return (DWORD)ICERR_ERROR;
// Set source and destination bitmap info headers
lpbiSrc = lpicDecEx->lpbiSrc;
lpbiDst = lpicDecEx->lpbiDst;
// Check the source dimensions
iSrcWidth = lpbiSrc->biWidth;
iSrcHeight = lpbiSrc->biHeight;
bSupportedSrcDimensions = FALSE;
if (lpbiSrc->biCompression == FOURCC_H263)
{
/* H261 supports CIF and QCIF
* H263 supports CIF, SQCIF, and QCIF.
* H263 also may need 160x120, 240x180, and 320x240 as Tom put special
* code into exbase to accept these.
*/
#ifdef H263P
/* H.263+ supports custom picture format with width [4,...,352],
* height [4,...,288], and both a multiple of 4.
*/
if ((iSrcWidth <= 352 && iSrcHeight <= 288) &&
(iSrcWidth >= 4 && iSrcHeight >= 4) &&
(iSrcWidth & ~3) == iSrcWidth &&
(iSrcHeight & ~3) == iSrcHeight)
bSupportedSrcDimensions = TRUE;
#else
if ((iSrcWidth == 352 && iSrcHeight == 288) ||
#ifndef H261
(iSrcWidth == 128 && iSrcHeight == 96) ||
(iSrcWidth == 160 && iSrcHeight == 120) ||
(iSrcWidth == 240 && iSrcHeight == 180) ||
(iSrcWidth == 320 && iSrcHeight == 240) ||
#endif
(iSrcWidth == 176 && iSrcHeight == 144))
bSupportedSrcDimensions = TRUE;
#endif // H263P
}
else if ((lpbiSrc->biCompression == FOURCC_YUV12) || (lpbiSrc->biCompression == FOURCC_IYUV))
{
#ifndef H261
if (((iSrcWidth <= 352 && iSrcHeight <= 288) &&
(iSrcWidth >= 4 && iSrcHeight >= 4) &&
((iSrcWidth & ~3) == iSrcWidth) &&
((iSrcHeight & ~3) == iSrcHeight)) ||
(iSrcWidth == 640 && iSrcHeight == 480))
#else
if ((iSrcWidth == 352 && iSrcHeight == 288) ||
(iSrcWidth == 176 && iSrcHeight == 144) ||
(iSrcWidth == 160 && iSrcHeight == 120) ||
(iSrcWidth == 320 && iSrcHeight == 240) ||
(iSrcWidth == 640 && iSrcHeight == 480))
#endif
bSupportedSrcDimensions = TRUE;
}
if (! bSupportedSrcDimensions )
{
DBOUT("DecompressQuery:Unsupported src dimen \n");
return (DWORD)ICERR_UNSUPPORTED;
}
/* Stop if just querying input
*/
if (lpbiDst == NULL)
return ICERR_OK;
/* Check the bit depth
*/
switch (lpbiDst->biBitCount)
{
case 8:
DBOUT("Checking 8 bits \n");
if (lpbiDst->biCompression != BI_RGB)
return((DWORD)ICERR_BADFORMAT);
break;
case 12:
DBOUT("Checking 12 bits \n");
if ((lpbiDst->biCompression != FOURCC_YUV12) && (lpbiDst->biCompression != FOURCC_IYUV))
return((DWORD)ICERR_BADFORMAT);
break;
case 16:
DBOUT("Checking 16 bits ");
switch (lpicDecEx->lpbiDst->biCompression)
{
case BI_RGB:
DBOUT("DecompressQuery:BI_RGB \n");
break;
case BI_BITFIELDS:
DBOUT("DecompressQuery:BI_BITFIELDS \n");
break;
/*
* This definition of BI_BITMAP is here because MS has not provided
* a "standard" definition. When MS does provide it, it will likely be
* in compddk.h. At that time this definition should be removed.
*/
#define BI_BITMAP mmioFOURCC('B', 'I', 'T', 'M')
case BI_BITMAP:
DBOUT("Checking BI_BITMAP \n");
if (lpicDecEx->lpbiDst->biYPelsPerMeter != 0)
{
// output shouldn't cross a segment boundary in a scan line.
return((DWORD)ICERR_BADFORMAT);
}
break;
case FOURCC_YUY2:
DBOUT("DecompressQuery:YUY2 \n");
break;
default:
return((DWORD)ICERR_BADFORMAT);
} // switch biCompression
break;
case 24:
DBOUT("Checking 24 bits \n");
if (lpbiDst->biCompression != BI_RGB)
{
return((DWORD)ICERR_BADFORMAT);
}
break;
case 32:
DBOUT("Checking 32 bits \n");
if (lpbiDst->biCompression != BI_RGB)
{
return((DWORD)ICERR_BADFORMAT);
}
break;
default:
return((DWORD)ICERR_BADFORMAT);
break;
}
/*
if(lpbiDst->biCompression != BI_RGB && lpbiDst->biCompression != FOURCC_IF09) // check color space
{
#define BI_BITMAP mmioFOURCC('B', 'I', 'T', 'M')
if(lpbiDst->biCompression != BI_BITMAP)
return (DWORD)ICERR_UNSUPPORTED;
if(lpbiDst->biYPelsPerMeter != 0)
{
return (DWORD)ICERR_UNSUPPORTED;
}
}
*/
// Find the destination dimensions
if (bIsDCI == TRUE)
{
iDstWidth = lpicDecEx->dxDst;
iDstHeight = lpicDecEx->dyDst;
}
else
{
iDstWidth = lpbiDst->biWidth;
iDstHeight = lpbiDst->biHeight;
}
#ifdef _DEBUG
{
char buf80[80];
wsprintf(buf80,"Query destination %d,%d", iDstWidth, iDstHeight);
DBOUT(buf80);
}
#endif
// For the sake of the checks below, we need to take the absolute value
// of the destination height.
if(iDstHeight < 0)
{
iDstHeight = -iDstHeight;
}
// Check out the instance pointer
if (!lpInst)
return ICERR_ERROR;
#ifdef H263P
// Initialize flag that is used for backward compatibility with old still
// frame mode
lpInst->bCIFto320x240 = FALSE;
#endif
// Check the destination dimensions
if ((iSrcWidth == iDstWidth) && (iSrcHeight == iDstHeight))
{
lpInst->pXScale = lpInst->pYScale = 1;
lpInst->bProposedCorrectAspectRatio = FALSE;
}
else if ( ((iSrcWidth<<1) == iDstWidth) && ((iSrcHeight<<1) == iDstHeight) )
{
lpInst->pXScale = lpInst->pYScale = 2;
lpInst->bProposedCorrectAspectRatio = FALSE;
}
else if (
#ifndef H261
((iSrcWidth == 128) && (iSrcHeight == 96)) ||
#endif
((iSrcWidth == 176) && (iSrcHeight == 144)) ||
((iSrcWidth == 352) && (iSrcHeight == 288))
)
{
/* Support aspect ratio correction for SQCIF, QCIF, and CIF
*/
if ( (iSrcWidth == iDstWidth) && ((iSrcHeight*11/12) == iDstHeight) )
{
lpInst->pXScale = lpInst->pYScale = 1;
lpInst->bProposedCorrectAspectRatio = TRUE;
}
else if ( ((iSrcWidth<<1) == iDstWidth) &&
(((iSrcHeight<<1)*11/12) == iDstHeight) )
{
lpInst->pXScale = lpInst->pYScale = 2;
lpInst->bProposedCorrectAspectRatio = TRUE;
}
else
{
return(DWORD)ICERR_UNSUPPORTED;
}
}
else
{
return(DWORD)ICERR_UNSUPPORTED;
}
/* check color depth
*/
if(lpbiDst->biBitCount != 8 &&
lpbiDst->biBitCount != 16 &&
lpbiDst->biBitCount != 12 && // raw YUV12 output
lpbiDst->biBitCount != 24 &&
lpbiDst->biBitCount != 32)
{
return(DWORD)ICERR_UNSUPPORTED;
}
// Set the parameters
lpInst->xres = (WORD)lpbiSrc->biWidth;
lpInst->yres = (WORD)lpbiSrc->biHeight;
#if 0
/* aspect ratio correction with YUY2 is not available */
// It's supported now, for direct draw support under Active Movie.
if (lpInst && lpInst->bProposedCorrectAspectRatio &&
(lpbiDst->biCompression == FOURCC_YUY2))
{
return (DWORD)ICERR_UNSUPPORTED;
}
#endif
/* aspect ratio correction with YUV12 is not supported
*/
if (lpInst && lpInst->bProposedCorrectAspectRatio &&
((lpbiDst->biCompression == FOURCC_YUV12) || (lpbiDst->biCompression == FOURCC_IYUV)))
{
return (DWORD)ICERR_UNSUPPORTED;
}
/* No driver zooming in DirectDraw */
if ( lpInst && ((lpInst->pXScale == 2) && (lpInst->pYScale == 2)) &&
(lpbiDst->biCompression == FOURCC_YUY2) )
{
return (DWORD)ICERR_UNSUPPORTED;
}
/* No driver zooming for YUV12 */
if ( lpInst && ((lpInst->pXScale == 2) && (lpInst->pYScale == 2)) &&
((lpbiDst->biCompression == FOURCC_YUV12) || (lpbiDst->biCompression == FOURCC_IYUV)) )
{
return (DWORD)ICERR_UNSUPPORTED;
}
return (DWORD)ICERR_OK;
}
;////////////////////////////////////////////////////////////////////////////
;// Function: DWORD PASCAL DecompressGetPalette(LPDECINST, LPBITMAPINFOHEADER, LPBITMAPINFOHEADER);
;//
;// Description: Added header.
;//
;// History: 02/18/94 -BEN-
;////////////////////////////////////////////////////////////////////////////
DWORD PASCAL DecompressGetPalette(
LPDECINST lpInst,
LPBITMAPINFOHEADER lpbiSrc,
LPBITMAPINFOHEADER lpbiDst)
{
DWORD dw;
LPBYTE lpPalArea, PalStart;
#ifndef RING0
HDC hDC;
#endif
BYTE tmp;
int i;
// int iUseActivePalette;
ICDECOMPRESSEX icDecEx;
icDecEx.lpbiSrc = lpbiSrc;
icDecEx.lpbiDst = lpbiDst;
if(dw = DecompressQuery(lpInst, &icDecEx, FALSE))
return dw;
if (lpbiDst == NULL)
return (DWORD)ICERR_ERROR;
if(lpbiDst->biBitCount != 8)
{
DBOUT("DecompressGetPalette:ICERR_ERROR \n");
return (DWORD)ICERR_ERROR;
}
lpbiDst->biClrUsed = 256; /* specify all used */
lpbiDst->biClrImportant = 0;
#ifndef RING0
/* copy system palette entries (valid entries are 0-9 and 246-255) */
hDC = GetDC(NULL);
lpPalArea = (unsigned char FAR *)lpbiDst + (int)lpbiDst->biSize;
GetSystemPaletteEntries(hDC, 0, 256, (PALETTEENTRY FAR *)lpPalArea);
ReleaseDC(NULL, hDC);
#endif
/*
#ifdef DEBUG
iUseActivePalette = GetPrivateProfileInt("indeo", "UseActivePalette", 0, "system.ini");
if (iUseActivePalette) {
for (i = 0; i < 256; i++) {
tmp = *lpPalArea;
*lpPalArea = *(lpPalArea+2);
*(lpPalArea+2) = tmp;
lpPalArea += 4;
}
lpPalArea = (unsigned char FAR *)lpbiDst + (int)lpbiDst->biSize;
_fmemcpy(lpInst->ActivePalette, lpPalArea, sizeof(lpInst->ActivePalette));
lpInst->UseActivePalette = 1;
}
#endif
*/
if (!lpInst)
return ICERR_ERROR;
#ifndef RING0
if (lpInst->UseActivePalette == 1)
{
#ifdef WIN32
memcpy(lpPalArea,lpInst->ActivePalette, sizeof(lpInst->ActivePalette));
#else
_fmemcpy(lpPalArea,lpInst->ActivePalette, sizeof(lpInst->ActivePalette));
#endif
}
else
{
#endif
DBOUT("DecompressGetPalette \n");
PalStart = (LPBYTE)lpbiDst + (int)lpbiDst->biSize;
lpPalArea = PalStart + 40; // fill in starting from the 10th
for(i = 0; i < (236 << 2); i++)
*lpPalArea++ = PalTable[i];
lpPalArea = PalStart; // reverse r&b: dealing with DIBs
for(i = 0; i < 256; i++)// for all the entries,from PALENTRY to RGBQUAD
// fixed by CZHU, 1/23/95
{
tmp = *lpPalArea;
*lpPalArea = *(lpPalArea+2);
*(lpPalArea+2) = tmp;
lpPalArea+=4;
}
#ifndef RING0
}
#endif
return (DWORD)ICERR_OK;
}
/***********************************************************************
* DWORD PASCAL DecompressGetFormat(LPDECINST, LPBITMAPINFOHEADER,
* LPBITMAPINFOHEADER);
* Description: This allows us to suggest a good format to decompress to.
*
* History: 02/18/94 -BEN-
***********************************************************************/
DWORD PASCAL DecompressGetFormat(
LPDECINST lpInst,
LPBITMAPINFOHEADER lpbiSrc,
LPBITMAPINFOHEADER lpbiDst)
{
DWORD dw;
ICDECOMPRESSEX icDecEx;
LPBYTE lpPalArea;
int i;
BYTE tmp;
HDC hDC;
BOOL f8Bit;
// check input format - dont check output: being asked to give one back
icDecEx.lpbiSrc = lpbiSrc;
icDecEx.lpbiDst = NULL;
if(dw = DecompressQuery(lpInst, &icDecEx, FALSE))
return dw;
// If the current disply mode is 8 bit return a size large enough
// to hold a 256 palette after the BMIh
hDC = GetDC(NULL);
f8Bit = (8 == GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES));
ReleaseDC(NULL, hDC);
#ifdef FORCE_8BIT_OUTPUT // { FORCE_8BIT_OUTPUT
f8Bit = TRUE;
#endif // } FORCE_8BIT_OUTPUT
#if defined(FORCE_16BIT_OUTPUT) || defined(FORCE_24BIT_OUTPUT) // { if defined(FORCE_16BIT_OUTPUT) || defined(FORCE_24BIT_OUTPUT)
f8Bit = FALSE;
#endif // } if defined(FORCE_16BIT_OUTPUT) || defined(FORCE_24BIT_OUTPUT)
// if lpbiDst == NULL return size required to hold a output format
// (add palette size)
if (lpbiDst == NULL)
return(sizeof(BITMAPINFOHEADER) + (int)(f8Bit ? 1024 : 0));
if (lpbiSrc == NULL)
return (DWORD)ICERR_ERROR;
lpbiDst->biSize = sizeof(BITMAPINFOHEADER);
#ifdef FORCE_ZOOM_BY_2 // { FORCE_ZOOM_BY_2
lpbiDst->biWidth = lpbiSrc->biWidth << 1;
lpbiDst->biHeight = lpbiSrc->biHeight << 1;
#else // }{ FORCE_ZOOM_BY_2
lpbiDst->biWidth = lpbiSrc->biWidth;
lpbiDst->biHeight = lpbiSrc->biHeight;
#endif // } FORCE_ZOOM_BY_2
#ifdef FORCE_16BIT_OUTPUT // { FORCE_16BIT_OUTPUT
lpbiDst->biBitCount = 16;
#else // }{ FORCE_16BIT_OUTPUT
lpbiDst->biBitCount = (int)(f8Bit ? 8 : 24);
#endif // } FORCE_16BIT_OUTPUT
lpbiDst->biPlanes = 1;
lpbiDst->biCompression = BI_RGB;
lpbiDst->biXPelsPerMeter = 0;
lpbiDst->biYPelsPerMeter = 0;
lpbiDst->biSizeImage = (DWORD) WIDTHBYTES(lpbiDst->biWidth * lpbiDst->biBitCount) * lpbiDst->biHeight;
lpbiDst->biClrUsed = lpbiDst->biClrImportant = 0;
if (f8Bit)
{
// Copy the palette
lpPalArea = (LPBYTE)lpbiDst + sizeof(BITMAPINFOHEADER) + 40; // fill in starting from the 10th
for(i = 0; i < (236 << 2); i++)
*lpPalArea++ = PalTable[i];
lpPalArea = (LPBYTE)lpbiDst + sizeof(BITMAPINFOHEADER); // reverse r&b: dealing with DIBs
for(i = 0; i < 256; i++)// for all the entries,from PALENTRY to RGBQUAD
// fixed by CZHU, 1/23/95
{
tmp = *lpPalArea;
*lpPalArea = *(lpPalArea+2);
*(lpPalArea+2) = tmp;
lpPalArea+=4;
}
}
return ICERR_OK;
}
/**********************************************************************
* DWORD PASCAL DecompressBegin(LPDECINST, ICDECOMPRESSEX FAR *, BOOL)
* Description: Provides codec indication to prepare to receive
* decompress requests for a particular input to output
* conversion. Begins arrive asynchronously, and should
* result in the codec adapting to the changes specified,
* if any.
*
* History: 02/18/94 -BEN-
**********************************************************************/
DWORD PASCAL DecompressBegin(
LPDECINST lpInst,
ICDECOMPRESSEX FAR *lpicDecEx,
BOOL bIsDCI)
{
int CodecID;
DWORD dw;
UINT ClrCnvtr;
LPBITMAPINFOHEADER lpbiSrc;
LPBITMAPINFOHEADER lpbiDst;
// AviEdit tends to call ICDecompressBegin too soon...
if (!lpInst || !lpicDecEx)
return((DWORD)ICERR_ERROR);
// Set source and destination pointers
lpbiSrc = lpicDecEx->lpbiSrc;
lpbiDst = lpicDecEx->lpbiDst;
// at begin need to know input and output sizes
if (!lpbiSrc || !lpbiDst)
return((DWORD)ICERR_BADFORMAT);
if(lpInst->Initialized == TRUE)
{
/* We assume the source dimensions never change. If they do change
* we should terminate the instance because the allocations are
* based on dimensions. Until we add code to do that we need this
* assertion.
*/
ASSERT(lpInst->xres == (WORD)lpbiSrc->biWidth);
ASSERT(lpInst->yres == (WORD)lpbiSrc->biHeight);
if(lpbiDst != NULL)
{
if(dw = DecompressQuery(lpInst, lpicDecEx, bIsDCI))
{
return(dw); // error
}
else
{ // apply changes
lpInst->XScale = lpInst->pXScale;
lpInst->YScale = lpInst->pYScale;
lpInst->bCorrectAspectRatio = lpInst->bProposedCorrectAspectRatio;
lpInst->outputDepth = lpbiDst->biBitCount;
ClrCnvtr = SelectConvertor(lpInst,lpbiDst, bIsDCI);
if (ClrCnvtr != lpInst->uColorConvertor )
{
if((dw = H263TermColorConvertor(lpInst)) == ICERR_OK)
dw = H263InitColorConvertor(lpInst, ClrCnvtr);
lpInst->uColorConvertor=ClrCnvtr;
}
return(dw);
}
}
}
// first time begin - check if this is a format I like
if(dw = DecompressQuery(lpInst, lpicDecEx, bIsDCI))
{
return(dw); // error
}
else
{ // apply proposed format to 'current' format
lpInst->XScale = lpInst->pXScale;
lpInst->YScale = lpInst->pYScale;
lpInst->bCorrectAspectRatio = lpInst->bProposedCorrectAspectRatio;
lpInst->outputDepth = lpbiDst->biBitCount;
}
if (lpbiSrc->biCompression == FOURCC_H263)
{
CodecID = H263_CODEC;
}
else if ((lpbiSrc->biCompression == FOURCC_YUV12) || (lpbiSrc->biCompression == FOURCC_IYUV))
{
CodecID = YUV12_CODEC;
}
if(dw = H263InitDecoderInstance(lpInst, CodecID))
{
return(dw);
}
ClrCnvtr = SelectConvertor(lpInst, lpbiDst, bIsDCI);
dw = H263InitColorConvertor(lpInst, ClrCnvtr);
return(dw);
}
/**********************************************************************
* DWORD PASCAL Decompress(LPDECINST, ICDECOMPRESS FAR *, DWORD);
* History: 02/18/94 -BEN-
**********************************************************************/
DWORD PASCAL Decompress(
LPDECINST lpInst,
ICDECOMPRESSEX FAR *lpicDecEx,
DWORD dwSize,
BOOL bIsDCI)
{
DWORD ret = (DWORD) ICERR_ERROR;
// Check for NULL parameters
if ((lpInst == NULL) || (lpInst->Initialized != TRUE) || (lpicDecEx == NULL) ||
(lpicDecEx->lpbiSrc == NULL) || (lpicDecEx->lpbiDst == NULL))
goto done;
if ((lpicDecEx->lpbiSrc->biCompression == FOURCC_H263)
|| (lpicDecEx->lpbiSrc->biCompression == FOURCC_YUV12)
|| (lpicDecEx->lpbiSrc->biCompression == FOURCC_IYUV) )
{
try
{
ret = H263Decompress(lpInst, lpicDecEx, bIsDCI);
}
catch (...)
{
// For a DEBUG build, display a message and pass the exception up.
// For a release build, stop the exception here and return an error
// code. This gives upstream code a chance to gracefully recover.
// We also need to clear the floating point control word, otherwise
// the upstream code may incur an exception the next time it tries
// a floating point operation (presuming this exception was due
// to a floating point problem).
#if defined(DEBUG) || defined(_DEBUG)
DBOUT("Exception during H263Decompress!!!");
throw;
#else
_clearfp();
ret = (DWORD) ICERR_ERROR;
#endif
}
}
done:
return ret;
}
/**********************************************************************
* DWORD PASCAL DecompressEnd(LPDECINST);
* History: 02/18/94 -BEN-
**********************************************************************/
DWORD PASCAL DecompressEnd(LPDECINST lpInst)
{
if(lpInst && lpInst->Initialized == TRUE)
{
H263TermColorConvertor(lpInst);
H263TermDecoderInstance(lpInst);
}
return ICERR_OK;
}
/*****************************************************************************
*
* DecompressSetPalette() is called from the ICM_DECOMPRESS_SET_PALETTE
* message.
*
* Fill in the palette using lpParam1.
*
****************************************************************************/
DWORD PASCAL DecompressSetPalette(LPDECINST pinst,
LPBITMAPINFOHEADER lpbi,
LPBITMAPINFOHEADER unused)
{
int i;
unsigned char FAR * palette;
RGBQUAD FAR *palptr;
// Check for NULL parameter
if (pinst == NULL)
{
return (DWORD)ICERR_ERROR;
}
pinst->InitActivePalette = 0; /* must re-init AP at Begin */
pinst->UseActivePalette = 0; /* must re-init AP at Begin */
if (lpbi && (lpbi->biBitCount == 8 && lpbi->biCompression == 0))
{
palette = (unsigned char FAR *)lpbi + (int)lpbi->biSize;
// Check if palette passed is identity
for (i = 0*4, palptr = (RGBQUAD FAR *)PalTable; i < 236*4;
i += 4, palptr++)
{
if (palette[i+40] != palptr->rgbRed ||
palette[i+41] != palptr->rgbGreen ||
palette[i+42] != palptr->rgbBlue
)
break;
}
if (i < 236*4)
{ /* broke early - not the identity palette */
/* Actually RGBQUAD (BGR) format. */
if (
#ifdef WIN32
memcmp((unsigned char FAR *)pinst->ActivePalette, (unsigned char FAR *)lpbi + (int)lpbi->biSize, (int)lpbi->biClrUsed * sizeof(RGBQUAD)) == 0
#else
_fmemcmp((unsigned char FAR *)pinst->ActivePalette, (unsigned char FAR *)lpbi + (int)lpbi->biSize, (int)lpbi->biClrUsed * sizeof(RGBQUAD)) == 0
#endif
)
{ /* same as last palette - don't re-init AP */
DBOUT("current active palette");
pinst->UseActivePalette = 1;
pinst->InitActivePalette = 1;
}
else
{
DBOUT("new active palette");
#ifdef WIN32
memcpy((unsigned char FAR *)pinst->ActivePalette, (unsigned char FAR *)lpbi + (int)lpbi->biSize, (int)lpbi->biClrUsed * sizeof(RGBQUAD));
#else
_fmemcpy((unsigned char FAR *)pinst->ActivePalette, (unsigned char FAR *)lpbi + (int)lpbi->biSize, (int)lpbi->biClrUsed * sizeof(RGBQUAD));
#endif
pinst->UseActivePalette = 1;
}
}
else
{
DBOUT("DecompressSetPalette:fixed \n");
}
}
else
{
DBOUT("DecompressSetPalette:NULL fixed \n");
}
return ICERR_OK;
}
/**********************************************************************
* Added to support the IH26XSnapshot interface.
* The essence of this code is to set up the Snapshot fields in the Decoder
* Catalog and then wait on an Event for the Decoder to do the copy.
* Ben - 09/23/95
**********************************************************************/
DWORD PASCAL Snapshot(LPDECINST lpInst, LPVOID pvBuffer, DWORD dwTimeout)
{
DWORD dwReturn;
U8 FAR * P32Inst;
T_H263DecoderCatalog * DC = NULL;
UINT uiSZ_Snapshot;
int WaitCounter = 10; // Number of retries in case of slowness.
/* check the input pointers */
if(IsBadWritePtr( (LPVOID)lpInst, sizeof(DECINSTINFO) ))
{
DBOUT("Snapshot:Decoder instance invalid \n");
dwReturn = (DWORD)ICERR_BADPARAM;
goto SnapshotDone;
}
/* Lock the memory */
if(lpInst->pDecoderInst == NULL)
{
DBOUT("Snapshot:Decoder catalog invalid \n");
dwReturn = (DWORD)ICERR_MEMORY;
goto SnapshotDone;
}
/* Build the decoder catalog pointer */
P32Inst = (U8 FAR *) ((((U32) lpInst->pDecoderInst) + 31) & ~0x1F);
DC = (T_H263DecoderCatalog FAR *) P32Inst;
/* Check that input buffer is large enough for Snapshot */
uiSZ_Snapshot = (DC->uFrameWidth * DC->uFrameHeight * 12) >> 3;
if(IsBadWritePtr(pvBuffer, uiSZ_Snapshot))
{
DBOUT("Snapshot:Decoder buffer invalid \n");
dwReturn = (DWORD)ICERR_MEMORY;
goto SnapshotDone;
}
/* Check the Snapshot request flag. */
if(DC->SnapshotRequest)
{
DBOUT("Snapshot:in progress \n");
dwReturn = (DWORD)ICERR_ABORT;
goto SnapshotDone;
}
/*********************************************************************/
/* OK. Everything looks good. Lets set the pointer, trigger the copy */
/* and then wait on the event for the decoder to do the copy. */
/* IMPORTANT: the order of these next three statements makes a */
/* critical section unnecessary. */
ResetEvent(DC->SnapshotEvent); /* First ... */
DC->SnapshotBuffer = pvBuffer; /* Second ... */
DC->SnapshotRequest = SNAPSHOT_REQUESTED; /* Third ... */
/*********************************************************************/
SnapshotWait:
/*********************************************************************/
/* If wait is abondoned or a timeout occurs, but the Snapshot copy */
/* has started, I will loop back here up to WaitCounter times hoping */
/* hoping that the copy in progress will complete soon. */
/*********************************************************************/
dwReturn = WaitForSingleObject(DC->SnapshotEvent, dwTimeout);
/* Check result of wait. */
switch(dwReturn)
{
case WAIT_ABANDONED: // Non-Signaled
DBOUT("Snapshot:Wait abandoned \n");
if(DC->SnapshotRequest == SNAPSHOT_COPY_STARTED)
{
WaitCounter--;
if(WaitCounter)
{
goto SnapshotWait;
}
}
dwReturn = (DWORD)ICERR_ABORT;
break;
case WAIT_TIMEOUT: // Non-Signaled
DBOUT("Snapshot:Wait timeout \n");
if(DC->SnapshotRequest == SNAPSHOT_COPY_STARTED)
{
WaitCounter--;
if(WaitCounter)
{
goto SnapshotWait;
}
}
dwReturn = (DWORD)ICERR_ABORT;
break;
case WAIT_OBJECT_0: // Signaled - Yep, this is the good one!
DBOUT("Snapshot:Wait timeout 0\n");
switch(DC->SnapshotRequest)
{
case SNAPSHOT_COPY_REJECTED:
DBOUT("Snapshot:Copy rejected \n");
dwReturn = (DWORD)ICERR_ERROR;
break;
case SNAPSHOT_COPY_FINISHED:
DBOUT("Snapshot:Copy finished \n");
dwReturn = (DWORD)ICERR_OK;
break;
}
break;
default: // Call failed - This should be a WAIT_FAILED, but hey what the heck
DBOUT("Snapshot:Wait failed \n");
dwReturn = (DWORD)ICERR_ERROR;
break;
}
SnapshotDone:
if(NULL != DC)
{
DC->SnapshotRequest = 0;
}
return dwReturn;
}