407 lines
12 KiB
C
407 lines
12 KiB
C
/*
|
|
thunks.c
|
|
|
|
Contains code for thunking msvideo.dll from 16bit to 32bit
|
|
|
|
Copyright (c) Microsoft Corporation 1994. All rights reserved
|
|
|
|
Basic Structure:
|
|
|
|
When loaded, the 16 bit DLL will try to find the corresponding
|
|
32 bit DLL. There are two of these.
|
|
|
|
The 32bit videoXXXX api entry points are in AVICAP32.DLL
|
|
The 32bit ICM code is in MSVFW32.DLL
|
|
|
|
The thunk initialisation routine will check the code is running on
|
|
Windows NT. If not, no further initialisation is done. This
|
|
ensures that the same binary can be used on NT, and other Windows
|
|
platforms.
|
|
|
|
The code then attempts to access the special entry points provided
|
|
in KERNEL.DLL for loading and calling 32 bit entry points. If this
|
|
link fails, no thunking can be done.
|
|
|
|
Each of the 32 bit DLLs is loaded in turn, and GetProcAddress32 is
|
|
called for the special thunk entry point. If all works then two
|
|
global flags are set (independently of each other).
|
|
|
|
gfVideo32 == TRUE means that the videoXXXX apis can be called.
|
|
gfICM32 == TRUE means that the 32 bit ICM code is available.
|
|
|
|
*/
|
|
|
|
#include <windows.h>
|
|
#define MMNOMCI
|
|
#include <win32.h>
|
|
#include <mmsystem.h>
|
|
#include <msvideo.h>
|
|
#include <msviddrv.h>
|
|
#include <compman.h>
|
|
#include "vidthunk.h"
|
|
#include "msvideoi.h"
|
|
|
|
|
|
SZCODE gszKernel[] = TEXT("KERNEL");
|
|
SZCODE gszLoadLibraryEx32W[] = TEXT("LoadLibraryEx32W");
|
|
//SZCODE gszFreeLibraryEx32W[] = TEXT("FreeLibraryEx32W");
|
|
SZCODE gszFreeLibrary32W[] = TEXT("FreeLibrary32W");
|
|
SZCODE gszGetProcAddress32W[] = TEXT("GetProcAddress32W");
|
|
SZCODE gszCallproc32W[] = TEXT("CallProc32W");
|
|
SZCODE gszVideoThunkEntry[] = TEXT("videoThunk32");
|
|
SZCODE gszVideo32[] = TEXT("avicap32.dll");
|
|
SZCODE gszICMThunkEntry[] = TEXT("ICMThunk32");
|
|
SZCODE gszICMThunkEntry2[] = TEXT("ICMTHUNK32");
|
|
SZCODE gszICM32[] = TEXT("msvfw32.dll");
|
|
|
|
VIDTHUNK pvth;
|
|
|
|
#ifndef WIN32
|
|
//--------------------------------------------------------------------------;
|
|
|
|
// BOOL InitThunks
|
|
|
|
// Description:
|
|
|
|
|
|
// Arguments:
|
|
// None.
|
|
|
|
// Return (BOOL):
|
|
|
|
// History:
|
|
|
|
|
|
//--------------------------------------------------------------------------;
|
|
void FAR PASCAL InitThunks(VOID)
|
|
{
|
|
HMODULE hmodKernel;
|
|
DWORD (FAR PASCAL *lpfnLoadLibraryEx32W)(LPCSTR, DWORD, DWORD);
|
|
LPVOID (FAR PASCAL *lpfnGetProcAddress32W)(DWORD, LPCSTR);
|
|
DWORD (FAR PASCAL *lpfnFreeLibrary32W)(DWORD hLibModule);
|
|
|
|
|
|
// Check if we're WOW
|
|
|
|
|
|
// if (!(GetWinFlags() & WF_WINNT)) {
|
|
// //DPF(("Not running in WOW... returning FALSE\n"));
|
|
// return;
|
|
// }
|
|
|
|
|
|
// See if we can find the thunking routine entry points in KERNEL
|
|
|
|
|
|
hmodKernel = GetModuleHandle(gszKernel);
|
|
|
|
if (hmodKernel == NULL)
|
|
{
|
|
DPF(("Cannot link to kernel module... returning FALSE\n"));
|
|
return; // !!!!
|
|
}
|
|
|
|
*(FARPROC *)&lpfnLoadLibraryEx32W =
|
|
GetProcAddress(hmodKernel, gszLoadLibraryEx32W);
|
|
if (lpfnLoadLibraryEx32W == NULL)
|
|
{
|
|
DPF(("Cannot get address of LoadLibrary32... returning FALSE\n"));
|
|
return;
|
|
}
|
|
|
|
*(FARPROC *)&lpfnGetProcAddress32W =
|
|
GetProcAddress(hmodKernel, gszGetProcAddress32W);
|
|
if (lpfnGetProcAddress32W == NULL)
|
|
{
|
|
DPF(("Cannot get address of GetProcAddress32... returning FALSE\n"));
|
|
return;
|
|
}
|
|
|
|
*(FARPROC *)&pvth.lpfnCallproc32W =
|
|
GetProcAddress(hmodKernel, gszCallproc32W);
|
|
if (pvth.lpfnCallproc32W == NULL)
|
|
{
|
|
DPF(("Cannot get address of CallProc32... returning FALSE\n"));
|
|
return;
|
|
}
|
|
|
|
// In case we need to unload our 32 bit libraries...
|
|
*(FARPROC *)&lpfnFreeLibrary32W =
|
|
GetProcAddress(hmodKernel, gszFreeLibrary32W);
|
|
|
|
|
|
|
|
// See if we can get pointers to our thunking entry points
|
|
|
|
|
|
pvth.dwVideo32Handle = (*lpfnLoadLibraryEx32W)(gszVideo32, 0L, 0L);
|
|
|
|
if (pvth.dwVideo32Handle != 0)
|
|
{
|
|
pvth.lpVideoThunkEntry = (*lpfnGetProcAddress32W)(pvth.dwVideo32Handle, gszVideoThunkEntry);
|
|
if (pvth.lpVideoThunkEntry != NULL)
|
|
{
|
|
gfVideo32 = TRUE;
|
|
} else {
|
|
DPF(("Cannot get address of video thunk entry...\n"));
|
|
if (lpfnFreeLibrary32W)
|
|
{
|
|
(*lpfnFreeLibrary32W)(pvth.dwVideo32Handle);
|
|
}
|
|
}
|
|
} else {
|
|
DPF(("Cannot load Video32 DLL...\n"));
|
|
}
|
|
|
|
pvth.dwICM32Handle = (*lpfnLoadLibraryEx32W)(gszICM32, 0L, 0L);
|
|
|
|
if (pvth.dwICM32Handle != 0)
|
|
{
|
|
pvth.lpICMThunkEntry = (*lpfnGetProcAddress32W)(pvth.dwICM32Handle, gszICMThunkEntry);
|
|
if (pvth.lpICMThunkEntry != NULL)
|
|
{
|
|
DPF(("ICM thunks OK!!\n"));
|
|
gfICM32 = TRUE;
|
|
} else {
|
|
DPF(("Cannot get address of ICM thunk entry... trying #2\n"));
|
|
pvth.lpICMThunkEntry = (*lpfnGetProcAddress32W)(pvth.dwICM32Handle, gszICMThunkEntry2);
|
|
if (pvth.lpICMThunkEntry != NULL)
|
|
{
|
|
DPF(("ICM thunks OK!! (at second time of trying)\n"));
|
|
gfICM32 = TRUE;
|
|
} else {
|
|
DPF(("Cannot get address of ICM thunk entry2...\n"));
|
|
if (lpfnFreeLibrary32W)
|
|
{
|
|
(*lpfnFreeLibrary32W)(pvth.dwICM32Handle);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
DPF(("Cannot load ICM32 DLL...\n"));
|
|
}
|
|
|
|
return;
|
|
}
|
|
#endif // !WIN32
|
|
|
|
|
|
|
|
// The following functions generate calls to the 32-bit side
|
|
|
|
|
|
DWORD FAR PASCAL videoMessage32(HVIDEO hVideo, UINT msg, DWORD dwP1, DWORD dwP2)
|
|
{
|
|
/*
|
|
* Check there's something on the other side!
|
|
*/
|
|
|
|
if (!gfVideo32) {
|
|
DPF(("videoMessage32 - no video thunks... returning FALSE\n"));
|
|
return DV_ERR_INVALHANDLE;
|
|
}
|
|
|
|
/*
|
|
* Watch out for hvideos being passed
|
|
*/
|
|
|
|
if (msg == DVM_STREAM_INIT) {
|
|
((LPVIDEO_STREAM_INIT_PARMS)dwP1)->hVideo = hVideo;
|
|
}
|
|
|
|
return((DWORD)(pvth.lpfnCallproc32W)(vidThunkvideoMessage32,
|
|
(DWORD)hVideo,
|
|
(DWORD)msg,
|
|
(DWORD)dwP1,
|
|
(DWORD)dwP2,
|
|
pvth.lpVideoThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L));
|
|
}
|
|
|
|
|
|
DWORD FAR PASCAL videoGetNumDevs32(void)
|
|
{
|
|
if (!gfVideo32) {
|
|
DPF(("videoGetNumDevs32 - no video thunks... returning FALSE\n"));
|
|
return 0;
|
|
}
|
|
|
|
return((DWORD)(pvth.lpfnCallproc32W)(vidThunkvideoGetNumDevs32,
|
|
(DWORD)0,
|
|
(DWORD)0,
|
|
(DWORD)0,
|
|
(DWORD)0,
|
|
pvth.lpVideoThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L));
|
|
}
|
|
|
|
DWORD FAR PASCAL videoClose32(HVIDEO hVideo)
|
|
{
|
|
/*
|
|
* Check there's something on the other side!
|
|
*/
|
|
|
|
if (!gfVideo32) {
|
|
DPF(("videoClose32 - no video thunks... returning FALSE\n"));
|
|
return DV_ERR_INVALHANDLE;
|
|
}
|
|
|
|
return((DWORD)(pvth.lpfnCallproc32W)(vidThunkvideoClose32,
|
|
(DWORD)hVideo,
|
|
(DWORD)0,
|
|
(DWORD)0,
|
|
(DWORD)0,
|
|
pvth.lpVideoThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L));
|
|
}
|
|
|
|
DWORD FAR PASCAL videoOpen32(LPHVIDEO lphVideo, DWORD dwDeviceID, DWORD dwFlags)
|
|
{
|
|
DWORD dwRetc;
|
|
|
|
if (!gfVideo32) {
|
|
DPF(("videoOpen32 - no video thunks... returning FALSE\n"));
|
|
return DV_ERR_NOTDETECTED;
|
|
}
|
|
|
|
dwRetc = ((DWORD)(pvth.lpfnCallproc32W)(vidThunkvideoOpen32,
|
|
(DWORD)lphVideo,
|
|
(DWORD)dwDeviceID,
|
|
(DWORD)dwFlags,
|
|
(DWORD)0,
|
|
pvth.lpVideoThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L));
|
|
|
|
if (dwRetc == DV_ERR_OK) {
|
|
#ifdef DEBUG
|
|
if (Is32bitHandle(*lphVideo)) {
|
|
//OutputDebugString("\nMSVIDEO : 32-bit handle does not fit in 16 bits!");
|
|
DebugBreak();
|
|
}
|
|
#endif
|
|
|
|
*lphVideo = Make32bitHandle(*lphVideo);
|
|
}
|
|
|
|
return dwRetc;
|
|
}
|
|
|
|
|
|
DWORD FAR PASCAL videoGetDriverDesc32(DWORD wDriverIndex,
|
|
LPSTR lpszName, short cbName,
|
|
LPSTR lpszVer, short cbVer)
|
|
{
|
|
if (!gfVideo32) {
|
|
DPF(("videoGetDriverDesc32 - no video thunks... returning FALSE\n"));
|
|
return DV_ERR_NOTDETECTED;
|
|
}
|
|
|
|
return (BOOL)(pvth.lpfnCallproc32W)(vidThunkvideoGetDriverDesc32,
|
|
(DWORD)wDriverIndex,
|
|
(DWORD)lpszName,
|
|
(DWORD)lpszVer,
|
|
(DWORD) MAKELONG(cbName, cbVer),
|
|
pvth.lpVideoThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L); // 5 params
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* The ICM thunking uses the same mechanism as for Video, but calls to a
|
|
* different 32 bit DLL.
|
|
*/
|
|
|
|
BOOL FAR PASCAL ICInfo32(DWORD fccType, DWORD fccHandler, ICINFO FAR * lpicInfo)
|
|
{
|
|
if (!gfICM32) {
|
|
//OutputDebugString("ICInfo32: gfICM32 is not set - returning FALSE\n");
|
|
return FALSE;
|
|
}
|
|
|
|
return ((BOOL)(pvth.lpfnCallproc32W)(compThunkICInfo32,
|
|
(DWORD)fccType,
|
|
(DWORD)fccHandler,
|
|
(DWORD)lpicInfo,
|
|
(DWORD)0,
|
|
pvth.lpICMThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L));
|
|
}
|
|
|
|
|
|
LRESULT FAR PASCAL ICSendMessage32(DWORD hic, UINT msg, DWORD dwP1, DWORD dwP2)
|
|
{
|
|
/*
|
|
* Check there's something on the other side!
|
|
*/
|
|
|
|
if (!gfICM32) {
|
|
#ifdef DEBUG
|
|
OutputDebugString("ICSendMessage32: gfICM32 is not set - returning FALSE\n");
|
|
#endif
|
|
return ICERR_BADHANDLE;
|
|
}
|
|
|
|
return ((LRESULT)(pvth.lpfnCallproc32W)(compThunkICSendMessage32,
|
|
(DWORD)hic,
|
|
(DWORD)msg,
|
|
(DWORD)dwP1,
|
|
(DWORD)dwP2,
|
|
pvth.lpICMThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L));
|
|
}
|
|
|
|
DWORD FAR PASCAL ICOpen32(DWORD fccType, DWORD fccHandler, UINT wMode)
|
|
{
|
|
/*
|
|
* Check there's something on the other side!
|
|
*/
|
|
|
|
if (!gfICM32) {
|
|
#ifdef DEBUG
|
|
OutputDebugString("ICOpen32: gfICM32 is not set - returning FALSE\n");
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
return ((DWORD)(pvth.lpfnCallproc32W)(compThunkICOpen32,
|
|
(DWORD)fccType,
|
|
(DWORD)fccHandler,
|
|
(DWORD)wMode,
|
|
(DWORD)0,
|
|
pvth.lpICMThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L));
|
|
}
|
|
|
|
|
|
LRESULT FAR PASCAL ICClose32(DWORD hic)
|
|
{
|
|
/*
|
|
* Check there's something on the other side!
|
|
*/
|
|
|
|
if (!gfICM32) {
|
|
#ifdef DEBUG
|
|
OutputDebugString("ICClose32: gfICM32 is not set - returning FALSE\n");
|
|
#endif
|
|
return ICERR_BADHANDLE;
|
|
}
|
|
|
|
return ((LRESULT)(pvth.lpfnCallproc32W)(compThunkICClose32,
|
|
(DWORD)hic,
|
|
(DWORD)0,
|
|
(DWORD)0,
|
|
(DWORD)0,
|
|
pvth.lpICMThunkEntry,
|
|
0L, // no mapping of pointers
|
|
5L));
|
|
}
|