/* * MSRLE32 Driver * * Copyright 2001 TAKESHIMA Hidenori * * 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 * * FIXME - encoding * FIXME - RLE4 * */ #include "config.h" #include "windef.h" #include "winbase.h" #include "wingdi.h" #include "winuser.h" #include "mmsystem.h" #include "vfw.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(msrle32); typedef struct CodecImpl { BOOL bInCompress; BOOL bInDecompress; BOOL bInDecompressEx; } CodecImpl; /***********************************************************************/ static LONG MSRLE32_DecompressRLE4( BYTE* pDst, LONG pitch, const BYTE* pSrc, LONG width, LONG height ) { FIXME( "RLE4 - not implemented yet\n" ); return ICERR_UNSUPPORTED; } static LONG MSRLE32_DecompressRLE8( BYTE* pDst, LONG pitch, const BYTE* pSrc, LONG width, LONG height ) { LONG x,y; LONG delta_x,delta_y; int len; UINT data; x = 0; y = 0; while ( y < height ) { len = *pSrc++; data = *pSrc++; if ( len > 0 ) { /* run length encoding */ while ( len-- > 0 && x < width ) pDst[x++] = (BYTE)data; } else { switch ( data ) { case 0: /* EOL */ x = 0; y++; pDst += pitch; break; case 1: /* END */ return ICERR_OK; case 2: /* DELTA */ delta_x = (LONG)*pSrc++; delta_y = (LONG)*pSrc++; x += delta_x; y += delta_y; pDst += delta_y * pitch; break; default: /* RAW */ len = data; if ( (len+x) > width ) len = width-x; memcpy( &pDst[x], pSrc, len ); x += len; pSrc += (data+1)&(~1); break; } } } return ICERR_OK; } /***********************************************************************/ static BOOL MSRLE32_IsValidInfoHeader( const BITMAPINFO* pbiIn ) { if ( pbiIn->bmiHeader.biSize < sizeof(BITMAPINFOHEADER) || pbiIn->bmiHeader.biWidth <= 0 || pbiIn->bmiHeader.biHeight == 0 || pbiIn->bmiHeader.biPlanes != 1 ) return FALSE; return TRUE; } static DWORD MSRLE32_GetClrUsed( const BITMAPINFO* pbiIn ) { if ( pbiIn->bmiHeader.biBitCount > 8 ) return 0; return (pbiIn->bmiHeader.biClrUsed == 0) ? (1<bmiHeader.biBitCount) : pbiIn->bmiHeader.biClrUsed; } static DWORD MSRLE32_GetUncompressedPitch( const BITMAPINFOHEADER* pbiIn ) { return ((((pbiIn->biWidth*pbiIn->biBitCount)+7)>>3)+3)&(~3); } static DWORD MSRLE32_GetUncompressedSize( const BITMAPINFOHEADER* pbiIn ) { return MSRLE32_GetUncompressedPitch( pbiIn ) * abs(pbiIn->biHeight); } static BOOL MSRLE32_IsValidRGB( const BITMAPINFO* pbiIn ) { if ( !MSRLE32_IsValidInfoHeader( pbiIn ) ) return FALSE; if ( pbiIn->bmiHeader.biSizeImage != 0 && pbiIn->bmiHeader.biSizeImage < MSRLE32_GetUncompressedSize( &pbiIn->bmiHeader ) ) return FALSE; switch ( pbiIn->bmiHeader.biCompression ) { case 0: case mmioFOURCC('R','G','B',' '): if ( pbiIn->bmiHeader.biBitCount == 1 || pbiIn->bmiHeader.biBitCount == 4 || pbiIn->bmiHeader.biBitCount == 8 || pbiIn->bmiHeader.biBitCount == 16 || pbiIn->bmiHeader.biBitCount == 24 || pbiIn->bmiHeader.biBitCount == 32 ) return TRUE; break; default: break; } return FALSE; } static BOOL MSRLE32_IsValidRLE( const BITMAPINFO* pbiIn ) { if ( !MSRLE32_IsValidInfoHeader( pbiIn ) ) return FALSE; switch ( pbiIn->bmiHeader.biCompression ) { case 1: case 2: case mmioFOURCC('R','L','E',' '): case mmioFOURCC('R','L','E','8'): case mmioFOURCC('R','L','E','4'): case mmioFOURCC('M','R','L','E'): if ( pbiIn->bmiHeader.biBitCount == 8 || pbiIn->bmiHeader.biBitCount == 4 ) return TRUE; break; default: break; } return FALSE; } static BOOL MSRLE32_CompareInfoHeader( const BITMAPINFO* pbiIn, const BITMAPINFO* pbiOut ) { if ( !MSRLE32_IsValidInfoHeader( pbiIn ) || !MSRLE32_IsValidInfoHeader( pbiOut ) ) return FALSE; if ( pbiIn->bmiHeader.biWidth != pbiOut->bmiHeader.biWidth || pbiIn->bmiHeader.biHeight != pbiOut->bmiHeader.biHeight || pbiIn->bmiHeader.biPlanes != pbiOut->bmiHeader.biPlanes || pbiIn->bmiHeader.biBitCount != pbiOut->bmiHeader.biBitCount ) return FALSE; return TRUE; } /***********************************************************************/ static LONG Codec_DrvQueryConfigure( CodecImpl* This ) { return ICERR_UNSUPPORTED; } static LONG Codec_DrvConfigure( CodecImpl* This, HWND hwnd, DRVCONFIGINFO* pinfo ) { return ICERR_UNSUPPORTED; } static LONG Codec_QueryAbout( void ) { return ICERR_UNSUPPORTED; } static LONG Codec_About( HWND hwnd ) { return ICERR_UNSUPPORTED; } static LONG Codec_CompressQuery( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut ) { FIXME( "compression is not implemented!\n" ); return ICERR_UNSUPPORTED; } static LONG Codec_CompressBegin( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut ) { return ICERR_UNSUPPORTED; } static LONG Codec_Compress( CodecImpl* This, ICCOMPRESS* picc, DWORD dwSize ) { FIXME( "compression is not implemented!\n" ); return ICERR_UNSUPPORTED; } static LONG Codec_CompressEnd( CodecImpl* This ) { This->bInCompress = FALSE; return ICERR_UNSUPPORTED; } static LONG Codec_CompressFramesInfo( CodecImpl* This, ICCOMPRESSFRAMES* piccf, DWORD dwSize ) { return ICERR_UNSUPPORTED; } static LONG Codec_CompressGetFormat( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut ) { return ICERR_UNSUPPORTED; } static LONG Codec_CompressGetSize( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut ) { return ICERR_UNSUPPORTED; } static LONG Codec_ICQueryConfigure( CodecImpl* This ) { return ICERR_OK; } static LONG Codec_ICConfigure( CodecImpl* This, HWND hwnd ) { MessageBoxA( hwnd, "Wine RLE Driver", "MSRLE32", MB_OK ); return ICERR_OK; } static LONG Codec_DecompressQuery( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut ) { if ( pbiIn == NULL ) return ICERR_BADPARAM; if ( !MSRLE32_IsValidRLE( pbiIn ) ) return ICERR_UNSUPPORTED; if ( pbiOut != NULL ) { if ( !MSRLE32_IsValidRGB( pbiOut ) ) return ICERR_UNSUPPORTED; if ( !MSRLE32_CompareInfoHeader( pbiIn, pbiOut ) ) return ICERR_UNSUPPORTED; } return ICERR_OK; } static LONG Codec_DecompressBegin( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut ) { LONG lr; if ( pbiIn == NULL || pbiOut == NULL ) return ICERR_BADPARAM; lr = Codec_DecompressQuery( This, pbiIn, pbiOut ); if ( lr != ICERR_OK ) return lr; This->bInDecompress = TRUE; return ICERR_OK; } static LONG Codec_Decompress( CodecImpl* This, ICDECOMPRESS* picd, DWORD dwSize ) { LONG lr; if ( !This->bInDecompress ) return ICERR_BADHANDLE; /* FIXME? */ if ( ( picd->dwFlags & ICDECOMPRESS_NOTKEYFRAME ) && ( picd->dwFlags & ICDECOMPRESS_UPDATE ) ) return ICERR_CANTUPDATE; /* FIXME? */ if ( picd->lpbiInput == NULL || picd->lpInput == NULL || picd->lpbiOutput == NULL || picd->lpOutput == NULL ) return ICERR_BADPARAM; switch ( picd->lpbiInput->biBitCount ) { case 4: /* RLE4 */ lr = MSRLE32_DecompressRLE4( (BYTE*)picd->lpOutput, MSRLE32_GetUncompressedPitch( picd->lpbiInput ), (const BYTE*)picd->lpInput, picd->lpbiInput->biWidth, picd->lpbiInput->biHeight ); break; case 8: /* RLE8 */ lr = MSRLE32_DecompressRLE8( (BYTE*)picd->lpOutput, MSRLE32_GetUncompressedPitch( picd->lpbiInput ), (const BYTE*)picd->lpInput, picd->lpbiInput->biWidth, picd->lpbiInput->biHeight ); break; default: lr = ICERR_BADBITDEPTH; break; } return lr; } static LONG Codec_DecompressEnd( CodecImpl* This ) { This->bInDecompress = FALSE; return ICERR_OK; } static LONG Codec_DecompressGetFormat( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut ) { DWORD biClrUsed; LONG lr; if ( pbiIn == NULL ) return ICERR_BADPARAM; lr = Codec_DecompressQuery( This, pbiIn, NULL ); if ( lr != ICERR_OK ) return ( pbiOut == NULL ) ? 0 : lr; biClrUsed = MSRLE32_GetClrUsed(pbiIn); if ( pbiOut == NULL ) return sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * biClrUsed; ZeroMemory( pbiOut, sizeof(BITMAPINFOHEADER) ); memcpy( &pbiOut->bmiHeader, &pbiIn->bmiHeader, sizeof(BITMAPINFOHEADER) ); memcpy( &pbiOut->bmiColors, &pbiIn->bmiColors, sizeof(RGBQUAD) * biClrUsed ); pbiOut->bmiHeader.biCompression = 0; pbiOut->bmiHeader.biSizeImage = MSRLE32_GetUncompressedSize( &pbiOut->bmiHeader ); return ICERR_OK; } static LONG Codec_DecompressGetPalette( CodecImpl* This, BITMAPINFO* pbiIn, BITMAPINFO* pbiOut ) { if ( pbiIn == NULL ) return ICERR_BADPARAM; return (pbiOut == NULL) ? 0 : ICERR_UNSUPPORTED; } static LONG Codec_DecompressSetPalette( CodecImpl* This, BITMAPINFO* pbiIn ) { return ICERR_UNSUPPORTED; } static LONG Codec_DecompressExQuery( CodecImpl* This, ICDECOMPRESSEX* picdex, DWORD dwSize ) { FIXME( "DecompressEx is not implemented!\n" ); return ICERR_UNSUPPORTED; } static LONG Codec_DecompressExBegin( CodecImpl* This, ICDECOMPRESSEX* picdex, DWORD dwSize ) { FIXME( "DecompressEx is not implemented!\n" ); return ICERR_UNSUPPORTED; } static LONG Codec_DecompressEx( CodecImpl* This, ICDECOMPRESSEX* picdex, DWORD dwSize ) { return ICERR_UNSUPPORTED; } static LONG Codec_DecompressExEnd( CodecImpl* This ) { This->bInDecompressEx = FALSE; return ICERR_UNSUPPORTED; } static LONG Codec_GetInfo( CodecImpl* This, ICINFO* pici, DWORD dwSize ) { return ICERR_UNSUPPORTED; } static LONG Codec_GetQuality( CodecImpl* This, DWORD* pdwQuality ) { return ICERR_UNSUPPORTED; } static LONG Codec_GetState( CodecImpl* This, LPVOID pvState, DWORD dwSize ) { if ( pvState == NULL ) return 0; /* no driver-specific state */ return 0; } static LONG Codec_SetQuality( CodecImpl* This, DWORD* pdwQuality ) { return ICERR_UNSUPPORTED; } static LONG Codec_SetStatusProc(CodecImpl* This, ICSETSTATUSPROC* picssp, DWORD dwSize ) { if ( picssp == NULL ) return 0; /* no driver-specific state */ return 0; } static LONG Codec_SetState( CodecImpl* This, LPVOID pvState, DWORD dwSize ) { return ICERR_UNSUPPORTED; } static CodecImpl* Codec_AllocDriver( void ) { CodecImpl* This; This = HeapAlloc( GetProcessHeap(), 0, sizeof(CodecImpl) ); if ( This == NULL ) return NULL; ZeroMemory( This, sizeof(CodecImpl) ); This->bInCompress = FALSE; This->bInDecompress = FALSE; This->bInDecompressEx = FALSE; return This; } static void Codec_Close( CodecImpl* This ) { if ( This->bInCompress ) Codec_CompressEnd(This); if ( This->bInDecompress ) Codec_DecompressEnd(This); if ( This->bInDecompressEx ) Codec_DecompressExEnd(This); HeapFree( GetProcessHeap(), 0, This ); } LONG WINAPI MSRLE32_DriverProc( DWORD dwDriverId, HDRVR hdrvr, UINT msg, LONG lParam1, LONG lParam2 ) { TRACE( "DriverProc(%08lx,%08x,%08x,%08lx,%08lx)\n", dwDriverId, hdrvr, msg, lParam1, lParam2 ); switch ( msg ) { case DRV_LOAD: TRACE("DRV_LOAD\n"); return TRUE; case DRV_FREE: TRACE("DRV_FREE\n"); return TRUE; case DRV_OPEN: TRACE("DRV_OPEN\n"); return (LONG)Codec_AllocDriver(); case DRV_CLOSE: TRACE("DRV_CLOSE\n"); Codec_Close( (CodecImpl*)dwDriverId ); return TRUE; case DRV_ENABLE: TRACE("DRV_ENABLE\n"); return TRUE; case DRV_DISABLE: TRACE("DRV_DISABLE\n"); return TRUE; case DRV_QUERYCONFIGURE: TRACE("DRV_QUERYCONFIGURE\n"); return Codec_DrvQueryConfigure( (CodecImpl*)dwDriverId ); case DRV_CONFIGURE: TRACE("DRV_CONFIGURE\n"); return Codec_DrvConfigure( (CodecImpl*)dwDriverId, (HWND)lParam1, (DRVCONFIGINFO*)lParam2 ); case DRV_INSTALL: TRACE("DRV_INSTALL\n"); return DRVCNF_OK; case DRV_REMOVE: TRACE("DRV_REMOVE\n"); return 0; case DRV_POWER: TRACE("DRV_POWER\n"); return TRUE; case ICM_ABOUT: TRACE("ICM_ABOUT\n"); return (lParam1 == -1) ? Codec_QueryAbout() : Codec_About( (HWND)lParam1 ); case ICM_COMPRESS: TRACE("ICM_COMPRESS\n"); return Codec_Compress((CodecImpl*)dwDriverId,(ICCOMPRESS*)lParam1,(DWORD)lParam2); case ICM_COMPRESS_BEGIN: TRACE("ICM_COMPRESS_BEGIN\n"); return Codec_CompressBegin((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2); case ICM_COMPRESS_END: TRACE("ICM_COMPRESS_END\n"); return Codec_CompressEnd((CodecImpl*)dwDriverId); case ICM_COMPRESS_FRAMES_INFO: TRACE("ICM_COMPRESS_FRAMES_INFO\n"); return Codec_CompressFramesInfo((CodecImpl*)dwDriverId,(ICCOMPRESSFRAMES*)lParam1,(DWORD)lParam2); case ICM_COMPRESS_GET_FORMAT: TRACE("ICM_COMPRESS_GET_FORMAT\n"); return Codec_CompressGetFormat((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2); case ICM_COMPRESS_GET_SIZE: TRACE("ICM_COMPRESS_GET_SIZE\n"); return Codec_CompressGetSize((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2); case ICM_COMPRESS_QUERY: TRACE("ICM_COMPRESS_GET_SIZE\n"); return Codec_CompressQuery((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2); case ICM_CONFIGURE: TRACE("ICM_CONFIGURE\n"); return ( lParam1 == -1 ) ? Codec_ICQueryConfigure( (CodecImpl*)dwDriverId ) : Codec_ICConfigure( (CodecImpl*)dwDriverId, (HWND)lParam1 ); case ICM_DECOMPRESS: TRACE( "ICM_DECOMPRESS\n" ); return Codec_Decompress((CodecImpl*)dwDriverId,(ICDECOMPRESS*)lParam1,(DWORD)lParam2); case ICM_DECOMPRESS_BEGIN: TRACE( "ICM_DECOMPRESS_BEGIN\n" ); return Codec_DecompressBegin((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2); case ICM_DECOMPRESS_END: TRACE( "ICM_DECOMPRESS_END\n" ); return Codec_DecompressEnd((CodecImpl*)dwDriverId); case ICM_DECOMPRESS_GET_FORMAT: TRACE( "ICM_DECOMPRESS_GET_FORMAT\n" ); return Codec_DecompressGetFormat((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2); case ICM_DECOMPRESS_GET_PALETTE: TRACE( "ICM_DECOMPRESS_GET_PALETTE\n" ); return Codec_DecompressGetPalette((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2); case ICM_DECOMPRESS_QUERY: TRACE( "ICM_DECOMPRESS_QUERY\n" ); return Codec_DecompressQuery((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1,(BITMAPINFO*)lParam2); case ICM_DECOMPRESS_SET_PALETTE: TRACE( "ICM_DECOMPRESS_SET_PALETTE\n" ); return Codec_DecompressSetPalette((CodecImpl*)dwDriverId,(BITMAPINFO*)lParam1); case ICM_DECOMPRESSEX_BEGIN: TRACE( "ICM_DECOMPRESSEX_BEGIN\n" ); return Codec_DecompressExBegin((CodecImpl*)dwDriverId,(ICDECOMPRESSEX*)lParam1,(DWORD)lParam2); case ICM_DECOMPRESSEX: TRACE( "ICM_DECOMPRESSEX\n" ); return Codec_DecompressEx((CodecImpl*)dwDriverId,(ICDECOMPRESSEX*)lParam1,(DWORD)lParam2); case ICM_DECOMPRESSEX_END: TRACE( "ICM_DECOMPRESSEX_END\n" ); return Codec_DecompressExEnd((CodecImpl*)dwDriverId); case ICM_DECOMPRESSEX_QUERY: TRACE( "ICM_DECOMPRESSEX_QUERY\n" ); return Codec_DecompressExQuery((CodecImpl*)dwDriverId,(ICDECOMPRESSEX*)lParam1,(DWORD)lParam2); case ICM_GETINFO: TRACE( "ICM_GETINFO\n" ); return Codec_GetInfo((CodecImpl*)dwDriverId,(ICINFO*)lParam1,(DWORD)lParam2); case ICM_GETQUALITY: TRACE( "ICM_SETQUALITY\n"); return Codec_GetQuality((CodecImpl*)dwDriverId,(DWORD*)lParam1); case ICM_GETSTATE: TRACE( "ICM_GETSTATE\n" ); return Codec_GetState((CodecImpl*)dwDriverId,(LPVOID)lParam1,(DWORD)lParam2); case ICM_SETQUALITY: TRACE( "ICM_SETQUALITY\n"); return Codec_SetQuality((CodecImpl*)dwDriverId,(DWORD*)lParam1); case ICM_SET_STATUS_PROC: TRACE( "ICM_SET_STATUS_PROC\n" ); return Codec_SetStatusProc((CodecImpl*)dwDriverId,(ICSETSTATUSPROC*)lParam1,(DWORD)lParam2); case ICM_SETSTATE: TRACE( "ICM_SETSTATE\n" ); return Codec_SetState((CodecImpl*)dwDriverId,(LPVOID)lParam1,(DWORD)lParam2); } return DefDriverProc( dwDriverId, hdrvr, msg, lParam1, lParam2 ); } BOOL WINAPI MSRLE32_DllMain( HINSTANCE hInst, DWORD dwReason, LPVOID lpvReserved ) { TRACE( "(%08x,%08lx,%p)\n",hInst,dwReason,lpvReserved ); return TRUE; }