Windows2000/private/windows/media/avi/avicap/thunk32.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();
}