include/wine/mmsystem16.h

   1 /*
   2  * MMSYSTEM - Multimedia Wine Extension ... :-)
   3  *
   4  * Copyright (C) the Wine project
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifndef __WINE_WINE_MMSYSTEM16_H
  22 #define __WINE_WINE_MMSYSTEM16_H
  23
  24 #include <windef.h>
  25 #include <wine/windef16.h>
  26 #include <mmddk.h>
  27
  28 #include <pshpack1.h>
  29
  30 typedef UINT16  MMVERSION16;
  31 typedef UINT16  MCIDEVICEID16;
  32 typedef UINT16  MMRESULT16;
  33
  34 typedef struct {
  35     UINT16    wType;            /* indicates the contents of the union */
  36     union {
  37         DWORD ms;               /* milliseconds */
  38         DWORD sample;           /* samples */
  39         DWORD cb;               /* byte count */
  40         struct {                /* SMPTE */
  41             BYTE hour;          /* hours */
  42             BYTE min;           /* minutes */
  43             BYTE sec;           /* seconds */
  44             BYTE frame;         /* frames  */
  45             BYTE fps;           /* frames per second */
  46             BYTE dummy;         /* pad */
  47         } smpte;
  48         struct {                /* MIDI */
  49             DWORD songptrpos;   /* song pointer position */
  50         } midi;
  51     } u;
  52 } MMTIME16,  *LPMMTIME16;
  53
  54 typedef struct {
  55     DWORD   dwDCISize;
  56     SEGPTR  lpszDCISectionName;
  57     SEGPTR  lpszDCIAliasName;
  58 } DRVCONFIGINFO16, *LPDRVCONFIGINFO16;
  59
  60 /* GetDriverInfo16 references this structure, so this a struct defined
  61  * in the Win16 API.
  62  * GetDriverInfo has been deprecated in Win32.
  63  */
  64 typedef struct
  65 {
  66     UINT16       length;
  67     HDRVR16      hDriver;
  68     HINSTANCE16  hModule;
  69     CHAR         szAliasName[128];
  70 } DRIVERINFOSTRUCT16, *LPDRIVERINFOSTRUCT16;
  71
  72 LRESULT   WINAPI DefDriverProc16(DWORD,HDRVR16,UINT16,LPARAM,LPARAM);
  73 HDRVR16   WINAPI OpenDriver16(LPCSTR,LPCSTR,LPARAM);
  74 LRESULT   WINAPI CloseDriver16(HDRVR16,LPARAM,LPARAM);
  75 LRESULT   WINAPI SendDriverMessage16(HDRVR16,UINT16,LPARAM,LPARAM);
  76 HMODULE16 WINAPI GetDriverModuleHandle16(HDRVR16);
  77 HDRVR16   WINAPI GetNextDriver16(HDRVR16,DWORD);
  78 BOOL16    WINAPI GetDriverInfo16(HDRVR16,DRIVERINFOSTRUCT16 *);
  79
  80 typedef void (CALLBACK *LPDRVCALLBACK16) (HDRVR16,UINT16,DWORD,DWORD,DWORD);
  81 typedef LPDRVCALLBACK16 LPWAVECALLBACK16;
  82
  83 UINT16    WINAPI mmsystemGetVersion16(void);
  84 BOOL16    WINAPI sndPlaySound16(LPCSTR,UINT16);
  85
  86 typedef struct {
  87     WORD        wMid;                   /* manufacturer ID */
  88     WORD        wPid;                   /* product ID */
  89     MMVERSION16 vDriverVersion;         /* version of the driver */
  90     CHAR        szPname[MAXPNAMELEN];   /* product name (0 terminated string) */
  91     DWORD       dwFormats;              /* formats supported */
  92     WORD        wChannels;              /* number of sources supported */
  93     DWORD       dwSupport;              /* functionality supported by driver */
  94 } WAVEOUTCAPS16, *LPWAVEOUTCAPS16;
  95
  96 typedef struct {
  97     WORD        wMid;                   /* manufacturer ID */
  98     WORD        wPid;                   /* product ID */
  99     MMVERSION16 vDriverVersion;         /* version of the driver */
 100     CHAR        szPname[MAXPNAMELEN];   /* product name (0 terminated string) */
 101     DWORD       dwFormats;              /* formats supported */
 102     WORD        wChannels;              /* number of channels supported */
 103 } WAVEINCAPS16, *LPWAVEINCAPS16;
 104
 105 typedef struct {
 106         HWAVE16                 hWave;
 107         LPWAVEFORMATEX          lpFormat;
 108         DWORD                   dwCallback;
 109         DWORD                   dwInstance;
 110         UINT16                  uMappedDeviceID;
 111         DWORD                   dnDevNode;
 112 } WAVEOPENDESC16, *LPWAVEOPENDESC16;
 113
 114 UINT16    WINAPI waveOutGetNumDevs16(void);
 115 UINT16    WINAPI waveOutGetDevCaps16(UINT16,LPWAVEOUTCAPS16,UINT16);
 116 UINT16    WINAPI waveOutGetVolume16(UINT16,DWORD*);
 117 UINT16    WINAPI waveOutSetVolume16(UINT16,DWORD);
 118 UINT16    WINAPI waveOutGetErrorText16(UINT16,LPSTR,UINT16);
 119 UINT16    WINAPI waveOutOpen16(HWAVEOUT16*,UINT16,const WAVEFORMATEX *,DWORD,DWORD,DWORD);
 120 UINT16    WINAPI waveOutClose16(HWAVEOUT16);
 121 UINT16    WINAPI waveOutPrepareHeader16(HWAVEOUT16,SEGPTR,UINT16);
 122 UINT16    WINAPI waveOutUnprepareHeader16(HWAVEOUT16,SEGPTR,UINT16);
 123 UINT16    WINAPI waveOutWrite16(HWAVEOUT16,WAVEHDR*,UINT16);
 124 UINT16    WINAPI waveOutPause16(HWAVEOUT16);
 125 UINT16    WINAPI waveOutRestart16(HWAVEOUT16);
 126 UINT16    WINAPI waveOutReset16(HWAVEOUT16);
 127 UINT16    WINAPI waveOutBreakLoop16(HWAVEOUT16);
 128 UINT16    WINAPI waveOutGetPosition16(HWAVEOUT16,LPMMTIME16,UINT16);
 129 UINT16    WINAPI waveOutGetPitch16(HWAVEOUT16,DWORD*);
 130 UINT16    WINAPI waveOutSetPitch16(HWAVEOUT16,DWORD);
 131 UINT16    WINAPI waveOutGetPlaybackRate16(HWAVEOUT16,DWORD*);
 132 UINT16    WINAPI waveOutSetPlaybackRate16(HWAVEOUT16,DWORD);
 133 UINT16    WINAPI waveOutGetID16(HWAVEOUT16,UINT16*);
 134 DWORD     WINAPI waveOutMessage16(HWAVEOUT16,UINT16,DWORD,DWORD);
 135 UINT16    WINAPI waveInGetNumDevs16(void);
 136 UINT16    WINAPI waveInGetDevCaps16(UINT16,LPWAVEINCAPS16,UINT16);
 137 UINT16    WINAPI waveInGetErrorText16(UINT16,LPSTR,UINT16);
 138 UINT16    WINAPI waveInOpen16(HWAVEIN16*,UINT16,const WAVEFORMATEX *,DWORD,DWORD,DWORD);
 139 UINT16    WINAPI waveInClose16(HWAVEIN16);
 140 UINT16    WINAPI waveInPrepareHeader16(HWAVEIN16,SEGPTR,UINT16);
 141 UINT16    WINAPI waveInUnprepareHeader16(HWAVEIN16,SEGPTR,UINT16);
 142 UINT16    WINAPI waveInAddBuffer16(HWAVEIN16,WAVEHDR*,UINT16);
 143 UINT16    WINAPI waveInStart16(HWAVEIN16);
 144 UINT16    WINAPI waveInStop16(HWAVEIN16);
 145 UINT16    WINAPI waveInReset16(HWAVEIN16);
 146 UINT16    WINAPI waveInGetPosition16(HWAVEIN16,LPMMTIME16,UINT16);
 147 UINT16    WINAPI waveInGetID16(HWAVEIN16,UINT16*);
 148 DWORD     WINAPI waveInMessage16(HWAVEIN16,UINT16,DWORD,DWORD);
 149
 150 typedef LPDRVCALLBACK16 LPMIDICALLBACK16;
 151
 152 typedef struct {
 153     WORD        wMid;           /* manufacturer ID */
 154     WORD        wPid;           /* product ID */
 155     MMVERSION16 vDriverVersion; /* version of the driver */
 156     CHAR        szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
 157     WORD        wTechnology;    /* type of device */
 158     WORD        wVoices;        /* # of voices (internal synth only) */
 159     WORD        wNotes;         /* max # of notes (internal synth only) */
 160     WORD        wChannelMask;   /* channels used (internal synth only) */
 161     DWORD       dwSupport;      /* functionality supported by driver */
 162 } MIDIOUTCAPS16, *LPMIDIOUTCAPS16;
 163
 164 typedef struct {
 165     WORD        wMid;           /* manufacturer ID */
 166     WORD        wPid;           /* product ID */
 167     MMVERSION16 vDriverVersion; /* version of the driver */
 168     CHAR        szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
 169     DWORD       dwSupport;      /* included in win95 and higher */
 170 } MIDIINCAPS16, *LPMIDIINCAPS16;
 171
 172 typedef struct midihdr16_tag {
 173     LPSTR       lpData;         /* pointer to locked data block */
 174     DWORD       dwBufferLength; /* length of data in data block */
 175     DWORD       dwBytesRecorded;/* used for input only */
 176     DWORD       dwUser;         /* for client's use */
 177     DWORD       dwFlags;        /* assorted flags (see defines) */
 178     struct midihdr16_tag *lpNext;       /* reserved for driver */
 179     DWORD       reserved;       /* reserved for driver */
 180 } MIDIHDR16, *LPMIDIHDR16;
 181
 182 typedef struct {
 183     HMIDI16         hMidi;
 184     DWORD           dwCallback;
 185     DWORD           dwInstance;
 186     UINT16          reserved;
 187     DWORD           dnDevNode;
 188     DWORD           cIds;
 189     MIDIOPENSTRMID  rgIds;
 190 } MIDIOPENDESC16, *LPMIDIOPENDESC16;
 191
 192 UINT16     WINAPI midiOutGetNumDevs16(void);
 193 UINT16     WINAPI midiOutGetDevCaps16(UINT16,LPMIDIOUTCAPS16,UINT16);
 194 UINT16     WINAPI midiOutGetVolume16(UINT16,DWORD*);
 195 UINT16     WINAPI midiOutSetVolume16(UINT16,DWORD);
 196 UINT16     WINAPI midiOutGetErrorText16(UINT16,LPSTR,UINT16);
 197 UINT16     WINAPI midiOutOpen16(HMIDIOUT16*,UINT16,DWORD,DWORD,DWORD);
 198 UINT16     WINAPI midiOutClose16(HMIDIOUT16);
 199 UINT16     WINAPI midiOutPrepareHeader16(HMIDIOUT16,SEGPTR,UINT16);
 200 UINT16     WINAPI midiOutUnprepareHeader16(HMIDIOUT16,SEGPTR,UINT16);
 201 UINT16     WINAPI midiOutShortMsg16(HMIDIOUT16,DWORD);
 202 UINT16     WINAPI midiOutLongMsg16(HMIDIOUT16,MIDIHDR16*,UINT16);
 203 UINT16     WINAPI midiOutReset16(HMIDIOUT16);
 204 UINT16     WINAPI midiOutCachePatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
 205 UINT16     WINAPI midiOutCacheDrumPatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
 206 UINT16     WINAPI midiOutGetID16(HMIDIOUT16,UINT16*);
 207 DWORD      WINAPI midiOutMessage16(HMIDIOUT16,UINT16,DWORD,DWORD);
 208 UINT16     WINAPI midiInGetNumDevs16(void);
 209 UINT16     WINAPI midiInGetDevCaps16(UINT16,LPMIDIINCAPS16,UINT16);
 210 UINT16     WINAPI midiInGetErrorText16(UINT16,LPSTR,UINT16);
 211 UINT16     WINAPI midiInOpen16(HMIDIIN16*,UINT16,DWORD,DWORD,DWORD);
 212 UINT16     WINAPI midiInClose16(HMIDIIN16);
 213 UINT16     WINAPI midiInPrepareHeader16(HMIDIIN16,SEGPTR,UINT16);
 214 UINT16     WINAPI midiInUnprepareHeader16(HMIDIIN16,SEGPTR,UINT16);
 215 UINT16     WINAPI midiInAddBuffer16(HMIDIIN16,MIDIHDR16*,UINT16);
 216 UINT16     WINAPI midiInStart16(HMIDIIN16);
 217 UINT16     WINAPI midiInStop16(HMIDIIN16);
 218 UINT16     WINAPI midiInReset16(HMIDIIN16);
 219 UINT16     WINAPI midiInGetID16(HMIDIIN16,UINT16*);
 220 DWORD      WINAPI midiInMessage16(HMIDIIN16,UINT16,DWORD,DWORD);
 221 MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms);
 222 MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16*,LPUINT16,DWORD,DWORD,DWORD,DWORD);
 223 MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16,LPMIDIHDR16,UINT16);
 224 MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16);
 225 MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16,LPMMTIME16,UINT16);
 226 MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16,LPBYTE,DWORD);
 227 MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16);
 228 MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16);
 229
 230 typedef struct {
 231     WORD        wMid;                   /* manufacturer ID */
 232     WORD        wPid;                   /* product ID */
 233     MMVERSION16 vDriverVersion;         /* version of the driver */
 234     CHAR        szPname[MAXPNAMELEN];   /* product name (NULL terminated string) */
 235     WORD        wTechnology;            /* type of device */
 236     DWORD       dwSupport;              /* functionality supported by driver */
 237 } AUXCAPS16, *LPAUXCAPS16;
 238
 239 typedef void (CALLBACK *LPTIMECALLBACK16)(UINT16,UINT16,DWORD,DWORD,DWORD);
 240
 241 typedef struct {
 242     UINT16      wPeriodMin;     /* minimum period supported  */
 243     UINT16      wPeriodMax;     /* maximum period supported  */
 244 } TIMECAPS16,*LPTIMECAPS16;
 245
 246 typedef struct {
 247     WORD wMid;                  /* manufacturer ID */
 248     WORD wPid;                  /* product ID */
 249     char szPname[MAXPNAMELEN];  /* product name (NULL terminated string) */
 250     UINT16 wXmin;               /* minimum x position value */
 251     UINT16 wXmax;               /* maximum x position value */
 252     UINT16 wYmin;               /* minimum y position value */
 253     UINT16 wYmax;               /* maximum y position value */
 254     UINT16 wZmin;               /* minimum z position value */
 255     UINT16 wZmax;               /* maximum z position value */
 256     UINT16 wNumButtons;         /* number of buttons */
 257     UINT16 wPeriodMin;          /* minimum message period when captured */
 258     UINT16 wPeriodMax;          /* maximum message period when captured */
 259                                 /* win95,nt4 additions: */
 260     UINT16 wRmin;               /* minimum r position value */
 261     UINT16 wRmax;               /* maximum r position value */
 262     UINT16 wUmin;               /* minimum u (5th axis) position value */
 263     UINT16 wUmax;               /* maximum u (5th axis) position value */
 264     UINT16 wVmin;               /* minimum v (6th axis) position value */
 265     UINT16 wVmax;               /* maximum v (6th axis) position value */
 266     UINT16 wCaps;               /* joystick capabilities */
 267     UINT16 wMaxAxes;            /* maximum number of axes supported */
 268     UINT16 wNumAxes;            /* number of axes in use */
 269     UINT16 wMaxButtons;         /* maximum number of buttons supported */
 270     CHAR szRegKey[MAXPNAMELEN]; /* registry key */
 271     CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; /* OEM VxD in use */
 272 } JOYCAPS16, *LPJOYCAPS16;
 273
 274 typedef struct {
 275     UINT16 wXpos;                 /* x position */
 276     UINT16 wYpos;                 /* y position */
 277     UINT16 wZpos;                 /* z position */
 278     UINT16 wButtons;              /* button states */
 279 } JOYINFO16, *LPJOYINFO16;
 280
 281 typedef struct {
 282     WORD         wMid;                  /* manufacturer id */
 283     WORD         wPid;                  /* product id */
 284     MMVERSION16  vDriverVersion;        /* version of the driver */
 285     CHAR         szPname[MAXPNAMELEN];  /* product name */
 286     DWORD        fdwSupport;            /* misc. support bits */
 287     DWORD        cDestinations;         /* count of destinations */
 288 } MIXERCAPS16,*LPMIXERCAPS16;
 289
 290 typedef struct tMIXEROPENDESC16
 291 {
 292         HMIXEROBJ16             hmx;
 293         LPVOID                  pReserved0;
 294         DWORD                   dwCallback;
 295         DWORD                   dwInstance;
 296 } MIXEROPENDESC16, *LPMIXEROPENDESC16;
 297
 298 typedef struct {
 299     DWORD       cbStruct;               /* size of MIXERLINE structure */
 300     DWORD       dwDestination;          /* zero based destination index */
 301     DWORD       dwSource;               /* zero based source index (if source) */
 302     DWORD       dwLineID;               /* unique line id for mixer device */
 303     DWORD       fdwLine;                /* state/information about line */
 304     DWORD       dwUser;                 /* driver specific information */
 305     DWORD       dwComponentType;        /* component type line connects to */
 306     DWORD       cChannels;              /* number of channels line supports */
 307     DWORD       cConnections;           /* number of connections [possible] */
 308     DWORD       cControls;              /* number of controls at this line */
 309     CHAR        szShortName[MIXER_SHORT_NAME_CHARS];
 310     CHAR        szName[MIXER_LONG_NAME_CHARS];
 311     struct {
 312         DWORD   dwType;                 /* MIXERLINE_TARGETTYPE_xxxx */
 313         DWORD   dwDeviceID;             /* target device ID of device type */
 314         WORD    wMid;                   /* of target device */
 315         WORD    wPid;                   /*      " */
 316         MMVERSION16     vDriverVersion; /*      " */
 317         CHAR    szPname[MAXPNAMELEN];   /*      " */
 318     } Target;
 319 } MIXERLINE16, *LPMIXERLINE16;
 320
 321 typedef struct {
 322     DWORD               cbStruct;           /* size in bytes of MIXERCONTROL */
 323     DWORD               dwControlID;        /* unique control id for mixer device */
 324     DWORD               dwControlType;      /* MIXERCONTROL_CONTROLTYPE_xxx */
 325     DWORD               fdwControl;         /* MIXERCONTROL_CONTROLF_xxx */
 326     DWORD               cMultipleItems;     /* if MIXERCONTROL_CONTROLF_MULTIPLE set */
 327     CHAR                szShortName[MIXER_SHORT_NAME_CHARS];
 328     CHAR                szName[MIXER_LONG_NAME_CHARS];
 329     union {
 330         struct {
 331             LONG        lMinimum;       /* signed minimum for this control */
 332             LONG        lMaximum;       /* signed maximum for this control */
 333         } s;
 334         struct {
 335             DWORD       dwMinimum;      /* unsigned minimum for this control */
 336             DWORD       dwMaximum;      /* unsigned maximum for this control */
 337         } s1;
 338         DWORD           dwReserved[6];
 339     } Bounds;
 340     union {
 341         DWORD           cSteps;         /* # of steps between min & max */
 342         DWORD           cbCustomData;   /* size in bytes of custom data */
 343         DWORD           dwReserved[6];  /* !!! needed? we have cbStruct.... */
 344     } Metrics;
 345 } MIXERCONTROL16, *LPMIXERCONTROL16;
 346
 347 typedef struct {
 348     DWORD       cbStruct;       /* size in bytes of MIXERLINECONTROLS */
 349     DWORD       dwLineID;       /* line id (from MIXERLINE.dwLineID) */
 350     union {
 351         DWORD   dwControlID;    /* MIXER_GETLINECONTROLSF_ONEBYID */
 352         DWORD   dwControlType;  /* MIXER_GETLINECONTROLSF_ONEBYTYPE */
 353     } u;
 354     DWORD       cControls;      /* count of controls pmxctrl points to */
 355     DWORD       cbmxctrl;       /* size in bytes of _one_ MIXERCONTROL */
 356     SEGPTR      pamxctrl;       /* pointer to first MIXERCONTROL array */
 357 } MIXERLINECONTROLS16, *LPMIXERLINECONTROLS16;
 358
 359 typedef struct {
 360     DWORD       cbStruct;       /* size in bytes of MIXERCONTROLDETAILS */
 361     DWORD       dwControlID;    /* control id to get/set details on */
 362     DWORD       cChannels;      /* number of channels in paDetails array */
 363     union {
 364         HWND16  hwndOwner;      /* for MIXER_SETCONTROLDETAILSF_CUSTOM */
 365         DWORD   cMultipleItems; /* if _MULTIPLE, the number of items per channel */
 366     } u;
 367     DWORD       cbDetails;      /* size of _one_ details_XX struct */
 368     LPVOID      paDetails;      /* pointer to array of details_XX structs */
 369 } MIXERCONTROLDETAILS16,*LPMIXERCONTROLDETAILS16;
 370
 371 typedef struct {
 372     DWORD       dwParam1;
 373     DWORD       dwParam2;
 374     CHAR        szName[MIXER_LONG_NAME_CHARS];
 375 } MIXERCONTROLDETAILS_LISTTEXT16,*LPMIXERCONTROLDETAILS_LISTTEXT16;
 376
 377 typedef LRESULT (CALLBACK *LPMMIOPROC16)(LPSTR lpmmioinfo,UINT16 uMessage,
 378                                          LPARAM lParam1,LPARAM lParam2);
 379
 380 typedef struct {
 381         DWORD           dwFlags;        /* general status flags */
 382         FOURCC          fccIOProc;      /* pointer to I/O procedure */
 383         LPMMIOPROC16    pIOProc;        /* pointer to I/O procedure */
 384         UINT16          wErrorRet;      /* place for error to be returned */
 385         HTASK16         hTask;          /* alternate local task */
 386         /* fields maintained by MMIO functions during buffered I/O */
 387         LONG            cchBuffer;      /* size of I/O buffer (or 0L) */
 388         HPSTR           pchBuffer;      /* start of I/O buffer (or NULL) */
 389         HPSTR           pchNext;        /* pointer to next byte to read/write */
 390         HPSTR           pchEndRead;     /* pointer to last valid byte to read */
 391         HPSTR           pchEndWrite;    /* pointer to last byte to write */
 392         LONG            lBufOffset;     /* disk offset of start of buffer */
 393         /* fields maintained by I/O procedure */
 394         LONG            lDiskOffset;    /* disk offset of next read or write */
 395         DWORD           adwInfo[3];     /* data specific to type of MMIOPROC */
 396         /* other fields maintained by MMIO */
 397         DWORD           dwReserved1;    /* reserved for MMIO use */
 398         DWORD           dwReserved2;    /* reserved for MMIO use */
 399         HMMIO16         hmmio;          /* handle to open file */
 400 } MMIOINFO16, *LPMMIOINFO16;
 401
 402 typedef UINT16 (CALLBACK *YIELDPROC16)(UINT16,DWORD);
 403
 404 UINT16          WINAPI auxGetNumDevs16(void);
 405 UINT16          WINAPI auxGetDevCaps16 (UINT16,LPAUXCAPS16,UINT16);
 406 UINT16          WINAPI auxSetVolume16(UINT16,DWORD);
 407 UINT16          WINAPI auxGetVolume16(UINT16,LPDWORD);
 408 DWORD           WINAPI auxOutMessage16(UINT16,UINT16,DWORD,DWORD);
 409 MMRESULT16      WINAPI timeGetSystemTime16(LPMMTIME16,UINT16);
 410 MMRESULT16      WINAPI timeSetEvent16(UINT16,UINT16,LPTIMECALLBACK16,DWORD,UINT16);
 411 MMRESULT16      WINAPI timeKillEvent16(UINT16);
 412 MMRESULT16      WINAPI timeGetDevCaps16(LPTIMECAPS16,UINT16);
 413 MMRESULT16      WINAPI timeBeginPeriod16(UINT16);
 414 MMRESULT16      WINAPI timeEndPeriod16(UINT16);
 415 MMRESULT16      WINAPI joyGetDevCaps16 (UINT16,LPJOYCAPS16,UINT16);
 416 UINT16          WINAPI joyGetNumDevs16(void);
 417 MMRESULT16      WINAPI joyGetPos16(UINT16,LPJOYINFO16);
 418 MMRESULT16      WINAPI joyGetPosEx16(UINT16,LPJOYINFOEX);
 419 MMRESULT16      WINAPI joyGetThreshold16(UINT16,UINT16*);
 420 MMRESULT16      WINAPI joyReleaseCapture16(UINT16);
 421 MMRESULT16      WINAPI joySetCapture16(HWND16,UINT16,UINT16,BOOL16);
 422 MMRESULT16      WINAPI joySetThreshold16(UINT16,UINT16);
 423 UINT16          WINAPI mixerGetNumDevs16(void);
 424 UINT16          WINAPI mixerOpen16(LPHMIXER16,UINT16,DWORD,DWORD,DWORD);
 425 UINT16          WINAPI mixerClose16(HMIXER16);
 426 DWORD           WINAPI mixerMessage16(HMIXER16,UINT16,DWORD,DWORD);
 427 UINT16          WINAPI mixerGetDevCaps16(UINT16,LPMIXERCAPS16,UINT16);
 428 UINT16          WINAPI mixerGetLineInfo16(HMIXEROBJ16,LPMIXERLINE16,DWORD);
 429 UINT16          WINAPI mixerGetID16(HMIXEROBJ16,LPUINT16,DWORD);
 430 UINT16          WINAPI mixerGetLineControls16(HMIXEROBJ16,LPMIXERLINECONTROLS16,DWORD);
 431 UINT16          WINAPI mixerGetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
 432 UINT16          WINAPI mixerSetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
 433 LPMMIOPROC16    WINAPI mmioInstallIOProc16(FOURCC,LPMMIOPROC16,DWORD);
 434 FOURCC          WINAPI mmioStringToFOURCC16(LPCSTR,UINT16);
 435 HMMIO16         WINAPI mmioOpen16(LPSTR,MMIOINFO16*,DWORD);
 436 UINT16          WINAPI mmioRename16(LPCSTR,LPCSTR,MMIOINFO16*,DWORD);
 437 MMRESULT16      WINAPI mmioClose16(HMMIO16,UINT16);
 438 LONG            WINAPI mmioRead16(HMMIO16,HPSTR,LONG);
 439 LONG            WINAPI mmioWrite16(HMMIO16,HPCSTR,LONG);
 440 LONG            WINAPI mmioSeek16(HMMIO16,LONG,INT16);
 441 MMRESULT16      WINAPI mmioGetInfo16(HMMIO16,MMIOINFO16*,UINT16);
 442 MMRESULT16      WINAPI mmioSetInfo16(HMMIO16,const MMIOINFO16*,UINT16);
 443 UINT16          WINAPI mmioSetBuffer16(HMMIO16,LPSTR,LONG,UINT16);
 444 UINT16          WINAPI mmioFlush16(HMMIO16,UINT16);
 445 UINT16          WINAPI mmioAdvance16(HMMIO16,MMIOINFO16*,UINT16);
 446 LRESULT         WINAPI mmioSendMessage16(HMMIO16,UINT16,LPARAM,LPARAM);
 447 UINT16          WINAPI mmioDescend16(HMMIO16,MMCKINFO*,const MMCKINFO*,UINT16);
 448 UINT16          WINAPI mmioAscend16(HMMIO16,MMCKINFO*,UINT16);
 449 UINT16          WINAPI mmioCreateChunk16(HMMIO16,MMCKINFO*,UINT16);
 450 DWORD           WINAPI mciSendCommand16(UINT16,UINT16,DWORD,DWORD);
 451 DWORD           WINAPI mciSendString16(LPCSTR,LPSTR,UINT16,HWND16);
 452 UINT16          WINAPI mciGetDeviceID16(LPCSTR);
 453 UINT16          WINAPI mciGetDeviceIDFromElementID16(DWORD,LPCSTR);
 454 BOOL16          WINAPI mciGetErrorString16 (DWORD,LPSTR,UINT16);
 455 BOOL16          WINAPI mciSetYieldProc16(UINT16,YIELDPROC16,DWORD);
 456 HTASK16         WINAPI mciGetCreatorTask16(UINT16);
 457 YIELDPROC16     WINAPI mciGetYieldProc16(UINT16,DWORD*);
 458 DWORD           WINAPI mciGetDriverData16(UINT16 uDeviceID);
 459 BOOL16          WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD dwData);
 460 UINT16          WINAPI mciDriverYield16(UINT16 uDeviceID);
 461 BOOL16          WINAPI mciDriverNotify16(HWND16 hwndCallback, UINT16 uDeviceID,
 462                                           UINT16 uStatus);
 463 UINT16          WINAPI mciLoadCommandResource16(HINSTANCE16 hInstance,
 464                                          LPCSTR lpResName, UINT16 uType);
 465 BOOL16          WINAPI mciFreeCommandResource16(UINT16 uTable);
 466
 467 HINSTANCE16     WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD dwPmt);
 468 void            WINAPI mmTaskBlock16(HINSTANCE16 hInst);
 469 LRESULT         WINAPI mmTaskSignal16(HTASK16 ht);
 470 void            WINAPI mmTaskYield16(void);
 471 LRESULT         WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl,
 472                                          DWORD dwPmt, DWORD dwFlags);
 473 void            WINAPI mmThreadSignal16(HANDLE16 hndl);
 474 void            WINAPI mmThreadBlock16(HANDLE16 hndl);
 475 HANDLE16        WINAPI mmThreadGetTask16(HANDLE16 hndl);
 476 BOOL16          WINAPI mmThreadIsValid16(HANDLE16 hndl);
 477 BOOL16          WINAPI mmThreadIsCurrent16(HANDLE16 hndl);
 478
 479 BOOL16          WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
 480                                          WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
 481
 482 typedef struct {
 483     DWORD       dwCallback;
 484     WORD        wDeviceID;
 485     WORD        wReserved0;
 486     SEGPTR      lpstrDeviceType;
 487     SEGPTR      lpstrElementName;
 488     SEGPTR      lpstrAlias;
 489 } MCI_OPEN_PARMS16, *LPMCI_OPEN_PARMS16;
 490
 491 typedef struct {
 492     DWORD   dwCallback;
 493     SEGPTR  lpstrReturn;
 494     DWORD   dwRetSize;
 495 } MCI_INFO_PARMS16, *LPMCI_INFO_PARMS16;
 496
 497 typedef struct {
 498     DWORD       dwCallback;
 499     SEGPTR      lpstrReturn;
 500     DWORD       dwRetSize;
 501     DWORD       dwNumber;
 502     WORD        wDeviceType;
 503     WORD        wReserved0;
 504 } MCI_SYSINFO_PARMS16, *LPMCI_SYSINFO_PARMS16;
 505
 506 typedef struct {
 507     DWORD       dwCallback;
 508     UINT16      nVirtKey;
 509     WORD        wReserved0;
 510     HWND16      hwndBreak;
 511     WORD        wReserved1;
 512 } MCI_BREAK_PARMS16, *LPMCI_BREAK_PARMS16;
 513
 514 typedef struct {
 515     DWORD       dwCallback;
 516     SEGPTR      lpfilename;
 517 } MCI_LOAD_PARMS16, *LPMCI_LOAD_PARMS16;
 518
 519 typedef struct {
 520     DWORD       dwCallback;
 521     SEGPTR      lpstrSoundName;
 522 } MCI_SOUND_PARMS16, *LPMCI_SOUND_PARMS16;
 523
 524 typedef struct {
 525     DWORD       dwCallback;
 526     SEGPTR      lpstrCommand;
 527 } MCI_VD_ESCAPE_PARMS16, *LPMCI_VD_ESCAPE_PARMS16;
 528
 529 typedef struct {
 530     UINT16                      wDeviceID;              /* device ID */
 531     SEGPTR                      lpstrParams;            /* parameter string for entry in SYSTEM.INI */
 532     UINT16                      wCustomCommandTable;    /* custom command table (0xFFFF if none)
 533                                                          * filled in by the driver */
 534     UINT16                      wType;                  /* driver type (filled in by the driver) */
 535 } MCI_OPEN_DRIVER_PARMS16, *LPMCI_OPEN_DRIVER_PARMS16;
 536
 537 typedef struct {
 538     DWORD               dwCallback;
 539     MCIDEVICEID16       wDeviceID;
 540     WORD                wReserved0;
 541     SEGPTR              lpstrDeviceType;
 542     SEGPTR              lpstrElementName;
 543     SEGPTR              lpstrAlias;
 544     DWORD               dwBufferSeconds;
 545 } MCI_WAVE_OPEN_PARMS16, *LPMCI_WAVE_OPEN_PARMS16;
 546
 547 typedef struct {
 548     DWORD       dwCallback;
 549     DWORD       dwTimeFormat;
 550     DWORD       dwAudio;
 551     UINT16      wInput;
 552     UINT16      wReserved0;
 553     UINT16      wOutput;
 554     UINT16      wReserved1;
 555     UINT16      wFormatTag;
 556     UINT16      wReserved2;
 557     UINT16      nChannels;
 558     UINT16      wReserved3;
 559     DWORD       nSamplesPerSec;
 560     DWORD       nAvgBytesPerSec;
 561     UINT16      nBlockAlign;
 562     UINT16      wReserved4;
 563     UINT16      wBitsPerSample;
 564     UINT16      wReserved5;
 565 } MCI_WAVE_SET_PARMS16, * LPMCI_WAVE_SET_PARMS16;
 566
 567 typedef struct {
 568     DWORD   dwCallback;
 569     UINT16  wDeviceID;
 570     UINT16  wReserved0;
 571     SEGPTR  lpstrDeviceType;
 572     SEGPTR  lpstrElementName;
 573     SEGPTR  lpstrAlias;
 574     DWORD   dwStyle;
 575     HWND16  hWndParent;
 576     UINT16  wReserved1;
 577 } MCI_ANIM_OPEN_PARMS16, *LPMCI_ANIM_OPEN_PARMS16;
 578
 579 typedef struct {
 580     DWORD       dwCallback;
 581     HWND16      hWnd;
 582     WORD        wReserved1;
 583     WORD        nCmdShow;
 584     WORD        wReserved2;
 585     SEGPTR      lpstrText;
 586 } MCI_ANIM_WINDOW_PARMS16, *LPMCI_ANIM_WINDOW_PARMS16;
 587
 588 typedef struct {
 589     DWORD   dwCallback;
 590 #ifdef MCI_USE_OFFEXT
 591     POINT16 ptOffset;
 592     POINT16 ptExtent;
 593 #else   /* ifdef MCI_USE_OFFEXT */
 594     RECT16  rc;
 595 #endif  /* ifdef MCI_USE_OFFEXT */
 596 } MCI_ANIM_RECT_PARMS16, *LPMCI_ANIM_RECT_PARMS16;
 597
 598 typedef struct {
 599     DWORD   dwCallback;
 600     RECT16  rc;
 601     HDC16   hDC;
 602 } MCI_ANIM_UPDATE_PARMS16, *LPMCI_ANIM_UPDATE_PARMS16;
 603
 604 typedef struct {
 605     DWORD               dwCallback;
 606     MCIDEVICEID16       wDeviceID;
 607     WORD                wReserved0;
 608     SEGPTR              lpstrDeviceType;
 609     SEGPTR              lpstrElementName;
 610     SEGPTR              lpstrAlias;
 611     DWORD               dwStyle;
 612     HWND16              hWndParent;
 613     WORD                wReserved1;
 614 } MCI_OVLY_OPEN_PARMS16, *LPMCI_OVLY_OPEN_PARMS16;
 615
 616 typedef struct {
 617     DWORD       dwCallback;
 618     HWND16      hWnd;
 619     WORD        wReserved1;
 620     UINT16      nCmdShow;
 621     WORD        wReserved2;
 622     SEGPTR      lpstrText;
 623 } MCI_OVLY_WINDOW_PARMS16, *LPMCI_OVLY_WINDOW_PARMS16;
 624
 625 typedef struct {
 626     DWORD   dwCallback;
 627 #ifdef MCI_USE_OFFEXT
 628     POINT16 ptOffset;
 629     POINT16 ptExtent;
 630 #else   /* ifdef MCI_USE_OFFEXT */
 631     RECT16  rc;
 632 #endif  /* ifdef MCI_USE_OFFEXT */
 633 } MCI_OVLY_RECT_PARMS16, *LPMCI_OVLY_RECT_PARMS16;
 634
 635 typedef struct {
 636     DWORD   dwCallback;
 637     SEGPTR  lpfilename;
 638     RECT16  rc;
 639 } MCI_OVLY_SAVE_PARMS16, *LPMCI_OVLY_SAVE_PARMS16;
 640
 641 typedef struct {
 642     DWORD       dwCallback;
 643     SEGPTR      lpfilename;
 644     RECT16      rc;
 645 } MCI_OVLY_LOAD_PARMS16, *LPMCI_OVLY_LOAD_PARMS16;
 646
 647 /* from digitalv / 16 bit */
 648 typedef struct {
 649     DWORD   dwCallback;
 650     RECT16  rc;
 651 } MCI_DGV_RECT_PARMS16, *LPMCI_DGV_RECT_PARMS16;
 652
 653 typedef struct {
 654     DWORD   dwCallback;
 655     SEGPTR  lpstrFileName;
 656     RECT16  rc;
 657 } MCI_DGV_CAPTURE_PARMS16, *LPMCI_DGV_CAPTURE_PARMS16;
 658
 659 typedef struct {
 660     DWORD   dwCallback;
 661     DWORD   dwFrom;
 662     DWORD   dwTo;
 663     RECT16  rc;
 664     DWORD   dwAudioStream;
 665     DWORD   dwVideoStream;
 666 } MCI_DGV_COPY_PARMS16, *LPMCI_DGV_COPY_PARMS16;
 667
 668 typedef struct {
 669     DWORD   dwCallback;
 670     DWORD   dwFrom;
 671     DWORD   dwTo;
 672     RECT16  rc;
 673     DWORD   dwAudioStream;
 674     DWORD   dwVideoStream;
 675 } MCI_DGV_CUT_PARMS16, * LPMCI_DGV_CUT_PARMS16;
 676
 677 typedef struct {
 678     DWORD   dwCallback;
 679     DWORD   dwFrom;
 680     DWORD   dwTo;
 681     RECT16  rc;
 682     DWORD   dwAudioStream;
 683     DWORD   dwVideoStream;
 684 } MCI_DGV_DELETE_PARMS16, * LPMCI_DGV_DELETE_PARMS16;
 685
 686 typedef MCI_DGV_RECT_PARMS16 MCI_DGV_FREEZE_PARMS16, * LPMCI_DGV_FREEZE_PARMS16;
 687
 688 typedef struct  {
 689     DWORD   dwCallback;
 690     SEGPTR  lpstrReturn;
 691     DWORD   dwRetSize;
 692     DWORD   dwItem;
 693 } MCI_DGV_INFO_PARMS16, * LPMCI_DGV_INFO_PARMS16;
 694
 695 typedef struct {
 696     DWORD   dwCallback;
 697     SEGPTR  lpstrReturn;
 698     DWORD   dwLength;
 699     DWORD   dwNumber;
 700     DWORD   dwItem;
 701     SEGPTR  lpstrAlgorithm;
 702 } MCI_DGV_LIST_PARMS16, *LPMCI_DGV_LIST_PARMS16;
 703
 704 typedef MCI_LOAD_PARMS16  MCI_DGV_LOAD_PARMS16 , * LPMCI_DGV_LOAD_PARMS16;
 705
 706 typedef struct {
 707     DWORD   dwCallback;
 708     UINT16  wDeviceID;
 709     UINT16  wReserved0;
 710     SEGPTR  lpstrDeviceType;
 711     SEGPTR  lpstrElementName;
 712     SEGPTR  lpstrAlias;
 713     DWORD   dwStyle;
 714     HWND16  hWndParent;
 715     UINT16  wReserved1;
 716 } MCI_DGV_OPEN_PARMS16, *LPMCI_DGV_OPEN_PARMS16;
 717
 718 typedef struct {
 719     DWORD   dwCallback;
 720     DWORD   dwTo;
 721     RECT16  rc;
 722     DWORD   dwAudioStream;
 723     DWORD   dwVideoStream;
 724 } MCI_DGV_PASTE_PARMS16, * LPMCI_DGV_PASTE_PARMS16;
 725
 726 typedef MCI_DGV_RECT_PARMS16 MCI_DGV_PUT_PARMS16, * LPMCI_DGV_PUT_PARMS16;
 727
 728 typedef struct {
 729     DWORD       dwCallback;
 730     DWORD       dwItem;
 731     SEGPTR      lpstrName;
 732     SEGPTR      lpstrAlgorithm;
 733     DWORD       dwHandle;
 734 } MCI_DGV_QUALITY_PARMS16, *LPMCI_DGV_QUALITY_PARMS16;
 735
 736 typedef struct {
 737     DWORD   dwCallback;
 738     DWORD   dwFrom;
 739     DWORD   dwTo;
 740     RECT16  rc;
 741     DWORD   dwAudioStream;
 742     DWORD   dwVideoStream;
 743 } MCI_DGV_RECORD_PARMS16, * LPMCI_DGV_RECORD_PARMS16;
 744
 745 typedef struct {
 746     DWORD   dwCallback;
 747     SEGPTR  lpstrPath;
 748     DWORD   dwSize;
 749 } MCI_DGV_RESERVE_PARMS16, *LPMCI_DGV_RESERVE_PARMS16A;
 750
 751 typedef struct {
 752     DWORD   dwCallback;
 753     SEGPTR  lpstrFileName;
 754     RECT16  rc;
 755 } MCI_DGV_RESTORE_PARMS16, *LPMCI_DGV_RESTORE_PARMS16;
 756
 757 typedef struct {
 758     DWORD   dwCallback;
 759     SEGPTR  lpstrFileName;
 760     RECT16  rc;
 761 } MCI_DGV_SAVE_PARMS16, *LPMCI_DGV_SAVE_PARMS16;
 762
 763 typedef struct {
 764     DWORD   dwCallback;
 765     DWORD   dwItem;
 766     DWORD   dwValue;
 767     DWORD   dwOver;
 768     SEGPTR  lpstrAlgorithm;
 769     SEGPTR  lpstrQuality;
 770 } MCI_DGV_SETAUDIO_PARMS16, *LPMCI_DGV_SETAUDIO_PARMS16;
 771
 772 typedef struct {
 773     DWORD   dwCallback;
 774     DWORD   dwItem;
 775     DWORD   dwValue;
 776     DWORD   dwOver;
 777     SEGPTR  lpstrAlgorithm;
 778     SEGPTR  lpstrQuality;
 779     DWORD   dwSourceNumber;
 780 } MCI_DGV_SETVIDEO_PARMS16, *LPMCI_DGV_SETVIDEO_PARMS16;
 781
 782 typedef struct {
 783     DWORD   dwCallback;
 784     DWORD   dwReturn;
 785     DWORD   dwItem;
 786     DWORD   dwTrack;
 787     SEGPTR  lpstrDrive;
 788     DWORD   dwReference;
 789 } MCI_DGV_STATUS_PARMS16, *LPMCI_DGV_STATUS_PARMS16;
 790
 791 typedef struct {
 792     DWORD   dwCallback;
 793     RECT16  rc;
 794     HDC16   hDC;
 795     UINT16  wReserved0;
 796 } MCI_DGV_UPDATE_PARMS16, * LPMCI_DGV_UPDATE_PARMS16;
 797
 798 typedef MCI_DGV_RECT_PARMS16 MCI_DGV_UNFREEZE_PARMS16, * LPMCI_DGV_UNFREEZE_PARMS16;
 799
 800 typedef MCI_DGV_RECT_PARMS16 MCI_DGV_WHERE_PARMS16, * LPMCI_DGV_WHERE_PARMS16;
 801
 802 typedef struct {
 803     DWORD   dwCallback;
 804     HWND16  hWnd;
 805     UINT16  wReserved1;
 806     UINT16  nCmdShow;
 807     UINT16  wReserved2;
 808     SEGPTR  lpstrText;
 809 } MCI_DGV_WINDOW_PARMS16, *LPMCI_DGV_WINDOW_PARMS16;
 810
 811 #include <poppack.h>
 812
 813 #endif  /* __WINE_WINE_MMSYSTEM16_H */