| /* |
| * MSRLE32 Driver |
| * |
| * Copyright 2001 TAKESHIMA Hidenori <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 |
| * |
| * 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<<pbiIn->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; |
| } |