1985 lines
53 KiB
C
1985 lines
53 KiB
C
//==========================================================================;
|
|
// COMMENTS DO NOT YET APPLY TO MSVIDEO.DLL/MSVFW32.DLL
|
|
// thunk.c
|
|
//
|
|
// Copyright (c) 1991-1994 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// Description:
|
|
// This module contains routines for thunking the
|
|
// ICM APIs (messages) from 16-bit Windows to 32-bit WOW.
|
|
//
|
|
// History:
|
|
//
|
|
//==========================================================================;
|
|
|
|
|
|
// This stuff is not going to work 64-bit
|
|
#pragma warning(disable:4312)
|
|
|
|
|
|
/*
|
|
|
|
WOW Thunking design:
|
|
|
|
Thunks are generated as follows :
|
|
|
|
16-bit :
|
|
acmBootDrivers->acmInitThunks :
|
|
|
|
Generate calls to 32-bit drivers if we're in WOW call across
|
|
to KERNEL to find thunking entry points.
|
|
|
|
If we're thunking 'load' all the 32-bit ACM drivers as well as
|
|
the 16-bit ones.
|
|
|
|
Priority is always to find a 32-bit driver first but this is
|
|
done via searching for one on open.
|
|
|
|
The internal flag ACM_DRIVERADDF_32BIT is specified when
|
|
calling IDriverAdd and this flag is stored in the ACMDRIVERID
|
|
structure.
|
|
|
|
IDriverAdd->IDriverLoad->IDriverLoad32
|
|
|
|
The 16-bit side calls the 32-bit side passing in the driver
|
|
alias which is used to compare against the aliases on the 32
|
|
bit side and the 32-bit HACMDRIVERID is passed back for the
|
|
relevant driver and stored in the hdrvr field of the
|
|
ACMDRIVERID structure.
|
|
|
|
IDriverOpen->IDriverOpen32
|
|
|
|
The parameters are passed to the 32-bit side using the hdrvr
|
|
field deduced from the HACMDRIVERID as the 32-bit HACMDRIVERID.
|
|
|
|
IDriverMessageId->IDriverMessageId32 :
|
|
|
|
If the driver is 32-bit (as identified in the ACMDRIVERID
|
|
structure) then call IDriverMessageId32. The hadid for
|
|
the 32-bit driver is stored in the hdrvr field of ACMDRIVERID
|
|
on the 16-bit side.
|
|
|
|
IDriverMessage->IDriverMessage32
|
|
|
|
If the driver is 32-bit (as identified in the ACMDRIVERID
|
|
structure pointed to by the ACMDRIVER structure) then call
|
|
IDriverMessage32. The had for the 32-bit driver is stored
|
|
in the hdrvr field of ACMDRIVER on the 16-bit side.
|
|
|
|
Stream headers
|
|
|
|
These must be persistent on the 32-bit side too and kept
|
|
in synch.
|
|
|
|
They are allocated on the 32-bit side for ACMDM_STREAM_PREPARE
|
|
and freed on ACMDM_STREAM_UNPREPARE. While in existence
|
|
the 32-bit stream header is stored in the dwDriver field in
|
|
|
|
*/
|
|
//==========================================================================;
|
|
|
|
#define _INC_COMPMAN
|
|
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <mmsystem.h>
|
|
#include <mmddk.h>
|
|
#include <mmreg.h>
|
|
#include <memory.h>
|
|
#include <win32.h>
|
|
#include <vfw.h>
|
|
#include <msviddrv.h>
|
|
#ifdef _WIN32
|
|
#ifdef DAYTONA
|
|
#include <wownt32.h>
|
|
#endif
|
|
#include <stdlib.h> // for mbstowcs and wcstombs
|
|
#endif // _WIN32
|
|
|
|
#ifdef _WIN32
|
|
#include "compmn16.h"
|
|
#endif
|
|
#include "compmani.h"
|
|
#include "thunk.h"
|
|
|
|
#include "debug.h"
|
|
|
|
|
|
|
|
#ifdef NT_THUNK32
|
|
|
|
//==========================================================================;
|
|
//
|
|
//
|
|
// --- === 32 BIT SIDE === ---
|
|
//
|
|
//
|
|
//==========================================================================;
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
** Handle and memory mapping functions.
|
|
** -------------------------------------------------------------------------
|
|
*/
|
|
|
|
LPWOWHANDLE32 lpWOWHandle32;
|
|
LPWOWHANDLE16 lpWOWHandle16;
|
|
LPGETVDMPOINTER GetVDMPointer;
|
|
LPWOWCALLBACK16 lpWOWCallback16;
|
|
int ThunksInitialized;
|
|
|
|
//
|
|
// These wrap around whatever mapping mechanism is used on the platform
|
|
// we are compiling for.
|
|
//
|
|
INLINE PVOID ptrFixMap16To32(const VOID * pv, DWORD cb);
|
|
INLINE VOID ptrUnFix16(const VOID * pv);
|
|
|
|
|
|
#ifdef CHICAGO
|
|
//
|
|
// -= Chicago implementation of memory mapping functions =-
|
|
//
|
|
|
|
//
|
|
// Thunk helper routines in Chicago kernel
|
|
//
|
|
extern PVOID WINAPI MapSL(const VOID * pv);
|
|
extern PVOID WINAPI MapSLFix(const VOID * pv);
|
|
extern VOID WINAPI UnMapSLFixArray(DWORD dwCnt, const VOID * lpSels[]);
|
|
|
|
PVOID INLINE ptrFixMap16To32(const VOID * pv, DWORD cb)
|
|
{
|
|
return MapSLFix(pv);
|
|
}
|
|
|
|
VOID INLINE ptrUnFix16(const VOID * pv)
|
|
{
|
|
UnMapSLFixArray(1, &pv);
|
|
}
|
|
|
|
|
|
#else // CHICAGO ELSE
|
|
|
|
//
|
|
// -= Daytona implementation of memory mapping functions =-
|
|
//
|
|
// Use #define to avoid having a function call
|
|
|
|
#define ptrFixMap16To32(spv, cb) \
|
|
GetVDMPointer( (DWORD) (DWORD_PTR) (spv), (cb), TRUE )
|
|
|
|
//PVOID ptrFixMap16To32(const VOID * pv, DWORD cb)
|
|
//{
|
|
// return GetVDMPointer( (DWORD)pv, cb, TRUE );
|
|
//}
|
|
|
|
//
|
|
// The unfix routine is a total noop.
|
|
// We should really call WOWGetVDMPointerUnfix...
|
|
//
|
|
|
|
#define ptrUnFix16(spv)
|
|
|
|
//VOID ptrUnFix16(const VOID * pv)
|
|
//{
|
|
// return;
|
|
//}
|
|
|
|
#endif // !CHICAGO
|
|
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
//
|
|
// 16-bit structures
|
|
//
|
|
|
|
typedef struct {
|
|
DWORD dwDCISize;
|
|
LPCSTR lpszDCISectionName;
|
|
LPCSTR lpszDCIAliasName;
|
|
} DRVCONFIGINFO16;
|
|
|
|
//
|
|
// Useful functions
|
|
//
|
|
|
|
//
|
|
// CopyAlloc - allocate a new piece of memory, and copy the data in
|
|
// Must use LocalFree to release the memory later
|
|
//
|
|
PVOID CopyAlloc(PVOID pvSrc, UINT uSize)
|
|
{
|
|
PVOID pvDest;
|
|
|
|
pvDest = (PVOID)LocalAlloc(LMEM_FIXED, uSize);
|
|
|
|
if (pvDest != NULL) {
|
|
CopyMemory(pvDest, pvSrc, uSize);
|
|
}
|
|
|
|
return pvDest;
|
|
}
|
|
|
|
/*
|
|
* Copy data from source to dest where source is a 32bit pointer
|
|
* and dest is a 16bit pointer
|
|
*/
|
|
void CopyTo16Bit(LPVOID Dest16, LPVOID Src32, DWORD Length)
|
|
{
|
|
PVOID Dest32;
|
|
|
|
if (Src32 == NULL) {
|
|
return;
|
|
}
|
|
|
|
Dest32 = ptrFixMap16To32(Dest16, Length);
|
|
|
|
CopyMemory(Dest32, Src32, Length);
|
|
|
|
ptrUnFix16(Dest16);
|
|
}
|
|
|
|
|
|
/*
|
|
* Copy data from source to dest where source is a 16bit pointer
|
|
* and dest is a 32bit pointer
|
|
*/
|
|
void CopyTo32Bit(LPVOID Dest32, LPVOID Src16, DWORD Length)
|
|
{
|
|
PVOID Src32;
|
|
|
|
if (Src16 == NULL) {
|
|
return;
|
|
}
|
|
|
|
Src32 = ptrFixMap16To32(Src16, Length);
|
|
|
|
CopyMemory(Dest32, Src32, Length);
|
|
|
|
ptrUnFix16(Src16);
|
|
}
|
|
#ifdef _INC_COMPMAN
|
|
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
| |
|
|
| Now thunk the compman functions |
|
|
| |
|
|
| |
|
|
| |
|
|
| |
|
|
\*--------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
* Convert ICDRAWBEGIN structures
|
|
*/
|
|
|
|
INLINE STATICFN void ConvertICDRAWBEGIN(ICDRAWBEGIN *DrawBegin32,
|
|
LPBITMAPINFOHEADER lpBmi,
|
|
DWORD dw)
|
|
{
|
|
ICDRAWBEGIN16 DrawBegin16;
|
|
|
|
CopyTo32Bit(&DrawBegin16, (LPVOID)dw, sizeof(ICDRAWBEGIN16));
|
|
|
|
DrawBegin32->dwFlags = DrawBegin16.dwFlags;
|
|
DrawBegin32->hpal = ThunkHPAL(DrawBegin16.hpal);
|
|
if (DrawBegin16.dwFlags & ICDRAW_HDC) {
|
|
DrawBegin32->hwnd = ThunkHWND(DrawBegin16.hwnd);
|
|
DrawBegin32->hdc = ThunkHDC(DrawBegin16.hdc);
|
|
}
|
|
DrawBegin32->xDst = (int)DrawBegin16.xDst;
|
|
DrawBegin32->yDst = (int)DrawBegin16.yDst;
|
|
DrawBegin32->dxDst = (int)DrawBegin16.dxDst;
|
|
DrawBegin32->dyDst = (int)DrawBegin16.dyDst;
|
|
|
|
CopyTo32Bit(lpBmi, DrawBegin16.lpbi, sizeof(BITMAPINFOHEADER));
|
|
|
|
DrawBegin32->lpbi = lpBmi;
|
|
DrawBegin32->xSrc = (int)DrawBegin16.xSrc;
|
|
DrawBegin32->ySrc = (int)DrawBegin16.ySrc;
|
|
DrawBegin32->dxSrc = (int)DrawBegin16.dxSrc;
|
|
DrawBegin32->dySrc = (int)DrawBegin16.dySrc;
|
|
DrawBegin32->dwRate = DrawBegin16.dwRate;
|
|
DrawBegin32->dwScale = DrawBegin16.dwScale;
|
|
}
|
|
|
|
|
|
/*
|
|
* Following logic copied from mvdm\wow32\wstruc.c - however since we
|
|
* don't have the usage parameter we're a bit stuck on the size of the
|
|
* entries.
|
|
*
|
|
* See also the video for windows documentation - only a limited range of
|
|
* bitmap types are discussed.
|
|
*/
|
|
|
|
INT GetBMI16Size(UNALIGNED BITMAPINFOHEADER *pbmi16)
|
|
{
|
|
int nHdrSize;
|
|
int nEntSize;
|
|
int nEntries;
|
|
int nBitCount;
|
|
DWORD dwClrUsed;
|
|
|
|
nHdrSize = (int)pbmi16->biSize;
|
|
|
|
/*
|
|
* We don't have some of the info we need so assume RGBQUAD
|
|
*/
|
|
|
|
nEntSize = sizeof(RGBQUAD);
|
|
|
|
nBitCount = pbmi16->biBitCount;
|
|
dwClrUsed = pbmi16->biClrUsed;
|
|
|
|
/* the following block of code should be this:
|
|
*
|
|
* if ( nBitCount > 8 ) { // true colour
|
|
* nEntries = 0; (ordinary case)
|
|
* nEntries = 3; (BI_BITFIELDS case)
|
|
* }
|
|
* else if ( dwClrUsed ) {
|
|
* nEntries = dwClrUsed;
|
|
* }
|
|
* else {
|
|
* nEntries = 1 << nBitCount;
|
|
* }
|
|
*
|
|
* but due to the fact that many apps don't initialize the biBitCount &
|
|
* biClrUsed fields (especially biClrUsed) we have to do the following
|
|
* sanity checking instead. v-cjones
|
|
*/
|
|
|
|
if ( nBitCount <= 8 ) {
|
|
nEntries = 1 << nBitCount;
|
|
// sanity check for apps (lots) that don't init the dwClrUsed field
|
|
if(dwClrUsed) {
|
|
nEntries = (int)min((DWORD)nEntries, dwClrUsed);
|
|
}
|
|
} else {
|
|
if (pbmi16->biCompression == BI_BITFIELDS)
|
|
nEntries = 3;
|
|
else
|
|
nEntries = 0;
|
|
}
|
|
|
|
return ( nHdrSize + (nEntries * nEntSize) );
|
|
}
|
|
|
|
INLINE LPBITMAPINFO CopyBitmapInfo(DWORD Bi16)
|
|
{
|
|
UNALIGNED BITMAPINFOHEADER *pbmi16;
|
|
LPBITMAPINFO lpbmi;
|
|
|
|
pbmi16 = ptrFixMap16To32((PVOID)Bi16, 0);
|
|
|
|
if ((int)pbmi16->biSize == 0) {
|
|
pbmi16->biSize = sizeof(BITMAPINFOHEADER);
|
|
DPF(0, "WARNING: null bitmap info size, setting it correctly");
|
|
}
|
|
|
|
lpbmi = (LPBITMAPINFO)CopyAlloc((LPVOID)pbmi16, GetBMI16Size(pbmi16));
|
|
|
|
ptrUnFix16((PVOID)Bi16);
|
|
|
|
return (lpbmi);
|
|
}
|
|
|
|
/*
|
|
* Allocate a BITMAPINFO structure to contain 256 colours
|
|
*/
|
|
INLINE LPBITMAPINFO AllocBitmapInfo()
|
|
{
|
|
return (PVOID)LocalAlloc(LMEM_FIXED, sizeof(BITMAPINFOHEADER)+
|
|
(sizeof(RGBQUAD)*256));
|
|
}
|
|
|
|
INLINE LPBITMAPINFOHEADER CopyBitmapInfoHeader(DWORD Bi16)
|
|
{
|
|
UNALIGNED BITMAPINFOHEADER *pbmi16;
|
|
LPBITMAPINFOHEADER lpbmi;
|
|
|
|
pbmi16 = ptrFixMap16To32((PVOID)Bi16, 0);
|
|
|
|
lpbmi = (LPBITMAPINFOHEADER)CopyAlloc((LPVOID)pbmi16, pbmi16->biSize);
|
|
|
|
ptrUnFix16((PVOID)Bi16);
|
|
|
|
return (lpbmi);
|
|
}
|
|
|
|
|
|
|
|
DWORD CopyICINFOTo16bit(DWORD dw, ICINFO *IcInfoCopy, DWORD Length)
|
|
{
|
|
ICINFO16 IcInfo;
|
|
LONG ReturnCode;
|
|
|
|
/*
|
|
* Make a copy since the behaviour of wcstombs is undefined
|
|
* for overlapping input and output
|
|
*/
|
|
|
|
memcpy(&IcInfo, IcInfoCopy, FIELD_OFFSET(ICINFO, szName[0]));
|
|
|
|
/*
|
|
* Massage the strings
|
|
*/
|
|
|
|
wcstombs(IcInfo.szName,
|
|
IcInfoCopy->szName,
|
|
sizeof(IcInfo.szName));
|
|
// HACK : overwrite the last five characters with "[32]\0"
|
|
|
|
if ((IcInfo.szName[0]))
|
|
{
|
|
UINT n = min(sizeof(IcInfo.szName)-5, lstrlenA(IcInfo.szName));
|
|
IcInfo.szName[n++] = '[';
|
|
IcInfo.szName[n++] = '3';
|
|
IcInfo.szName[n++] = '2';
|
|
IcInfo.szName[n++] = ']';
|
|
IcInfo.szName[n] = '\0';
|
|
}
|
|
|
|
wcstombs(IcInfo.szDescription,
|
|
IcInfoCopy->szDescription,
|
|
sizeof(IcInfo.szDescription));
|
|
// HACK : overwrite the last five characters with "[32]\0"
|
|
if ((IcInfo.szDescription[0]))
|
|
{
|
|
UINT n = min(sizeof(IcInfo.szDescription)-5, lstrlenA(IcInfo.szDescription));
|
|
IcInfo.szDescription[n++] = '[';
|
|
IcInfo.szDescription[n++] = '3';
|
|
IcInfo.szDescription[n++] = '2';
|
|
IcInfo.szDescription[n++] = ']';
|
|
IcInfo.szDescription[n] = '\0';
|
|
}
|
|
|
|
wcstombs(IcInfo.szDriver,
|
|
IcInfoCopy->szDriver,
|
|
sizeof(IcInfo.szDriver));
|
|
|
|
|
|
IcInfo.dwSize = sizeof(IcInfo);
|
|
|
|
ReturnCode = min(Length, IcInfo.dwSize);
|
|
|
|
CopyTo16Bit((LPVOID)dw, &IcInfo, ReturnCode);
|
|
|
|
return ReturnCode;
|
|
}
|
|
|
|
/*
|
|
* We need to convert the various fields in the ICDECOMPRESS/EX
|
|
* structure(s). Fortunately(?) the EX structure is a simple
|
|
* extension.
|
|
*/
|
|
typedef struct {
|
|
//
|
|
// same as ICM_DECOMPRESS
|
|
//
|
|
DWORD dwFlags;
|
|
|
|
LPBITMAPINFOHEADER lpbiSrc; // BITMAPINFO of compressed data
|
|
LPVOID lpSrc; // compressed data
|
|
|
|
LPBITMAPINFOHEADER lpbiDst; // DIB to decompress to
|
|
LPVOID lpDst; // output data
|
|
|
|
//
|
|
// new for ICM_DECOMPRESSEX
|
|
//
|
|
short xDst; // destination rectangle
|
|
short yDst;
|
|
short dxDst;
|
|
short dyDst;
|
|
|
|
short xSrc; // source rectangle
|
|
short ySrc;
|
|
short dxSrc;
|
|
short dySrc;
|
|
|
|
} ICDECOMPRESSEX16;
|
|
|
|
STATICFN DWORD DoICM_DecompressX(DWORD hic, UINT msg, DWORD_PTR dwP1, DWORD_PTR dwP2)
|
|
{
|
|
ICDECOMPRESSEX16 UNALIGNED *lpicdmpr16;
|
|
ICDECOMPRESSEX ICDecompressEx;
|
|
LRESULT l;
|
|
BOOL fQuery = TRUE;
|
|
|
|
/* Copy the standard or extended structure */
|
|
lpicdmpr16 = ptrFixMap16To32( (PVOID)dwP1, (DWORD) dwP2 );
|
|
ICDecompressEx.dwFlags = lpicdmpr16->dwFlags;
|
|
|
|
|
|
ICDecompressEx.lpbiSrc = (LPBITMAPINFOHEADER)CopyBitmapInfo((DWORD)(DWORD_PTR)lpicdmpr16->lpbiSrc);
|
|
if (NULL == ICDecompressEx.lpbiSrc) {
|
|
ptrUnFix16( (PVOID)dwP1 );
|
|
return (DWORD)ICERR_MEMORY;
|
|
}
|
|
|
|
ICDecompressEx.lpbiDst = (LPBITMAPINFOHEADER)CopyBitmapInfo((DWORD)(DWORD_PTR)lpicdmpr16->lpbiDst);
|
|
|
|
if ((NULL == ICDecompressEx.lpbiDst) && (msg != ICM_DECOMPRESSEX_QUERY)) {
|
|
LocalFree( (HLOCAL)ICDecompressEx.lpbiSrc );
|
|
ptrUnFix16( (PVOID)dwP1 );
|
|
return (DWORD)ICERR_MEMORY;
|
|
}
|
|
|
|
if (msg == ICM_DECOMPRESSEX || msg == ICM_DECOMPRESS) {
|
|
// map the source and destination pointers
|
|
ICDecompressEx.lpSrc = ptrFixMap16To32(lpicdmpr16->lpSrc,
|
|
ICDecompressEx.lpbiSrc->biSizeImage);
|
|
|
|
ICDecompressEx.lpDst = ptrFixMap16To32(lpicdmpr16->lpDst,
|
|
ICDecompressEx.lpbiDst->biSizeImage);
|
|
fQuery = FALSE; // remember
|
|
} else { // it is a query and we do not map the pointers
|
|
ICDecompressEx.lpSrc = NULL;
|
|
ICDecompressEx.lpDst = NULL;
|
|
}
|
|
|
|
if (dwP2 == sizeof(ICDECOMPRESSEX16) ) {
|
|
|
|
ICDecompressEx.xDst = (int)lpicdmpr16->xDst;
|
|
ICDecompressEx.yDst = (int)lpicdmpr16->yDst;
|
|
ICDecompressEx.dxDst = (int)lpicdmpr16->dxDst;
|
|
ICDecompressEx.dyDst = (int)lpicdmpr16->dyDst;
|
|
|
|
ICDecompressEx.xSrc = (int)lpicdmpr16->xSrc;
|
|
ICDecompressEx.ySrc = (int)lpicdmpr16->ySrc;
|
|
ICDecompressEx.dxSrc = (int)lpicdmpr16->dxSrc;
|
|
ICDecompressEx.dySrc = (int)lpicdmpr16->dySrc;
|
|
dwP2 = sizeof(ICDecompressEx); // Make the size relate to 32 bit
|
|
}
|
|
|
|
|
|
l = ICSendMessage( (HIC)hic, (UINT)msg, (LPARAM)&ICDecompressEx, dwP2 );
|
|
|
|
/* I don't think the following is needed // FrankYe 11/18/94
|
|
// If we do, don't just uncomment this. You gotta use biUnMapSL
|
|
if ( l == ICERR_OK) {
|
|
|
|
CopyTo16Bit( lpicdmpr16->lpbiDst, ICDecompressEx.lpbiDst,
|
|
sizeof(BITMAPINFOHEADER) );
|
|
}
|
|
*/
|
|
|
|
LocalFree( (HLOCAL)ICDecompressEx.lpbiSrc );
|
|
if (ICDecompressEx.lpbiDst) {
|
|
LocalFree( (HLOCAL)ICDecompressEx.lpbiDst );
|
|
}
|
|
if (!fQuery) {
|
|
ptrUnFix16( lpicdmpr16->lpSrc );
|
|
ptrUnFix16( lpicdmpr16->lpDst );
|
|
}
|
|
ptrUnFix16( (PVOID)dwP1 );
|
|
|
|
return (DWORD) l;
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate our thunks - refer to msvideo!compman.c for definitions of
|
|
* functions.
|
|
*
|
|
* NOTE - we often rely here on the fact that most of the message
|
|
* parameter structures are identical for 16 and 32-bit - ie they
|
|
* contain DWORDs and 32-bit pointers.
|
|
*/
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// LONG thkStatusProc32
|
|
//
|
|
// When a client calls the 16-bit ICSetStatusProc while using a
|
|
// 32-bit codec, this function is set as the StatusProc in 32-bit codec.
|
|
// This function will then thunk down to 16-bits and call the
|
|
// client's StatusProc.
|
|
//
|
|
// Arguments:
|
|
// LPARAM lParam : contains linear ptr to an ICSTATUSTHUNKDESC. The
|
|
// ICSTATUSTHUNKDESC is created during the call to ICSetStatusProc.
|
|
//
|
|
// UINT uMsg :
|
|
//
|
|
// LONG l :
|
|
//
|
|
// Return value:
|
|
// LONG :
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
LONG CALLBACK thkStatusProc32(LPARAM lParam, UINT uMsg, LONG l)
|
|
{
|
|
LPICSTATUSTHUNKDESC lpstd;
|
|
LONG lr;
|
|
|
|
DPFS(dbgThunks, 4, "thkStatusProc32()");
|
|
|
|
lpstd = (LPICSTATUSTHUNKDESC)lParam;
|
|
ASSERT( lpstd->fnStatusProcS );
|
|
ASSERT( lpstd->pfnthkStatusProc16S );
|
|
|
|
|
|
lr = 0;
|
|
|
|
//
|
|
// TODO: Thunk error string for ICSTATUS_ERROR. Currently I'm not
|
|
// sure if ICSTATUS_ERROR is documented.
|
|
//
|
|
//#pragma message(REMIND("thkStatusProc32: thunk ICSTATUS_ERROR"))
|
|
if (ICSTATUS_ERROR == uMsg) {
|
|
//
|
|
// Is l supposed to be an LPSTR to an error string???
|
|
//
|
|
l = (LONG)0;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
lpstd->uMsg = uMsg;
|
|
lpstd->l = l;
|
|
|
|
lr = lpWOWCallback16(lpstd->pfnthkStatusProc16S, (DWORD)lpstd->lpstdS);
|
|
|
|
return (lr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// LRESULT thkSetStatusProc
|
|
//
|
|
// This function is called as a result of thunking up from a call to
|
|
// the 16-bit ICSetStatusProc. It will call the 32-bit ICSetStatusProc
|
|
// to install thkStatusProc32.
|
|
//
|
|
// Arguments:
|
|
// HIC hic : handle to 32-bit codec
|
|
//
|
|
// LPARAM lParam : contains linear ptr to an ICSTATUSTHUNKDESC. The
|
|
// ICSTATUSTHUNKDESC is created in the call to the 16-bit
|
|
// ICSetStatusProc. This will be set as the lParam to be passed
|
|
// to our thkStatusProc32.
|
|
//
|
|
// Return value:
|
|
// LRESULT :
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
LRESULT WINAPI thkSetStatusProc(HIC hic, LPICSTATUSTHUNKDESC lpstd)
|
|
{
|
|
DPFS(dbgThunks, 3, "thkSetStatusProc()");
|
|
|
|
return ICSetStatusProc(hic, 0L, (LPARAM)lpstd, thkStatusProc32);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
LRESULT FAR PASCAL ICInfo32(DWORD fccType, DWORD fccHandler, ICINFO16 FAR * lpicInfo)
|
|
{
|
|
ICINFO ReturnedICInfo;
|
|
StartThunk(ICInfo);
|
|
|
|
//DPF2(("Calling ICInfo %4.4hs %4.4hs %8X", &fccType, &fccHandler, lpicInfo));
|
|
|
|
ReturnedICInfo.fccHandler = 0; // Initialise...
|
|
ReturnCode = ICInfo(fccType, fccHandler, &ReturnedICInfo);
|
|
|
|
CopyICINFOTo16bit((DWORD)(DWORD_PTR)lpicInfo, &ReturnedICInfo, sizeof(ReturnedICInfo));
|
|
EndThunk()
|
|
}
|
|
|
|
LRESULT FAR PASCAL ICInfoInternal32(DWORD fccType, DWORD fccHandler, ICINFO16 FAR * lpicInfo, ICINFOI FAR * lpicInfoI)
|
|
{
|
|
return ICInfo32(fccType, fccHandler, lpicInfo);
|
|
#if 0
|
|
ICINFO ReturnedICInfo;
|
|
ICINFOI ReturnedICInfoI;
|
|
|
|
StartThunk(ICInfo);
|
|
|
|
// DPF(1, "Calling ICInfo %4.4hs %4.4hs %8X", &fccType, &fccHandler, lpicInfo);
|
|
|
|
ReturnedICInfo.fccHandler = 0; // Initialise...
|
|
ReturnCode = ICInfoInternal(fccType, fccHandler, &ReturnedICInfo, &ReturnedICInfoI);
|
|
|
|
if (NULL != lpicInfoI) {
|
|
//
|
|
// Assuming no members of ICINFOI need special thunking
|
|
//
|
|
CopyTo16Bit(lpicInfoI, &ReturnedICInfoI, sizeof(*lpicInfoI));
|
|
}
|
|
|
|
CopyICINFOTo16bit((DWORD)(DWORD_PTR)lpicInfo, &ReturnedICInfo, sizeof(ReturnedICInfo));
|
|
|
|
EndThunk()
|
|
#endif
|
|
}
|
|
|
|
LRESULT FAR PASCAL ICSendMessage32(DWORD hic, UINT msg, DWORD_PTR dwP1, DWORD_PTR dwP2)
|
|
{
|
|
StartThunk(ICSendMessage);
|
|
DPF(2,"Calling ICSendMessage %4X %4X %8X %8X",
|
|
hic, msg, dwP1, dwP2);
|
|
|
|
switch (msg) {
|
|
case ICM_GETSTATE:
|
|
case ICM_SETSTATE:
|
|
|
|
if (dwP1 == 0) {
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
dwP1,
|
|
dwP2);
|
|
} else {
|
|
PVOID pState;
|
|
/*
|
|
* Create some aligned memory to return or pass on the data
|
|
*/
|
|
pState = (PVOID)LocalAlloc(LPTR, dwP2);
|
|
|
|
if (pState == NULL) {
|
|
ReturnCode = 0;
|
|
} else {
|
|
|
|
if ((UINT)msg == ICM_SETSTATE) {
|
|
// Copy the data from 16 bit land
|
|
CopyTo32Bit(pState, (LPVOID)dwP1, (DWORD) dwP2);
|
|
}
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic, (UINT)msg,
|
|
(DWORD_PTR)pState, dwP2);
|
|
|
|
/*
|
|
* Copy back the state, if the driver returned any data
|
|
*/
|
|
|
|
if (ReturnCode > 0 && (UINT)msg == ICM_GETSTATE) {
|
|
CopyTo16Bit((LPVOID)dwP1, pState,
|
|
min((DWORD)ReturnCode, (DWORD) dwP2));
|
|
}
|
|
|
|
LocalFree((HLOCAL)pState);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ICM_GETINFO:
|
|
{
|
|
ICINFO IcInfo;
|
|
|
|
ReturnCode = ICGetInfo((HIC)(DWORD)hic, &IcInfo, sizeof(IcInfo));
|
|
|
|
if (ReturnCode != 0) {
|
|
ReturnCode = CopyICINFOTo16bit((DWORD) (DWORD_PTR) dwP1, &IcInfo, (DWORD) ReturnCode);
|
|
}
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
case ICM_CONFIGURE:
|
|
case ICM_ABOUT:
|
|
|
|
/*
|
|
* dwP1 = -1 is a special value asking if config is supported,
|
|
* otherwise it's a window handle
|
|
*/
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
dwP1 == (DWORD_PTR)-1 ?
|
|
(DWORD_PTR)-1 :
|
|
(DWORD_PTR)ThunkHWND(LOWORD(dwP1)),
|
|
dwP2);
|
|
|
|
|
|
break;
|
|
|
|
case ICM_COMPRESS:
|
|
{
|
|
if (dwP2 != sizeof(ICCOMPRESS)) { // validation code
|
|
ReturnCode = ICERR_BADSIZE;
|
|
} else {
|
|
|
|
DWORD dwFlags;
|
|
LPDWORD lpdwFlags16, lpckid16;
|
|
LPBITMAPINFOHEADER lpbih16;
|
|
|
|
LPVOID lpInput, lpOutput, lpPrev;
|
|
|
|
DWORD ckid;
|
|
|
|
ICCOMPRESS IcCompress;
|
|
|
|
ReturnCode = ICERR_OK;
|
|
|
|
/*
|
|
* We need to convert the various fields in the ICCOMPRESS
|
|
* structure
|
|
*/
|
|
|
|
CopyTo32Bit( &IcCompress, (LPVOID)dwP1, (DWORD) dwP2 );
|
|
|
|
IcCompress.lpbiInput = (LPBITMAPINFOHEADER)CopyBitmapInfo((DWORD)(DWORD_PTR)IcCompress.lpbiInput);
|
|
if (NULL == IcCompress.lpbiInput) {
|
|
ReturnCode = ICERR_MEMORY;
|
|
break;
|
|
}
|
|
|
|
lpbih16 = IcCompress.lpbiOutput;
|
|
IcCompress.lpbiOutput = (LPBITMAPINFOHEADER)CopyBitmapInfo((DWORD)(DWORD_PTR)IcCompress.lpbiOutput);
|
|
if (NULL == IcCompress.lpbiOutput) {
|
|
LocalFree((HLOCAL)IcCompress.lpbiInput);
|
|
ReturnCode = ICERR_MEMORY;
|
|
break;
|
|
}
|
|
|
|
lpInput = IcCompress.lpInput;
|
|
IcCompress.lpInput = ptrFixMap16To32(IcCompress.lpInput, IcCompress.lpbiInput->biSizeImage);
|
|
|
|
lpOutput = IcCompress.lpOutput;
|
|
IcCompress.lpOutput = ptrFixMap16To32(IcCompress.lpOutput, IcCompress.lpbiOutput->biSizeImage);
|
|
|
|
lpPrev = NULL;
|
|
if (IcCompress.lpbiPrev) {
|
|
|
|
IcCompress.lpbiPrev = (LPBITMAPINFOHEADER)CopyBitmapInfo((DWORD)(DWORD_PTR)IcCompress.lpbiPrev);
|
|
if (NULL == IcCompress.lpbiPrev) {
|
|
LocalFree((HLOCAL)IcCompress.lpbiOutput);
|
|
LocalFree((HLOCAL)IcCompress.lpbiInput);
|
|
ptrUnFix16(lpOutput);
|
|
ptrUnFix16(lpInput);
|
|
ReturnCode = ICERR_MEMORY;
|
|
break;
|
|
}
|
|
|
|
|
|
lpPrev = IcCompress.lpPrev;
|
|
IcCompress.lpPrev = ptrFixMap16To32(IcCompress.lpPrev, IcCompress.lpbiPrev->biSizeImage);
|
|
}
|
|
|
|
lpdwFlags16 = IcCompress.lpdwFlags;
|
|
if (lpdwFlags16 != NULL) {
|
|
CopyTo32Bit(&dwFlags, lpdwFlags16, sizeof(DWORD));
|
|
IcCompress.lpdwFlags = &dwFlags;
|
|
}
|
|
|
|
if (IcCompress.lpckid != NULL) {
|
|
lpckid16 = IcCompress.lpckid;
|
|
IcCompress.lpckid = &ckid;
|
|
}
|
|
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic, (UINT)msg,
|
|
(DWORD_PTR)&IcCompress, dwP2);
|
|
|
|
if (ReturnCode == ICERR_OK) {
|
|
|
|
CopyTo16Bit( lpbih16, IcCompress.lpbiOutput,
|
|
sizeof(BITMAPINFOHEADER) );
|
|
|
|
if (lpdwFlags16 != NULL) {
|
|
CopyTo16Bit(lpdwFlags16, &dwFlags, sizeof(DWORD));
|
|
}
|
|
|
|
if (IcCompress.lpckid != NULL) {
|
|
CopyTo16Bit(lpckid16, &ckid, sizeof(DWORD));
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Free the bitmap info storage regardless of the return code
|
|
*/
|
|
|
|
if (NULL != IcCompress.lpbiPrev) {
|
|
LocalFree((HLOCAL)IcCompress.lpbiPrev);
|
|
}
|
|
|
|
LocalFree((HLOCAL)IcCompress.lpbiOutput);
|
|
LocalFree((HLOCAL)IcCompress.lpbiInput);
|
|
|
|
if (NULL != lpPrev)
|
|
{
|
|
ptrUnFix16(lpPrev);
|
|
}
|
|
ptrUnFix16(lpOutput);
|
|
ptrUnFix16(lpInput);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
|
|
case ICM_COMPRESS_GET_SIZE:
|
|
case ICM_COMPRESS_BEGIN:
|
|
case ICM_COMPRESS_QUERY:
|
|
|
|
case ICM_DECOMPRESS_BEGIN:
|
|
case ICM_DECOMPRESS_GET_PALETTE:
|
|
case ICM_DECOMPRESS_SET_PALETTE: // only takes one BitmapInfoHeader
|
|
case ICM_DECOMPRESS_QUERY:
|
|
|
|
{
|
|
LPBITMAPINFO bmi1, bmi2;
|
|
|
|
bmi1 = bmi2 = NULL;
|
|
if (dwP1 != 0) {
|
|
bmi1 = CopyBitmapInfo((DWORD) (DWORD_PTR) dwP1);
|
|
}
|
|
if (dwP2 != 0) {
|
|
bmi2 = CopyBitmapInfo((DWORD) (DWORD_PTR) dwP2);
|
|
}
|
|
|
|
if ( (NULL == bmi1 && 0 != dwP1) || (NULL == bmi2 && 0 != dwP2) )
|
|
{
|
|
if (NULL != bmi1) LocalFree((HLOCAL)bmi1);
|
|
if (NULL != bmi2) LocalFree((HLOCAL)bmi2);
|
|
ReturnCode = (UINT)msg == ICM_COMPRESS_GET_SIZE ? 0 : ICERR_MEMORY;
|
|
|
|
} else {
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)bmi1,
|
|
(DWORD_PTR)bmi2);
|
|
|
|
if (bmi2 != NULL) {
|
|
|
|
// We might have to return data to the 16 bit side.
|
|
// The messages for which we have to do this are:
|
|
// ICM_DECOMPRESS_QUERY (iff retcode == ICERR_OK)
|
|
// ICM_DECOMPRESS_GET_PALETTE (iff retcode >= 0)
|
|
|
|
if (((ReturnCode == ICERR_OK) && (msg == ICM_DECOMPRESS_QUERY))
|
|
|| ((ReturnCode >= 0) && (msg == ICM_DECOMPRESS_GET_PALETTE)))
|
|
{
|
|
CopyTo16Bit((LPVOID)dwP2, bmi2, GetBMI16Size((LPBITMAPINFOHEADER)bmi2));
|
|
}
|
|
LocalFree((HLOCAL)bmi2);
|
|
}
|
|
|
|
}
|
|
|
|
if (bmi1 != NULL) {
|
|
LocalFree((HLOCAL)bmi1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ICM_COMPRESS_END:
|
|
case ICM_DECOMPRESS_END:
|
|
case ICM_DECOMPRESSEX_END:
|
|
case ICM_DRAW_END:
|
|
case ICM_DRAW_FLUSH:
|
|
case ICM_DRAW_START: //??
|
|
case ICM_DRAW_STOP: //??
|
|
case ICM_DRAW_SETTIME:
|
|
case ICM_DRAW_RENDERBUFFER:
|
|
case ICM_SETQUALITY:
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
dwP1,
|
|
dwP2);
|
|
break;
|
|
|
|
case ICM_DRAW_GETTIME:
|
|
case ICM_GETBUFFERSWANTED:
|
|
case ICM_GETDEFAULTQUALITY:
|
|
case ICM_GETDEFAULTKEYFRAMERATE:
|
|
case ICM_GETQUALITY:
|
|
{
|
|
DWORD dwReturn;
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)&dwReturn,
|
|
dwP2);
|
|
|
|
// Note: although the definition of these messages state
|
|
// that dwParam2 is not used, trouble will brew if the
|
|
// decompressor ever tries to use dwParam2. We cannot
|
|
// thunk non-standard uses of this parameter.
|
|
|
|
if (ReturnCode == ICERR_OK) {
|
|
CopyTo16Bit((LPVOID)dwP1, &dwReturn, sizeof(DWORD));
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case ICM_COMPRESS_GET_FORMAT:
|
|
case ICM_DECOMPRESS_GET_FORMAT:
|
|
|
|
/*
|
|
* This is a tricky one - we first have to find the size of
|
|
* the output format so we can get a copy of the (aligned)
|
|
* version before passing it back to the app
|
|
*/
|
|
|
|
{
|
|
LPBITMAPINFO bmi1, bmi2;
|
|
|
|
if ( dwP1 == 0L ) {
|
|
ReturnCode = ICERR_OK;
|
|
break;
|
|
}
|
|
|
|
bmi1 = CopyBitmapInfo((DWORD) (DWORD_PTR) dwP1);
|
|
|
|
if (bmi1 == NULL) {
|
|
ReturnCode = ICERR_MEMORY;
|
|
} else {
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)bmi1,
|
|
0);
|
|
|
|
if (ReturnCode > 0 && dwP2 != 0) {
|
|
bmi2 = LocalAlloc(LMEM_FIXED, ReturnCode);
|
|
|
|
if (bmi2 == NULL) {
|
|
/*
|
|
* Can't do anything!!! - there's not good return code
|
|
*/
|
|
|
|
ReturnCode = ICERR_MEMORY;
|
|
} else {
|
|
DWORD Length;
|
|
|
|
Length = (DWORD) ReturnCode; /* preserve length */
|
|
|
|
ReturnCode =
|
|
ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)bmi1,
|
|
(DWORD_PTR)bmi2);
|
|
|
|
if (ReturnCode >= 0) {
|
|
CopyTo16Bit((LPVOID)dwP2, bmi2, Length);
|
|
}
|
|
|
|
LocalFree((HLOCAL)bmi2);
|
|
}
|
|
}
|
|
|
|
LocalFree((HLOCAL)bmi1);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case ICM_DECOMPRESS:
|
|
if (dwP2 != sizeof(ICDECOMPRESS)) {
|
|
ReturnCode = ICERR_BADSIZE;
|
|
} else {
|
|
ReturnCode = DoICM_DecompressX(hic, msg, dwP1, dwP2);
|
|
}
|
|
break;
|
|
|
|
case ICM_DECOMPRESSEX:
|
|
case ICM_DECOMPRESSEX_BEGIN:
|
|
case ICM_DECOMPRESSEX_QUERY:
|
|
if (dwP2 != sizeof(ICDECOMPRESSEX16)) {
|
|
ReturnCode = ICERR_BADSIZE;
|
|
} else {
|
|
ReturnCode = DoICM_DecompressX(hic, msg, dwP1, dwP2);
|
|
}
|
|
break;
|
|
|
|
case ICM_DRAW:
|
|
|
|
/*
|
|
* We can't support unknown extensions
|
|
*/
|
|
|
|
if (dwP2 != sizeof(ICDRAW)) {
|
|
ReturnCode = ICERR_BADSIZE;
|
|
} else {
|
|
ICDRAW ICDraw;
|
|
BITMAPINFOHEADER bmi;
|
|
LPVOID lpData;
|
|
|
|
CopyTo32Bit(&ICDraw, (LPVOID)dwP1, (DWORD) dwP2);
|
|
|
|
/*
|
|
* We have to assume this is a draw for video
|
|
*/
|
|
|
|
CopyTo32Bit(&bmi, ICDraw.lpFormat, sizeof(BITMAPINFOHEADER));
|
|
|
|
ICDraw.lpFormat = (LPVOID)&bmi;
|
|
|
|
lpData = ICDraw.lpData;
|
|
ICDraw.lpData = ptrFixMap16To32(ICDraw.lpData, ICDraw.cbData);
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)&ICDraw,
|
|
dwP2);
|
|
ptrUnFix16(lpData);
|
|
}
|
|
break;
|
|
|
|
case ICM_DRAW_BEGIN:
|
|
{
|
|
ICDRAWBEGIN InputFormat;
|
|
BITMAPINFOHEADER bmihInput;
|
|
|
|
ConvertICDRAWBEGIN(&InputFormat, &bmihInput, (DWORD) (DWORD_PTR) dwP1);
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)&InputFormat,
|
|
dwP2);
|
|
}
|
|
break;
|
|
|
|
case ICM_DRAW_CHANGEPALETTE:
|
|
case ICM_DRAW_QUERY:
|
|
{
|
|
LPBITMAPINFO lpbi;
|
|
|
|
lpbi = CopyBitmapInfo((DWORD) (DWORD_PTR) dwP1);
|
|
|
|
if (lpbi == NULL) {
|
|
ReturnCode = ICERR_MEMORY;
|
|
} else {
|
|
ReturnCode = ICSendMessage((HIC)(DWORD_PTR)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)lpbi,
|
|
dwP2);
|
|
|
|
LocalFree((HLOCAL)lpbi);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ICM_DRAW_REALIZE:
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)ThunkHDC(LOWORD(dwP1)),
|
|
dwP2);
|
|
|
|
break;
|
|
|
|
case ICM_DRAW_WINDOW:
|
|
{
|
|
RECT_SHORT SRect;
|
|
RECT Rect;
|
|
|
|
CopyTo32Bit(&SRect, (LPVOID)dwP1, sizeof(SRect));
|
|
|
|
SHORT_RECT_TO_RECT(Rect, SRect);
|
|
|
|
ReturnCode = ICSendMessage((HIC)(DWORD_PTR)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)&Rect,
|
|
dwP2);
|
|
}
|
|
break;
|
|
|
|
// The next three messages are INTERNAL ones
|
|
case ICM_GETERRORTEXT:
|
|
break;
|
|
|
|
case ICM_GETFORMATNAME:
|
|
break;
|
|
|
|
case ICM_ENUMFORMATS:
|
|
break;
|
|
|
|
case ICM_COMPRESS_FRAMES_INFO:
|
|
{
|
|
ICCOMPRESSFRAMES icf32;
|
|
|
|
// We might explode if we get too small a length and start treating
|
|
// some of the elements as pointers anyway. Just fail the call.
|
|
// (WIN95C bug 8615).
|
|
// dwP2 is the length of the 16 bit structure and we only know
|
|
// the size of the 32 bit structure, but thankfully they're the
|
|
// same.
|
|
if (dwP2 < sizeof(ICCOMPRESSFRAMES)) {
|
|
ReturnCode = ICERR_BADPARAM;
|
|
break;
|
|
}
|
|
|
|
CopyTo32Bit(&icf32, (LPBYTE)dwP1, (DWORD) dwP2);
|
|
|
|
// Now fix up the 32 bit structure
|
|
icf32.PutData = icf32.GetData = NULL; // For safety. should not be used for this message
|
|
|
|
if (icf32.lpbiOutput) {
|
|
icf32.lpbiOutput = CopyBitmapInfoHeader((DWORD)(DWORD_PTR)icf32.lpbiOutput);
|
|
}
|
|
if (icf32.lpbiInput) {
|
|
icf32.lpbiInput = CopyBitmapInfoHeader((DWORD)(DWORD_PTR)icf32.lpbiInput);
|
|
}
|
|
|
|
// According to the documentation, lInput and lOutput are undefined. Treating
|
|
// them as pointers is as scary as a really scary thing.
|
|
#if 0
|
|
lInput = icf32.lInput;
|
|
icf32.lInput = (LPARAM)ptrFixMap16To32((LPVOID)icf32.lInput, icf32.lpbiInput->biSizeImage);
|
|
|
|
lOutput = icf32.lOutput;
|
|
icf32.lOutput = (LPARAM)ptrFixMap16To32((LPVOID)icf32.lOutput, icf32.lpbiOutput->biSizeImage);
|
|
#endif
|
|
// After the fixups have been done, call the actual routine
|
|
ReturnCode = ICSendMessage((HIC)(DWORD_PTR)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)&icf32,
|
|
dwP2);
|
|
|
|
#if 0
|
|
ptrUnFix16((LPVOID)lOutput);
|
|
ptrUnFix16((LPVOID)lInput);
|
|
#endif
|
|
|
|
if (icf32.lpbiOutput) {
|
|
LocalFree(icf32.lpbiOutput);
|
|
}
|
|
if (icf32.lpbiInput) {
|
|
LocalFree(icf32.lpbiInput);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ICM_DRAW_GET_PALETTE:
|
|
{
|
|
ReturnCode = ICSendMessage((HIC) hic,
|
|
(UINT)msg,
|
|
dwP1,
|
|
dwP2);
|
|
if ((ReturnCode != 0L) && (ReturnCode != ICERR_UNSUPPORTED)) {
|
|
#ifdef CHICAGO
|
|
ReturnCode = (LRESULT)(WORD)ReturnCode;
|
|
#else
|
|
|
|
FARPROC lpWOWHandle16;
|
|
HMODULE hmodWow;
|
|
|
|
if ( (hmodWow = GetModuleHandle( GET_MAPPING_MODULE_NAME ))
|
|
&& (lpWOWHandle16 = GetProcAddress(hmodWow, "WOWHandle16"))) {
|
|
ReturnCode = (WORD)(lpWOWHandle16((HANDLE)ReturnCode, (WOW_HANDLE_TYPE)WOW_TYPE_HPALETTE));
|
|
} else {
|
|
ReturnCode = ICERR_ERROR;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ICM_DRAW_SUGGESTFORMAT:
|
|
{
|
|
ICDRAWSUGGEST icdrwsug;
|
|
LPBITMAPINFOHEADER lpbiSuggest16;
|
|
LPBITMAPINFOHEADER lpbiSuggest;
|
|
|
|
DPF(4, "!ICMSendMessage32: ICM_DRAW_SUGGESTFORMAT: dwP1=%08lXh, dwP2=%08lXh", dwP1, dwP2);
|
|
|
|
//
|
|
CopyTo32Bit(&icdrwsug, (LPBYTE)dwP1, (DWORD) dwP2);
|
|
|
|
lpbiSuggest = NULL;
|
|
lpbiSuggest16 = icdrwsug.lpbiSuggest;
|
|
if (lpbiSuggest16) {
|
|
lpbiSuggest = ptrFixMap16To32(lpbiSuggest16, 0);
|
|
}
|
|
|
|
// Now fix up the 32 bit structure
|
|
|
|
if (icdrwsug.lpbiIn) {
|
|
icdrwsug.lpbiIn = CopyBitmapInfoHeader((DWORD)(DWORD_PTR)icdrwsug.lpbiIn);
|
|
}
|
|
|
|
if (icdrwsug.lpbiSuggest) {
|
|
icdrwsug.lpbiSuggest = CopyBitmapInfoHeader((DWORD)(DWORD_PTR)icdrwsug.lpbiSuggest);
|
|
}
|
|
|
|
// After the fixups have been done, call the actual routine
|
|
ReturnCode = ICSendMessage((HIC)(DWORD)hic,
|
|
(UINT)msg,
|
|
(DWORD_PTR)&icdrwsug,
|
|
dwP2);
|
|
if (icdrwsug.lpbiIn) {
|
|
LocalFree(icdrwsug.lpbiIn);
|
|
}
|
|
|
|
// We must return the 32 bit suggested format to 16 bit land
|
|
if (icdrwsug.lpbiSuggest) {
|
|
if (ReturnCode == ICERR_OK) {
|
|
CopyMemory( lpbiSuggest, icdrwsug.lpbiSuggest,
|
|
lpbiSuggest->biSize);
|
|
}
|
|
LocalFree(icdrwsug.lpbiSuggest);
|
|
ptrUnFix16(lpbiSuggest16);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ICM_SET_STATUS_PROC:
|
|
// We do not need to support this under NT. It is much
|
|
// easier not to add the callback support... even if we could
|
|
// guarantee to be on the right thread to actually do the callback.
|
|
|
|
//
|
|
// This message has its own thunk!
|
|
//
|
|
ASSERT( FALSE );
|
|
|
|
|
|
default:
|
|
ReturnCode = ICERR_UNSUPPORTED;
|
|
break;
|
|
}
|
|
|
|
EndThunk()
|
|
}
|
|
|
|
INLINE LRESULT FAR PASCAL ICOpen32(DWORD fccType, DWORD fccHandler, UINT wMode)
|
|
{
|
|
StartThunk(ICOpen);
|
|
|
|
DPF(1, "Calling ICOpen %4.4hs %4.4hs %4X", &fccType, &fccHandler, wMode);
|
|
ReturnCode = (LONG_PTR)ICOpen(fccType, fccHandler, (UINT)wMode);
|
|
EndThunk();
|
|
}
|
|
|
|
INLINE LRESULT FAR PASCAL ICClose32(DWORD hic)
|
|
{
|
|
StartThunk(ICClose);
|
|
ReturnCode = ICClose((HIC)hic);
|
|
EndThunk();
|
|
}
|
|
|
|
#endif // _INC_COMPMAN
|
|
|
|
|
|
DWORD ICMThunk32(DWORD dwThunkId,DWORD dw1,DWORD dw2,DWORD dw3,DWORD dw4)
|
|
{
|
|
//
|
|
// Make sure we've got thunking functionality
|
|
//
|
|
|
|
#if 0
|
|
{
|
|
char szBuffer[80];
|
|
char szMsg[32];
|
|
|
|
|
|
switch (dwThunkId) {
|
|
|
|
case compThunkICSendMessage32:
|
|
lstrcpyA( szMsg, "ICSendMessage32" );
|
|
break;
|
|
|
|
case compThunkICInfoInternal32:
|
|
lstrcpyA( szMsg, "ICInfoInternal32" );
|
|
break;
|
|
|
|
case compThunkICOpen32:
|
|
lstrcpyA( szMsg, "ICOpen32" );
|
|
break;
|
|
|
|
case compThunkICClose32:
|
|
lstrcpyA( szMsg, "ICClose32" );
|
|
break;
|
|
|
|
default:
|
|
lstrcpyA( szMsg, "Unknown" );
|
|
break;
|
|
}
|
|
|
|
wsprintfA( szBuffer, "%18.18s 0x%08X 0x%08X 0x%08X 0x%08X\r\n",
|
|
szMsg, dw1, dw2, dw3, dw4);
|
|
|
|
OutputDebugStringA( szBuffer );
|
|
|
|
}
|
|
#endif
|
|
|
|
if (ThunksInitialized <= 0) {
|
|
|
|
HMODULE hMod;
|
|
|
|
if (ThunksInitialized == -1) {
|
|
return (DWORD)ICERR_ERROR;
|
|
}
|
|
|
|
hMod = GetModuleHandle(GET_MAPPING_MODULE_NAME);
|
|
if (hMod != NULL) {
|
|
|
|
GetVDMPointer =
|
|
(LPGETVDMPOINTER)GetProcAddress(hMod, GET_VDM_POINTER_NAME);
|
|
lpWOWHandle32 =
|
|
(LPWOWHANDLE32)GetProcAddress(hMod, GET_HANDLE_MAPPER32 );
|
|
lpWOWHandle16 =
|
|
(LPWOWHANDLE16)GetProcAddress(hMod, GET_HANDLE_MAPPER16 );
|
|
lpWOWCallback16 =
|
|
(LPWOWCALLBACK16)GetProcAddress(hMod, GET_CALLBACK16);
|
|
}
|
|
|
|
if ( GetVDMPointer == NULL ||
|
|
lpWOWHandle16 == NULL ||
|
|
lpWOWHandle32 == NULL ||
|
|
lpWOWCallback16 == NULL ) {
|
|
|
|
ThunksInitialized = -1;
|
|
return (DWORD)ICERR_ERROR;
|
|
|
|
} else {
|
|
ThunksInitialized = 1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Perform the requested function
|
|
//
|
|
|
|
switch (dwThunkId) {
|
|
|
|
case compThunkICSendMessage32:
|
|
return (DWORD) ICSendMessage32(dw1, (UINT)dw2, dw3, dw4);
|
|
break;
|
|
|
|
case compThunkICInfoInternal32:
|
|
return (DWORD) ICInfoInternal32(dw1, dw2, (ICINFOA FAR * )dw3, (ICINFOI FAR *)dw4);
|
|
break;
|
|
|
|
case compThunkICOpen32:
|
|
return (DWORD) ICOpen32(dw1, dw2, (UINT)dw3);
|
|
break;
|
|
|
|
case compThunkICClose32:
|
|
return (DWORD) ICClose32(dw1);
|
|
break;
|
|
|
|
case compThunkICOpenFunction32:
|
|
{
|
|
DWORD fccType;
|
|
DWORD fccHandler;
|
|
UINT uMode;
|
|
FARPROC lpfnHandler;
|
|
|
|
fccType = dw1;
|
|
fccHandler = dw2;
|
|
uMode = (UINT)dw3;
|
|
lpfnHandler = (FARPROC)dw4;
|
|
|
|
// !!! this won't work
|
|
return (DWORD) (DWORD_PTR) ICOpenFunction( fccType, fccHandler, uMode, lpfnHandler );
|
|
break;
|
|
}
|
|
|
|
case compThunkICSetStatusProc32:
|
|
{
|
|
DWORD lpstdS;
|
|
DWORD cbStruct;
|
|
HIC hic;
|
|
LPICSTATUSTHUNKDESC lpstd;
|
|
LRESULT lr;
|
|
|
|
hic = (HIC)dw1;
|
|
lpstdS = dw2;
|
|
cbStruct = dw3;
|
|
|
|
lpstd = ptrFixMap16To32((LPVOID)lpstdS, sizeof(*lpstd));
|
|
|
|
lr = thkSetStatusProc(hic, lpstd);
|
|
|
|
ptrUnFix16((LPVOID)lpstdS);
|
|
|
|
return (DWORD)lr;
|
|
}
|
|
|
|
default:
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
#endif // NT_THUNK32
|
|
|
|
#ifdef NT_THUNK16
|
|
|
|
//==========================================================================;
|
|
//
|
|
//
|
|
// --- === 16 BIT SIDE === ---
|
|
//
|
|
//
|
|
//==========================================================================;
|
|
|
|
//
|
|
// --== Global garbage ==--
|
|
//
|
|
DWORD (FAR PASCAL *lpfnCallproc32W)(DWORD, DWORD, DWORD,
|
|
DWORD, DWORD,
|
|
LPVOID, DWORD, DWORD);
|
|
DWORD (FAR PASCAL *lpfnFreeLibrary32W)(DWORD);
|
|
TCHAR gszKernel[] = TEXT("KERNEL");
|
|
|
|
TCHAR gszLoadLibraryEx32W[] = TEXT("LoadLibraryEx32W");
|
|
TCHAR gszFreeLibrary32W[] = TEXT("FreeLibrary32W");
|
|
TCHAR gszGetProcAddress32W[] = TEXT("GetProcAddress32W");
|
|
TCHAR gszCallproc32W[] = TEXT("CallProc32W");
|
|
|
|
TCHAR gszThunkEntry[] = TEXT("ICMThunk32");
|
|
TCHAR gszMsvfw32[] = TEXT("msvfw32.dll");
|
|
|
|
//
|
|
// --== ==--
|
|
//
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// PICMGARB thunkInitialize
|
|
//
|
|
// Description:
|
|
// Thunk initialization under NT WOW or Chicago 16-bit.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return (PICMGARB):
|
|
// NULL if thunks are not functional. Otherwise, a pointer to the
|
|
// ICMGARB structure for the current process is returned.
|
|
//
|
|
// History:
|
|
// 07/07/94 frankye
|
|
//
|
|
// Notes:
|
|
// The lack of a pig for the current process implies that a thunk
|
|
// is being called in the context of a process in which we were never
|
|
// loaded. If this happens, we allocate a new pig for this process
|
|
// and continue the thunk initialization. Since we were never
|
|
// loaded in the process, we *probably* will never be freed. We
|
|
// cannot reliably determine when we can thunkTerminate in the process.
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
PICMGARB WINAPI thunkInitialize(VOID)
|
|
{
|
|
HMODULE hmodKernel;
|
|
DWORD (FAR PASCAL *lpfnLoadLibraryEx32W)(LPCSTR, DWORD, DWORD);
|
|
LPVOID (FAR PASCAL *lpfnGetProcAddress32W)(DWORD, LPCSTR);
|
|
|
|
PICMGARB pig;
|
|
|
|
|
|
if (NULL == (pig = pigFind()))
|
|
{
|
|
DPF(0, "thunkInitialize: WARNING: ICM called from process %08lXh in which it was never loaded.", GetCurrentProcessId());
|
|
DebugErr(DBF_WARNING, "thunkInitialize: WARNING: ICM called from process in which it was never loaded.");
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// If we've already tried and failed...
|
|
//
|
|
if (pig->fThunkError)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// If we already successfully initialized thunks...
|
|
//
|
|
if (pig->fThunksInitialized)
|
|
{
|
|
return pig;
|
|
}
|
|
|
|
//
|
|
// Try to initialize our connection the the 32-bit side...
|
|
//
|
|
DPFS(dbgInit, 1, "thunkInitialize()");
|
|
|
|
//
|
|
// For now, we'll assume we hit an error...
|
|
//
|
|
pig->fThunkError = TRUE;
|
|
|
|
//
|
|
// See if we can find the thunking routine entry points in KERNEL
|
|
//
|
|
hmodKernel = GetModuleHandle(gszKernel);
|
|
|
|
if (hmodKernel == NULL)
|
|
{
|
|
DPFS(dbgInit, 0, "thunkInitialize: Couldn't GetModuleHandle(kernel)");
|
|
return NULL;
|
|
}
|
|
|
|
*(FARPROC *)&lpfnLoadLibraryEx32W =
|
|
GetProcAddress(hmodKernel, gszLoadLibraryEx32W);
|
|
|
|
if (lpfnLoadLibraryEx32W == NULL)
|
|
{
|
|
DPFS(dbgInit, 0, "thunkInitialize: Couldn't GetProcAddress(kernel, LoadLibraryEx32W)");
|
|
return NULL;
|
|
}
|
|
|
|
*(FARPROC *)&lpfnFreeLibrary32W =
|
|
GetProcAddress(hmodKernel, gszFreeLibrary32W);
|
|
|
|
if (lpfnFreeLibrary32W == NULL)
|
|
{
|
|
DPFS(dbgInit, 0, "thunkInitialize: Couldn't GetProcAddress(kernel, FreeLibrary32W)");
|
|
return NULL;
|
|
}
|
|
|
|
*(FARPROC *)&lpfnGetProcAddress32W = GetProcAddress(hmodKernel, gszGetProcAddress32W);
|
|
|
|
if (lpfnGetProcAddress32W == NULL)
|
|
{
|
|
DPFS(dbgInit, 0, "thunkInitialize: Couldn't GetProcAddress(kernel, GetProcAddress32W)");
|
|
return NULL;
|
|
}
|
|
|
|
*(FARPROC *)&lpfnCallproc32W = GetProcAddress(hmodKernel, gszCallproc32W);
|
|
|
|
if (lpfnCallproc32W == NULL)
|
|
{
|
|
DPFS(dbgInit, 0, "thunkInitialize: Couldn't GetProcAddress(kernel, CallProc32W)");
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// See if we can get a pointer to our thunking entry points
|
|
//
|
|
pig->dwMsvfw32Handle = (*lpfnLoadLibraryEx32W)(gszMsvfw32, 0L, 0L);
|
|
|
|
if (pig->dwMsvfw32Handle == 0)
|
|
{
|
|
DPFS(dbgInit, 0, "thunkInitialize: Couldn't LoadLibraryEx32W(msvfw32.dll)");
|
|
return NULL;
|
|
}
|
|
|
|
pig->lpvThunkEntry = (*lpfnGetProcAddress32W)(pig->dwMsvfw32Handle, gszThunkEntry);
|
|
|
|
if (pig->lpvThunkEntry == NULL)
|
|
{
|
|
DPFS(dbgInit, 0, "thunkInitialize: Couldn't GetProcAddress32W(msvfw32, ICMThunk32)");
|
|
(*lpfnFreeLibrary32W)(pig->dwMsvfw32Handle);
|
|
return NULL;
|
|
}
|
|
|
|
pig->fThunkError = FALSE;
|
|
pig->fThunksInitialized = TRUE;
|
|
|
|
DPFS(dbgInit, 4, "thunkInitialize: Done!");
|
|
|
|
return pig;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// VOID thunkTerminate
|
|
//
|
|
// Description:
|
|
// Thunk termination under NT WOW or Chicago. Called for each process
|
|
// by 16-bit side to terminate thunks.
|
|
//
|
|
// Arguments:
|
|
// PICMGARB pig:
|
|
//
|
|
// Return (VOID):
|
|
//
|
|
// History:
|
|
// 07/07/94 frankye
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
VOID WINAPI thunkTerminate(PICMGARB pig)
|
|
{
|
|
ASSERT( NULL != pig );
|
|
|
|
if (pig->fThunksInitialized)
|
|
{
|
|
lpfnFreeLibrary32W(pig->dwMsvfw32Handle);
|
|
pig->fThunksInitialized = FALSE;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
/*
|
|
* Generate our thunks - refer to msvideo!compman.c for definitions of
|
|
* functions.
|
|
*
|
|
* NOTE - we often rely here on the fact that most of the message
|
|
* parameter structures are identical for 16 and 32-bit - ie they
|
|
* contain DWORDs and 32-bit pointers.
|
|
*/
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// LONG thkStatusProc
|
|
//
|
|
// This is reached by thunking down from the 32-bit thkStatusProc32.
|
|
// It will call the client's StatusProc.
|
|
//
|
|
// Arguments:
|
|
// DWORD dwParam : contains segmented ptr to an ICSTATUSTHUNKDESC.
|
|
// The ICSTATUSTHUNKDESC is created during the call to ICSetStatusProc.
|
|
//
|
|
// Return value:
|
|
// LONG :
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
LONG FAR PASCAL _loadds thkStatusProc(DWORD dwParam)
|
|
{
|
|
LPICSTATUSTHUNKDESC lpstd;
|
|
|
|
DPFS(dbgThunks, 4, "thkStatusProc()");
|
|
|
|
lpstd = (LPICSTATUSTHUNKDESC)dwParam;
|
|
ASSERT( NULL != lpstd );
|
|
ASSERT( NULL != lpstd->fnStatusProcS );
|
|
|
|
return (lpstd->fnStatusProcS)(lpstd->lParam, (UINT)lpstd->uMsg, lpstd->l);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// LRESULT ICSendSetStatusProc32
|
|
//
|
|
// Called from 16-bit ICSendMessage to thunk the ICM_SET_STATUS_PROC
|
|
// message to 32-bits
|
|
//
|
|
// Arguments:
|
|
// HIC hic :
|
|
//
|
|
// LPICSETSTATUSPROC lpissp :
|
|
//
|
|
// DWORD : cbStruct
|
|
//
|
|
// Return value:
|
|
// LRESULT :
|
|
//
|
|
// Notes:
|
|
// !!! For Daytona, we fail this. If we ever decide to support this
|
|
// on Daytona, then I think we have much more work to do since linear
|
|
// addresses in use by the 32-bit codec may change when the status
|
|
// callback thunks down to 16-bits. On Chicago, all the linear addresses
|
|
// our fixed when we convert from the segmented address to the linear
|
|
// address. WHY DOESN'T NT GIVE US AN EASY WAY TO FIX LINEAR ADDRESSES?
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
LRESULT WINAPI ICSendSetStatusProc32(HIC hic, ICSETSTATUSPROC FAR* lpissp, DWORD cbStruct)
|
|
{
|
|
#ifdef DAYTONA
|
|
return ICERR_UNSUPPORTED;
|
|
#else
|
|
PICMGARB pig;
|
|
PIC pic;
|
|
LPICSTATUSTHUNKDESC lpstd;
|
|
LRESULT lr;
|
|
|
|
DPFS(dbgThunks, 4, "ICSendSetStatusProc32()");
|
|
|
|
if (NULL == (pig = thunkInitialize())) {
|
|
return ICERR_ERROR;
|
|
}
|
|
|
|
pic = (PIC)hic;
|
|
|
|
//
|
|
// This should never fail since the structure was allocated by
|
|
// our own code in the ICSetStatusProc macro.
|
|
//
|
|
if (cbStruct < sizeof(*lpissp)) {
|
|
ASSERT( FALSE );
|
|
return ICERR_BADPARAM;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
if (NULL != pic->lpstd) {
|
|
DPFS(dbgThunks, 1, "ICSendSetStatusProc32: replacing existing status proc!");
|
|
GlobalUnfix(GlobalPtrHandle(pic->lpstd));
|
|
GlobalFreePtr(pic->lpstd);
|
|
pic->lpstd = NULL;
|
|
}
|
|
|
|
//
|
|
// Allocate a ICSTATUSTHUNKDESC status thunk descriptor. We fix it
|
|
// in linear memory here so that it's linear address remains constant
|
|
// throughout it use. It's linear address will be given to the 32-bit
|
|
// codec which will cache it for use in callbacks.
|
|
//
|
|
lpstd = (LPICSTATUSTHUNKDESC)GlobalAllocPtr(GHND, sizeof(*lpstd));
|
|
if (NULL == lpstd) {
|
|
return (ICERR_MEMORY);
|
|
}
|
|
GlobalFix(GlobalPtrHandle(lpstd));
|
|
|
|
pic->lpstd = lpstd;
|
|
|
|
lpstd->lpstdS = lpstd;
|
|
lpstd->dwFlags = lpissp->dwFlags;
|
|
lpstd->lParam = lpissp->lParam;
|
|
lpstd->fnStatusProcS = lpissp->Status;
|
|
lpstd->pfnthkStatusProc16S = thkStatusProc;
|
|
|
|
lr = (LRESULT)(*lpfnCallproc32W)(compThunkICSetStatusProc32,
|
|
(DWORD)pic->h32,
|
|
(DWORD)lpstd,
|
|
(DWORD)0,
|
|
(DWORD)0,
|
|
pig->lpvThunkEntry,
|
|
0L, // Don't map pointers
|
|
5L);
|
|
|
|
if (0 != lr) {
|
|
DPFS(dbgThunks, 1, "ICSendSetStatusProc32: fail");
|
|
GlobalUnfix(GlobalPtrHandle(pic->lpstd));
|
|
GlobalFreePtr(pic->lpstd);
|
|
pic->lpstd = NULL;
|
|
}
|
|
|
|
return lr;
|
|
#endif
|
|
}
|
|
|
|
|
|
BOOL FAR PASCAL ICInfoInternal32(DWORD fccType, DWORD fccHandler, ICINFO FAR * lpicInfo, ICINFOI FAR * lpicInfoI)
|
|
{
|
|
PICMGARB pig;
|
|
|
|
DPFS(dbgThunks, 4, "ICInfoInternal32");
|
|
|
|
if (NULL == (pig = thunkInitialize()))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return (BOOL)(*lpfnCallproc32W)(compThunkICInfoInternal32,
|
|
(DWORD)fccType,
|
|
(DWORD)fccHandler,
|
|
(DWORD)lpicInfo,
|
|
(DWORD)lpicInfoI,
|
|
pig->lpvThunkEntry,
|
|
0L, // Don't map pointers
|
|
5L);
|
|
}
|
|
|
|
LRESULT FAR PASCAL ICSendMessage32(DWORD hic, UINT msg, DWORD dwP1, DWORD dwP2)
|
|
{
|
|
PICMGARB pig;
|
|
|
|
DPFS(dbgThunks, 4, "ICSendMessage32(hic=%08lXh, msg=%04Xh, dwP1=%08lXh, dwP2=%08lXh)", hic, msg, dwP1, dwP2);
|
|
|
|
if (NULL == (pig = thunkInitialize()))
|
|
{
|
|
switch (msg) {
|
|
case ICM_GETSTATE:
|
|
case ICM_SETSTATE:
|
|
case ICM_GETINFO:
|
|
case ICM_COMPRESS_GET_SIZE:
|
|
return 0;
|
|
}
|
|
return (LRESULT)ICERR_ERROR;
|
|
}
|
|
|
|
return (LRESULT)(*lpfnCallproc32W)(compThunkICSendMessage32,
|
|
(DWORD)hic,
|
|
(DWORD)msg,
|
|
(DWORD)dwP1,
|
|
(DWORD)dwP2,
|
|
pig->lpvThunkEntry,
|
|
0L, // Don't map pointers
|
|
5L);
|
|
}
|
|
|
|
LRESULT FAR PASCAL ICOpen32(DWORD fccType, DWORD fccHandler, UINT wMode)
|
|
{
|
|
PICMGARB pig;
|
|
|
|
DPFS(dbgThunks, 4, "ICOpen32");
|
|
|
|
if (NULL == (pig = thunkInitialize()))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return (DWORD)(lpfnCallproc32W)(compThunkICOpen32,
|
|
(DWORD)fccType,
|
|
(DWORD)fccHandler,
|
|
(DWORD)wMode,
|
|
(DWORD)0L,
|
|
pig->lpvThunkEntry,
|
|
0L, // Don't map pointers
|
|
5L);
|
|
}
|
|
|
|
LRESULT FAR PASCAL ICOpenFunction32(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler)
|
|
{
|
|
PICMGARB pig;
|
|
|
|
DPFS(dbgThunks, 4, "ICOpenFunction32");
|
|
|
|
if (NULL == (pig = thunkInitialize()))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return (LRESULT)(lpfnCallproc32W)(compThunkICOpenFunction32,
|
|
(DWORD)fccType,
|
|
(DWORD)fccHandler,
|
|
(DWORD)wMode,
|
|
(DWORD)lpfnHandler,
|
|
pig->lpvThunkEntry,
|
|
0L, // Don't map pointers
|
|
5L);
|
|
}
|
|
|
|
LRESULT FAR PASCAL ICClose32(DWORD hic)
|
|
{
|
|
PICMGARB pig;
|
|
|
|
DPFS(dbgThunks, 4, "ICClose32");
|
|
|
|
if (NULL == (pig = thunkInitialize()))
|
|
{
|
|
return (LRESULT)ICERR_ERROR;
|
|
}
|
|
|
|
return (DWORD)(lpfnCallproc32W)(compThunkICClose32,
|
|
(DWORD)hic,
|
|
(DWORD)0L,
|
|
(DWORD)0L,
|
|
(DWORD)0L,
|
|
pig->lpvThunkEntry,
|
|
0L, // Don't map pointers
|
|
5L);
|
|
}
|
|
|
|
#endif // NT_THUNK16
|
|
|