You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
384 lines
12 KiB
384 lines
12 KiB
|
|
|
|
/*----------------------------------------------------------------------+
|
|
| |
|
|
| drvproc.c - driver procedure |
|
|
| |
|
|
| Copyright (c) 1993 Microsoft Corporation. |
|
|
| All Rights Reserved. |
|
|
| |
|
|
+----------------------------------------------------------------------*/
|
|
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <mmsystem.h>
|
|
|
|
#include "msyuv.h"
|
|
|
|
HMODULE ghModule; // Our DLL module handle
|
|
|
|
|
|
/***************************************************************************
|
|
* DriverProc - The entry point for an installable driver.
|
|
*
|
|
* PARAMETERS
|
|
* dwDriverId: For most messages, <dwDriverId> is the DWORD
|
|
* value that the driver returns in response to a <DRV_OPEN> message.
|
|
* Each time that the driver is opened, through the <DrvOpen> API,
|
|
* the driver receives a <DRV_OPEN> message and can return an
|
|
* arbitrary, non-zero value. The installable driver interface
|
|
* saves this value and returns a unique driver handle to the
|
|
* application. Whenever the application sends a message to the
|
|
* driver using the driver handle, the interface routes the message
|
|
* to this entry point and passes the corresponding <dwDriverId>.
|
|
* This mechanism allows the driver to use the same or different
|
|
* identifiers for multiple opens but ensures that driver handles
|
|
* are unique at the application interface layer.
|
|
*
|
|
* The following messages are not related to a particular open
|
|
* instance of the driver. For these messages, the dwDriverId
|
|
* will always be zero.
|
|
*
|
|
* DRV_LOAD, DRV_FREE, DRV_ENABLE, DRV_DISABLE, DRV_OPEN
|
|
*
|
|
* hDriver: This is the handle returned to the application by the
|
|
* driver interface.
|
|
*
|
|
* uiMessage: The requested action to be performed. Message
|
|
* values below <DRV_RESERVED> are used for globally defined messages.
|
|
* Message values from <DRV_RESERVED> to <DRV_USER> are used for
|
|
* defined driver protocols. Messages above <DRV_USER> are used
|
|
* for driver specific messages.
|
|
*
|
|
* lParam1: Data for this message. Defined separately for
|
|
* each message
|
|
*
|
|
* lParam2: Data for this message. Defined separately for
|
|
* each message
|
|
*
|
|
* RETURNS
|
|
* Defined separately for each message.
|
|
*
|
|
***************************************************************************/
|
|
|
|
LRESULT DriverProc(PINSTINFO pi, HDRVR hDriver, UINT uiMessage, LPARAM lParam1, LPARAM lParam2)
|
|
{
|
|
|
|
switch (uiMessage)
|
|
{
|
|
case DRV_LOAD:
|
|
dprintf2((TEXT("DRV_LOAD:\n")));
|
|
#ifdef _WIN32
|
|
if (ghModule) {
|
|
// AVI explicitly loads us as well, but does not pass the
|
|
// correct (as known by WINMM) driver handle.
|
|
} else {
|
|
ghModule = (HANDLE) GetDriverModuleHandle(hDriver);
|
|
}
|
|
#endif
|
|
return (LRESULT) 1L;
|
|
|
|
case DRV_FREE:
|
|
dprintf2((TEXT("DRV_FREE:\n")));
|
|
return (LRESULT)1L;
|
|
|
|
case DRV_OPEN:
|
|
dprintf2((TEXT("DRV_OPEN\n")));
|
|
// if being opened with no open struct, then return a non-zero
|
|
// value without actually opening
|
|
if (lParam2 == 0L)
|
|
return 0xFFFF0000;
|
|
|
|
return (LRESULT)(DWORD_PTR) Open((ICOPEN FAR *) lParam2);
|
|
|
|
case DRV_CLOSE:
|
|
dprintf2((TEXT("DRV_CLOSE:\n")));
|
|
#ifdef _WIN32
|
|
if (pi != (PINSTINFO)(ULONG_PTR)0xFFFF0000)
|
|
#else
|
|
if (pi)
|
|
#endif
|
|
Close(pi);
|
|
|
|
return (LRESULT)1L;
|
|
|
|
/*********************************************************************
|
|
|
|
state messages
|
|
|
|
*********************************************************************/
|
|
|
|
case DRV_QUERYCONFIGURE: // configuration from drivers applet
|
|
dprintf2((TEXT("DRV_QUERYCONFIGURE:\n")));
|
|
return (LRESULT)0L;
|
|
|
|
case DRV_CONFIGURE:
|
|
dprintf2((TEXT("DRV_CONFIGURE:\n")));
|
|
return DRV_OK;
|
|
|
|
case ICM_CONFIGURE:
|
|
dprintf2((TEXT("ICM_CONFIGURE:\n")));
|
|
//
|
|
// return ICERR_OK if you will do a configure box, error otherwise
|
|
//
|
|
if (lParam1 == -1)
|
|
return QueryConfigure(pi) ? ICERR_OK : ICERR_UNSUPPORTED;
|
|
else
|
|
return Configure(pi, (HWND)lParam1);
|
|
|
|
case ICM_ABOUT:
|
|
dprintf2((TEXT("ICM_ABOUT:\n")));
|
|
//
|
|
// return ICERR_OK if you will do a about box, error otherwise
|
|
//
|
|
if (lParam1 == -1)
|
|
return QueryAbout(pi) ? ICERR_OK : ICERR_UNSUPPORTED;
|
|
else
|
|
return About(pi, (HWND)lParam1);
|
|
|
|
case ICM_GETSTATE:
|
|
dprintf1((TEXT("ICM_GETSTATE:\n")));
|
|
return GetState(pi, (LPVOID)lParam1, (DWORD)lParam2);
|
|
|
|
case ICM_SETSTATE:
|
|
dprintf1((TEXT("ICM_SETSTATE:\n")));
|
|
return SetState(pi, (LPVOID)lParam1, (DWORD)lParam2);
|
|
|
|
case ICM_GETINFO:
|
|
dprintf1((TEXT("ICM_GETINFO:\n")));
|
|
return GetInfo(pi, (ICINFO FAR *)lParam1, (DWORD)lParam2);
|
|
|
|
case ICM_GETDEFAULTQUALITY:
|
|
dprintf2((TEXT("ICM_GETDEFAULTQUALITY:\n")));
|
|
if (lParam1) {
|
|
*((LPDWORD)lParam1) = 7500;
|
|
return ICERR_OK;
|
|
}
|
|
break;
|
|
|
|
#if 0
|
|
// NOT SUPPORTED
|
|
/*********************************************************************
|
|
|
|
compression messages
|
|
|
|
*********************************************************************/
|
|
|
|
case ICM_COMPRESS_QUERY:
|
|
dprintf2((TEXT("ICM_COMPRESS_QUERY:\n")));
|
|
return CompressQuery(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_COMPRESS_BEGIN:
|
|
dprintf2((TEXT("ICM_COMPRESS_BEGIN:\n")));
|
|
return CompressBegin(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_COMPRESS_GET_FORMAT:
|
|
dprintf2((TEXT("ICM_COMPRESS_GET_FORMAT:\n")));
|
|
return CompressGetFormat(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_COMPRESS_GET_SIZE:
|
|
dprintf2((TEXT("ICM_COMPRESS_GET_SIZE:\n")));
|
|
return CompressGetSize(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_COMPRESS:
|
|
dprintf2((TEXT("ICM_COMPRESS:\n")));
|
|
return Compress(pi,
|
|
(ICCOMPRESS FAR *)lParam1, (DWORD)lParam2);
|
|
|
|
case ICM_COMPRESS_END:
|
|
dprintf2((TEXT("ICM_COMPRESS_END:\n")));
|
|
return CompressEnd(pi);
|
|
|
|
#endif
|
|
/*********************************************************************
|
|
|
|
decompress messages
|
|
|
|
*********************************************************************/
|
|
|
|
case ICM_DECOMPRESS_QUERY:
|
|
dprintf2((TEXT("\nICM_DECOMPRESS_QUERY:----------------\n")));
|
|
return DecompressQuery(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_DECOMPRESS_BEGIN:
|
|
dprintf2((TEXT("\nICM_DECOMPRESS_BEGIN:\n")));
|
|
return DecompressBegin(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_DECOMPRESS_GET_FORMAT:
|
|
dprintf2((TEXT("\nICM_DECOMPRESS_GET_FORMAT:================\n")));
|
|
return DecompressGetFormat(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_DECOMPRESS_GET_PALETTE:
|
|
dprintf2((TEXT("ICM_DECOMPRESS_GET_PALETTE:\n")));
|
|
return DecompressGetPalette(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_DECOMPRESS:
|
|
dprintf4((TEXT("ICM_DECOMPRESS:\n")));
|
|
return Decompress(pi,
|
|
(ICDECOMPRESS FAR *)lParam1, (DWORD)lParam2);
|
|
|
|
case ICM_DECOMPRESS_END:
|
|
dprintf2((TEXT("ICM_DECOMPRESS_END:\n")));
|
|
return DecompressEnd(pi);
|
|
|
|
|
|
// *EX
|
|
case ICM_DECOMPRESSEX_QUERY:
|
|
dprintf2((TEXT("\nICM_DECOMPRESSEX_QUERY:----------------\n")));
|
|
return DecompressExQuery(pi, (ICDECOMPRESSEX *) lParam1,(DWORD) lParam2);
|
|
|
|
case ICM_DECOMPRESSEX:
|
|
dprintf4((TEXT("ICM_DECOMPRESSEX:\n")));
|
|
return DecompressEx(pi, (ICDECOMPRESSEX *) lParam1, (DWORD) lParam2);
|
|
|
|
case ICM_DECOMPRESSEX_BEGIN:
|
|
dprintf2((TEXT("\nICM_DECOMPRESSEX_BEGIN:\n")));
|
|
return DecompressExBegin(pi, (ICDECOMPRESSEX *) lParam1,(DWORD) lParam2);;
|
|
|
|
case ICM_DECOMPRESSEX_END:
|
|
dprintf2((TEXT("\nICM_DECOMPRESSEX_END:\n")));
|
|
return DecompressExEnd(pi);;
|
|
|
|
|
|
|
|
/*********************************************************************
|
|
|
|
draw messages:
|
|
|
|
*********************************************************************/
|
|
#ifdef ICM_DRAW_SUPPORTED
|
|
case ICM_DRAW_BEGIN:
|
|
dprintf2((TEXT("ICM_DRAW_BEGIN:\n")));
|
|
/*
|
|
* sent when a sequence of draw calls are about to start -
|
|
* enable hardware.
|
|
*/
|
|
//return DrawBegin(pi,(ICDRAWBEGIN FAR *)lParam1, (DWORD)lParam2);
|
|
return( (DWORD) ICERR_OK);
|
|
|
|
|
|
case ICM_DRAW:
|
|
dprintf2((TEXT("ICM_DRAW:\n")));
|
|
/*
|
|
* frame ready for decompress. Since we don't have any pre-buffering,
|
|
* it is ok to render the frame at this time too. If we had
|
|
* pre-buffer, we would queue now, and start clocking frames out
|
|
* on the draw-start message.
|
|
*/
|
|
return Draw(pi,(ICDRAW FAR *)lParam1, (DWORD)lParam2);
|
|
|
|
case ICM_DRAW_END:
|
|
dprintf2((TEXT("ICM_DRAW_END:\n")));
|
|
/*
|
|
* this message is sent when the sequence of draw calls has finished -
|
|
* note that the final frame should remain rendered!! - so we can't
|
|
* disable the hardware yet.
|
|
*/
|
|
//return DrawEnd(pi);
|
|
//return((DWORD) ICERR_OK);
|
|
|
|
|
|
case ICM_DRAW_WINDOW:
|
|
dprintf2(("ICM_DRAW_WINDOW:\n"));
|
|
/*
|
|
* the window has changed position or z-ordering. re-sync the
|
|
* hardware rendering.
|
|
*/
|
|
return(DrawWindow(pi, (PRECT)lParam1));
|
|
|
|
|
|
case ICM_DRAW_QUERY:
|
|
dprintf2((TEXT("ICM_DRAW_QUERY:\n")));
|
|
/*
|
|
* can we draw this format ? (lParam2 may (should?) be null)
|
|
*/
|
|
return DrawQuery(pi,
|
|
(LPBITMAPINFOHEADER)lParam1,
|
|
(LPBITMAPINFOHEADER)lParam2);
|
|
|
|
case ICM_DRAW_START:
|
|
case ICM_DRAW_STOP:
|
|
dprintf2((TEXT("ICM_DRAW_START/END:\n")));
|
|
/*
|
|
* only relevant if you have pre-buffering.
|
|
*/
|
|
return( (DWORD) ICERR_OK);
|
|
#endif
|
|
|
|
/*********************************************************************
|
|
|
|
standard driver messages
|
|
|
|
*********************************************************************/
|
|
|
|
case DRV_DISABLE:
|
|
case DRV_ENABLE:
|
|
dprintf2((TEXT("DRV_DISABLE/ENABLE:\n")));
|
|
return (LRESULT)1L;
|
|
|
|
case DRV_INSTALL:
|
|
case DRV_REMOVE:
|
|
dprintf2((TEXT("DRV_INSTALL/REMOVE:\n")));
|
|
return (LRESULT)DRV_OK;
|
|
}
|
|
|
|
if (uiMessage < DRV_USER) {
|
|
return DefDriverProc((UINT_PTR)pi, hDriver, uiMessage,lParam1,lParam2);
|
|
} else {
|
|
dprintf1((TEXT("DriverProc: ICM message ID (ICM_USER+%d) not supported.\n"), uiMessage-ICM_USER));
|
|
return ICERR_UNSUPPORTED;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef _WIN32
|
|
#if 0 // done on DRV_LOAD
|
|
BOOL DllInstanceInit(PVOID hModule, ULONG Reason, PCONTEXT pContext)
|
|
{
|
|
if (Reason == DLL_PROCESS_ATTACH) {
|
|
ghModule = (HANDLE) hModule;
|
|
DisableThreadLibraryCalls(hModule);
|
|
}
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
#endif
|
|
// #else
|
|
|
|
/****************************************************************************
|
|
* LibMain - Library initialization code.
|
|
*
|
|
* PARAMETERS
|
|
* hModule: Our module handle.
|
|
*
|
|
* wHeapSize: The heap size from the .def file.
|
|
*
|
|
* lpCmdLine: The command line.
|
|
*
|
|
* Returns 1 if the initialization was successful and 0 otherwise.
|
|
***************************************************************************/
|
|
//int NEAR PASCAL LibMain(HMODULE hModule, WORD wHeapSize, LPSTR lpCmdLine)
|
|
BOOL FAR PASCAL LibMain(HMODULE hModule, WORD wHeapSize, LPSTR lpCmdLine)
|
|
{
|
|
ghModule = hModule;
|
|
|
|
return 1;
|
|
}
|
|
|
|
// #endif
|