d3dx8: Implement D3DXQuaternionBaryCentric.
[wine] / include / mmsystem.h
index 0ef4f80..d75062f 100644 (file)
  *
  * 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
@@ -53,11 +61,9 @@ typedef LRESULT (CALLBACK *DRIVERPROC)(DWORD,HDRVR,UINT,LPARAM,LPARAM);
 #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;
@@ -69,7 +75,7 @@ typedef UINT  MCIDEVICEID;
 #endif
 typedef        UINT    MMRESULT;
 
-typedef struct {
+typedef struct mmtime_tag {
     UINT    wType;
     union {
        DWORD ms;
@@ -89,7 +95,7 @@ typedef struct {
            DWORD songptrpos;
        } midi;
     } u;
-} MMTIME,  *LPMMTIME;
+} MMTIME, *PMMTIME, *LPMMTIME;
 
 #define TIME_MS         0x0001  /* time in milliseconds */
 #define TIME_SAMPLES    0x0002  /* number of wave samples */
@@ -131,6 +137,9 @@ typedef struct {
 
 #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
@@ -144,19 +153,29 @@ typedef struct {
 #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 */
@@ -198,37 +217,32 @@ typedef struct {
 #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 */
@@ -246,6 +260,7 @@ typedef void (CALLBACK *LPDRVCALLBACK) (HDRVR h, UINT uMessage, DWORD dwUser, DW
 
 #define MM_PC_JOYSTICK          12      /* Joystick adapter */
 
+#define MM_CREATIVE_SBP16_WAVEOUT   104 
 
 UINT           WINAPI  mmsystemGetVersion(void);
 BOOL           WINAPI  sndPlaySoundA(LPCSTR lpszSound, UINT fuSound);
@@ -293,52 +308,78 @@ typedef LPDRVCALLBACK LPWAVECALLBACK;
 #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 */
@@ -347,53 +388,88 @@ DECL_WINELIB_TYPE_AW(LPWAVEOUTCAPS)
 #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;
@@ -401,28 +477,28 @@ typedef struct {
 #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);
@@ -437,15 +513,15 @@ UINT              WINAPI  waveOutSetPitch(HWAVEOUT,DWORD);
 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);
@@ -455,15 +531,17 @@ UINT              WINAPI  waveInStop(HWAVEIN);
 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
@@ -501,33 +579,66 @@ typedef WORD *LPKEYARRAY;
 #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 */
@@ -539,39 +650,63 @@ DECL_WINELIB_TYPE_AW(LPMIDIOUTCAPS)
 #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 */
@@ -579,12 +714,12 @@ typedef struct midihdr_tag {
 #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;
@@ -594,7 +729,7 @@ typedef struct {
 #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. */
@@ -616,15 +751,15 @@ typedef struct {
 #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);
@@ -634,16 +769,16 @@ UINT              WINAPI  midiOutReset(HMIDIOUT);
 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);
@@ -652,10 +787,9 @@ UINT               WINAPI  midiInStart(HMIDIIN);
 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);
@@ -665,29 +799,58 @@ MMRESULT  WINAPI  midiStreamStop(HMIDISTRM hms);
 
 #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 */
 
@@ -695,26 +858,27 @@ DECL_WINELIB_TYPE_AW(LPAUXCAPS)
 #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;
@@ -722,7 +886,7 @@ typedef struct {
 
 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);
@@ -790,7 +954,7 @@ MMRESULT    WINAPI  timeEndPeriod(UINT);
 #define JOY_CAL_READUONLY      0x04000000
 #define JOY_CAL_READVONLY      0x08000000
 
-typedef struct {
+typedef struct tagJOYCAPSA {
     WORD wMid;
     WORD wPid;
     CHAR szPname[MAXPNAMELEN];
@@ -817,7 +981,7 @@ typedef struct {
     CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME];
 } JOYCAPSA, *LPJOYCAPSA;
 
-typedef struct {
+typedef struct tagJOYCAPSW {
     WORD wMid;
     WORD wPid;
     WCHAR szPname[MAXPNAMELEN];
@@ -846,32 +1010,94 @@ typedef struct {
 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);
@@ -887,7 +1113,7 @@ MMRESULT   WINAPI  joySetThreshold(UINT,UINT);
 #define MIXERR_INVALVALUE      (MIXERR_BASE + 2)
 #define MIXERR_LASTERROR       (MIXERR_BASE + 2)
 
-typedef struct {
+typedef struct tagMIXERCAPSA {
        WORD            wMid;
        WORD            wPid;
        MMVERSION       vDriverVersion;
@@ -896,7 +1122,7 @@ typedef struct {
        DWORD           cDestinations;
 } MIXERCAPSA,*LPMIXERCAPSA;
 
-typedef struct {
+typedef struct tagMIXERCAPSW {
        WORD            wMid;
        WORD            wPid;
        MMVERSION       vDriverVersion;
@@ -908,6 +1134,33 @@ typedef struct {
 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
 
@@ -966,7 +1219,7 @@ DECL_WINELIB_TYPE_AW(LPMIXERCAPS)
 #define        MIXERLINE_TARGETTYPE_MIDIIN     4
 #define MIXERLINE_TARGETTYPE_AUX       5
 
-typedef struct {
+typedef struct tagMIXERLINEA {
     DWORD      cbStruct;
     DWORD      dwDestination;
     DWORD      dwSource;
@@ -989,7 +1242,7 @@ typedef struct {
     } Target;
 } MIXERLINEA, *LPMIXERLINEA;
 
-typedef struct {
+typedef struct tagMIXERLINEW {
     DWORD      cbStruct;
     DWORD      dwDestination;
     DWORD      dwSource;
@@ -1064,6 +1317,7 @@ DECL_WINELIB_TYPE_AW(LPMIXERLINE)
 #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)
@@ -1085,7 +1339,7 @@ DECL_WINELIB_TYPE_AW(LPMIXERLINE)
 #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;
@@ -1111,7 +1365,7 @@ typedef struct {
     } Metrics;
 } MIXERCONTROLA, *LPMIXERCONTROLA;
 
-typedef struct {
+typedef struct MIXERCONTROLW {
     DWORD              cbStruct;
     DWORD              dwControlID;
     DWORD              dwControlType;
@@ -1140,7 +1394,7 @@ typedef struct {
 DECL_WINELIB_TYPE_AW(MIXERCONTROL)
 DECL_WINELIB_TYPE_AW(LPMIXERCONTROL)
 
-typedef struct {
+typedef struct tagMIXERLINECONTROLSA {
     DWORD      cbStruct;
     DWORD      dwLineID;
     union {
@@ -1152,7 +1406,7 @@ typedef struct {
     LPMIXERCONTROLA    pamxctrl;
 } MIXERLINECONTROLSA, *LPMIXERLINECONTROLSA;
 
-typedef struct {
+typedef struct tagMIXERLINECONTROLSW {
     DWORD      cbStruct;
     DWORD      dwLineID;
     union {
@@ -1167,7 +1421,7 @@ typedef struct {
 DECL_WINELIB_TYPE_AW(MIXERLINECONTROLS)
 DECL_WINELIB_TYPE_AW(LPMIXERLINECONTROLS)
 
-typedef struct {
+typedef struct tMIXERCONTROLDETAILS {
     DWORD      cbStruct;
     DWORD      dwControlID;
     DWORD      cChannels;
@@ -1179,13 +1433,13 @@ typedef struct {
     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];
@@ -1232,11 +1486,11 @@ typedef struct {
 #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);
@@ -1261,6 +1515,12 @@ UINT             WINAPI  mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,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. */
 
@@ -1268,7 +1528,7 @@ typedef DWORD           FOURCC;         /* a four character code */
 typedef LRESULT (CALLBACK *LPMMIOPROC)  (LPSTR lpmmioinfo, UINT uMessage,
                                         LPARAM lParam1, LPARAM lParam2);
 
-typedef struct {
+typedef struct _MMIOINFO {
         DWORD          dwFlags;
         FOURCC         fccIOProc;
         LPMMIOPROC     pIOProc;
@@ -1376,9 +1636,9 @@ HMMIO             WINAPI  mmioOpenW(LPWSTR,MMIOINFO*,DWORD);
 #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);
@@ -1397,21 +1657,25 @@ MMRESULT        WINAPI  mmioCreateChunk(HMMIO,MMCKINFO*,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)
@@ -1677,125 +1941,141 @@ YIELDPROC     WINAPI  mciGetYieldProc(UINT,DWORD*);
 
 #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;
@@ -1843,25 +2123,25 @@ typedef struct {
 
 #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;
 
@@ -1894,8 +2174,8 @@ DECL_WINELIB_TYPE_AW(LPMCI_VD_ESCAPE_PARMS)
 #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;
@@ -1903,8 +2183,8 @@ typedef struct {
        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;
@@ -1915,14 +2195,14 @@ typedef struct {
 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;
@@ -1961,8 +2241,8 @@ typedef struct {
 #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;
@@ -2021,8 +2301,8 @@ typedef struct {
 
 #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;
@@ -2031,8 +2311,8 @@ typedef struct {
        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;
@@ -2044,27 +2324,27 @@ typedef struct {
 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;
@@ -2073,8 +2353,8 @@ typedef struct {
 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;
@@ -2084,8 +2364,8 @@ typedef struct {
 } 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;
@@ -2122,8 +2402,8 @@ typedef struct {
 #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;
@@ -2132,8 +2412,8 @@ typedef struct {
        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;
@@ -2145,15 +2425,15 @@ typedef struct {
 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;
@@ -2162,8 +2442,8 @@ typedef struct {
 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;
@@ -2173,14 +2453,14 @@ typedef struct {
 } 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;
@@ -2188,14 +2468,14 @@ typedef struct {
 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;
@@ -2203,7 +2483,19 @@ typedef struct {
 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
 }