dlls/quartz/avidec.c - wine - Git at Google

 /*
  * Implements AVI Decompressor(CLSID_AVIDec).
  *
  * Copyright (C) Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */


 #include "config.h"

 #include "windef.h"
 #include "winbase.h"
 #include "wingdi.h"
 #include "winuser.h"
 #include "winerror.h"
 #include "vfw.h"
 #include "strmif.h"
 #include "control.h"
 #include "amvideo.h"
 #include "vfwmsgs.h"
 #include "uuids.h"

 #include "wine/debug.h"
 WINE_DEFAULT_DEBUG_CHANNEL(quartz);

 #include "quartz_private.h"
 #include "xform.h"


 static const WCHAR AVIDec_FilterName[] =
 {'A','V','I',' ','D','e','c','o','m','p','r','e','s','s','o','r',0};

 typedef struct CAVIDecImpl
 {
 	HIC hicCached;
 	HIC hicTrans;
 	AM_MEDIA_TYPE m_mtOut;
 	BITMAPINFO* m_pbiIn;
 	BITMAPINFO* m_pbiOut;
 	BYTE* m_pOutBuf;
 } CAVIDecImpl;

 /***************************************************************************
  *
  *	CAVIDecImpl methods
  *
  */

 static void AVIDec_ReleaseDIBBuffers(CAVIDecImpl* This)
 {
 	TRACE("(%p)\n",This);

 	if ( This->m_pbiIn != NULL )
 	{
 		QUARTZ_FreeMem(This->m_pbiIn); This->m_pbiIn = NULL;
 	}
 	if ( This->m_pbiOut != NULL )
 	{
 		QUARTZ_FreeMem(This->m_pbiOut); This->m_pbiOut = NULL;
 	}
 	if ( This->m_pOutBuf != NULL )
 	{
 		QUARTZ_FreeMem(This->m_pOutBuf); This->m_pOutBuf = NULL;
 	}
 }

 static BITMAPINFO* AVIDec_DuplicateBitmapInfo(const BITMAPINFO* pbi)
 {
 	DWORD dwSize;
 	BITMAPINFO*	pbiRet;

 	dwSize = pbi->bmiHeader.biSize;
 	if ( dwSize < sizeof(BITMAPINFOHEADER) )
 		return NULL;
 	if ( pbi->bmiHeader.biBitCount <= 8 )
 	{
 		if ( pbi->bmiHeader.biClrUsed == 0 )
 			dwSize += sizeof(RGBQUAD)*(1<<pbi->bmiHeader.biBitCount);
 		else
 			dwSize += sizeof(RGBQUAD)*pbi->bmiHeader.biClrUsed;
 	}
 	if ( pbi->bmiHeader.biCompression == 3 &&
 		 dwSize == sizeof(BITMAPINFOHEADER) )
 		dwSize += sizeof(DWORD)*3;

 	pbiRet = (BITMAPINFO*)QUARTZ_AllocMem(dwSize);
 	if ( pbiRet != NULL )
 		memcpy( pbiRet, pbi, dwSize );

 	return pbiRet;
 }

 static HRESULT AVIDec_Init( CTransformBaseImpl* pImpl )
 {
 	CAVIDecImpl*	This = pImpl->m_pUserData;

 	TRACE("(%p)\n",This);

 	if ( This != NULL )
 		return NOERROR;

 	This = (CAVIDecImpl*)QUARTZ_AllocMem( sizeof(CAVIDecImpl) );
 	if ( This == NULL )
 		return E_OUTOFMEMORY;
 	ZeroMemory( This, sizeof(CAVIDecImpl) );
 	pImpl->m_pUserData = This;
 	/* construct */
 	This->hicCached = (HIC)NULL;
 	This->hicTrans = (HIC)NULL;
 	ZeroMemory( &This->m_mtOut, sizeof(AM_MEDIA_TYPE) );
 	This->m_pbiIn = NULL;
 	This->m_pbiOut = NULL;
 	This->m_pOutBuf = NULL;

 	return NOERROR;
 }

 static HRESULT AVIDec_Cleanup( CTransformBaseImpl* pImpl )
 {
 	CAVIDecImpl*	This = pImpl->m_pUserData;

 	TRACE("(%p)\n",This);

 	if ( This == NULL )
 		return NOERROR;

 	/* destruct */
 	QUARTZ_MediaType_Free( &This->m_mtOut );

 	AVIDec_ReleaseDIBBuffers(This);

 	if ( This->hicCached != (HIC)NULL )
 		ICClose(This->hicCached);
 	if ( This->hicTrans != (HIC)NULL )
 		ICClose(This->hicTrans);

 	QUARTZ_FreeMem( This );
 	pImpl->m_pUserData = NULL;

 	return NOERROR;
 }

 static HRESULT AVIDec_CheckMediaType( CTransformBaseImpl* pImpl, const AM_MEDIA_TYPE* pmtIn, const AM_MEDIA_TYPE* pmtOut )
 {
 	CAVIDecImpl*	This = pImpl->m_pUserData;
 	BITMAPINFO*	pbiIn = NULL;
 	BITMAPINFO*	pbiOut = NULL;
 	HIC	hic;

 	TRACE("(%p)\n",This);
 	if ( This == NULL )
 		return E_UNEXPECTED;

 	if ( !IsEqualGUID( &pmtIn->majortype, &MEDIATYPE_Video ) )
 		return E_FAIL;
 	if ( !IsEqualGUID( &pmtIn->formattype, &FORMAT_VideoInfo ) )
 		return E_FAIL;
 	pbiIn = (BITMAPINFO*)(&((VIDEOINFOHEADER*)pmtIn->pbFormat)->bmiHeader);
 	if ( pmtOut != NULL )
 	{
 		if ( !IsEqualGUID( &pmtOut->majortype, &MEDIATYPE_Video ) )
 			return E_FAIL;
 		if ( !IsEqualGUID( &pmtOut->formattype, &FORMAT_VideoInfo ) )
 			return E_FAIL;
 		pbiOut = (BITMAPINFO*)(&((VIDEOINFOHEADER*)pmtOut->pbFormat)->bmiHeader);
 	}

 	if ( This->hicCached != (HIC)NULL &&
 		 ICDecompressQuery( This->hicCached, pbiIn, pbiOut ) == ICERR_OK )
 	{
 		TRACE("supported format\n");
 		return NOERROR;
 	}

 	TRACE("try to find a decoder...\n");
 	hic = ICLocate(
 		mmioFOURCC('V','I','D','C'), 0,
 		&pbiIn->bmiHeader, &pbiOut->bmiHeader, ICMODE_DECOMPRESS );
 	if ( hic == (HIC)NULL )
 	{
 		WARN("no decoder for %c%c%c%c\n",
 			(int)(( pbiIn->bmiHeader.biCompression >>  0 ) & 0xff),
 			(int)(( pbiIn->bmiHeader.biCompression >>  8 ) & 0xff),
 			(int)(( pbiIn->bmiHeader.biCompression >> 16 ) & 0xff),
 			(int)(( pbiIn->bmiHeader.biCompression >> 24 ) & 0xff) );
 		return E_FAIL;
 	}
 	TRACE("found\n");

 	if ( This->hicCached != (HIC)NULL )
 		ICClose(This->hicCached);
 	This->hicCached = hic;

 	return NOERROR;
 }

 static HRESULT AVIDec_GetOutputTypes( CTransformBaseImpl* pImpl, const AM_MEDIA_TYPE* pmtIn, const AM_MEDIA_TYPE** ppmtAcceptTypes, ULONG* pcAcceptTypes )
 {
 	CAVIDecImpl*	This = pImpl->m_pUserData;
 	HRESULT hr;
 	LONG cbFmt;
 	BITMAPINFO*	pbiIn = NULL;
 	BITMAPINFO*	pbiOut = NULL;

 	TRACE("(%p)\n",This);
 	hr = AVIDec_CheckMediaType( pImpl, pmtIn, NULL );
 	if ( FAILED(hr) )
 		return hr;

 	TRACE("(%p) - get size of format\n",This);
 	pbiIn = (BITMAPINFO*)(&((VIDEOINFOHEADER*)pmtIn->pbFormat)->bmiHeader);
 	cbFmt = (LONG)ICDecompressGetFormatSize( This->hicCached, pbiIn );
 	if ( cbFmt < sizeof(BITMAPINFOHEADER) )
 		return E_FAIL;

 	QUARTZ_MediaType_Free( &This->m_mtOut );
 	ZeroMemory( &This->m_mtOut, sizeof(AM_MEDIA_TYPE) );

 	memcpy( &This->m_mtOut.majortype, &MEDIATYPE_Video, sizeof(GUID) );
 	memcpy( &This->m_mtOut.formattype, &FORMAT_VideoInfo, sizeof(GUID) );
 	This->m_mtOut.cbFormat = sizeof(VIDEOINFOHEADER) + cbFmt + sizeof(RGBQUAD)*256;
 	This->m_mtOut.pbFormat = (BYTE*)CoTaskMemAlloc(This->m_mtOut.cbFormat);
 	if ( This->m_mtOut.pbFormat == NULL )
 		return E_OUTOFMEMORY;
 	ZeroMemory( This->m_mtOut.pbFormat, This->m_mtOut.cbFormat );

 	pbiOut = (BITMAPINFO*)(&((VIDEOINFOHEADER*)This->m_mtOut.pbFormat)->bmiHeader);

 	TRACE("(%p) - get format\n",This);
 	if ( ICDecompressGetFormat( This->hicCached, pbiIn, pbiOut ) != ICERR_OK )
 		return E_FAIL;

 	hr = QUARTZ_MediaSubType_FromBitmap( &This->m_mtOut.subtype, &pbiOut->bmiHeader );
 	if ( FAILED(hr) )
 		return hr;
 	if ( hr != S_OK )
 		QUARTZ_MediaSubType_FromFourCC( &This->m_mtOut.subtype, pbiOut->bmiHeader.biCompression );

 	This->m_mtOut.bFixedSizeSamples = (pbiOut->bmiHeader.biCompression == 0) ? 1 : 0;
 	This->m_mtOut.lSampleSize = (pbiOut->bmiHeader.biCompression == 0) ? DIBSIZE(pbiOut->bmiHeader) : pbiOut->bmiHeader.biSizeImage;

 	/* get palette */
 	if ( pbiOut->bmiHeader.biBitCount <= 8 )
 	{
 		TRACE("(%p) - get palette\n",This);
 		if ( ICDecompressGetPalette( This->hicCached, pbiIn, pbiOut ) != ICERR_OK )
 		{
 			TRACE("(%p) - use the input palette\n",This);
 			if ( pbiIn->bmiHeader.biBitCount != pbiOut->bmiHeader.biBitCount )
 			{
 				FIXME( "no palette...FIXME?\n" );
 				return E_FAIL;
 			}
 			if ( pbiOut->bmiHeader.biClrUsed == 0 )
 				pbiOut->bmiHeader.biClrUsed = 1<<pbiOut->bmiHeader.biBitCount;
 			if ( pbiOut->bmiHeader.biClrUsed > (1<<pbiOut->bmiHeader.biBitCount) )
 			{
 				ERR( "biClrUsed=%ld\n", pbiOut->bmiHeader.biClrUsed );
 				return E_FAIL;
 			}

 			memcpy( pbiOut->bmiColors, pbiIn->bmiColors,
 				sizeof(RGBQUAD) * pbiOut->bmiHeader.biClrUsed );
 		}
 	}

 	TRACE("(%p) - return format\n",This);
 	*ppmtAcceptTypes = &This->m_mtOut;
 	*pcAcceptTypes = 1;

 	return NOERROR;
 }

 static HRESULT AVIDec_GetAllocProp( CTransformBaseImpl* pImpl, const AM_MEDIA_TYPE* pmtIn, const AM_MEDIA_TYPE* pmtOut, ALLOCATOR_PROPERTIES* pProp, BOOL* pbTransInPlace, BOOL* pbTryToReuseSample )
 {
 	CAVIDecImpl*	This = pImpl->m_pUserData;
 	BITMAPINFO*	pbiOut = NULL;
 	HRESULT hr;

 	TRACE("(%p)\n",This);

 	if ( This == NULL )
 		return E_UNEXPECTED;

 	hr = AVIDec_CheckMediaType( pImpl, pmtIn, pmtOut );
 	if ( FAILED(hr) )
 		return hr;

 	pbiOut = (BITMAPINFO*)(&((VIDEOINFOHEADER*)pmtOut->pbFormat)->bmiHeader);

 	pProp->cBuffers = 1;
 	if ( pbiOut->bmiHeader.biCompression == 0 )
 		pProp->cbBuffer = DIBSIZE(pbiOut->bmiHeader);
 	else
 		pProp->cbBuffer = pbiOut->bmiHeader.biSizeImage;

 	*pbTransInPlace = FALSE;
 	*pbTryToReuseSample = TRUE;

 	return NOERROR;
 }

 static HRESULT AVIDec_BeginTransform( CTransformBaseImpl* pImpl, const AM_MEDIA_TYPE* pmtIn, const AM_MEDIA_TYPE* pmtOut, BOOL bReuseSample )
 {
 	CAVIDecImpl*	This = pImpl->m_pUserData;
 	BITMAPINFO*	pbiIn = NULL;
 	BITMAPINFO*	pbiOut = NULL;
 	HRESULT hr;

 	TRACE("(%p,%p,%p,%d)\n",This,pmtIn,pmtOut,bReuseSample);

 	if ( This == NULL ||
 		 This->hicTrans != (HIC)NULL )
 		return E_UNEXPECTED;

 	hr = AVIDec_CheckMediaType( pImpl, pmtIn, pmtOut );
 	if ( FAILED(hr) )
 		return hr;

 	AVIDec_ReleaseDIBBuffers(This);

 	pbiIn = (BITMAPINFO*)(&((VIDEOINFOHEADER*)pmtIn->pbFormat)->bmiHeader);
 	pbiOut = (BITMAPINFO*)(&((VIDEOINFOHEADER*)pmtOut->pbFormat)->bmiHeader);
 	This->m_pbiIn = AVIDec_DuplicateBitmapInfo(pbiIn);
 	This->m_pbiOut = AVIDec_DuplicateBitmapInfo(pbiOut);
 	if ( This->m_pbiIn == NULL || This->m_pbiOut == NULL )
 		return E_OUTOFMEMORY;
 	if ( This->m_pbiOut->bmiHeader.biCompression == 0 || This->m_pbiOut->bmiHeader.biCompression == 3 )
 		This->m_pbiOut->bmiHeader.biSizeImage = DIBSIZE(This->m_pbiOut->bmiHeader);

 	if ( !bReuseSample )
 	{
 		This->m_pOutBuf = QUARTZ_AllocMem(This->m_pbiOut->bmiHeader.biSizeImage);
 		if ( This->m_pOutBuf == NULL )
 			return E_OUTOFMEMORY;
 		ZeroMemory( This->m_pOutBuf, This->m_pbiOut->bmiHeader.biSizeImage );
 	}

 	if ( ICERR_OK != ICDecompressBegin(
 		This->hicCached, This->m_pbiIn, This->m_pbiOut ) )
 		return E_FAIL;

 	This->hicTrans = This->hicCached;
 	This->hicCached = (HIC)NULL;

 	return NOERROR;
 }

 static HRESULT AVIDec_Transform( CTransformBaseImpl* pImpl, IMediaSample* pSampIn, IMediaSample* pSampOut )
 {
 	CAVIDecImpl*	This = pImpl->m_pUserData;
 	DWORD	dwFlags;
 	BYTE*	pDataIn = NULL;
 	BYTE*	pDataOut = NULL;
 	HRESULT hr;

 	TRACE("(%p)\n",This);

 	if ( This == NULL || pSampOut == NULL ||
 		 This->hicTrans == (HIC)NULL ||
 		 This->m_pbiIn == NULL ||
 		 This->m_pbiOut == NULL )
 		return E_UNEXPECTED;

 	hr = IMediaSample_GetPointer( pSampIn, &pDataIn );
 	if ( FAILED(hr) )
 		return hr;
 	hr = IMediaSample_GetPointer( pSampOut, &pDataOut );
 	if ( FAILED(hr) )
 		return hr;

 	dwFlags = 0;
 	/*** FIXME!!!
 	 *
 	 * if ( IMediaSample_IsSyncPoint(pSampIn) != S_OK )
 	 *	dwFlags |= ICDECOMPRESS_NOTKEYFRAME;
 	 ****/

 	if ( IMediaSample_IsPreroll(pSampIn) == S_OK )
 		dwFlags |= ICDECOMPRESS_PREROLL;

 	if ( ICERR_OK != ICDecompress(
 		This->hicTrans,
 		dwFlags,
 		&This->m_pbiIn->bmiHeader,
 		pDataIn,
 		&This->m_pbiOut->bmiHeader,
 		( This->m_pOutBuf != NULL ) ? This->m_pOutBuf : pDataOut ) )
 		return E_FAIL;

 	if ( This->m_pOutBuf != NULL )
 		memcpy( pDataOut, This->m_pOutBuf,
 				This->m_pbiOut->bmiHeader.biSizeImage );

 	return NOERROR;
 }

 static HRESULT AVIDec_EndTransform( CTransformBaseImpl* pImpl )
 {
 	CAVIDecImpl*	This = pImpl->m_pUserData;

 	TRACE("(%p)\n",This);

 	if ( This == NULL )
 		return E_UNEXPECTED;
 	if ( This->hicTrans == (HIC)NULL )
 		return NOERROR;

 	ICDecompressEnd(This->hicTrans);

 	if ( This->hicCached != (HIC)NULL )
 		ICClose(This->hicCached);
 	This->hicCached = This->hicTrans;
 	This->hicTrans = (HIC)NULL;

 	AVIDec_ReleaseDIBBuffers(This);

 	return NOERROR;
 }


 static const TransformBaseHandlers transhandlers =
 {
 	AVIDec_Init,
 	AVIDec_Cleanup,
 	AVIDec_CheckMediaType,
 	AVIDec_GetOutputTypes,
 	AVIDec_GetAllocProp,
 	AVIDec_BeginTransform,
 	AVIDec_Transform,
 	AVIDec_EndTransform,
 };


 HRESULT QUARTZ_CreateAVIDec(IUnknown* punkOuter,void** ppobj)
 {
 	return QUARTZ_CreateTransformBase(
 		punkOuter,ppobj,
 		&CLSID_AVIDec,
 		AVIDec_FilterName,
 		NULL, NULL,
 		&transhandlers );
 }
	/*
	* Implements AVI Decompressor(CLSID_AVIDec).
	*
	* Copyright (C) Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/


	#include "config.h"

	#include "windef.h"
	#include "winbase.h"
	#include "wingdi.h"
	#include "winuser.h"
	#include "winerror.h"
	#include "vfw.h"
	#include "strmif.h"
	#include "control.h"
	#include "amvideo.h"
	#include "vfwmsgs.h"
	#include "uuids.h"

	#include "wine/debug.h"
	WINE_DEFAULT_DEBUG_CHANNEL(quartz);

	#include "quartz_private.h"
	#include "xform.h"


	static const WCHAR AVIDec_FilterName[] =
	{'A','V','I',' ','D','e','c','o','m','p','r','e','s','s','o','r',0};

	typedef struct CAVIDecImpl
	{
	HIC hicCached;
	HIC hicTrans;
	AM_MEDIA_TYPE m_mtOut;
	BITMAPINFO* m_pbiIn;
	BITMAPINFO* m_pbiOut;
	BYTE* m_pOutBuf;
	} CAVIDecImpl;

	/***************************************************************************
	*
	* CAVIDecImpl methods
	*
	*/

	static void AVIDec_ReleaseDIBBuffers(CAVIDecImpl* This)
	{
	TRACE("(%p)\n",This);

	if ( This->m_pbiIn != NULL )
	{
	QUARTZ_FreeMem(This->m_pbiIn); This->m_pbiIn = NULL;
	}
	if ( This->m_pbiOut != NULL )
	{
	QUARTZ_FreeMem(This->m_pbiOut); This->m_pbiOut = NULL;
	}
	if ( This->m_pOutBuf != NULL )
	{
	QUARTZ_FreeMem(This->m_pOutBuf); This->m_pOutBuf = NULL;
	}
	}

	static BITMAPINFO* AVIDec_DuplicateBitmapInfo(const BITMAPINFO* pbi)
	{
	DWORD dwSize;
	BITMAPINFO* pbiRet;

	dwSize = pbi->bmiHeader.biSize;
	if ( dwSize < sizeof(BITMAPINFOHEADER) )
	return NULL;
	if ( pbi->bmiHeader.biBitCount <= 8 )
	{
	if ( pbi->bmiHeader.biClrUsed == 0 )
	dwSize += sizeof(RGBQUAD)*(1<<pbi->bmiHeader.biBitCount);
	else
	dwSize += sizeof(RGBQUAD)*pbi->bmiHeader.biClrUsed;
	}
	if ( pbi->bmiHeader.biCompression == 3 &&
	dwSize == sizeof(BITMAPINFOHEADER) )
	dwSize += sizeof(DWORD)*3;

	pbiRet = (BITMAPINFO*)QUARTZ_AllocMem(dwSize);
	if ( pbiRet != NULL )
	memcpy( pbiRet, pbi, dwSize );

	return pbiRet;
	}

	static HRESULT AVIDec_Init( CTransformBaseImpl* pImpl )
	{
	CAVIDecImpl* This = pImpl->m_pUserData;

	TRACE("(%p)\n",This);

	if ( This != NULL )
	return NOERROR;

	This = (CAVIDecImpl*)QUARTZ_AllocMem( sizeof(CAVIDecImpl) );
	if ( This == NULL )
	return E_OUTOFMEMORY;
	ZeroMemory( This, sizeof(CAVIDecImpl) );
	pImpl->m_pUserData = This;
	/* construct */
	This->hicCached = (HIC)NULL;
	This->hicTrans = (HIC)NULL;
	ZeroMemory( &This->m_mtOut, sizeof(AM_MEDIA_TYPE) );
	This->m_pbiIn = NULL;
	This->m_pbiOut = NULL;
	This->m_pOutBuf = NULL;

	return NOERROR;
	}

	static HRESULT AVIDec_Cleanup( CTransformBaseImpl* pImpl )
	{
	CAVIDecImpl* This = pImpl->m_pUserData;

	TRACE("(%p)\n",This);

	if ( This == NULL )
	return NOERROR;

	/* destruct */
	QUARTZ_MediaType_Free( &This->m_mtOut );

	AVIDec_ReleaseDIBBuffers(This);

	if ( This->hicCached != (HIC)NULL )
	ICClose(This->hicCached);
	if ( This->hicTrans != (HIC)NULL )
	ICClose(This->hicTrans);

	QUARTZ_FreeMem( This );
	pImpl->m_pUserData = NULL;

	return NOERROR;
	}

	static HRESULT AVIDec_CheckMediaType( CTransformBaseImpl* pImpl, const AM_MEDIA_TYPE* pmtIn, const AM_MEDIA_TYPE* pmtOut )
	{
	CAVIDecImpl* This = pImpl->m_pUserData;
	BITMAPINFO* pbiIn = NULL;
	BITMAPINFO* pbiOut = NULL;
	HIC hic;

	TRACE("(%p)\n",This);
	if ( This == NULL )
	return E_UNEXPECTED;

	if ( !IsEqualGUID( &pmtIn->majortype, &MEDIATYPE_Video ) )
	return E_FAIL;
	if ( !IsEqualGUID( &pmtIn->formattype, &FORMAT_VideoInfo ) )
	return E_FAIL;
	pbiIn = (BITMAPINFO)(&((VIDEOINFOHEADER)pmtIn->pbFormat)->bmiHeader);
	if ( pmtOut != NULL )
	{
	if ( !IsEqualGUID( &pmtOut->majortype, &MEDIATYPE_Video ) )
	return E_FAIL;
	if ( !IsEqualGUID( &pmtOut->formattype, &FORMAT_VideoInfo ) )
	return E_FAIL;
	pbiOut = (BITMAPINFO)(&((VIDEOINFOHEADER)pmtOut->pbFormat)->bmiHeader);
	}

	if ( This->hicCached != (HIC)NULL &&
	ICDecompressQuery( This->hicCached, pbiIn, pbiOut ) == ICERR_OK )
	{
	TRACE("supported format\n");
	return NOERROR;
	}

	TRACE("try to find a decoder...\n");
	hic = ICLocate(
	mmioFOURCC('V','I','D','C'), 0,
	&pbiIn->bmiHeader, &pbiOut->bmiHeader, ICMODE_DECOMPRESS );
	if ( hic == (HIC)NULL )
	{
	WARN("no decoder for %c%c%c%c\n",
	(int)(( pbiIn->bmiHeader.biCompression >> 0 ) & 0xff),
	(int)(( pbiIn->bmiHeader.biCompression >> 8 ) & 0xff),
	(int)(( pbiIn->bmiHeader.biCompression >> 16 ) & 0xff),
	(int)(( pbiIn->bmiHeader.biCompression >> 24 ) & 0xff) );
	return E_FAIL;
	}
	TRACE("found\n");

	if ( This->hicCached != (HIC)NULL )
	ICClose(This->hicCached);
	This->hicCached = hic;

	return NOERROR;
	}

	static HRESULT AVIDec_GetOutputTypes( CTransformBaseImpl* pImpl, const AM_MEDIA_TYPE* pmtIn, const AM_MEDIA_TYPE** ppmtAcceptTypes, ULONG* pcAcceptTypes )
	{
	CAVIDecImpl* This = pImpl->m_pUserData;
	HRESULT hr;
	LONG cbFmt;
	BITMAPINFO* pbiIn = NULL;
	BITMAPINFO* pbiOut = NULL;

	TRACE("(%p)\n",This);
	hr = AVIDec_CheckMediaType( pImpl, pmtIn, NULL );
	if ( FAILED(hr) )
	return hr;

	TRACE("(%p) - get size of format\n",This);
	pbiIn = (BITMAPINFO)(&((VIDEOINFOHEADER)pmtIn->pbFormat)->bmiHeader);
	cbFmt = (LONG)ICDecompressGetFormatSize( This->hicCached, pbiIn );
	if ( cbFmt < sizeof(BITMAPINFOHEADER) )
	return E_FAIL;

	QUARTZ_MediaType_Free( &This->m_mtOut );
	ZeroMemory( &This->m_mtOut, sizeof(AM_MEDIA_TYPE) );

	memcpy( &This->m_mtOut.majortype, &MEDIATYPE_Video, sizeof(GUID) );
	memcpy( &This->m_mtOut.formattype, &FORMAT_VideoInfo, sizeof(GUID) );
	This->m_mtOut.cbFormat = sizeof(VIDEOINFOHEADER) + cbFmt + sizeof(RGBQUAD)*256;
	This->m_mtOut.pbFormat = (BYTE*)CoTaskMemAlloc(This->m_mtOut.cbFormat);
	if ( This->m_mtOut.pbFormat == NULL )
	return E_OUTOFMEMORY;
	ZeroMemory( This->m_mtOut.pbFormat, This->m_mtOut.cbFormat );

	pbiOut = (BITMAPINFO)(&((VIDEOINFOHEADER)This->m_mtOut.pbFormat)->bmiHeader);

	TRACE("(%p) - get format\n",This);
	if ( ICDecompressGetFormat( This->hicCached, pbiIn, pbiOut ) != ICERR_OK )
	return E_FAIL;

	hr = QUARTZ_MediaSubType_FromBitmap( &This->m_mtOut.subtype, &pbiOut->bmiHeader );
	if ( FAILED(hr) )
	return hr;
	if ( hr != S_OK )
	QUARTZ_MediaSubType_FromFourCC( &This->m_mtOut.subtype, pbiOut->bmiHeader.biCompression );

	This->m_mtOut.bFixedSizeSamples = (pbiOut->bmiHeader.biCompression == 0) ? 1 : 0;
	This->m_mtOut.lSampleSize = (pbiOut->bmiHeader.biCompression == 0) ? DIBSIZE(pbiOut->bmiHeader) : pbiOut->bmiHeader.biSizeImage;

	/* get palette */
	if ( pbiOut->bmiHeader.biBitCount <= 8 )
	{
	TRACE("(%p) - get palette\n",This);
	if ( ICDecompressGetPalette( This->hicCached, pbiIn, pbiOut ) != ICERR_OK )
	{
	TRACE("(%p) - use the input palette\n",This);
	if ( pbiIn->bmiHeader.biBitCount != pbiOut->bmiHeader.biBitCount )
	{
	FIXME( "no palette...FIXME?\n" );
	return E_FAIL;
	}
	if ( pbiOut->bmiHeader.biClrUsed == 0 )
	pbiOut->bmiHeader.biClrUsed = 1<<pbiOut->bmiHeader.biBitCount;
	if ( pbiOut->bmiHeader.biClrUsed > (1<<pbiOut->bmiHeader.biBitCount) )
	{
	ERR( "biClrUsed=%ld\n", pbiOut->bmiHeader.biClrUsed );
	return E_FAIL;
	}

	memcpy( pbiOut->bmiColors, pbiIn->bmiColors,
	sizeof(RGBQUAD) * pbiOut->bmiHeader.biClrUsed );
	}
	}

	TRACE("(%p) - return format\n",This);
	*ppmtAcceptTypes = &This->m_mtOut;
	*pcAcceptTypes = 1;

	return NOERROR;
	}

	static HRESULT AVIDec_GetAllocProp( CTransformBaseImpl* pImpl, const AM_MEDIA_TYPE* pmtIn, const AM_MEDIA_TYPE* pmtOut, ALLOCATOR_PROPERTIES* pProp, BOOL* pbTransInPlace, BOOL* pbTryToReuseSample )
	{
	CAVIDecImpl* This = pImpl->m_pUserData;
	BITMAPINFO* pbiOut = NULL;
	HRESULT hr;

	TRACE("(%p)\n",This);

	if ( This == NULL )
	return E_UNEXPECTED;

	hr = AVIDec_CheckMediaType( pImpl, pmtIn, pmtOut );
	if ( FAILED(hr) )
	return hr;

	pbiOut = (BITMAPINFO)(&((VIDEOINFOHEADER)pmtOut->pbFormat)->bmiHeader);

	pProp->cBuffers = 1;
	if ( pbiOut->bmiHeader.biCompression == 0 )
	pProp->cbBuffer = DIBSIZE(pbiOut->bmiHeader);
	else
	pProp->cbBuffer = pbiOut->bmiHeader.biSizeImage;

	*pbTransInPlace = FALSE;
	*pbTryToReuseSample = TRUE;

	return NOERROR;
	}

	static HRESULT AVIDec_BeginTransform( CTransformBaseImpl* pImpl, const AM_MEDIA_TYPE* pmtIn, const AM_MEDIA_TYPE* pmtOut, BOOL bReuseSample )
	{
	CAVIDecImpl* This = pImpl->m_pUserData;
	BITMAPINFO* pbiIn = NULL;
	BITMAPINFO* pbiOut = NULL;
	HRESULT hr;

	TRACE("(%p,%p,%p,%d)\n",This,pmtIn,pmtOut,bReuseSample);

	if ( This == NULL \|\|
	This->hicTrans != (HIC)NULL )
	return E_UNEXPECTED;

	hr = AVIDec_CheckMediaType( pImpl, pmtIn, pmtOut );
	if ( FAILED(hr) )
	return hr;

	AVIDec_ReleaseDIBBuffers(This);

	pbiIn = (BITMAPINFO)(&((VIDEOINFOHEADER)pmtIn->pbFormat)->bmiHeader);
	pbiOut = (BITMAPINFO)(&((VIDEOINFOHEADER)pmtOut->pbFormat)->bmiHeader);
	This->m_pbiIn = AVIDec_DuplicateBitmapInfo(pbiIn);
	This->m_pbiOut = AVIDec_DuplicateBitmapInfo(pbiOut);
	if ( This->m_pbiIn == NULL \|\| This->m_pbiOut == NULL )
	return E_OUTOFMEMORY;
	if ( This->m_pbiOut->bmiHeader.biCompression == 0 \|\| This->m_pbiOut->bmiHeader.biCompression == 3 )
	This->m_pbiOut->bmiHeader.biSizeImage = DIBSIZE(This->m_pbiOut->bmiHeader);

	if ( !bReuseSample )
	{
	This->m_pOutBuf = QUARTZ_AllocMem(This->m_pbiOut->bmiHeader.biSizeImage);
	if ( This->m_pOutBuf == NULL )
	return E_OUTOFMEMORY;
	ZeroMemory( This->m_pOutBuf, This->m_pbiOut->bmiHeader.biSizeImage );
	}

	if ( ICERR_OK != ICDecompressBegin(
	This->hicCached, This->m_pbiIn, This->m_pbiOut ) )
	return E_FAIL;

	This->hicTrans = This->hicCached;
	This->hicCached = (HIC)NULL;

	return NOERROR;
	}

	static HRESULT AVIDec_Transform( CTransformBaseImpl* pImpl, IMediaSample* pSampIn, IMediaSample* pSampOut )
	{
	CAVIDecImpl* This = pImpl->m_pUserData;
	DWORD dwFlags;
	BYTE* pDataIn = NULL;
	BYTE* pDataOut = NULL;
	HRESULT hr;

	TRACE("(%p)\n",This);

	if ( This == NULL \|\| pSampOut == NULL \|\|
	This->hicTrans == (HIC)NULL \|\|
	This->m_pbiIn == NULL \|\|
	This->m_pbiOut == NULL )
	return E_UNEXPECTED;

	hr = IMediaSample_GetPointer( pSampIn, &pDataIn );
	if ( FAILED(hr) )
	return hr;
	hr = IMediaSample_GetPointer( pSampOut, &pDataOut );
	if ( FAILED(hr) )
	return hr;

	dwFlags = 0;
	/*** FIXME!!!
	*
	* if ( IMediaSample_IsSyncPoint(pSampIn) != S_OK )
	* dwFlags \|= ICDECOMPRESS_NOTKEYFRAME;
	****/

	if ( IMediaSample_IsPreroll(pSampIn) == S_OK )
	dwFlags \|= ICDECOMPRESS_PREROLL;

	if ( ICERR_OK != ICDecompress(
	This->hicTrans,
	dwFlags,
	&This->m_pbiIn->bmiHeader,
	pDataIn,
	&This->m_pbiOut->bmiHeader,
	( This->m_pOutBuf != NULL ) ? This->m_pOutBuf : pDataOut ) )
	return E_FAIL;

	if ( This->m_pOutBuf != NULL )
	memcpy( pDataOut, This->m_pOutBuf,
	This->m_pbiOut->bmiHeader.biSizeImage );

	return NOERROR;
	}

	static HRESULT AVIDec_EndTransform( CTransformBaseImpl* pImpl )
	{
	CAVIDecImpl* This = pImpl->m_pUserData;

	TRACE("(%p)\n",This);

	if ( This == NULL )
	return E_UNEXPECTED;
	if ( This->hicTrans == (HIC)NULL )
	return NOERROR;

	ICDecompressEnd(This->hicTrans);

	if ( This->hicCached != (HIC)NULL )
	ICClose(This->hicCached);
	This->hicCached = This->hicTrans;
	This->hicTrans = (HIC)NULL;

	AVIDec_ReleaseDIBBuffers(This);

	return NOERROR;
	}


	static const TransformBaseHandlers transhandlers =
	{
	AVIDec_Init,
	AVIDec_Cleanup,
	AVIDec_CheckMediaType,
	AVIDec_GetOutputTypes,
	AVIDec_GetAllocProp,
	AVIDec_BeginTransform,
	AVIDec_Transform,
	AVIDec_EndTransform,
	};


	HRESULT QUARTZ_CreateAVIDec(IUnknown* punkOuter,void** ppobj)
	{
	return QUARTZ_CreateTransformBase(
	punkOuter,ppobj,
	&CLSID_AVIDec,
	AVIDec_FilterName,
	NULL, NULL,
	&transhandlers );
	}