923 lines
24 KiB
C
923 lines
24 KiB
C
//==========================================================================;
|
|
// thunk32.c
|
|
//
|
|
// Copyright (c) 1991-1994 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// Description:
|
|
// This module contains routines for thunking the video APIs
|
|
// from 16-bit Windows to 32-bit WOW.
|
|
//
|
|
// History:
|
|
//
|
|
//==========================================================================;
|
|
|
|
/*
|
|
|
|
WOW Thunking design:
|
|
|
|
Thunks are generated as follows :
|
|
|
|
16-bit :
|
|
|
|
*/
|
|
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <mmsystem.h>
|
|
#include <mmddk.h>
|
|
#include <mmreg.h>
|
|
#include <memory.h>
|
|
#include <win32.h>
|
|
#ifdef _WIN32
|
|
#include <ivideo32.h>
|
|
#else
|
|
#include <msvideo.h>
|
|
#endif
|
|
#include <msviddrv.h>
|
|
#include <msvideoi.h>
|
|
#ifdef _WIN32
|
|
#include <wownt32.h>
|
|
#include <stdlib.h> // for mbstowcs and wcstombs
|
|
#include <video16.h>
|
|
#ifdef UNICODE
|
|
#include "profile.h" // NT only (for now?)
|
|
#endif
|
|
#endif // WIN32
|
|
|
|
// in capinit.c
|
|
BOOL capInternalGetDriverDescA(UINT wDriverIndex,
|
|
LPSTR lpszName, int cbName,
|
|
LPSTR lpszVer, int cbVer);
|
|
|
|
//
|
|
// pick up the function definitions
|
|
//
|
|
|
|
#include "vidthunk.h"
|
|
|
|
#ifdef DEBUG
|
|
#define MODNAME "AVICAP32"
|
|
int videoDebugLevel = -1;
|
|
void videoDebugInit(VOID)
|
|
{
|
|
if (videoDebugLevel == -1)
|
|
videoDebugLevel = GetProfileIntA("Debug", MODNAME, 0);
|
|
}
|
|
#else
|
|
#define videoDebugInit()
|
|
#endif
|
|
|
|
/* -------------------------------------------------------------------------
|
|
** Handle and memory mapping functions.
|
|
** -------------------------------------------------------------------------
|
|
*/
|
|
LPWOWHANDLE32 lpWOWHandle32;
|
|
LPWOWHANDLE16 lpWOWHandle16;
|
|
LPWOWCALLBACK16 lpWOWCallback16;
|
|
LPGETVDMPOINTER GetVdmPointer;
|
|
int ThunksInitialized;
|
|
|
|
#ifdef WIN32
|
|
#ifdef DEBUG
|
|
void FAR cdecl thkdprintf(LPSTR szFormat, ...)
|
|
{
|
|
char ach[128];
|
|
va_list va;
|
|
|
|
#define MARKER "AVICAP (thunk): "
|
|
lstrcpyA(ach, MARKER);
|
|
|
|
va_start(va, szFormat);
|
|
wvsprintfA(ach+sizeof(MARKER), szFormat, va);
|
|
va_end(va);
|
|
OutputDebugStringA(ach);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
//
|
|
// 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 = GetVdmPointer((DWORD)Dest16, Length, TRUE);
|
|
|
|
CopyMemory(Dest32, Src32, Length);
|
|
}
|
|
|
|
|
|
/*
|
|
* 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 = GetVdmPointer((DWORD)Src16, Length, TRUE);
|
|
|
|
CopyMemory(Dest32, Src32, Length);
|
|
}
|
|
|
|
/*
|
|
* Copy data from source to dest where source is a 16bit pointer
|
|
* and dest is a 32bit pointer ONLY if the source is not aligned
|
|
*
|
|
* Returns which pointer to use (src or dest)
|
|
*/
|
|
LPVOID CopyIfNotAligned(LPVOID Dest32, LPVOID Src16, DWORD Length)
|
|
{
|
|
PVOID Src32;
|
|
|
|
if (Src16 == NULL) {
|
|
return Dest32;
|
|
}
|
|
|
|
Src32 = GetVdmPointer((DWORD)Src16, Length, TRUE);
|
|
|
|
CopyMemory(Dest32, Src32, Length);
|
|
|
|
return Dest32;
|
|
}
|
|
|
|
|
|
typedef struct _callback {
|
|
WORD flags;
|
|
WORD hVideo16;
|
|
WORD msg;
|
|
DWORD dwCallback16inst;
|
|
DWORD dw1;
|
|
DWORD dw2;
|
|
} CALLBACK16;
|
|
typedef CALLBACK16 * PCALLBACK16;
|
|
|
|
/*
|
|
* Callbacks
|
|
*/
|
|
|
|
void MyVideoCallback(HANDLE handle,
|
|
UINT msg,
|
|
DWORD dwUser,
|
|
DWORD dw1,
|
|
DWORD dw2)
|
|
{
|
|
PVIDEOINSTANCEDATA32 pInst;
|
|
BOOL fFree = FALSE;
|
|
|
|
pInst = (PVIDEOINSTANCEDATA32)dwUser;
|
|
|
|
DPF3(("Video callback - handle = %8X, msg = %8X, dwUser = %8X, dw1 = %8X, dw2 = %8X\n",
|
|
handle, msg, dwUser, dw1, dw2));
|
|
|
|
switch (msg) {
|
|
|
|
/*
|
|
* What are the parameters for these messages ??
|
|
*/
|
|
|
|
case MM_DRVM_OPEN:
|
|
|
|
/*
|
|
* We get this when we INIT_STREAM
|
|
*/
|
|
|
|
break;
|
|
|
|
case MM_DRVM_CLOSE:
|
|
|
|
/*
|
|
* Device is closing - this is where we free our structures
|
|
* (just in case the 32-bit side called close to clean up).
|
|
* dwUser points to our data
|
|
*/
|
|
|
|
fFree = TRUE;
|
|
|
|
break;
|
|
|
|
case MM_DRVM_DATA:
|
|
|
|
/*
|
|
* We have data - this means a buffer has been returned in
|
|
* dw1
|
|
*/
|
|
|
|
{
|
|
PVIDEOHDR32 pHdr32;
|
|
|
|
pHdr32 = CONTAINING_RECORD((PVIDEOHDR)dw1,
|
|
VIDEOHDR32,
|
|
videoHdr);
|
|
|
|
dw1 = (DWORD)pHdr32->pHdr16; // For callback below
|
|
|
|
/*
|
|
* Map back the data and free our structure
|
|
*/
|
|
|
|
{
|
|
VIDEOHDR Hdr16;
|
|
Hdr16 = pHdr32->videoHdr;
|
|
Hdr16.lpData = pHdr32->lpData16;
|
|
memcpy(pHdr32->pHdr32, (LPVOID)&Hdr16, sizeof(VIDEOHDR));
|
|
}
|
|
|
|
/*
|
|
* Clean up our local structure
|
|
*/
|
|
|
|
LocalFree((HLOCAL)pHdr32);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MM_DRVM_ERROR:
|
|
/*
|
|
* dw1 = frames skipped - unfortunately there's nobody to tell!
|
|
*/
|
|
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Call back the application if appropriate
|
|
*/
|
|
|
|
switch (pInst->dwFlags & CALLBACK_TYPEMASK) {
|
|
case CALLBACK_WINDOW:
|
|
PostMessage(ThunkHWND(LOWORD(pInst->dwCallback)),
|
|
msg, (WPARAM)handle, (LPARAM)dw1);
|
|
break;
|
|
|
|
case CALLBACK_FUNCTION:
|
|
#if 0
|
|
// Must call a generic 16 bit callback passing a pointer to
|
|
// a parameter array.
|
|
{
|
|
|
|
WORD hMem;
|
|
PCALLBACK16 pCallStruct;
|
|
pCallStruct = WOWGlobalAllocLock16(0, sizeof(CALLBACK16), &hMem);
|
|
if (pCallStruct) {
|
|
pCallStruct->flags = HIWORD(pInst->dwFlags);
|
|
pCallStruct->hVideo16 = (WORD)pInst->hVideo;
|
|
pCallStruct->msg = (WORD)msg;
|
|
pCallStruct->dwCallback16inst = pInst->dwCallbackInst;
|
|
pCallStruct->dw1 = (DWORD)dw1;
|
|
pCallStruct->dw2 = (DWORD)dw2;
|
|
|
|
lpWOWCallback16(pInst->dwCallback, pCallStruct);
|
|
|
|
// Now free off the callback structure
|
|
WOWGlobalUnlockFree16(pCallStruct);
|
|
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
if (fFree) {
|
|
LocalFree((HLOCAL)pInst);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Thunking callbacks to WOW32 (or wherever)
|
|
//
|
|
|
|
//--------------------------------------------------------------------------;
|
|
//
|
|
// DWORD videoThunk32
|
|
//
|
|
// Description:
|
|
//
|
|
// 32-bit function dispatcher for thunks.
|
|
//
|
|
// Arguments:
|
|
// DWORD dwThunkId:
|
|
//
|
|
// DWORD dw1:
|
|
//
|
|
// DWORD dw2:
|
|
//
|
|
// DWORD dw3:
|
|
//
|
|
// DWORD dw4:
|
|
//
|
|
// Return (DWORD):
|
|
//
|
|
// History:
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
DWORD videoThunk32(DWORD dwThunkId,DWORD dw1,DWORD dw2,DWORD dw3,DWORD dw4)
|
|
{
|
|
//
|
|
// Make sure we've got thunking functionality
|
|
//
|
|
if (ThunksInitialized <= 0) {
|
|
|
|
HMODULE hMod;
|
|
|
|
if (ThunksInitialized == -1) {
|
|
return MMSYSERR_ERROR;
|
|
}
|
|
|
|
videoDebugInit();
|
|
|
|
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 ) {
|
|
|
|
ThunksInitialized = -1;
|
|
return MMSYSERR_ERROR;
|
|
|
|
} else {
|
|
ThunksInitialized = 1;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Perform the requested function
|
|
//
|
|
|
|
switch (dwThunkId) {
|
|
|
|
case vidThunkvideoMessage32:
|
|
return videoMessage32((HVIDEO)dw1, (UINT)dw2, dw3, dw4);
|
|
break;
|
|
|
|
case vidThunkvideoGetNumDevs32:
|
|
return videoGetNumDevs32();
|
|
break;
|
|
|
|
case vidThunkvideoOpen32:
|
|
return videoOpen32((LPHVIDEO)dw1, dw2, dw3);
|
|
break;
|
|
|
|
case vidThunkvideoClose32:
|
|
return videoClose32((HVIDEO)dw1);
|
|
break;
|
|
|
|
case vidThunkvideoGetDriverDesc32:
|
|
{
|
|
LPSTR lpszName = NULL, lpszVer = NULL;
|
|
short cbName, cbVer;
|
|
DWORD dwRet;
|
|
|
|
cbName = (short) LOWORD(dw4);
|
|
cbVer = (short) HIWORD(dw4);
|
|
|
|
// for chicago, need to call WOW32GetVdmPointerFix
|
|
// (via getprocaddr!)
|
|
|
|
if ((dw2 != 0) && (cbName > 0)) {
|
|
lpszName = WOW32ResolveMemory(dw2);
|
|
}
|
|
if ((dw3 != 0) && (cbVer > 0)) {
|
|
lpszVer = WOW32ResolveMemory(dw3);
|
|
}
|
|
|
|
|
|
dwRet = capInternalGetDriverDescA(
|
|
dw1, // device id
|
|
lpszName,
|
|
cbName,
|
|
lpszVer,
|
|
cbVer);
|
|
|
|
#if 0 //should do this for chicago
|
|
if (lpszName) {
|
|
WOWGetVDMPointerUnfix(dw2);
|
|
}
|
|
if (lpszVer) {
|
|
WOWGetVDMPointerUnfix(dw3);
|
|
}
|
|
#endif
|
|
return dwRet;
|
|
}
|
|
|
|
|
|
default:
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
|
|
DWORD FAR PASCAL videoMessage32(HVIDEO hVideo, UINT msg, DWORD dwP1, DWORD dwP2)
|
|
{
|
|
StartThunk(videoMessage);
|
|
DPF2(("\tvideoMessage id = %4X, lParam1 = %8X, lParam2 = %8X",
|
|
msg, dwP1, dwP2));
|
|
|
|
/*
|
|
* We ONLY support (and we only ever will support) messages which
|
|
* have ALREADY been defined. New 32-bit driver messages will NOT
|
|
* be supported from 16-bit apps.
|
|
*/
|
|
|
|
switch (msg) {
|
|
case DVM_GETVIDEOAPIVER:
|
|
{
|
|
DWORD ApiVer;
|
|
|
|
ReturnCode = videoMessage((HVIDEO)hVideo,
|
|
(UINT)msg,
|
|
(DWORD)&ApiVer,
|
|
dwP2);
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
CopyTo16Bit((LPVOID)dwP1, &ApiVer, sizeof(DWORD));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DVM_GETERRORTEXT:
|
|
{
|
|
VIDEO_GETERRORTEXT_PARMS vet;
|
|
VIDEO_GETERRORTEXT_PARMS MappedVet;
|
|
|
|
/*
|
|
* Get the parameter block
|
|
*/
|
|
|
|
CopyTo32Bit((LPVOID)&vet, (LPVOID)dwP1, sizeof(vet));
|
|
MappedVet = vet;
|
|
|
|
/*
|
|
* Map the string pointer
|
|
*/
|
|
|
|
MappedVet.lpText = WOW32ResolveMemory(vet.lpText);
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)&MappedVet,
|
|
0);
|
|
}
|
|
break;
|
|
|
|
case DVM_GET_CHANNEL_CAPS:
|
|
{
|
|
CHANNEL_CAPS Caps;
|
|
|
|
ReturnCode = videoMessage((HVIDEO)hVideo,
|
|
(UINT)msg,
|
|
(DWORD)&Caps,
|
|
dwP2);
|
|
|
|
/*
|
|
* If successful return the data to the 16-bit app
|
|
*/
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
CopyTo16Bit((LPVOID)dwP1, (LPVOID)&Caps,
|
|
sizeof(Caps));
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case DVM_UPDATE:
|
|
{
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)ThunkHWND(dwP1),
|
|
(DWORD)ThunkHDC(dwP2));
|
|
}
|
|
break;
|
|
|
|
case DVM_PALETTE:
|
|
case DVM_PALETTERGB555:
|
|
case DVM_FORMAT:
|
|
/*
|
|
* This stuff all comes from videoConfigure
|
|
*
|
|
* Let's hope this data is all DWORDs!
|
|
*/
|
|
{
|
|
VIDEOCONFIGPARMS vcp, MappedVcp;
|
|
DWORD dwReturn;
|
|
|
|
BOOL Ok;
|
|
|
|
Ok = TRUE;
|
|
|
|
CopyTo32Bit((LPVOID)&vcp, (LPVOID)dwP2, sizeof(vcp));
|
|
MappedVcp.lpdwReturn = &dwReturn;
|
|
MappedVcp.dwSize1 = vcp.dwSize1;
|
|
MappedVcp.dwSize2 = vcp.dwSize2;
|
|
|
|
/*
|
|
* Get some storage to store the answer
|
|
*/
|
|
|
|
if (MappedVcp.dwSize1 != 0) {
|
|
MappedVcp.lpData1 = (LPSTR)LocalAlloc(LPTR, MappedVcp.dwSize1);
|
|
if (MappedVcp.lpData1 == NULL) {
|
|
Ok = FALSE;
|
|
} else {
|
|
if (MappedVcp.dwSize2 != 0) {
|
|
MappedVcp.lpData2 = (LPSTR)LocalAlloc(LPTR, MappedVcp.dwSize2);
|
|
if (MappedVcp.lpData2 == NULL) {
|
|
Ok = FALSE;
|
|
|
|
if (MappedVcp.dwSize1 != 0) {
|
|
LocalFree((HLOCAL)MappedVcp.lpData1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Ok) {
|
|
|
|
CopyTo32Bit(MappedVcp.lpData1, vcp.lpData1, MappedVcp.dwSize1);
|
|
CopyTo32Bit(MappedVcp.lpData2, vcp.lpData2, MappedVcp.dwSize2);
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
dwP1,
|
|
(DWORD)&MappedVcp);
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
|
|
if (vcp.lpdwReturn != NULL) {
|
|
CopyTo16Bit(vcp.lpdwReturn, MappedVcp.lpdwReturn,
|
|
sizeof(DWORD));
|
|
}
|
|
|
|
CopyTo16Bit(vcp.lpData1, MappedVcp.lpData1, MappedVcp.dwSize1);
|
|
CopyTo16Bit(vcp.lpData2, MappedVcp.lpData2, MappedVcp.dwSize2);
|
|
}
|
|
|
|
if (MappedVcp.dwSize1 != 0) {
|
|
LocalFree((HLOCAL)MappedVcp.lpData1);
|
|
}
|
|
if (MappedVcp.dwSize2 != 0) {
|
|
LocalFree((HLOCAL)MappedVcp.lpData2);
|
|
}
|
|
} else {
|
|
ReturnCode = DV_ERR_NOMEM;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DVM_CONFIGURESTORAGE:
|
|
{
|
|
LPSTR lpStrIdent;
|
|
lpStrIdent = WOW32ResolveMemory(dwP1);
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)lpStrIdent,
|
|
dwP2);
|
|
|
|
}
|
|
break;
|
|
|
|
case DVM_DIALOG:
|
|
{
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)ThunkHWND(dwP1),
|
|
dwP2);
|
|
}
|
|
break;
|
|
|
|
case DVM_SRC_RECT:
|
|
case DVM_DST_RECT:
|
|
/*
|
|
* If it's a query only then don't bother with the
|
|
* rectangle
|
|
*/
|
|
|
|
if (dwP2 & VIDEO_CONFIGURE_QUERY) {
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
dwP1,
|
|
dwP2);
|
|
} else {
|
|
|
|
/*
|
|
* The rectangle is regarded as 'in' and 'out'
|
|
* We need to translate between 16-bit and 32-bit rectangle structures
|
|
*/
|
|
|
|
RECT_SHORT SRect;
|
|
RECT Rect;
|
|
|
|
CopyTo32Bit((LPVOID)&SRect, (LPVOID)dwP1, sizeof(SRect));
|
|
|
|
SHORT_RECT_TO_RECT(Rect, SRect);
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)&Rect,
|
|
dwP2);
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
RECT_TO_SHORT_RECT(SRect, Rect);
|
|
CopyTo16Bit((LPVOID)dwP1, (LPVOID)&SRect, sizeof(SRect));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DVM_STREAM_PREPAREHEADER:
|
|
case DVM_STREAM_UNPREPAREHEADER:
|
|
case DVM_FRAME:
|
|
case DVM_STREAM_ADDBUFFER:
|
|
{
|
|
VIDEOHDR Hdr32;
|
|
LPBYTE pData16, pData32;
|
|
DWORD dwSize;
|
|
|
|
dwSize = (UINT)msg == DVM_FRAME ? sizeof(VIDEOHDR) :
|
|
min(dwP2, sizeof(VIDEOHDR));
|
|
|
|
CopyTo32Bit((LPVOID)&Hdr32, (LPVOID)dwP1, dwSize);
|
|
|
|
pData16 = Hdr32.lpData;
|
|
|
|
/*
|
|
* Create a mapping for the pointer
|
|
*/
|
|
|
|
pData32 = GetVdmPointer((DWORD)pData16, Hdr32.dwBufferLength, TRUE);
|
|
Hdr32.lpData = pData32;
|
|
|
|
if (msg == DVM_STREAM_ADDBUFFER) {
|
|
|
|
PVIDEOHDR32 pHdr32;
|
|
|
|
/*
|
|
* Allocate our callback structure and pass this
|
|
* as our header (suitably offset to the video header part).
|
|
*/
|
|
|
|
pHdr32 = (PVIDEOHDR32)LocalAlloc(LPTR, sizeof(VIDEOHDR32));
|
|
|
|
if (pHdr32 == NULL) {
|
|
ReturnCode = DV_ERR_NOMEM;
|
|
} else {
|
|
|
|
/*
|
|
* Remember the old header so we can pass it back
|
|
* and the old data pointer so we can flush it
|
|
*/
|
|
|
|
pHdr32->pHdr16 = (LPVOID)dwP1;
|
|
|
|
/*
|
|
* Some systems can't handle GetVdmPointer at interrupt
|
|
* time so get a pointer here
|
|
*/
|
|
|
|
pHdr32->pHdr32 = WOW32ResolveMemory(dwP1);
|
|
pHdr32->lpData16 = pData16;
|
|
pHdr32->videoHdr = Hdr32;
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)&pHdr32->videoHdr,
|
|
dwP2);
|
|
/*
|
|
* If everything was OK copy it back
|
|
*/
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
Hdr32.lpData = pData16;
|
|
CopyTo16Bit((LPVOID)dwP1, (LPVOID)&Hdr32, dwSize);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
* Prepare/unprepare the header for 32bit
|
|
*/
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)&Hdr32,
|
|
dwP2);
|
|
|
|
/*
|
|
* If everything was OK copy it back
|
|
*/
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
Hdr32.lpData = pData16;
|
|
CopyTo16Bit((LPVOID)dwP1, (LPVOID)&Hdr32, dwSize);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DVM_STREAM_RESET:
|
|
case DVM_STREAM_FINI:
|
|
case DVM_STREAM_STOP:
|
|
case DVM_STREAM_START:
|
|
|
|
/*
|
|
* Note that the MM_DRVM_CLOSE message will cause us to clean up our
|
|
* callback structures on DVM_STREAM_FINI.
|
|
*/
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
0,
|
|
0);
|
|
break;
|
|
|
|
case DVM_STREAM_GETPOSITION:
|
|
{
|
|
MMTIME mmTime;
|
|
MMTIME16 mmTime16;
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)&mmTime,
|
|
sizeof(mmTime));
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
mmTime16.wType = (WORD)mmTime.wType;
|
|
CopyMemory((LPVOID)&mmTime16.u,
|
|
(LPVOID)&mmTime.u, sizeof(mmTime16.u));
|
|
|
|
CopyTo16Bit((LPVOID)dwP1, (LPVOID)&mmTime16,
|
|
min(sizeof(mmTime16), dwP2));
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case DVM_STREAM_INIT:
|
|
{
|
|
VIDEO_STREAM_INIT_PARMS vsip;
|
|
VIDEO_STREAM_INIT_PARMS * pvsip = WOW32ResolveMemory(dwP1);
|
|
PVIDEOINSTANCEDATA32 pInst32;
|
|
|
|
#if 0
|
|
// always do callback
|
|
if (!(pvsip->dwFlags & CALLBACK_TYPEMASK)) {
|
|
// No callback wanted by the 16 bit code. Pass call
|
|
// straight through
|
|
|
|
ReturnCode = videoMessage((HVIDEO)hVideo,
|
|
(UINT)msg,
|
|
(DWORD)pvsip,
|
|
(DWORD)dwP2);
|
|
|
|
} else
|
|
#endif
|
|
{
|
|
// We set up a callback to a 32 bit routine, that in
|
|
// turn will callback to the 16 bit function/window
|
|
pInst32 = (PVIDEOINSTANCEDATA32)
|
|
LocalAlloc(LPTR, sizeof(VIDEOINSTANCEDATA32));
|
|
|
|
if (pInst32 == NULL) {
|
|
ReturnCode = DV_ERR_NOMEM;
|
|
} else {
|
|
CopyTo32Bit((LPVOID)&vsip, (LPVOID)dwP1,
|
|
min(sizeof(vsip), dwP2));
|
|
|
|
pInst32->dwFlags = vsip.dwFlags;
|
|
pInst32->dwCallbackInst = vsip.dwCallbackInst;
|
|
pInst32->dwCallback = vsip.dwCallback;
|
|
pInst32->hVideo = (HVIDEO16)vsip.hVideo;
|
|
|
|
/*
|
|
* Make up our own parms. Only set up a callback if
|
|
* the user wanted one
|
|
*/
|
|
|
|
vsip.dwCallback = (DWORD)MyVideoCallback;
|
|
vsip.dwFlags = (vsip.dwFlags & ~CALLBACK_TYPEMASK) |
|
|
CALLBACK_FUNCTION;
|
|
vsip.dwCallbackInst = (DWORD)pInst32;
|
|
|
|
ReturnCode = videoMessage((HVIDEO)hVideo,
|
|
(UINT)msg,
|
|
(DWORD)&vsip,
|
|
(DWORD)dwP2);
|
|
|
|
if (ReturnCode != DV_ERR_OK) {
|
|
LocalFree((HLOCAL)pInst32);
|
|
} else {
|
|
// The instance block will be freed off by the
|
|
// 32 bit callback routine when all over
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DVM_STREAM_GETERROR:
|
|
{
|
|
DWORD dwError;
|
|
DWORD dwFramesSkipped;
|
|
|
|
ReturnCode = videoMessage(hVideo,
|
|
msg,
|
|
(DWORD)&dwError,
|
|
(DWORD)&dwFramesSkipped);
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
CopyTo16Bit((LPVOID)dwP1, &dwError, sizeof(DWORD));
|
|
CopyTo16Bit((LPVOID)dwP2, &dwFramesSkipped, sizeof(DWORD));
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DPF2(("videoMessage - Message not implemented %X\n", (UINT)msg));
|
|
ReturnCode = DV_ERR_NOTSUPPORTED;
|
|
|
|
}
|
|
EndThunk();
|
|
}
|
|
|
|
INLINE DWORD FAR PASCAL videoGetNumDevs32(void)
|
|
{
|
|
StartThunk(videoGetNumDevs);
|
|
ReturnCode = videoGetNumDevs();
|
|
EndThunk();
|
|
}
|
|
|
|
DWORD FAR PASCAL videoClose32(HVIDEO hVideo)
|
|
{
|
|
StartThunk(videoClose)
|
|
ReturnCode = videoClose(hVideo);
|
|
EndThunk();
|
|
}
|
|
|
|
DWORD FAR PASCAL videoOpen32(LPHVIDEO lphVideo, DWORD dwDeviceID, DWORD dwFlags)
|
|
{
|
|
HVIDEO hVideo;
|
|
StartThunk(videoOpen);
|
|
|
|
ReturnCode = videoOpen(
|
|
&hVideo,
|
|
dwDeviceID,
|
|
dwFlags);
|
|
|
|
if (ReturnCode == DV_ERR_OK) {
|
|
lphVideo = WOW32ResolveMemory((PVOID)lphVideo);
|
|
* (HVIDEO UNALIGNED *)lphVideo = hVideo;
|
|
}
|
|
EndThunk();
|
|
}
|
|
|
|
|