Moved all MCI internal functions/variables/macros to mci.c.
Changed some interface names.
diff --git a/if1632/mmsystem.spec b/if1632/mmsystem.spec
index db72fe4..346edd1 100644
--- a/if1632/mmsystem.spec
+++ b/if1632/mmsystem.spec
@@ -2,7 +2,7 @@
type win16
#1 pascal MMSYSTEM_WEP(word word word ptr) MMSYSTEM_WEP
-2 pascal SNDPLAYSOUND(ptr word) sndPlaySound
+2 pascal SNDPLAYSOUND(ptr word) sndPlaySoundA
3 stub PLAYSOUND
5 pascal mmsystemGetVersion() mmsystemGetVersion16
6 pascal DriverProc(long word word long long) DriverProc16
diff --git a/include/mmsystem.h b/include/mmsystem.h
index 0d89426..50a29fc 100644
--- a/include/mmsystem.h
+++ b/include/mmsystem.h
@@ -10,21 +10,21 @@
#endif
#include "windef.h"
-typedef LPSTR HPSTR; /* a huge version of LPSTR */
-typedef LPCSTR HPCSTR; /* a huge version of LPCSTR */
-
+typedef LPSTR HPSTR; /* a huge version of LPSTR */
+typedef LPCSTR HPCSTR; /* a huge version of LPCSTR */
+
#pragma pack(1)
-
+
#define MAXWAVEDRIVERS 10
#define MAXMIDIDRIVERS 10
#define MAXAUXDRIVERS 10
#define MAXMCIDRIVERS 32
#define MAXMIXERDRIVERS 10
-
+
#define MAXPNAMELEN 32 /* max product name length (including NULL) */
#define MAXERRORLENGTH 128 /* max error text length (including NULL) */
#define MAX_JOYSTICKOEMVXDNAME 260
-
+
typedef WORD VERSION; /* major (high byte), minor (low byte) */
typedef UINT16 MMVERSION16;
@@ -125,26 +125,26 @@
#define MCI_WAVE_OFFSET 1152
#define MCI_SEQ_OFFSET 1216
-#define MMSYSERR_NOERROR 0 /* no error */
-#define MMSYSERR_ERROR (MMSYSERR_BASE + 1) /* unspecified error */
-#define MMSYSERR_BADDEVICEID (MMSYSERR_BASE + 2) /* device ID out of range */
-#define MMSYSERR_NOTENABLED (MMSYSERR_BASE + 3) /* driver failed enable */
-#define MMSYSERR_ALLOCATED (MMSYSERR_BASE + 4) /* device already allocated */
-#define MMSYSERR_INVALHANDLE (MMSYSERR_BASE + 5) /* device handle is invalid */
-#define MMSYSERR_NODRIVER (MMSYSERR_BASE + 6) /* no device driver present */
-#define MMSYSERR_NOMEM (MMSYSERR_BASE + 7) /* memory allocation error */
-#define MMSYSERR_NOTSUPPORTED (MMSYSERR_BASE + 8) /* function isn't supported */
-#define MMSYSERR_BADERRNUM (MMSYSERR_BASE + 9) /* error value out of range */
-#define MMSYSERR_INVALFLAG (MMSYSERR_BASE + 10) /* invalid flag passed */
-#define MMSYSERR_INVALPARAM (MMSYSERR_BASE + 11) /* invalid parameter passed */
-#define MMSYSERR_LASTERROR (MMSYSERR_BASE + 11) /* last error in range */
+#define MMSYSERR_NOERROR 0 /* no error */
+#define MMSYSERR_ERROR (MMSYSERR_BASE + 1) /* unspecified error */
+#define MMSYSERR_BADDEVICEID (MMSYSERR_BASE + 2) /* device ID out of range */
+#define MMSYSERR_NOTENABLED (MMSYSERR_BASE + 3) /* driver failed enable */
+#define MMSYSERR_ALLOCATED (MMSYSERR_BASE + 4) /* device already allocated */
+#define MMSYSERR_INVALHANDLE (MMSYSERR_BASE + 5) /* device handle is invalid */
+#define MMSYSERR_NODRIVER (MMSYSERR_BASE + 6) /* no device driver present */
+#define MMSYSERR_NOMEM (MMSYSERR_BASE + 7) /* memory allocation error */
+#define MMSYSERR_NOTSUPPORTED (MMSYSERR_BASE + 8) /* function isn't supported */
+#define MMSYSERR_BADERRNUM (MMSYSERR_BASE + 9) /* error value out of range */
+#define MMSYSERR_INVALFLAG (MMSYSERR_BASE + 10) /* invalid flag passed */
+#define MMSYSERR_INVALPARAM (MMSYSERR_BASE + 11) /* invalid parameter passed */
+#define MMSYSERR_LASTERROR (MMSYSERR_BASE + 11) /* last error in range */
-#define CALLBACK_TYPEMASK 0x00070000l /* callback type mask */
-#define CALLBACK_NULL 0x00000000l /* no callback */
-#define CALLBACK_WINDOW 0x00010000l /* dwCallback is a HWND */
-#define CALLBACK_TASK 0x00020000l /* dwCallback is a HTASK */
-#define CALLBACK_FUNCTION 0x00030000l /* dwCallback is a FARPROC */
-#define CALLBACK_FUNC 0x00070000l /* (ugly hack) 32-bit FARPROC */
+#define CALLBACK_TYPEMASK 0x00070000l /* callback type mask */
+#define CALLBACK_NULL 0x00000000l /* no callback */
+#define CALLBACK_WINDOW 0x00010000l /* dwCallback is a HWND */
+#define CALLBACK_TASK 0x00020000l /* dwCallback is a HTASK */
+#define CALLBACK_FUNCTION 0x00030000l /* dwCallback is a FARPROC */
+#define CALLBACK_FUNC 0x00070000l /* (ugly hack) 32-bit FARPROC */
#define CALLBACK32CONV(x) ((((x)&CALLBACK_TYPEMASK)==CALLBACK_FUNCTION) ? \
(((x)&~CALLBACK_TYPEMASK)|CALLBACK_FUNC) : (x))
@@ -170,27 +170,27 @@
#define MM_PC_JOYSTICK 12 /* Joystick adapter */
-UINT16 WINAPI mmsystemGetVersion16(void);
-UINT WINAPI mmsystemGetVersion(void);
-BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags);
-BOOL WINAPI PlaySoundA(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound);
-BOOL WINAPI PlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound);
-#define PlaySound WINELIB_NAME_AW(PlaySound)
+UINT16 WINAPI mmsystemGetVersion16(void);
+UINT WINAPI mmsystemGetVersion(void);
+BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags);
+BOOL WINAPI PlaySoundA(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound);
+BOOL WINAPI PlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound);
+#define PlaySound WINELIB_NAME_AW(PlaySound)
-#define SND_SYNC 0x0000 /* play synchronously (default) */
-#define SND_ASYNC 0x0001 /* play asynchronously */
-#define SND_NODEFAULT 0x0002 /* don't use default sound */
-#define SND_MEMORY 0x0004 /* lpszSoundName points to a memory file */
-#define SND_LOOP 0x0008 /* loop the sound until next sndPlaySound */
-#define SND_NOSTOP 0x0010 /* don't stop any currently playing sound */
+#define SND_SYNC 0x0000 /* play synchronously (default) */
+#define SND_ASYNC 0x0001 /* play asynchronously */
+#define SND_NODEFAULT 0x0002 /* don't use default sound */
+#define SND_MEMORY 0x0004 /* lpszSoundName points to a memory file */
+#define SND_LOOP 0x0008 /* loop the sound until next sndPlaySound */
+#define SND_NOSTOP 0x0010 /* don't stop any currently playing sound */
-#define SND_NOWAIT 0x00002000L /* don't wait if the driver is busy */
-#define SND_ALIAS 0x00010000L /* name is a registry alias */
-#define SND_ALIAS_ID 0x00110000L /* alias is a predefined ID */
-#define SND_FILENAME 0x00020000L /* name is file name */
-#define SND_RESOURCE 0x00040004L /* name is resource name or atom */
-#define SND_PURGE 0x00000040L /* purge all sounds */
-#define SND_APPLICATION 0x00000080L /* look for application specific association */
+#define SND_NOWAIT 0x00002000L /* don't wait if the driver is busy */
+#define SND_ALIAS 0x00010000L /* name is a registry alias */
+#define SND_ALIAS_ID 0x00110000L /* alias is a predefined ID */
+#define SND_FILENAME 0x00020000L /* name is file name */
+#define SND_RESOURCE 0x00040004L /* name is resource name or atom */
+#define SND_PURGE 0x00000040L /* purge all sounds */
+#define SND_APPLICATION 0x00000080L /* look for application specific association */
/* waveform audio error return values */
#define WAVERR_BADFORMAT (WAVERR_BASE + 0) /* unsupported wave format */
@@ -351,86 +351,86 @@
} WAVEFORMATEX, *LPWAVEFORMATEX, *NPWAVEFORMATEX, *PWAVEFORMATEX;
#endif
-UINT16 WINAPI waveOutGetNumDevs16(void);
-UINT WINAPI waveOutGetNumDevs(void);
-UINT16 WINAPI waveOutGetDevCaps16(UINT16,LPWAVEOUTCAPS16,UINT16);
-UINT WINAPI waveOutGetDevCapsA(UINT,LPWAVEOUTCAPSA,UINT);
-UINT WINAPI waveOutGetDevCapsW(UINT,LPWAVEOUTCAPSW,UINT);
-#define waveOutGetDevCaps WINELIB_NAME_AW(waveOutGetDevCaps)
-UINT16 WINAPI waveOutGetVolume16(UINT16,DWORD*);
-UINT WINAPI waveOutGetVolume(UINT,DWORD*);
-UINT16 WINAPI waveOutSetVolume16(UINT16,DWORD);
-UINT WINAPI waveOutSetVolume(UINT,DWORD);
-UINT16 WINAPI waveOutGetErrorText16(UINT16,LPSTR,UINT16);
-UINT WINAPI waveOutGetErrorTextA(UINT,LPSTR,UINT);
-UINT WINAPI waveOutGetErrorTextW(UINT,LPWSTR,UINT);
-#define waveOutGetErrorText WINELIB_NAME_AW(waveOutGetErrorText)
-UINT16 WINAPI waveOutOpen16(HWAVEOUT16*,UINT16,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
-UINT WINAPI waveOutOpen(HWAVEOUT*,UINT,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
-UINT16 WINAPI waveOutClose16(HWAVEOUT16);
-UINT WINAPI waveOutClose(HWAVEOUT);
-UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16,WAVEHDR*,UINT16);
-UINT WINAPI waveOutPrepareHeader(HWAVEOUT,WAVEHDR*,UINT);
-UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16,WAVEHDR*,UINT16);
-UINT WINAPI waveOutUnprepareHeader(HWAVEOUT,WAVEHDR*,UINT);
-UINT16 WINAPI waveOutWrite16(HWAVEOUT16,WAVEHDR*,UINT16);
-UINT WINAPI waveOutWrite(HWAVEOUT,WAVEHDR*,UINT);
-UINT16 WINAPI waveOutPause16(HWAVEOUT16);
-UINT WINAPI waveOutPause(HWAVEOUT);
-UINT16 WINAPI waveOutRestart16(HWAVEOUT16);
-UINT WINAPI waveOutRestart(HWAVEOUT);
-UINT16 WINAPI waveOutReset16(HWAVEOUT16);
-UINT WINAPI waveOutReset(HWAVEOUT);
-UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16);
-UINT WINAPI waveOutBreakLoop(HWAVEOUT);
-UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16,LPMMTIME16,UINT16);
-UINT WINAPI waveOutGetPosition(HWAVEOUT,LPMMTIME,UINT);
-UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16,DWORD*);
-UINT WINAPI waveOutGetPitch(HWAVEOUT,DWORD*);
-UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16,DWORD);
-UINT WINAPI waveOutSetPitch(HWAVEOUT,DWORD);
-UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16,DWORD*);
-UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT,DWORD*);
-UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16,DWORD);
-UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT,DWORD);
-UINT16 WINAPI waveOutGetID16(HWAVEOUT16,UINT16*);
-UINT WINAPI waveOutGetID(HWAVEOUT,UINT*);
-DWORD WINAPI waveOutMessage16(HWAVEOUT16,UINT16,DWORD,DWORD);
-DWORD WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD);
+UINT16 WINAPI waveOutGetNumDevs16(void);
+UINT WINAPI waveOutGetNumDevs(void);
+UINT16 WINAPI waveOutGetDevCaps16(UINT16,LPWAVEOUTCAPS16,UINT16);
+UINT WINAPI waveOutGetDevCapsA(UINT,LPWAVEOUTCAPSA,UINT);
+UINT WINAPI waveOutGetDevCapsW(UINT,LPWAVEOUTCAPSW,UINT);
+#define waveOutGetDevCaps WINELIB_NAME_AW(waveOutGetDevCaps)
+UINT16 WINAPI waveOutGetVolume16(UINT16,DWORD*);
+UINT WINAPI waveOutGetVolume(UINT,DWORD*);
+UINT16 WINAPI waveOutSetVolume16(UINT16,DWORD);
+UINT WINAPI waveOutSetVolume(UINT,DWORD);
+UINT16 WINAPI waveOutGetErrorText16(UINT16,LPSTR,UINT16);
+UINT WINAPI waveOutGetErrorTextA(UINT,LPSTR,UINT);
+UINT WINAPI waveOutGetErrorTextW(UINT,LPWSTR,UINT);
+#define waveOutGetErrorText WINELIB_NAME_AW(waveOutGetErrorText)
+UINT16 WINAPI waveOutOpen16(HWAVEOUT16*,UINT16,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
+UINT WINAPI waveOutOpen(HWAVEOUT*,UINT,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
+UINT16 WINAPI waveOutClose16(HWAVEOUT16);
+UINT WINAPI waveOutClose(HWAVEOUT);
+UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16,WAVEHDR*,UINT16);
+UINT WINAPI waveOutPrepareHeader(HWAVEOUT,WAVEHDR*,UINT);
+UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16,WAVEHDR*,UINT16);
+UINT WINAPI waveOutUnprepareHeader(HWAVEOUT,WAVEHDR*,UINT);
+UINT16 WINAPI waveOutWrite16(HWAVEOUT16,WAVEHDR*,UINT16);
+UINT WINAPI waveOutWrite(HWAVEOUT,WAVEHDR*,UINT);
+UINT16 WINAPI waveOutPause16(HWAVEOUT16);
+UINT WINAPI waveOutPause(HWAVEOUT);
+UINT16 WINAPI waveOutRestart16(HWAVEOUT16);
+UINT WINAPI waveOutRestart(HWAVEOUT);
+UINT16 WINAPI waveOutReset16(HWAVEOUT16);
+UINT WINAPI waveOutReset(HWAVEOUT);
+UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16);
+UINT WINAPI waveOutBreakLoop(HWAVEOUT);
+UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16,LPMMTIME16,UINT16);
+UINT WINAPI waveOutGetPosition(HWAVEOUT,LPMMTIME,UINT);
+UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16,DWORD*);
+UINT WINAPI waveOutGetPitch(HWAVEOUT,DWORD*);
+UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16,DWORD);
+UINT WINAPI waveOutSetPitch(HWAVEOUT,DWORD);
+UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16,DWORD*);
+UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT,DWORD*);
+UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16,DWORD);
+UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT,DWORD);
+UINT16 WINAPI waveOutGetID16(HWAVEOUT16,UINT16*);
+UINT WINAPI waveOutGetID(HWAVEOUT,UINT*);
+DWORD WINAPI waveOutMessage16(HWAVEOUT16,UINT16,DWORD,DWORD);
+DWORD WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD);
-UINT16 WINAPI waveInGetNumDevs16(void);
-UINT WINAPI waveInGetNumDevs(void);
-UINT16 WINAPI waveInGetDevCaps16(UINT16,LPWAVEINCAPS16,UINT16);
-UINT WINAPI waveInGetDevCapsA(UINT,LPWAVEINCAPSA,UINT);
-UINT WINAPI waveInGetDevCapsW(UINT,LPWAVEINCAPSW,UINT);
-#define waveInGetDevCaps WINELIB_NAME_AW(waveInGetDevCaps)
-UINT16 WINAPI waveInGetErrorText16(UINT16,LPSTR,UINT16);
-UINT WINAPI waveInGetErrorTextA(UINT,LPSTR,UINT);
-UINT WINAPI waveInGetErrorTextW(UINT,LPWSTR,UINT);
-#define waveInGetErrorText WINELIB_NAME_AW(waveInGetErrorText)
-UINT16 WINAPI waveInOpen16(HWAVEIN16*,UINT16,const LPWAVEFORMAT,DWORD,DWORD,DWORD);
-UINT WINAPI waveInOpen(HWAVEIN*,UINT,const LPWAVEFORMAT,DWORD,DWORD,DWORD);
-UINT16 WINAPI waveInClose16(HWAVEIN16);
-UINT WINAPI waveInClose(HWAVEIN);
-UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16,WAVEHDR*,UINT16);
-UINT WINAPI waveInPrepareHeader(HWAVEIN,WAVEHDR*,UINT);
-UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16,WAVEHDR*,UINT16);
-UINT WINAPI waveInUnprepareHeader(HWAVEIN,WAVEHDR*,UINT);
-UINT16 WINAPI waveInAddBuffer16(HWAVEIN16,WAVEHDR*,UINT16);
-UINT WINAPI waveInAddBuffer(HWAVEIN,WAVEHDR*,UINT);
-UINT16 WINAPI waveInStart16(HWAVEIN16);
-UINT WINAPI waveInStart(HWAVEIN);
-UINT16 WINAPI waveInStop16(HWAVEIN16);
-UINT WINAPI waveInStop(HWAVEIN);
-UINT16 WINAPI waveInReset16(HWAVEIN16);
-UINT WINAPI waveInReset(HWAVEIN);
-UINT16 WINAPI waveInGetPosition16(HWAVEIN16,LPMMTIME16,UINT16);
-UINT WINAPI waveInGetPosition(HWAVEIN,LPMMTIME,UINT);
-UINT16 WINAPI waveInGetID16(HWAVEIN16,UINT16*);
-UINT WINAPI waveInGetID(HWAVEIN,UINT*);
+UINT16 WINAPI waveInGetNumDevs16(void);
+UINT WINAPI waveInGetNumDevs(void);
+UINT16 WINAPI waveInGetDevCaps16(UINT16,LPWAVEINCAPS16,UINT16);
+UINT WINAPI waveInGetDevCapsA(UINT,LPWAVEINCAPSA,UINT);
+UINT WINAPI waveInGetDevCapsW(UINT,LPWAVEINCAPSW,UINT);
+#define waveInGetDevCaps WINELIB_NAME_AW(waveInGetDevCaps)
+UINT16 WINAPI waveInGetErrorText16(UINT16,LPSTR,UINT16);
+UINT WINAPI waveInGetErrorTextA(UINT,LPSTR,UINT);
+UINT WINAPI waveInGetErrorTextW(UINT,LPWSTR,UINT);
+#define waveInGetErrorText WINELIB_NAME_AW(waveInGetErrorText)
+UINT16 WINAPI waveInOpen16(HWAVEIN16*,UINT16,const LPWAVEFORMAT,DWORD,DWORD,DWORD);
+UINT WINAPI waveInOpen(HWAVEIN*,UINT,const LPWAVEFORMAT,DWORD,DWORD,DWORD);
+UINT16 WINAPI waveInClose16(HWAVEIN16);
+UINT WINAPI waveInClose(HWAVEIN);
+UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16,WAVEHDR*,UINT16);
+UINT WINAPI waveInPrepareHeader(HWAVEIN,WAVEHDR*,UINT);
+UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16,WAVEHDR*,UINT16);
+UINT WINAPI waveInUnprepareHeader(HWAVEIN,WAVEHDR*,UINT);
+UINT16 WINAPI waveInAddBuffer16(HWAVEIN16,WAVEHDR*,UINT16);
+UINT WINAPI waveInAddBuffer(HWAVEIN,WAVEHDR*,UINT);
+UINT16 WINAPI waveInStart16(HWAVEIN16);
+UINT WINAPI waveInStart(HWAVEIN);
+UINT16 WINAPI waveInStop16(HWAVEIN16);
+UINT WINAPI waveInStop(HWAVEIN);
+UINT16 WINAPI waveInReset16(HWAVEIN16);
+UINT WINAPI waveInReset(HWAVEIN);
+UINT16 WINAPI waveInGetPosition16(HWAVEIN16,LPMMTIME16,UINT16);
+UINT WINAPI waveInGetPosition(HWAVEIN,LPMMTIME,UINT);
+UINT16 WINAPI waveInGetID16(HWAVEIN16,UINT16*);
+UINT WINAPI waveInGetID(HWAVEIN,UINT*);
-DWORD WINAPI waveInMessage16(HWAVEIN16,UINT16,DWORD,DWORD);
-DWORD WINAPI waveInMessage(HWAVEIN,UINT,DWORD,DWORD);
+DWORD WINAPI waveInMessage16(HWAVEIN16,UINT16,DWORD,DWORD);
+DWORD WINAPI waveInMessage(HWAVEIN,UINT,DWORD,DWORD);
#define MIDIERR_UNPREPARED (MIDIERR_BASE + 0) /* header not prepared */
#define MIDIERR_STILLPLAYING (MIDIERR_BASE + 1) /* still something playing */
@@ -580,7 +580,7 @@
#define MHDR_PREPARED 0x00000002 /* set if header prepared */
#define MHDR_INQUEUE 0x00000004 /* reserved for driver */
#define MHDR_ISSTRM 0x00000008 /* FIXME is this a correct
- * value ? Win32 only*/
+ * value ? Win32 only */
typedef struct {
DWORD cbStruct;
DWORD dwTempo;
@@ -617,94 +617,94 @@
#define MEVT_TEMPO 0x01
#define MEVT_VERSION 0x84
-UINT16 WINAPI midiOutGetNumDevs16(void);
-UINT WINAPI midiOutGetNumDevs(void);
-UINT16 WINAPI midiOutGetDevCaps16(UINT16,LPMIDIOUTCAPS16,UINT16);
-UINT WINAPI midiOutGetDevCapsA(UINT,LPMIDIOUTCAPSA,UINT);
-UINT WINAPI midiOutGetDevCapsW(UINT,LPMIDIOUTCAPSW,UINT);
-#define midiOutGetDevCaps WINELIB_NAME_AW(midiOutGetDevCaps)
-UINT16 WINAPI midiOutGetVolume16(UINT16,DWORD*);
-UINT WINAPI midiOutGetVolume(UINT,DWORD*);
-UINT16 WINAPI midiOutSetVolume16(UINT16,DWORD);
-UINT WINAPI midiOutSetVolume(UINT,DWORD);
-UINT16 WINAPI midiOutGetErrorText16(UINT16,LPSTR,UINT16);
-UINT WINAPI midiOutGetErrorTextA(UINT,LPSTR,UINT);
-UINT WINAPI midiOutGetErrorTextW(UINT,LPWSTR,UINT);
-#define midiOutGetErrorText WINELIB_NAME_AW(midiOutGetErrorText)
-UINT16 WINAPI midiGetErrorText(UINT16,LPSTR,UINT16);
-UINT16 WINAPI midiOutOpen16(HMIDIOUT16*,UINT16,DWORD,DWORD,DWORD);
-UINT WINAPI midiOutOpen(HMIDIOUT*,UINT,DWORD,DWORD,DWORD);
-UINT16 WINAPI midiOutClose16(HMIDIOUT16);
-UINT WINAPI midiOutClose(HMIDIOUT);
-UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16,MIDIHDR16*,UINT16);
-UINT WINAPI midiOutPrepareHeader(HMIDIOUT,MIDIHDR16*,UINT);
-UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16,MIDIHDR16*,UINT16);
-UINT WINAPI midiOutUnprepareHeader(HMIDIOUT,MIDIHDR16*,UINT);
-UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16,DWORD);
-UINT WINAPI midiOutShortMsg(HMIDIOUT,DWORD);
-UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16,MIDIHDR16*,UINT16);
-UINT WINAPI midiOutLongMsg(HMIDIOUT,MIDIHDR16*,UINT);
-UINT16 WINAPI midiOutReset16(HMIDIOUT16);
-UINT WINAPI midiOutReset(HMIDIOUT);
-UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
-UINT WINAPI midiOutCachePatches(HMIDIOUT,UINT,WORD*,UINT);
-UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
-UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT,UINT,WORD*,UINT);
-UINT16 WINAPI midiOutGetID16(HMIDIOUT16,UINT16*);
-UINT WINAPI midiOutGetID(HMIDIOUT,UINT*);
+UINT16 WINAPI midiOutGetNumDevs16(void);
+UINT WINAPI midiOutGetNumDevs(void);
+UINT16 WINAPI midiOutGetDevCaps16(UINT16,LPMIDIOUTCAPS16,UINT16);
+UINT WINAPI midiOutGetDevCapsA(UINT,LPMIDIOUTCAPSA,UINT);
+UINT WINAPI midiOutGetDevCapsW(UINT,LPMIDIOUTCAPSW,UINT);
+#define midiOutGetDevCaps WINELIB_NAME_AW(midiOutGetDevCaps)
+UINT16 WINAPI midiOutGetVolume16(UINT16,DWORD*);
+UINT WINAPI midiOutGetVolume(UINT,DWORD*);
+UINT16 WINAPI midiOutSetVolume16(UINT16,DWORD);
+UINT WINAPI midiOutSetVolume(UINT,DWORD);
+UINT16 WINAPI midiOutGetErrorText16(UINT16,LPSTR,UINT16);
+UINT WINAPI midiOutGetErrorTextA(UINT,LPSTR,UINT);
+UINT WINAPI midiOutGetErrorTextW(UINT,LPWSTR,UINT);
+#define midiOutGetErrorText WINELIB_NAME_AW(midiOutGetErrorText)
+UINT16 WINAPI midiGetErrorText(UINT16,LPSTR,UINT16);
+UINT16 WINAPI midiOutOpen16(HMIDIOUT16*,UINT16,DWORD,DWORD,DWORD);
+UINT WINAPI midiOutOpen(HMIDIOUT*,UINT,DWORD,DWORD,DWORD);
+UINT16 WINAPI midiOutClose16(HMIDIOUT16);
+UINT WINAPI midiOutClose(HMIDIOUT);
+UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16,MIDIHDR16*,UINT16);
+UINT WINAPI midiOutPrepareHeader(HMIDIOUT,MIDIHDR16*,UINT);
+UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16,MIDIHDR16*,UINT16);
+UINT WINAPI midiOutUnprepareHeader(HMIDIOUT,MIDIHDR16*,UINT);
+UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16,DWORD);
+UINT WINAPI midiOutShortMsg(HMIDIOUT,DWORD);
+UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16,MIDIHDR16*,UINT16);
+UINT WINAPI midiOutLongMsg(HMIDIOUT,MIDIHDR16*,UINT);
+UINT16 WINAPI midiOutReset16(HMIDIOUT16);
+UINT WINAPI midiOutReset(HMIDIOUT);
+UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
+UINT WINAPI midiOutCachePatches(HMIDIOUT,UINT,WORD*,UINT);
+UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
+UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT,UINT,WORD*,UINT);
+UINT16 WINAPI midiOutGetID16(HMIDIOUT16,UINT16*);
+UINT WINAPI midiOutGetID(HMIDIOUT,UINT*);
-DWORD WINAPI midiOutMessage16(HMIDIOUT16,UINT16,DWORD,DWORD);
-DWORD WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD,DWORD);
+DWORD WINAPI midiOutMessage16(HMIDIOUT16,UINT16,DWORD,DWORD);
+DWORD WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD,DWORD);
-UINT16 WINAPI midiInGetNumDevs16(void);
-UINT WINAPI midiInGetNumDevs(void);
-UINT16 WINAPI midiInGetDevCaps16(UINT16,LPMIDIINCAPS16,UINT16);
-UINT WINAPI midiInGetDevCapsA(UINT,LPMIDIINCAPSA,UINT);
-UINT WINAPI midiInGetDevCapsW(UINT,LPMIDIINCAPSW,UINT);
-#define midiInGetDevCaps WINELIB_NAME_AW(midiInGetDevCaps)
-UINT16 WINAPI midiInGetErrorText16(UINT16,LPSTR,UINT16);
-UINT WINAPI midiInGetErrorTextA(UINT,LPSTR,UINT);
-UINT WINAPI midiInGetErrorTextW(UINT,LPWSTR,UINT);
-#define midiInGetErrorText WINELIB_NAME_AW(midiInGetErrorText)
-UINT16 WINAPI midiInOpen16(HMIDIIN16*,UINT16,DWORD,DWORD,DWORD);
-UINT WINAPI midiInOpen(HMIDIIN*,UINT,DWORD,DWORD,DWORD);
-UINT16 WINAPI midiInClose16(HMIDIIN16);
-UINT WINAPI midiInClose(HMIDIIN);
-UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16,MIDIHDR16*,UINT16);
-UINT WINAPI midiInPrepareHeader(HMIDIIN,MIDIHDR16*,UINT);
-UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16,MIDIHDR16*,UINT16);
-UINT WINAPI midiInUnprepareHeader(HMIDIIN,MIDIHDR16*,UINT);
-UINT16 WINAPI midiInAddBuffer16(HMIDIIN16,MIDIHDR16*,UINT16);
-UINT WINAPI midiInAddBuffer(HMIDIIN,MIDIHDR16*,UINT);
-UINT16 WINAPI midiInStart16(HMIDIIN16);
-UINT WINAPI midiInStart(HMIDIIN);
-UINT16 WINAPI midiInStop16(HMIDIIN16);
-UINT WINAPI midiInStop(HMIDIIN);
-UINT16 WINAPI midiInReset16(HMIDIIN16);
-UINT WINAPI midiInReset(HMIDIIN);
-UINT16 WINAPI midiInGetID16(HMIDIIN16,UINT16*);
-UINT WINAPI midiInGetID(HMIDIIN,UINT*);
-DWORD WINAPI midiInMessage16(HMIDIIN16,UINT16,DWORD,DWORD);
-DWORD WINAPI midiInMessage(HMIDIIN,UINT,DWORD,DWORD);
+UINT16 WINAPI midiInGetNumDevs16(void);
+UINT WINAPI midiInGetNumDevs(void);
+UINT16 WINAPI midiInGetDevCaps16(UINT16,LPMIDIINCAPS16,UINT16);
+UINT WINAPI midiInGetDevCapsA(UINT,LPMIDIINCAPSA,UINT);
+UINT WINAPI midiInGetDevCapsW(UINT,LPMIDIINCAPSW,UINT);
+#define midiInGetDevCaps WINELIB_NAME_AW(midiInGetDevCaps)
+UINT16 WINAPI midiInGetErrorText16(UINT16,LPSTR,UINT16);
+UINT WINAPI midiInGetErrorTextA(UINT,LPSTR,UINT);
+UINT WINAPI midiInGetErrorTextW(UINT,LPWSTR,UINT);
+#define midiInGetErrorText WINELIB_NAME_AW(midiInGetErrorText)
+UINT16 WINAPI midiInOpen16(HMIDIIN16*,UINT16,DWORD,DWORD,DWORD);
+UINT WINAPI midiInOpen(HMIDIIN*,UINT,DWORD,DWORD,DWORD);
+UINT16 WINAPI midiInClose16(HMIDIIN16);
+UINT WINAPI midiInClose(HMIDIIN);
+UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16,MIDIHDR16*,UINT16);
+UINT WINAPI midiInPrepareHeader(HMIDIIN,MIDIHDR16*,UINT);
+UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16,MIDIHDR16*,UINT16);
+UINT WINAPI midiInUnprepareHeader(HMIDIIN,MIDIHDR16*,UINT);
+UINT16 WINAPI midiInAddBuffer16(HMIDIIN16,MIDIHDR16*,UINT16);
+UINT WINAPI midiInAddBuffer(HMIDIIN,MIDIHDR16*,UINT);
+UINT16 WINAPI midiInStart16(HMIDIIN16);
+UINT WINAPI midiInStart(HMIDIIN);
+UINT16 WINAPI midiInStop16(HMIDIIN16);
+UINT WINAPI midiInStop(HMIDIIN);
+UINT16 WINAPI midiInReset16(HMIDIIN16);
+UINT WINAPI midiInReset(HMIDIIN);
+UINT16 WINAPI midiInGetID16(HMIDIIN16,UINT16*);
+UINT WINAPI midiInGetID(HMIDIIN,UINT*);
+DWORD WINAPI midiInMessage16(HMIDIIN16,UINT16,DWORD,DWORD);
+DWORD WINAPI midiInMessage(HMIDIIN,UINT,DWORD,DWORD);
-MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms);
-MMRESULT WINAPI midiStreamClose(HMIDISTRM hms);
-MMRESULT WINAPI midiStreamOpen(HMIDISTRM* phms, LPUINT uDeviceID, DWORD cMidi,
- DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);
-MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phms, LPUINT16 devid, DWORD cMidi,
- DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);
-MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hms, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr);
-MMRESULT WINAPI midiStreamOut(HMIDISTRM hms, LPMIDIHDR16 lpMidiHdr, UINT cbMidiHdr);
-MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hms);
-MMRESULT WINAPI midiStreamPause(HMIDISTRM hms);
-MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hms, LPMMTIME16 lpmmt, UINT16 cbmmt);
-MMRESULT WINAPI midiStreamPosition(HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt);
-MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hms, LPBYTE lpPropData, DWORD dwProperty);
-MMRESULT WINAPI midiStreamProperty(HMIDISTRM hms, LPBYTE lpPropData, DWORD dwProperty);
-MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hms);
-MMRESULT WINAPI midiStreamRestart(HMIDISTRM hms);
-MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hms);
-MMRESULT WINAPI midiStreamStop(HMIDISTRM hms);
+MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms);
+MMRESULT WINAPI midiStreamClose(HMIDISTRM hms);
+MMRESULT WINAPI midiStreamOpen(HMIDISTRM* phms, LPUINT uDeviceID, DWORD cMidi,
+ DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);
+MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phms, LPUINT16 devid, DWORD cMidi,
+ DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);
+MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hms, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr);
+MMRESULT WINAPI midiStreamOut(HMIDISTRM hms, LPMIDIHDR16 lpMidiHdr, UINT cbMidiHdr);
+MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hms);
+MMRESULT WINAPI midiStreamPause(HMIDISTRM hms);
+MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hms, LPMMTIME16 lpmmt, UINT16 cbmmt);
+MMRESULT WINAPI midiStreamPosition(HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt);
+MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hms, LPBYTE lpPropData, DWORD dwProperty);
+MMRESULT WINAPI midiStreamProperty(HMIDISTRM hms, LPBYTE lpPropData, DWORD dwProperty);
+MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hms);
+MMRESULT WINAPI midiStreamRestart(HMIDISTRM hms);
+MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hms);
+MMRESULT WINAPI midiStreamStop(HMIDISTRM hms);
#define AUX_MAPPER (-1)
@@ -743,20 +743,20 @@
#define AUXCAPS_VOLUME 0x0001 /* supports volume control */
#define AUXCAPS_LRVOLUME 0x0002 /* separate left-right volume control */
-UINT16 WINAPI auxGetNumDevs16(void);
-UINT WINAPI auxGetNumDevs(void);
-UINT16 WINAPI auxGetDevCaps16 (UINT16,LPAUXCAPS16,UINT16);
-UINT WINAPI auxGetDevCapsA(UINT,LPAUXCAPSA,UINT);
-UINT WINAPI auxGetDevCapsW(UINT,LPAUXCAPSW,UINT);
-#define auxGetDevCaps WINELIB_NAME_AW(auxGetDevCaps)
-UINT16 WINAPI auxSetVolume16(UINT16,DWORD);
-UINT WINAPI auxSetVolume(UINT,DWORD);
+UINT16 WINAPI auxGetNumDevs16(void);
+UINT WINAPI auxGetNumDevs(void);
+UINT16 WINAPI auxGetDevCaps16 (UINT16,LPAUXCAPS16,UINT16);
+UINT WINAPI auxGetDevCapsA(UINT,LPAUXCAPSA,UINT);
+UINT WINAPI auxGetDevCapsW(UINT,LPAUXCAPSW,UINT);
+#define auxGetDevCaps WINELIB_NAME_AW(auxGetDevCaps)
+UINT16 WINAPI auxSetVolume16(UINT16,DWORD);
+UINT WINAPI auxSetVolume(UINT,DWORD);
-UINT16 WINAPI auxGetVolume16(UINT16,LPDWORD);
-UINT WINAPI auxGetVolume(UINT,LPDWORD);
+UINT16 WINAPI auxGetVolume16(UINT16,LPDWORD);
+UINT WINAPI auxGetVolume(UINT,LPDWORD);
-DWORD WINAPI auxOutMessage16(UINT16,UINT16,DWORD,DWORD);
-DWORD WINAPI auxOutMessage(UINT,UINT,DWORD,DWORD);
+DWORD WINAPI auxOutMessage16(UINT16,UINT16,DWORD,DWORD);
+DWORD WINAPI auxOutMessage(UINT,UINT,DWORD,DWORD);
#define TIMERR_NOERROR (0) /* no error */
#define TIMERR_NOCANDO (TIMERR_BASE+1) /* request not completed */
@@ -765,11 +765,11 @@
typedef void (CALLBACK *LPTIMECALLBACK16)(UINT16 uTimerID, UINT16 uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
typedef void (CALLBACK *LPTIMECALLBACK)(UINT uTimerID, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
-#define TIME_ONESHOT 0x0000 /* program timer for single event */
-#define TIME_PERIODIC 0x0001 /* program for continuous periodic event */
-#define TIME_CALLBACK_FUNCTION 0x0000 /* callback is function */
-#define TIME_CALLBACK_EVENT_SET 0x0010 /* callback is event - use SetEvent */
-#define TIME_CALLBACK_EVENT_PULSE 0x0020/* callback is event - use PulseEvent */
+#define TIME_ONESHOT 0x0000 /* program timer for single event */
+#define TIME_PERIODIC 0x0001 /* program for continuous periodic event */
+#define TIME_CALLBACK_FUNCTION 0x0000 /* callback is function */
+#define TIME_CALLBACK_EVENT_SET 0x0010 /* callback is event - use SetEvent */
+#define TIME_CALLBACK_EVENT_PULSE 0x0020 /* callback is event - use PulseEvent */
typedef struct {
UINT16 wPeriodMin; /* minimum period supported */
@@ -782,19 +782,19 @@
} TIMECAPS, *LPTIMECAPS;
-MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16,UINT16);
-MMRESULT WINAPI timeGetSystemTime(LPMMTIME,UINT);
-DWORD WINAPI timeGetTime(void); /* same for win32/win16 */
-MMRESULT16 WINAPI timeSetEvent16(UINT16,UINT16,LPTIMECALLBACK16,DWORD,UINT16);
-MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD,UINT);
-MMRESULT16 WINAPI timeKillEvent16(UINT16);
-MMRESULT WINAPI timeKillEvent(UINT);
-MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16,UINT16);
-MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS,UINT);
-MMRESULT16 WINAPI timeBeginPeriod16(UINT16);
-MMRESULT WINAPI timeBeginPeriod(UINT);
-MMRESULT16 WINAPI timeEndPeriod16(UINT16);
-MMRESULT WINAPI timeEndPeriod(UINT);
+MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16,UINT16);
+MMRESULT WINAPI timeGetSystemTime(LPMMTIME,UINT);
+DWORD WINAPI timeGetTime(void); /* same for win32/win16 */
+MMRESULT16 WINAPI timeSetEvent16(UINT16,UINT16,LPTIMECALLBACK16,DWORD,UINT16);
+MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD,UINT);
+MMRESULT16 WINAPI timeKillEvent16(UINT16);
+MMRESULT WINAPI timeKillEvent(UINT);
+MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16,UINT16);
+MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS,UINT);
+MMRESULT16 WINAPI timeBeginPeriod16(UINT16);
+MMRESULT WINAPI timeBeginPeriod(UINT);
+MMRESULT16 WINAPI timeEndPeriod16(UINT16);
+MMRESULT WINAPI timeEndPeriod(UINT);
#define JOYERR_NOERROR (0) /* no error */
#define JOYERR_PARMS (JOYERR_BASE+5) /* bad parameters */
@@ -802,17 +802,17 @@
#define JOYERR_UNPLUGGED (JOYERR_BASE+7) /* joystick is unplugged */
/* JOYINFO, JOYINFOEX, MM_JOY* */
-#define JOY_BUTTON1 0x0001
-#define JOY_BUTTON2 0x0002
-#define JOY_BUTTON3 0x0004
-#define JOY_BUTTON4 0x0008
-#define JOY_BUTTON1CHG 0x0100
-#define JOY_BUTTON2CHG 0x0200
-#define JOY_BUTTON3CHG 0x0400
-#define JOY_BUTTON4CHG 0x0800
+#define JOY_BUTTON1 0x0001
+#define JOY_BUTTON2 0x0002
+#define JOY_BUTTON3 0x0004
+#define JOY_BUTTON4 0x0008
+#define JOY_BUTTON1CHG 0x0100
+#define JOY_BUTTON2CHG 0x0200
+#define JOY_BUTTON3CHG 0x0400
+#define JOY_BUTTON4CHG 0x0800
-#define JOYSTICKID1 0
-#define JOYSTICKID2 1
+#define JOYSTICKID1 0
+#define JOYSTICKID2 1
/* JOYCAPS.wCaps */
#define JOYCAPS_HASZ 0x0001
@@ -861,17 +861,17 @@
typedef struct {
WORD wMid; /* manufacturer ID */
WORD wPid; /* product ID */
- char szPname[MAXPNAMELEN]; /* product name (NULL terminated string) */
- UINT16 wXmin; /* minimum x position value */
- UINT16 wXmax; /* maximum x position value */
- UINT16 wYmin; /* minimum y position value */
- UINT16 wYmax; /* maximum y position value */
- UINT16 wZmin; /* minimum z position value */
- UINT16 wZmax; /* maximum z position value */
- UINT16 wNumButtons; /* number of buttons */
- UINT16 wPeriodMin; /* minimum message period when captured */
- UINT16 wPeriodMax; /* maximum message period when captured */
- /* win95,nt4 additions: */
+ char szPname[MAXPNAMELEN]; /* product name (NULL terminated string) */
+ UINT16 wXmin; /* minimum x position value */
+ UINT16 wXmax; /* maximum x position value */
+ UINT16 wYmin; /* minimum y position value */
+ UINT16 wYmax; /* maximum y position value */
+ UINT16 wZmin; /* minimum z position value */
+ UINT16 wZmax; /* maximum z position value */
+ UINT16 wNumButtons; /* number of buttons */
+ UINT16 wPeriodMin; /* minimum message period when captured */
+ UINT16 wPeriodMax; /* maximum message period when captured */
+ /* win95,nt4 additions: */
UINT16 wRmin; /* minimum r position value */
UINT16 wRmax; /* maximum r position value */
UINT16 wUmin; /* minimum u (5th axis) position value */
@@ -973,31 +973,31 @@
} JOYINFOEX,*LPJOYINFOEX;
-MMRESULT16 WINAPI joyGetDevCaps16 (UINT16,LPJOYCAPS16 ,UINT16);
-MMRESULT WINAPI joyGetDevCapsA(UINT,LPJOYCAPSA,UINT);
-MMRESULT WINAPI joyGetDevCapsW(UINT,LPJOYCAPSW,UINT);
+MMRESULT16 WINAPI joyGetDevCaps16 (UINT16,LPJOYCAPS16 ,UINT16);
+MMRESULT WINAPI joyGetDevCapsA(UINT,LPJOYCAPSA,UINT);
+MMRESULT WINAPI joyGetDevCapsW(UINT,LPJOYCAPSW,UINT);
#define joyGetDevCaps WINELIB_NAME_AW(joyGetDevCaps)
-UINT16 WINAPI joyGetNumDevs16(void);
-UINT WINAPI joyGetNumDevs(void);
-MMRESULT16 WINAPI joyGetPos16(UINT16,LPJOYINFO16);
-MMRESULT WINAPI joyGetPos(UINT,LPJOYINFO);
-MMRESULT WINAPI joyGetPosEx(UINT,LPJOYINFOEX);
-MMRESULT16 WINAPI joyGetThreshold16(UINT16,UINT16*);
-MMRESULT WINAPI joyGetThreshold(UINT,UINT*);
-MMRESULT16 WINAPI joyReleaseCapture16(UINT16);
-MMRESULT WINAPI joyReleaseCapture(UINT);
-MMRESULT16 WINAPI joySetCapture16(HWND16,UINT16,UINT16,BOOL16);
-MMRESULT WINAPI joySetCapture(HWND,UINT,UINT,BOOL);
-MMRESULT16 WINAPI joySetThreshold16(UINT16,UINT16);
-MMRESULT WINAPI joySetThreshold(UINT,UINT);
+UINT16 WINAPI joyGetNumDevs16(void);
+UINT WINAPI joyGetNumDevs(void);
+MMRESULT16 WINAPI joyGetPos16(UINT16,LPJOYINFO16);
+MMRESULT WINAPI joyGetPos(UINT,LPJOYINFO);
+MMRESULT WINAPI joyGetPosEx(UINT,LPJOYINFOEX);
+MMRESULT16 WINAPI joyGetThreshold16(UINT16,UINT16*);
+MMRESULT WINAPI joyGetThreshold(UINT,UINT*);
+MMRESULT16 WINAPI joyReleaseCapture16(UINT16);
+MMRESULT WINAPI joyReleaseCapture(UINT);
+MMRESULT16 WINAPI joySetCapture16(HWND16,UINT16,UINT16,BOOL16);
+MMRESULT WINAPI joySetCapture(HWND,UINT,UINT,BOOL);
+MMRESULT16 WINAPI joySetThreshold16(UINT16,UINT16);
+MMRESULT WINAPI joySetThreshold(UINT,UINT);
typedef struct {
- WORD wMid; /* manufacturer id */
- WORD wPid; /* product id */
+ WORD wMid; /* manufacturer id */
+ WORD wPid; /* product id */
MMVERSION16 vDriverVersion; /* version of the driver */
CHAR szPname[MAXPNAMELEN]; /* product name */
- DWORD fdwSupport; /* misc. support bits */
- DWORD cDestinations; /* count of destinations */
+ DWORD fdwSupport; /* misc. support bits */
+ DWORD cDestinations; /* count of destinations */
} MIXERCAPS16,*LPMIXERCAPS16;
typedef struct {
@@ -1021,8 +1021,8 @@
DECL_WINELIB_TYPE_AW(MIXERCAPS)
DECL_WINELIB_TYPE_AW(LPMIXERCAPS)
-#define MIXER_SHORT_NAME_CHARS 16
-#define MIXER_LONG_NAME_CHARS 64
+#define MIXER_SHORT_NAME_CHARS 16
+#define MIXER_LONG_NAME_CHARS 64
/* MIXERLINE.fdwLine */
#define MIXERLINE_LINEF_ACTIVE 0x00000001
@@ -1138,9 +1138,9 @@
DECL_WINELIB_TYPE_AW(LPMIXERLINE)
/* MIXERCONTROL.fdwControl */
-#define MIXERCONTROL_CONTROLF_UNIFORM 0x00000001L
-#define MIXERCONTROL_CONTROLF_MULTIPLE 0x00000002L
-#define MIXERCONTROL_CONTROLF_DISABLED 0x80000000L
+#define MIXERCONTROL_CONTROLF_UNIFORM 0x00000001L
+#define MIXERCONTROL_CONTROLF_MULTIPLE 0x00000002L
+#define MIXERCONTROL_CONTROLF_DISABLED 0x80000000L
/* MIXERCONTROL_CONTROLTYPE_xxx building block defines */
#define MIXERCONTROL_CT_CLASS_MASK 0xF0000000L
@@ -1410,34 +1410,34 @@
#define MIXER_SETCONTROLDETAILSF_CUSTOM 0x00000001L
#define MIXER_SETCONTROLDETAILSF_QUERYMASK 0x0000000FL
-UINT16 WINAPI mixerGetNumDevs16(void);
-UINT WINAPI mixerGetNumDevs(void);
-UINT16 WINAPI mixerOpen16(LPHMIXER16,UINT16,DWORD,DWORD,DWORD);
-UINT WINAPI mixerOpen(LPHMIXER,UINT,DWORD,DWORD,DWORD);
-UINT16 WINAPI mixerClose16(HMIXER16);
-UINT WINAPI mixerClose(HMIXER);
-UINT16 WINAPI mixerMessage16(HMIXER16,UINT16,DWORD,DWORD);
-UINT WINAPI mixerMessage(HMIXER,UINT,DWORD,DWORD);
-UINT16 WINAPI mixerGetDevCaps16(UINT16,LPMIXERCAPS16,UINT16);
-UINT WINAPI mixerGetDevCapsA(UINT,LPMIXERCAPSA,UINT);
-UINT WINAPI mixerGetDevCapsW(UINT,LPMIXERCAPSW,UINT);
-#define mixerGetDevCaps WINELIB_NAME_AW(mixerGetDevCaps)
-UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16,LPMIXERLINE16,DWORD);
-UINT WINAPI mixerGetLineInfoA(HMIXEROBJ,LPMIXERLINEA,DWORD);
-UINT WINAPI mixerGetLineInfoW(HMIXEROBJ,LPMIXERLINEW,DWORD);
-#define mixerGetLineInfo WINELIB_NAME_AW(mixerGetLineInfo)
-UINT16 WINAPI mixerGetID16(HMIXEROBJ16,LPUINT16,DWORD);
-UINT WINAPI mixerGetID(HMIXEROBJ,LPUINT,DWORD);
-UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16,LPMIXERLINECONTROLS16,DWORD);
-UINT WINAPI mixerGetLineControlsA(HMIXEROBJ,LPMIXERLINECONTROLSA,DWORD);
-UINT WINAPI mixerGetLineControlsW(HMIXEROBJ,LPMIXERLINECONTROLSW,DWORD);
-#define mixerGetLineControl WINELIB_NAME_AW(mixerGetLineControl)
-UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
-UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
-UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
-#define mixerGetControlDetails WINELIB_NAME_AW(mixerGetControlDetails)
-UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
-UINT WINAPI mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
+UINT16 WINAPI mixerGetNumDevs16(void);
+UINT WINAPI mixerGetNumDevs(void);
+UINT16 WINAPI mixerOpen16(LPHMIXER16,UINT16,DWORD,DWORD,DWORD);
+UINT WINAPI mixerOpen(LPHMIXER,UINT,DWORD,DWORD,DWORD);
+UINT16 WINAPI mixerClose16(HMIXER16);
+UINT WINAPI mixerClose(HMIXER);
+UINT16 WINAPI mixerMessage16(HMIXER16,UINT16,DWORD,DWORD);
+UINT WINAPI mixerMessage(HMIXER,UINT,DWORD,DWORD);
+UINT16 WINAPI mixerGetDevCaps16(UINT16,LPMIXERCAPS16,UINT16);
+UINT WINAPI mixerGetDevCapsA(UINT,LPMIXERCAPSA,UINT);
+UINT WINAPI mixerGetDevCapsW(UINT,LPMIXERCAPSW,UINT);
+#define mixerGetDevCaps WINELIB_NAME_AW(mixerGetDevCaps)
+UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16,LPMIXERLINE16,DWORD);
+UINT WINAPI mixerGetLineInfoA(HMIXEROBJ,LPMIXERLINEA,DWORD);
+UINT WINAPI mixerGetLineInfoW(HMIXEROBJ,LPMIXERLINEW,DWORD);
+#define mixerGetLineInfo WINELIB_NAME_AW(mixerGetLineInfo)
+UINT16 WINAPI mixerGetID16(HMIXEROBJ16,LPUINT16,DWORD);
+UINT WINAPI mixerGetID(HMIXEROBJ,LPUINT,DWORD);
+UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16,LPMIXERLINECONTROLS16,DWORD);
+UINT WINAPI mixerGetLineControlsA(HMIXEROBJ,LPMIXERLINECONTROLSA,DWORD);
+UINT WINAPI mixerGetLineControlsW(HMIXEROBJ,LPMIXERLINECONTROLSW,DWORD);
+#define mixerGetLineControl WINELIB_NAME_AW(mixerGetLineControl)
+UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
+UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
+UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
+#define mixerGetControlDetails WINELIB_NAME_AW(mixerGetControlDetails)
+UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
+UINT WINAPI mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
#define MMIOERR_BASE 256
#define MMIOERR_FILENOTFOUND (MMIOERR_BASE + 1) /* file not found */
@@ -1457,7 +1457,7 @@
typedef LONG (CALLBACK *LPMMIOPROC16)(LPSTR lpmmioinfo, UINT16 uMessage,
LPARAM lParam1, LPARAM lParam2);
typedef LONG (CALLBACK *LPMMIOPROC)(LPSTR lpmmioinfo, UINT uMessage,
- LPARAM lParam1, LPARAM lParam2);
+ LPARAM lParam1, LPARAM lParam2);
typedef struct {
DWORD dwFlags; /* general status flags */
@@ -1575,86 +1575,86 @@
( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \
( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
-LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC,LPMMIOPROC16,DWORD);
-LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC,LPMMIOPROC,DWORD);
-LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC,LPMMIOPROC,DWORD);
-#define mmioInstallIOProc WINELIB_NAME_AW(mmioInstallIOProc)
+LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC,LPMMIOPROC16,DWORD);
+LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC,LPMMIOPROC,DWORD);
+LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC,LPMMIOPROC,DWORD);
+#define mmioInstallIOProc WINELIB_NAME_AW(mmioInstallIOProc)
-FOURCC WINAPI mmioStringToFOURCC16(LPCSTR,UINT16);
-FOURCC WINAPI mmioStringToFOURCCA(LPCSTR,UINT);
-FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR,UINT);
-#define mmioStringToFOURCC WINELIB_NAME_AW(mmioStringToFOURCC)
-HMMIO16 WINAPI mmioOpen16 (LPSTR ,MMIOINFO16*,DWORD);
-HMMIO WINAPI mmioOpenA(LPSTR ,MMIOINFO*,DWORD);
-HMMIO WINAPI mmioOpenW(LPWSTR,MMIOINFO*,DWORD);
-#define mmioOpen WINELIB_NAME_AW(mmioOpen)
+FOURCC WINAPI mmioStringToFOURCC16(LPCSTR,UINT16);
+FOURCC WINAPI mmioStringToFOURCCA(LPCSTR,UINT);
+FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR,UINT);
+#define mmioStringToFOURCC WINELIB_NAME_AW(mmioStringToFOURCC)
+HMMIO16 WINAPI mmioOpen16 (LPSTR ,MMIOINFO16*,DWORD);
+HMMIO WINAPI mmioOpenA(LPSTR ,MMIOINFO*,DWORD);
+HMMIO WINAPI mmioOpenW(LPWSTR,MMIOINFO*,DWORD);
+#define mmioOpen WINELIB_NAME_AW(mmioOpen)
-UINT16 WINAPI mmioRename16(LPCSTR szFileName, LPCSTR szNewFileName,
- MMIOINFO16 * lpmmioinfo, DWORD dwRenameFlags);
-UINT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
- MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
-UINT WINAPI mmioRenameW(LPCWSTR szFileName, LPCWSTR szNewFileName,
- MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
-#define mmioRename WINELIB_NAME_AW(mmioRename)
+UINT16 WINAPI mmioRename16(LPCSTR szFileName, LPCSTR szNewFileName,
+ MMIOINFO16 * lpmmioinfo, DWORD dwRenameFlags);
+UINT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
+ MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
+UINT WINAPI mmioRenameW(LPCWSTR szFileName, LPCWSTR szNewFileName,
+ MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
+#define mmioRename WINELIB_NAME_AW(mmioRename)
-MMRESULT16 WINAPI mmioClose16(HMMIO16,UINT16);
-MMRESULT WINAPI mmioClose(HMMIO,UINT);
-LONG WINAPI mmioRead16(HMMIO16,HPSTR,LONG);
-LONG WINAPI mmioRead(HMMIO,HPSTR,LONG);
-LONG WINAPI mmioWrite16(HMMIO16,HPCSTR,LONG);
-LONG WINAPI mmioWrite(HMMIO,HPCSTR,LONG);
-LONG WINAPI mmioSeek16(HMMIO16,LONG,INT16);
-LONG WINAPI mmioSeek(HMMIO,LONG,INT);
-MMRESULT16 WINAPI mmioGetInfo16(HMMIO16,MMIOINFO16*,UINT16);
-MMRESULT WINAPI mmioGetInfo(HMMIO,MMIOINFO*,UINT);
-MMRESULT16 WINAPI mmioSetInfo16(HMMIO16,const MMIOINFO16*,UINT16);
-MMRESULT WINAPI mmioSetInfo(HMMIO,const MMIOINFO*,UINT);
-UINT16 WINAPI mmioSetBuffer16(HMMIO16,LPSTR,LONG,UINT16);
-UINT WINAPI mmioSetBuffer(HMMIO,LPSTR,LONG,UINT);
-UINT16 WINAPI mmioFlush16(HMMIO16,UINT16);
-UINT WINAPI mmioFlush(HMMIO,UINT);
-UINT16 WINAPI mmioAdvance16(HMMIO16,MMIOINFO16*,UINT16);
-UINT WINAPI mmioAdvance(HMMIO,MMIOINFO*,UINT);
-LONG WINAPI mmioSendMessage(HMMIO16,UINT16,LPARAM,LPARAM);
-UINT16 WINAPI mmioDescend(HMMIO16,MMCKINFO*,const MMCKINFO*,UINT16);
+MMRESULT16 WINAPI mmioClose16(HMMIO16,UINT16);
+MMRESULT WINAPI mmioClose(HMMIO,UINT);
+LONG WINAPI mmioRead16(HMMIO16,HPSTR,LONG);
+LONG WINAPI mmioRead(HMMIO,HPSTR,LONG);
+LONG WINAPI mmioWrite16(HMMIO16,HPCSTR,LONG);
+LONG WINAPI mmioWrite(HMMIO,HPCSTR,LONG);
+LONG WINAPI mmioSeek16(HMMIO16,LONG,INT16);
+LONG WINAPI mmioSeek(HMMIO,LONG,INT);
+MMRESULT16 WINAPI mmioGetInfo16(HMMIO16,MMIOINFO16*,UINT16);
+MMRESULT WINAPI mmioGetInfo(HMMIO,MMIOINFO*,UINT);
+MMRESULT16 WINAPI mmioSetInfo16(HMMIO16,const MMIOINFO16*,UINT16);
+MMRESULT WINAPI mmioSetInfo(HMMIO,const MMIOINFO*,UINT);
+UINT16 WINAPI mmioSetBuffer16(HMMIO16,LPSTR,LONG,UINT16);
+UINT WINAPI mmioSetBuffer(HMMIO,LPSTR,LONG,UINT);
+UINT16 WINAPI mmioFlush16(HMMIO16,UINT16);
+UINT WINAPI mmioFlush(HMMIO,UINT);
+UINT16 WINAPI mmioAdvance16(HMMIO16,MMIOINFO16*,UINT16);
+UINT WINAPI mmioAdvance(HMMIO,MMIOINFO*,UINT);
+LONG WINAPI mmioSendMessage(HMMIO16,UINT16,LPARAM,LPARAM);
+UINT16 WINAPI mmioDescend(HMMIO16,MMCKINFO*,const MMCKINFO*,UINT16);
-UINT16 WINAPI mmioAscend16(HMMIO16,MMCKINFO*,UINT16);
-UINT WINAPI mmioAscend(HMMIO,MMCKINFO*,UINT);
-UINT16 WINAPI mmioCreateChunk16(HMMIO16,MMCKINFO*,UINT16);
-UINT WINAPI mmioCreateChunk(HMMIO,MMCKINFO*,UINT);
+UINT16 WINAPI mmioAscend16(HMMIO16,MMCKINFO*,UINT16);
+UINT WINAPI mmioAscend(HMMIO,MMCKINFO*,UINT);
+UINT16 WINAPI mmioCreateChunk16(HMMIO16,MMCKINFO*,UINT16);
+UINT WINAPI mmioCreateChunk(HMMIO,MMCKINFO*,UINT);
typedef UINT16 (CALLBACK *YIELDPROC)(UINT16,DWORD);
-DWORD WINAPI mciSendCommand16(UINT16,UINT16,DWORD,DWORD);
-DWORD WINAPI mciSendCommandA(UINT,UINT,DWORD,DWORD);
-DWORD WINAPI mciSendCommandW(UINT,UINT,DWORD,DWORD);
-#define mciSendCommand WINELIB_NAME_AW(mciSendCommand)
+DWORD WINAPI mciSendCommand16(UINT16,UINT16,DWORD,DWORD);
+DWORD WINAPI mciSendCommandA(UINT,UINT,DWORD,DWORD);
+DWORD WINAPI mciSendCommandW(UINT,UINT,DWORD,DWORD);
+#define mciSendCommand WINELIB_NAME_AW(mciSendCommand)
-DWORD WINAPI mciSendString16(LPCSTR,LPSTR,UINT16,HWND16);
-DWORD WINAPI mciSendStringA(LPCSTR,LPSTR,UINT,HWND);
-DWORD WINAPI mciSendStringW(LPCWSTR,LPSTR,UINT,HWND);
-#define mciSendString WINELIB_NAME_AW(mciSendString)
+DWORD WINAPI mciSendString16(LPCSTR,LPSTR,UINT16,HWND16);
+DWORD WINAPI mciSendStringA(LPCSTR,LPSTR,UINT,HWND);
+DWORD WINAPI mciSendStringW(LPCWSTR,LPSTR,UINT,HWND);
+#define mciSendString WINELIB_NAME_AW(mciSendString)
-UINT16 WINAPI mciGetDeviceID16(LPCSTR);
-UINT WINAPI mciGetDeviceIDA(LPCSTR);
-UINT WINAPI mciGetDeviceIDW(LPCWSTR);
-#define mciGetDeviceID WINELIB_NAME_AW(mciGetDeviceID)
+UINT16 WINAPI mciGetDeviceID16(LPCSTR);
+UINT WINAPI mciGetDeviceIDA(LPCSTR);
+UINT WINAPI mciGetDeviceIDW(LPCWSTR);
+#define mciGetDeviceID WINELIB_NAME_AW(mciGetDeviceID)
-UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD,LPCSTR);
+UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD,LPCSTR);
-BOOL16 WINAPI mciGetErrorString16 (DWORD,LPSTR,UINT16);
-BOOL WINAPI mciGetErrorStringA(DWORD,LPSTR,UINT);
-BOOL WINAPI mciGetErrorStringW(DWORD,LPWSTR,UINT);
-#define mciGetErrorString WINELIB_NAME_AW(mciGetErrorString)
+BOOL16 WINAPI mciGetErrorString16 (DWORD,LPSTR,UINT16);
+BOOL WINAPI mciGetErrorStringA(DWORD,LPSTR,UINT);
+BOOL WINAPI mciGetErrorStringW(DWORD,LPWSTR,UINT);
+#define mciGetErrorString WINELIB_NAME_AW(mciGetErrorString)
-BOOL16 WINAPI mciSetYieldProc16(UINT16,YIELDPROC,DWORD);
-BOOL WINAPI mciSetYieldProc(UINT,YIELDPROC,DWORD);
+BOOL16 WINAPI mciSetYieldProc16(UINT16,YIELDPROC,DWORD);
+BOOL WINAPI mciSetYieldProc(UINT,YIELDPROC,DWORD);
-HTASK16 WINAPI mciGetCreatorTask16(UINT16);
-HTASK WINAPI mciGetCreatorTask(UINT);
+HTASK16 WINAPI mciGetCreatorTask16(UINT16);
+HTASK WINAPI mciGetCreatorTask(UINT);
-YIELDPROC WINAPI mciGetYieldProc16(UINT16,DWORD*);
-YIELDPROC WINAPI mciGetYieldProc(UINT,DWORD*);
+YIELDPROC WINAPI mciGetYieldProc16(UINT16,DWORD*);
+YIELDPROC WINAPI mciGetYieldProc(UINT,DWORD*);
#define MCIERR_INVALID_DEVICE_ID (MCIERR_BASE + 1)
#define MCIERR_UNRECOGNIZED_KEYWORD (MCIERR_BASE + 3)
@@ -1736,10 +1736,10 @@
#define MCIERR_CUSTOM_DRIVER_BASE (MCIERR_BASE + 256)
-#define MCI_OPEN_DRIVER 0x0801
-#define MCI_CLOSE_DRIVER 0x0802
-#define MCI_OPEN 0x0803
-#define MCI_CLOSE 0x0804
+#define MCI_OPEN_DRIVER 0x0801
+#define MCI_CLOSE_DRIVER 0x0802
+#define MCI_OPEN 0x0803
+#define MCI_CLOSE 0x0804
#define MCI_ESCAPE 0x0805
#define MCI_PLAY 0x0806
#define MCI_SEEK 0x0807
@@ -2639,16 +2639,16 @@
#define MODM_GETNUMDEVS 1
#define MODM_GETDEVCAPS 2
-#define MODM_OPEN 3
-#define MODM_CLOSE 4
+#define MODM_OPEN 3
+#define MODM_CLOSE 4
#define MODM_PREPARE 5
#define MODM_UNPREPARE 6
-#define MODM_DATA 7
+#define MODM_DATA 7
#define MODM_LONGDATA 8
-#define MODM_RESET 9
+#define MODM_RESET 9
#define MODM_GETVOLUME 10
#define MODM_SETVOLUME 11
-#define MODM_CACHEPATCHES 12
+#define MODM_CACHEPATCHES 12
#define MODM_CACHEDRUMPATCHES 13
#define MIDM_GETNUMDEVS 53
@@ -2803,52 +2803,52 @@
UINT wType; /* driver type (filled in by the driver) */
} MCI_OPEN_DRIVER_PARMSW, *LPMCI_OPEN_DRIVER_PARMSW;
-DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID);
-DWORD WINAPI mciGetDriverData(UINT uDeviceID);
+DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID);
+DWORD WINAPI mciGetDriverData(UINT uDeviceID);
-BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD dwData);
-BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData);
+BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD dwData);
+BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData);
-UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID);
-UINT WINAPI mciDriverYield(UINT uDeviceID);
+UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID);
+UINT WINAPI mciDriverYield(UINT uDeviceID);
-BOOL16 WINAPI mciDriverNotify16(HWND16 hwndCallback, UINT16 uDeviceID,
- UINT16 uStatus);
-BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID,
- UINT uStatus);
+BOOL16 WINAPI mciDriverNotify16(HWND16 hwndCallback, UINT16 uDeviceID,
+ UINT16 uStatus);
+BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID,
+ UINT uStatus);
-UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInstance,
- LPCSTR lpResName, UINT16 uType);
-UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance,
- LPCWSTR lpResName, UINT uType);
+UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInstance,
+ LPCSTR lpResName, UINT16 uType);
+UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance,
+ LPCWSTR lpResName, UINT uType);
-BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable);
-BOOL WINAPI mciFreeCommandResource(UINT uTable);
+BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable);
+BOOL WINAPI mciFreeCommandResource(UINT uTable);
#define DCB_NULL 0x0000
#define DCB_WINDOW 0x0001 /* dwCallback is a HWND */
#define DCB_TASK 0x0002 /* dwCallback is a HTASK */
-#define DCB_FUNCTION 0x0003 /* dwCallback is a FARPROC */
-#define DCB_FUNC32 0x0007 /* (ugly hack) 32-bit FARPROC */
-#define DCB_TYPEMASK 0x0007
-#define DCB_NOSWITCH 0x0008 /* don't switch stacks for callback */
+#define DCB_FUNCTION 0x0003 /* dwCallback is a FARPROC */
+#define DCB_FUNC32 0x0007 /* (ugly hack) 32-bit FARPROC */
+#define DCB_TYPEMASK 0x0007
+#define DCB_NOSWITCH 0x0008 /* don't switch stacks for callback */
-BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
- WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
-DWORD WINAPI auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
- DWORD dwParam1, DWORD dwParam2);
+BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
+ WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
+DWORD WINAPI auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
+ DWORD dwParam1, DWORD dwParam2);
#pragma pack(4)
-DWORD WINAPI mixMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
- DWORD dwParam1, DWORD dwParam2);
-DWORD WINAPI midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
- DWORD dwParam1, DWORD dwParam2);
-DWORD WINAPI modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
- DWORD dwParam1, DWORD dwParam2);
-DWORD WINAPI widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
- DWORD dwParam1, DWORD dwParam2);
-DWORD WINAPI wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
- DWORD dwParam1, DWORD dwParam2);
+DWORD WINAPI mixMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
+ DWORD dwParam1, DWORD dwParam2);
+DWORD WINAPI midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
+ DWORD dwParam1, DWORD dwParam2);
+DWORD WINAPI modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
+ DWORD dwParam1, DWORD dwParam2);
+DWORD WINAPI widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
+ DWORD dwParam1, DWORD dwParam2);
+DWORD WINAPI wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
+ DWORD dwParam1, DWORD dwParam2);
#pragma pack(4)
#ifdef __cplusplus
diff --git a/include/multimedia.h b/include/multimedia.h
index 3a2d3b5..cf969e6 100644
--- a/include/multimedia.h
+++ b/include/multimedia.h
@@ -49,38 +49,59 @@
DWORD dwPrivate;
};
+extern struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS];
+
+#define MCI_GetDrv(wDevID) (&mciDrv[MCI_DevIDToIndex(wDevID)])
+#define MCI_GetOpenDrv(wDevID) (&(MCI_GetDrv(wDevID)->mop))
+
/* function prototypes */
extern BOOL MULTIMEDIA_Init(void);
-extern int MCI_DevIDToIndex(UINT16 wDevID);
-extern UINT16 MCI_FirstDevID(void);
-extern UINT16 MCI_NextDevID(UINT16 wDevID);
-extern BOOL MCI_DevIDValid(UINT16 wDevID);
+extern int MCI_DevIDToIndex(UINT16 wDevID);
+extern UINT16 MCI_FirstDevID(void);
+extern UINT16 MCI_NextDevID(UINT16 wDevID);
+extern BOOL MCI_DevIDValid(UINT16 wDevID);
-extern int MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam);
-extern int MCI_UnMapMsg16To32A(WORD uDevTyp, WORD wMsg, DWORD lParam);
+extern int MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam);
+extern int MCI_UnMapMsg16To32A(WORD uDevTyp, WORD wMsg, DWORD lParam);
-typedef LONG (*MCIPROC16)(DWORD, HDRVR16, WORD, DWORD, DWORD);
-typedef LONG (*MCIPROC)(DWORD, HDRVR16, DWORD, DWORD, DWORD);
+extern DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms);
+extern DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms);
+extern DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms);
-extern MCIPROC MCI_GetProc(UINT16 uDevType);
-extern WORD MCI_GetDevType(LPCSTR str);
-extern DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr);
-extern const char* MCI_CommandToString(UINT16 wMsg);
+typedef LONG (*MCIPROC16)(DWORD, HDRVR16, WORD, DWORD, DWORD);
+typedef LONG (*MCIPROC)(DWORD, HDRVR16, DWORD, DWORD, DWORD);
+extern WORD MCI_GetDevType(LPCSTR str);
+extern DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr);
+extern const char* MCI_CommandToString(UINT16 wMsg);
-extern DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2);
-extern DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2, UINT size);
+extern int mciInstalledCount;
+extern int mciInstalledListLen;
+extern LPSTR lpmciInstallNames;
-LONG MCIWAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
- DWORD dwParam1, DWORD dwParam2);
-LONG MCIMIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
- DWORD dwParam1, DWORD dwParam2);
-LONG MCICDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
- DWORD dwParam1, DWORD dwParam2);
-LONG MCIANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
- DWORD dwParam1, DWORD dwParam2);
-LONG MCIAVI_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
- DWORD dwParam1, DWORD dwParam2);
+typedef struct {
+ WORD uDevType;
+ char* lpstrName;
+ MCIPROC lpfnProc;
+} MCI_WineDesc;
+
+extern MCI_WineDesc MCI_InternalDescriptors[];
+
+extern LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2, BOOL bIs32);
+
+extern DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2);
+extern DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2, UINT size);
+
+LONG MCIWAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
+ DWORD dwParam1, DWORD dwParam2);
+LONG MCIMIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
+ DWORD dwParam1, DWORD dwParam2);
+LONG MCICDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
+ DWORD dwParam1, DWORD dwParam2);
+LONG MCIANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
+ DWORD dwParam1, DWORD dwParam2);
+LONG MCIAVI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
+ DWORD dwParam1, DWORD dwParam2);
#endif /* __WINE_MULTIMEDIA_H */
diff --git a/multimedia/Makefile.in b/multimedia/Makefile.in
index d0f6527..7b5792c 100644
--- a/multimedia/Makefile.in
+++ b/multimedia/Makefile.in
@@ -11,6 +11,7 @@
dsound.c \
init.c \
joystick.c \
+ mci.c \
mcianim.c \
mciavi.c \
mcicda.c \
diff --git a/multimedia/mci.c b/multimedia/mci.c
new file mode 100644
index 0000000..b78de0bd
--- /dev/null
+++ b/multimedia/mci.c
@@ -0,0 +1,1331 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
+/*
+ * MCI internal functions
+ *
+ * Copyright 1998/1999 Eric Pouech
+ */
+
+#include <string.h>
+
+#include "winbase.h"
+#include "winuser.h"
+#include "heap.h"
+#include "driver.h"
+#include "mmsystem.h"
+#include "multimedia.h"
+#include "selectors.h"
+#include "debug.h"
+#include "digitalv.h"
+
+struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS];
+
+int mciInstalledCount;
+int mciInstalledListLen;
+LPSTR lpmciInstallNames = NULL;
+
+/* 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
+ * MCI_DevIDToIndex to get an index in that range. An
+ * arbitrary value, MCI_MAGIC is added to the wDevID seen
+ * by the windows programs.
+ */
+
+#define MCI_MAGIC 0x0F00
+
+MCI_WineDesc MCI_InternalDescriptors[] = {
+ {MCI_DEVTYPE_CD_AUDIO, "CDAUDIO", MCICDAUDIO_DriverProc},
+ {MCI_DEVTYPE_WAVEFORM_AUDIO, "WAVEAUDIO", MCIWAVE_DriverProc},
+ {MCI_DEVTYPE_SEQUENCER, "SEQUENCER", MCIMIDI_DriverProc},
+ {MCI_DEVTYPE_ANIMATION, "ANIMATION1", MCIANIM_DriverProc},
+ {MCI_DEVTYPE_DIGITAL_VIDEO, "AVIVIDEO", MCIAVI_DriverProc},
+ {0xFFFF, NULL, NULL} /* sentinel */
+};
+
+/**************************************************************************
+ * MCI_GetDevTypeString [internal]
+ */
+static LPCSTR MCI_GetDevTypeString(WORD uDevType)
+{
+ LPCSTR str = "??? MCI ???";
+ int i;
+
+ for (i = 0; MCI_InternalDescriptors[i].uDevType != 0xFFFF; i++) {
+ if (MCI_InternalDescriptors[i].uDevType != 0 && MCI_InternalDescriptors[i].uDevType == uDevType) {
+ str = MCI_InternalDescriptors[i].lpstrName;
+ break;
+ }
+ }
+ /* TRACE(mci, "devType=%u => %s\n", uDevType, str);*/
+ return str;
+}
+
+/**************************************************************************
+ * MCI_GetProc [internal]
+ */
+static MCIPROC MCI_GetProc(UINT16 uDevType)
+{
+ MCIPROC proc = 0;
+ int i;
+
+ for (i = 0; MCI_InternalDescriptors[i].uDevType != 0xFFFF; i++) {
+ if (MCI_InternalDescriptors[i].uDevType != 0 &&
+ MCI_InternalDescriptors[i].uDevType == uDevType) {
+ proc = MCI_InternalDescriptors[i].lpfnProc;
+ break;
+ }
+ }
+ return proc;
+}
+
+/**************************************************************************
+ * MCI_GetDevType [internal]
+ */
+WORD MCI_GetDevType(LPCSTR str)
+{
+ WORD uDevType = 0;
+ int i;
+
+ for (i = 0; MCI_InternalDescriptors[i].uDevType != 0xFFFF; i++) {
+ if (MCI_InternalDescriptors[i].uDevType != 0 &&
+ strcmp(str, MCI_InternalDescriptors[i].lpstrName) == 0) {
+ uDevType = MCI_InternalDescriptors[i].uDevType;
+ break;
+ }
+ }
+ return uDevType;
+}
+
+/**************************************************************************
+ * MCI_DevIDToIndex [internal]
+ */
+int MCI_DevIDToIndex(UINT16 wDevID)
+{
+ return wDevID - MCI_MAGIC;
+}
+
+/**************************************************************************
+ * MCI_FirstDevId [internal]
+ */
+UINT16 MCI_FirstDevID(void)
+{
+ return MCI_MAGIC;
+}
+
+/**************************************************************************
+ * MCI_NextDevId [internal]
+ */
+UINT16 MCI_NextDevID(UINT16 wDevID)
+{
+ return wDevID + 1;
+}
+
+/**************************************************************************
+ * MCI_DevIDValid [internal]
+ */
+BOOL MCI_DevIDValid(UINT16 wDevID)
+{
+ return wDevID >= MCI_MAGIC && wDevID < (MCI_MAGIC + MAXMCIDRIVERS);
+}
+
+/**************************************************************************
+ * MCI_CommandToString [internal]
+ */
+const char* MCI_CommandToString(UINT16 wMsg)
+{
+ static char buffer[100];
+
+#define CASE(s) case (s): return #s
+
+ switch (wMsg) {
+ CASE(MCI_BREAK);
+ CASE(MCI_CLOSE);
+ CASE(MCI_CLOSE_DRIVER);
+ CASE(MCI_COPY);
+ CASE(MCI_CUE);
+ CASE(MCI_CUT);
+ CASE(MCI_DELETE);
+ CASE(MCI_ESCAPE);
+ CASE(MCI_FREEZE);
+ CASE(MCI_PAUSE);
+ CASE(MCI_PLAY);
+ CASE(MCI_GETDEVCAPS);
+ CASE(MCI_INFO);
+ CASE(MCI_LOAD);
+ CASE(MCI_OPEN);
+ CASE(MCI_OPEN_DRIVER);
+ CASE(MCI_PASTE);
+ CASE(MCI_PUT);
+ CASE(MCI_REALIZE);
+ CASE(MCI_RECORD);
+ CASE(MCI_RESUME);
+ CASE(MCI_SAVE);
+ CASE(MCI_SEEK);
+ CASE(MCI_SET);
+ CASE(MCI_SPIN);
+ CASE(MCI_STATUS);
+ CASE(MCI_STEP);
+ CASE(MCI_STOP);
+ CASE(MCI_SYSINFO);
+ CASE(MCI_UNFREEZE);
+ CASE(MCI_UPDATE);
+ CASE(MCI_WHERE);
+ CASE(MCI_WINDOW);
+ default:
+ sprintf(buffer, "MCI_<<%04X>>", wMsg);
+ return buffer;
+ }
+#undef CASE
+}
+
+/**************************************************************************
+ * MCI_MapMsg16To32A [internal]
+ */
+int MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
+{
+ if (*lParam == 0)
+ return 0;
+ /* FIXME: to add also (with seg/linear modifications to do):
+ * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
+ * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
+ */
+ switch (wMsg) {
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ /* case MCI_CONFIGURE:*/
+ case MCI_COPY:
+ case MCI_CUE:
+ case MCI_CUT:
+ case MCI_DELETE:
+ case MCI_FREEZE:
+ case MCI_GETDEVCAPS:
+ /* case MCI_INDEX: */
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_PASTE:
+ case MCI_PAUSE:
+ case MCI_PLAY:
+ case MCI_PUT:
+ case MCI_REALIZE:
+ case MCI_RECORD:
+ case MCI_RESUME:
+ case MCI_SEEK:
+ case MCI_SET:
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ case MCI_SPIN:
+ case MCI_STATUS: /* FIXME: is wrong for digital video */
+ case MCI_STEP:
+ case MCI_STOP:
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ case MCI_UPDATE:
+ case MCI_WHERE:
+ *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
+ return 0;
+ case MCI_WINDOW:
+ /* in fact, I would also need the dwFlags... to see
+ * which members of lParam are effectively used
+ */
+ *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
+ FIXME(mci, "Current mapping may be wrong\n");
+ break;
+ case MCI_BREAK:
+ {
+ LPMCI_BREAK_PARMS mbp32 = HeapAlloc(SystemHeap, 0, sizeof(MCI_BREAK_PARMS));
+ LPMCI_BREAK_PARMS16 mbp16 = PTR_SEG_TO_LIN(*lParam);
+
+ if (mbp32) {
+ mbp32->dwCallback = mbp16->dwCallback;
+ mbp32->nVirtKey = mbp16->nVirtKey;
+ mbp32->hwndBreak = mbp16->hwndBreak;
+ } else {
+ return -2;
+ }
+ *lParam = (DWORD)mbp32;
+ }
+ return 1;
+ case MCI_ESCAPE:
+ {
+ LPMCI_VD_ESCAPE_PARMSA mvep32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_VD_ESCAPE_PARMSA));
+ LPMCI_VD_ESCAPE_PARMS16 mvep16 = PTR_SEG_TO_LIN(*lParam);
+
+ if (mvep32a) {
+ mvep32a->dwCallback = mvep16->dwCallback;
+ mvep32a->lpstrCommand = PTR_SEG_TO_LIN(mvep16->lpstrCommand);
+ } else {
+ return -2;
+ }
+ *lParam = (DWORD)mvep32a;
+ }
+ return 1;
+ case MCI_INFO:
+ {
+ LPMCI_INFO_PARMSA mip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_INFO_PARMSA));
+ LPMCI_INFO_PARMS16 mip16 = PTR_SEG_TO_LIN(*lParam);
+
+ /* FIXME this is wrong if device is of type
+ * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
+ */
+ if (mip32a) {
+ mip32a->dwCallback = mip16->dwCallback;
+ mip32a->lpstrReturn = PTR_SEG_TO_LIN(mip16->lpstrReturn);
+ mip32a->dwRetSize = mip16->dwRetSize;
+ } else {
+ return -2;
+ }
+ *lParam = (DWORD)mip32a;
+ }
+ return 1;
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ {
+ LPMCI_OPEN_PARMSA mop32a = HeapAlloc(SystemHeap, 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD));
+ LPMCI_OPEN_PARMS16 mop16 = PTR_SEG_TO_LIN(*lParam);
+
+ if (mop32a) {
+ *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
+ mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
+ mop32a->dwCallback = mop16->dwCallback;
+ mop32a->wDeviceID = mop16->wDeviceID;
+ mop32a->lpstrDeviceType = PTR_SEG_TO_LIN(mop16->lpstrDeviceType);
+ mop32a->lpstrElementName = PTR_SEG_TO_LIN(mop16->lpstrElementName);
+ mop32a->lpstrAlias = PTR_SEG_TO_LIN(mop16->lpstrAlias);
+ /* copy extended information if any...
+ * FIXME: this may seg fault if initial structure does not contain them and
+ * the reads after msip16 fail under LDT limits...
+ * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
+ * should not take care of extended parameters, and should be used by MCI_Open
+ * to fetch uDevType. When, this is known, the mapping for sending the
+ * MCI_OPEN_DRIVER shall be done depending on uDevType.
+ */
+ memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD));
+ } else {
+ return -2;
+ }
+ *lParam = (DWORD)mop32a;
+ }
+ return 1;
+ case MCI_SYSINFO:
+ {
+ LPMCI_SYSINFO_PARMSA msip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_SYSINFO_PARMSA));
+ LPMCI_SYSINFO_PARMS16 msip16 = PTR_SEG_TO_LIN(*lParam);
+
+ if (msip32a) {
+ msip32a->dwCallback = msip16->dwCallback;
+ msip32a->lpstrReturn = PTR_SEG_TO_LIN(msip16->lpstrReturn);
+ msip32a->dwRetSize = msip16->dwRetSize;
+ msip32a->dwNumber = msip16->dwNumber;
+ msip32a->wDeviceType = msip16->wDeviceType;
+ } else {
+ return -2;
+ }
+ *lParam = (DWORD)msip32a;
+ }
+ return 1;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_OPEN:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME(mci, "This is a hack\n");
+ return 0;
+
+ default:
+ WARN(mci, "Don't know how to map msg=%s\n", MCI_CommandToString(wMsg));
+ }
+ return -1;
+}
+
+/**************************************************************************
+ * MCI_UnMapMsg16To32A [internal]
+ */
+int MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
+{
+ switch (wMsg) {
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ /* case MCI_CONFIGURE:*/
+ case MCI_COPY:
+ case MCI_CUE:
+ case MCI_CUT:
+ case MCI_DELETE:
+ case MCI_FREEZE:
+ case MCI_GETDEVCAPS:
+ /* case MCI_INDEX: */
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_PASTE:
+ case MCI_PAUSE:
+ case MCI_PLAY:
+ case MCI_PUT:
+ case MCI_REALIZE:
+ case MCI_RECORD:
+ case MCI_RESUME:
+ case MCI_SEEK:
+ case MCI_SET:
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ case MCI_SPIN:
+ case MCI_STATUS:
+ case MCI_STEP:
+ case MCI_STOP:
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ case MCI_UPDATE:
+ case MCI_WHERE:
+ return 0;
+
+ case MCI_WINDOW:
+ /* FIXME ?? see Map function */
+ return 0;
+
+ case MCI_BREAK:
+ case MCI_ESCAPE:
+ case MCI_INFO:
+ case MCI_SYSINFO:
+ HeapFree(SystemHeap, 0, (LPVOID)lParam);
+ return 0;
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ if (lParam) {
+ LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)lParam;
+ LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16*));
+
+ mop16->wDeviceID = mop32a->wDeviceID;
+ if (!HeapFree(SystemHeap, 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+ }
+ return 0;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_OPEN:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME(mci, "This is a hack\n");
+ return 0;
+ default:
+ FIXME(mci, "Map/Unmap internal error on msg=%s\n", MCI_CommandToString(wMsg));
+ }
+ return -1;
+}
+
+/**************************************************************************
+ * MCI_MsgMapper32To16_Create [internal]
+ *
+ * Helper for MCI_MapMsg32ATo16.
+ * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit segmented pointer.
+ * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
+ * 1 : ok, some memory allocated
+ * -2 : ko, memory problem
+ */
+static int MCI_MsgMapper32To16_Create(void** ptr, int size, BOOLEAN keep)
+{
+ void* lp = SEGPTR_ALLOC(sizeof(void**) + size);
+
+ if (!lp) {
+ return -2;
+ }
+ if (keep) {
+ *(void**)lp = *ptr;
+ memcpy((char*)lp + sizeof(void**), *ptr, size);
+ *ptr = (char*)SEGPTR_GET(lp) + sizeof(void**);
+ } else {
+ memcpy((char*)lp, *ptr, size);
+ *ptr = (void*)SEGPTR_GET(lp);
+ }
+ return 1;
+
+}
+
+/**************************************************************************
+ * MCI_MsgMapper32To16_Destroy [internal]
+ *
+ * Helper for MCI_UnMapMsg32ATo16.
+ */
+static int MCI_MsgMapper32To16_Destroy(void* ptr, int size, BOOLEAN kept)
+{
+ if (ptr) {
+ void* msg16 = PTR_SEG_TO_LIN(ptr);
+ void* alloc;
+
+ if (kept) {
+ alloc = (char*)msg16 - sizeof(void**);
+ memcpy(*(void**)alloc, msg16, size);
+ } else {
+ alloc = msg16;
+ }
+
+ if (!SEGPTR_FREE(alloc)) {
+ FIXME(mci, "bad free\n");
+ }
+ }
+ return 0;
+}
+
+/**************************************************************************
+ * MCI_MapMsg32ATo16 [internal]
+ *
+ * Map a 32-A bit MCI message to a 16 bit MCI message.
+ * 1 : ok, some memory allocated, need to call MCI_UnMapMsg32ATo16
+ * 0 : ok, no memory allocated
+ * -1 : ko, unknown message
+ * -2 : ko, memory problem
+ */
+int MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD* lParam)
+{
+ int size;
+ BOOLEAN keep = FALSE;
+
+ if (*lParam == 0)
+ return 0;
+ /* FIXME: to add also (with seg/linear modifications to do):
+ * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
+ * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
+ */
+ switch (wMsg) {
+ /* case MCI_BREAK: */
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ size = sizeof(MCI_GENERIC_PARMS);
+ break;
+ /* case MCI_CONFIGURE:*/
+ /* case MCI_COPY: */
+ case MCI_CUE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME(mci, "NIY vcr\n"); return -2;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ /* case MCI_CUT:*/
+ case MCI_DELETE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ /* case MCI_ESCAPE: */
+ case MCI_FREEZE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ case MCI_DEVTYPE_OVERLAY: /*size = sizeof(MCI_OVLY_FREEZE_PARMS); FIXME(mci, "NIY rect\n"); return -2;*/
+ FIXME(mci, "NIY ovly\n"); return -2;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_GETDEVCAPS:
+ keep = TRUE;
+ size = sizeof(MCI_GETDEVCAPS_PARMS);
+ break;
+ /* case MCI_INDEX: */
+ case MCI_INFO:
+ {
+ LPMCI_INFO_PARMSA mip32a = (LPMCI_INFO_PARMSA)(*lParam);
+ char* ptr;
+ LPMCI_INFO_PARMS16 mip16;
+
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
+ default: size = sizeof(MCI_INFO_PARMS16); break;
+ }
+ ptr = SEGPTR_ALLOC(sizeof(LPMCI_INFO_PARMSA) + size);
+
+ if (ptr) {
+ *(LPMCI_INFO_PARMSA*)ptr = mip32a;
+ mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSA));
+ mip16->dwCallback = mip32a->dwCallback;
+ mip16->lpstrReturn = (LPSTR)SEGPTR_GET(SEGPTR_ALLOC(mip32a->dwRetSize));
+ mip16->dwRetSize = mip32a->dwRetSize;
+ if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
+ ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
+ }
+ } else {
+ return -2;
+ }
+ *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_INFO_PARMSA);
+ }
+ return 1;
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ {
+ LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
+ char* ptr = SEGPTR_ALLOC(sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
+ LPMCI_OPEN_PARMS16 mop16;
+
+
+ if (ptr) {
+ *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
+ mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
+ mop16->dwCallback = mop32a->dwCallback;
+ mop16->wDeviceID = mop32a->wDeviceID;
+ mop16->lpstrDeviceType = SEGPTR_STRDUP(mop32a->lpstrDeviceType);
+ mop16->lpstrElementName = SEGPTR_STRDUP(mop32a->lpstrElementName);
+ mop16->lpstrAlias = SEGPTR_STRDUP(mop32a->lpstrAlias);
+ /* copy extended information if any...
+ * FIXME: this may seg fault if initial structure does not contain them and
+ * the reads after msip16 fail under LDT limits...
+ * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
+ * should not take care of extended parameters, and should be used by MCI_Open
+ * to fetch uDevType. When, this is known, the mapping for sending the
+ * MCI_OPEN_DRIVER shall be done depending on uDevType.
+ */
+ memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
+ } else {
+ return -2;
+ }
+ *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_OPEN_PARMSA);
+ }
+ return 1;
+ /* case MCI_PASTE:*/
+ case MCI_PAUSE:
+ size = sizeof(MCI_GENERIC_PARMS);
+ break;
+ case MCI_PLAY:
+ switch (uDevType) {
+ case MCI_DEVTYPE_OVERLAY: /*size = sizeof(MCI_OVLY_PLAY_PARMS); break;*/FIXME(mci, "NIY ovly\n"); return -2;
+ default: size = sizeof(MCI_PLAY_PARMS); break;
+ }
+ break;
+ case MCI_PUT:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_PUT_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ case MCI_DEVTYPE_OVERLAY: /*size = sizeof(MCI_OVLY_PUT_PARMS); FIXME(mci, "NIY rect\n"); return -2;*/
+ FIXME(mci, "NIY ovly\n"); return -2;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_REALIZE:
+ size = sizeof(MCI_GENERIC_PARMS);
+ break;
+ case MCI_RECORD:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME(mci, "NIY vcr\n"); return -2;
+ default: size = sizeof(MCI_RECORD_PARMS); break;
+ }
+ break;
+ case MCI_RESUME:
+ size = sizeof(MCI_GENERIC_PARMS);
+ break;
+ case MCI_SEEK:
+ switch (uDevType) {
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME(mci, "NIY vcr\n"); return -2;
+ default: size = sizeof(MCI_SEEK_PARMS); break;
+ }
+ break;
+ case MCI_SET:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME(mci, "NIY vcr\n"); return -2;
+ case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
+ case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); FIXME(mci, "NIY UINT\n"); return -2;
+ default: size = sizeof(MCI_SET_PARMS); break;
+ }
+ break;
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ case MCI_SPIN:
+ size = sizeof(MCI_SET_PARMS);
+ break;
+ case MCI_STATUS:
+ keep = TRUE;
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); FIXME(mci, "NIY lpstrDevice\n");return -2;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME(mci, "NIY vcr\n"); return -2;
+ default: size = sizeof(MCI_STATUS_PARMS); break;
+ }
+ break;
+ case MCI_STEP:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME(mci, "NIY vcr\n"); return -2;
+ case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_STOP:
+ size = sizeof(MCI_SET_PARMS);
+ break;
+ case MCI_SYSINFO:
+ {
+ LPMCI_SYSINFO_PARMSA msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
+ char* ptr = SEGPTR_ALLOC(sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16));
+ LPMCI_SYSINFO_PARMS16 msip16;
+
+ if (ptr) {
+ *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
+ msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
+
+ msip16->dwCallback = msip32a->dwCallback;
+ msip16->lpstrReturn = (LPSTR)SEGPTR_GET(SEGPTR_ALLOC(msip32a->dwRetSize));
+ msip16->dwRetSize = msip32a->dwRetSize;
+ msip16->dwNumber = msip32a->dwNumber;
+ msip16->wDeviceType = msip32a->wDeviceType;
+ } else {
+ return -2;
+ }
+ *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
+ }
+ return 1;
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_UPDATE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_WHERE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); FIXME(mci, "NIY rect\n"); return -2;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_WINDOW:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); FIXME(mci, "NIY lpstrText\n"); return -2;
+ case MCI_DEVTYPE_OVERLAY: /*size = sizeof(MCI_OVLY_WINDOW_PARMS); FIXME(mci, "NIY lpstrText\n"); return -2;*/
+ FIXME(mci, "NIY ovly\n"); return -2;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_OPEN:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME(mci, "This is a hack\n");
+ return 0;
+
+ default:
+ WARN(mci, "Don't know how to map msg=%s\n", MCI_CommandToString(wMsg));
+ return -1;
+ }
+ return MCI_MsgMapper32To16_Create((void**)lParam, size, keep);
+}
+
+/**************************************************************************
+ * MCI_UnMapMsg32ATo16 [internal]
+ */
+int MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD lParam)
+{
+ int size = 0;
+ BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
+
+ switch (wMsg) {
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ break;
+ /* case MCI_CONFIGURE:*/
+ /* case MCI_COPY: */
+ case MCI_CUE:
+ break;
+ /* case MCI_CUT: */
+ case MCI_DELETE:
+ break;
+ /* case MCI_ESCAPE: */
+ case MCI_FREEZE:
+ break;
+ case MCI_GETDEVCAPS:
+ kept = TRUE;
+ size = sizeof(MCI_GETDEVCAPS_PARMS);
+ break;
+ /* case MCI_INDEX: */
+ case MCI_INFO:
+ {
+ LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(lParam);
+ LPMCI_INFO_PARMSA mip32a = *(LPMCI_INFO_PARMSA*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSA));
+
+ memcpy(mip32a->lpstrReturn, PTR_SEG_TO_LIN(mip16->lpstrReturn), mip32a->dwRetSize);
+
+ if (!SEGPTR_FREE(PTR_SEG_TO_LIN(mip16->lpstrReturn)))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+ if (!SEGPTR_FREE((char*)mip16 - sizeof(LPMCI_INFO_PARMSA)))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+ }
+ return 0;
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ if (lParam) {
+ LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)PTR_SEG_TO_LIN(lParam);
+ LPMCI_OPEN_PARMSA mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
+
+ mop32a->wDeviceID = mop16->wDeviceID;
+ if (!SEGPTR_FREE(mop16->lpstrDeviceType))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+ if (!SEGPTR_FREE(mop16->lpstrElementName))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+ if (!SEGPTR_FREE(mop16->lpstrAlias))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+
+ if (!SEGPTR_FREE((LPVOID)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA))))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+ }
+ return 0;
+ /* case MCI_PASTE:*/
+ case MCI_PAUSE:
+ break;
+ case MCI_PLAY:
+ break;
+ case MCI_PUT:
+ break;
+ case MCI_REALIZE:
+ break;
+ case MCI_RECORD:
+ break;
+ case MCI_RESUME:
+ break;
+ case MCI_SEEK:
+ break;
+ case MCI_SET:
+ break;
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ case MCI_SPIN:
+ break;
+ case MCI_STATUS:
+ kept = TRUE;
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); FIXME(mci, "NIY lpstrDevice\n");return -2;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME(mci, "NIY vcr\n"); return -2;
+ default: size = sizeof(MCI_STATUS_PARMS); break;
+ }
+ break;
+ case MCI_STEP:
+ break;
+ case MCI_STOP:
+ break;
+ case MCI_SYSINFO:
+ if (lParam) {
+ LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)PTR_SEG_TO_LIN(lParam);
+ LPMCI_SYSINFO_PARMSA msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
+
+ if (msip16) {
+ msip16->dwCallback = msip32a->dwCallback;
+ memcpy(msip32a->lpstrReturn, PTR_SEG_TO_LIN(msip16->lpstrReturn), msip32a->dwRetSize);
+ if (!SEGPTR_FREE(msip16->lpstrReturn))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+
+ if (!SEGPTR_FREE((LPVOID)(lParam - sizeof(LPMCI_SYSINFO_PARMSA))))
+ FIXME(mci, "bad free line=%d\n", __LINE__);
+ } else {
+ return -2;
+ }
+ }
+ return 1;
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ break;
+ case MCI_UPDATE:
+ break;
+ case MCI_WHERE:
+ break;
+ case MCI_WINDOW:
+ /* FIXME: see map function */
+ break;
+
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_OPEN:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME(mci, "This is a hack\n");
+ return 0;
+ default:
+ FIXME(mci, "Map/Unmap internal error on msg=%s\n", MCI_CommandToString(wMsg));
+ return -1;
+ }
+ return MCI_MsgMapper32To16_Destroy((void*)lParam, size, kept);
+}
+
+/**************************************************************************
+ * MCI_SendCommand [internal]
+ */
+DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
+{
+ DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
+
+ if (!MCI_DevIDValid(wDevID)) {
+ dwRet = MCIERR_INVALID_DEVICE_ID;
+ } else {
+ MCIPROC proc = MCI_GetProc(MCI_GetDrv(wDevID)->modp.wType);
+
+ if (proc) {
+ dwRet = (*proc)(MCI_GetDrv(wDevID)->modp.wDeviceID,
+ MCI_GetDrv(wDevID)->hDrv,
+ wMsg, dwParam1, dwParam2);
+ } else if (MCI_GetDrv(wDevID)->hDrv) {
+ switch (DRIVER_GetType(MCI_GetDrv(wDevID)->hDrv)) {
+ case WINE_DI_TYPE_16:
+ {
+ int res;
+
+ switch (res = MCI_MapMsg32ATo16(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2)) {
+ case -1:
+ TRACE(mci, "Not handled yet (%s)\n", MCI_CommandToString(wMsg));
+ dwRet = MCIERR_DRIVER_INTERNAL;
+ break;
+ case -2:
+ TRACE(mci, "Problem mapping msg=%s from 16 to 32a\n", MCI_CommandToString(wMsg));
+ dwRet = MCIERR_OUT_OF_MEMORY;
+ break;
+ case 0:
+ case 1:
+ dwRet = SendDriverMessage16(MCI_GetDrv(wDevID)->hDrv, wMsg, dwParam1, dwParam2);
+ if (res)
+ MCI_UnMapMsg32ATo16(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
+ break;
+ }
+ }
+ break;
+ case WINE_DI_TYPE_32:
+ dwRet = SendDriverMessage(MCI_GetDrv(wDevID)->hDrv, wMsg, dwParam1, dwParam2);
+ break;
+ default:
+ WARN(mci, "Unknown driver type=%u\n", DRIVER_GetType(MCI_GetDrv(wDevID)->hDrv));
+ dwRet = MCIERR_DRIVER_INTERNAL;
+ }
+ } else {
+ WARN(mci, "unknown device type=%04X !\n", MCI_GetDrv(wDevID)->modp.wType);
+ }
+ }
+ return dwRet;
+}
+
+/**************************************************************************
+ * MCI_Open [internal]
+ */
+DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
+{
+ char strDevTyp[128];
+ UINT16 uDevType = 0;
+ UINT16 wDevID = MCI_FirstDevID();
+ DWORD dwRet;
+
+ TRACE(mci, "(%08lX, %p)\n", dwParam, lpParms);
+ if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
+
+ if ((dwParam & ~(MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)) != 0) {
+ FIXME(mci, "unsupported yet dwFlags=%08lX\n",
+ (dwParam & ~(MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)));
+ }
+
+ while (MCI_GetDrv(wDevID)->modp.wType != 0) {
+ wDevID = MCI_NextDevID(wDevID);
+ if (!MCI_DevIDValid(wDevID)) {
+ TRACE(mci, "MAXMCIDRIVERS reached !\n");
+ return MCIERR_OUT_OF_MEMORY;
+ }
+ }
+
+ TRACE(mci, "wDevID=%04X \n", wDevID);
+ memcpy(MCI_GetOpenDrv(wDevID), lpParms, sizeof(*lpParms));
+
+ strDevTyp[0] = 0;
+
+ if (dwParam & MCI_OPEN_ELEMENT) {
+ char* t;
+
+ TRACE(mci, "lpstrElementName='%s'\n", lpParms->lpstrElementName);
+ t = strrchr(lpParms->lpstrElementName, '.');
+ if (t) {
+ GetProfileStringA("mci extensions", t+1, "*", strDevTyp, sizeof(strDevTyp));
+ if (strcmp(strDevTyp, "*") == 0) {
+ TRACE(mci,"No [mci extensions] entry for %s found.\n", t);
+ return MCIERR_EXTENSION_NOT_FOUND;
+ }
+ TRACE(mci, "Extension %s is mapped to type %s\n", t, strDevTyp);
+ } else if (GetDriveTypeA(lpParms->lpstrElementName) == DRIVE_CDROM) {
+ /* FIXME: this will not work if several CDROM drives are installed on the machine */
+ strcpy(strDevTyp, "CDAUDIO");
+ } else {
+ return MCIERR_EXTENSION_NOT_FOUND;
+ }
+ }
+
+ if (dwParam & MCI_OPEN_ALIAS) {
+ TRACE(mci, "Alias='%s' !\n", lpParms->lpstrAlias);
+ /* FIXME is there any memory leak here ? */
+ MCI_GetOpenDrv(wDevID)->lpstrAlias = strdup(lpParms->lpstrAlias);
+ /* mplayer does allocate alias to CDAUDIO */
+ }
+ if (dwParam & MCI_OPEN_TYPE) {
+ if (dwParam & MCI_OPEN_TYPE_ID) {
+#if 0
+ TRACE(mci, "Dev=%08lx!\n", (DWORD)lpParms->lpstrDeviceType);
+ uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
+ MCI_GetOpenDrv(wDevID)->lpstrDeviceType = lpParms->lpstrDeviceType;
+#endif
+ if (LOWORD((DWORD)lpParms->lpstrDeviceType) != MCI_DEVTYPE_CD_AUDIO) {
+ FIXME(mci, "MCI_OPEN_TYPE_ID is no longer properly supported\n");
+ }
+ } else {
+ if (lpParms->lpstrDeviceType == NULL)
+ return MCIERR_NULL_PARAMETER_BLOCK;
+ TRACE(mci, "Dev='%s' !\n", lpParms->lpstrDeviceType);
+ /* FIXME is there any memory leak here ? */
+ MCI_GetOpenDrv(wDevID)->lpstrDeviceType = strdup(lpParms->lpstrDeviceType);
+ strcpy(strDevTyp, lpParms->lpstrDeviceType);
+ }
+ }
+
+ if (uDevType == 0 && strDevTyp[0] != 0) {
+ CharUpperA(strDevTyp);
+ /* try Wine internal MCI drivers */
+ uDevType = MCI_GetDevType(strDevTyp);
+ if (uDevType == 0) { /* Nope, load external */
+ HDRVR hDrv;
+ MCI_OPEN_DRIVER_PARMSA modp;
+
+ modp.wDeviceID = wDevID;
+ modp.lpstrParams = NULL;
+
+ /* FIXME: this is a hack... some MCI drivers, while being open, call
+ * mciSetData, which lookup for non empty slots in MCI table list
+ * Unfortunatly, open slots are known when wType == 0...
+ * so use a dummy type, just to keep on going. May be wType == 0 is
+ * not the best solution to indicate empty slot in MCI drivers table
+ */
+ MCI_GetDrv(wDevID)->modp.wType = MCI_DEVTYPE_CD_AUDIO;
+ hDrv = OpenDriverA(strDevTyp, "mci", (LPARAM)&modp);
+
+ if (!hDrv) {
+ FIXME(mci, "Couldn't load driver for type %s.\n", strDevTyp);
+ return MCIERR_DEVICE_NOT_INSTALLED;
+ }
+ uDevType = modp.wType;
+ MCI_GetDrv(wDevID)->hDrv = hDrv;
+
+ TRACE(mci, "Loaded driver %u (%s), type is %d\n", hDrv, strDevTyp, uDevType);
+ }
+ } else {
+ MCI_GetDrv(wDevID)->hDrv = 0;
+ }
+
+ MCI_GetDrv(wDevID)->modp.wType = uDevType;
+ MCI_GetDrv(wDevID)->modp.wDeviceID = 0; /* FIXME? for multiple devices */
+
+ lpParms->wDeviceID = wDevID;
+
+ TRACE(mci, "mcidev=%d, uDevType=%04X wDeviceID=%04X !\n",
+ wDevID, uDevType, lpParms->wDeviceID);
+
+ dwRet = MCI_SendCommand(wDevID, MCI_OPEN_DRIVER, dwParam, (DWORD)lpParms);
+
+ if (dwRet == 0) {
+ /* only handled devices fall through */
+ TRACE(mci, "wDevID = %04X wDeviceID = %d dwRet = %ld\n", wDevID, lpParms->wDeviceID, dwRet);
+ } else {
+ TRACE(mci, "failed to open driver (MCI_OPEN_DRIVER msg) [%08lx], closing\n", dwRet);
+ MCI_GetDrv(wDevID)->modp.wType = 0;
+ }
+ if (dwParam & MCI_NOTIFY)
+ mciDriverNotify16(lpParms->dwCallback, wDevID, dwRet == 0 ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
+
+ return dwRet;
+}
+
+/**************************************************************************
+ * MCI_Close [internal]
+ */
+DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
+{
+ DWORD dwRet;
+
+ TRACE(mci, "(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
+
+ if (wDevID == MCI_ALL_DEVICE_ID) {
+ FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
+ return MCIERR_CANNOT_USE_ALL;
+ }
+
+ dwRet = MCI_SendCommand(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
+ if (MCI_GetDrv(wDevID)->hDrv) {
+#if 0
+ CloseDriver(MCI_GetDrv(wDevID)->hDrv, 0, 0);
+#endif
+ }
+ MCI_GetDrv(wDevID)->modp.wType = 0;
+
+ if (dwParam & MCI_NOTIFY)
+ mciDriverNotify16(lpParms->dwCallback, wDevID,
+ (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
+
+ return dwRet;
+}
+
+/**************************************************************************
+ * MCI_WriteString [internal]
+ */
+DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
+{
+ DWORD ret;
+
+ if (dstSize <= strlen(lpSrcStr)) {
+ lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
+ ret = MCIERR_PARAM_OVERFLOW;
+ } else {
+ strcpy(lpDstStr, lpSrcStr);
+ ret = 0;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * MCI_Sysinfo [internal]
+ */
+DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
+{
+ DWORD ret = MCIERR_INVALID_DEVICE_ID;
+
+ if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
+
+ TRACE(mci, "(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
+ uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
+
+ switch (dwFlags & ~MCI_SYSINFO_OPEN) {
+ case MCI_SYSINFO_QUANTITY:
+ {
+ DWORD cnt = 0;
+ WORD i;
+
+ if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST || lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
+ if (dwFlags & MCI_SYSINFO_OPEN) {
+ TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
+ for (i = 0; i < MAXMCIDRIVERS; i++) {
+ if (mciDrv[i].modp.wType != 0) cnt++;
+ }
+ } else {
+ TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
+ cnt = mciInstalledCount;
+ }
+ } else {
+ if (dwFlags & MCI_SYSINFO_OPEN) {
+ TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms->wDeviceType);
+ for (i = 0; i < MAXMCIDRIVERS; i++) {
+ if (mciDrv[i].modp.wType == lpParms->wDeviceType) cnt++;
+ }
+ } else {
+ TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms->wDeviceType);
+ FIXME(mci, "Don't know how to get # of MCI devices of a given type\n");
+ cnt = 1;
+ }
+ }
+ *(DWORD*)lpParms->lpstrReturn = cnt;
+ }
+ TRACE(mci, "(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
+ ret = 0;
+ break;
+ case MCI_SYSINFO_INSTALLNAME:
+ TRACE(mci, "MCI_SYSINFO_INSTALLNAME \n");
+ if (MCI_DevIDValid(uDevID)) {
+ LPCSTR str = MCI_GetDevTypeString(MCI_GetDrv(uDevID)->modp.wType);
+ ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, str);
+ } else {
+ *lpParms->lpstrReturn = 0;
+ ret = MCIERR_INVALID_DEVICE_ID;
+ }
+ TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
+ break;
+ case MCI_SYSINFO_NAME:
+ TRACE(mci, "MCI_SYSINFO_NAME\n");
+ if (dwFlags & MCI_SYSINFO_OPEN) {
+ FIXME(mci, "Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
+ ret = MCIERR_UNRECOGNIZED_COMMAND;
+ } else if (lpParms->dwNumber > mciInstalledCount) {
+ ret = MCIERR_OUTOFRANGE;
+ } else {
+ DWORD count = lpParms->dwNumber;
+ LPSTR ptr = lpmciInstallNames;
+
+ while (--count > 0) ptr += strlen(ptr) + 1;
+ ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
+ }
+ TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
+ break;
+ default:
+ TRACE(mci, "Unsupported flag value=%08lx\n", dwFlags);
+ ret = MCIERR_UNRECOGNIZED_COMMAND;
+ }
+ return ret;
+}
+
+struct SCA {
+ UINT wDevID;
+ UINT wMsg;
+ DWORD dwParam1;
+ DWORD dwParam2;
+ BOOL allocatedCopy;
+};
+
+DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2);
+
+/**************************************************************************
+ * MCI_SCAStarter [internal]
+ */
+static DWORD WINAPI MCI_SCAStarter(LPVOID arg)
+{
+ struct SCA* sca = (struct SCA*)arg;
+ DWORD ret;
+
+ TRACE(mci, "In thread before async command (%08x,%s,%08lx,%08lx)\n",
+ sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2);
+ ret = mciSendCommandA(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
+ TRACE(mci, "In thread after async command (%08x,%s,%08lx,%08lx)\n",
+ sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2);
+ if (sca->allocatedCopy)
+ HeapFree(GetProcessHeap(), 0, (LPVOID)sca->dwParam2);
+ HeapFree(GetProcessHeap(), 0, sca);
+ ExitThread(ret);
+ WARN(mci, "Should not happen ? what's wrong \n");
+ /* should not go after this point */
+ return ret;
+}
+
+/**************************************************************************
+ * MCI_SendCommandAsync [internal]
+ */
+DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2, UINT size)
+{
+ struct SCA* sca = HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA));
+
+ if (sca == 0)
+ return MCIERR_OUT_OF_MEMORY;
+
+ sca->wDevID = wDevID;
+ sca->wMsg = wMsg;
+ sca->dwParam1 = dwParam1;
+
+ if (size) {
+ sca->dwParam2 = (DWORD)HeapAlloc(GetProcessHeap(), 0, size);
+ if (sca->dwParam2 == 0) {
+ HeapFree(GetProcessHeap(), 0, sca);
+ return MCIERR_OUT_OF_MEMORY;
+ }
+ sca->allocatedCopy = TRUE;
+ /* copy structure passed by program in dwParam2 to be sure
+ * we can still use it whatever the program does
+ */
+ memcpy((LPVOID)sca->dwParam2, (LPVOID)dwParam2, size);
+ } else {
+ sca->dwParam2 = dwParam2;
+ sca->allocatedCopy = FALSE;
+ }
+
+ if (CreateThread(NULL, 0, MCI_SCAStarter, sca, 0, NULL) == 0) {
+ WARN(mci, "Couldn't allocate thread for async command handling, sending synchonously\n");
+ return MCI_SCAStarter(&sca);
+ }
+ return 0;
+}
+
+/**************************************************************************
+ * MCI_CleanUp [internal]
+ *
+ * Some MCI commands need to be cleaned-up (when not called from
+ * mciSendString), because MCI drivers return extra information for string
+ * transformation. This function gets read of them.
+ */
+LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2, BOOL bIs32)
+{
+ switch (wMsg) {
+ case MCI_GETDEVCAPS:
+ switch (dwRet & 0xFFFF0000ul) {
+ case 0:
+ break;
+ case MCI_RESOURCE_RETURNED:
+ case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
+ case MCI_COLONIZED3_RETURN:
+ case MCI_COLONIZED4_RETURN:
+ case MCI_INTEGER_RETURNED:
+ {
+ LPMCI_GETDEVCAPS_PARMS lmgp = (LPMCI_GETDEVCAPS_PARMS)(bIs32 ? (void*)dwParam2 : PTR_SEG_TO_LIN(dwParam2));
+
+ dwRet = LOWORD(dwRet);
+ TRACE(mci, "Changing %08lx to %08lx\n", lmgp->dwReturn, (DWORD)LOWORD(lmgp->dwReturn));
+
+ lmgp->dwReturn = LOWORD(lmgp->dwReturn);
+ }
+ break;
+ default:
+ FIXME(mci, "Unsupported value for hiword (%04x) returned by DriverProc\n", HIWORD(dwRet));
+ }
+ break;
+ case MCI_STATUS:
+ switch (dwRet & 0xFFFF0000ul) {
+ case 0:
+ break;
+ case MCI_RESOURCE_RETURNED:
+ case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
+ case MCI_COLONIZED3_RETURN:
+ case MCI_COLONIZED4_RETURN:
+ case MCI_INTEGER_RETURNED:
+ {
+ LPMCI_STATUS_PARMS lsp = (LPMCI_STATUS_PARMS)(bIs32 ? (void*)dwParam2 : PTR_SEG_TO_LIN(dwParam2));
+
+ dwRet = LOWORD(dwRet);
+ TRACE(mci, "Changing %08lx to %08lx\n", lsp->dwReturn,(DWORD) LOWORD(lsp->dwReturn));
+ lsp->dwReturn = LOWORD(lsp->dwReturn);
+ }
+ break;
+ default:
+ FIXME(mci, "Unsupported value for hiword (%04x) returned by DriverProc\n", HIWORD(dwRet));
+ }
+ break;
+ default:
+ break;
+ }
+ return dwRet;
+}
+
diff --git a/multimedia/mcistring.c b/multimedia/mcistring.c
index 4d6c1b7..9a6fad3 100644
--- a/multimedia/mcistring.c
+++ b/multimedia/mcistring.c
@@ -27,13 +27,6 @@
#include "debug.h"
#include "xmalloc.h"
-/* FIXME the following definitions must be moved to mmsystem.c */
-extern struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS];
-
-#define MCI_GetDrv(wDevID) (&mciDrv[MCI_DevIDToIndex(wDevID)])
-#define MCI_GetOpenDrv(wDevID) (&(MCI_GetDrv(wDevID)->mop))
-/* end of FIXME */
-
/* The reason why I just don't lowercase the keywords array in
* mciSendString is left as an exercise to the reader.
*/
@@ -52,14 +45,14 @@
do { \
TRACE(mci, "->returns '%s'\n", s); \
if (lpstrReturnString) { \
- lstrcpynA(lpstrReturnString, s, uReturnLength); \
+ lstrcpynA(lpstrReturnString, s, uReturnLength); \
TRACE(mci, "-->'%s'\n", lpstrReturnString); \
} \
} while(0)
/* print a DWORD in the specified timeformat */
static void
-_MCISTR_printtf(char *buf,UINT16 uDevType,DWORD timef,DWORD val)
+_MCISTR_printtf(char *buf, UINT16 uDevType, DWORD timef, DWORD val)
{
*buf = '\0';
switch (timef) {
@@ -106,8 +99,8 @@
#define _MCISTR_devtype 9
static void
-_MCISTR_convreturn(int type,DWORD dwReturn,LPSTR lpstrReturnString,
- WORD uReturnLength,WORD uDevTyp,int timef)
+_MCISTR_convreturn(int type, DWORD dwReturn, LPSTR lpstrReturnString,
+ WORD uReturnLength, WORD uDevTyp, int timef)
{
switch (type) {
case _MCISTR_vdmtype:
@@ -2159,7 +2152,7 @@
}
/**************************************************************************
- * mciSendString32A [MMSYSTEM.702][WINMM.51]
+ * mciSendStringA [MMSYSTEM.702][WINMM.51]
*/
DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString,
UINT uReturnLength, HWND hwndCallback)
@@ -2168,7 +2161,7 @@
}
/**************************************************************************
- * mciSendString32W [WINMM.52]
+ * mciSendStringW [WINMM.52]
*/
DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPSTR lpstrReturnString,
UINT uReturnLength, HWND hwndCallback)
diff --git a/multimedia/mmsystem.c b/multimedia/mmsystem.c
index e1ccc4e..d76723f 100644
--- a/multimedia/mmsystem.c
+++ b/multimedia/mmsystem.c
@@ -25,7 +25,6 @@
#include "windef.h"
#include "wine/winbase16.h"
#include "heap.h"
-#include "ldt.h"
#include "user.h"
#include "driver.h"
#include "multimedia.h"
@@ -35,122 +34,11 @@
#include "debugstr.h"
#include "debug.h"
-int mciInstalledCount;
-int mciInstalledListLen;
-LPSTR lpmciInstallNames = NULL;
-
-struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS];
-
UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
-LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
+LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
-#define MCI_GetDrv(wDevID) (&mciDrv[MCI_DevIDToIndex(wDevID)])
-#define MCI_GetOpenDrv(wDevID) (&(MCI_GetDrv(wDevID)->mop))
-
-/* 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
- * MCI_DevIDToIndex to get an index in that range. An
- * arbitrary value, MCI_MAGIC is added to the wDevID seen
- * by the windows programs.
- */
-
-#define MCI_MAGIC 0x0F00
-
-/**************************************************************************
- * MCI_GetProc32 [internal]
- */
-MCIPROC MCI_GetProc(UINT16 uDevType)
-{
- MCIPROC proc = 0;
-
- switch (uDevType) {
- case MCI_DEVTYPE_CD_AUDIO: proc = MCICDAUDIO_DriverProc; break;
- case MCI_DEVTYPE_WAVEFORM_AUDIO: proc = MCIWAVE_DriverProc; break;
- case MCI_DEVTYPE_SEQUENCER: proc = MCIMIDI_DriverProc; break;
- case MCI_DEVTYPE_ANIMATION: proc = MCIANIM_DriverProc; break;
- case MCI_DEVTYPE_DIGITAL_VIDEO: proc = MCIAVI_DriverProc32; break;
- default: TRACE(mci, "Unknown device type %u\n", uDevType);
- }
- return proc;
-}
-
-/**************************************************************************
- * MCI_GetDevType [internal]
- */
-WORD MCI_GetDevType(LPCSTR str)
-{
- WORD uDevTyp = 0;
-
- if (lstrcmpiA(str, "CDAUDIO") == 0) {
- uDevTyp = MCI_DEVTYPE_CD_AUDIO;
- } else if (lstrcmpiA(str, "WAVEAUDIO") == 0) {
- uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
- } else if (lstrcmpiA(str, "SEQUENCER") == 0) {
- uDevTyp = MCI_DEVTYPE_SEQUENCER;
- } else if (lstrcmpiA(str, "ANIMATION1") == 0) {
- uDevTyp = MCI_DEVTYPE_ANIMATION;
- } else if (lstrcmpiA(str, "AVIVIDEO") == 0) {
- uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
- }
- TRACE(mci, "str = %s => %u\n", str, uDevTyp);
- return uDevTyp;
-}
-
-/**************************************************************************
- * MCI_GetDevTypeString [internal]
- */
-static LPCSTR MCI_GetDevTypeString(WORD uDevTyp)
-{
- LPCSTR str = "??? MCI ???";
-
- switch (uDevTyp) {
- case MCI_DEVTYPE_CD_AUDIO: str = "CDAUDIO"; break;
- case MCI_DEVTYPE_WAVEFORM_AUDIO: str = "WAVEAUDIO"; break;
- case MCI_DEVTYPE_SEQUENCER: str = "SEQUENCER"; break;
- case MCI_DEVTYPE_ANIMATION: str = "ANIMATION1"; break;
- case MCI_DEVTYPE_DIGITAL_VIDEO: str = "AVIVIDEO"; break;
- default: FIXME(mci, "Incohenrent MCI definitions\n");
- }
- TRACE(mci, "devType=%u => %s\n", uDevTyp, str);
- return str;
-}
-
-/**************************************************************************
- * MCI_DevIDToIndex [internal]
- */
-int MCI_DevIDToIndex(UINT16 wDevID)
-{
- return wDevID - MCI_MAGIC;
-}
-
-/**************************************************************************
- * MCI_FirstDevId [internal]
- */
-UINT16 MCI_FirstDevID(void)
-{
- return MCI_MAGIC;
-}
-
-/**************************************************************************
- * MCI_NextDevId [internal]
- */
-UINT16 MCI_NextDevID(UINT16 wDevID)
-{
- return wDevID + 1;
-}
-
-/**************************************************************************
- * MCI_DevIDValid [internal]
- */
-BOOL MCI_DevIDValid(UINT16 wDevID)
-{
- return wDevID >= MCI_MAGIC && wDevID < (MCI_MAGIC + MAXMCIDRIVERS);
-}
-
/**************************************************************************
* MMSYSTEM_WEP [MMSYSTEM.1]
*/
@@ -186,7 +74,7 @@
static int PlaySound_Playing = FALSE;
static LPCSTR PlaySound_pszSound = NULL;
-static HMODULE PlaySound_hmod = 0;
+static HMODULE PlaySound_hmod = 0;
static DWORD PlaySound_fdwSound = 0;
static int PlaySound_Loop = FALSE;
static int PlaySound_SearchMode = 0; /* 1 - sndPlaySound search order
@@ -369,9 +257,9 @@
PlaySound_Playing = TRUE;
if ((PlaySound_fdwSound & SND_RESOURCE) == SND_RESOURCE) {
- HRSRC hRES;
- HGLOBAL hGLOB;
- void *ptr;
+ HRSRC hRES;
+ HGLOBAL hGLOB;
+ void* ptr;
if ((hRES = FindResourceA(PlaySound_hmod, PlaySound_pszSound, "WAVE")) == 0) {
PlaySound_Result = FALSE;
@@ -486,18 +374,18 @@
}
/**************************************************************************
- * sndPlaySound [MMSYSTEM.2][WINMM135]
+ * sndPlaySoundA [MMSYSTEM.2][WINMM135]
*/
-BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags)
+BOOL16 WINAPI sndPlaySoundA(LPCSTR lpszSoundName, UINT16 uFlags)
{
PlaySound_SearchMode = 1;
return PlaySoundA(lpszSoundName, 0, uFlags);
}
/**************************************************************************
- * sndPlaySound [WINMM.136]
+ * sndPlaySoundW [WINMM.136]
*/
-BOOL16 WINAPI sndPlaySound32W(LPCWSTR lpszSoundName, UINT16 uFlags)
+BOOL16 WINAPI sndPlaySoundW(LPCWSTR lpszSoundName, UINT16 uFlags)
{
PlaySound_SearchMode = 1;
return PlaySoundW(lpszSoundName, 0, uFlags);
@@ -524,17 +412,17 @@
/**************************************************************************
* DriverProc [MMSYSTEM.6]
*/
-LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
- DWORD dwParam1, DWORD dwParam2)
+LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
+ DWORD dwParam1, DWORD dwParam2)
{
- return DrvDefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
+ return DrvDefDriverProc(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
}
/**************************************************************************
* DriverCallback [MMSYSTEM.31]
*/
BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
- WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
+ WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
{
TRACE(mmsys, "(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
@@ -609,7 +497,7 @@
/**************************************************************************
* mixerGetDevCapsW [WINMM.102]
*/
-UINT WINAPI mixerGetDevCapsW(UINT devid, LPMIXERCAPSW mixcaps,UINT size)
+UINT WINAPI mixerGetDevCapsW(UINT devid, LPMIXERCAPSW mixcaps, UINT size)
{
MIXERCAPS16 mic16;
UINT ret = mixerGetDevCaps16(devid, &mic16, sizeof(mic16));
@@ -626,7 +514,7 @@
/**************************************************************************
* mixerGetDevCaps [WINMM.101]
*/
-UINT WINAPI mixerGetDevCapsA(UINT devid, LPMIXERCAPSA mixcaps,UINT size)
+UINT WINAPI mixerGetDevCapsA(UINT devid, LPMIXERCAPSA mixcaps, UINT size)
{
MIXERCAPS16 mic16;
UINT ret = mixerGetDevCaps16(devid, &mic16, sizeof(mic16));
@@ -643,7 +531,7 @@
/**************************************************************************
* mixerGetDevCaps
*/
-UINT16 WINAPI mixerGetDevCaps16(UINT16 devid, LPMIXERCAPS16 mixcaps,UINT16 size)
+UINT16 WINAPI mixerGetDevCaps16(UINT16 devid, LPMIXERCAPS16 mixcaps, UINT16 size)
{
FIXME(mmsys,"should this be a fixme?\n");
return mixMessage(devid, MXDM_GETDEVCAPS, 0L, (DWORD)mixcaps, (DWORD)size);
@@ -652,7 +540,7 @@
/**************************************************************************
* mixerOpen [WINMM.110]
*/
-UINT WINAPI mixerOpen(LPHMIXER lphmix,UINT uDeviceID, DWORD dwCallback,
+UINT WINAPI mixerOpen(LPHMIXER lphmix, UINT uDeviceID, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen)
{
HMIXER16 hmix16;
@@ -668,7 +556,7 @@
/**************************************************************************
* mixerOpen
*/
-UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix,UINT16 uDeviceID, DWORD dwCallback,
+UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix, UINT16 uDeviceID, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen)
{
HMIXER16 hmix;
@@ -731,7 +619,7 @@
/**************************************************************************
* mixerGetID
*/
-UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix,LPUINT16 lpid,DWORD fdwID)
+UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix, LPUINT16 lpid, DWORD fdwID)
{
FIXME(mmsys,"(%04x): semi-stub\n",hmix);
if (lpid)
@@ -742,69 +630,82 @@
/**************************************************************************
* mixerGetControlDetailsA [WINMM.99]
*/
-UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix,LPMIXERCONTROLDETAILS lpmcd,DWORD fdwDetails)
+UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
{
- FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails);
+ FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* mixerGetControlDetailsW [WINMM.100]
*/
-UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix,LPMIXERCONTROLDETAILS lpmcd,DWORD fdwDetails)
+UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
{
- FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix,lpmcd,fdwDetails);
+ FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* mixerGetControlDetails [MMSYSTEM.808]
*/
-UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,LPMIXERCONTROLDETAILS16 lpmcd,DWORD fdwDetails)
+UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix, LPMIXERCONTROLDETAILS16 lpmcd, DWORD fdwDetails)
{
- FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails);
+ FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* mixerGetLineControlsA [WINMM.104]
*/
-UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix,LPMIXERLINECONTROLSA lpmlc,DWORD fdwControls)
+UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlc, DWORD fdwControls)
{
- FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
+ FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmlc, fdwControls);
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* mixerGetLineControlsW [WINMM.105]
*/
-UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix,LPMIXERLINECONTROLSW lpmlc,DWORD fdwControls)
+UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlc, DWORD fdwControls)
{
- FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
+ FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmlc, fdwControls);
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* mixerGetLineControls [MMSYSTEM.807]
*/
-UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,LPMIXERLINECONTROLS16 lpmlc,DWORD fdwControls)
+UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix, LPMIXERLINECONTROLS16 lpmlc, DWORD fdwControls)
{
- FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
+ FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmlc, fdwControls);
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* mixerGetLineInfoA [WINMM.106]
*/
-UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix,LPMIXERLINEA lpml,DWORD fdwInfo)
+UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpml, DWORD fdwInfo)
{
MIXERLINE16 ml16;
UINT ret;
+ TRACE(mmsys, "(%04x,%p,%08lx)\n", hmix, lpml, fdwInfo);
+
+ if (lpml == NULL || lpml->cbStruct != sizeof(*lpml))
+ return MMSYSERR_INVALPARAM;
+
+ ml16.cbStruct = sizeof(ml16);
ml16.dwDestination = lpml->dwDestination;
- FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpml,fdwInfo);
- ret = mixerGetLineInfo16(hmix,&ml16,fdwInfo);
- lpml->cbStruct = sizeof(*lpml);
+ ml16.dwSource = lpml->dwSource;
+ ml16.dwLineID = lpml->dwLineID;
+ ml16.dwUser = lpml->dwUser;
+ ml16.dwComponentType = lpml->dwComponentType;
+ ml16.cChannels = lpml->cChannels;
+ ml16.cConnections = lpml->cConnections;
+ ml16.cControls = lpml->cControls;
+
+ ret = mixerGetLineInfo16(hmix, &ml16, fdwInfo);
+
lpml->dwSource = ml16.dwSource;
lpml->dwLineID = ml16.dwLineID;
lpml->fdwLine = ml16.fdwLine;
@@ -873,7 +774,7 @@
*/
UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpml, DWORD fdwInfo)
{
- UINT16 devid = _get_mixerID_from_handle(hmix, fdwInfo);
+ UINT16 devid = _get_mixerID_from_handle(hmix, fdwInfo);
FIXME(mmsys, "(%04x, %p[line %08lx], %08lx)\n",
hmix, lpml, lpml->dwDestination, fdwInfo);
@@ -901,7 +802,7 @@
/**************************************************************************
* mixerMessage [WINMM.109]
*/
-UINT WINAPI mixerMessage(HMIXER hmix,UINT uMsg, DWORD dwParam1, DWORD dwParam2)
+UINT WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
{
LPMIXEROPENDESC lpmod;
UINT16 uDeviceID;
@@ -919,7 +820,7 @@
/**************************************************************************
* mixerMessage [MMSYSTEM.804]
*/
-UINT16 WINAPI mixerMessage16(HMIXER16 hmix,UINT16 uMsg, DWORD dwParam1, DWORD dwParam2)
+UINT16 WINAPI mixerMessage16(HMIXER16 hmix, UINT16 uMsg, DWORD dwParam1, DWORD dwParam2)
{
LPMIXEROPENDESC lpmod;
UINT16 uDeviceID;
@@ -955,7 +856,7 @@
/**************************************************************************
* auxGetDevCaps [WINMM.20]
*/
-UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps,UINT uSize)
+UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
{
AUXCAPS16 ac16;
UINT ret = auxGetDevCaps16(uDeviceID, &ac16, sizeof(ac16));
@@ -972,7 +873,7 @@
/**************************************************************************
* auxGetDevCaps [WINMM.21]
*/
-UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps,UINT uSize)
+UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
{
AUXCAPS16 ac16;
UINT ret = auxGetDevCaps16(uDeviceID, &ac16, sizeof(ac16));
@@ -1000,7 +901,7 @@
/**************************************************************************
* auxGetVolume [WINM.23]
*/
-UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD * lpdwVolume)
+UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
{
return auxGetVolume16(uDeviceID, lpdwVolume);
}
@@ -1008,7 +909,7 @@
/**************************************************************************
* auxGetVolume [MMSYSTEM.352]
*/
-UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
+UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
{
TRACE(mmsys, "(%04X, %p) !\n", uDeviceID, lpdwVolume);
@@ -1036,7 +937,7 @@
/**************************************************************************
* auxOutMessage [MMSYSTEM.354]
*/
-DWORD WINAPI auxOutMessage(UINT uDeviceID,UINT uMessage, DWORD dw1, DWORD dw2)
+DWORD WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD dw1, DWORD dw2)
{
switch (uMessage) {
case AUXDM_GETNUMDEVS:
@@ -1081,20 +982,20 @@
/**************************************************************************
* mciGetErrorStringW [WINMM.46]
*/
-BOOL WINAPI mciGetErrorStringW(DWORD wError, LPWSTR lpstrBuffer,UINT uLength)
+BOOL WINAPI mciGetErrorStringW(DWORD wError, LPWSTR lpstrBuffer, UINT uLength)
{
LPSTR bufstr = HeapAlloc(GetProcessHeap(), 0,uLength);
- BOOL ret = mciGetErrorStringA(wError,bufstr,uLength);
+ BOOL ret = mciGetErrorStringA(wError, bufstr, uLength);
- lstrcpyAtoW(lpstrBuffer,bufstr);
- HeapFree(GetProcessHeap(), 0,bufstr);
+ lstrcpyAtoW(lpstrBuffer, bufstr);
+ HeapFree(GetProcessHeap(), 0, bufstr);
return ret;
}
/**************************************************************************
* mciGetErrorStringA [WINMM.45]
*/
-BOOL WINAPI mciGetErrorStringA(DWORD wError, LPSTR lpstrBuffer,UINT uLength)
+BOOL WINAPI mciGetErrorStringA(DWORD wError, LPSTR lpstrBuffer, UINT uLength)
{
return mciGetErrorString16(wError, lpstrBuffer,uLength);
}
@@ -1102,7 +1003,7 @@
/**************************************************************************
* mciGetErrorString [MMSYSTEM.706]
*/
-BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer,UINT16 uLength)
+BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
{
LPSTR msgptr;
@@ -1398,7 +1299,7 @@
}
/**************************************************************************
- * mciDriverNotify32 [WINMM.36]
+ * mciDriverNotify [WINMM.36]
*/
BOOL WINAPI mciDriverNotify(HWND hWndCallBack, UINT wDevID, UINT wStatus)
{
@@ -1416,50 +1317,52 @@
/**************************************************************************
* mciGetDriverData [MMSYSTEM.708]
*/
-DWORD WINAPI mciGetDriverData16(HDRVR16 hdrv)
+DWORD WINAPI mciGetDriverData16(HDRVR16 hDrv)
{
- return mciGetDriverData(hdrv);
+ return mciGetDriverData(hDrv);
}
/**************************************************************************
* mciGetDriverData [WINMM.44]
*/
-DWORD WINAPI mciGetDriverData(HDRVR hdrv)
+DWORD WINAPI mciGetDriverData(HDRVR hDrv)
{
- TRACE(mmsys,"(%04x)\n", hdrv);
- if (!MCI_DevIDValid(hdrv) || MCI_GetDrv(hdrv)->modp.wType == 0) {
+ TRACE(mmsys,"(%04x)\n", hDrv);
+ if (!MCI_DevIDValid(hDrv) || MCI_GetDrv(hDrv)->modp.wType == 0) {
+ WARN(mmsys, "Bad hDrv\n");
return 0L;
}
- return MCI_GetDrv(hdrv)->dwPrivate;
+ return MCI_GetDrv(hDrv)->dwPrivate;
}
/**************************************************************************
* mciSetDriverData [MMSYSTEM.707]
*/
-BOOL16 WINAPI mciSetDriverData16(HDRVR16 hdrv, DWORD data)
+BOOL16 WINAPI mciSetDriverData16(HDRVR16 hDrv, DWORD data)
{
- return mciSetDriverData(hdrv, data);
+ return mciSetDriverData(hDrv, data);
}
/**************************************************************************
* mciSetDriverData [WINMM.53]
*/
-BOOL WINAPI mciSetDriverData(HDRVR hdrv, DWORD data)
+BOOL WINAPI mciSetDriverData(HDRVR hDrv, DWORD data)
{
- TRACE(mmsys,"(%04x,%08lx)\n", hdrv, data);
- if (!MCI_DevIDValid(hdrv) || MCI_GetDrv(hdrv)->modp.wType == 0) {
+ TRACE(mmsys,"(%04x,%08lx)\n", hDrv, data);
+ if (!MCI_DevIDValid(hDrv) || MCI_GetDrv(hDrv)->modp.wType == 0) {
+ WARN(mmsys, "Bad hDrv\n");
return FALSE;
}
- MCI_GetDrv(hdrv)->dwPrivate = data;
+ MCI_GetDrv(hDrv)->dwPrivate = data;
return TRUE;
}
/**************************************************************************
* mciLoadCommandResource [MMSYSTEM.705]
*/
-UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hinst, LPCSTR resname,UINT16 type)
+UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hinst, LPCSTR resname, UINT16 type)
{
char buf[200];
OFSTRUCT ofs;
@@ -1483,7 +1386,7 @@
strcat(buf,".mci");
if (OpenFile(buf, &ofs,OF_EXIST) != HFILE_ERROR) {
xhinst = LoadLibrary16(buf);
- if (xhinst >32)
+ if (xhinst > 32)
hinst = xhinst;
} /* else use passed hinst */
segstr = SEGPTR_STRDUP(resname);
@@ -1523,674 +1426,51 @@
* mciFreeCommandResource [WINMM.39]
*/
BOOL WINAPI mciFreeCommandResource(UINT uTable)
- {
+{
FIXME(mci, "(%08x) stub\n", uTable);
return 0;
- }
+}
/**************************************************************************
* mciLoadCommandResource [WINMM.48]
*/
-UINT WINAPI mciLoadCommandResource(HANDLE hinst, LPCWSTR resname,UINT type)
+UINT WINAPI mciLoadCommandResource(HANDLE hinst, LPCWSTR resname, UINT type)
{
- FIXME(mmsys,"(%04x,%s,%d): stub!\n", hinst, debugstr_w(resname), type);
+ FIXME(mci, "(%04x,%s,%d): stub!\n", hinst, debugstr_w(resname), type);
return 0;
}
-const char* MCI_CommandToString(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, "MCI_<<%04X>>", wMsg);
- return buffer;
- }
-}
-
-/**************************************************************************
- * MCI_SendCommand32 [internal]
- */
-DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
-{
- DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
-
- if (!MCI_DevIDValid(wDevID)) {
- dwRet = MCIERR_INVALID_DEVICE_ID;
- } else {
- MCIPROC proc = MCI_GetProc(MCI_GetDrv(wDevID)->modp.wType);
-
- if (proc) {
- dwRet = (*proc)(MCI_GetDrv(wDevID)->modp.wDeviceID,
- MCI_GetDrv(wDevID)->hDrv,
- wMsg, dwParam1, dwParam2);
- } else if (MCI_GetDrv(wDevID)->driverProc) {
- FIXME(mmsys, "is that correct ?\n");
- dwRet = Callbacks->CallDriverProc(MCI_GetDrv(wDevID)->driverProc,
- MCI_GetDrv(wDevID)->modp.wDeviceID,
- MCI_GetDrv(wDevID)->hDrv,
- wMsg, dwParam1, dwParam2);
- } else {
- WARN(mmsys, "unknown device type=%04X !\n", MCI_GetDrv(wDevID)->modp.wType);
- }
- }
- return dwRet;
-}
-
-/**************************************************************************
- * MCI_Open [internal]
- */
-static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
-{
- char str[128];
- UINT16 uDevTyp = 0;
- UINT16 wDevID = MCI_FirstDevID();
- DWORD dwRet;
-
- TRACE(mmsys, "(%08lX, %p)\n", dwParam, lpParms);
- if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
-
- if ((dwParam & ~(MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)) != 0) {
- FIXME(mmsys, "unsupported yet dwFlags=%08lX\n",
- (dwParam & ~(MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)));
- }
-
- while (MCI_GetDrv(wDevID)->modp.wType != 0) {
- wDevID = MCI_NextDevID(wDevID);
- if (!MCI_DevIDValid(wDevID)) {
- TRACE(mmsys, "MAXMCIDRIVERS reached !\n");
- return MCIERR_OUT_OF_MEMORY;
- }
- }
-
- TRACE(mmsys, "wDevID=%04X \n", wDevID);
- memcpy(MCI_GetOpenDrv(wDevID), lpParms, sizeof(*lpParms));
-
- if (dwParam & MCI_OPEN_ELEMENT) {
- char *s,*t;
-
- TRACE(mmsys,"lpstrElementName='%s'\n", lpParms->lpstrElementName);
- s = lpParms->lpstrElementName;
- t = strrchr(s, '.');
- if (t) {
- GetProfileStringA("mci extensions", t+1, "*", str, sizeof(str));
- CharUpperA(str);
- uDevTyp = MCI_GetDevType(str);
- if (uDevTyp == 0) {
- if (strcmp(str,"*") == 0) {
- TRACE(mmsys,"No [mci extensions] entry for %s found.\n", t);
- return MCIERR_EXTENSION_NOT_FOUND;
- }
-#if testing32
- /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */
- else {
- HDRVR16 hdrv = OpenDriver32(str, "mci", NULL);
- if (hdrv) {
- HMODULE16 hmod;
-
- hmod = GetDriverModuleHandle(hdrv);
- MCI_GetDrv(wDevID)->hDrv = hdrv;
- MCI_GetDrv(wDevID)->driverProc = GetProcAddress(hmod,oouch SEGPTR_GET(SEGPTR_STRDUP("DRIVERPROC")));
- uDevTyp = MCI_DEVTYPE_OTHER;
- } else {
- FIXME(mmsys, "[mci extensions] entry %s for %s not supported.\n", str, t);
- return MCIERR_DEVICE_NOT_INSTALLED;
- }
- }
-#endif
- }
- } else if (GetDriveTypeA(s) == DRIVE_CDROM) {
- /* FIXME: this will not work if several CDROM drives are installed on the machine */
- uDevTyp = MCI_DEVTYPE_CD_AUDIO;
- } else {
- return MCIERR_EXTENSION_NOT_FOUND;
- }
- }
-
- if (dwParam & MCI_OPEN_ALIAS) {
- TRACE(mmsys, "Alias='%s' !\n", lpParms->lpstrAlias);
- /* FIXME is there any memory leak here ? */
- MCI_GetOpenDrv(wDevID)->lpstrAlias = strdup(lpParms->lpstrAlias);
- /* mplayer does allocate alias to CDAUDIO */
- }
- if (dwParam & MCI_OPEN_TYPE) {
- if (dwParam & MCI_OPEN_TYPE_ID) {
- TRACE(mmsys, "Dev=%08lx!\n", (DWORD)lpParms->lpstrDeviceType);
- uDevTyp = LOWORD((DWORD)lpParms->lpstrDeviceType);
- MCI_GetOpenDrv(wDevID)->lpstrDeviceType = lpParms->lpstrDeviceType;
- } else {
- if (lpParms->lpstrDeviceType == NULL)
- return MCIERR_NULL_PARAMETER_BLOCK;
- TRACE(mmsys, "Dev='%s' !\n", lpParms->lpstrDeviceType);
- /* FIXME is there any memory leak here ? */
- MCI_GetOpenDrv(wDevID)->lpstrDeviceType = strdup(lpParms->lpstrDeviceType);
- strcpy(str, lpParms->lpstrDeviceType);
- CharUpperA(str);
- uDevTyp = MCI_GetDevType(str);
- if (uDevTyp == 0) {
-#if testing32
- /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */
- HDRVR16 hdrv;
- TRACE(mmsys,"trying to load driver...\n");
- hdrv = OpenDriver32(str,"mci",NULL);
- if (hdrv) {
- HMODULE16 hmod;
-
- hmod = GetDriverModuleHandle(hdrv);
- MCI_GetDrv(wDevID)->hDrv = hdrv;
- MCI_GetDrv(wDevID)->driverProc = GetProcAddress(hmod,oouch SEGPTR_GET(SEGPTR_STRDUP("DriverProc")));
- uDevTyp = MCI_DEVTYPE_OTHER;
- } else
-#endif
- return MCIERR_DEVICE_NOT_INSTALLED;
- }
- }
- }
- MCI_GetDrv(wDevID)->modp.wType = uDevTyp;
- MCI_GetDrv(wDevID)->modp.wDeviceID = 0; /* FIXME? for multiple devices */
- MCI_GetDrv(wDevID)->dwPrivate = 0;
- lpParms->wDeviceID = wDevID;
- TRACE(mmsys, "mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
- wDevID, uDevTyp, lpParms->wDeviceID);
- dwRet = MCI_SendCommand(wDevID, MCI_OPEN_DRIVER, dwParam, (DWORD)lpParms);
-
- if (dwRet == 0) {
- /* only handled devices fall through */
- TRACE(mmsys, "wDevID = %04X wDeviceID = %d dwRet = %ld\n", wDevID, lpParms->wDeviceID, dwRet);
- } else {
- TRACE(mmsys, "failed to open driver (MCI_OPEN_DRIVER msg) [%08lx], closing\n", dwRet);
- MCI_GetDrv(wDevID)->modp.wType = 0;
- }
- if (dwParam & MCI_NOTIFY)
- mciDriverNotify16(lpParms->dwCallback, wDevID, dwRet == 0 ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
-
- return dwRet;
-}
-
-/**************************************************************************
- * MCI_Close [internal]
- */
-static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
-{
- DWORD dwRet;
-
- TRACE(mmsys, "(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
-
- if (wDevID == MCI_ALL_DEVICE_ID) {
- FIXME(mmsys, "unhandled MCI_ALL_DEVICE_ID\n");
- return MCIERR_CANNOT_USE_ALL;
- }
-
- dwRet = MCI_SendCommand(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
- MCI_GetDrv(wDevID)->modp.wType = 0;
-
- if (dwParam&MCI_NOTIFY)
- mciDriverNotify16(lpParms->dwCallback, wDevID,
- (dwRet==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
-
- TRACE(mmsys, "returns %ld\n", dwRet);
- return dwRet;
-}
-
-/**************************************************************************
- * MCI_WriteString [internal]
- */
-DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
-{
- DWORD ret;
-
- if (dstSize <= strlen(lpSrcStr)) {
- lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
- ret = MCIERR_PARAM_OVERFLOW;
- } else {
- strcpy(lpDstStr, lpSrcStr);
- ret = 0;
- }
- return ret;
-}
-
-/**************************************************************************
- * MCI_Sysinfo [internal]
- */
-static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
-{
- DWORD ret = MCIERR_INVALID_DEVICE_ID;
-
- if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
-
- TRACE(mci, "(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
- uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
-
- switch (dwFlags & ~MCI_SYSINFO_OPEN) {
- case MCI_SYSINFO_QUANTITY:
- {
- DWORD cnt = 0;
- WORD i;
-
- if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST || lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
- if (dwFlags & MCI_SYSINFO_OPEN) {
- TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
- for (i = 0; i < MAXMCIDRIVERS; i++) {
- if (mciDrv[i].modp.wType != 0) cnt++;
- }
- } else {
- TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
- cnt = mciInstalledCount;
- }
- } else {
- if (dwFlags & MCI_SYSINFO_OPEN) {
- TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms->wDeviceType);
- for (i = 0; i < MAXMCIDRIVERS; i++) {
- if (mciDrv[i].modp.wType == lpParms->wDeviceType) cnt++;
- }
- } else {
- TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms->wDeviceType);
- FIXME(mci, "Don't know how to get # of MCI devices of a given type\n");
- cnt = 1;
- }
- }
- *(DWORD*)lpParms->lpstrReturn = cnt;
- }
- TRACE(mci, "(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
- ret = 0;
- break;
- case MCI_SYSINFO_INSTALLNAME:
- TRACE(mci, "MCI_SYSINFO_INSTALLNAME \n");
- if (MCI_DevIDValid(uDevID)) {
- LPCSTR str = MCI_GetDevTypeString(MCI_GetDrv(uDevID)->modp.wType);
- ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, str);
- } else {
- *lpParms->lpstrReturn = 0;
- ret = MCIERR_INVALID_DEVICE_ID;
- }
- TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
- break;
- case MCI_SYSINFO_NAME:
- TRACE(mci, "MCI_SYSINFO_NAME\n");
- if (dwFlags & MCI_SYSINFO_OPEN) {
- FIXME(mci, "Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
- ret = MCIERR_UNRECOGNIZED_COMMAND;
- } else if (lpParms->dwNumber > mciInstalledCount) {
- ret = MCIERR_OUTOFRANGE;
- } else {
- DWORD count = lpParms->dwNumber;
- LPSTR ptr = lpmciInstallNames;
-
- while (--count > 0) ptr += strlen(ptr) + 1;
- ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
- }
- TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
- break;
- default:
- TRACE(mci, "Unsupported flag value=%08lx\n", dwFlags);
- ret = MCIERR_UNRECOGNIZED_COMMAND;
- }
- return ret;
-}
-
-struct SCA {
- UINT wDevID;
- UINT wMsg;
- DWORD dwParam1;
- DWORD dwParam2;
- BOOL allocatedCopy;
-};
-
-DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2);
-
-/**************************************************************************
- * MCI_SCAStarter32 [internal]
- */
-static DWORD WINAPI MCI_SCAStarter(LPVOID arg)
-{
- struct SCA* sca = (struct SCA*)arg;
- DWORD ret;
-
- TRACE(mci, "In thread before async command (%08x,%s,%08lx,%08lx)\n",
- sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2);
- ret = mciSendCommandA(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
- TRACE(mci, "In thread after async command (%08x,%s,%08lx,%08lx)\n",
- sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2);
- if (sca->allocatedCopy)
- HeapFree(GetProcessHeap(), 0, (LPVOID)sca->dwParam2);
- HeapFree(GetProcessHeap(), 0, sca);
- ExitThread(ret);
- WARN(mci, "Should not happen ? what's wrong \n");
- /* should not go after this point */
- return ret;
-}
-
-/**************************************************************************
- * MCI_SendCommandAsync32 [internal]
- */
-DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2, UINT size)
-{
- struct SCA* sca = HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA));
-
- if (sca == 0)
- return MCIERR_OUT_OF_MEMORY;
-
- sca->wDevID = wDevID;
- sca->wMsg = wMsg;
- sca->dwParam1 = dwParam1;
-
- if (size) {
- sca->dwParam2 = (DWORD)HeapAlloc(GetProcessHeap(), 0, size);
- if (sca->dwParam2 == 0) {
- HeapFree(GetProcessHeap(), 0, sca);
- return MCIERR_OUT_OF_MEMORY;
- }
- sca->allocatedCopy = TRUE;
- /* copy structure passed by program in dwParam2 to be sure
- * we can still use it whatever the program does
- */
- memcpy((LPVOID)sca->dwParam2, (LPVOID)dwParam2, size);
- } else {
- sca->dwParam2 = dwParam2;
- sca->allocatedCopy = FALSE;
- }
-
- if (CreateThread(NULL, 0, MCI_SCAStarter, sca, 0, NULL) == 0) {
- WARN(mci, "Couldn't allocate thread for async command handling, sending synchonously\n");
- return MCI_SCAStarter(&sca);
- }
- return 0;
-}
-
-/**************************************************************************
- * MCI_MapMsg16To32A [internal]
- */
-int MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
-{
- if (*lParam == 0)
- return 0;
- /* FIXME: to add also (with seg/linear modifications to do):
- * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
- * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO, MCI_WINDOW
- */
- switch (wMsg) {
- /* case MCI_CAPTURE */
- case MCI_CLOSE:
- case MCI_CLOSE_DRIVER:
- /* case MCI_CONFIGURE:*/
- case MCI_COPY:
- case MCI_CUE:
- case MCI_CUT:
- case MCI_DELETE:
- case MCI_FREEZE:
- case MCI_GETDEVCAPS:
- /* case MCI_INDEX: */
- /* case MCI_MARK: */
- /* case MCI_MONITOR: */
- case MCI_PASTE:
- case MCI_PAUSE:
- case MCI_PLAY:
- case MCI_PUT:
- case MCI_REALIZE:
- case MCI_RECORD:
- case MCI_RESUME:
- case MCI_SEEK:
- case MCI_SET:
- /* case MCI_SETTIMECODE:*/
- /* case MCI_SIGNAL:*/
- case MCI_SPIN:
- case MCI_STATUS: /* FIXME: is wrong for digital video */
- case MCI_STEP:
- case MCI_STOP:
- /* case MCI_UNDO: */
- case MCI_UNFREEZE:
- case MCI_UPDATE:
- case MCI_WHERE:
- *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
- return 0;
- case MCI_BREAK:
- {
- LPMCI_BREAK_PARMS mbp32 = HeapAlloc(SystemHeap, 0, sizeof(MCI_BREAK_PARMS));
- LPMCI_BREAK_PARMS16 mbp16 = PTR_SEG_TO_LIN(*lParam);
-
- if (mbp32) {
- mbp32->dwCallback = mbp16->dwCallback;
- mbp32->nVirtKey = mbp16->nVirtKey;
- mbp32->hwndBreak = mbp16->hwndBreak;
- } else {
- return -2;
- }
- *lParam = (DWORD)mbp32;
- }
- return 1;
- case MCI_ESCAPE:
- {
- LPMCI_VD_ESCAPE_PARMSA mvep32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_VD_ESCAPE_PARMSA));
- LPMCI_VD_ESCAPE_PARMS16 mvep16 = PTR_SEG_TO_LIN(*lParam);
-
- if (mvep32a) {
- mvep32a->dwCallback = mvep16->dwCallback;
- mvep32a->lpstrCommand = PTR_SEG_TO_LIN(mvep16->lpstrCommand);
- } else {
- return -2;
- }
- *lParam = (DWORD)mvep32a;
- }
- return 1;
- case MCI_INFO:
- {
- LPMCI_INFO_PARMSA mip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_INFO_PARMSA));
- LPMCI_INFO_PARMS16 mip16 = PTR_SEG_TO_LIN(*lParam);
-
- /* FIXME this is wrong if device is of type
- * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
- */
- if (mip32a) {
- mip32a->dwCallback = mip16->dwCallback;
- mip32a->lpstrReturn = PTR_SEG_TO_LIN(mip16->lpstrReturn);
- mip32a->dwRetSize = mip16->dwRetSize;
- } else {
- return -2;
- }
- *lParam = (DWORD)mip32a;
- }
- return 1;
- case MCI_OPEN:
- case MCI_OPEN_DRIVER:
- {
- LPMCI_OPEN_PARMSA mop32a = HeapAlloc(SystemHeap, 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD));
- LPMCI_OPEN_PARMS16 mop16 = PTR_SEG_TO_LIN(*lParam);
-
- if (mop32a) {
- *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
- mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
- mop32a->dwCallback = mop16->dwCallback;
- mop32a->wDeviceID = mop16->wDeviceID;
- mop32a->lpstrDeviceType = PTR_SEG_TO_LIN(mop16->lpstrDeviceType);
- mop32a->lpstrElementName = PTR_SEG_TO_LIN(mop16->lpstrElementName);
- mop32a->lpstrAlias = PTR_SEG_TO_LIN(mop16->lpstrAlias);
- /* copy extended information if any...
- * FIXME: this may seg fault if initial structure does not contain them and
- * the reads after msip16 fail under LDT limits...
- * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
- * should not take care of extended parameters, and should be used by MCI_Open
- * to fetch uDevTyp. When, this is known, the mapping for sending the
- * MCI_OPEN_DRIVER shall be done depending on uDevTyp.
- */
- ((DWORD*)(mop32a + 1))[0] = ((DWORD*)(mop16 + 1))[0];
- ((DWORD*)(mop32a + 1))[1] = ((DWORD*)(mop16 + 1))[1];
- } else {
- return -2;
- }
- *lParam = (DWORD)mop32a;
- }
- return 1;
- case MCI_SYSINFO:
- {
- LPMCI_SYSINFO_PARMSA msip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_SYSINFO_PARMSA));
- LPMCI_SYSINFO_PARMS16 msip16 = PTR_SEG_TO_LIN(*lParam);
-
- if (msip32a) {
- msip32a->dwCallback = msip16->dwCallback;
- msip32a->lpstrReturn = PTR_SEG_TO_LIN(msip16->lpstrReturn);
- msip32a->dwRetSize = msip16->dwRetSize;
- msip32a->dwNumber = msip16->dwNumber;
- msip32a->wDeviceType = msip16->wDeviceType;
- } else {
- return -2;
- }
- *lParam = (DWORD)msip32a;
- }
- return 1;
- case DRV_LOAD:
- case DRV_ENABLE:
- case DRV_OPEN:
- case DRV_CLOSE:
- case DRV_DISABLE:
- case DRV_FREE:
- case DRV_CONFIGURE:
- case DRV_QUERYCONFIGURE:
- case DRV_INSTALL:
- case DRV_REMOVE:
- case DRV_EXITSESSION:
- case DRV_EXITAPPLICATION:
- case DRV_POWER:
- FIXME(mci, "This is a hack\n");
- return 0;
-
- default:
- WARN(mci, "Don't know how to map msg=%s\n", MCI_CommandToString(wMsg));
- }
- return -1;
-}
-
-/**************************************************************************
- * MCI_UnMapMsg16To32A [internal]
- */
-int MCI_UnMapMsg16To32A(WORD uDevTyp, WORD wMsg, DWORD lParam)
-{
- switch (wMsg) {
- /* case MCI_CAPTURE */
- case MCI_CLOSE:
- case MCI_CLOSE_DRIVER:
- /* case MCI_CONFIGURE:*/
- case MCI_COPY:
- case MCI_CUE:
- case MCI_CUT:
- case MCI_DELETE:
- case MCI_FREEZE:
- case MCI_GETDEVCAPS:
- /* case MCI_INDEX: */
- /* case MCI_MARK: */
- /* case MCI_MONITOR: */
- case MCI_PASTE:
- case MCI_PAUSE:
- case MCI_PLAY:
- case MCI_PUT:
- case MCI_REALIZE:
- case MCI_RECORD:
- case MCI_RESUME:
- case MCI_SEEK:
- case MCI_SET:
- /* case MCI_SETTIMECODE:*/
- /* case MCI_SIGNAL:*/
- case MCI_SPIN:
- case MCI_STATUS:
- case MCI_STEP:
- case MCI_STOP:
- /* case MCI_UNDO: */
- case MCI_UNFREEZE:
- case MCI_UPDATE:
- case MCI_WHERE:
- return 0;
-
- case MCI_BREAK:
- case MCI_ESCAPE:
- case MCI_INFO:
- case MCI_SYSINFO:
- HeapFree(SystemHeap, 0, (LPVOID)lParam);
- return 0;
- case MCI_OPEN:
- case MCI_OPEN_DRIVER:
- if (lParam) {
- LPMCI_OPEN_PARMSA mop32a = (MCI_OPEN_PARMSA*)lParam;
- LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16*));
-
- mop16->wDeviceID = mop32a->wDeviceID;
- HeapFree(SystemHeap, 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16)));
- }
- return 0;
- case DRV_LOAD:
- case DRV_ENABLE:
- case DRV_OPEN:
- case DRV_CLOSE:
- case DRV_DISABLE:
- case DRV_FREE:
- case DRV_CONFIGURE:
- case DRV_QUERYCONFIGURE:
- case DRV_INSTALL:
- case DRV_REMOVE:
- case DRV_EXITSESSION:
- case DRV_EXITAPPLICATION:
- case DRV_POWER:
- FIXME(mci, "This is a hack\n");
- return 0;
- default:
- FIXME(mci, "Map/Unmap internal error on msg=%s\n", MCI_CommandToString(wMsg));
- }
- return -1;
-}
-
/**************************************************************************
* mciSendCommandA [WINMM.49]
*/
DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2)
{
+ DWORD dwRet;
+
TRACE(mci, "(%08x,%s,%08lx,%08lx)\n", wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2);
switch (wMsg) {
case MCI_OPEN:
- return MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
+ dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
+ break;
case MCI_CLOSE:
- return MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
+ dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
+ break;
case MCI_SYSINFO:
- return MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
+ dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
+ break;
default:
if (wDevID == MCI_ALL_DEVICE_ID) {
FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
- return MCIERR_CANNOT_USE_ALL;
+ dwRet = MCIERR_CANNOT_USE_ALL;
+ } else {
+ dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2);
}
-
- return MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2);
+ break;
}
+ dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2, TRUE);
+ TRACE(mci, "=> %08ld\n", dwRet);
+ return dwRet;
}
/**************************************************************************
@@ -2244,22 +1524,37 @@
dwRet = MCIERR_INVALID_DEVICE_ID;
} else {
int res;
-
- switch (res = MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2)) {
- case -1:
- TRACE(mci, "Not handled yet (%s)\n", MCI_CommandToString(wMsg));
+
+ switch (DRIVER_GetType(MCI_GetDrv(wDevID)->hDrv)) {
+ case WINE_DI_TYPE_16:
+ dwRet = SendDriverMessage16(MCI_GetDrv(wDevID)->hDrv, wMsg, dwParam1, dwParam2);
break;
- case -2:
- TRACE(mci, "Problem mapping msg=%s from 16 to 32a\n", MCI_CommandToString(wMsg));
- case 0:
- case 1:
- dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2);
- if (res)
- MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
+ case WINE_DI_TYPE_32:
+ switch (res = MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2)) {
+ case -1:
+ TRACE(mci, "Not handled yet (%s)\n", MCI_CommandToString(wMsg));
+ dwRet = MCIERR_DRIVER_INTERNAL;
+ break;
+ case -2:
+ TRACE(mci, "Problem mapping msg=%s from 16 to 32a\n", MCI_CommandToString(wMsg));
+ dwRet = MCIERR_OUT_OF_MEMORY;
+ break;
+ case 0:
+ case 1:
+ dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2);
+ if (res)
+ MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
+ break;
+ }
break;
+ default:
+ WARN(mmsys, "Unknown driver type=%u\n", DRIVER_GetType(MCI_GetDrv(wDevID)->hDrv));
+ dwRet = MCIERR_DRIVER_INTERNAL;
}
}
}
+ dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2, FALSE);
+ TRACE(mmsys, "=> %ld\n", dwRet);
return dwRet;
}
@@ -2564,8 +1859,8 @@
/**************************************************************************
* midiOutOpen [WINM.84]
*/
-UINT WINAPI midiOutOpen(HMIDIOUT * lphMidiOut, UINT uDeviceID,
- DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
+UINT WINAPI midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID,
+ DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
{
HMIDIOUT16 hmo16;
UINT ret;
@@ -2579,7 +1874,7 @@
/**************************************************************************
* midiOutOpen [MMSYSTEM.204]
*/
-UINT16 WINAPI midiOutOpen16(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
+UINT16 WINAPI midiOutOpen16(HMIDIOUT16* lphMidiOut, UINT16 uDeviceID,
DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
{
HMIDI16 hMidiOut;
@@ -2643,7 +1938,7 @@
* midiOutPrepareHeader [WINMM.85]
*/
UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut,
- MIDIHDR16 * lpMidiOutHdr, UINT uSize)
+ MIDIHDR16* lpMidiOutHdr, UINT uSize)
{
LPMIDIOPENDESC lpDesc;
@@ -2660,7 +1955,7 @@
* midiOutPrepareHeader [MMSYSTEM.206]
*/
UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,
- MIDIHDR16 * lpMidiOutHdr, UINT16 uSize)
+ MIDIHDR16* lpMidiOutHdr, UINT16 uSize)
{
LPMIDIOPENDESC lpDesc;
@@ -2677,7 +1972,7 @@
* midiOutUnprepareHeader [WINMM.89]
*/
UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut,
- MIDIHDR16 * lpMidiOutHdr, UINT uSize)
+ MIDIHDR16* lpMidiOutHdr, UINT uSize)
{
return midiOutUnprepareHeader16(hMidiOut, lpMidiOutHdr,uSize);
}
@@ -2686,7 +1981,7 @@
* midiOutUnprepareHeader [MMSYSTEM.207]
*/
UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,
- MIDIHDR16 * lpMidiOutHdr, UINT16 uSize)
+ MIDIHDR16* lpMidiOutHdr, UINT16 uSize)
{
LPMIDIOPENDESC lpDesc;
@@ -2724,7 +2019,7 @@
* midiOutLongMsg [WINMM.82]
*/
UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut,
- MIDIHDR16 * lpMidiOutHdr, UINT uSize)
+ MIDIHDR16* lpMidiOutHdr, UINT uSize)
{
return midiOutLongMsg16(hMidiOut, lpMidiOutHdr,uSize);
}
@@ -2733,7 +2028,7 @@
* midiOutLongMsg [MMSYSTEM.209]
*/
UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut,
- MIDIHDR16 * lpMidiOutHdr, UINT16 uSize)
+ MIDIHDR16* lpMidiOutHdr, UINT16 uSize)
{
LPMIDIOPENDESC lpDesc;
@@ -2770,7 +2065,7 @@
/**************************************************************************
* midiOutGetVolume [WINM.81]
*/
-UINT WINAPI midiOutGetVolume(UINT uDeviceID, DWORD * lpdwVolume)
+UINT WINAPI midiOutGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
{
return midiOutGetVolume16(uDeviceID, lpdwVolume);
}
@@ -2778,7 +2073,7 @@
/**************************************************************************
* midiOutGetVolume [MMSYSTEM.211]
*/
-UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
+UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
{
TRACE(mmsys, "(%04X, %p);\n", uDeviceID, lpdwVolume);
return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
@@ -2805,7 +2100,7 @@
* midiOutCachePatches [WINMM.73]
*/
UINT WINAPI midiOutCachePatches(HMIDIOUT hMidiOut, UINT uBank,
- WORD * lpwPatchArray, UINT uFlags)
+ WORD* lpwPatchArray, UINT uFlags)
{
return midiOutCachePatches16(hMidiOut,uBank, lpwPatchArray,uFlags);
}
@@ -2814,7 +2109,7 @@
* midiOutCachePatches [MMSYSTEM.213]
*/
UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
- WORD * lpwPatchArray, UINT16 uFlags)
+ WORD* lpwPatchArray, UINT16 uFlags)
{
/* not really necessary to support this */
FIXME(mmsys, "not supported yet\n");
@@ -2825,7 +2120,7 @@
* midiOutCacheDrumPatches [WINMM.72]
*/
UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT hMidiOut, UINT uPatch,
- WORD * lpwKeyArray, UINT uFlags)
+ WORD* lpwKeyArray, UINT uFlags)
{
return midiOutCacheDrumPatches16(hMidiOut,uPatch, lpwKeyArray,uFlags);
}
@@ -2834,7 +2129,7 @@
* midiOutCacheDrumPatches [MMSYSTEM.214]
*/
UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
- WORD * lpwKeyArray, UINT16 uFlags)
+ WORD* lpwKeyArray, UINT16 uFlags)
{
FIXME(mmsys, "not supported yet\n");
return MMSYSERR_NOTSUPPORTED;
@@ -2843,7 +2138,7 @@
/**************************************************************************
* midiOutGetID [WINMM.79]
*/
-UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT * lpuDeviceID)
+UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT* lpuDeviceID)
{
UINT16 xid;
UINT ret;
@@ -2856,7 +2151,7 @@
/**************************************************************************
* midiOutGetID [MMSYSTEM.215]
*/
-UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID)
+UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16* lpuDeviceID)
{
TRACE(mmsys, "midiOutGetID\n");
return 0;
@@ -2866,7 +2161,7 @@
* midiOutMessage [WINMM.83]
*/
DWORD WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage,
- DWORD dwParam1, DWORD dwParam2)
+ DWORD dwParam1, DWORD dwParam2)
{
LPMIDIOPENDESC lpDesc;
@@ -2959,8 +2254,7 @@
/**************************************************************************
* midiInGetDevCaps [WINMM.60]
*/
-UINT WINAPI midiInGetDevCapsW(UINT uDeviceID,
- LPMIDIINCAPSW lpCaps, UINT uSize)
+UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
{
MIDIINCAPS16 mic16;
UINT ret = midiInGetDevCaps16(uDeviceID, &mic16,uSize);
@@ -2976,8 +2270,7 @@
/**************************************************************************
* midiInGetDevCaps [WINMM.59]
*/
-UINT WINAPI midiInGetDevCapsA(UINT uDeviceID,
- LPMIDIINCAPSA lpCaps, UINT uSize)
+UINT WINAPI midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
{
MIDIINCAPS16 mic16;
UINT ret = midiInGetDevCaps16(uDeviceID, &mic16,uSize);
@@ -3032,8 +2325,8 @@
/**************************************************************************
* midiInOpen [WINMM.66]
*/
-UINT WINAPI midiInOpen(HMIDIIN * lphMidiIn, UINT uDeviceID,
- DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
+UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
+ DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
{
HMIDIIN16 xhmid16;
UINT ret = midiInOpen16(&xhmid16,uDeviceID, dwCallback, dwInstance,
@@ -3046,7 +2339,7 @@
/**************************************************************************
* midiInOpen [MMSYSTEM.304]
*/
-UINT16 WINAPI midiInOpen16(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
+UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID,
DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
{
HMIDI16 hMidiIn;
@@ -3111,7 +2404,7 @@
* midiInPrepareHeader [WINMM.67]
*/
UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn,
- MIDIHDR16 * lpMidiInHdr, UINT uSize)
+ MIDIHDR16* lpMidiInHdr, UINT uSize)
{
LPMIDIOPENDESC lpDesc;
@@ -3128,7 +2421,7 @@
* midiInPrepareHeader [MMSYSTEM.306]
*/
UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,
- MIDIHDR16 * lpMidiInHdr, UINT16 uSize)
+ MIDIHDR16* lpMidiInHdr, UINT16 uSize)
{
LPMIDIOPENDESC lpDesc;
@@ -3145,7 +2438,7 @@
* midiInUnprepareHeader [WINMM.71]
*/
UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
- MIDIHDR16 * lpMidiInHdr, UINT uSize)
+ MIDIHDR16* lpMidiInHdr, UINT uSize)
{
return midiInUnprepareHeader16(hMidiIn, lpMidiInHdr,uSize);
}
@@ -3154,7 +2447,7 @@
* midiInUnprepareHeader [MMSYSTEM.307]
*/
UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,
- MIDIHDR16 * lpMidiInHdr, UINT16 uSize)
+ MIDIHDR16* lpMidiInHdr, UINT16 uSize)
{
LPMIDIOPENDESC lpDesc;
TRACE(mmsys, "(%04X, %p, %d)\n",
@@ -3169,7 +2462,7 @@
* midiInAddBuffer [WINMM.57]
*/
UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn,
- MIDIHDR16 * lpMidiInHdr, UINT uSize)
+ MIDIHDR16* lpMidiInHdr, UINT uSize)
{
return midiInAddBuffer16(hMidiIn, lpMidiInHdr,uSize);
}
@@ -3178,7 +2471,7 @@
* midiInAddBuffer [MMSYSTEM.308]
*/
UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,
- MIDIHDR16 * lpMidiInHdr, UINT16 uSize)
+ MIDIHDR16* lpMidiInHdr, UINT16 uSize)
{
TRACE(mmsys, "midiInAddBuffer\n");
return 0;
@@ -3290,7 +2583,7 @@
* midiInMessage [WINMM.65]
*/
DWORD WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage,
- DWORD dwParam1, DWORD dwParam2)
+ DWORD dwParam1, DWORD dwParam2)
{
LPMIDIOPENDESC lpDesc;
@@ -3455,8 +2748,8 @@
* midiStreamOpen [WINMM.91]
*/
MMRESULT WINAPI midiStreamOpen(HMIDISTRM* phms, LPUINT lpuDeviceID,
- DWORD cMidi, DWORD dwCallback,
- DWORD dwInstance, DWORD fdwOpen)
+ DWORD cMidi, DWORD dwCallback,
+ DWORD dwInstance, DWORD fdwOpen)
{
WINE_MIDIStream* ms;
@@ -3689,7 +2982,8 @@
/**************************************************************************
* waveOutGetNumDevs [MMSYSTEM.401]
*/
-UINT WINAPI waveOutGetNumDevs() {
+UINT WINAPI waveOutGetNumDevs()
+{
return waveOutGetNumDevs16();
}
@@ -3709,7 +3003,7 @@
/**************************************************************************
* waveOutGetDevCaps [MMSYSTEM.402]
*/
-UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, WAVEOUTCAPS16 * lpCaps,
+UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, LPWAVEOUTCAPS16 lpCaps,
UINT16 uSize)
{
if (uDeviceID > waveOutGetNumDevs16() - 1) return MMSYSERR_BADDEVICEID;
@@ -3722,7 +3016,7 @@
* waveOutGetDevCapsA [WINMM.162]
*/
UINT WINAPI waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA lpCaps,
- UINT uSize)
+ UINT uSize)
{
WAVEOUTCAPS16 woc16;
UINT16 ret = waveOutGetDevCaps16(uDeviceID, &woc16, sizeof(woc16));
@@ -3857,9 +3151,9 @@
* waveOutOpen [WINMM.173]
* All the args/structs have the same layout as the win16 equivalents
*/
-UINT WINAPI waveOutOpen(HWAVEOUT * lphWaveOut, UINT uDeviceID,
- const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
- DWORD dwInstance, DWORD dwFlags)
+UINT WINAPI waveOutOpen(HWAVEOUT* lphWaveOut, UINT uDeviceID,
+ const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
+ DWORD dwInstance, DWORD dwFlags)
{
HWAVEOUT16 hwo16;
UINT ret = waveOutOpen16(&hwo16,uDeviceID, lpFormat, dwCallback, dwInstance,
@@ -3872,7 +3166,7 @@
/**************************************************************************
* waveOutOpen [MMSYSTEM.404]
*/
-UINT16 WINAPI waveOutOpen16(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
+UINT16 WINAPI waveOutOpen16(HWAVEOUT16* lphWaveOut, UINT16 uDeviceID,
const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
DWORD dwInstance, DWORD dwFlags)
{
@@ -3944,7 +3238,7 @@
* waveOutPrepareHeader [WINMM.175]
*/
UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
- WAVEHDR* lpWaveOutHdr, UINT uSize)
+ WAVEHDR* lpWaveOutHdr, UINT uSize)
{
LPWAVEOPENDESC lpDesc;
@@ -3982,7 +3276,7 @@
* waveOutUnprepareHeader [WINMM.181]
*/
UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
- WAVEHDR* lpWaveOutHdr, UINT uSize)
+ WAVEHDR* lpWaveOutHdr, UINT uSize)
{
LPWAVEOPENDESC lpDesc;
@@ -4020,7 +3314,7 @@
* waveOutWrite [MMSYSTEM.408]
*/
UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, WAVEHDR* lpWaveOutHdr,
- UINT uSize)
+ UINT uSize)
{
LPWAVEOPENDESC lpDesc;
@@ -4122,7 +3416,7 @@
* waveOutGetPosition [WINMM.170]
*/
UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
- UINT uSize)
+ UINT uSize)
{
MMTIME16 mmt16;
UINT ret;
@@ -4201,7 +3495,7 @@
/**************************************************************************
* waveOutGetID [MMSYSTEM.420]
*/
-UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT * lpuDeviceID)
+UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
{
LPWAVEOPENDESC lpDesc;
@@ -4217,7 +3511,7 @@
/**************************************************************************
* waveOutGetID [MMSYSTEM.420]
*/
-UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID)
+UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16* lpuDeviceID)
{
LPWAVEOPENDESC lpDesc;
@@ -4420,9 +3714,9 @@
/**************************************************************************
* waveInOpen [WINMM.154]
*/
-UINT WINAPI waveInOpen(HWAVEIN * lphWaveIn, UINT uDeviceID,
- const LPWAVEFORMAT lpFormat, DWORD dwCallback,
- DWORD dwInstance, DWORD dwFlags)
+UINT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
+ const LPWAVEFORMAT lpFormat, DWORD dwCallback,
+ DWORD dwInstance, DWORD dwFlags)
{
HWAVEIN16 hwin16;
UINT ret = waveInOpen16(&hwin16,uDeviceID, lpFormat, dwCallback, dwInstance,
@@ -4434,7 +3728,7 @@
/**************************************************************************
* waveInOpen [MMSYSTEM.504]
*/
-UINT16 WINAPI waveInOpen16(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
+UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID,
const LPWAVEFORMAT lpFormat, DWORD dwCallback,
DWORD dwInstance, DWORD dwFlags)
{
@@ -4502,7 +3796,7 @@
* waveInPrepareHeader [WINMM.155]
*/
UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn,
- WAVEHDR * lpWaveInHdr, UINT uSize)
+ WAVEHDR* lpWaveInHdr, UINT uSize)
{
LPWAVEOPENDESC lpDesc;
@@ -4524,7 +3818,7 @@
* waveInPrepareHeader [MMSYSTEM.506]
*/
UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,
- WAVEHDR * lpWaveInHdr, UINT16 uSize)
+ WAVEHDR* lpWaveInHdr, UINT16 uSize)
{
LPWAVEOPENDESC lpDesc;
LPBYTE saveddata = lpWaveInHdr->lpData;
@@ -4552,7 +3846,7 @@
* waveInUnprepareHeader [WINMM.159]
*/
UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn,
- WAVEHDR * lpWaveInHdr, UINT uSize)
+ WAVEHDR* lpWaveInHdr, UINT uSize)
{
LPWAVEOPENDESC lpDesc;
@@ -4572,7 +3866,7 @@
* waveInUnprepareHeader [MMSYSTEM.507]
*/
UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,
- WAVEHDR * lpWaveInHdr, UINT16 uSize)
+ WAVEHDR* lpWaveInHdr, UINT16 uSize)
{
LPWAVEOPENDESC lpDesc;
@@ -4592,7 +3886,7 @@
* waveInAddBuffer [WINMM.144]
*/
UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn,
- WAVEHDR * lpWaveInHdr, UINT uSize)
+ WAVEHDR* lpWaveInHdr, UINT uSize)
{
LPWAVEOPENDESC lpDesc;
@@ -4613,7 +3907,7 @@
* waveInAddBuffer [MMSYSTEM.508]
*/
UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,
- WAVEHDR * lpWaveInHdr, UINT16 uSize)
+ WAVEHDR* lpWaveInHdr, UINT16 uSize)
{
LPWAVEOPENDESC lpDesc;
UINT16 ret;
@@ -4700,7 +3994,7 @@
* waveInGetPosition [WINMM.152]
*/
UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
- UINT uSize)
+ UINT uSize)
{
MMTIME16 mmt16;
UINT ret;
@@ -4730,7 +4024,7 @@
/**************************************************************************
* waveInGetID [WINMM.150]
*/
-UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT * lpuDeviceID)
+UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
{
LPWAVEOPENDESC lpDesc;
@@ -4745,7 +4039,7 @@
/**************************************************************************
* waveInGetID [MMSYSTEM.513]
*/
-UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID)
+UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16* lpuDeviceID)
{
LPWAVEOPENDESC lpDesc;
@@ -4761,7 +4055,7 @@
* waveInMessage [WINMM.153]
*/
DWORD WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
- DWORD dwParam1, DWORD dwParam2)
+ DWORD dwParam1, DWORD dwParam2)
{
LPWAVEOPENDESC lpDesc;
@@ -4814,7 +4108,7 @@
break;
case WIDM_GETNUMDEVS:
case WIDM_CLOSE:
- case WIDM_STOP :
+ case WIDM_STOP:
case WIDM_RESET:
case WIDM_START:
case WIDM_PAUSE:
@@ -4851,50 +4145,51 @@
/**************************************************************************
* DrvClose [MMSYSTEM.1101]
*/
-LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
+LRESULT WINAPI DrvClose(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2)
{
- TRACE(mmsys, "(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
+ TRACE(mmsys, "(%04X, %08lX, %08lX);\n", hDrv, lParam1, lParam2);
- return CloseDriver16(hDrvr, lParam1, lParam2);
+ return CloseDriver16(hDrv, lParam1, lParam2);
}
/**************************************************************************
* DrvSendMessage [MMSYSTEM.1102]
*/
-LRESULT WINAPI DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1,
+LRESULT WINAPI DrvSendMessage(HDRVR16 hDrv, WORD msg, LPARAM lParam1,
LPARAM lParam2)
{
/* DWORD dwDriverID = 0; */
- FIXME(mmsys, "(%04X, %04X, %08lX, %08lX);\n", hDriver, msg, lParam1, lParam2);
+ FIXME(mmsys, "(%04X, %04X, %08lX, %08lX);\n", hDrv, msg, lParam1, lParam2);
return MMSYSERR_NOTENABLED;
/* FIXME: wrong ... */
/* should known the mapping between hDrv and wDevIDs */
- /* MCICDAUDIO_DriverProc16(dwDriverID, hDriver, msg, lParam1, lParam2); */
+ /* MCICDAUDIO_DriverProc16(dwDriverID, hDrv, msg, lParam1, lParam2); */
}
/**************************************************************************
* DrvGetModuleHandle [MMSYSTEM.1103]
*/
-HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrvr)
+HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv)
{
- return GetDriverModuleHandle16(hDrvr);
+ return GetDriverModuleHandle16(hDrv);
}
/**************************************************************************
* DrvDefDriverProc [MMSYSTEM.1104]
*/
-LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg,
+LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
- return DefDriverProc16(dwDriverID, hDriv, wMsg, dwParam1, dwParam2);
+ /* FIXME : any mapping from 32 to 16 bit structure ? */
+ return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2);
}
/**************************************************************************
- * DefDriverProc32 [WINMM.5]
+ * DefDriverProc [WINMM.5]
*/
-LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hdrvr,
- UINT Msg, LPARAM lParam1, LPARAM lParam2)
+LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
+ UINT Msg, LPARAM lParam1, LPARAM lParam2)
{
switch (Msg) {
case DRV_LOAD:
diff --git a/relay32/winmm.spec b/relay32/winmm.spec
index 7fecf2e..0e5bd13 100644
--- a/relay32/winmm.spec
+++ b/relay32/winmm.spec
@@ -135,8 +135,8 @@
132 stdcall mmioStringToFOURCCW(wstr long) mmioStringToFOURCCW
133 stdcall mmioWrite(long ptr long) mmioWrite
134 stdcall mmsystemGetVersion() mmsystemGetVersion
-135 stdcall sndPlaySoundA(ptr long) sndPlaySound
-136 stdcall sndPlaySoundW(ptr long) sndPlaySound32W
+135 stdcall sndPlaySoundA(ptr long) sndPlaySoundA
+136 stdcall sndPlaySoundW(ptr long) sndPlaySoundW
137 stdcall timeBeginPeriod(long) timeBeginPeriod
138 stdcall timeEndPeriod(long) timeEndPeriod
139 stdcall timeGetDevCaps(ptr long) timeGetDevCaps
