int cap_ic_start(cap_cx *cx, char *err)
{
char format[32];
char message[80];
if((cx->ic = ICDecompressOpen(
ICTYPE_VIDEO,
0,
&(cx->pfmt->bmiHeader),
NULL)))
{
cx->outfmtlen = ICDecompressGetFormatSize(cx->ic, cx->pfmt);
if((cx->poutfmt = malloc(cx->outfmtlen)))
{
if(ICDecompressGetFormat(cx->ic, cx->pfmt, cx->poutfmt) == ICERR_OK)
{
if(ICDecompressBegin(cx->ic, cx->pfmt, cx->poutfmt) == ICERR_OK)
{
cx->mode = CAP_USE_IC;
return 1;
}
}
free(cx->poutfmt);
}
ICClose(cx->ic);
}
sprintf(message, "Can't open decompressor for format \"%s\"",
reverse_fourcc(format, cx->pfmt->bmiHeader.biCompression));
set_err(message);
return 0;
}
// init driver
static int init(sh_video_t *sh){
HRESULT ret;
// unsigned int outfmt=sh->codec->outfmt[sh->outfmtidx];
int i, o_bih_len;
vd_vfw_ctx *priv;
const char *dll = codec_idx2str(sh->codec->dll_idx);
/* Hack for VSSH codec: new dll can't decode old files
* In my samples old files have no extradata, so use that info
* to decide what dll should be used (here and in vd_dshow).
*/
if (!strcmp(dll, "vssh264.dll") && (sh->bih->biSize > 40))
return 0;
priv = malloc(sizeof(vd_vfw_ctx));
if (!priv)
return 0;
memset(priv, 0, sizeof(vd_vfw_ctx));
sh->context = priv;
mp_msg(MSGT_WIN32,MSGL_V,"======= Win32 (VFW) VIDEO Codec init =======\n");
// win32_codec_name = dll;
// sh->hic = ICOpen( 0x63646976, sh->bih->biCompression, ICMODE_FASTDECOMPRESS);
// priv->handle = ICOpen( 0x63646976, sh->bih->biCompression, ICMODE_DECOMPRESS);
priv->handle = ICOpen( (long)(dll), sh->bih->biCompression, ICMODE_DECOMPRESS);
if(!priv->handle){
mp_msg(MSGT_WIN32,MSGL_ERR,"ICOpen failed! unknown codec / wrong parameters?\n");
return 0;
}
// sh->bih->biBitCount=32;
o_bih_len = ICDecompressGetFormatSize(priv->handle, sh->bih);
if(o_bih_len < sizeof(BITMAPINFOHEADER)){
mp_msg(MSGT_WIN32,MSGL_ERR,"ICDecompressGetFormatSize returned a bogus value: %d\n", o_bih_len);
return 0;
}
priv->o_bih = malloc(o_bih_len);
memset(priv->o_bih, 0, o_bih_len);
mp_msg(MSGT_WIN32,MSGL_V,"ICDecompressGetFormatSize ret: %d\n", o_bih_len);
ret = ICDecompressGetFormat(priv->handle, sh->bih, priv->o_bih);
if(ret < 0){
mp_msg(MSGT_WIN32,MSGL_ERR,"ICDecompressGetFormat failed: Error %d\n", (int)ret);
for (i=0; i < o_bih_len; i++) mp_msg(MSGT_WIN32, MSGL_DBG2, "%02x ", priv->o_bih[i]);
return 0;
}
mp_msg(MSGT_WIN32,MSGL_V,"ICDecompressGetFormat OK\n");
#if 0
// workaround for pegasus MJPEG:
if(!sh_video->o_bih.biWidth) sh_video->o_bih.biWidth=sh_video->bih->biWidth;
if(!sh_video->o_bih.biHeight) sh_video->o_bih.biHeight=sh_video->bih->biHeight;
if(!sh_video->o_bih.biPlanes) sh_video->o_bih.biPlanes=sh_video->bih->biPlanes;
#endif
// ok let libvo and vd core to handshake and decide the optimal csp:
if(!mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,IMGFMT_YUY2)) return 0;
if (!(sh->codec->outflags[sh->outfmtidx]&CODECS_FLAG_FLIP)) {
priv->o_bih->biHeight=-sh->bih->biHeight; // flip image!
}
// ok, let's set the choosen colorspace:
set_csp(priv->o_bih,sh->codec->outfmt[sh->outfmtidx]);
// fake it to RGB for broken DLLs (divx3)
if(sh->codec->outflags[sh->outfmtidx] & CODECS_FLAG_YUVHACK)
priv->o_bih->biCompression = 0;
// sanity check:
#ifdef BUILD_VFWEX
ret = ICDecompressQueryEx(priv->handle, sh->bih, priv->o_bih);
#else
ret = ICDecompressQuery(priv->handle, sh->bih, priv->o_bih);
#endif
if (ret)
{
mp_msg(MSGT_WIN32,MSGL_WARN,"ICDecompressQuery failed: Error %d\n", (int)ret);
// return 0;
} else
mp_msg(MSGT_WIN32,MSGL_V,"ICDecompressQuery OK\n");
#ifdef BUILD_VFWEX
ret = ICDecompressBeginEx(priv->handle, sh->bih, priv->o_bih);
#else
ret = ICDecompressBegin(priv->handle, sh->bih, priv->o_bih);
#endif
if (ret)
{
mp_msg(MSGT_WIN32,MSGL_WARN,"ICDecompressBegin failed: Error %d\n", (int)ret);
// return 0;
}
// for broken codecs set it again:
if(sh->codec->outflags[sh->outfmtidx] & CODECS_FLAG_YUVHACK)
set_csp(priv->o_bih,sh->codec->outfmt[sh->outfmtidx]);
mp_msg(MSGT_WIN32, MSGL_V, "Input format:\n");
if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(sh->bih,MSGL_V);
mp_msg(MSGT_WIN32, MSGL_V, "Output format:\n");
if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(priv->o_bih,MSGL_V);
// set postprocessing level in xvid/divx4 .dll
ICSendMessage(priv->handle, ICM_USER+80, (long)(&divx_quality), 0);
// don't do this palette mess always, it makes div3 dll crashing...
if(sh->codec->outfmt[sh->outfmtidx]==IMGFMT_BGR8){
if(ICDecompressGetPalette(priv->handle, sh->bih, priv->o_bih)){
priv->palette = (unsigned char*)(priv->o_bih+1);
mp_msg(MSGT_WIN32,MSGL_V,"ICDecompressGetPalette OK\n");
} else {
if(sh->bih->biSize>=40+4*4)
priv->palette = (unsigned char*)(sh->bih+1);
}
}
mp_msg(MSGT_DECVIDEO,MSGL_V,"INFO: Win32 video codec init OK!\n");
return 1;
}
HANDLE VFWAPI ICImageDecompress(
HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn,
LPVOID lpBits, LPBITMAPINFO lpbiOut)
{
HGLOBAL hMem = NULL;
BYTE* pMem = NULL;
BOOL bReleaseIC = FALSE;
BYTE* pHdr = NULL;
ULONG cbHdr = 0;
BOOL bSucceeded = FALSE;
BOOL bInDecompress = FALSE;
DWORD biSizeImage;
TRACE("(%p,%08x,%p,%p,%p)\n",
hic, uiFlags, lpbiIn, lpBits, lpbiOut);
if ( hic == NULL )
{
hic = ICDecompressOpen( ICTYPE_VIDEO, 0, &lpbiIn->bmiHeader, (lpbiOut != NULL) ? &lpbiOut->bmiHeader : NULL );
if ( hic == NULL )
{
WARN("no handler\n" );
goto err;
}
bReleaseIC = TRUE;
}
if ( uiFlags != 0 )
{
FIXME( "unknown flag %08x\n", uiFlags );
goto err;
}
if ( lpbiIn == NULL || lpBits == NULL )
{
WARN("invalid argument\n");
goto err;
}
if ( lpbiOut != NULL )
{
if ( lpbiOut->bmiHeader.biSize != sizeof(BITMAPINFOHEADER) )
goto err;
cbHdr = sizeof(BITMAPINFOHEADER);
if ( lpbiOut->bmiHeader.biCompression == 3 )
cbHdr += sizeof(DWORD)*3;
else
if ( lpbiOut->bmiHeader.biBitCount <= 8 )
{
if ( lpbiOut->bmiHeader.biClrUsed == 0 )
cbHdr += sizeof(RGBQUAD) * (1<<lpbiOut->bmiHeader.biBitCount);
else
cbHdr += sizeof(RGBQUAD) * lpbiOut->bmiHeader.biClrUsed;
}
}
else
{
TRACE( "get format\n" );
cbHdr = ICDecompressGetFormatSize(hic,lpbiIn);
if ( cbHdr < sizeof(BITMAPINFOHEADER) )
goto err;
pHdr = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,cbHdr+sizeof(RGBQUAD)*256);
if ( pHdr == NULL )
goto err;
if ( ICDecompressGetFormat( hic, lpbiIn, pHdr ) != ICERR_OK )
goto err;
lpbiOut = (BITMAPINFO*)pHdr;
if ( lpbiOut->bmiHeader.biBitCount <= 8 &&
ICDecompressGetPalette( hic, lpbiIn, lpbiOut ) != ICERR_OK &&
lpbiIn->bmiHeader.biBitCount == lpbiOut->bmiHeader.biBitCount )
{
if ( lpbiIn->bmiHeader.biClrUsed == 0 )
memcpy( lpbiOut->bmiColors, lpbiIn->bmiColors, sizeof(RGBQUAD)*(1<<lpbiOut->bmiHeader.biBitCount) );
else
memcpy( lpbiOut->bmiColors, lpbiIn->bmiColors, sizeof(RGBQUAD)*lpbiIn->bmiHeader.biClrUsed );
}
if ( lpbiOut->bmiHeader.biBitCount <= 8 &&
lpbiOut->bmiHeader.biClrUsed == 0 )
lpbiOut->bmiHeader.biClrUsed = 1<<lpbiOut->bmiHeader.biBitCount;
lpbiOut->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
cbHdr = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*lpbiOut->bmiHeader.biClrUsed;
}
biSizeImage = lpbiOut->bmiHeader.biSizeImage;
if ( biSizeImage == 0 )
biSizeImage = ((((lpbiOut->bmiHeader.biWidth * lpbiOut->bmiHeader.biBitCount + 7) >> 3) + 3) & (~3)) * abs(lpbiOut->bmiHeader.biHeight);
TRACE( "call ICDecompressBegin\n" );
if ( ICDecompressBegin( hic, lpbiIn, lpbiOut ) != ICERR_OK )
goto err;
bInDecompress = TRUE;
TRACE( "cbHdr %d, biSizeImage %d\n", cbHdr, biSizeImage );
hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_ZEROINIT, cbHdr + biSizeImage );
if ( hMem == NULL )
{
WARN( "out of memory\n" );
goto err;
}
pMem = GlobalLock( hMem );
if ( pMem == NULL )
goto err;
memcpy( pMem, lpbiOut, cbHdr );
TRACE( "call ICDecompress\n" );
if ( ICDecompress( hic, 0, &lpbiIn->bmiHeader, lpBits, &lpbiOut->bmiHeader, pMem+cbHdr ) != ICERR_OK )
goto err;
bSucceeded = TRUE;
err:
if ( bInDecompress )
ICDecompressEnd( hic );
if ( bReleaseIC )
ICClose(hic);
HeapFree(GetProcessHeap(),0,pHdr);
if ( pMem != NULL )
GlobalUnlock( hMem );
if ( !bSucceeded && hMem != NULL )
{
GlobalFree(hMem); hMem = NULL;
}
return hMem;
}
static HRESULT AVIFILE_OpenGetFrame(IAVIStreamImpl *This)
{
LPBITMAPINFOHEADER lpbi;
DWORD size;
/* pre-conditions */
assert(This != NULL);
assert(This->pStream != NULL);
assert(This->pg == NULL);
This->pg = AVIStreamGetFrameOpen(This->pStream, NULL);
if (This->pg == NULL)
return AVIERR_ERROR;
/* When we only decompress this is enough */
if (This->sInfo.fccHandler == comptypeDIB)
return AVIERR_OK;
assert(This->hic != NULL);
assert(This->lpbiOutput == NULL);
/* get input format */
lpbi = AVIStreamGetFrame(This->pg, This->sInfo.dwStart);
if (lpbi == NULL)
return AVIERR_MEMORY;
/* get memory for output format */
size = ICCompressGetFormatSize(This->hic, lpbi);
if ((LONG)size < (LONG)sizeof(BITMAPINFOHEADER))
return AVIERR_COMPRESSOR;
This->lpbiOutput = HeapAlloc(GetProcessHeap(), 0, size);
if (This->lpbiOutput == NULL)
return AVIERR_MEMORY;
This->cbOutput = size;
if (ICCompressGetFormat(This->hic, lpbi, This->lpbiOutput) < S_OK)
return AVIERR_BADFORMAT;
/* update AVISTREAMINFO structure */
This->sInfo.rcFrame.right =
This->sInfo.rcFrame.left + This->lpbiOutput->biWidth;
This->sInfo.rcFrame.bottom =
This->sInfo.rcFrame.top + This->lpbiOutput->biHeight;
This->sInfo.dwSuggestedBufferSize =
ICCompressGetSize(This->hic, lpbi, This->lpbiOutput);
/* prepare codec for compression */
if (ICCompressBegin(This->hic, lpbi, This->lpbiOutput) != S_OK)
return AVIERR_COMPRESSOR;
/* allocate memory for current frame */
size += This->sInfo.dwSuggestedBufferSize;
This->lpbiCur = HeapAlloc(GetProcessHeap(), 0, size);
if (This->lpbiCur == NULL)
return AVIERR_MEMORY;
memcpy(This->lpbiCur, This->lpbiOutput, This->cbOutput);
This->lpCur = DIBPTR(This->lpbiCur);
/* allocate memory for last frame if needed */
if (This->lKeyFrameEvery != 1 &&
(This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
size = ICDecompressGetFormatSize(This->hic, This->lpbiOutput);
This->lpbiPrev = HeapAlloc(GetProcessHeap(), 0, size);
if (This->lpbiPrev == NULL)
return AVIERR_MEMORY;
if (ICDecompressGetFormat(This->hic, This->lpbiOutput, This->lpbiPrev) < S_OK)
return AVIERR_COMPRESSOR;
if (This->lpbiPrev->biSizeImage == 0) {
This->lpbiPrev->biSizeImage =
DIBWIDTHBYTES(*This->lpbiPrev) * This->lpbiPrev->biHeight;
}
/* get memory for format and picture */
size += This->lpbiPrev->biSizeImage;
This->lpbiPrev = HeapReAlloc(GetProcessHeap(), 0, This->lpbiPrev, size );
if (This->lpbiPrev == NULL)
return AVIERR_MEMORY;
This->lpPrev = DIBPTR(This->lpbiPrev);
/* prepare codec also for decompression */
if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
return AVIERR_COMPRESSOR;
}
return AVIERR_OK;
}
static HRESULT WINAPI ICMStream_fnSetFormat(IAVIStream *iface, LONG pos,
LPVOID format, LONG formatsize)
{
IAVIStreamImpl *This = impl_from_IAVIStream(iface);
TRACE("(%p,%d,%p,%d)\n", iface, pos, format, formatsize);
/* check parameters */
if (format == NULL || formatsize <= 0)
return AVIERR_BADPARAM;
/* We can only accept RGB data for writing */
if (((LPBITMAPINFOHEADER)format)->biCompression != BI_RGB) {
WARN(": need RGB data as input\n");
return AVIERR_UNSUPPORTED;
}
/* Input format already known?
* Changing of palette is supported, but be quiet if it's the same */
if (This->lpbiInput != NULL) {
if (This->cbInput != formatsize)
return AVIERR_UNSUPPORTED;
if (memcmp(format, This->lpbiInput, formatsize) == 0)
return AVIERR_OK;
}
/* Does the nested stream support writing? */
if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
return AVIERR_READONLY;
/* check if frame is already written */
if (This->sInfo.dwLength + This->sInfo.dwStart > pos)
return AVIERR_UNSUPPORTED;
/* check if we should compress */
if (This->sInfo.fccHandler == 0 ||
This->sInfo.fccHandler == mmioFOURCC('N','O','N','E'))
This->sInfo.fccHandler = comptypeDIB;
/* only pass through? */
if (This->sInfo.fccHandler == comptypeDIB)
return IAVIStream_SetFormat(This->pStream, pos, format, formatsize);
/* initial format setting? */
if (This->lpbiInput == NULL) {
ULONG size;
assert(This->hic != NULL);
/* get memory for input format */
This->lpbiInput = HeapAlloc(GetProcessHeap(), 0, formatsize);
if (This->lpbiInput == NULL)
return AVIERR_MEMORY;
This->cbInput = formatsize;
memcpy(This->lpbiInput, format, formatsize);
/* get output format */
size = ICCompressGetFormatSize(This->hic, This->lpbiInput);
if (size < sizeof(BITMAPINFOHEADER))
return AVIERR_COMPRESSOR;
This->lpbiOutput = HeapAlloc(GetProcessHeap(), 0, size);
if (This->lpbiOutput == NULL)
return AVIERR_MEMORY;
This->cbOutput = size;
if (ICCompressGetFormat(This->hic,This->lpbiInput,This->lpbiOutput) < S_OK)
return AVIERR_COMPRESSOR;
/* update AVISTREAMINFO structure */
This->sInfo.rcFrame.right =
This->sInfo.rcFrame.left + This->lpbiOutput->biWidth;
This->sInfo.rcFrame.bottom =
This->sInfo.rcFrame.top + This->lpbiOutput->biHeight;
/* prepare codec for compression */
if (ICCompressBegin(This->hic, This->lpbiInput, This->lpbiOutput) != S_OK)
return AVIERR_COMPRESSOR;
/* allocate memory for compressed frame */
size = ICCompressGetSize(This->hic, This->lpbiInput, This->lpbiOutput);
This->lpbiCur = HeapAlloc(GetProcessHeap(), 0, This->cbOutput + size);
if (This->lpbiCur == NULL)
return AVIERR_MEMORY;
memcpy(This->lpbiCur, This->lpbiOutput, This->cbOutput);
This->lpCur = DIBPTR(This->lpbiCur);
/* allocate memory for last frame if needed */
if (This->lKeyFrameEvery != 1 &&
(This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
size = ICDecompressGetFormatSize(This->hic, This->lpbiOutput);
This->lpbiPrev = HeapAlloc(GetProcessHeap(), 0, size);
if (This->lpbiPrev == NULL)
return AVIERR_MEMORY;
if (ICDecompressGetFormat(This->hic, This->lpbiOutput, This->lpbiPrev) < S_OK)
return AVIERR_COMPRESSOR;
if (This->lpbiPrev->biSizeImage == 0) {
This->lpbiPrev->biSizeImage =
DIBWIDTHBYTES(*This->lpbiPrev) * This->lpbiPrev->biHeight;
}
/* get memory for format and picture */
size += This->lpbiPrev->biSizeImage;
This->lpbiPrev = HeapReAlloc(GetProcessHeap(), 0, This->lpbiPrev, size);
if (This->lpbiPrev == NULL)
return AVIERR_MEMORY;
This->lpPrev = DIBPTR(This->lpbiPrev);
/* prepare codec also for decompression */
if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
return AVIERR_COMPRESSOR;
}
} else {
/* format change -- check that's only the palette */
LPBITMAPINFOHEADER lpbi = format;
if (lpbi->biSize != This->lpbiInput->biSize ||
lpbi->biWidth != This->lpbiInput->biWidth ||
lpbi->biHeight != This->lpbiInput->biHeight ||
lpbi->biBitCount != This->lpbiInput->biBitCount ||
lpbi->biPlanes != This->lpbiInput->biPlanes ||
lpbi->biCompression != This->lpbiInput->biCompression ||
lpbi->biClrUsed != This->lpbiInput->biClrUsed)
return AVIERR_UNSUPPORTED;
/* get new output format */
if (ICCompressGetFormat(This->hic, lpbi, This->lpbiOutput) < S_OK)
return AVIERR_BADFORMAT;
/* restart compression */
ICCompressEnd(This->hic);
if (ICCompressBegin(This->hic, lpbi, This->lpbiOutput) != S_OK)
return AVIERR_COMPRESSOR;
/* check if we need to restart decompression also */
if (This->lKeyFrameEvery != 1 &&
(This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
ICDecompressEnd(This->hic);
if (ICDecompressGetFormat(This->hic,This->lpbiOutput,This->lpbiPrev) < S_OK)
return AVIERR_COMPRESSOR;
if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
return AVIERR_COMPRESSOR;
}
}
/* tell nested stream the new format */
return IAVIStream_SetFormat(This->pStream, pos,
This->lpbiOutput, This->cbOutput);
}
