| /* |
| * MMSYTEM functions |
| * |
| * Copyright 1993 Martin Ayotte |
| */ |
| /* FIXME: I think there are some segmented vs. linear pointer weirdnesses |
| * and long term pointers to 16 bit space in here |
| */ |
| |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <fcntl.h> |
| #include <errno.h> |
| #include <sys/ioctl.h> |
| #include "windows.h" |
| #include "win.h" |
| #include "heap.h" |
| #include "ldt.h" |
| #include "user.h" |
| #include "driver.h" |
| #include "file.h" |
| #include "mmsystem.h" |
| #include "stddebug.h" |
| #include "debug.h" |
| #include "xmalloc.h" |
| #include "callback.h" |
| |
| static int InstalledCount; |
| static int InstalledListLen; |
| static LPSTR lpInstallNames = NULL; |
| |
| MCI_OPEN_DRIVER_PARMS mciDrv[MAXMCIDRIVERS]; |
| /* struct below is to remember alias/devicenames for mcistring.c |
| * FIXME: should use some internal struct ... |
| */ |
| MCI_OPEN_PARMS mciOpenDrv[MAXMCIDRIVERS]; |
| |
| UINT16 midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize); |
| UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize); |
| LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2); |
| |
| LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2); |
| LONG MIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2); |
| LONG CDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2); |
| LONG ANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2); |
| |
| |
| #define GetDrv(wDevID) (&mciDrv[MMSYSTEM_DevIDToIndex(wDevID)]) |
| #define GetOpenDrv(wDevID) (&mciOpenDrv[MMSYSTEM_DevIDToIndex(wDevID)]) |
| |
| /* The wDevID's returned by wine were originally in the range |
| * 0 - (MAXMCIDRIVERS - 1) and used directly as array indices. |
| * Unfortunately, ms-windows uses wDevID of zero to indicate |
| * errors. Now, multimedia drivers must pass the wDevID through |
| * MMSYSTEM_DevIDToIndex to get an index in that range. An |
| * aribtrary value, MMSYSTEM_MAGIC is added to the wDevID seen |
| * by the windows programs. |
| */ |
| |
| #define MMSYSTEM_MAGIC 0x0F00 |
| |
| /************************************************************************** |
| * MMSYSTEM_DevIDToIndex [internal] |
| */ |
| int MMSYSTEM_DevIDToIndex(UINT16 wDevID) { |
| return wDevID - MMSYSTEM_MAGIC; |
| } |
| |
| /************************************************************************** |
| * MMSYSTEM_FirstDevId [internal] |
| */ |
| UINT16 MMSYSTEM_FirstDevID(void) |
| { |
| return MMSYSTEM_MAGIC; |
| } |
| |
| /************************************************************************** |
| * MMSYSTEM_NextDevId [internal] |
| */ |
| UINT16 MMSYSTEM_NextDevID(UINT16 wDevID) { |
| return wDevID + 1; |
| } |
| |
| /************************************************************************** |
| * MMSYSTEM_DevIdValid [internal] |
| */ |
| BOOL32 MMSYSTEM_DevIDValid(UINT16 wDevID) { |
| return wDevID >= 0x0F00 && wDevID < (0x0F00 + MAXMCIDRIVERS); |
| } |
| |
| /************************************************************************** |
| * MMSYSTEM_WEP [MMSYSTEM.1] |
| */ |
| int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg, |
| WORD cbHeapSize, LPSTR lpCmdLine) |
| { |
| fprintf(stderr, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance); |
| return(TRUE); |
| } |
| |
| /************************************************************************** |
| * PlaySoundA [WINMM.1] |
| */ |
| BOOL32 WINAPI PlaySound32A(LPCSTR pszSound, HMODULE32 hmod, DWORD fdwSound) |
| { |
| dprintf_mmsys(stddeb, "PlaySoundA: pszSound='%s' hmod=%04X fdwSound=%08lX\n", |
| pszSound, hmod, fdwSound); |
| if(hmod != 0 || !(fdwSound & SND_FILENAME)) { |
| fprintf(stderr, "PlaySoundA: only disk sound files are supported\n"); |
| return FALSE; |
| } else { |
| BOOL16 bSound; |
| bSound = sndPlaySound(pszSound, (UINT16) fdwSound); |
| return (BOOL32) bSound; |
| } |
| } |
| |
| /************************************************************************** |
| * PlaySoundW [WINMM.18] |
| */ |
| BOOL32 WINAPI PlaySound32W(LPCWSTR pszSound, HMODULE32 hmod, DWORD fdwSound) |
| { |
| LPSTR pszSoundA = xmalloc((lstrlen32W(pszSound)+1)*sizeof(WCHAR)); |
| BOOL32 bSound; |
| lstrcpyWtoA(pszSoundA, pszSound); |
| bSound = PlaySound32A(pszSoundA, hmod, fdwSound); |
| free(pszSoundA); |
| return bSound; |
| } |
| |
| /************************************************************************** |
| * sndPlaySound [MMSYSTEM.2] |
| */ |
| BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags) |
| { |
| BOOL16 bRet = FALSE; |
| HMMIO16 hmmio; |
| MMCKINFO ckMainRIFF; |
| char str[128]; |
| LPSTR ptr; |
| |
| dprintf_mmsys(stddeb, "sndPlaySound // SoundName='%s' uFlags=%04X !\n", |
| lpszSoundName, uFlags); |
| if (lpszSoundName == NULL) { |
| dprintf_mmsys(stddeb, "sndPlaySound // Stop !\n"); |
| return FALSE; |
| } |
| hmmio = mmioOpen((LPSTR)lpszSoundName, NULL, |
| MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE); |
| |
| if (uFlags & SND_MEMORY) { |
| dprintf_mmsys(stddeb, "sndPlaySound // SND_MEMORY flag not implemented!\n"); |
| return FALSE; |
| } |
| |
| if (hmmio == 0) |
| { |
| dprintf_mmsys(stddeb, "sndPlaySound // searching in SystemSound List !\n"); |
| GetProfileString32A("Sounds", (LPSTR)lpszSoundName, "", str, sizeof(str)); |
| if (strlen(str) == 0) return FALSE; |
| if ( (ptr = (LPSTR)strchr(str, ',')) != NULL) *ptr = '\0'; |
| hmmio = mmioOpen(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE); |
| if (hmmio == 0) |
| { |
| dprintf_mmsys(stddeb, "sndPlaySound // can't find SystemSound='%s' !\n", str); |
| return FALSE; |
| } |
| } |
| |
| if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0) |
| { |
| dprintf_mmsys(stddeb, "sndPlaySound // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n", |
| (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize); |
| |
| if ((ckMainRIFF.ckid == FOURCC_RIFF) && |
| (ckMainRIFF.fccType == mmioFOURCC('W', 'A', 'V', 'E'))) |
| { |
| MMCKINFO mmckInfo; |
| |
| mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' '); |
| |
| if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) |
| { |
| PCMWAVEFORMAT pcmWaveFormat; |
| |
| dprintf_mmsys(stddeb, "sndPlaySound // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n", |
| (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize); |
| |
| if (mmioRead(hmmio, (HPSTR) &pcmWaveFormat, |
| (long) sizeof(PCMWAVEFORMAT)) == (long) sizeof(PCMWAVEFORMAT)) |
| { |
| |
| dprintf_mmsys(stddeb, "sndPlaySound // wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag); |
| dprintf_mmsys(stddeb, "sndPlaySound // nChannels=%d \n", pcmWaveFormat.wf.nChannels); |
| dprintf_mmsys(stddeb, "sndPlaySound // nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec); |
| dprintf_mmsys(stddeb, "sndPlaySound // nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec); |
| dprintf_mmsys(stddeb, "sndPlaySound // nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign); |
| dprintf_mmsys(stddeb, "sndPlaySound // wBitsPerSample=%u !\n", pcmWaveFormat.wBitsPerSample); |
| |
| mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a'); |
| if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) |
| { |
| LPWAVEFORMAT lpFormat = (LPWAVEFORMAT) SEGPTR_ALLOC(sizeof(PCMWAVEFORMAT)); |
| LPWAVEOPENDESC lpWaveDesc = (LPWAVEOPENDESC) SEGPTR_ALLOC(sizeof(WAVEOPENDESC)); |
| DWORD dwRet; |
| |
| dprintf_mmsys(stddeb, "sndPlaySound // Chunk Found \ |
| ckid=%.4s fccType=%.4s cksize=%08lX \n", (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize); |
| |
| pcmWaveFormat.wf.nAvgBytesPerSec = pcmWaveFormat.wf.nSamplesPerSec * |
| pcmWaveFormat.wf.nBlockAlign; |
| memcpy(lpFormat, &pcmWaveFormat, sizeof(PCMWAVEFORMAT)); |
| |
| lpWaveDesc->hWave = 0; |
| lpWaveDesc->lpFormat = (LPWAVEFORMAT) SEGPTR_GET(lpFormat); |
| |
| dwRet = wodMessage( 0, |
| WODM_OPEN, 0, (DWORD)SEGPTR_GET(lpWaveDesc), CALLBACK_NULL); |
| SEGPTR_FREE(lpFormat); |
| SEGPTR_FREE(lpWaveDesc); |
| |
| if (dwRet == MMSYSERR_NOERROR) |
| { |
| LPWAVEHDR lpWaveHdr = (LPWAVEHDR) SEGPTR_ALLOC(sizeof(WAVEHDR)); |
| SEGPTR spWaveHdr = SEGPTR_GET(lpWaveHdr); |
| HGLOBAL16 hData; |
| INT32 count, bufsize; |
| |
| bufsize = 64000; |
| hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize); |
| lpWaveHdr->lpData = (LPSTR) WIN16_GlobalLock16(hData); |
| lpWaveHdr->dwBufferLength = bufsize; |
| lpWaveHdr->dwUser = 0L; |
| lpWaveHdr->dwFlags = 0L; |
| lpWaveHdr->dwLoops = 0L; |
| |
| dwRet = wodMessage( 0, |
| WODM_PREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR)); |
| if (dwRet == MMSYSERR_NOERROR) |
| { |
| while( TRUE ) |
| { |
| count = mmioRead(hmmio, PTR_SEG_TO_LIN(lpWaveHdr->lpData), bufsize); |
| if (count < 1) break; |
| lpWaveHdr->dwBufferLength = count; |
| /* lpWaveHdr->dwBytesRecorded = count; */ |
| wodMessage( 0, WODM_WRITE, |
| 0, (DWORD)spWaveHdr, sizeof(WAVEHDR)); |
| } |
| wodMessage( 0, |
| WODM_UNPREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR)); |
| wodMessage( 0, |
| WODM_CLOSE, 0, 0L, 0L); |
| |
| bRet = TRUE; |
| } |
| else dprintf_mmsys(stddeb, "sndPlaySound // can't prepare WaveOut device !\n"); |
| |
| GlobalUnlock16(hData); |
| GlobalFree16(hData); |
| |
| SEGPTR_FREE(lpWaveHdr); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if (hmmio != 0) mmioClose(hmmio, 0); |
| return bRet; |
| } |
| |
| /************************************************************************** |
| * mmsystemGetVersion [MMSYSTEM.5] |
| */ |
| WORD WINAPI mmsystemGetVersion() |
| { |
| dprintf_mmsys(stddeb, "mmsystemGetVersion // 0.4.0 ...?... :-) !\n"); |
| return 0x0040; |
| } |
| |
| /************************************************************************** |
| * DriverProc [MMSYSTEM.6] |
| */ |
| LRESULT WINAPI DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| return DrvDefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2); |
| } |
| |
| /************************************************************************** |
| * DriverCallback [MMSYSTEM.31] |
| */ |
| BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev, |
| WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "DriverCallback(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n", |
| dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2); |
| switch(uFlags & DCB_TYPEMASK) { |
| case DCB_NULL: |
| dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_NULL !\n"); |
| break; |
| case DCB_WINDOW: |
| dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_WINDOW = %04lX handle = %04X!\n",dwCallBack,hDev); |
| if (!IsWindow32(dwCallBack)) return FALSE; |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hDev); |
| if (lpDesc == NULL) return FALSE; |
| |
| PostMessage16((HWND16)dwCallBack, wMsg, hDev, dwParam1); |
| break; |
| case DCB_TASK: |
| dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_TASK !\n"); |
| return FALSE; |
| case DCB_FUNCTION: |
| dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_FUNCTION !\n"); |
| CallDriverCallback( (FARPROC16)dwCallBack, hDev, wMsg, |
| dwUser, dwParam1, dwParam2 ); |
| break; |
| } |
| return TRUE; |
| } |
| |
| /************************************************************************** |
| * auxGetNumDevs [MMSYSTEM.350] |
| */ |
| UINT16 WINAPI auxGetNumDevs() |
| { |
| UINT16 count = 0; |
| dprintf_mmsys(stddeb, "auxGetNumDevs !\n"); |
| count += auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L); |
| dprintf_mmsys(stddeb, "auxGetNumDevs return %u \n", count); |
| return count; |
| } |
| |
| /************************************************************************** |
| * auxGetDevCaps [MMSYSTEM.351] |
| */ |
| UINT16 WINAPI auxGetDevCaps(UINT16 uDeviceID, AUXCAPS * lpCaps, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "auxGetDevCaps(%04X, %p, %d) !\n", |
| uDeviceID, lpCaps, uSize); |
| return auxMessage(uDeviceID, AUXDM_GETDEVCAPS, |
| 0L, (DWORD)lpCaps, (DWORD)uSize); |
| } |
| |
| /************************************************************************** |
| * auxGetVolume [MMSYSTEM.352] |
| */ |
| UINT16 WINAPI auxGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume) |
| { |
| dprintf_mmsys(stddeb, "auxGetVolume(%04X, %p) !\n", uDeviceID, lpdwVolume); |
| return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L); |
| } |
| |
| /************************************************************************** |
| * auxSetVolume [MMSYSTEM.353] |
| */ |
| UINT16 WINAPI auxSetVolume(UINT16 uDeviceID, DWORD dwVolume) |
| { |
| dprintf_mmsys(stddeb, "auxSetVolume(%04X, %08lX) !\n", uDeviceID, dwVolume); |
| return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L); |
| } |
| |
| /************************************************************************** |
| * auxOutMessage [MMSYSTEM.354] |
| */ |
| DWORD WINAPI auxOutMessage(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2) |
| { |
| dprintf_mmsys(stddeb, "auxOutMessage(%04X, %04X, %08lX, %08lX)\n", |
| uDeviceID, uMessage, dw1, dw2); |
| return auxMessage(uDeviceID, uMessage, 0L, dw1, dw2); |
| } |
| |
| /************************************************************************** |
| * mciGetErrorString [MMSYSTEM.706] |
| */ |
| BOOL16 WINAPI mciGetErrorString (DWORD wError, LPSTR lpstrBuffer, UINT16 uLength) |
| { |
| LPSTR msgptr; |
| dprintf_mmsys(stddeb, "mciGetErrorString(%08lX, %p, %d);\n", wError, lpstrBuffer, uLength); |
| if ((lpstrBuffer == NULL) || (uLength < 1)) return(FALSE); |
| lpstrBuffer[0] = '\0'; |
| switch(wError) { |
| case MCIERR_INVALID_DEVICE_ID: |
| msgptr = "Invalid MCI device ID. Use the ID returned when opening the MCI device."; |
| break; |
| case MCIERR_UNRECOGNIZED_KEYWORD: |
| msgptr = "The driver cannot recognize the specified command parameter."; |
| break; |
| case MCIERR_UNRECOGNIZED_COMMAND: |
| msgptr = "The driver cannot recognize the specified command."; |
| break; |
| case MCIERR_HARDWARE: |
| msgptr = "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer."; |
| break; |
| case MCIERR_INVALID_DEVICE_NAME: |
| msgptr = "The specified device is not open or is not recognized by MCI."; |
| break; |
| case MCIERR_OUT_OF_MEMORY: |
| msgptr = "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again."; |
| break; |
| case MCIERR_DEVICE_OPEN: |
| msgptr = "The device name is already being used as an alias by this application. Use a unique alias."; |
| break; |
| case MCIERR_CANNOT_LOAD_DRIVER: |
| msgptr = "There is an undetectable problem in loading the specified device driver."; |
| break; |
| case MCIERR_MISSING_COMMAND_STRING: |
| msgptr = "No command was specified."; |
| break; |
| case MCIERR_PARAM_OVERFLOW: |
| msgptr = "The output string was to large to fit in the return buffer. Increase the size of the buffer."; |
| break; |
| case MCIERR_MISSING_STRING_ARGUMENT: |
| msgptr = "The specified command requires a character-string parameter. Please provide one."; |
| break; |
| case MCIERR_BAD_INTEGER: |
| msgptr = "The specified integer is invalid for this command."; |
| break; |
| case MCIERR_PARSER_INTERNAL: |
| msgptr = "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver."; |
| break; |
| case MCIERR_DRIVER_INTERNAL: |
| msgptr = "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver."; |
| break; |
| case MCIERR_MISSING_PARAMETER: |
| msgptr = "The specified command requires a parameter. Please supply one."; |
| break; |
| case MCIERR_UNSUPPORTED_FUNCTION: |
| msgptr = "The MCI device you are using does not support the specified command."; |
| break; |
| case MCIERR_FILE_NOT_FOUND: |
| msgptr = "Cannot find the specified file. Make sure the path and filename are correct."; |
| break; |
| case MCIERR_DEVICE_NOT_READY: |
| msgptr = "The device driver is not ready."; |
| break; |
| case MCIERR_INTERNAL: |
| msgptr = "A problem occurred in initializing MCI. Try restarting Windows."; |
| break; |
| case MCIERR_DRIVER: |
| msgptr = "There is a problem with the device driver. The driver has closed. Cannot access error."; |
| break; |
| case MCIERR_CANNOT_USE_ALL: |
| msgptr = "Cannot use 'all' as the device name with the specified command."; |
| break; |
| case MCIERR_MULTIPLE: |
| msgptr = "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error"; |
| break; |
| case MCIERR_EXTENSION_NOT_FOUND: |
| msgptr = "Cannot determine the device type from the given filename extension."; |
| break; |
| case MCIERR_OUTOFRANGE: |
| msgptr = "The specified parameter is out of range for the specified command."; |
| break; |
| case MCIERR_FLAGS_NOT_COMPATIBLE: |
| msgptr = "The specified parameters cannot be used together."; |
| break; |
| case MCIERR_FILE_NOT_SAVED: |
| msgptr = "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network."; |
| break; |
| case MCIERR_DEVICE_TYPE_REQUIRED: |
| msgptr = "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly."; |
| break; |
| case MCIERR_DEVICE_LOCKED: |
| msgptr = "The specified device is now being closed. Wait a few seconds, and then try again."; |
| break; |
| case MCIERR_DUPLICATE_ALIAS: |
| msgptr = "The specified alias is already being used in this application. Use a unique alias."; |
| break; |
| case MCIERR_BAD_CONSTANT: |
| msgptr = "The specified parameter is invalid for this command."; |
| break; |
| case MCIERR_MUST_USE_SHAREABLE: |
| msgptr = "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command."; |
| break; |
| case MCIERR_MISSING_DEVICE_NAME: |
| msgptr = "The specified command requires an alias, file, driver, or device name. Please supply one."; |
| break; |
| case MCIERR_BAD_TIME_FORMAT: |
| msgptr = "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats."; |
| break; |
| case MCIERR_NO_CLOSING_QUOTE: |
| msgptr = "A closing double-quotation mark is missing from the parameter value. Please supply one."; |
| break; |
| case MCIERR_DUPLICATE_FLAGS: |
| msgptr = "A parameter or value was specified twice. Only specify it once."; |
| break; |
| case MCIERR_INVALID_FILE: |
| msgptr = "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format."; |
| break; |
| case MCIERR_NULL_PARAMETER_BLOCK: |
| msgptr = "A null parameter block was passed to MCI."; |
| break; |
| case MCIERR_UNNAMED_RESOURCE: |
| msgptr = "Cannot save an unnamed file. Supply a filename."; |
| break; |
| case MCIERR_NEW_REQUIRES_ALIAS: |
| msgptr = "You must specify an alias when using the 'new' parameter."; |
| break; |
| case MCIERR_NOTIFY_ON_AUTO_OPEN: |
| msgptr = "Cannot use the 'notify' flag with auto-opened devices."; |
| break; |
| case MCIERR_NO_ELEMENT_ALLOWED: |
| msgptr = "Cannot use a filename with the specified device."; |
| break; |
| case MCIERR_NONAPPLICABLE_FUNCTION: |
| msgptr = "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again."; |
| break; |
| case MCIERR_ILLEGAL_FOR_AUTO_OPEN: |
| msgptr = "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again."; |
| break; |
| case MCIERR_FILENAME_REQUIRED: |
| msgptr = "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension."; |
| break; |
| case MCIERR_EXTRA_CHARACTERS: |
| msgptr = "Cannot specify extra characters after a string enclosed in quotation marks."; |
| break; |
| case MCIERR_DEVICE_NOT_INSTALLED: |
| msgptr = "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device."; |
| break; |
| case MCIERR_GET_CD: |
| msgptr = "Cannot access the specified file or MCI device. Try changing directories or restarting your computer."; |
| break; |
| case MCIERR_SET_CD: |
| msgptr = "Cannot access the specified file or MCI device because the application cannot change directories."; |
| break; |
| case MCIERR_SET_DRIVE: |
| msgptr = "Cannot access specified file or MCI device because the application cannot change drives."; |
| break; |
| case MCIERR_DEVICE_LENGTH: |
| msgptr = "Specify a device or driver name that is less than 79 characters."; |
| break; |
| case MCIERR_DEVICE_ORD_LENGTH: |
| msgptr = "Specify a device or driver name that is less than 69 characters."; |
| break; |
| case MCIERR_NO_INTEGER: |
| msgptr = "The specified command requires an integer parameter. Please provide one."; |
| break; |
| case MCIERR_WAVE_OUTPUTSINUSE: |
| msgptr = "All wave devices that can play files in the current format are in use. Wait until a wave device is free, and then try again."; |
| break; |
| case MCIERR_WAVE_SETOUTPUTINUSE: |
| msgptr = "Cannot set the current wave device for play back because it is in use. Wait until the device is free, and then try again."; |
| break; |
| case MCIERR_WAVE_INPUTSINUSE: |
| msgptr = "All wave devices that can record files in the current format are in use. Wait until a wave device is free, and then try again."; |
| break; |
| case MCIERR_WAVE_SETINPUTINUSE: |
| msgptr = "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again."; |
| break; |
| case MCIERR_WAVE_OUTPUTUNSPECIFIED: |
| msgptr = "Any compatible waveform playback device may be used."; |
| break; |
| case MCIERR_WAVE_INPUTUNSPECIFIED: |
| msgptr = "Any compatible waveform recording device may be used."; |
| break; |
| case MCIERR_WAVE_OUTPUTSUNSUITABLE: |
| msgptr = "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device."; |
| break; |
| case MCIERR_WAVE_SETOUTPUTUNSUITABLE: |
| msgptr = "The device you are trying to play to cannot recognize the current file format."; |
| break; |
| case MCIERR_WAVE_INPUTSUNSUITABLE: |
| msgptr = "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device."; |
| break; |
| case MCIERR_WAVE_SETINPUTUNSUITABLE: |
| msgptr = "The device you are trying to record from cannot recognize the current file format."; |
| break; |
| case MCIERR_NO_WINDOW: |
| msgptr = "There is no display window."; |
| break; |
| case MCIERR_CREATEWINDOW: |
| msgptr = "Could not create or use window."; |
| break; |
| case MCIERR_FILE_READ: |
| msgptr = "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection."; |
| break; |
| case MCIERR_FILE_WRITE: |
| msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network."; |
| break; |
| case MCIERR_SEQ_DIV_INCOMPATIBLE: |
| msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together."; |
| break; |
| case MCIERR_SEQ_NOMIDIPRESENT: |
| msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver."; |
| break; |
| case MCIERR_SEQ_PORT_INUSE: |
| msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again."; |
| break; |
| case MCIERR_SEQ_PORT_MAPNODEVICE: |
| msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup."; |
| break; |
| case MCIERR_SEQ_PORT_MISCERROR: |
| msgptr = "An error occurred with the specified port."; |
| break; |
| case MCIERR_SEQ_PORT_NONEXISTENT: |
| msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device."; |
| break; |
| case MCIERR_SEQ_PORTUNSPECIFIED: |
| msgptr = "The system doesnot have a current MIDI port specified."; |
| break; |
| case MCIERR_SEQ_TIMER: |
| msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again."; |
| break; |
| |
| /* |
| msg# 513 : vcr |
| msg# 514 : videodisc |
| msg# 515 : overlay |
| msg# 516 : cdaudio |
| msg# 517 : dat |
| msg# 518 : scanner |
| msg# 519 : animation |
| msg# 520 : digitalvideo |
| msg# 521 : other |
| msg# 522 : waveaudio |
| msg# 523 : sequencer |
| msg# 524 : not ready |
| msg# 525 : stopped |
| msg# 526 : playing |
| msg# 527 : recording |
| msg# 528 : seeking |
| msg# 529 : paused |
| msg# 530 : open |
| msg# 531 : false |
| msg# 532 : true |
| msg# 533 : milliseconds |
| msg# 534 : hms |
| msg# 535 : msf |
| msg# 536 : frames |
| msg# 537 : smpte 24 |
| msg# 538 : smpte 25 |
| msg# 539 : smpte 30 |
| msg# 540 : smpte 30 drop |
| msg# 541 : bytes |
| msg# 542 : samples |
| msg# 543 : tmsf |
| */ |
| default: |
| msgptr = "Unknown MCI Error !\n"; |
| break; |
| } |
| lstrcpyn32A(lpstrBuffer, msgptr, uLength); |
| dprintf_mmsys(stddeb, "mciGetErrorString // msg = %s;\n", msgptr); |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * mciDriverNotify [MMSYSTEM.711] |
| */ |
| BOOL16 WINAPI mciDriverNotify(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus) |
| { |
| dprintf_mmsys(stddeb, "mciDriverNotify(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus); |
| if (!IsWindow32(hWndCallBack)) return FALSE; |
| dprintf_mmsys(stddeb, "mciDriverNotify // before PostMessage\n"); |
| PostMessage16( hWndCallBack, MM_MCINOTIFY, wStatus, |
| MAKELONG(wDevID, 0)); |
| return TRUE; |
| } |
| |
| /************************************************************************** |
| * mciOpen [internal] |
| */ |
| |
| DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS lp16Parms) |
| { |
| char str[128]; |
| LPMCI_OPEN_PARMS lpParms; |
| UINT16 uDevTyp = 0; |
| UINT16 wDevID = MMSYSTEM_FirstDevID(); |
| DWORD dwret; |
| |
| lpParms = PTR_SEG_TO_LIN(lp16Parms); |
| dprintf_mmsys(stddeb, "mciOpen(%08lX, %p (%p))\n", dwParam, lp16Parms, lpParms); |
| if (lp16Parms == NULL) return MCIERR_INTERNAL; |
| |
| while(GetDrv(wDevID)->wType != 0) { |
| wDevID = MMSYSTEM_NextDevID(wDevID); |
| if (!MMSYSTEM_DevIDValid(wDevID)) { |
| dprintf_mmsys(stddeb, "MCI_OPEN // MAXMCIDRIVERS reached !\n"); |
| return MCIERR_INTERNAL; |
| } |
| } |
| dprintf_mmsys(stddeb, "mciOpen // wDevID=%04X \n", wDevID); |
| memcpy(GetOpenDrv(wDevID),lpParms,sizeof(*lpParms)); |
| |
| if (dwParam & MCI_OPEN_ELEMENT) { |
| char *s,*t; |
| |
| dprintf_mmsys(stddeb,"mciOpen // lpstrElementName='%s'\n", |
| (char*)PTR_SEG_TO_LIN(lpParms->lpstrElementName) |
| ); |
| s=(char*)PTR_SEG_TO_LIN(lpParms->lpstrElementName); |
| t=strrchr(s,'.'); |
| if (t) { |
| GetProfileString32A("mci extensions",t+1,"*",str,sizeof(str)); |
| CharUpper32A(str); |
| dprintf_mmsys(stddeb, "mciOpen // str = %s \n", str); |
| if (strcmp(str, "CDAUDIO") == 0) { |
| uDevTyp = MCI_DEVTYPE_CD_AUDIO; |
| } else |
| if (strcmp(str, "WAVEAUDIO") == 0) { |
| uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO; |
| } else |
| if (strcmp(str, "SEQUENCER") == 0) { |
| uDevTyp = MCI_DEVTYPE_SEQUENCER; |
| } else |
| if (strcmp(str, "ANIMATION1") == 0) { |
| uDevTyp = MCI_DEVTYPE_ANIMATION; |
| } else |
| if (strcmp(str, "AVIVIDEO") == 0) { |
| uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO; |
| } else |
| if (strcmp(str,"*") == 0) { |
| dprintf_mmsys(stddeb,"No [mci extensions] entry for %s found.\n",t); |
| return MCIERR_EXTENSION_NOT_FOUND; |
| } else { |
| dprintf_mmsys(stddeb,"[mci extensions] entry %s for %s not supported.\n",str,t); |
| } |
| } else |
| return MCIERR_EXTENSION_NOT_FOUND; |
| } |
| |
| if (dwParam & MCI_OPEN_ALIAS) { |
| dprintf_mmsys(stddeb, "MCI_OPEN // Alias='%s' !\n", |
| (char*)PTR_SEG_TO_LIN(lpParms->lpstrAlias)); |
| GetOpenDrv(wDevID)->lpstrAlias = SEGPTR_GET( |
| SEGPTR_STRDUP((char*)PTR_SEG_TO_LIN(lpParms->lpstrAlias))); |
| /* mplayer does allocate alias to CDAUDIO */ |
| } |
| if (dwParam & MCI_OPEN_TYPE) { |
| if (dwParam & MCI_OPEN_TYPE_ID) { |
| dprintf_mmsys(stddeb, "MCI_OPEN // Dev=%08lx !\n", lpParms->lpstrDeviceType); |
| uDevTyp = LOWORD((DWORD)lpParms->lpstrDeviceType); |
| GetOpenDrv(wDevID)->lpstrDeviceType=lpParms->lpstrDeviceType; |
| } else { |
| if (lpParms->lpstrDeviceType == (SEGPTR)NULL) return MCIERR_INTERNAL; |
| dprintf_mmsys(stddeb, "MCI_OPEN // Dev='%s' !\n", |
| (char*)PTR_SEG_TO_LIN(lpParms->lpstrDeviceType)); |
| GetOpenDrv(wDevID)->lpstrDeviceType = SEGPTR_GET( |
| SEGPTR_STRDUP((char*)PTR_SEG_TO_LIN(lpParms->lpstrDeviceType))); |
| strcpy(str, PTR_SEG_TO_LIN(lpParms->lpstrDeviceType)); |
| CharUpper32A(str); |
| if (strcmp(str, "CDAUDIO") == 0) { |
| uDevTyp = MCI_DEVTYPE_CD_AUDIO; |
| } else |
| if (strcmp(str, "WAVEAUDIO") == 0) { |
| uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO; |
| } else |
| if (strcmp(str, "SEQUENCER") == 0) { |
| uDevTyp = MCI_DEVTYPE_SEQUENCER; |
| } else |
| if (strcmp(str, "ANIMATION1") == 0) { |
| uDevTyp = MCI_DEVTYPE_ANIMATION; |
| } else |
| if (strcmp(str, "AVIVIDEO") == 0) { |
| uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO; |
| } |
| } |
| } |
| GetDrv(wDevID)->wType = uDevTyp; |
| GetDrv(wDevID)->wDeviceID = 0; /* FIXME? for multiple devices */ |
| lpParms->wDeviceID = wDevID; |
| dprintf_mmsys(stddeb, "MCI_OPEN // mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n", |
| wDevID, uDevTyp, lpParms->wDeviceID); |
| switch(uDevTyp) |
| { |
| case MCI_DEVTYPE_CD_AUDIO: |
| dwret = CDAUDIO_DriverProc( 0, 0, MCI_OPEN_DRIVER, |
| dwParam, (DWORD)lp16Parms); |
| break; |
| case MCI_DEVTYPE_WAVEFORM_AUDIO: |
| dwret = WAVE_DriverProc( 0, 0, MCI_OPEN_DRIVER, |
| dwParam, (DWORD)lp16Parms); |
| break; |
| case MCI_DEVTYPE_SEQUENCER: |
| dwret = MIDI_DriverProc( 0, 0, MCI_OPEN_DRIVER, |
| dwParam, (DWORD)lp16Parms); |
| break; |
| case MCI_DEVTYPE_ANIMATION: |
| dwret = ANIM_DriverProc( 0, 0, MCI_OPEN_DRIVER, |
| dwParam, (DWORD)lp16Parms); |
| break; |
| case MCI_DEVTYPE_DIGITAL_VIDEO: |
| dprintf_mmsys(stddeb, "MCI_OPEN // No DIGITAL_VIDEO yet !\n"); |
| return MCIERR_DEVICE_NOT_INSTALLED; |
| default: |
| dprintf_mmsys(stddeb, "MCI_OPEN // Invalid Device Name '%08lx' !\n", lpParms->lpstrDeviceType); |
| return MCIERR_INVALID_DEVICE_NAME; |
| } |
| |
| |
| if (dwParam&MCI_NOTIFY) |
| mciDriverNotify(lpParms->dwCallback,wDevID, |
| (dwret==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE)); |
| |
| /* only handled devices fall through */ |
| dprintf_mmsys(stddeb, "MCI_OPEN // wDevID = %04X wDeviceID = %d dwret = %ld\n",wDevID, lpParms->wDeviceID, dwret); |
| return dwret; |
| } |
| |
| |
| /************************************************************************** |
| * mciClose [internal] |
| */ |
| DWORD mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) |
| { |
| DWORD dwRet = MCIERR_INTERNAL; |
| |
| dprintf_mmsys(stddeb, "mciClose(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms); |
| switch(GetDrv(wDevID)->wType) { |
| case MCI_DEVTYPE_CD_AUDIO: |
| dwRet = CDAUDIO_DriverProc(GetDrv(wDevID)->wDeviceID,0, |
| MCI_CLOSE, dwParam, (DWORD)lpParms); |
| break; |
| case MCI_DEVTYPE_WAVEFORM_AUDIO: |
| dwRet = WAVE_DriverProc(GetDrv(wDevID)->wDeviceID, 0, |
| MCI_CLOSE, dwParam, |
| (DWORD)lpParms); |
| break; |
| case MCI_DEVTYPE_SEQUENCER: |
| dwRet = MIDI_DriverProc(GetDrv(wDevID)->wDeviceID, 0, |
| MCI_CLOSE, dwParam, |
| (DWORD)lpParms); |
| break; |
| case MCI_DEVTYPE_ANIMATION: |
| dwRet = ANIM_DriverProc(GetDrv(wDevID)->wDeviceID, 0, |
| MCI_CLOSE, dwParam, |
| (DWORD)lpParms); |
| break; |
| default: |
| dprintf_mmsys(stddeb, "mciClose() // unknown device type=%04X !\n", GetDrv(wDevID)->wType); |
| dwRet = MCIERR_DEVICE_NOT_INSTALLED; |
| } |
| GetDrv(wDevID)->wType = 0; |
| |
| if (dwParam&MCI_NOTIFY) |
| mciDriverNotify(lpParms->dwCallback,wDevID, |
| (dwRet==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE)); |
| |
| dprintf_mmsys(stddeb, "mciClose() // returns %ld\n",dwRet); |
| return dwRet; |
| } |
| |
| |
| /************************************************************************** |
| * mciSysinfo [internal] |
| */ |
| DWORD mciSysInfo(DWORD dwFlags, LPMCI_SYSINFO_PARMS lpParms) |
| { |
| int len; |
| LPSTR ptr; |
| LPSTR lpstrReturn; |
| DWORD *lpdwRet; |
| LPSTR SysFile = "SYSTEM.INI"; |
| dprintf_mci(stddeb, "mciSysInfo(%08lX, %08lX)\n", dwFlags, (DWORD)lpParms); |
| lpstrReturn = PTR_SEG_TO_LIN(lpParms->lpstrReturn); |
| switch(dwFlags) { |
| case MCI_SYSINFO_QUANTITY: |
| dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_QUANTITY \n"); |
| lpdwRet = (DWORD *)lpstrReturn; |
| *(lpdwRet) = InstalledCount; |
| return 0; |
| case MCI_SYSINFO_INSTALLNAME: |
| dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_INSTALLNAME \n"); |
| if (lpInstallNames == NULL) { |
| InstalledCount = 0; |
| InstalledListLen = 0; |
| ptr = lpInstallNames = xmalloc(2048); |
| GetPrivateProfileString32A("mci", NULL, "", lpInstallNames, 2000, SysFile); |
| while(strlen(ptr) > 0) { |
| dprintf_mci(stddeb, "---> '%s' \n", ptr); |
| len = strlen(ptr) + 1; |
| ptr += len; |
| InstalledListLen += len; |
| InstalledCount++; |
| } |
| } |
| if (lpParms->dwRetSize < InstalledListLen) |
| lstrcpyn32A(lpstrReturn, lpInstallNames, lpParms->dwRetSize - 1); |
| else |
| strcpy(lpstrReturn, lpInstallNames); |
| return 0; |
| case MCI_SYSINFO_NAME: |
| dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_NAME \n"); |
| return 0; |
| case MCI_SYSINFO_OPEN: |
| dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_OPEN \n"); |
| return 0; |
| } |
| return MMSYSERR_INVALPARAM; |
| } |
| |
| /************************************************************************** |
| * mciSound [internal] |
| * not used anymore ?? |
| |
| DWORD mciSound(UINT16 wDevID, DWORD dwParam, LPMCI_SOUND_PARMS lpParms) |
| { |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| if (dwParam & MCI_SOUND_NAME) |
| dprintf_mci(stddeb, "MCI_SOUND // file='%s' !\n", lpParms->lpstrSoundName); |
| return MCIERR_INVALID_DEVICE_ID; |
| } |
| * |
| */ |
| |
| static const char *_mciCommandToString(UINT16 wMsg) |
| { |
| static char buffer[100]; |
| |
| #define CASE(s) case (s): return #s |
| |
| switch (wMsg) { |
| CASE(MCI_OPEN); |
| CASE(MCI_CLOSE); |
| CASE(MCI_ESCAPE); |
| CASE(MCI_PLAY); |
| CASE(MCI_SEEK); |
| CASE(MCI_STOP); |
| CASE(MCI_PAUSE); |
| CASE(MCI_INFO); |
| CASE(MCI_GETDEVCAPS); |
| CASE(MCI_SPIN); |
| CASE(MCI_SET); |
| CASE(MCI_STEP); |
| CASE(MCI_RECORD); |
| CASE(MCI_SYSINFO); |
| CASE(MCI_BREAK); |
| CASE(MCI_SAVE); |
| CASE(MCI_STATUS); |
| CASE(MCI_CUE); |
| CASE(MCI_REALIZE); |
| CASE(MCI_WINDOW); |
| CASE(MCI_PUT); |
| CASE(MCI_WHERE); |
| CASE(MCI_FREEZE); |
| CASE(MCI_UNFREEZE); |
| CASE(MCI_LOAD); |
| CASE(MCI_CUT); |
| CASE(MCI_COPY); |
| CASE(MCI_PASTE); |
| CASE(MCI_UPDATE); |
| CASE(MCI_RESUME); |
| CASE(MCI_DELETE); |
| default: |
| sprintf(buffer, "%04X", wMsg); |
| return buffer; |
| |
| } |
| } |
| |
| /************************************************************************** |
| * mciSendCommand [MMSYSTEM.701] |
| */ |
| DWORD WINAPI mciSendCommand(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, |
| DWORD dwParam2) |
| { |
| HDRVR16 hDrv = 0; |
| dprintf_mci(stddeb, "mciSendCommand(%04X, %s, %08lX, %08lX)\n", |
| wDevID, _mciCommandToString(wMsg), dwParam1, dwParam2); |
| switch(wMsg) |
| { |
| case MCI_OPEN: |
| return mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2); |
| case MCI_CLOSE: |
| return mciClose( wDevID, dwParam1, |
| (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_SYSINFO: |
| return mciSysInfo( dwParam1, |
| (LPMCI_SYSINFO_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| default: |
| switch(GetDrv(wDevID)->wType) |
| { |
| case MCI_DEVTYPE_CD_AUDIO: |
| return CDAUDIO_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv, |
| wMsg, dwParam1, dwParam2); |
| case MCI_DEVTYPE_WAVEFORM_AUDIO: |
| return WAVE_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv, |
| wMsg, dwParam1, dwParam2); |
| case MCI_DEVTYPE_SEQUENCER: |
| return MIDI_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv, |
| wMsg, dwParam1, dwParam2); |
| case MCI_DEVTYPE_ANIMATION: |
| return ANIM_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv, |
| wMsg, dwParam1, dwParam2); |
| default: |
| dprintf_mci(stddeb, |
| "mciSendCommand() // unknown device type=%04X !\n", |
| GetDrv(wDevID)->wType); |
| } |
| } |
| return MMSYSERR_INVALPARAM; |
| } |
| |
| /************************************************************************** |
| * mciGetDeviceID [MMSYSTEM.703] |
| */ |
| UINT16 WINAPI mciGetDeviceID (LPCSTR lpstrName) |
| { |
| UINT16 wDevID; |
| |
| dprintf_mci(stddeb, "mciGetDeviceID(\"%s\")\n", lpstrName); |
| if (lpstrName && !lstrcmpi32A(lpstrName, "ALL")) |
| return MCI_ALL_DEVICE_ID; |
| |
| if (!lpstrName) |
| return 0; |
| |
| wDevID = MMSYSTEM_FirstDevID(); |
| while(MMSYSTEM_DevIDValid(wDevID) && GetDrv(wDevID)->wType) { |
| if (GetOpenDrv(wDevID)->lpstrDeviceType && |
| strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrDeviceType), lpstrName) == 0) |
| return wDevID; |
| |
| if (GetOpenDrv(wDevID)->lpstrAlias && |
| strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrAlias), lpstrName) == 0) |
| return wDevID; |
| |
| wDevID = MMSYSTEM_NextDevID(wDevID); |
| } |
| |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mciSetYieldProc [MMSYSTEM.714] |
| */ |
| BOOL16 WINAPI mciSetYieldProc (UINT16 uDeviceID, |
| YIELDPROC fpYieldProc, DWORD dwYieldData) |
| { |
| return FALSE; |
| } |
| |
| /************************************************************************** |
| * mciGetDeviceIDFromElementID [MMSYSTEM.715] |
| */ |
| UINT16 WINAPI mciGetDeviceIDFromElementID(DWORD dwElementID, LPCSTR lpstrType) |
| { |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mciGetYieldProc [MMSYSTEM.716] |
| */ |
| YIELDPROC WINAPI mciGetYieldProc(UINT16 uDeviceID, DWORD * lpdwYieldData) |
| { |
| return NULL; |
| } |
| |
| /************************************************************************** |
| * mciGetCreatorTask [MMSYSTEM.717] |
| */ |
| HTASK16 WINAPI mciGetCreatorTask(UINT16 uDeviceID) |
| { |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiOutGetNumDevs [MMSYSTEM.201] |
| */ |
| UINT16 WINAPI midiOutGetNumDevs(void) |
| { |
| UINT16 count = 0; |
| dprintf_mmsys(stddeb, "midiOutGetNumDevs\n"); |
| count += modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L); |
| dprintf_mmsys(stddeb, "midiOutGetNumDevs return %u \n", count); |
| return count; |
| } |
| |
| /************************************************************************** |
| * midiOutGetDevCaps [MMSYSTEM.202] |
| */ |
| UINT16 WINAPI midiOutGetDevCaps(UINT16 uDeviceID, MIDIOUTCAPS * lpCaps, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "midiOutGetDevCaps\n"); |
| return modMessage(uDeviceID,MODM_GETDEVCAPS,0,(DWORD)lpCaps,uSize); |
| } |
| |
| /************************************************************************** |
| * midiOutGetErrorText [MMSYSTEM.203] |
| */ |
| UINT16 WINAPI midiOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "midiOutGetErrorText\n"); |
| return midiGetErrorText(uError, lpText, uSize); |
| } |
| |
| |
| /************************************************************************** |
| * midiGetErrorText [internal] |
| */ |
| UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) |
| { |
| LPSTR msgptr; |
| if ((lpText == NULL) || (uSize < 1)) return(FALSE); |
| lpText[0] = '\0'; |
| switch(uError) { |
| case MIDIERR_UNPREPARED: |
| msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again."; |
| break; |
| case MIDIERR_STILLPLAYING: |
| msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing."; |
| break; |
| case MIDIERR_NOMAP: |
| msgptr = "A MIDI map was not found. There may be a problem with the driver, or the MIDIMAP.CFG file may be corrupt or missing."; |
| break; |
| case MIDIERR_NOTREADY: |
| msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again."; |
| break; |
| case MIDIERR_NODEVICE: |
| msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup."; |
| break; |
| case MIDIERR_INVALIDSETUP: |
| msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again."; |
| break; |
| /* |
| msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together. |
| msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again. |
| msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver. |
| msg# 339 : The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup. |
| msg# 340 : An error occurred using the specified port. |
| msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again. |
| msg# 342 : There is no current MIDI port. |
| msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver. |
| */ |
| default: |
| msgptr = "Unknown MIDI Error !\n"; |
| break; |
| } |
| lstrcpyn32A(lpText, msgptr, uSize); |
| return TRUE; |
| } |
| |
| /************************************************************************** |
| * midiOutOpen [MMSYSTEM.204] |
| */ |
| UINT16 WINAPI midiOutOpen(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID, |
| DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) |
| { |
| HMIDI16 hMidiOut; |
| LPMIDIOPENDESC lpDesc; |
| LPMIDIOPENDESC lp16Desc; |
| DWORD dwRet = 0; |
| BOOL32 bMapperFlg = FALSE; |
| if (lphMidiOut != NULL) *lphMidiOut = 0; |
| dprintf_mmsys(stddeb, "midiOutOpen(%p, %d, %08lX, %08lX, %08lX);\n", |
| lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags); |
| if (uDeviceID == (UINT16)MIDI_MAPPER) { |
| dprintf_mmsys(stddeb, "midiOutOpen // MIDI_MAPPER mode requested !\n"); |
| bMapperFlg = TRUE; |
| uDeviceID = 0; |
| } |
| hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC)); |
| if (lphMidiOut != NULL) *lphMidiOut = hMidiOut; |
| lp16Desc = (LPMIDIOPENDESC) USER_HEAP_SEG_ADDR(hMidiOut); |
| lpDesc = (LPMIDIOPENDESC) PTR_SEG_TO_LIN(lp16Desc); |
| if (lpDesc == NULL) return MMSYSERR_NOMEM; |
| lpDesc->hMidi = hMidiOut; |
| lpDesc->dwCallback = dwCallback; |
| lpDesc->dwInstance = dwInstance; |
| while(uDeviceID < MAXMIDIDRIVERS) { |
| dwRet = modMessage(uDeviceID, MODM_OPEN, |
| lpDesc->dwInstance, (DWORD)lp16Desc, 0L); |
| if (dwRet == MMSYSERR_NOERROR) break; |
| if (!bMapperFlg) break; |
| uDeviceID++; |
| dprintf_mmsys(stddeb, "midiOutOpen // MIDI_MAPPER mode ! try next driver...\n"); |
| } |
| return dwRet; |
| } |
| |
| /************************************************************************** |
| * midiOutClose [MMSYSTEM.205] |
| */ |
| UINT16 WINAPI midiOutClose(HMIDIOUT16 hMidiOut) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiOutClose(%04X)\n", hMidiOut); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return modMessage(0, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| /************************************************************************** |
| * midiOutPrepareHeader [MMSYSTEM.206] |
| */ |
| UINT16 WINAPI midiOutPrepareHeader(HMIDIOUT16 hMidiOut, |
| MIDIHDR * lpMidiOutHdr, UINT16 uSize) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiOutPrepareHeader(%04X, %p, %d)\n", |
| hMidiOut, lpMidiOutHdr, uSize); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return modMessage(0, MODM_PREPARE, lpDesc->dwInstance, |
| (DWORD)lpMidiOutHdr, (DWORD)uSize); |
| } |
| |
| /************************************************************************** |
| * midiOutUnprepareHeader [MMSYSTEM.207] |
| */ |
| UINT16 WINAPI midiOutUnprepareHeader(HMIDIOUT16 hMidiOut, |
| MIDIHDR * lpMidiOutHdr, UINT16 uSize) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiOutUnprepareHeader(%04X, %p, %d)\n", |
| hMidiOut, lpMidiOutHdr, uSize); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return modMessage(0, MODM_UNPREPARE, lpDesc->dwInstance, |
| (DWORD)lpMidiOutHdr, (DWORD)uSize); |
| } |
| |
| /************************************************************************** |
| * midiOutShortMsg [MMSYSTEM.208] |
| */ |
| UINT16 WINAPI midiOutShortMsg(HMIDIOUT16 hMidiOut, DWORD dwMsg) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiOutShortMsg(%04X, %08lX)\n", hMidiOut, dwMsg); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return modMessage(0, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L); |
| } |
| |
| /************************************************************************** |
| * midiOutLongMsg [MMSYSTEM.209] |
| */ |
| UINT16 WINAPI midiOutLongMsg(HMIDIOUT16 hMidiOut, |
| MIDIHDR * lpMidiOutHdr, UINT16 uSize) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiOutLongMsg(%04X, %p, %d)\n", |
| hMidiOut, lpMidiOutHdr, uSize); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return modMessage(0, MODM_LONGDATA, lpDesc->dwInstance, |
| (DWORD)lpMidiOutHdr, (DWORD)uSize); |
| } |
| |
| /************************************************************************** |
| * midiOutReset [MMSYSTEM.210] |
| */ |
| UINT16 WINAPI midiOutReset(HMIDIOUT16 hMidiOut) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiOutReset(%04X)\n", hMidiOut); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return modMessage(0, MODM_RESET, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| /************************************************************************** |
| * midiOutGetVolume [MMSYSTEM.211] |
| */ |
| UINT16 WINAPI midiOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume) |
| { |
| dprintf_mmsys(stddeb, "midiOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume); |
| return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiOutSetVolume [MMSYSTEM.212] |
| */ |
| UINT16 WINAPI midiOutSetVolume(UINT16 uDeviceID, DWORD dwVolume) |
| { |
| dprintf_mmsys(stddeb, "midiOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume); |
| return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiOutCachePatches [MMSYSTEM.213] |
| */ |
| UINT16 WINAPI midiOutCachePatches(HMIDIOUT16 hMidiOut, UINT16 uBank, |
| WORD * lpwPatchArray, UINT16 uFlags) |
| { |
| /* not really necessary to support this */ |
| fprintf(stdnimp, "midiOutCachePatches: not supported yet\n"); |
| return MMSYSERR_NOTSUPPORTED; |
| } |
| |
| /************************************************************************** |
| * midiOutCacheDrumPatches [MMSYSTEM.214] |
| */ |
| UINT16 WINAPI midiOutCacheDrumPatches(HMIDIOUT16 hMidiOut, UINT16 uPatch, |
| WORD * lpwKeyArray, UINT16 uFlags) |
| { |
| fprintf(stdnimp, "midiOutCacheDrumPatchesi: not supported yet\n"); |
| return MMSYSERR_NOTSUPPORTED; |
| } |
| |
| /************************************************************************** |
| * midiOutGetID [MMSYSTEM.215] |
| */ |
| UINT16 WINAPI midiOutGetID(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID) |
| { |
| dprintf_mmsys(stddeb, "midiOutGetID\n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiOutMessage [MMSYSTEM.216] |
| */ |
| DWORD WINAPI midiOutMessage(HMIDIOUT16 hMidiOut, UINT16 uMessage, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiOutMessage(%04X, %04X, %08lX, %08lX)\n", |
| hMidiOut, uMessage, dwParam1, dwParam2); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return modMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiInGetNumDevs [MMSYSTEM.301] |
| */ |
| UINT16 WINAPI midiInGetNumDevs(void) |
| { |
| UINT16 count = 0; |
| dprintf_mmsys(stddeb, "midiInGetNumDevs\n"); |
| count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L); |
| dprintf_mmsys(stddeb, "midiInGetNumDevs return %u \n", count); |
| return count; |
| } |
| |
| /************************************************************************** |
| * midiInGetDevCaps [MMSYSTEM.302] |
| */ |
| UINT16 WINAPI midiInGetDevCaps(UINT16 uDeviceID, |
| LPMIDIINCAPS lpCaps, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "midiInGetDevCaps\n"); |
| return midMessage(uDeviceID,MIDM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);; |
| } |
| |
| /************************************************************************** |
| * midiInGetErrorText [MMSYSTEM.303] |
| */ |
| UINT16 WINAPI midiInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "midiInGetErrorText\n"); |
| return (midiGetErrorText(uError, lpText, uSize)); |
| } |
| |
| /************************************************************************** |
| * midiInOpen [MMSYSTEM.304] |
| */ |
| UINT16 WINAPI midiInOpen(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID, |
| DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) |
| { |
| HMIDI16 hMidiIn; |
| LPMIDIOPENDESC lpDesc; |
| LPMIDIOPENDESC lp16Desc; |
| DWORD dwRet = 0; |
| BOOL32 bMapperFlg = FALSE; |
| if (lphMidiIn != NULL) *lphMidiIn = 0; |
| dprintf_mmsys(stddeb, "midiInOpen(%p, %d, %08lX, %08lX, %08lX);\n", |
| lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags); |
| if (uDeviceID == (UINT16)MIDI_MAPPER) { |
| dprintf_mmsys(stddeb, "midiInOpen // MIDI_MAPPER mode requested !\n"); |
| bMapperFlg = TRUE; |
| uDeviceID = 0; |
| } |
| hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC)); |
| if (lphMidiIn != NULL) *lphMidiIn = hMidiIn; |
| lp16Desc = (LPMIDIOPENDESC) USER_HEAP_SEG_ADDR(hMidiIn); |
| lpDesc = (LPMIDIOPENDESC) PTR_SEG_TO_LIN(lp16Desc); |
| if (lpDesc == NULL) return MMSYSERR_NOMEM; |
| lpDesc->hMidi = hMidiIn; |
| lpDesc->dwCallback = dwCallback; |
| lpDesc->dwInstance = dwInstance; |
| while(uDeviceID < MAXMIDIDRIVERS) { |
| dwRet = midMessage(uDeviceID, MIDM_OPEN, |
| lpDesc->dwInstance, (DWORD)lpDesc, 0L); |
| if (dwRet == MMSYSERR_NOERROR) break; |
| if (!bMapperFlg) break; |
| uDeviceID++; |
| dprintf_mmsys(stddeb, "midiInOpen // MIDI_MAPPER mode ! try next driver...\n"); |
| } |
| return dwRet; |
| } |
| |
| /************************************************************************** |
| * midiInClose [MMSYSTEM.305] |
| */ |
| UINT16 WINAPI midiInClose(HMIDIIN16 hMidiIn) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiInClose(%04X)\n", hMidiIn); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return midMessage(0, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| /************************************************************************** |
| * midiInPrepareHeader [MMSYSTEM.306] |
| */ |
| UINT16 WINAPI midiInPrepareHeader(HMIDIIN16 hMidiIn, |
| MIDIHDR * lpMidiInHdr, UINT16 uSize) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiInPrepareHeader(%04X, %p, %d)\n", |
| hMidiIn, lpMidiInHdr, uSize); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return midMessage(0, MIDM_PREPARE, lpDesc->dwInstance, |
| (DWORD)lpMidiInHdr, (DWORD)uSize); |
| } |
| |
| /************************************************************************** |
| * midiInUnprepareHeader [MMSYSTEM.307] |
| */ |
| UINT16 WINAPI midiInUnprepareHeader(HMIDIIN16 hMidiIn, |
| MIDIHDR * lpMidiInHdr, UINT16 uSize) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiInUnprepareHeader(%04X, %p, %d)\n", |
| hMidiIn, lpMidiInHdr, uSize); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return midMessage(0, MIDM_UNPREPARE, lpDesc->dwInstance, |
| (DWORD)lpMidiInHdr, (DWORD)uSize); |
| } |
| |
| /************************************************************************** |
| * midiInAddBuffer [MMSYSTEM.308] |
| */ |
| UINT16 WINAPI midiInAddBuffer(HMIDIIN16 hMidiIn, |
| MIDIHDR * lpMidiInHdr, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "midiInAddBuffer\n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiInStart [MMSYSTEM.309] |
| */ |
| UINT16 WINAPI midiInStart(HMIDIIN16 hMidiIn) |
| { |
| dprintf_mmsys(stddeb, "midiInStart\n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiInStop [MMSYSTEM.310] |
| */ |
| UINT16 WINAPI midiInStop(HMIDIIN16 hMidiIn) |
| { |
| dprintf_mmsys(stddeb, "midiInStop\n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiInReset [MMSYSTEM.311] |
| */ |
| UINT16 WINAPI midiInReset(HMIDIIN16 hMidiIn) |
| { |
| dprintf_mmsys(stddeb, "midiInReset\n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiInGetID [MMSYSTEM.312] |
| */ |
| UINT16 WINAPI midiInGetID(HMIDIIN16 hMidiIn, UINT16 * lpuDeviceID) |
| { |
| dprintf_mmsys(stddeb, "midiInGetID\n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiInMessage [MMSYSTEM.313] |
| */ |
| DWORD WINAPI midiInMessage(HMIDIIN16 hMidiIn, UINT16 uMessage, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| LPMIDIOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "midiInMessage(%04X, %04X, %08lX, %08lX)\n", |
| hMidiIn, uMessage, dwParam1, dwParam2); |
| lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); |
| } |
| |
| |
| /************************************************************************** |
| * waveOutGetNumDevs [MMSYSTEM.401] |
| */ |
| UINT16 WINAPI waveOutGetNumDevs() |
| { |
| UINT16 count = 0; |
| dprintf_mmsys(stddeb, "waveOutGetNumDevs\n"); |
| count += wodMessage( MMSYSTEM_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L); |
| dprintf_mmsys(stddeb, "waveOutGetNumDevs return %u \n", count); |
| return count; |
| } |
| |
| /************************************************************************** |
| * waveOutGetDevCaps [MMSYSTEM.402] |
| */ |
| UINT16 WINAPI waveOutGetDevCaps(UINT16 uDeviceID, WAVEOUTCAPS * lpCaps, |
| UINT16 uSize) |
| { |
| if (uDeviceID > waveOutGetNumDevs() - 1) return MMSYSERR_BADDEVICEID; |
| if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */ |
| dprintf_mmsys(stddeb, "waveOutGetDevCaps\n"); |
| return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize); |
| } |
| |
| /************************************************************************** |
| * waveOutGetErrorText [MMSYSTEM.403] |
| */ |
| UINT16 WINAPI waveOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "waveOutGetErrorText\n"); |
| return(waveGetErrorText(uError, lpText, uSize)); |
| } |
| |
| |
| /************************************************************************** |
| * waveGetErrorText [internal] |
| */ |
| UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) |
| { |
| LPSTR msgptr; |
| dprintf_mmsys(stddeb, "waveGetErrorText(%04X, %p, %d);\n", uError, lpText, uSize); |
| if ((lpText == NULL) || (uSize < 1)) return(FALSE); |
| lpText[0] = '\0'; |
| switch(uError) { |
| case MMSYSERR_NOERROR: |
| msgptr = "The specified command was carried out."; |
| break; |
| case MMSYSERR_ERROR: |
| msgptr = "Undefined external error."; |
| break; |
| case MMSYSERR_BADDEVICEID: |
| msgptr = "A device ID has been used that is out of range for your system."; |
| break; |
| case MMSYSERR_NOTENABLED: |
| msgptr = "The driver was not enabled."; |
| break; |
| case MMSYSERR_ALLOCATED: |
| msgptr = "The specified device is already in use. Wait until it is free, and then try again."; |
| break; |
| case MMSYSERR_INVALHANDLE: |
| msgptr = "The specified device handle is invalid."; |
| break; |
| case MMSYSERR_NODRIVER: |
| msgptr = "There is no driver installed on your system !\n"; |
| break; |
| case MMSYSERR_NOMEM: |
| msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again."; |
| break; |
| case MMSYSERR_NOTSUPPORTED: |
| msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports."; |
| break; |
| case MMSYSERR_BADERRNUM: |
| msgptr = "An error number was specified that is not defined in the system."; |
| break; |
| case MMSYSERR_INVALFLAG: |
| msgptr = "An invalid flag was passed to a system function."; |
| break; |
| case MMSYSERR_INVALPARAM: |
| msgptr = "An invalid parameter was passed to a system function."; |
| break; |
| case WAVERR_BADFORMAT: |
| msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats"; |
| break; |
| case WAVERR_STILLPLAYING: |
| msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing."; |
| break; |
| case WAVERR_UNPREPARED: |
| msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again."; |
| break; |
| case WAVERR_SYNC: |
| msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again."; |
| break; |
| default: |
| msgptr = "Unknown MMSYSTEM Error !\n"; |
| break; |
| } |
| lstrcpyn32A(lpText, msgptr, uSize); |
| return TRUE; |
| } |
| |
| /************************************************************************** |
| * waveOutOpen [MMSYSTEM.404] |
| */ |
| UINT16 WINAPI waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID, |
| const LPWAVEFORMAT lpFormat, DWORD dwCallback, |
| DWORD dwInstance, DWORD dwFlags) |
| { |
| HWAVEOUT16 hWaveOut; |
| LPWAVEOPENDESC lpDesc; |
| LPWAVEOPENDESC lp16Desc; |
| DWORD dwRet = 0; |
| BOOL32 bMapperFlg = FALSE; |
| |
| dprintf_mmsys(stddeb, "waveOutOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n", |
| lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags); |
| if (dwFlags & WAVE_FORMAT_QUERY) { |
| dprintf_mmsys(stddeb, "waveOutOpen // WAVE_FORMAT_QUERY requested !\n"); |
| } |
| if (uDeviceID == (UINT16)WAVE_MAPPER) { |
| dprintf_mmsys(stddeb, "waveOutOpen // WAVE_MAPPER mode requested !\n"); |
| bMapperFlg = TRUE; |
| uDeviceID = 0; |
| } |
| if (lpFormat == NULL) return WAVERR_BADFORMAT; |
| |
| hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC)); |
| if (lphWaveOut != NULL) *lphWaveOut = hWaveOut; |
| lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveOut); |
| lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc); |
| if (lpDesc == NULL) return MMSYSERR_NOMEM; |
| lpDesc->hWave = hWaveOut; |
| lpDesc->lpFormat = lpFormat; /* should the struct be copied iso pointer? */ |
| lpDesc->dwCallBack = dwCallback; |
| lpDesc->dwInstance = dwInstance; |
| if (uDeviceID >= MAXWAVEDRIVERS) uDeviceID = 0; |
| while(uDeviceID < MAXWAVEDRIVERS) { |
| dwRet = wodMessage(uDeviceID, WODM_OPEN, |
| lpDesc->dwInstance, (DWORD)lp16Desc, dwFlags); |
| if (dwRet == MMSYSERR_NOERROR) break; |
| if (!bMapperFlg) break; |
| uDeviceID++; |
| dprintf_mmsys(stddeb, "waveOutOpen // WAVE_MAPPER mode ! try next driver...\n"); |
| } |
| lpDesc->uDeviceID = uDeviceID; /* save physical Device ID */ |
| if (dwFlags & WAVE_FORMAT_QUERY) { |
| dprintf_mmsys(stddeb, "waveOutOpen // End of WAVE_FORMAT_QUERY !\n"); |
| dwRet = waveOutClose(hWaveOut); |
| } |
| return dwRet; |
| } |
| |
| /************************************************************************** |
| * waveOutClose [MMSYSTEM.405] |
| */ |
| UINT16 WINAPI waveOutClose(HWAVEOUT16 hWaveOut) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveOutClose(%04X)\n", hWaveOut); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutPrepareHeader [MMSYSTEM.406] |
| */ |
| UINT16 WINAPI waveOutPrepareHeader(HWAVEOUT16 hWaveOut, |
| WAVEHDR * lpWaveOutHdr, UINT16 uSize) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveOutPrepareHeader(%04X, %p, %u);\n", |
| hWaveOut, lpWaveOutHdr, uSize); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance, |
| (DWORD)lpWaveOutHdr, uSize); |
| } |
| |
| /************************************************************************** |
| * waveOutUnprepareHeader [MMSYSTEM.407] |
| */ |
| UINT16 WINAPI waveOutUnprepareHeader(HWAVEOUT16 hWaveOut, |
| WAVEHDR * lpWaveOutHdr, UINT16 uSize) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveOutUnprepareHeader(%04X, %p, %u);\n", |
| hWaveOut, lpWaveOutHdr, uSize); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance, |
| (DWORD)lpWaveOutHdr, uSize); |
| } |
| |
| /************************************************************************** |
| * waveOutWrite [MMSYSTEM.408] |
| */ |
| UINT16 WINAPI waveOutWrite(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr, |
| UINT16 uSize) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveOutWrite(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, |
| (DWORD)lpWaveOutHdr, uSize); |
| } |
| |
| /************************************************************************** |
| * waveOutPause [MMSYSTEM.409] |
| */ |
| UINT16 WINAPI waveOutPause(HWAVEOUT16 hWaveOut) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveOutPause(%04X)\n", hWaveOut); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutRestart [MMSYSTEM.410] |
| */ |
| UINT16 WINAPI waveOutRestart(HWAVEOUT16 hWaveOut) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveOutRestart(%04X)\n", hWaveOut); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutReset [MMSYSTEM.411] |
| */ |
| UINT16 WINAPI waveOutReset(HWAVEOUT16 hWaveOut) |
| { |
| LPWAVEOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "waveOutReset(%04X)\n", hWaveOut); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutGetPosition [MMSYSTEM.412] |
| */ |
| UINT16 WINAPI waveOutGetPosition(HWAVEOUT16 hWaveOut, MMTIME * lpTime, |
| UINT16 uSize) |
| { |
| LPWAVEOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "waveOutGetPosition(%04X, %p, %u);\n", hWaveOut, lpTime, uSize); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance, |
| (DWORD)lpTime, (DWORD)uSize); |
| } |
| |
| /************************************************************************** |
| * waveOutGetPitch [MMSYSTEM.413] |
| */ |
| UINT16 WINAPI waveOutGetPitch(HWAVEOUT16 hWaveOut, DWORD * lpdwPitch) |
| { |
| LPWAVEOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "waveOutGetPitch(%04X, %p);\n", hWaveOut, lpdwPitch); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_GETPITCH, lpDesc->dwInstance, |
| (DWORD)lpdwPitch, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutSetPitch [MMSYSTEM.414] |
| */ |
| UINT16 WINAPI waveOutSetPitch(HWAVEOUT16 hWaveOut, DWORD dwPitch) |
| { |
| LPWAVEOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "waveOutSetPitch(%04X, %08lX);\n", hWaveOut, dwPitch); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_SETPITCH, lpDesc->dwInstance, (DWORD)dwPitch, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutGetVolume [MMSYSTEM.415] |
| */ |
| UINT16 WINAPI waveOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume) |
| { |
| dprintf_mmsys(stddeb, "waveOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume); |
| return wodMessage(uDeviceID, WODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutSetVolume [MMSYSTEM.416] |
| */ |
| UINT16 WINAPI waveOutSetVolume(UINT16 uDeviceID, DWORD dwVolume) |
| { |
| dprintf_mmsys(stddeb, "waveOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume); |
| return wodMessage(uDeviceID, WODM_SETVOLUME, 0L, dwVolume, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutGetPlaybackRate [MMSYSTEM.417] |
| */ |
| UINT16 WINAPI waveOutGetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD * lpdwRate) |
| { |
| LPWAVEOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "waveOutGetPlaybackRate(%04X, %p);\n", hWaveOut, lpdwRate); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_GETPLAYBACKRATE, lpDesc->dwInstance, |
| (DWORD)lpdwRate, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutSetPlaybackRate [MMSYSTEM.418] |
| */ |
| UINT16 WINAPI waveOutSetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD dwRate) |
| { |
| LPWAVEOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "waveOutSetPlaybackRate(%04X, %08lX);\n", hWaveOut, dwRate); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, WODM_SETPLAYBACKRATE, |
| lpDesc->dwInstance, (DWORD)dwRate, 0L); |
| } |
| |
| /************************************************************************** |
| * waveOutBreakLoop [MMSYSTEM.419] |
| */ |
| UINT16 WINAPI waveOutBreakLoop(HWAVEOUT16 hWaveOut) |
| { |
| dprintf_mmsys(stddeb, "waveOutBreakLoop(%04X)\n", hWaveOut); |
| return MMSYSERR_INVALHANDLE; |
| } |
| |
| /************************************************************************** |
| * waveOutGetID [MMSYSTEM.420] |
| */ |
| UINT16 WINAPI waveOutGetID(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID) |
| { |
| LPWAVEOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "waveOutGetID(%04X, %p);\n", hWaveOut, lpuDeviceID); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; |
| *lpuDeviceID = lpDesc->uDeviceID; |
| return 0; |
| } |
| |
| /************************************************************************** |
| * waveOutMessage [MMSYSTEM.421] |
| */ |
| DWORD WINAPI waveOutMessage(HWAVEOUT16 hWaveOut, UINT16 uMessage, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| LPWAVEOPENDESC lpDesc; |
| dprintf_mmsys(stddeb, "waveOutMessage(%04X, %04X, %08lX, %08lX)\n", |
| hWaveOut, uMessage, dwParam1, dwParam2); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); |
| } |
| |
| /************************************************************************** |
| * waveInGetNumDevs [MMSYSTEM.501] |
| */ |
| UINT16 WINAPI waveInGetNumDevs() |
| { |
| UINT16 count = 0; |
| dprintf_mmsys(stddeb, "waveInGetNumDevs\n"); |
| count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L); |
| dprintf_mmsys(stddeb, "waveInGetNumDevs return %u \n", count); |
| return count; |
| } |
| |
| |
| /************************************************************************** |
| * waveInGetDevCaps [MMSYSTEM.502] |
| */ |
| UINT16 WINAPI waveInGetDevCaps(UINT16 uDeviceID, WAVEINCAPS * lpCaps, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "waveInGetDevCaps\n"); |
| return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize); |
| } |
| |
| |
| /************************************************************************** |
| * waveInGetErrorText [MMSYSTEM.503] |
| */ |
| UINT16 WINAPI waveInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) |
| { |
| dprintf_mmsys(stddeb, "waveInGetErrorText\n"); |
| return(waveGetErrorText(uError, lpText, uSize)); |
| } |
| |
| |
| /************************************************************************** |
| * waveInOpen [MMSYSTEM.504] |
| */ |
| UINT16 WINAPI waveInOpen(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID, |
| const LPWAVEFORMAT lpFormat, DWORD dwCallback, |
| DWORD dwInstance, DWORD dwFlags) |
| { |
| HWAVEIN16 hWaveIn; |
| LPWAVEOPENDESC lpDesc; |
| LPWAVEOPENDESC lp16Desc; |
| DWORD dwRet = 0; |
| BOOL32 bMapperFlg = FALSE; |
| dprintf_mmsys(stddeb, "waveInOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n", |
| lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags); |
| if (dwFlags & WAVE_FORMAT_QUERY) { |
| dprintf_mmsys(stddeb, "waveInOpen // WAVE_FORMAT_QUERY requested !\n"); |
| } |
| if (uDeviceID == (UINT16)WAVE_MAPPER) { |
| dprintf_mmsys(stddeb, "waveInOpen // WAVE_MAPPER mode requested !\n"); |
| bMapperFlg = TRUE; |
| uDeviceID = 0; |
| } |
| if (lpFormat == NULL) return WAVERR_BADFORMAT; |
| hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC)); |
| if (lphWaveIn != NULL) *lphWaveIn = hWaveIn; |
| lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveIn); |
| lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc); |
| if (lpDesc == NULL) return MMSYSERR_NOMEM; |
| lpDesc->hWave = hWaveIn; |
| lpDesc->lpFormat = lpFormat; |
| lpDesc->dwCallBack = dwCallback; |
| lpDesc->dwInstance = dwInstance; |
| while(uDeviceID < MAXWAVEDRIVERS) { |
| dwRet = widMessage(uDeviceID, WIDM_OPEN, |
| lpDesc->dwInstance, (DWORD)lp16Desc, 0L); |
| if (dwRet == MMSYSERR_NOERROR) break; |
| if (!bMapperFlg) break; |
| uDeviceID++; |
| dprintf_mmsys(stddeb, "waveInOpen // WAVE_MAPPER mode ! try next driver...\n"); |
| } |
| lpDesc->uDeviceID = uDeviceID; |
| if (dwFlags & WAVE_FORMAT_QUERY) { |
| dprintf_mmsys(stddeb, "waveInOpen // End of WAVE_FORMAT_QUERY !\n"); |
| dwRet = waveInClose(hWaveIn); |
| } |
| return dwRet; |
| } |
| |
| |
| /************************************************************************** |
| * waveInClose [MMSYSTEM.505] |
| */ |
| UINT16 WINAPI waveInClose(HWAVEIN16 hWaveIn) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveInClose(%04X)\n", hWaveIn); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| |
| /************************************************************************** |
| * waveInPrepareHeader [MMSYSTEM.506] |
| */ |
| UINT16 WINAPI waveInPrepareHeader(HWAVEIN16 hWaveIn, |
| WAVEHDR * lpWaveInHdr, UINT16 uSize) |
| { |
| LPWAVEOPENDESC lpDesc; |
| LPWAVEHDR lp32WaveInHdr; |
| |
| dprintf_mmsys(stddeb, "waveInPrepareHeader(%04X, %p, %u);\n", |
| hWaveIn, lpWaveInHdr, uSize); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; |
| lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr); |
| lp32WaveInHdr->lp16Next = (SEGPTR)NULL; |
| lp32WaveInHdr->dwBytesRecorded = 0; |
| dprintf_mmsys(stddeb, "waveInPrepareHeader // lpData=%p size=%lu \n", |
| lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength); |
| return widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance, |
| (DWORD)lpWaveInHdr, uSize); |
| } |
| |
| |
| /************************************************************************** |
| * waveInUnprepareHeader [MMSYSTEM.507] |
| */ |
| UINT16 WINAPI waveInUnprepareHeader(HWAVEIN16 hWaveIn, |
| WAVEHDR * lpWaveInHdr, UINT16 uSize) |
| { |
| LPWAVEOPENDESC lpDesc; |
| LPWAVEHDR lp32WaveInHdr; |
| |
| dprintf_mmsys(stddeb, "waveInUnprepareHeader(%04X, %p, %u);\n", |
| hWaveIn, lpWaveInHdr, uSize); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; |
| lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr); |
| USER_HEAP_FREE(HIWORD((DWORD)lp32WaveInHdr->lpData)); |
| lp32WaveInHdr->lpData = NULL; |
| lp32WaveInHdr->lp16Next = (SEGPTR)NULL; |
| return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance, |
| (DWORD)lpWaveInHdr, uSize); |
| } |
| |
| |
| /************************************************************************** |
| * waveInAddBuffer [MMSYSTEM.508] |
| */ |
| UINT16 WINAPI waveInAddBuffer(HWAVEIN16 hWaveIn, |
| WAVEHDR * lpWaveInHdr, UINT16 uSize) |
| { |
| LPWAVEOPENDESC lpDesc; |
| LPWAVEHDR lp32WaveInHdr; |
| |
| dprintf_mmsys(stddeb, "waveInAddBuffer(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; |
| lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr); |
| lp32WaveInHdr->lp16Next = (SEGPTR)NULL; |
| lp32WaveInHdr->dwBytesRecorded = 0; |
| dprintf_mmsys(stddeb, "waveInAddBuffer // lpData=%p size=%lu \n", |
| lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength); |
| return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance, |
| (DWORD)lpWaveInHdr, uSize); |
| } |
| |
| |
| /************************************************************************** |
| * waveInStart [MMSYSTEM.509] |
| */ |
| UINT16 WINAPI waveInStart(HWAVEIN16 hWaveIn) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveInStart(%04X)\n", hWaveIn); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return widMessage(lpDesc->uDeviceID, WIDM_START, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| |
| /************************************************************************** |
| * waveInStop [MMSYSTEM.510] |
| */ |
| UINT16 WINAPI waveInStop(HWAVEIN16 hWaveIn) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveInStop(%04X)\n", hWaveIn); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| |
| /************************************************************************** |
| * waveInReset [MMSYSTEM.511] |
| */ |
| UINT16 WINAPI waveInReset(HWAVEIN16 hWaveIn) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveInReset(%04X)\n", hWaveIn); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return widMessage(lpDesc->uDeviceID, WIDM_RESET, lpDesc->dwInstance, 0L, 0L); |
| } |
| |
| |
| /************************************************************************** |
| * waveInGetPosition [MMSYSTEM.512] |
| */ |
| UINT16 WINAPI waveInGetPosition(HWAVEIN16 hWaveIn, MMTIME * lpTime, |
| UINT16 uSize) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveInGetPosition(%04X, %p, %u);\n", hWaveIn, lpTime, uSize); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance, |
| (DWORD)lpTime, (DWORD)uSize); |
| } |
| |
| |
| /************************************************************************** |
| * waveInGetID [MMSYSTEM.513] |
| */ |
| UINT16 WINAPI waveInGetID(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveInGetID\n"); |
| if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| *lpuDeviceID = lpDesc->uDeviceID; |
| return 0; |
| } |
| |
| |
| /************************************************************************** |
| * waveInMessage [MMSYSTEM.514] |
| */ |
| DWORD WINAPI waveInMessage(HWAVEIN16 hWaveIn, UINT16 uMessage, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| LPWAVEOPENDESC lpDesc; |
| |
| dprintf_mmsys(stddeb, "waveInMessage(%04X, %04X, %08lX, %08lX)\n", |
| hWaveIn, uMessage, dwParam1, dwParam2); |
| lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); |
| if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; |
| return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); |
| } |
| |
| |
| /************************************************************************** |
| * mmioOpen [MMSYSTEM.1210] |
| */ |
| HMMIO16 WINAPI mmioOpen(LPSTR szFileName, MMIOINFO * lpmmioinfo, |
| DWORD dwOpenFlags) |
| { |
| HFILE32 hFile; |
| HMMIO16 hmmio; |
| OFSTRUCT ofs; |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioOpen('%s', %p, %08lX);\n", szFileName, lpmmioinfo, dwOpenFlags); |
| if (!szFileName) |
| { |
| /* FIXME: should load memory file if szFileName == NULL */ |
| fprintf(stderr, "WARNING: mmioOpen(): szFileName == NULL (memory file ???)\n"); |
| return 0; |
| } |
| hFile = OpenFile32(szFileName, &ofs, dwOpenFlags); |
| if (hFile == -1) return 0; |
| hmmio = GlobalAlloc16(GMEM_MOVEABLE, sizeof(MMIOINFO)); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) return 0; |
| memset(lpmminfo, 0, sizeof(MMIOINFO)); |
| lpmminfo->hmmio = hmmio; |
| lpmminfo->dwReserved2 = hFile; |
| GlobalUnlock16(hmmio); |
| dprintf_mmio(stddeb, "mmioOpen // return hmmio=%04X\n", hmmio); |
| return hmmio; |
| } |
| |
| |
| /************************************************************************** |
| * mmioClose [MMSYSTEM.1211] |
| */ |
| UINT16 WINAPI mmioClose(HMMIO16 hmmio, UINT16 uFlags) |
| { |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioClose(%04X, %04X);\n", hmmio, uFlags); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) return 0; |
| _lclose32((HFILE32)lpmminfo->dwReserved2); |
| GlobalUnlock16(hmmio); |
| GlobalFree16(hmmio); |
| return 0; |
| } |
| |
| |
| |
| /************************************************************************** |
| * mmioRead [MMSYSTEM.1212] |
| */ |
| LONG WINAPI mmioRead(HMMIO16 hmmio, HPSTR pch, LONG cch) |
| { |
| LONG count; |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioRead(%04X, %p, %ld);\n", hmmio, pch, cch); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) return 0; |
| count = _lread32(LOWORD(lpmminfo->dwReserved2), pch, cch); |
| GlobalUnlock16(hmmio); |
| dprintf_mmio(stddeb, "mmioRead // count=%ld\n", count); |
| return count; |
| } |
| |
| |
| |
| /************************************************************************** |
| * mmioWrite [MMSYSTEM.1213] |
| */ |
| LONG WINAPI mmioWrite(HMMIO16 hmmio, HPCSTR pch, LONG cch) |
| { |
| LONG count; |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioWrite(%04X, %p, %ld);\n", hmmio, pch, cch); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) return 0; |
| count = _lwrite32(LOWORD(lpmminfo->dwReserved2), (LPSTR)pch, cch); |
| GlobalUnlock16(hmmio); |
| return count; |
| } |
| |
| /************************************************************************** |
| * mmioSeek [MMSYSTEM.1214] |
| */ |
| LONG WINAPI mmioSeek(HMMIO16 hmmio, LONG lOffset, int iOrigin) |
| { |
| int count; |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioSeek(%04X, %08lX, %d);\n", hmmio, lOffset, iOrigin); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) { |
| dprintf_mmio(stddeb, "mmioSeek // can't lock hmmio=%04X !\n", hmmio); |
| return 0; |
| } |
| count = _llseek32((HFILE32)lpmminfo->dwReserved2, lOffset, iOrigin); |
| GlobalUnlock16(hmmio); |
| return count; |
| } |
| |
| /************************************************************************** |
| * mmioGetInfo [MMSYSTEM.1215] |
| */ |
| UINT16 WINAPI mmioGetInfo(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags) |
| { |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioGetInfo\n"); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) return 0; |
| memcpy(lpmmioinfo, lpmminfo, sizeof(MMIOINFO)); |
| GlobalUnlock16(hmmio); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioSetInfo [MMSYSTEM.1216] |
| */ |
| UINT16 WINAPI mmioSetInfo(HMMIO16 hmmio, const MMIOINFO * lpmmioinfo, UINT16 uFlags) |
| { |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioSetInfo\n"); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) return 0; |
| GlobalUnlock16(hmmio); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioSetBuffer [MMSYSTEM.1217] |
| */ |
| UINT16 WINAPI mmioSetBuffer(HMMIO16 hmmio, LPSTR pchBuffer, |
| LONG cchBuffer, UINT16 uFlags) |
| { |
| dprintf_mmio(stddeb, "mmioSetBuffer // empty stub \n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioFlush [MMSYSTEM.1218] |
| */ |
| UINT16 WINAPI mmioFlush(HMMIO16 hmmio, UINT16 uFlags) |
| { |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioFlush(%04X, %04X)\n", hmmio, uFlags); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) return 0; |
| GlobalUnlock16(hmmio); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioAdvance [MMSYSTEM.1219] |
| */ |
| UINT16 WINAPI mmioAdvance(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags) |
| { |
| int count = 0; |
| LPMMIOINFO lpmminfo; |
| dprintf_mmio(stddeb, "mmioAdvance\n"); |
| lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio); |
| if (lpmminfo == NULL) return 0; |
| if (uFlags == MMIO_READ) { |
| count = _lread32(LOWORD(lpmminfo->dwReserved2), |
| lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer); |
| } |
| if (uFlags == MMIO_WRITE) { |
| count = _lwrite32(LOWORD(lpmminfo->dwReserved2), |
| lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer); |
| } |
| lpmmioinfo->pchNext += count; |
| GlobalUnlock16(hmmio); |
| lpmminfo->lDiskOffset = _llseek32((HFILE32)lpmminfo->dwReserved2, 0, SEEK_CUR); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioStringToFOURCC [MMSYSTEM.1220] |
| */ |
| FOURCC WINAPI mmioStringToFOURCC(LPCSTR sz, UINT16 uFlags) |
| { |
| dprintf_mmio(stddeb, "mmioStringToFOURCC // empty stub \n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioInstallIOProc16 [MMSYSTEM.1221] |
| */ |
| LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc, |
| LPMMIOPROC16 pIOProc, DWORD dwFlags) |
| { |
| dprintf_mmio(stddeb, "mmioInstallIOProc // empty stub \n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioInstallIOProc32A [WINMM.120] |
| */ |
| LPMMIOPROC32 WINAPI mmioInstallIOProc32A(FOURCC fccIOProc, |
| LPMMIOPROC32 pIOProc, DWORD dwFlags) |
| { |
| dprintf_mmio(stddeb, "mmioInstallIOProcA (%c%c%c%c,%p,0x%08lx)// empty stub \n", |
| (char)((fccIOProc&0xff000000)>>24), |
| (char)((fccIOProc&0x00ff0000)>>16), |
| (char)((fccIOProc&0x0000ff00)>> 8), |
| (char)(fccIOProc&0x000000ff), |
| pIOProc, dwFlags ); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioSendMessage [MMSYSTEM.1222] |
| */ |
| LRESULT WINAPI mmioSendMessage(HMMIO16 hmmio, UINT16 uMessage, |
| LPARAM lParam1, LPARAM lParam2) |
| { |
| dprintf_mmio(stddeb, "mmioSendMessage // empty stub \n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioDescend [MMSYSTEM.1223] |
| */ |
| UINT16 WINAPI mmioDescend(HMMIO16 hmmio, MMCKINFO * lpck, |
| const MMCKINFO * lpckParent, UINT16 uFlags) |
| { |
| DWORD dwfcc, dwOldPos; |
| |
| dprintf_mmio(stddeb, "mmioDescend(%04X, %p, %p, %04X);\n", |
| hmmio, lpck, lpckParent, uFlags); |
| |
| if (lpck == NULL) |
| return 0; |
| |
| dwfcc = lpck->ckid; |
| dprintf_mmio(stddeb, "mmioDescend // dwfcc=%08lX\n", dwfcc); |
| |
| dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); |
| dprintf_mmio(stddeb, "mmioDescend // dwOldPos=%ld\n", dwOldPos); |
| |
| if (lpckParent != NULL) { |
| dprintf_mmio(stddeb, "mmioDescend // seek inside parent at %ld !\n", lpckParent->dwDataOffset); |
| dwOldPos = mmioSeek(hmmio, lpckParent->dwDataOffset, SEEK_SET); |
| } |
| /* |
| |
| It seems to be that FINDRIFF should not be treated the same as the |
| other FINDxxx so I treat it as a MMIO_FINDxxx |
| |
| if ((uFlags & MMIO_FINDCHUNK) || (uFlags & MMIO_FINDRIFF) || |
| (uFlags & MMIO_FINDLIST)) { |
| */ |
| if ((uFlags & MMIO_FINDCHUNK) || (uFlags & MMIO_FINDLIST)) { |
| dprintf_mmio(stddeb, "mmioDescend // MMIO_FINDxxxx dwfcc=%08lX !\n", dwfcc); |
| while (TRUE) { |
| LONG ix; |
| |
| ix = mmioRead(hmmio, (LPSTR)lpck, sizeof(MMCKINFO)); |
| dprintf_mmio(stddeb, "mmioDescend // after _lread32 ix = %ld req = %d, errno = %d\n",ix,sizeof(MMCKINFO),errno); |
| if (ix < sizeof(MMCKINFO)) { |
| |
| mmioSeek(hmmio, dwOldPos, SEEK_SET); |
| dprintf_mmio(stddeb, "mmioDescend // return ChunkNotFound\n"); |
| return MMIOERR_CHUNKNOTFOUND; |
| } |
| dprintf_mmio(stddeb, "mmioDescend // dwfcc=%08lX ckid=%08lX cksize=%08lX !\n", |
| dwfcc, lpck->ckid, lpck->cksize); |
| if (dwfcc == lpck->ckid) |
| break; |
| |
| dwOldPos += lpck->cksize + 2 * sizeof(DWORD); |
| if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST) |
| dwOldPos += sizeof(DWORD); |
| mmioSeek(hmmio, dwOldPos, SEEK_SET); |
| } |
| } |
| else { |
| if (mmioRead(hmmio, (LPSTR)lpck, sizeof(MMCKINFO)) < sizeof(MMCKINFO)) { |
| mmioSeek(hmmio, dwOldPos, SEEK_SET); |
| dprintf_mmio(stddeb, "mmioDescend // return ChunkNotFound 2nd\n"); |
| return MMIOERR_CHUNKNOTFOUND; |
| } |
| } |
| lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD); |
| if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST) |
| lpck->dwDataOffset += sizeof(DWORD); |
| mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET); |
| |
| dprintf_mmio(stddeb, "mmioDescend // lpck->ckid=%08lX lpck->cksize=%ld !\n", |
| lpck->ckid, lpck->cksize); |
| dprintf_mmio(stddeb, "mmioDescend // lpck->fccType=%08lX !\n", lpck->fccType); |
| |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioAscend [MMSYSTEM.1224] |
| */ |
| UINT16 WINAPI mmioAscend(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags) |
| { |
| dprintf_mmio(stddeb, "mmioAscend // empty stub !\n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * mmioCreateChunk [MMSYSTEM.1225] |
| */ |
| UINT16 WINAPI mmioCreateChunk(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags) |
| { |
| dprintf_mmio(stddeb, "mmioCreateChunk // empty stub \n"); |
| return 0; |
| } |
| |
| |
| /************************************************************************** |
| * mmioRename [MMSYSTEM.1226] |
| */ |
| UINT16 WINAPI mmioRename(LPCSTR szFileName, LPCSTR szNewFileName, |
| MMIOINFO * lpmmioinfo, DWORD dwRenameFlags) |
| { |
| dprintf_mmio(stddeb, "mmioRename('%s', '%s', %p, %08lX); // empty stub \n", |
| szFileName, szNewFileName, lpmmioinfo, dwRenameFlags); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * DrvOpen [MMSYSTEM.1100] |
| */ |
| HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam) |
| { |
| dprintf_mmsys(stddeb, "DrvOpen('%s', '%s', %08lX);\n", |
| lpDriverName, lpSectionName, lParam); |
| return OpenDriver(lpDriverName, lpSectionName, lParam); |
| } |
| |
| |
| /************************************************************************** |
| * DrvClose [MMSYSTEM.1101] |
| */ |
| LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2) |
| { |
| dprintf_mmsys(stddeb, "DrvClose(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2); |
| return CloseDriver(hDrvr, lParam1, lParam2); |
| } |
| |
| |
| /************************************************************************** |
| * DrvSendMessage [MMSYSTEM.1102] |
| */ |
| LRESULT WINAPI DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1, |
| LPARAM lParam2) |
| { |
| DWORD dwDriverID = 0; |
| dprintf_mmsys(stddeb, "DrvSendMessage(%04X, %04X, %08lX, %08lX);\n", |
| hDriver, msg, lParam1, lParam2); |
| return CDAUDIO_DriverProc(dwDriverID, hDriver, msg, lParam1, lParam2); |
| } |
| |
| /************************************************************************** |
| * DrvGetModuleHandle [MMSYSTEM.1103] |
| */ |
| HANDLE16 WINAPI DrvGetModuleHandle(HDRVR16 hDrvr) |
| { |
| dprintf_mmsys(stddeb, "DrvGetModuleHandle(%04X);\n", hDrvr); |
| return 0; |
| } |
| |
| |
| /************************************************************************** |
| * DrvDefDriverProc [MMSYSTEM.1104] |
| */ |
| LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| return DefDriverProc(dwDriverID, hDriv, wMsg, dwParam1, dwParam2); |
| } |