*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_MMSYSTEM_H
#define __WINE_MMSYSTEM_H
-#include "windef.h"
-
#ifdef __cplusplus
extern "C" {
#endif
typedef LPSTR HPSTR; /* a huge version of LPSTR */
typedef LPCSTR HPCSTR; /* a huge version of LPCSTR */
+typedef UINT* LPUINT;
-DECLARE_OLD_HANDLE(HDRVR);
-DECLARE_OLD_HANDLE(HWAVE);
-DECLARE_OLD_HANDLE(HWAVEIN);
-DECLARE_OLD_HANDLE(HWAVEOUT);
+DECLARE_HANDLE(HDRVR);
+DECLARE_HANDLE(HWAVE);
+DECLARE_HANDLE(HWAVEIN);
+DECLARE_HANDLE(HWAVEOUT);
DECLARE_HANDLE(HMIDI);
DECLARE_HANDLE(HMIDIIN);
DECLARE_HANDLE(HMIDIOUT);
DECLARE_HANDLE(HMIDISTRM);
-DECLARE_OLD_HANDLE(HMIXER);
-DECLARE_OLD_HANDLE(HMIXEROBJ);
-DECLARE_OLD_HANDLE(HMMIO);
+DECLARE_HANDLE(HMIXER);
+DECLARE_HANDLE(HMIXEROBJ);
+DECLARE_HANDLE(HMMIO);
+
+typedef HMIDI *LPHMIDI;
+typedef HMIDIIN *LPHMIDIIN;
+typedef HMIDIOUT *LPHMIDIOUT;
+typedef HMIDISTRM *LPHMIDISTRM;
+typedef HMIXER *LPHMIXER;
+typedef HMIXEROBJ *LPHMIXEROBJ;
+typedef HWAVEIN *LPHWAVEIN;
+typedef HWAVEOUT *LPHWAVEOUT;
-#include "pshpack1.h"
+#include <pshpack1.h>
-typedef LRESULT (CALLBACK *DRIVERPROC)(DWORD,HDRVR,UINT,LPARAM,LPARAM);
+typedef LRESULT (CALLBACK *DRIVERPROC)(DWORD_PTR,HDRVR,UINT,LPARAM,LPARAM);
#define MAXWAVEDRIVERS 10
#define MAXMIDIDRIVERS 10
#define MAXMIXERDRIVERS 10
#define MAXPNAMELEN 32 /* max product name length (including NULL) */
-#define MAXERRORLENGTH 128 /* max error text length (including NULL) */
+#define MAXERRORLENGTH 256 /* max error text length (including NULL) */
#define MAX_JOYSTICKOEMVXDNAME 260
-typedef WORD VERSION; /* major (high byte), minor (low byte) */
-
#ifndef _MCIERROR_
#define _MCIERROR_
typedef DWORD MCIERROR;
#endif
typedef UINT MMRESULT;
-typedef struct {
+typedef struct mmtime_tag {
UINT wType;
union {
DWORD ms;
DWORD songptrpos;
} midi;
} u;
-} MMTIME, *LPMMTIME;
+} MMTIME, *PMMTIME, *LPMMTIME;
#define TIME_MS 0x0001 /* time in milliseconds */
#define TIME_SAMPLES 0x0002 /* number of wave samples */
#define MM_MIM_MOREDATA 0x3CC
+#define MM_MIXM_LINE_CHANGE 0x3D0
+#define MM_MIXM_CONTROL_CHANGE 0x3D1
+
#define MMSYSERR_BASE 0
#define WAVERR_BASE 32
#define MIDIERR_BASE 64
#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
+#define MMSYSERR_ERROR (MMSYSERR_BASE + 1)
+#define MMSYSERR_BADDEVICEID (MMSYSERR_BASE + 2)
+#define MMSYSERR_NOTENABLED (MMSYSERR_BASE + 3)
+#define MMSYSERR_ALLOCATED (MMSYSERR_BASE + 4)
+#define MMSYSERR_INVALHANDLE (MMSYSERR_BASE + 5)
+#define MMSYSERR_NODRIVER (MMSYSERR_BASE + 6)
+#define MMSYSERR_NOMEM (MMSYSERR_BASE + 7)
+#define MMSYSERR_NOTSUPPORTED (MMSYSERR_BASE + 8)
+#define MMSYSERR_BADERRNUM (MMSYSERR_BASE + 9)
+#define MMSYSERR_INVALFLAG (MMSYSERR_BASE + 10)
+#define MMSYSERR_INVALPARAM (MMSYSERR_BASE + 11)
+#define MMSYSERR_HANDLEBUSY (MMSYSERR_BASE + 12)
+#define MMSYSERR_INVALIDALIAS (MMSYSERR_BASE + 13)
+#define MMSYSERR_BADDB (MMSYSERR_BASE + 14)
+#define MMSYSERR_KEYNOTFOUND (MMSYSERR_BASE + 15)
+#define MMSYSERR_READERROR (MMSYSERR_BASE + 16)
+#define MMSYSERR_WRITEERROR (MMSYSERR_BASE + 17)
+#define MMSYSERR_DELETEERROR (MMSYSERR_BASE + 18)
+#define MMSYSERR_VALNOTFOUND (MMSYSERR_BASE + 19)
+#define MMSYSERR_NODRIVERCB (MMSYSERR_BASE + 20)
+#define MMSYSERR_MOREDATA (MMSYSERR_BASE + 21)
+#define MMSYSERR_LASTERROR (MMSYSERR_BASE + 21)
#define CALLBACK_TYPEMASK 0x00070000l /* callback type mask */
#define CALLBACK_NULL 0x00000000l /* no callback */
#define GND_FORWARD 0x00000000
#define GND_REVERSE 0x00000002
-typedef struct {
+typedef struct tagDRVCONFIGINFO {
DWORD dwDCISize;
LPCWSTR lpszDCISectionName;
LPCWSTR lpszDCIAliasName;
} DRVCONFIGINFO, *LPDRVCONFIGINFO;
-LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hdrvr,
- UINT Msg, LPARAM lParam1, LPARAM lParam2);
+LRESULT WINAPI DefDriverProc(DWORD_PTR,HDRVR,UINT,LPARAM,LPARAM);
+/* this sounds odd, but it's the way it is. OpenDriverA even disappeared
+ * from latest SDK
+ */
HDRVR WINAPI OpenDriverA(LPCSTR szDriverName, LPCSTR szSectionName,
LPARAM lParam2);
-HDRVR WINAPI OpenDriverW(LPCWSTR szDriverName, LPCWSTR szSectionName,
- LPARAM lParam2);
-#define OpenDriver WINELIB_NAME_AW(OpenDriver)
+HDRVR WINAPI OpenDriver(LPCWSTR szDriverName, LPCWSTR szSectionName,
+ LPARAM lParam2);
LRESULT WINAPI CloseDriver(HDRVR hDriver, LPARAM lParam1, LPARAM lParam2);
LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT message,
LPARAM lParam1, LPARAM lParam2);
HMODULE WINAPI GetDriverModuleHandle(HDRVR hDriver);
DWORD WINAPI GetDriverFlags(HDRVR hDriver);
-#ifdef __WINE__
-/* this call (GetDriverFlags) is not documented, nor the flags returned.
- * here are Wine only definitions
- */
-#define WINE_GDF_EXIST 0x80000000
-#define WINE_GDF_16BIT 0x10000000
-#endif
-typedef void (CALLBACK *LPDRVCALLBACK) (HDRVR h, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
+typedef void (CALLBACK *LPDRVCALLBACK)(HDRVR,UINT,DWORD_PTR,DWORD_PTR,DWORD_PTR);
#define MM_MICROSOFT 1 /* Microsoft Corp. */
+#define MM_CREATIVE 2 /* Creative labs */
#define MM_MIDI_MAPPER 1 /* MIDI Mapper */
#define MM_WAVE_MAPPER 2 /* Wave Mapper */
#define MM_PC_JOYSTICK 12 /* Joystick adapter */
+#define MM_CREATIVE_SBP16_WAVEOUT 104
UINT WINAPI mmsystemGetVersion(void);
BOOL WINAPI sndPlaySoundA(LPCSTR lpszSound, UINT fuSound);
#define WAVE_MAPPED 0x0004
#define WAVE_FORMAT_DIRECT 0x0008
#define WAVE_FORMAT_DIRECT_QUERY (WAVE_FORMAT_QUERY | WAVE_FORMAT_DIRECT)
-#ifdef __WINE__
-#define WAVE_DIRECTSOUND 0x0080
-#endif
typedef struct wavehdr_tag {
- LPSTR lpData; /* pointer to locked data buffer */
- DWORD dwBufferLength; /* length of data buffer */
- DWORD dwBytesRecorded;/* used for input only */
- DWORD dwUser; /* for client's use */
- DWORD dwFlags; /* assorted flags (see defines) */
- DWORD dwLoops; /* loop control counter */
-
- struct wavehdr_tag *lpNext; /* reserved for driver */
- DWORD reserved; /* reserved for driver */
+ LPSTR lpData;
+ DWORD dwBufferLength;
+ DWORD dwBytesRecorded;
+ DWORD dwUser;
+ DWORD dwFlags;
+ DWORD dwLoops;
+ struct wavehdr_tag *lpNext;
+ DWORD reserved;
} WAVEHDR, *PWAVEHDR, *NPWAVEHDR, *LPWAVEHDR;
-#define WHDR_DONE 0x00000001 /* done bit */
-#define WHDR_PREPARED 0x00000002 /* set if this header has been prepared */
-#define WHDR_BEGINLOOP 0x00000004 /* loop start block */
-#define WHDR_ENDLOOP 0x00000008 /* loop end block */
-#define WHDR_INQUEUE 0x00000010 /* reserved for driver */
-
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- CHAR szPname[MAXPNAMELEN]; /* product name (0 terminated string) */
- DWORD dwFormats; /* formats supported */
- WORD wChannels; /* number of sources supported */
- WORD wReserved1; /* padding */
- DWORD dwSupport; /* functionality supported by driver */
+#define WHDR_DONE 0x00000001
+#define WHDR_PREPARED 0x00000002
+#define WHDR_BEGINLOOP 0x00000004
+#define WHDR_ENDLOOP 0x00000008
+#define WHDR_INQUEUE 0x00000010
+
+typedef struct tagWAVEOUTCAPSA {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ DWORD dwFormats;
+ WORD wChannels;
+ WORD wReserved1;
+ DWORD dwSupport;
} WAVEOUTCAPSA, *LPWAVEOUTCAPSA;
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- WCHAR szPname[MAXPNAMELEN]; /* product name (0 terminated string) */
- DWORD dwFormats; /* formats supported */
- WORD wChannels; /* number of sources supported */
- WORD wReserved1; /* padding */
- DWORD dwSupport; /* functionality supported by driver */
+typedef struct tagWAVEOUTCAPSW {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ DWORD dwFormats;
+ WORD wChannels;
+ WORD wReserved1;
+ DWORD dwSupport;
} WAVEOUTCAPSW, *LPWAVEOUTCAPSW;
DECL_WINELIB_TYPE_AW(WAVEOUTCAPS)
DECL_WINELIB_TYPE_AW(LPWAVEOUTCAPS)
+typedef struct tagWAVEOUTCAPS2A {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ DWORD dwFormats;
+ WORD wChannels;
+ WORD wReserved1;
+ DWORD dwSupport;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} WAVEOUTCAPS2A, *LPWAVEOUTCAPS2A;
+
+typedef struct tagWAVEOUTCAPS2W {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ DWORD dwFormats;
+ WORD wChannels;
+ WORD wReserved1;
+ DWORD dwSupport;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} WAVEOUTCAPS2W, *LPWAVEOUTCAPS2W;
+DECL_WINELIB_TYPE_AW(WAVEOUTCAPS2)
+DECL_WINELIB_TYPE_AW(LPWAVEOUTCAPS2)
+
#define WAVECAPS_PITCH 0x0001 /* supports pitch control */
#define WAVECAPS_PLAYBACKRATE 0x0002 /* supports playback rate control */
#define WAVECAPS_VOLUME 0x0004 /* supports volume control */
#define WAVECAPS_SAMPLEACCURATE 0x0020 /* position is sample accurate */
#define WAVECAPS_DIRECTSOUND 0x0040 /* ? */
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- CHAR szPname[MAXPNAMELEN]; /* product name (0 terminated string) */
- DWORD dwFormats; /* formats supported */
- WORD wChannels; /* number of channels supported */
+typedef struct tagWAVEINCAPSA {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ DWORD dwFormats;
+ WORD wChannels;
WORD wReserved1;
} WAVEINCAPSA, *LPWAVEINCAPSA;
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- WCHAR szPname[MAXPNAMELEN]; /* product name (0 terminated string) */
- DWORD dwFormats; /* formats supported */
- WORD wChannels; /* number of channels supported */
+typedef struct tagWAVEINCAPSW {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ DWORD dwFormats;
+ WORD wChannels;
WORD wReserved1;
} WAVEINCAPSW, *LPWAVEINCAPSW;
DECL_WINELIB_TYPE_AW(WAVEINCAPS)
DECL_WINELIB_TYPE_AW(LPWAVEINCAPS)
-#define WAVE_INVALIDFORMAT 0x00000000 /* invalid format */
-#define WAVE_FORMAT_1M08 0x00000001 /* 11.025 kHz, Mono, 8-bit */
-#define WAVE_FORMAT_1S08 0x00000002 /* 11.025 kHz, Stereo, 8-bit */
-#define WAVE_FORMAT_1M16 0x00000004 /* 11.025 kHz, Mono, 16-bit */
-#define WAVE_FORMAT_1S16 0x00000008 /* 11.025 kHz, Stereo, 16-bit */
-#define WAVE_FORMAT_2M08 0x00000010 /* 22.05 kHz, Mono, 8-bit */
-#define WAVE_FORMAT_2S08 0x00000020 /* 22.05 kHz, Stereo, 8-bit */
-#define WAVE_FORMAT_2M16 0x00000040 /* 22.05 kHz, Mono, 16-bit */
-#define WAVE_FORMAT_2S16 0x00000080 /* 22.05 kHz, Stereo, 16-bit */
-#define WAVE_FORMAT_4M08 0x00000100 /* 44.1 kHz, Mono, 8-bit */
-#define WAVE_FORMAT_4S08 0x00000200 /* 44.1 kHz, Stereo, 8-bit */
-#define WAVE_FORMAT_4M16 0x00000400 /* 44.1 kHz, Mono, 16-bit */
-#define WAVE_FORMAT_4S16 0x00000800 /* 44.1 kHz, Stereo, 16-bit */
+typedef struct tagWAVEINCAPS2A {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ DWORD dwFormats;
+ WORD wChannels;
+ WORD wReserved1;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} WAVEINCAPS2A, *LPWAVEINCAPS2A;
+typedef struct tagWAVEINCAPS2W {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ DWORD dwFormats;
+ WORD wChannels;
+ WORD wReserved1;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} WAVEINCAPS2W, *LPWAVEINCAPS2W;
+DECL_WINELIB_TYPE_AW(WAVEINCAPS2)
+DECL_WINELIB_TYPE_AW(LPWAVEINCAPS2)
+
+#define WAVE_INVALIDFORMAT 0x00000000 /* invalid format */
+#define WAVE_FORMAT_1M08 0x00000001 /* 11.025 kHz, Mono, 8-bit */
+#define WAVE_FORMAT_1S08 0x00000002 /* 11.025 kHz, Stereo, 8-bit */
+#define WAVE_FORMAT_1M16 0x00000004 /* 11.025 kHz, Mono, 16-bit */
+#define WAVE_FORMAT_1S16 0x00000008 /* 11.025 kHz, Stereo, 16-bit */
+#define WAVE_FORMAT_2M08 0x00000010 /* 22.05 kHz, Mono, 8-bit */
+#define WAVE_FORMAT_2S08 0x00000020 /* 22.05 kHz, Stereo, 8-bit */
+#define WAVE_FORMAT_2M16 0x00000040 /* 22.05 kHz, Mono, 16-bit */
+#define WAVE_FORMAT_2S16 0x00000080 /* 22.05 kHz, Stereo, 16-bit */
+#define WAVE_FORMAT_4M08 0x00000100 /* 44.1 kHz, Mono, 8-bit */
+#define WAVE_FORMAT_4S08 0x00000200 /* 44.1 kHz, Stereo, 8-bit */
+#define WAVE_FORMAT_4M16 0x00000400 /* 44.1 kHz, Mono, 16-bit */
+#define WAVE_FORMAT_4S16 0x00000800 /* 44.1 kHz, Stereo, 16-bit */
+#define WAVE_FORMAT_48M08 0x00001000 /* 48 kHz, Mono, 8-bit */
+#define WAVE_FORMAT_48S08 0x00002000 /* 48 kHz, Stereo, 8-bit */
+#define WAVE_FORMAT_48M16 0x00004000 /* 48 kHz, Mono, 16-bit */
+#define WAVE_FORMAT_48S16 0x00008000 /* 48 kHz, Stereo, 16-bit */
+#define WAVE_FORMAT_96M08 0x00010000 /* 96 kHz, Mono, 8-bit */
+#define WAVE_FORMAT_96S08 0x00020000 /* 96 kHz, Stereo, 8-bit */
+#define WAVE_FORMAT_96M16 0x00040000 /* 96 kHz, Mono, 16-bit */
+#define WAVE_FORMAT_96S16 0x00080000 /* 96 kHz, Stereo, 16-bit */
/* General format structure common to all formats, same for Win16 and Win32 */
-typedef struct {
- WORD wFormatTag; /* format type */
- WORD nChannels; /* number of channels */
- DWORD nSamplesPerSec; /* sample rate */
- DWORD nAvgBytesPerSec;/* for buffer estimation */
- WORD nBlockAlign; /* block size of data */
+typedef struct waveformat_tag {
+ WORD wFormatTag;
+ WORD nChannels;
+ DWORD nSamplesPerSec;
+ DWORD nAvgBytesPerSec;
+ WORD nBlockAlign;
} WAVEFORMAT, *LPWAVEFORMAT;
#define WAVE_FORMAT_PCM 1
-typedef struct {
+typedef struct pcmwaveformat_tag {
WAVEFORMAT wf;
WORD wBitsPerSample;
} PCMWAVEFORMAT, *LPPCMWAVEFORMAT;
#ifndef _WAVEFORMATEX_
#define _WAVEFORMATEX_
/* dito same for Win16 / Win32 */
-typedef struct {
- WORD wFormatTag; /* format type */
- WORD nChannels; /* number of channels (i.e. mono, stereo...) */
- DWORD nSamplesPerSec; /* sample rate */
- DWORD nAvgBytesPerSec;/* for buffer estimation */
- WORD nBlockAlign; /* block size of data */
- WORD wBitsPerSample; /* number of bits per sample of mono data */
- WORD cbSize; /* the count in bytes of the size of */
- /* extra information (after cbSize) */
+typedef struct tWAVEFORMATEX {
+ WORD wFormatTag;
+ WORD nChannels;
+ DWORD nSamplesPerSec;
+ DWORD nAvgBytesPerSec;
+ WORD nBlockAlign;
+ WORD wBitsPerSample;
+ WORD cbSize;
} WAVEFORMATEX, *LPWAVEFORMATEX, *NPWAVEFORMATEX, *PWAVEFORMATEX;
#endif
+typedef const WAVEFORMATEX *LPCWAVEFORMATEX;
UINT WINAPI waveOutGetNumDevs(void);
-UINT WINAPI waveOutGetDevCapsA(UINT,LPWAVEOUTCAPSA,UINT);
-UINT WINAPI waveOutGetDevCapsW(UINT,LPWAVEOUTCAPSW,UINT);
+UINT WINAPI waveOutGetDevCapsA(UINT_PTR,LPWAVEOUTCAPSA,UINT);
+UINT WINAPI waveOutGetDevCapsW(UINT_PTR,LPWAVEOUTCAPSW,UINT);
#define waveOutGetDevCaps WINELIB_NAME_AW(waveOutGetDevCaps)
-UINT WINAPI waveOutGetVolume(UINT,DWORD*);
-UINT WINAPI waveOutSetVolume(UINT,DWORD);
+UINT WINAPI waveOutGetVolume(HWAVEOUT,DWORD*);
+UINT WINAPI waveOutSetVolume(HWAVEOUT,DWORD);
UINT WINAPI waveOutGetErrorTextA(UINT,LPSTR,UINT);
UINT WINAPI waveOutGetErrorTextW(UINT,LPWSTR,UINT);
#define waveOutGetErrorText WINELIB_NAME_AW(waveOutGetErrorText)
-UINT WINAPI waveOutOpen(HWAVEOUT*,UINT,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
+MMRESULT WINAPI waveOutOpen(HWAVEOUT*,UINT,LPCWAVEFORMATEX,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI waveOutClose(HWAVEOUT);
UINT WINAPI waveOutPrepareHeader(HWAVEOUT,WAVEHDR*,UINT);
UINT WINAPI waveOutUnprepareHeader(HWAVEOUT,WAVEHDR*,UINT);
UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT,DWORD*);
UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT,DWORD);
UINT WINAPI waveOutGetID(HWAVEOUT,UINT*);
-DWORD WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD);
+UINT WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD_PTR,DWORD_PTR);
UINT WINAPI waveInGetNumDevs(void);
-UINT WINAPI waveInGetDevCapsA(UINT,LPWAVEINCAPSA,UINT);
-UINT WINAPI waveInGetDevCapsW(UINT,LPWAVEINCAPSW,UINT);
+UINT WINAPI waveInGetDevCapsA(UINT_PTR,LPWAVEINCAPSA,UINT);
+UINT WINAPI waveInGetDevCapsW(UINT_PTR,LPWAVEINCAPSW,UINT);
#define waveInGetDevCaps WINELIB_NAME_AW(waveInGetDevCaps)
UINT WINAPI waveInGetErrorTextA(UINT,LPSTR,UINT);
UINT WINAPI waveInGetErrorTextW(UINT,LPWSTR,UINT);
#define waveInGetErrorText WINELIB_NAME_AW(waveInGetErrorText)
-UINT WINAPI waveInOpen(HWAVEIN*,UINT,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
+MMRESULT WINAPI waveInOpen(HWAVEIN*,UINT,LPCWAVEFORMATEX,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI waveInClose(HWAVEIN);
UINT WINAPI waveInPrepareHeader(HWAVEIN,WAVEHDR*,UINT);
UINT WINAPI waveInUnprepareHeader(HWAVEIN,WAVEHDR*,UINT);
UINT WINAPI waveInReset(HWAVEIN);
UINT WINAPI waveInGetPosition(HWAVEIN,LPMMTIME,UINT);
UINT WINAPI waveInGetID(HWAVEIN,UINT*);
-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 */
-#define MIDIERR_NOMAP (MIDIERR_BASE + 2) /* no current map */
-#define MIDIERR_NOTREADY (MIDIERR_BASE + 3) /* hardware is still busy */
-#define MIDIERR_NODEVICE (MIDIERR_BASE + 4) /* port no longer connected */
-#define MIDIERR_INVALIDSETUP (MIDIERR_BASE + 5) /* invalid setup */
-#define MIDIERR_LASTERROR (MIDIERR_BASE + 5) /* last error in range */
+UINT WINAPI waveInMessage(HWAVEIN,UINT,DWORD_PTR,DWORD_PTR);
+
+#define MIDIERR_UNPREPARED (MIDIERR_BASE + 0)
+#define MIDIERR_STILLPLAYING (MIDIERR_BASE + 1)
+#define MIDIERR_NOMAP (MIDIERR_BASE + 2)
+#define MIDIERR_NOTREADY (MIDIERR_BASE + 3)
+#define MIDIERR_NODEVICE (MIDIERR_BASE + 4)
+#define MIDIERR_INVALIDSETUP (MIDIERR_BASE + 5)
+#define MIDIERR_BADOPENMODE (MIDIERR_BASE + 6)
+#define MIDIERR_DONT_CONTINUE (MIDIERR_BASE + 7)
+#define MIDIERR_LASTERROR (MIDIERR_BASE + 7)
typedef LPDRVCALLBACK LPMIDICALLBACK;
#define MIDIPATCHSIZE 128
#define MIDI_CACHE_QUERY 3
#define MIDI_UNCACHE 4
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- CHAR szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
- WORD wTechnology; /* type of device */
- WORD wVoices; /* # of voices (internal synth only) */
- WORD wNotes; /* max # of notes (internal synth only) */
- WORD wChannelMask; /* channels used (internal synth only) */
- DWORD dwSupport; /* functionality supported by driver */
+typedef struct tagMIDIOUTCAPSA {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ WORD wTechnology;
+ WORD wVoices;
+ WORD wNotes;
+ WORD wChannelMask;
+ DWORD dwSupport;
} MIDIOUTCAPSA, *LPMIDIOUTCAPSA;
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- WCHAR szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
- WORD wTechnology; /* type of device */
- WORD wVoices; /* # of voices (internal synth only) */
- WORD wNotes; /* max # of notes (internal synth only) */
- WORD wChannelMask; /* channels used (internal synth only) */
- DWORD dwSupport; /* functionality supported by driver */
+typedef struct tagMIDIOUTCAPSW {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ WORD wTechnology;
+ WORD wVoices;
+ WORD wNotes;
+ WORD wChannelMask;
+ DWORD dwSupport;
} MIDIOUTCAPSW, *LPMIDIOUTCAPSW;
DECL_WINELIB_TYPE_AW(MIDIOUTCAPS)
DECL_WINELIB_TYPE_AW(LPMIDIOUTCAPS)
+typedef struct tagMIDIOUTCAPS2A {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ WORD wTechnology;
+ WORD wVoices;
+ WORD wNotes;
+ WORD wChannelMask;
+ DWORD dwSupport;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} MIDIOUTCAPS2A, *LPMIDIOUTCAPS2A;
+
+typedef struct tagMIDIOUTCAPS2W {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ WORD wTechnology;
+ WORD wVoices;
+ WORD wNotes;
+ WORD wChannelMask;
+ DWORD dwSupport;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} MIDIOUTCAPS2W, *LPMIDIOUTCAPS2W;
+
+DECL_WINELIB_TYPE_AW(MIDIOUTCAPS2)
+DECL_WINELIB_TYPE_AW(LPMIDIOUTCAPS2)
+
#define MOD_MIDIPORT 1 /* output port */
#define MOD_SYNTH 2 /* generic internal synth */
#define MOD_SQSYNTH 3 /* square wave internal synth */
#define MIDICAPS_CACHE 0x0004
#define MIDICAPS_STREAM 0x0008 /* capable of supporting stream buffer */
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- CHAR szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
- DWORD dwSupport; /* included in win95 and higher */
+typedef struct tagMIDIINCAPSA {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ DWORD dwSupport;
} MIDIINCAPSA, *LPMIDIINCAPSA;
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- WCHAR szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
- DWORD dwSupport; /* included in win95 and higher */
+typedef struct tagMIDIINCAPSW {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ DWORD dwSupport;
} MIDIINCAPSW, *LPMIDIINCAPSW;
DECL_WINELIB_TYPE_AW(MIDIINCAPS)
DECL_WINELIB_TYPE_AW(LPMIDIINCAPS)
+typedef struct tagMIDIINCAPS2A {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ DWORD dwSupport;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} MIDIINCAPS2A, *LPMIDIINCAPS2A;
+
+typedef struct tagMIDIINCAPS2W {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ DWORD dwSupport;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} MIDIINCAPS2W, *LPMIDIINCAPS2W;
+
+DECL_WINELIB_TYPE_AW(MIDIINCAPS2)
+DECL_WINELIB_TYPE_AW(LPMIDIINCAPS2)
+
/* It seems that Win32 has a slightly different structure than Win 16.
* sigh....
*/
typedef struct midihdr_tag {
- LPSTR lpData; /* pointer to locked data block */
- DWORD dwBufferLength; /* length of data in data block */
- DWORD dwBytesRecorded;/* used for input only */
- DWORD_PTR dwUser; /* for client's use */
- DWORD dwFlags; /* assorted flags (see defines) */
- struct midihdr_tag *lpNext; /* reserved for driver */
- DWORD reserved; /* reserved for driver */
- DWORD dwOffset; /* offset of playback in case of
- * MIDISTRM buffer */
- DWORD_PTR dwReserved[8]; /* reserved for driver */
+ LPSTR lpData;
+ DWORD dwBufferLength;
+ DWORD dwBytesRecorded;
+ DWORD_PTR dwUser;
+ DWORD dwFlags;
+ struct midihdr_tag *lpNext;
+ DWORD reserved;
+ DWORD dwOffset;
+ DWORD_PTR dwReserved[8];
} MIDIHDR, *LPMIDIHDR;
#define MHDR_DONE 0x00000001 /* done bit */
#define MHDR_INQUEUE 0x00000004 /* reserved for driver */
#define MHDR_ISSTRM 0x00000008 /* data is sent by Stream functions */
-typedef struct {
+typedef struct midiproptempo_tag {
DWORD cbStruct;
DWORD dwTempo;
} MIDIPROPTEMPO, *LPMIDIPROPTEMPO;
-typedef struct {
+typedef struct midiproptimediv_tag {
DWORD cbStruct;
DWORD dwTimeDiv;
} MIDIPROPTIMEDIV, *LPMIDIPROPTIMEDIV;
#define MIDIPROP_TEMPO 0x00000002
#define MIDIPROP_TIMEDIV 0x00000001
-typedef struct {
+typedef struct midievent_tag {
DWORD dwDeltaTime; /* Time, in MIDI ticks, between the previous
* event and the current event. */
DWORD dwStreamID; /* Reserved; must be zero. */
#define MEVT_VERSION ((BYTE)0x84)
UINT WINAPI midiOutGetNumDevs(void);
-UINT WINAPI midiOutGetDevCapsA(UINT,LPMIDIOUTCAPSA,UINT);
-UINT WINAPI midiOutGetDevCapsW(UINT,LPMIDIOUTCAPSW,UINT);
+UINT WINAPI midiOutGetDevCapsA(UINT_PTR,LPMIDIOUTCAPSA,UINT);
+UINT WINAPI midiOutGetDevCapsW(UINT_PTR,LPMIDIOUTCAPSW,UINT);
#define midiOutGetDevCaps WINELIB_NAME_AW(midiOutGetDevCaps)
-UINT WINAPI midiOutGetVolume(UINT,DWORD*);
-UINT WINAPI midiOutSetVolume(UINT,DWORD);
+UINT WINAPI midiOutGetVolume(HMIDIOUT,DWORD*);
+UINT WINAPI midiOutSetVolume(HMIDIOUT,DWORD);
UINT WINAPI midiOutGetErrorTextA(UINT,LPSTR,UINT);
UINT WINAPI midiOutGetErrorTextW(UINT,LPWSTR,UINT);
#define midiOutGetErrorText WINELIB_NAME_AW(midiOutGetErrorText)
-UINT WINAPI midiOutOpen(HMIDIOUT*,UINT,DWORD,DWORD,DWORD);
+UINT WINAPI midiOutOpen(LPHMIDIOUT,UINT,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI midiOutClose(HMIDIOUT);
UINT WINAPI midiOutPrepareHeader(HMIDIOUT,MIDIHDR*,UINT);
UINT WINAPI midiOutUnprepareHeader(HMIDIOUT,MIDIHDR*,UINT);
UINT WINAPI midiOutCachePatches(HMIDIOUT,UINT,WORD*,UINT);
UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT,UINT,WORD*,UINT);
UINT WINAPI midiOutGetID(HMIDIOUT,UINT*);
-DWORD WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD,DWORD);
+UINT WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD_PTR,DWORD_PTR);
UINT WINAPI midiInGetNumDevs(void);
-UINT WINAPI midiInGetDevCapsA(UINT,LPMIDIINCAPSA,UINT);
-UINT WINAPI midiInGetDevCapsW(UINT,LPMIDIINCAPSW,UINT);
+UINT WINAPI midiInGetDevCapsA(UINT_PTR,LPMIDIINCAPSA,UINT);
+UINT WINAPI midiInGetDevCapsW(UINT_PTR,LPMIDIINCAPSW,UINT);
#define midiInGetDevCaps WINELIB_NAME_AW(midiInGetDevCaps)
UINT WINAPI midiInGetErrorTextA(UINT,LPSTR,UINT);
UINT WINAPI midiInGetErrorTextW(UINT,LPWSTR,UINT);
#define midiInGetErrorText WINELIB_NAME_AW(midiInGetErrorText)
-UINT WINAPI midiInOpen(HMIDIIN*,UINT,DWORD,DWORD,DWORD);
+UINT WINAPI midiInOpen(LPHMIDIIN,UINT,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI midiInClose(HMIDIIN);
UINT WINAPI midiInPrepareHeader(HMIDIIN,MIDIHDR*,UINT);
UINT WINAPI midiInUnprepareHeader(HMIDIIN,MIDIHDR*,UINT);
UINT WINAPI midiInStop(HMIDIIN);
UINT WINAPI midiInReset(HMIDIIN);
UINT WINAPI midiInGetID(HMIDIIN,UINT*);
-DWORD WINAPI midiInMessage(HMIDIIN,UINT,DWORD,DWORD);
+UINT WINAPI midiInMessage(HMIDIIN,UINT,DWORD_PTR,DWORD_PTR);
MMRESULT WINAPI midiStreamClose(HMIDISTRM hms);
-MMRESULT WINAPI midiStreamOpen(HMIDISTRM* phms, LPUINT uDeviceID, DWORD cMidi,
- DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);
+MMRESULT WINAPI midiStreamOpen(LPHMIDISTRM,LPUINT,DWORD,DWORD_PTR,DWORD_PTR,DWORD);
MMRESULT WINAPI midiStreamOut(HMIDISTRM hms, LPMIDIHDR lpMidiHdr, UINT cbMidiHdr);
MMRESULT WINAPI midiStreamPause(HMIDISTRM hms);
MMRESULT WINAPI midiStreamPosition(HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt);
#define AUX_MAPPER (-1)
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- CHAR szPname[MAXPNAMELEN]; /* product name (NULL terminated string) */
- WORD wTechnology; /* type of device */
- WORD wReserved1; /* padding */
- DWORD dwSupport; /* functionality supported by driver */
+typedef struct tagAUXCAPSA {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ WORD wTechnology;
+ WORD wReserved1;
+ DWORD dwSupport;
} AUXCAPSA, *LPAUXCAPSA;
-typedef struct {
- WORD wMid; /* manufacturer ID */
- WORD wPid; /* product ID */
- MMVERSION vDriverVersion; /* version of the driver */
- WCHAR szPname[MAXPNAMELEN]; /* product name (NULL terminated string) */
- WORD wTechnology; /* type of device */
- WORD wReserved1; /* padding */
- DWORD dwSupport; /* functionality supported by driver */
+typedef struct tagAUXCAPSW {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ WORD wTechnology;
+ WORD wReserved1;
+ DWORD dwSupport;
} AUXCAPSW, *LPAUXCAPSW;
DECL_WINELIB_TYPE_AW(AUXCAPS)
DECL_WINELIB_TYPE_AW(LPAUXCAPS)
+typedef struct tagAUXCAPS2A {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ WORD wTechnology;
+ WORD wReserved1;
+ DWORD dwSupport;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} AUXCAPS2A, *LPAUXCAPS2A;
+
+typedef struct tagAUXCAPS2W {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ WORD wTechnology;
+ WORD wReserved1;
+ DWORD dwSupport;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} AUXCAPS2W, *LPAUXCAPS2W;
+
+DECL_WINELIB_TYPE_AW(AUXCAPS2)
+DECL_WINELIB_TYPE_AW(LPAUXCAPS2)
+
#define AUXCAPS_CDAUDIO 1 /* audio from internal CD-ROM drive */
#define AUXCAPS_AUXIN 2 /* audio from auxiliary input jacks */
#define AUXCAPS_LRVOLUME 0x0002 /* separate left-right volume control */
UINT WINAPI auxGetNumDevs(void);
-UINT WINAPI auxGetDevCapsA(UINT,LPAUXCAPSA,UINT);
-UINT WINAPI auxGetDevCapsW(UINT,LPAUXCAPSW,UINT);
+UINT WINAPI auxGetDevCapsA(UINT_PTR,LPAUXCAPSA,UINT);
+UINT WINAPI auxGetDevCapsW(UINT_PTR,LPAUXCAPSW,UINT);
#define auxGetDevCaps WINELIB_NAME_AW(auxGetDevCaps)
UINT WINAPI auxSetVolume(UINT,DWORD);
UINT WINAPI auxGetVolume(UINT,LPDWORD);
-DWORD WINAPI auxOutMessage(UINT,UINT,DWORD,DWORD);
+UINT WINAPI auxOutMessage(UINT,UINT,DWORD_PTR,DWORD_PTR);
#define TIMERR_NOERROR (0) /* no error */
#define TIMERR_NOCANDO (TIMERR_BASE+1) /* request not completed */
#define TIMERR_STRUCT (TIMERR_BASE+33) /* time struct size */
-typedef void (CALLBACK *LPTIMECALLBACK)(UINT uTimerID, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
+typedef void (CALLBACK *LPTIMECALLBACK)(UINT,UINT,DWORD_PTR,DWORD_PTR,DWORD_PTR);
#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_KILL_SYNCHRONOUS 0x0100
-typedef struct {
+typedef struct timecaps_tag {
UINT wPeriodMin;
UINT wPeriodMax;
} TIMECAPS, *LPTIMECAPS;
MMRESULT WINAPI timeGetSystemTime(LPMMTIME,UINT);
DWORD WINAPI timeGetTime(void); /* same for win32/win16 */
-MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD,UINT);
+MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD_PTR,UINT);
MMRESULT WINAPI timeKillEvent(UINT);
MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS,UINT);
MMRESULT WINAPI timeBeginPeriod(UINT);
#define JOY_CAL_READUONLY 0x04000000
#define JOY_CAL_READVONLY 0x08000000
-typedef struct {
+typedef struct tagJOYCAPSA {
WORD wMid;
WORD wPid;
CHAR szPname[MAXPNAMELEN];
CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME];
} JOYCAPSA, *LPJOYCAPSA;
-typedef struct {
+typedef struct tagJOYCAPSW {
WORD wMid;
WORD wPid;
WCHAR szPname[MAXPNAMELEN];
DECL_WINELIB_TYPE_AW(JOYCAPS)
DECL_WINELIB_TYPE_AW(LPJOYCAPS)
-typedef struct {
+typedef struct tagJOYCAPS2A {
+ WORD wMid;
+ WORD wPid;
+ CHAR szPname[MAXPNAMELEN];
+ UINT wXmin;
+ UINT wXmax;
+ UINT wYmin;
+ UINT wYmax;
+ UINT wZmin;
+ UINT wZmax;
+ UINT wNumButtons;
+ UINT wPeriodMin;
+ UINT wPeriodMax;
+ UINT wRmin;
+ UINT wRmax;
+ UINT wUmin;
+ UINT wUmax;
+ UINT wVmin;
+ UINT wVmax;
+ UINT wCaps;
+ UINT wMaxAxes;
+ UINT wNumAxes;
+ UINT wMaxButtons;
+ CHAR szRegKey[MAXPNAMELEN];
+ CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME];
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} JOYCAPS2A, *LPJOYCAPS2A;
+
+typedef struct tagJOYCAPS2W {
+ WORD wMid;
+ WORD wPid;
+ WCHAR szPname[MAXPNAMELEN];
+ UINT wXmin;
+ UINT wXmax;
+ UINT wYmin;
+ UINT wYmax;
+ UINT wZmin;
+ UINT wZmax;
+ UINT wNumButtons;
+ UINT wPeriodMin;
+ UINT wPeriodMax;
+ UINT wRmin;
+ UINT wRmax;
+ UINT wUmin;
+ UINT wUmax;
+ UINT wVmin;
+ UINT wVmax;
+ UINT wCaps;
+ UINT wMaxAxes;
+ UINT wNumAxes;
+ UINT wMaxButtons;
+ WCHAR szRegKey[MAXPNAMELEN];
+ WCHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME];
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} JOYCAPS2W, *LPJOYCAPS2W;
+DECL_WINELIB_TYPE_AW(JOYCAPS2)
+DECL_WINELIB_TYPE_AW(LPJOYCAPS2)
+
+typedef struct joyinfo_tag {
UINT wXpos;
UINT wYpos;
UINT wZpos;
UINT wButtons;
} JOYINFO, *LPJOYINFO;
-typedef struct {
- DWORD dwSize; /* size of structure */
- DWORD dwFlags; /* flags to indicate what to return */
- DWORD dwXpos; /* x position */
- DWORD dwYpos; /* y position */
- DWORD dwZpos; /* z position */
- DWORD dwRpos; /* rudder/4th axis position */
- DWORD dwUpos; /* 5th axis position */
- DWORD dwVpos; /* 6th axis position */
- DWORD dwButtons; /* button states */
- DWORD dwButtonNumber; /* current button number pressed */
- DWORD dwPOV; /* point of view state */
- DWORD dwReserved1; /* reserved for communication between winmm & driver */
- DWORD dwReserved2; /* reserved for future expansion */
+typedef struct joyinfoex_tag {
+ DWORD dwSize;
+ DWORD dwFlags;
+ DWORD dwXpos;
+ DWORD dwYpos;
+ DWORD dwZpos;
+ DWORD dwRpos;
+ DWORD dwUpos;
+ DWORD dwVpos;
+ DWORD dwButtons;
+ DWORD dwButtonNumber;
+ DWORD dwPOV;
+ DWORD dwReserved1;
+ DWORD dwReserved2;
} JOYINFOEX,*LPJOYINFOEX;
-MMRESULT WINAPI joyGetDevCapsA(UINT,LPJOYCAPSA,UINT);
-MMRESULT WINAPI joyGetDevCapsW(UINT,LPJOYCAPSW,UINT);
+MMRESULT WINAPI joyGetDevCapsA(UINT_PTR,LPJOYCAPSA,UINT);
+MMRESULT WINAPI joyGetDevCapsW(UINT_PTR,LPJOYCAPSW,UINT);
#define joyGetDevCaps WINELIB_NAME_AW(joyGetDevCaps)
UINT WINAPI joyGetNumDevs(void);
MMRESULT WINAPI joyGetPos(UINT,LPJOYINFO);
#define MIXERR_INVALVALUE (MIXERR_BASE + 2)
#define MIXERR_LASTERROR (MIXERR_BASE + 2)
-typedef struct {
+typedef struct tagMIXERCAPSA {
WORD wMid;
WORD wPid;
MMVERSION vDriverVersion;
DWORD cDestinations;
} MIXERCAPSA,*LPMIXERCAPSA;
-typedef struct {
+typedef struct tagMIXERCAPSW {
WORD wMid;
WORD wPid;
MMVERSION vDriverVersion;
DECL_WINELIB_TYPE_AW(MIXERCAPS)
DECL_WINELIB_TYPE_AW(LPMIXERCAPS)
+typedef struct tagMIXERCAPS2A {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ CHAR szPname[MAXPNAMELEN];
+ DWORD fdwSupport;
+ DWORD cDestinations;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} MIXERCAPS2A,*LPMIXERCAPS2A;
+
+typedef struct tagMIXERCAPS2W {
+ WORD wMid;
+ WORD wPid;
+ MMVERSION vDriverVersion;
+ WCHAR szPname[MAXPNAMELEN];
+ DWORD fdwSupport;
+ DWORD cDestinations;
+ GUID ManufacturerGuid;
+ GUID ProductGuid;
+ GUID NameGuid;
+} MIXERCAPS2W,*LPMIXERCAPS2W;
+
+DECL_WINELIB_TYPE_AW(MIXERCAPS2)
+DECL_WINELIB_TYPE_AW(LPMIXERCAPS2)
+
#define MIXER_SHORT_NAME_CHARS 16
#define MIXER_LONG_NAME_CHARS 64
#define MIXERLINE_TARGETTYPE_MIDIIN 4
#define MIXERLINE_TARGETTYPE_AUX 5
-typedef struct {
+typedef struct tagMIXERLINEA {
DWORD cbStruct;
DWORD dwDestination;
DWORD dwSource;
} Target;
} MIXERLINEA, *LPMIXERLINEA;
-typedef struct {
+typedef struct tagMIXERLINEW {
DWORD cbStruct;
DWORD dwDestination;
DWORD dwSource;
#define MIXERCONTROL_CONTROLTYPE_MONO (MIXERCONTROL_CONTROLTYPE_BOOLEAN + 3)
#define MIXERCONTROL_CONTROLTYPE_LOUDNESS (MIXERCONTROL_CONTROLTYPE_BOOLEAN + 4)
#define MIXERCONTROL_CONTROLTYPE_STEREOENH (MIXERCONTROL_CONTROLTYPE_BOOLEAN + 5)
+#define MIXERCONTROL_CONTROLTYPE_BASS_BOOST (MIXERCONTROL_CONTROLTYPE_BOOLEAN + 0x00002277)
#define MIXERCONTROL_CONTROLTYPE_BUTTON (MIXERCONTROL_CT_CLASS_SWITCH | MIXERCONTROL_CT_SC_SWITCH_BUTTON | MIXERCONTROL_CT_UNITS_BOOLEAN)
#define MIXERCONTROL_CONTROLTYPE_DECIBELS (MIXERCONTROL_CT_CLASS_NUMBER | MIXERCONTROL_CT_UNITS_DECIBELS)
#define MIXERCONTROL_CONTROLTYPE_SIGNED (MIXERCONTROL_CT_CLASS_NUMBER | MIXERCONTROL_CT_UNITS_SIGNED)
#define MIXERCONTROL_CONTROLTYPE_MILLITIME (MIXERCONTROL_CT_CLASS_TIME | MIXERCONTROL_CT_SC_TIME_MILLISECS | MIXERCONTROL_CT_UNITS_UNSIGNED)
-typedef struct {
+typedef struct tagMIXERCONTROLA {
DWORD cbStruct;
DWORD dwControlID;
DWORD dwControlType;
} Metrics;
} MIXERCONTROLA, *LPMIXERCONTROLA;
-typedef struct {
+typedef struct MIXERCONTROLW {
DWORD cbStruct;
DWORD dwControlID;
DWORD dwControlType;
DECL_WINELIB_TYPE_AW(MIXERCONTROL)
DECL_WINELIB_TYPE_AW(LPMIXERCONTROL)
-typedef struct {
+typedef struct tagMIXERLINECONTROLSA {
DWORD cbStruct;
DWORD dwLineID;
union {
LPMIXERCONTROLA pamxctrl;
} MIXERLINECONTROLSA, *LPMIXERLINECONTROLSA;
-typedef struct {
+typedef struct tagMIXERLINECONTROLSW {
DWORD cbStruct;
DWORD dwLineID;
union {
DECL_WINELIB_TYPE_AW(MIXERLINECONTROLS)
DECL_WINELIB_TYPE_AW(LPMIXERLINECONTROLS)
-typedef struct {
+typedef struct tMIXERCONTROLDETAILS {
DWORD cbStruct;
DWORD dwControlID;
DWORD cChannels;
LPVOID paDetails;
} MIXERCONTROLDETAILS,*LPMIXERCONTROLDETAILS;
-typedef struct {
+typedef struct tagMIXERCONTROLDETAILS_LISTTEXTA {
DWORD dwParam1;
DWORD dwParam2;
CHAR szName[MIXER_LONG_NAME_CHARS];
} MIXERCONTROLDETAILS_LISTTEXTA,*LPMIXERCONTROLDETAILS_LISTTEXTA;
-typedef struct {
+typedef struct tagMIXERCONTROLDETAILS_LISTTEXTW {
DWORD dwParam1;
DWORD dwParam2;
WCHAR szName[MIXER_LONG_NAME_CHARS];
#define MIXER_SETCONTROLDETAILSF_QUERYMASK 0x0000000FL
UINT WINAPI mixerGetNumDevs(void);
-UINT WINAPI mixerOpen(LPHMIXER,UINT,DWORD,DWORD,DWORD);
+UINT WINAPI mixerOpen(LPHMIXER,UINT,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI mixerClose(HMIXER);
-UINT WINAPI mixerMessage(HMIXER,UINT,DWORD,DWORD);
-UINT WINAPI mixerGetDevCapsA(UINT,LPMIXERCAPSA,UINT);
-UINT WINAPI mixerGetDevCapsW(UINT,LPMIXERCAPSW,UINT);
+DWORD WINAPI mixerMessage(HMIXER,UINT,DWORD_PTR,DWORD_PTR);
+UINT WINAPI mixerGetDevCapsA(UINT_PTR,LPMIXERCAPSA,UINT);
+UINT WINAPI mixerGetDevCapsW(UINT_PTR,LPMIXERCAPSW,UINT);
#define mixerGetDevCaps WINELIB_NAME_AW(mixerGetDevCaps)
UINT WINAPI mixerGetLineInfoA(HMIXEROBJ,LPMIXERLINEA,DWORD);
UINT WINAPI mixerGetLineInfoW(HMIXEROBJ,LPMIXERLINEW,DWORD);
#define MMIOERR_CANNOTEXPAND (MMIOERR_BASE + 8) /* cannot expand file */
#define MMIOERR_CHUNKNOTFOUND (MMIOERR_BASE + 9) /* chunk not found */
#define MMIOERR_UNBUFFERED (MMIOERR_BASE + 10) /* file is unbuffered */
+#define MMIOERR_PATHNOTFOUND (MMIOERR_BASE + 11)
+#define MMIOERR_ACCESSDENIED (MMIOERR_BASE + 12)
+#define MMIOERR_SHARINGVIOLATION (MMIOERR_BASE + 13)
+#define MMIOERR_NETWORKERROR (MMIOERR_BASE + 14)
+#define MMIOERR_TOOMANYOPENFILES (MMIOERR_BASE + 15)
+#define MMIOERR_INVALIDFILE (MMIOERR_BASE + 16)
#define CFSEPCHAR '+' /* compound file name separator char. */
typedef LRESULT (CALLBACK *LPMMIOPROC) (LPSTR lpmmioinfo, UINT uMessage,
LPARAM lParam1, LPARAM lParam2);
-typedef struct {
+typedef struct _MMIOINFO {
DWORD dwFlags;
FOURCC fccIOProc;
LPMMIOPROC pIOProc;
#define mmioOpen WINELIB_NAME_AW(mmioOpen)
MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
- MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
+ const MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
MMRESULT WINAPI mmioRenameW(LPCWSTR szFileName, LPCWSTR szNewFileName,
- MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
+ const MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
#define mmioRename WINELIB_NAME_AW(mmioRename)
MMRESULT WINAPI mmioClose(HMMIO,UINT);
typedef UINT (CALLBACK *YIELDPROC)(MCIDEVICEID,DWORD);
-DWORD WINAPI mciSendCommandA(UINT,UINT,DWORD,DWORD);
-DWORD WINAPI mciSendCommandW(UINT,UINT,DWORD,DWORD);
+BOOL WINAPI mciExecute(LPCSTR);
+DWORD WINAPI mciSendCommandA(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
+DWORD WINAPI mciSendCommandW(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
#define mciSendCommand WINELIB_NAME_AW(mciSendCommand)
DWORD WINAPI mciSendStringA(LPCSTR,LPSTR,UINT,HWND);
-DWORD WINAPI mciSendStringW(LPCWSTR,LPSTR,UINT,HWND);
+DWORD WINAPI mciSendStringW(LPCWSTR,LPWSTR,UINT,HWND);
#define mciSendString WINELIB_NAME_AW(mciSendString)
-UINT WINAPI mciGetDeviceIDA(LPCSTR);
-UINT WINAPI mciGetDeviceIDW(LPCWSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDA(LPCSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDW(LPCWSTR);
#define mciGetDeviceID WINELIB_NAME_AW(mciGetDeviceID)
-BOOL WINAPI mciGetErrorStringA(DWORD,LPSTR,UINT);
-BOOL WINAPI mciGetErrorStringW(DWORD,LPWSTR,UINT);
+MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA(DWORD,LPCSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW(DWORD,LPCWSTR);
+#define mciGetDeviceIDFromElementID WINELIB_NAME_AW(mciGetDeviceIDFromElementID)
+BOOL WINAPI mciGetErrorStringA(MCIERROR,LPSTR,UINT);
+BOOL WINAPI mciGetErrorStringW(MCIERROR,LPWSTR,UINT);
#define mciGetErrorString WINELIB_NAME_AW(mciGetErrorString)
-BOOL WINAPI mciSetYieldProc(UINT,YIELDPROC,DWORD);
-HTASK WINAPI mciGetCreatorTask(UINT);
-YIELDPROC WINAPI mciGetYieldProc(UINT,DWORD*);
+BOOL WINAPI mciSetYieldProc(MCIDEVICEID,YIELDPROC,DWORD);
+HTASK WINAPI mciGetCreatorTask(MCIDEVICEID);
+YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID,DWORD*);
#define MCIERR_INVALID_DEVICE_ID (MCIERR_BASE + 1)
#define MCIERR_UNRECOGNIZED_KEYWORD (MCIERR_BASE + 3)
#define MCI_LOAD_FILE 0x00000100L
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_GENERIC_PARMS {
+ DWORD_PTR dwCallback;
} MCI_GENERIC_PARMS, *LPMCI_GENERIC_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OPEN_PARMSA {
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
- LPSTR lpstrDeviceType;
- LPSTR lpstrElementName;
- LPSTR lpstrAlias;
+ LPCSTR lpstrDeviceType;
+ LPCSTR lpstrElementName;
+ LPCSTR lpstrAlias;
} MCI_OPEN_PARMSA, *LPMCI_OPEN_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OPEN_PARMSW {
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
- LPWSTR lpstrDeviceType;
- LPWSTR lpstrElementName;
- LPWSTR lpstrAlias;
+ LPCWSTR lpstrDeviceType;
+ LPCWSTR lpstrElementName;
+ LPCWSTR lpstrAlias;
} MCI_OPEN_PARMSW, *LPMCI_OPEN_PARMSW;
DECL_WINELIB_TYPE_AW(MCI_OPEN_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OPEN_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_PLAY_PARMS{
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_PLAY_PARMS, *LPMCI_PLAY_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_SEEK_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwTo;
} MCI_SEEK_PARMS, *LPMCI_SEEK_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_STATUS_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwReturn;
DWORD dwItem;
DWORD dwTrack;
} MCI_STATUS_PARMS, *LPMCI_STATUS_PARMS;
-typedef struct {
- DWORD dwCallback;
- LPSTR lpstrReturn;
- DWORD dwRetSize;
+typedef struct tagMCI_INFO_PARMSA {
+ DWORD_PTR dwCallback;
+ LPSTR lpstrReturn;
+ DWORD dwRetSize;
} MCI_INFO_PARMSA, *LPMCI_INFO_PARMSA;
-typedef struct {
- DWORD dwCallback;
- LPSTR lpstrReturn;
- DWORD dwRetSize;
+typedef struct tagMCI_INFO_PARMSW {
+ DWORD_PTR dwCallback;
+ LPWSTR lpstrReturn;
+ DWORD dwRetSize;
} MCI_INFO_PARMSW, *LPMCI_INFO_PARMSW;
DECL_WINELIB_TYPE_AW(MCI_INFO_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_INFO_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_GETDEVCAPS_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwReturn;
DWORD dwItem;
} MCI_GETDEVCAPS_PARMS, *LPMCI_GETDEVCAPS_PARMS;
-typedef struct {
- DWORD dwCallback;
- LPSTR lpstrReturn;
- DWORD dwRetSize;
- DWORD dwNumber;
- UINT wDeviceType;
+typedef struct tagMCI_SYSINFO_PARMSA {
+ DWORD_PTR dwCallback;
+ LPSTR lpstrReturn;
+ DWORD dwRetSize;
+ DWORD dwNumber;
+ UINT wDeviceType;
} MCI_SYSINFO_PARMSA, *LPMCI_SYSINFO_PARMSA;
-typedef struct {
- DWORD dwCallback;
- LPWSTR lpstrReturn;
- DWORD dwRetSize;
- DWORD dwNumber;
- UINT wDeviceType;
+typedef struct tagMCI_SYSINFO_PARMSW {
+ DWORD_PTR dwCallback;
+ LPWSTR lpstrReturn;
+ DWORD dwRetSize;
+ DWORD dwNumber;
+ UINT wDeviceType;
} MCI_SYSINFO_PARMSW, *LPMCI_SYSINFO_PARMSW;
DECL_WINELIB_TYPE_AW(MCI_SYSINFO_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_SYSINFO_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_SET_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
} MCI_SET_PARMS, *LPMCI_SET_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_BREAK_PARMS {
+ DWORD_PTR dwCallback;
INT nVirtKey;
HWND hwndBreak;
} MCI_BREAK_PARMS, *LPMCI_BREAK_PARMS;
-typedef struct {
- DWORD dwCallback;
- LPCSTR lpstrSoundName;
-} MCI_SOUND_PARMS, *LPMCI_SOUND_PARMS;
+typedef struct tagMCI_SOUND_PARMSA {
+ DWORD_PTR dwCallback;
+ LPCSTR lpstrSoundName;
+} MCI_SOUND_PARMSA, *LPMCI_SOUND_PARMSA;
-typedef struct {
- DWORD dwCallback;
- LPCSTR lpfilename;
-} MCI_SAVE_PARMS, *LPMCI_SAVE_PARMS;
+typedef struct tagMCI_SOUND_PARMSW {
+ DWORD_PTR dwCallback;
+ LPCWSTR lpstrSoundName;
+} MCI_SOUND_PARMSW, *LPMCI_SOUND_PARMSW;
-typedef struct {
- DWORD dwCallback;
+DECL_WINELIB_TYPE_AW(MCI_SOUND_PARMS)
+DECL_WINELIB_TYPE_AW(LPMCI_SOUND_PARMS)
+
+typedef struct tagMCI_SAVE_PARMSA {
+ DWORD_PTR dwCallback;
+ LPCSTR lpfilename;
+} MCI_SAVE_PARMSA, *LPMCI_SAVE_PARMSA;
+
+typedef struct tagMCI_SAVE_PARMSW {
+ DWORD_PTR dwCallback;
+ LPCWSTR lpfilename;
+} MCI_SAVE_PARMSW, *LPMCI_SAVE_PARMSW;
+
+DECL_WINELIB_TYPE_AW(MCI_SAVE_PARMS)
+DECL_WINELIB_TYPE_AW(LPMCI_SAVE_PARMS)
+
+typedef struct tagMCI_LOAD_PARMSA {
+ DWORD_PTR dwCallback;
LPCSTR lpfilename;
} MCI_LOAD_PARMSA, *LPMCI_LOAD_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_LOAD_PARMSW {
+ DWORD_PTR dwCallback;
LPCWSTR lpfilename;
} MCI_LOAD_PARMSW, *LPMCI_LOAD_PARMSW;
DECL_WINELIB_TYPE_AW(MCI_LOAD_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_LOAD_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_RECORD_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_RECORD_PARMS, *LPMCI_RECORD_PARMS;
#define MCI_VD_ESCAPE_STRING 0x00000100L
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_VD_PLAY_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
DWORD dwSpeed;
} MCI_VD_PLAY_PARMS, *LPMCI_VD_PLAY_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_VD_STEP_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwFrames;
} MCI_VD_STEP_PARMS, *LPMCI_VD_STEP_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_VD_ESCAPE_PARMSA {
+ DWORD_PTR dwCallback;
LPCSTR lpstrCommand;
} MCI_VD_ESCAPE_PARMSA, *LPMCI_VD_ESCAPE_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_VD_ESCAPE_PARMSW {
+ DWORD_PTR dwCallback;
LPCWSTR lpstrCommand;
} MCI_VD_ESCAPE_PARMSW, *LPMCI_VD_ESCAPE_PARMSW;
#define MCI_WAVE_GETDEVCAPS_INPUTS 0x00004001L
#define MCI_WAVE_GETDEVCAPS_OUTPUTS 0x00004002L
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_WAVE_OPEN_PARMSA {
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
DWORD dwBufferSeconds;
} MCI_WAVE_OPEN_PARMSA, *LPMCI_WAVE_OPEN_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_WAVE_OPEN_PARMSW {
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
DECL_WINELIB_TYPE_AW(MCI_WAVE_OPEN_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_WAVE_OPEN_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_WAVE_DELETE_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_WAVE_DELETE_PARMS, *LPMCI_WAVE_DELETE_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_WAVE_SET_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
UINT wInput;
#define MCI_SEQ_SET_MASTER 0x00080000L
#define MCI_SEQ_SET_OFFSET 0x01000000L
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_SEQ_SET_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
DWORD dwTempo;
#define MCI_ANIM_UPDATE_HDC 0x00020000L
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_ANIM_OPEN_PARMSA {
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
HWND hWndParent;
} MCI_ANIM_OPEN_PARMSA, *LPMCI_ANIM_OPEN_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_ANIM_OPEN_PARMSW {
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
DECL_WINELIB_TYPE_AW(MCI_ANIM_OPEN_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_ANIM_OPEN_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_ANIM_PLAY_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
DWORD dwSpeed;
} MCI_ANIM_PLAY_PARMS, *LPMCI_ANIM_PLAY_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_ANIM_STEP_PARMS {
+ DWORD_PTR dwCallback;
DWORD dwFrames;
} MCI_ANIM_STEP_PARMS, *LPMCI_ANIM_STEP_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_ANIM_WINDOW_PARMSA {
+ DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCSTR lpstrText;
} MCI_ANIM_WINDOW_PARMSA, *LPMCI_ANIM_WINDOW_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_ANIM_WINDOW_PARMSW {
+ DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCWSTR lpstrText;
DECL_WINELIB_TYPE_AW(MCI_ANIM_WINDOW_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_ANIM_WINDOW_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_ANIM_RECT_PARMS {
+ DWORD_PTR dwCallback;
#ifdef MCI_USE_OFFEXT
POINT ptOffset;
POINT ptExtent;
} MCI_ANIM_RECT_PARMS, *LPMCI_ANIM_RECT_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_ANIM_UPDATE_PARMS {
+ DWORD_PTR dwCallback;
RECT rc;
HDC hDC;
} MCI_ANIM_UPDATE_PARMS, *LPMCI_ANIM_UPDATE_PARMS;
#define MCI_OVLY_WHERE_FRAME 0x00080000L
#define MCI_OVLY_WHERE_VIDEO 0x00100000L
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_OPEN_PARMSA {
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
HWND hWndParent;
} MCI_OVLY_OPEN_PARMSA, *LPMCI_OVLY_OPEN_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_OPEN_PARMSW {
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
DECL_WINELIB_TYPE_AW(MCI_OVLY_OPEN_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OVLY_OPEN_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_WINDOW_PARMSA {
+ DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCSTR lpstrText;
} MCI_OVLY_WINDOW_PARMSA, *LPMCI_OVLY_WINDOW_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_WINDOW_PARMSW {
+ DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCWSTR lpstrText;
DECL_WINELIB_TYPE_AW(MCI_OVLY_WINDOW_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OVLY_WINDOW_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_RECT_PARMS {
+ DWORD_PTR dwCallback;
#ifdef MCI_USE_OFFEXT
POINT ptOffset;
POINT ptExtent;
} MCI_OVLY_RECT_PARMS, *LPMCI_OVLY_RECT_PARMS;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_SAVE_PARMSA {
+ DWORD_PTR dwCallback;
LPCSTR lpfilename;
RECT rc;
} MCI_OVLY_SAVE_PARMSA, *LPMCI_OVLY_SAVE_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_SAVE_PARMSW {
+ DWORD_PTR dwCallback;
LPCWSTR lpfilename;
RECT rc;
} MCI_OVLY_SAVE_PARMSW, *LPMCI_OVLY_SAVE_PARMSW;
DECL_WINELIB_TYPE_AW(MCI_OVLY_SAVE_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OVLY_SAVE_PARMS)
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_LOAD_PARMSA {
+ DWORD_PTR dwCallback;
LPCSTR lpfilename;
RECT rc;
} MCI_OVLY_LOAD_PARMSA, *LPMCI_OVLY_LOAD_PARMSA;
-typedef struct {
- DWORD dwCallback;
+typedef struct tagMCI_OVLY_LOAD_PARMSW {
+ DWORD_PTR dwCallback;
LPCWSTR lpfilename;
RECT rc;
} MCI_OVLY_LOAD_PARMSW, *LPMCI_OVLY_LOAD_PARMSW;
DECL_WINELIB_TYPE_AW(MCI_OVLY_LOAD_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OVLY_LOAD_PARMS)
-#include "poppack.h"
+#ifndef NEWTRANSPARENT
+#define NEWTRANSPARENT 3
+#define QUERYROPSUPPORT 40
+#endif
+
+#define SELECTDIB 41
+#define DIBINDEX(n) MAKELONG((n),0x10FF)
+
+#ifndef SC_SCREENSAVE
+#define SC_SCREENSAVE 0xf140
+#endif
+
+#include <poppack.h>
#ifdef __cplusplus
}