/**************************************************************************
* DriverProc (WINECOREAUDIO.1)
*/
LRESULT CALLBACK CoreAudio_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
LPARAM dwParam1, LPARAM dwParam2)
{
TRACE("(%08lX, %p, %s (%08X), %08lX, %08lX)\n",
dwDevID, hDriv, wMsg == DRV_LOAD ? "DRV_LOAD" :
wMsg == DRV_FREE ? "DRV_FREE" :
wMsg == DRV_OPEN ? "DRV_OPEN" :
wMsg == DRV_CLOSE ? "DRV_CLOSE" :
wMsg == DRV_ENABLE ? "DRV_ENABLE" :
wMsg == DRV_DISABLE ? "DRV_DISABLE" :
wMsg == DRV_QUERYCONFIGURE ? "DRV_QUERYCONFIGURE" :
wMsg == DRV_CONFIGURE ? "DRV_CONFIGURE" :
wMsg == DRV_INSTALL ? "DRV_INSTALL" :
wMsg == DRV_REMOVE ? "DRV_REMOVE" : "UNKNOWN",
wMsg, dwParam1, dwParam2);
switch(wMsg) {
case DRV_LOAD: return CoreAudio_drvLoad();
case DRV_FREE: return CoreAudio_drvFree();
case DRV_OPEN: return CoreAudio_drvOpen((LPSTR)dwParam1);
case DRV_CLOSE: return CoreAudio_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "CoreAudio driver!", "CoreAudio driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}
/**************************************************************************
* DriverProc (JOYSTICK.@)
*/
LRESULT CALLBACK JSTCK_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
LPARAM dwParam1, LPARAM dwParam2)
{
/* EPP TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n", */
/* EPP dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
switch(wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return JSTCK_drvOpen((LPSTR)dwParam1, dwParam2);
case DRV_CLOSE: return JSTCK_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "JoyStick MultiMedia Driver !", "JoyStick Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
case JDD_GETNUMDEVS: return 1;
case JDD_GETDEVCAPS: return JSTCK_GetDevCaps(dwDevID, (LPJOYCAPSW)dwParam1, dwParam2);
case JDD_GETPOS: return JSTCK_GetPos(dwDevID, (LPJOYINFO)dwParam1);
case JDD_SETCALIBRATION:
case JDD_CONFIGCHANGED: return JOYERR_NOCANDO;
case JDD_GETPOSEX: return JSTCK_GetPosEx(dwDevID, (LPJOYINFOEX)dwParam1);
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}
LONG WINAPI
DriverProc(
DWORD driver_id,
HANDLE driver_handle,
UINT message,
LONG parameter1,
LONG parameter2)
{
switch ( message )
{
case DRV_LOAD :
DPRINT("DRV_LOAD\n");
return 1L;
case DRV_FREE :
DPRINT("DRV_FREE\n");
return 1L;
case DRV_OPEN :
DPRINT("DRV_OPEN\n");
return 1L;
case DRV_CLOSE :
DPRINT("DRV_CLOSE\n");
return 1L;
case DRV_ENABLE :
DPRINT("DRV_ENABLE\n");
return 1L;
case DRV_DISABLE :
DPRINT("DRV_DISABLE\n");
return 1L;
/*
We don't provide configuration capabilities. This used to be
for things like I/O port, IRQ, DMA settings, etc.
*/
case DRV_QUERYCONFIGURE :
DPRINT("DRV_QUERYCONFIGURE\n");
return 0L;
case DRV_CONFIGURE :
DPRINT("DRV_CONFIGURE\n");
return 0L;
case DRV_INSTALL :
DPRINT("DRV_INSTALL\n");
return DRVCNF_RESTART;
};
return DefDriverProc(driver_id,
driver_handle,
message,
parameter1,
parameter2);
}
/**************************************************************************
* DriverProc (MSACM.@)
*/
LRESULT CALLBACK WAVEMAP_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
LPARAM dwParam1, LPARAM dwParam2)
{
TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
dwDevID, hDriv, wMsg, dwParam1, dwParam2);
switch(wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return WAVEMAP_drvOpen((LPSTR)dwParam1);
case DRV_CLOSE: return WAVEMAP_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "WAVEMAP MultiMedia Driver !", "Wave mapper Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}
/**************************************************************************
* DriverProc (MIDIMAP.@)
*/
LONG CALLBACK MIDIMAP_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
/* EPP TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n", */
/* EPP dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
switch (wMsg)
{
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return MIDIMAP_drvOpen((LPSTR)dwParam1);
case DRV_CLOSE: return MIDIMAP_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "MIDIMAP MultiMedia Driver !", "OSS Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}
/**************************************************************************
* DriverProc (WINEARTS.@)
*/
LRESULT CALLBACK ARTS_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
LPARAM dwParam1, LPARAM dwParam2)
{
/* EPP TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n", */
/* EPP dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
switch(wMsg) {
#ifdef HAVE_ARTS
case DRV_LOAD: if (ARTS_WaveInit()<0) return 0;
return 1;
case DRV_FREE: return ARTS_WaveClose();
case DRV_OPEN: return ARTS_drvOpen((LPSTR)dwParam1);
case DRV_CLOSE: return ARTS_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "aRts MultiMedia Driver!", "aRts Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
#endif
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}
/* __declspec(dllexport) */ LRESULT WINAPI DriverProc(
DWORD_PTR dwDriverId,
HDRVR hDriver,
UINT uMsg,
LPARAM lParam1,
LPARAM lParam2)
{
CODEC * codec = (CODEC *)dwDriverId;
switch(uMsg)
{
/* driver primitives */
case DRV_LOAD :
case DRV_FREE :
return DRVCNF_OK;
case DRV_OPEN :
DPRINTF("DRV_OPEN");
{
ICOPEN * icopen = (ICOPEN *)lParam2;
if (icopen != NULL && icopen->fccType != ICTYPE_VIDEO)
{
return DRVCNF_CANCEL;
}
codec = malloc(sizeof(CODEC));
if (codec == NULL)
{
if (icopen != NULL)
{
icopen->dwError = ICERR_MEMORY;
}
return 0;
}
memset(codec, 0, sizeof(CODEC));
codec->status.hDlg = NULL;
codec->config.ci_valid = 0;
codec->ehandle = codec->dhandle = NULL;
codec->fbase = 25;
codec->fincr = 1;
config_reg_get(&codec->config);
#if 0
/* bad things happen if this piece of code is activated */
if (lstrcmp(XVID_BUILD, codec->config.build))
{
config_reg_default(&codec->config);
}
#endif
if (icopen != NULL)
{
icopen->dwError = ICERR_OK;
}
return (LRESULT)codec;
}
case DRV_CLOSE :
DPRINTF("DRV_CLOSE");
/* compress_end/decompress_end don't always get called */
compress_end(codec);
decompress_end(codec);
clean_dll_bindings(codec);
status_destroy_always(&codec->status);
free(codec);
return DRVCNF_OK;
case DRV_DISABLE :
case DRV_ENABLE :
return DRVCNF_OK;
case DRV_INSTALL :
case DRV_REMOVE :
return DRVCNF_OK;
case DRV_QUERYCONFIGURE :
case DRV_CONFIGURE :
return DRVCNF_CANCEL;
/* info */
case ICM_GETINFO :
DPRINTF("ICM_GETINFO");
if (lParam1 && lParam2 >= sizeof(ICINFO)) {
ICINFO *icinfo = (ICINFO *)lParam1;
icinfo->fccType = ICTYPE_VIDEO;
icinfo->fccHandler = FOURCC_XVID;
icinfo->dwFlags =
VIDCF_FASTTEMPORALC |
VIDCF_FASTTEMPORALD |
VIDCF_COMPRESSFRAMES;
icinfo->dwVersion = 0;
#if !defined(ICVERSION)
#define ICVERSION 0x0104
#endif
icinfo->dwVersionICM = ICVERSION;
wcscpy(icinfo->szName, XVID_NAME_L);
wcscpy(icinfo->szDescription, XVID_DESC_L);
return lParam2; /* size of struct */
}
return 0; /* error */
/* state control */
case ICM_ABOUT :
DPRINTF("ICM_ABOUT");
DialogBoxParam(g_hInst, MAKEINTRESOURCE(IDD_ABOUT), (HWND)lParam1, about_proc, 0);
return ICERR_OK;
case ICM_CONFIGURE :
DPRINTF("ICM_CONFIGURE");
if (lParam1 != -1)
{
CONFIG temp;
codec->config.save = FALSE;
memcpy(&temp, &codec->config, sizeof(CONFIG));
DialogBoxParam(g_hInst, MAKEINTRESOURCE(IDD_MAIN), (HWND)lParam1, main_proc, (LPARAM)&temp);
if (temp.save)
{
memcpy(&codec->config, &temp, sizeof(CONFIG));
config_reg_set(&codec->config);
}
}
return ICERR_OK;
case ICM_GETSTATE :
DPRINTF("ICM_GETSTATE");
if ((void*)lParam1 == NULL)
{
return sizeof(CONFIG);
}
memcpy((void*)lParam1, &codec->config, sizeof(CONFIG));
return ICERR_OK;
case ICM_SETSTATE :
DPRINTF("ICM_SETSTATE");
if ((void*)lParam1 == NULL)
{
DPRINTF("ICM_SETSTATE : DEFAULT");
config_reg_get(&codec->config);
return 0;
}
memcpy(&codec->config,(void*)lParam1, sizeof(CONFIG));
return 0; /* sizeof(CONFIG); */
/* not sure the difference, private/public data? */
case ICM_GET :
case ICM_SET :
return ICERR_OK;
/* older-stype config */
case ICM_GETDEFAULTQUALITY :
case ICM_GETQUALITY :
case ICM_SETQUALITY :
case ICM_GETBUFFERSWANTED :
case ICM_GETDEFAULTKEYFRAMERATE :
return ICERR_UNSUPPORTED;
/* compressor */
case ICM_COMPRESS_QUERY :
DPRINTF("ICM_COMPRESS_QUERY");
return compress_query(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_COMPRESS_GET_FORMAT :
DPRINTF("ICM_COMPRESS_GET_FORMAT");
return compress_get_format(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_COMPRESS_GET_SIZE :
DPRINTF("ICM_COMPRESS_GET_SIZE");
return compress_get_size(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_COMPRESS_FRAMES_INFO :
DPRINTF("ICM_COMPRESS_FRAMES_INFO");
return compress_frames_info(codec, (ICCOMPRESSFRAMES *)lParam1);
case ICM_COMPRESS_BEGIN :
DPRINTF("ICM_COMPRESS_BEGIN");
return compress_begin(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_COMPRESS_END :
DPRINTF("ICM_COMPRESS_END");
return compress_end(codec);
case ICM_COMPRESS :
DPRINTF("ICM_COMPRESS");
return compress(codec, (ICCOMPRESS *)lParam1);
/* decompressor */
case ICM_DECOMPRESS_QUERY :
DPRINTF("ICM_DECOMPRESS_QUERY");
return decompress_query(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_DECOMPRESS_GET_FORMAT :
DPRINTF("ICM_DECOMPRESS_GET_FORMAT");
return decompress_get_format(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_DECOMPRESS_BEGIN :
DPRINTF("ICM_DECOMPRESS_BEGIN");
return decompress_begin(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_DECOMPRESS_END :
DPRINTF("ICM_DECOMPRESS_END");
return decompress_end(codec);
case ICM_DECOMPRESS :
DPRINTF("ICM_DECOMPRESS");
return decompress(codec, (ICDECOMPRESS *)lParam1);
case ICM_DECOMPRESS_GET_PALETTE :
case ICM_DECOMPRESS_SET_PALETTE :
case ICM_DECOMPRESSEX_QUERY:
case ICM_DECOMPRESSEX_BEGIN:
case ICM_DECOMPRESSEX_END:
case ICM_DECOMPRESSEX:
return ICERR_UNSUPPORTED;
/* VFWEXT entry point */
case ICM_USER+0x0fff :
if (lParam1 == VFWEXT_CONFIGURE_INFO) {
VFWEXT_CONFIGURE_INFO_T * info = (VFWEXT_CONFIGURE_INFO_T*)lParam2;
DPRINTF("%i %i %i %i %i %i",
info->ciWidth, info->ciHeight,
info->ciRate, info->ciScale,
info->ciActiveFrame, info->ciFrameCount);
codec->config.ci_valid = 1;
memcpy(&codec->config.ci, (void*)lParam2, sizeof(VFWEXT_CONFIGURE_INFO_T));
return ICERR_OK;
}
return ICERR_UNSUPPORTED;
default:
if (uMsg < DRV_USER)
return DefDriverProc(dwDriverId, hDriver, uMsg, lParam1, lParam2);
else
return ICERR_UNSUPPORTED;
}
}
/**************************************************************************
* DriverProc (MCICDA.@)
*/
LONG CALLBACK MCICDA_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
switch(wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return MCICDA_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
case DRV_CLOSE: return MCICDA_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "MCI audio CD driver !", "Wine Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
}
if (dwDevID == 0xFFFFFFFF) return MCIERR_UNSUPPORTED_FUNCTION;
switch (wMsg) {
case MCI_OPEN_DRIVER: return MCICDA_Open(dwDevID, dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
case MCI_CLOSE_DRIVER: return MCICDA_Close(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_GETDEVCAPS: return MCICDA_GetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
case MCI_INFO: return MCICDA_Info(dwDevID, dwParam1, (LPMCI_INFO_PARMSA)dwParam2);
case MCI_STATUS: return MCICDA_Status(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
case MCI_SET: return MCICDA_Set(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
case MCI_PLAY: return MCICDA_Play(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
case MCI_STOP: return MCICDA_Stop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_PAUSE: return MCICDA_Pause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_RESUME: return MCICDA_Resume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_SEEK: return MCICDA_Seek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)dwParam2);
/* FIXME: I wonder if those two next items are really called ? */
case MCI_SET_DOOR_OPEN: FIXME("MCI_SET_DOOR_OPEN called. Please report this.\n");
return MCICDA_SetDoor(dwDevID, TRUE);
case MCI_SET_DOOR_CLOSED: FIXME("MCI_SET_DOOR_CLOSED called. Please report this.\n");
return MCICDA_SetDoor(dwDevID, FALSE);
/* commands that should be supported */
case MCI_LOAD:
case MCI_SAVE:
case MCI_FREEZE:
case MCI_PUT:
case MCI_REALIZE:
case MCI_UNFREEZE:
case MCI_UPDATE:
case MCI_WHERE:
case MCI_STEP:
case MCI_SPIN:
case MCI_ESCAPE:
case MCI_COPY:
case MCI_CUT:
case MCI_DELETE:
case MCI_PASTE:
FIXME("Unsupported yet command [%lu]\n", wMsg);
break;
/* commands that should report an error */
case MCI_WINDOW:
TRACE("Unsupported command [%lu]\n", wMsg);
break;
case MCI_OPEN:
case MCI_CLOSE:
ERR("Shouldn't receive a MCI_OPEN or CLOSE message\n");
break;
default:
TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
return MCIERR_UNRECOGNIZED_COMMAND;
}
/***************************************************************************
* 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 PASCAL DriverProc(DWORD_PTR dwDriverID, HDRVR hDriver, UINT uiMessage, LPARAM lParam1, LPARAM lParam2) {
CodecInst* pi = (CodecInst*)dwDriverID;
switch (uiMessage) {
case DRV_LOAD:
return (LRESULT)1L;
case DRV_FREE:
return (LRESULT)1L;
case DRV_OPEN:
return (LRESULT)Open((ICOPEN*) lParam2);
case DRV_CLOSE:
if (pi) Close(pi);
return (LRESULT)1L;
/*********************************************************************
state messages
*********************************************************************/
// cwk
case DRV_QUERYCONFIGURE: // configuration from drivers applet
return (LRESULT)1L;
case DRV_CONFIGURE:
pi->Configure((HWND)lParam1);
return DRV_OK;
case ICM_CONFIGURE:
//
// return ICERR_OK if you will do a configure box, error otherwise
//
if (lParam1 == -1)
return ICERR_OK;
else
return pi->Configure((HWND)lParam1);
case ICM_ABOUT:
return ICERR_UNSUPPORTED;
case ICM_GETSTATE:
return pi->GetState((LPVOID)lParam1, (DWORD)lParam2);
case ICM_SETSTATE:
return pi->SetState((LPVOID)lParam1, (DWORD)lParam2);
case ICM_GETINFO:
return pi->GetInfo((ICINFO*)lParam1, (DWORD)lParam2);
case ICM_GETDEFAULTQUALITY:
if (lParam1) {
*((LPDWORD)lParam1) = 10000;
return ICERR_OK;
}
break;
/*********************************************************************
compression messages
*********************************************************************/
case ICM_COMPRESS_QUERY:
return pi->CompressQuery((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_COMPRESS_BEGIN:
return pi->CompressBegin((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_COMPRESS_GET_FORMAT:
return pi->CompressGetFormat((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_COMPRESS_GET_SIZE:
return pi->CompressGetSize((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_COMPRESS:
return pi->Compress((ICCOMPRESS*)lParam1, (DWORD)lParam2);
case ICM_COMPRESS_END:
return pi->CompressEnd();
/*********************************************************************
decompress messages
*********************************************************************/
case ICM_DECOMPRESS_QUERY:
return pi->DecompressQuery((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_DECOMPRESS_BEGIN:
return pi->DecompressBegin((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_DECOMPRESS_GET_FORMAT:
return pi->DecompressGetFormat((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_DECOMPRESS_GET_PALETTE:
return pi->DecompressGetPalette((LPBITMAPINFOHEADER)lParam1, (LPBITMAPINFOHEADER)lParam2);
case ICM_DECOMPRESS:
return pi->Decompress((ICDECOMPRESS*)lParam1, (DWORD)lParam2);
case ICM_DECOMPRESS_END:
return pi->DecompressEnd();
/*********************************************************************
standard driver messages
*********************************************************************/
case DRV_DISABLE:
case DRV_ENABLE:
return (LRESULT)1L;
case DRV_INSTALL:
case DRV_REMOVE:
return (LRESULT)DRV_OK;
}
if (uiMessage < DRV_USER)
return DefDriverProc(dwDriverID, hDriver, uiMessage, lParam1, lParam2);
return ICERR_UNSUPPORTED;
}
/**************************************************************************
* DriverProc (MCICDA.@)
*/
LRESULT CALLBACK MCICDA_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
LPARAM dwParam1, LPARAM dwParam2)
{
switch(wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return MCICDA_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
case DRV_CLOSE: return MCICDA_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "MCI audio CD driver !", "Wine Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
}
if (dwDevID == 0xFFFFFFFF) return MCIERR_UNSUPPORTED_FUNCTION;
switch (wMsg) {
case MCI_OPEN_DRIVER: return MCICDA_Open(dwDevID, dwParam1, (LPMCI_OPEN_PARMSW)dwParam2);
case MCI_CLOSE_DRIVER: return MCICDA_Close(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_GETDEVCAPS: return MCICDA_GetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
case MCI_INFO: return MCICDA_Info(dwDevID, dwParam1, (LPMCI_INFO_PARMSW)dwParam2);
case MCI_STATUS: return MCICDA_Status(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
case MCI_SET: return MCICDA_Set(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
case MCI_PLAY: return MCICDA_Play(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
case MCI_STOP: return MCICDA_Stop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_PAUSE: return MCICDA_Pause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_RESUME: return MCICDA_Resume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_SEEK: return MCICDA_Seek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)dwParam2);
/* commands that should report an error as they are not supported in
* the native version */
case MCI_RECORD:
case MCI_LOAD:
case MCI_SAVE:
return MCIERR_UNSUPPORTED_FUNCTION;
case MCI_BREAK:
case MCI_FREEZE:
case MCI_PUT:
case MCI_REALIZE:
case MCI_UNFREEZE:
case MCI_UPDATE:
case MCI_WHERE:
case MCI_STEP:
case MCI_SPIN:
case MCI_ESCAPE:
case MCI_COPY:
case MCI_CUT:
case MCI_DELETE:
case MCI_PASTE:
case MCI_WINDOW:
TRACE("Unsupported command [0x%x]\n", wMsg);
break;
case MCI_OPEN:
case MCI_CLOSE:
ERR("Shouldn't receive a MCI_OPEN or CLOSE message\n");
break;
default:
TRACE("Sending msg [0x%x] to default driver proc\n", wMsg);
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
return MCIERR_UNRECOGNIZED_COMMAND;
}
extern "C" __declspec(dllexport) LRESULT WINAPI DriverProc(DWORD dwDriverId, HDRVR hDriver, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
{
Iffacm2 *ffacm = (Iffacm2*)dwDriverId;
switch (uMsg) {
case DRV_LOAD:
return DRV_OK;
case DRV_FREE:
if (hdll) {
FreeModule(hdll);
hdll = NULL;
}
return DRV_OK;
case DRV_OPEN: {
ACMDRVOPENDESCW *icopen = (ACMDRVOPENDESCW*)lParam2;
if (icopen != NULL && icopen->fccType != ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC) {
return DRVCNF_CANCEL;
}
if (!hdll) {
TregOpRegRead r(HKEY_CLASSES_ROOT, "CLSID\\{F6E8FC04-8B05-48B1-9399-848229502A06}\\InprocServer32");
char pth[MAX_PATH];
r._REG_OP_S(0, "", pth, MAX_PATH, "");
hdll = LoadLibrary(pth);
}
typedef Iffacm2creator* (__stdcall * Tcreate)(void);
Tcreate create = (Tcreate)GetProcAddress(hdll, "ffacm2creator");
if (!create) {
return DRVCNF_CANCEL;
}
Iffacm2creator *creator = create();
if (!creator) {
return DRVCNF_CANCEL;
}
//if (FAILED(CoCreateInstance(CLSID_FFACM2CREATOR,NULL,CLSCTX_INPROC_SERVER,IID_Iffacm2creator,(void**)&creator))) return DRVCNF_CANCEL;
int size = creator->getSize();
ffacm = (Iffacm2*)LocalAlloc(LPTR, size);
if (!ffacm) {
creator->Release();
return DRVCNF_CANCEL;
}
creator->create(ffacm);
creator->Release();
if (icopen != NULL) {
icopen->dwError = DRV_OK;
}
DPRINTF("ACM DRV_OPEN %i %p", hDriver, ffacm);
return (LRESULT)ffacm;
}
case DRV_CLOSE:
DPRINTF("ACM DRV_CLOSE %i %p", hDriver, ffacm);
if (ffacm) {
LocalFree(ffacm);
}
return DRV_OK;
case DRV_CONFIGURE:
return DRVCNF_OK;
case DRV_QUERYCONFIGURE:
return FALSE;
case DRV_INSTALL:
return DRVCNF_RESTART;
case DRV_REMOVE:
return DRVCNF_RESTART;
// ACM
case ACMDM_DRIVER_DETAILS:
DPRINTF("ACM ACMDM_DRIVER_DETAILS %i %p", hDriver, ffacm);
return ffacm->driverDetails((LPACMDRIVERDETAILSW)lParam1);
case ACMDM_DRIVER_ABOUT:
DPRINTF("ACM ACMDM_DRIVER_ABOUT %i %p", hDriver, ffacm);
return ffacm->driverAbout((HWND)lParam1);
case ACMDM_FORMAT_SUGGEST:
DPRINTF("ACM ACMDM_FORMAT_SUGGEST %i %p", hDriver, ffacm);
return ffacm->formatSuggest((LPACMDRVFORMATSUGGEST)lParam1);
case ACMDM_FORMATTAG_DETAILS:
DPRINTF("ACM ACMDM_FORMATTAG_DETAILS %i %p", hDriver, ffacm);
return ffacm->formatTagDetails((LPACMFORMATTAGDETAILSW)lParam1, (DWORD)lParam2);
case ACMDM_FORMAT_DETAILS:
DPRINTF("ACM ACMDM_FORMAT_DETAILS %i %p", hDriver, ffacm);
//lr = acmdFormatDetails(pdi, (LPACMFORMATDETAILS)lParam1, (DWORD)lParam2);
return 0;
case ACMDM_STREAM_OPEN:
DPRINTF("ACM ACMDM_STREAM_OPEN %i %p", hDriver, ffacm);
return ffacm->streamOpen((LPACMDRVSTREAMINSTANCE)lParam1);
case ACMDM_STREAM_CLOSE:
DPRINTF("ACM ACMDM_STREAM_CLOSE %i %p", hDriver, ffacm);
return ffacm->streamClose((LPACMDRVSTREAMINSTANCE)lParam1);
case ACMDM_STREAM_SIZE:
DPRINTF("ACM ACMDM_STREAM_SIZE %i %p", hDriver, ffacm);
return ffacm->streamSize((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMDRVSTREAMSIZE)lParam2);
case ACMDM_STREAM_CONVERT:
DPRINTF("ACM ACMDM_STREAM_SIZE %i %p", hDriver, ffacm);
return ffacm->convert((LPACMDRVSTREAMINSTANCE) lParam1, (LPACMDRVSTREAMHEADER)lParam2);
default:
if (uMsg < DRV_USER) {
return DefDriverProc(dwDriverId, hDriver, uMsg, lParam1, lParam2);
}
}
return MMSYSERR_NOTSUPPORTED;
}
/**************************************************************************
* DriverProc (MCIQTZ.@)
*/
LRESULT CALLBACK MCIQTZ_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
LPARAM dwParam1, LPARAM dwParam2)
{
TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
dwDevID, hDriv, wMsg, dwParam1, dwParam2);
switch (wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return MCIQTZ_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
case DRV_CLOSE: return MCIQTZ_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: return MCIQTZ_drvConfigure(dwDevID);
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
}
/* session instance */
if (dwDevID == 0xFFFFFFFF)
return 1;
switch (wMsg) {
case MCI_OPEN_DRIVER: return MCIQTZ_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
case MCI_CLOSE_DRIVER: return MCIQTZ_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_PLAY: return MCIQTZ_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
case MCI_SEEK: return MCIQTZ_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
case MCI_STOP: return MCIQTZ_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_PAUSE: return MCIQTZ_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_GETDEVCAPS: return MCIQTZ_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
case MCI_SET: return MCIQTZ_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
case MCI_STATUS: return MCIQTZ_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
case MCI_WHERE: return MCIQTZ_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
/* Digital Video specific */
case MCI_SETAUDIO: return MCIQTZ_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
case MCI_UPDATE:
return MCIQTZ_mciUpdate(dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS)dwParam2);
case MCI_WINDOW:
return MCIQTZ_mciWindow(dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW)dwParam2);
case MCI_PUT:
case MCI_RECORD:
case MCI_RESUME:
case MCI_INFO:
case MCI_LOAD:
case MCI_SAVE:
case MCI_FREEZE:
case MCI_REALIZE:
case MCI_UNFREEZE:
case MCI_STEP:
case MCI_COPY:
case MCI_CUT:
case MCI_DELETE:
case MCI_PASTE:
case MCI_CUE:
/* Digital Video specific */
case MCI_CAPTURE:
case MCI_MONITOR:
case MCI_RESERVE:
case MCI_SIGNAL:
case MCI_SETVIDEO:
case MCI_QUALITY:
case MCI_LIST:
case MCI_UNDO:
case MCI_CONFIGURE:
case MCI_RESTORE:
FIXME("Unimplemented command [%08X]\n", wMsg);
break;
case MCI_SPIN:
case MCI_ESCAPE:
WARN("Unsupported command [%08X]\n", wMsg);
break;
case MCI_OPEN:
case MCI_CLOSE:
FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
break;
default:
TRACE("Sending msg [%08X] to default driver proc\n", wMsg);
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
return MCIERR_UNRECOGNIZED_COMMAND;
}
//***************************************************************************
long FAR PASCAL EXPORT MCIDrawProc(DWORD id, HDRVR hDriver, UINT message, LPARAM lParam1, LPARAM lParam2)
//***************************************************************************
{
PINSTINFO pi;
switch (message)
{
// First, all the messages we ignore
case DRV_LOAD:
case DRV_FREE:
case DRV_CONFIGURE:
case DRV_DISABLE:
case DRV_ENABLE:
case DRV_INSTALL:
case DRV_REMOVE:
return 1L; //ICERR_UNSUPPORTED; // JMM try unsupported instead of 1L
case ICM_CONFIGURE:
case ICM_ABOUT:
case ICM_DRAW_START_PLAY:
return ICERR_UNSUPPORTED;
// Next, all the messages we ignore and just return ICERR_OK (0):
// Note, these may be used to store state information.
// It is unclear if they will definitetly be called.
case DRV_QUERYCONFIGURE:
case ICM_GETSTATE:
case ICM_SETSTATE:
case ICM_DRAW_QUERY: // Determine if the input can be processed
case ICM_DRAW_SUGGESTFORMAT: // Suggest the output format
case ICM_DRAW_END: // Cleanup after a draw operation
return ICERR_OK;
// The draw messages we care about
case DRV_OPEN: // Open the rendering driver
return AVIDrawOpen((ICOPEN FAR *)lParam2);
case ICM_DRAW_BEGIN: // Prepare to draw the video data
return AVIDrawBegin((PINSTINFO)id, (ICDRAWBEGIN FAR *) lParam1, lParam2);
case ICM_GETINFO:
return AVIDrawGetInfo((ICINFO FAR *)lParam1, lParam2);
case ICM_DRAW: // Draw the video data
return AVIDraw((PINSTINFO)id, (ICDRAW FAR *)lParam1, lParam2);
case ICM_DRAW_CHANGEPALETTE:
return AVIDrawChangePalette((PINSTINFO)id, (LPBITMAPINFOHEADER) lParam1);
case ICM_DRAW_GET_PALETTE:
if ( !(pi = (PINSTINFO)id) ) return ICERR_UNSUPPORTED;
if (!pi->hdc || !pi->hdd) return ICERR_UNSUPPORTED;
return (UINT)DrawDibGetPalette(pi->hdd);
case ICM_DRAW_REALIZE:
if ( !(pi = (PINSTINFO)id) ) return ICERR_UNSUPPORTED;
pi->hdc = (HDC)lParam1;
if (!pi->hdc || !pi->hdd) return ICERR_UNSUPPORTED;
return DrawDibRealize(pi->hdd, pi->hdc, (BOOL) lParam2);
case DRV_CLOSE: // Close the rendering driver
return AVIDrawClose((PINSTINFO)id);
default:
if (message < DRV_USER)
return DefDriverProc(id, hDriver, message, lParam1, lParam2);
else
return ICERR_UNSUPPORTED;
}
return ICERR_UNSUPPORTED;
}
LONG ACM::DriverProcedure(const HDRVR hdrvr, const UINT msg, LONG lParam1, LONG lParam2)
{
DWORD dwRes = 0L;
//my_debug.OutPut(DEBUG_LEVEL_MSG, "message 0x%08X for ThisACM 0x%08X", msg, this);
switch (msg) {
case DRV_INSTALL:
my_debug.OutPut(DEBUG_LEVEL_MSG, "DRV_INSTALL");
// Sent when the driver is installed.
dwRes = DRVCNF_OK; // Can also return
break; // DRVCNF_CANCEL
// and DRV_RESTART
case DRV_REMOVE:
// Sent when the driver is removed.
my_debug.OutPut(DEBUG_LEVEL_MSG, "DRV_REMOVE");
dwRes = 1L; // return value ignored
break;
case DRV_QUERYCONFIGURE:
my_debug.OutPut(DEBUG_LEVEL_MSG, "DRV_QUERYCONFIGURE");
// Sent to determine if the driver can be
// configured.
dwRes = 1L; // Zero indicates configuration
break; // NOT supported
case DRV_CONFIGURE:
my_debug.OutPut(DEBUG_LEVEL_MSG, "DRV_CONFIGURE");
// Sent to display the configuration
// dialog box for the driver.
// dwRes = Configure( (HWND) lParam1, (LPDRVCONFIGINFO) lParam2 );
if (my_EncodingProperties.Config(my_hModule, (HWND) lParam1))
{
dwRes = DRVCNF_OK; // Can also return
// DRVCNF_CANCEL
// and DRVCNF_RESTART
} else {
dwRes = DRVCNF_CANCEL;
}
break;
/**************************************
// ACM additional messages
***************************************/
case ACMDM_DRIVER_ABOUT:
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_DRIVER_ABOUT");
dwRes = About( (HWND) lParam1 );
break;
case ACMDM_DRIVER_DETAILS: // acmDriverDetails
// Fill-in general informations about the driver/codec
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_DRIVER_DETAILS");
dwRes = OnDriverDetails(hdrvr, (LPACMDRIVERDETAILS) lParam1);
break;
case ACMDM_FORMATTAG_DETAILS: // acmFormatTagDetails
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_FORMATTAG_DETAILS");
dwRes = OnFormatTagDetails((LPACMFORMATTAGDETAILS) lParam1, lParam2);
break;
case ACMDM_FORMAT_DETAILS: // acmFormatDetails
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_FORMAT_DETAILS");
dwRes = OnFormatDetails((LPACMFORMATDETAILS) lParam1, lParam2);
break;
case ACMDM_FORMAT_SUGGEST: // acmFormatSuggest
// Sent to determine if the driver can be
// configured.
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_FORMAT_SUGGEST");
dwRes = OnFormatSuggest((LPACMDRVFORMATSUGGEST) lParam1);
break;
/**************************************
// ACM stream messages
***************************************/
case ACMDM_STREAM_OPEN:
// Sent to determine if the driver can be
// configured.
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_OPEN");
dwRes = OnStreamOpen((LPACMDRVSTREAMINSTANCE) lParam1);
break;
case ACMDM_STREAM_SIZE:
// returns a recommended size for a source
// or destination buffer on an ACM stream
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_SIZE");
dwRes = OnStreamSize((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMDRVSTREAMSIZE)lParam2);
break;
case ACMDM_STREAM_PREPARE:
// prepares an ACMSTREAMHEADER structure for
// an ACM stream conversion
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_PREPARE");
dwRes = OnStreamPrepareHeader((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMSTREAMHEADER) lParam2);
break;
case ACMDM_STREAM_UNPREPARE:
// cleans up the preparation performed by
// the ACMDM_STREAM_PREPARE message for an ACM stream
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_UNPREPARE");
dwRes = OnStreamUnPrepareHeader((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMSTREAMHEADER) lParam2);
break;
case ACMDM_STREAM_CONVERT:
// perform a conversion on the specified conversion stream
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_CONVERT");
dwRes = OnStreamConvert((LPACMDRVSTREAMINSTANCE)lParam1, (LPACMDRVSTREAMHEADER) lParam2);
break;
case ACMDM_STREAM_CLOSE:
// closes an ACM conversion stream
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACMDM_STREAM_CLOSE");
dwRes = OnStreamClose((LPACMDRVSTREAMINSTANCE)lParam1);
break;
/**************************************
// Unknown message
***************************************/
default:
// Process any other messages.
my_debug.OutPut(DEBUG_LEVEL_MSG, "ACM::DriverProc unknown message (0x%08X), lParam1 = 0x%08X, lParam2 = 0x%08X", msg, lParam1, lParam2);
return DefDriverProc ((DWORD)this, hdrvr, msg, lParam1, lParam2);
}
return dwRes;
}
/**************************************************************************
* GSM_DriverProc [exported]
*/
LRESULT CALLBACK GSM_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
LPARAM dwParam1, LPARAM dwParam2)
{
TRACE("(%08lx %p %04x %08lx %08lx);\n",
dwDevID, hDriv, wMsg, dwParam1, dwParam2);
switch (wMsg)
{
case DRV_LOAD: return 1;
case DRV_FREE: return GSM_drvFree();
case DRV_OPEN: return 1;
case DRV_CLOSE: return 1;
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "GSM 06.10 codec", "Wine Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
case ACMDM_DRIVER_NOTIFY:
/* no caching from other ACM drivers is done so far */
return MMSYSERR_NOERROR;
case ACMDM_DRIVER_DETAILS:
return GSM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
case ACMDM_FORMATTAG_DETAILS:
return GSM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
case ACMDM_FORMAT_DETAILS:
return GSM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
case ACMDM_FORMAT_SUGGEST:
return GSM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
#ifdef SONAME_LIBGSM
case ACMDM_STREAM_OPEN:
return GSM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
case ACMDM_STREAM_CLOSE:
return GSM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
case ACMDM_STREAM_SIZE:
return GSM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
case ACMDM_STREAM_CONVERT:
return GSM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
#else
case ACMDM_STREAM_OPEN: ERR("libgsm support not compiled in!\n");
case ACMDM_STREAM_CLOSE:
case ACMDM_STREAM_SIZE:
case ACMDM_STREAM_CONVERT:
return MMSYSERR_NOTSUPPORTED;
#endif
case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
/* this converter is not a hardware driver */
case ACMDM_FILTERTAG_DETAILS:
case ACMDM_FILTER_DETAILS:
/* this converter is not a filter */
case ACMDM_STREAM_RESET:
/* only needed for asynchronous driver... we aren't, so just say it */
return MMSYSERR_NOTSUPPORTED;
case ACMDM_STREAM_PREPARE:
case ACMDM_STREAM_UNPREPARE:
/* nothing special to do here... so don't do anything */
return MMSYSERR_NOERROR;
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}
/* This little puppy handles the calls which vfw programs send out to the codec */
LRESULT WINAPI DriverProc( DWORD dwDriverId, HDRVR hDriver, UINT uMsg, LPARAM lParam1, LPARAM lParam2 )
{
CODEC *codec = (CODEC *)dwDriverId;
switch( uMsg )
{
case DRV_LOAD:
case DRV_FREE:
return DRV_OK;
case DRV_OPEN:
{
ICOPEN *icopen = (ICOPEN *)lParam2;
if( icopen != NULL && icopen->fccType != ICTYPE_VIDEO )
return DRV_CANCEL;
if( ( codec = malloc( sizeof( CODEC ) ) ) == NULL )
{
if( icopen != NULL )
icopen->dwError = ICERR_MEMORY;
return 0;
}
memset( codec, 0, sizeof( CODEC ) );
config_reg_load( &codec->config );
codec->h = NULL;
if( icopen != NULL )
icopen->dwError = ICERR_OK;
return (LRESULT)codec;
}
case DRV_CLOSE:
/* From xvid: compress_end/decompress_end don't always get called */
compress_end(codec);
free( codec );
return DRV_OK;
case DRV_DISABLE:
case DRV_ENABLE:
return DRV_OK;
case DRV_INSTALL:
case DRV_REMOVE:
return DRV_OK;
case DRV_QUERYCONFIGURE:
case DRV_CONFIGURE:
return DRV_CANCEL;
/* info */
case ICM_GETINFO:
{
ICINFO *icinfo = (ICINFO *)lParam1;
/* return a description */
icinfo->fccType = ICTYPE_VIDEO;
icinfo->fccHandler = FOURCC_X264;
icinfo->dwFlags = VIDCF_COMPRESSFRAMES | VIDCF_FASTTEMPORALC;
icinfo->dwVersion = 0;
icinfo->dwVersionICM = ICVERSION;
wcscpy( icinfo->szName, X264_NAME_L);
wcscpy( icinfo->szDescription, X264_DESC_L);
return lParam2; /* size of struct */
}
case ICM_ABOUT:
if( lParam1 != -1 )
{
DialogBoxParam(g_hInst, MAKEINTRESOURCE(IDD_ABOUT), (HWND)lParam1, callback_about, 0 );
}
return ICERR_OK;
case ICM_CONFIGURE:
if( lParam1 != -1 )
{
CONFIG temp;
codec->config.b_save = FALSE;
memcpy( &temp, &codec->config, sizeof(CONFIG) );
DialogBoxParam( g_hInst, MAKEINTRESOURCE(IDD_MAINCONFIG), (HWND)lParam1, callback_main, (LPARAM)&temp );
if( temp.b_save )
{
memcpy( &codec->config, &temp, sizeof(CONFIG) );
config_reg_save( &codec->config );
}
}
return ICERR_OK;
case ICM_GETSTATE:
if( (void*)lParam1 == NULL )
{
return sizeof( CONFIG );
}
memcpy( (void*)lParam1, &codec->config, sizeof( CONFIG ) );
return ICERR_OK;
case ICM_SETSTATE:
if( (void*)lParam1 == NULL )
{
config_reg_load( &codec->config );
return 0;
}
memcpy( &codec->config, (void*)lParam1, sizeof( CONFIG ) );
return 0;
/* not sure the difference, private/public data? */
case ICM_GET:
case ICM_SET:
return ICERR_OK;
/* older-stype config */
case ICM_GETDEFAULTQUALITY:
case ICM_GETQUALITY:
case ICM_SETQUALITY:
case ICM_GETBUFFERSWANTED:
case ICM_GETDEFAULTKEYFRAMERATE:
return ICERR_UNSUPPORTED;
/* compressor */
case ICM_COMPRESS_QUERY:
return compress_query(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_COMPRESS_GET_FORMAT:
return compress_get_format(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_COMPRESS_GET_SIZE:
return compress_get_size(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_COMPRESS_FRAMES_INFO:
return compress_frames_info(codec, (ICCOMPRESSFRAMES *)lParam1);
case ICM_COMPRESS_BEGIN:
return compress_begin(codec, (BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2);
case ICM_COMPRESS_END:
return compress_end(codec);
case ICM_COMPRESS:
return compress(codec, (ICCOMPRESS *)lParam1);
/* decompressor : not implemented */
case ICM_DECOMPRESS_QUERY:
case ICM_DECOMPRESS_GET_FORMAT:
case ICM_DECOMPRESS_BEGIN:
case ICM_DECOMPRESS_END:
case ICM_DECOMPRESS:
case ICM_DECOMPRESS_GET_PALETTE:
case ICM_DECOMPRESS_SET_PALETTE:
case ICM_DECOMPRESSEX_QUERY:
case ICM_DECOMPRESSEX_BEGIN:
case ICM_DECOMPRESSEX_END:
case ICM_DECOMPRESSEX:
return ICERR_UNSUPPORTED;
default:
if (uMsg < DRV_USER)
return DefDriverProc(dwDriverId, hDriver, uMsg, lParam1, lParam2);
else
return ICERR_UNSUPPORTED;
}
}
BGBBTJ_API LRESULT WINAPI DriverProc(
DWORD_PTR dwDriverId,
HDRVR hDriver,
UINT uMsg,
LPARAM lParam1,
LPARAM lParam2)
{
ICOPEN * icopen;
ICINFO *icinfo;
BGBBTJ_VidCodecCTX *ctx;
ctx=(BGBBTJ_VidCodecCTX *)dwDriverId;
// BTJPG_DriverInit();
// btjpg_printf("DriverProc: %d %p %p\n",
// uMsg, (void *)lParam1, (void *)lParam2);
switch(uMsg)
{
case DRV_LOAD:
case DRV_FREE:
return(DRVCNF_OK);
case DRV_OPEN:
btjpg_printf("DriverProc: DRV_OPEN: %d %p %p\n",
uMsg, (void *)lParam1, (void *)lParam2);
icopen=(ICOPEN *)lParam2;
if(icopen && (icopen->fccType!=ICTYPE_VIDEO))
{ return(DRVCNF_CANCEL); }
if(icopen)
{
btjpg_printf("\tdwSize=%d\n", icopen->dwSize);
btjpg_printf("\tfccType=0x%08X (%.4s)\n",
icopen->fccType, &(icopen->fccType));
btjpg_printf("\tfccHandler=0x%08X (%.4s)\n",
icopen->fccHandler, &(icopen->fccHandler));
btjpg_printf("\tdwVersion=0x%08X\n", icopen->dwVersion);
btjpg_printf("\tdwFlags=0x%08X\n", icopen->dwFlags);
btjpg_printf("\tdwError=0x%08X\n", icopen->dwError);
btjpg_printf("\tpV1Reserved=%p\n", icopen->pV1Reserved);
btjpg_printf("\tpV2Reserved=%p\n", icopen->pV2Reserved);
btjpg_printf("\tdnDevNode=0x%08X\n", icopen->dnDevNode);
}
BTJPG_DriverInit();
// ctx = malloc(sizeof(CODEC));
ctx=BGBBTJ_VidCodecCTX_New();
ctx->viFlags=0;
if(!ctx)
{
if(icopen)
{ icopen->dwError = ICERR_MEMORY; }
return(0);
}
// ctx->viQuality=75*100;
ctx->viQuality=100*100;
if(icopen)
{
if((icopen->dwFlags&ICMODE_FASTCOMPRESS)==ICMODE_FASTCOMPRESS)
{ ctx->viFlags|=BGBBTJ_VIFL_FASTENCODE; }
if((icopen->dwFlags&ICMODE_FASTDECOMPRESS)==ICMODE_FASTDECOMPRESS)
{ ctx->viFlags|=BGBBTJ_VIFL_FASTDECODE; }
icopen->dwError=ICERR_OK;
}
return((LRESULT)ctx);
case DRV_CLOSE :
// compress_end(ctx);
// decompress_end(ctx);
// clean_dll_bindings(ctx);
// status_destroy_always(&ctx->status);
// free(ctx);
BGBBTJ_VidCodecCTX_Destroy(ctx);
BTJPG_DriverDeinit();
return(DRVCNF_OK);
case DRV_DISABLE:
case DRV_ENABLE:
return(DRVCNF_OK);
case DRV_INSTALL:
case DRV_REMOVE:
return(DRVCNF_OK);
case DRV_QUERYCONFIGURE:
case DRV_CONFIGURE:
return(DRVCNF_CANCEL);
case ICM_GETINFO:
btjpg_printf("ICM_GETINFO: %p %p\n",
(void *)lParam1, (void *)lParam2);
if (lParam1 && (lParam2>=sizeof(ICINFO)))
{
icinfo = (ICINFO *)lParam1;
icinfo->fccType = ICTYPE_VIDEO;
icinfo->fccHandler = RIFF_TAG_BTIC;
icinfo->dwFlags =
VIDCF_FASTTEMPORALC |
VIDCF_FASTTEMPORALD |
VIDCF_QUALITY |
VIDCF_TEMPORAL |
VIDCF_COMPRESSFRAMES;
icinfo->dwVersion = 0;
#if !defined(ICVERSION)
#define ICVERSION 0x0104
#endif
icinfo->dwVersionICM = ICVERSION;
// wcscpy(icinfo->szName, XVID_NAME_L);
// wcscpy(icinfo->szDescription, XVID_DESC_L);
wcscpy(icinfo->szName, L"BTIC");
wcscpy(icinfo->szDescription, L"BGBTech Image Codec");
return(lParam2);
}
return(0);
case ICM_ABOUT :
btjpg_printf("ICM_ABOUT: %p %p\n",
(void *)lParam1, (void *)lParam2);
return(ICERR_UNSUPPORTED);
// DialogBoxParam(g_hInst,
// MAKEINTRESOURCE(IDD_ABOUT),
// (HWND)lParam1, about_proc, 0);
// return(ICERR_OK);
case ICM_CONFIGURE:
case ICM_GETSTATE:
case ICM_SETSTATE:
btjpg_printf("ICM_CONFIGURE: %p %p\n",
(void *)lParam1, (void *)lParam2);
return(ICERR_UNSUPPORTED);
case ICM_GET:
btjpg_printf("ICM_GET: %p %p\n",
(void *)lParam1, (void *)lParam2);
return(ICERR_UNSUPPORTED);
case ICM_SET:
btjpg_printf("ICM_SET: %p %p\n",
(void *)lParam1, (void *)lParam2);
return(ICERR_UNSUPPORTED);
case ICM_GETDEFAULTQUALITY:
btjpg_printf("ICM_GETDEFAULTQUALITY: %p %p\n",
(void *)lParam1, (void *)lParam2);
*(DWORD *)lParam1=90*100;
return(ICERR_OK);
case ICM_GETQUALITY:
btjpg_printf("ICM_GETQUALITY: %p %p\n",
(void *)lParam1, (void *)lParam2);
*(DWORD *)lParam1=ctx->viQuality;
return(ICERR_OK);
case ICM_SETQUALITY:
btjpg_printf("ICM_SETQUALITY: %p %p\n",
(void *)lParam1, (void *)lParam2);
ctx->viQuality=*(DWORD *)lParam1;
btjpg_printf("ICM_SETQUALITY: Q=%d%%\n",
ctx->viQuality/100);
return(ICERR_OK);
case ICM_GETBUFFERSWANTED:
btjpg_printf("ICM_GETBUFFERSWANTED: %p %p\n",
(void *)lParam1, (void *)lParam2);
ctx->viQuality=*(DWORD *)lParam1;
return(ICERR_UNSUPPORTED);
case ICM_GETDEFAULTKEYFRAMERATE:
btjpg_printf("ICM_GETDEFAULTKEYFRAMERATE: %p %p\n",
(void *)lParam1, (void *)lParam2);
ctx->viQuality=*(DWORD *)lParam1;
return(ICERR_UNSUPPORTED);
case ICM_COMPRESS_QUERY:
return(btjvfw_compress_query(ctx,
(BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2));
case ICM_COMPRESS_GET_FORMAT:
return(btjvfw_compress_get_format(ctx,
(BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2));
case ICM_COMPRESS_GET_SIZE:
return(btjvfw_compress_get_size(ctx,
(BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2));
case ICM_COMPRESS_FRAMES_INFO:
return(btjvfw_compress_frames_info(ctx,
(ICCOMPRESSFRAMES *)lParam1));
case ICM_COMPRESS_BEGIN:
return(btjvfw_compress_begin(ctx,
(BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2));
case ICM_COMPRESS_END:
return(btjvfw_compress_end(ctx));
case ICM_COMPRESS:
return(btjvfw_compress(ctx, (ICCOMPRESS *)lParam1));
case ICM_DECOMPRESS_QUERY:
return(btjvfw_decompress_query(ctx,
(BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2));
case ICM_DECOMPRESS_GET_FORMAT:
return(btjvfw_decompress_get_format(ctx,
(BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2));
case ICM_DECOMPRESS_BEGIN:
return(btjvfw_decompress_begin(ctx,
(BITMAPINFO *)lParam1, (BITMAPINFO *)lParam2));
case ICM_DECOMPRESS_END:
return(btjvfw_decompress_end(ctx));
case ICM_DECOMPRESS:
return(btjvfw_decompress(ctx, (ICDECOMPRESS *)lParam1));
case ICM_DECOMPRESS_GET_PALETTE:
btjpg_printf("ICM_DECOMPRESS_GET_PALETTE: %p %p\n",
(void *)lParam1, (void *)lParam2);
return(ICERR_UNSUPPORTED);
case ICM_DECOMPRESS_SET_PALETTE:
btjpg_printf("ICM_DECOMPRESS_SET_PALETTE: %p %p\n",
(void *)lParam1, (void *)lParam2);
return(ICERR_UNSUPPORTED);
case ICM_DECOMPRESSEX_QUERY:
case ICM_DECOMPRESSEX_BEGIN:
case ICM_DECOMPRESSEX_END:
case ICM_DECOMPRESSEX:
btjpg_printf("ICM_DECOMPRESSEX: %p %p\n",
(void *)lParam1, (void *)lParam2);
return(ICERR_UNSUPPORTED);
/* VFWEXT entry point */
case ICM_USER+0x0fff :
btjpg_printf("ICM_USER: %p %p\n",
(void *)lParam1, (void *)lParam2);
return(ICERR_UNSUPPORTED);
default:
btjpg_printf("Default: %d %p %p\n", uMsg,
(void *)lParam1, (void *)lParam2);
if(uMsg<DRV_USER)
{
return(DefDriverProc(dwDriverId,
hDriver, uMsg, lParam1, lParam2));
}
else
{ return(ICERR_UNSUPPORTED); }
}
}
LPARAM YUVCodecDriver::Default(DWORD dwDriverID, HDRVR hDriver, UINT uiMessage, LPARAM lParam1, LPARAM lParam2) {
return DefDriverProc(dwDriverID, hDriver, uiMessage, lParam1, lParam2);
}
LONG WINAPI DriverProc(DWORD dwDriverId, HDRVR hdrvr, UINT msg, LONG lParam1, LONG lParam2)
{
switch (msg)
{
case DRV_OPEN: // acmDriverOpen
{
if (debug == NULL) {
debug = new ADbg(DEBUG_LEVEL_CREATION);
debug->setPrefix("LAMEdrv");
}
if (debug != NULL)
{
// Sent when the driver is opened.
if (lParam2 != NULL)
debug->OutPut(DEBUG_LEVEL_MSG, "DRV_OPEN (ID 0x%08X), pDesc = 0x%08X",dwDriverId,lParam2);
else
debug->OutPut(DEBUG_LEVEL_MSG, "DRV_OPEN (ID 0x%08X), pDesc = NULL",dwDriverId);
}
if (lParam2 != NULL) {
LPACMDRVOPENDESC pDesc = (LPACMDRVOPENDESC)lParam2;
if (pDesc->fccType != ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC) {
if (debug != NULL)
{
debug->OutPut(DEBUG_LEVEL_FUNC_CODE, "wrong pDesc->fccType (0x%08X)",pDesc->fccType);
}
return NULL;
}
} else {
if (debug != NULL)
{
debug->OutPut(DEBUG_LEVEL_FUNC_CODE, "pDesc == NULL");
}
}
ACM * ThisACM = new ACM(GetDriverModuleHandle(hdrvr));
if (debug != NULL)
{
debug->OutPut(DEBUG_LEVEL_FUNC_CODE, "OPENED instance 0x%08X",ThisACM);
}
return (LONG)ThisACM;// returns 0L to fail
// value subsequently used
// for dwDriverId.
}
break;
case DRV_CLOSE: // acmDriverClose
{
if (debug != NULL)
{
// Sent when the driver is closed. Drivers are
// unloaded when the open count reaches zero.
debug->OutPut(DEBUG_LEVEL_MSG, "DRV_CLOSE");
}
ACM * ThisACM = (ACM *)dwDriverId;
delete ThisACM;
if (debug != NULL)
{
debug->OutPut(DEBUG_LEVEL_FUNC_CODE, "CLOSED instance 0x%08X",ThisACM);
delete debug;
debug = NULL;
}
return 1L; // returns 0L to fail
}
break;
case DRV_LOAD:
{
// nothing to do
if (debug != NULL)
{
// debug->OutPut(DEBUG_LEVEL_MSG, "DRV_LOAD, version %s %s %s", ACM_VERSION, __DATE__, __TIME__);
debug->OutPut(DEBUG_LEVEL_MSG, "DRV_LOAD, %s %s", __DATE__, __TIME__);
}
return 1L;
}
break;
case DRV_ENABLE:
{
// nothing to do
if (debug != NULL)
{
debug->OutPut(DEBUG_LEVEL_MSG, "DRV_ENABLE");
}
return 1L;
}
break;
case DRV_DISABLE:
{
// nothing to do
if (debug != NULL)
{
debug->OutPut(DEBUG_LEVEL_MSG, "DRV_DISABLE");
}
return 1L;
}
break;
case DRV_FREE:
{
if (debug != NULL)
{
debug->OutPut(DEBUG_LEVEL_MSG, "DRV_FREE");
}
return 1L;
}
break;
default:
{
ACM * ThisACM = (ACM *)dwDriverId;
if (ThisACM != NULL)
return ThisACM->DriverProcedure(hdrvr, msg, lParam1, lParam2);
else
{
if (debug != NULL)
{
debug->OutPut(DEBUG_LEVEL_MSG, "Driver not opened, unknown message (0x%08X), lParam1 = 0x%08X, lParam2 = 0x%08X", msg, lParam1, lParam2);
}
return DefDriverProc (dwDriverId, hdrvr, msg, lParam1, lParam2);
}
}
break;
}
}
LONG APIENTRY
DriverProc(
DWORD DriverId,
HANDLE DriverHandle,
UINT Message,
LONG Parameter1,
LONG Parameter2)
{
MMRESULT Result;
switch ( Message )
{
case DRV_LOAD :
{
SND_TRACE(L"DRV_LOAD\n");
Result = InitEntrypointMutexes();
if ( ! MMSUCCESS(Result) )
return 0L;
Result = EnumerateNt4ServiceSoundDevices(L"sndblst",
0,
FoundDevice);
if ( ! MMSUCCESS(Result) )
{
CleanupEntrypointMutexes();
UnlistAllSoundDevices();
return 0L;
}
/*
PSOUND_DEVICE snd;
GetSoundDevice(WAVE_OUT_DEVICE_TYPE, 0, &snd);
GetSoundDevice(AUX_DEVICE_TYPE, 0, &snd);
GetSoundDevice(AUX_DEVICE_TYPE, 1, &snd);
GetSoundDevice(AUX_DEVICE_TYPE, 2, &snd);
*/
SND_TRACE(L"Initialisation complete\n");
return 1L;
}
case DRV_FREE :
{
SND_TRACE(L"DRV_FREE\n");
/* TODO: Clean up the path names! */
UnlistAllSoundDevices();
CleanupEntrypointMutexes();
SND_TRACE(L"Unfreed memory blocks: %d\n",
GetMemoryAllocationCount());
return 1L;
}
case DRV_ENABLE :
case DRV_DISABLE :
{
SND_TRACE(L"DRV_ENABLE / DRV_DISABLE\n");
return 1L;
}
case DRV_OPEN :
case DRV_CLOSE :
{
SND_TRACE(L"DRV_OPEN / DRV_CLOSE\n");
return 1L;
}
case DRV_QUERYCONFIGURE :
{
SND_TRACE(L"DRV_QUERYCONFIGURE");
return 0L;
}
case DRV_CONFIGURE :
return DRVCNF_OK;
default :
SND_TRACE(L"Unhandled message %d\n", Message);
return DefDriverProc(DriverId,
DriverHandle,
Message,
Parameter1,
Parameter2);
}
}
LRESULT CALLBACK
DriverProc(DWORD dwDriverID,
HDRVR hDriver,
UINT uMsg,
LPARAM lParam1,
LPARAM lParam2)
{
LPDRVCONFIGINFO lpDrvConfigInfo;
LPSTR lpszOpenParam;
DWORD dwOpenParam;
DWORD dwCloseParam1, dwCloseParam2;
HWND hConfigWndParent;
LPMCI_OPEN_DRIVER_PARMS lpMciOpenDriverParms;
DWORD dwMciOpenFlags;
LPMCI_OPEN_PARMS lpMciOpenParms;
DWORD dwMciGenericFlags;
LPMCI_GENERIC_PARMS lpMciGenericParms;
DWORD dwMciGetDevCapsFlags;
LPMCI_GETDEVCAPS_PARMS lpMciGetDevCapsParms;
DWORD dwMciInfoFlags;
LPMCI_INFO_PARMS lpMciInfoParms;
DWORD dwMciStatusFlags;
LPMCI_STATUS_PARMS lpMciStatusParms;
switch (uMsg)
{
case DRV_INSTALL:
lpDrvConfigInfo = (LPDRVCONFIGINFO) lParam2;
return XXXX_Install(dwDriverID, hDriver,
lpDrvConfigInfo);
case DRV_REMOVE:
return XXXX_Remove(dwDriverID, hDriver);
case DRV_LOAD:
return XXXX_Load(dwDriverID, hDriver);
case DRV_FREE:
return XXXX_Free(dwDriverID, hDriver);
case DRV_ENABLE:
return XXXX_Enable(dwDriverID, hDriver);
case DRV_DISABLE:
return XXXX_Disable(dwDriverID, hDriver);
case DRV_OPEN:
lpszOpenParam = (LPSTR) lParam1;
dwOpenParam = (DWORD) lParam2;
lpMciOpenDriverParms = (LPMCI_OPEN_DRIVER_PARMS) dwOpenParam;
return XXXX_mciOpen(dwDriverID, hDriver,
lpszOpenParam, lpMciOpenDriverParms);
case DRV_CLOSE:
dwCloseParam1 = (DWORD) lParam1;
dwCloseParam2 = (DWORD) lParam2;
return XXXX_Close(dwDriverID, hDriver,
dwCloseParam1, dwCloseParam2);
case DRV_QUERYCONFIGURE:
return XXXX_QueryConfigure(dwDriverID, hDriver);
case DRV_CONFIGURE:
hConfigWndParent = (HWND) lParam1;
lpDrvConfigInfo = (LPDRVCONFIGINFO) lParam2;
return XXXX_Configure(dwDriverID, hDriver,
hConfigWndParent, lpDrvConfigInfo);
case MCI_OPEN_DRIVER:
dwMciOpenFlags = (DWORD) lParam1;
lpMciOpenParms = (LPMCI_OPEN_PARMS) lParam2;
return XXXX_mciOpenDriver(dwDriverID, hDriver,
dwMciOpenFlags, lpMciOpenParms);
case MCI_CLOSE_DRIVER:
dwMciGenericFlags = (DWORD) lParam1;
lpMciGenericParms = (LPMCI_GENERIC_PARMS) lParam2;
return XXXX_mciCloseDriver(dwDriverID, hDriver,
dwMciGenericFlags, lpMciGenericParms);
case MCI_GETDEVCAPS:
dwMciGetDevCapsFlags = (DWORD) lParam1;
lpMciGetDevCapsParms = (LPMCI_GETDEVCAPS_PARMS) lParam2;
return XXXX_mciGetDevCaps(dwDriverID, hDriver,
dwMciGetDevCapsFlags, lpMciGetDevCapsParms);
case MCI_INFO:
dwMciInfoFlags = (DWORD) lParam1;
lpMciInfoParms = (LPMCI_INFO_PARMS) lParam2;
return XXXX_mciInfo(dwDriverID, hDriver,
dwMciInfoFlags, lpMciInfoParms);
case MCI_STATUS:
dwMciStatusFlags = (DWORD) lParam1;
lpMciStatusParms = (LPMCI_STATUS_PARMS) lParam2;
return XXXX_mciStatus(dwDriverID, hDriver,
dwMciStatusFlags, lpMciStatusParms);
}
return DefDriverProc(dwDriverID, hDriver, uMsg, lParam1, lParam2);
}
// this is the drawproc that vfw calls. It basically just hands
// stuff off to other functions later in this file. A few things
// are handled here. This is message-handling proc just like a
// Window Proc or a VBX Control Proc...
LONG FAR PASCAL _export ICAVIDrawProc(DWORD id, HDRVR hDriver,
UINT uiMessage, LPARAM lParam1, LPARAM lParam2)
{
PINSTINFO pi = (PINSTINFO)id;
switch (uiMessage)
{
case DRV_LOAD:
case DRV_FREE:
return 1;
case DRV_OPEN:
if (lParam2 == 0L)
{
// Uh-oh, no data to use...
return 1;
}
return AVIDrawOpen((ICOPEN FAR *)lParam2);
case DRV_CLOSE:
return AVIDrawClose(pi);
case DRV_QUERYCONFIGURE:
return 0;
case DRV_CONFIGURE:
return 1;
case ICM_CONFIGURE:
case ICM_ABOUT:
return ICERR_UNSUPPORTED;
case ICM_GETSTATE:
return 0L;
case ICM_GETINFO:
return AVIDrawGetInfo((ICINFO FAR *)lParam1, lParam2);
case ICM_DRAW_QUERY:
return AVIDrawQuery(pi, (LPBITMAPINFOHEADER)lParam1);
case ICM_DRAW_SUGGESTFORMAT:
return AVIDrawSuggestFormat(pi, (ICDRAWSUGGEST FAR *) lParam1, lParam2);
case ICM_DRAW_BEGIN:
return AVIDrawBegin(pi, (ICDRAWBEGIN FAR *) lParam1, lParam2);
case ICM_DRAW_REALIZE:
pi->hdc = (HDC) lParam1;
if (!pi->hdc || !pi->hdd)
{
// we aren't initialized yet.
break;
}
return DrawDibRealize(pi->hdd, pi->hdc, (BOOL) lParam2);
case ICM_DRAW_GET_PALETTE:
if (!pi->hdd)
{
break;
}
return (LONG) (UINT) DrawDibGetPalette(pi->hdd);
case ICM_DRAW:
return AVIDraw(pi, (ICDRAW FAR *)lParam1, lParam2);
case ICM_DRAW_CHANGEPALETTE:
return AVIDrawChangePalette(pi, (LPBITMAPINFOHEADER) lParam1);
case ICM_DRAW_END:
return AVIDrawEnd(pi);
case DRV_DISABLE:
case DRV_ENABLE:
return 1;
case DRV_INSTALL:
case DRV_REMOVE:
return 1;
}
if (uiMessage < DRV_USER)
{
return DefDriverProc(id,hDriver,uiMessage,lParam1,lParam2);
}
else
{
return ICERR_UNSUPPORTED;
}
}
LONG
FAR PASCAL
DriverProc(
DWORD driver_id,
HDRVR driver_handle,
UINT message,
LONG parameter1,
LONG parameter2)
{
switch ( message )
{
case DRV_LOAD :
DPRINT("DRV_LOAD\n");
the_device = NULL;
return 1L;
case DRV_FREE :
DPRINT("DRV_FREE\n");
return 1L;
case DRV_OPEN :
DPRINT("DRV_OPEN\n");
InitializeCriticalSection(&device_lock);
return 1L;
case DRV_CLOSE :
DPRINT("DRV_CLOSE\n");
return 1L;
case DRV_ENABLE :
DPRINT("DRV_ENABLE\n");
return 1L;
case DRV_DISABLE :
DPRINT("DRV_DISABLE\n");
return 1L;
/*
We don't provide configuration capabilities. This used to be
for things like I/O port, IRQ, DMA settings, etc.
*/
case DRV_QUERYCONFIGURE :
DPRINT("DRV_QUERYCONFIGURE\n");
return 0L;
case DRV_CONFIGURE :
DPRINT("DRV_CONFIGURE\n");
return 0L;
case DRV_INSTALL :
DPRINT("DRV_INSTALL\n");
return DRVCNF_RESTART;
};
DPRINT("???\n");
return DefDriverProc(driver_id,
driver_handle,
message,
parameter1,
parameter2);
}
