git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
  27 #include "pshpack1.h"
  28
  29 typedef UINT16  MMVERSION16;
  30 typedef UINT16  MCIDEVICEID16;
  31 typedef UINT16  MMRESULT16;
  32
  33 typedef struct {
  34     UINT16    wType;            /* indicates the contents of the union */
  35     union {
  36         DWORD ms;               /* milliseconds */
  37         DWORD sample;           /* samples */
  38         DWORD cb;               /* byte count */
  39         struct {                /* SMPTE */
  40             BYTE hour;          /* hours */
  41             BYTE min;           /* minutes */
  42             BYTE sec;           /* seconds */
  43             BYTE frame;         /* frames  */
  44             BYTE fps;           /* frames per second */
  45             BYTE dummy;         /* pad */
  46         } smpte;
  47         struct {                /* MIDI */
  48             DWORD songptrpos;   /* song pointer position */
  49         } midi;
  50     } u;
  51 } MMTIME16,  *LPMMTIME16;
  52
  53 typedef struct {
  54     DWORD   dwDCISize;
  55     SEGPTR  lpszDCISectionName;
  56     SEGPTR  lpszDCIAliasName;
  57 } DRVCONFIGINFO16, *LPDRVCONFIGINFO16;
  58
  59 /* GetDriverInfo16 references this structure, so this a struct defined
  60  * in the Win16 API.
  61  * GetDriverInfo has been deprecated in Win32.
  62  */
  63 typedef struct
  64 {
  65     UINT16       length;
  66     HDRVR16      hDriver;
  67     HINSTANCE16  hModule;
  68     CHAR         szAliasName[128];
  69 } DRIVERINFOSTRUCT16, *LPDRIVERINFOSTRUCT16;
  70
  71 LRESULT   WINAPI DefDriverProc16(DWORD,HDRVR16,UINT16,LPARAM,LPARAM);
  72 HDRVR16   WINAPI OpenDriver16(LPCSTR,LPCSTR,LPARAM);
  73 LRESULT   WINAPI CloseDriver16(HDRVR16,LPARAM,LPARAM);
  74 LRESULT   WINAPI SendDriverMessage16(HDRVR16,UINT16,LPARAM,LPARAM);
  75 HMODULE16 WINAPI GetDriverModuleHandle16(HDRVR16);
  76 HDRVR16   WINAPI GetNextDriver16(HDRVR16,DWORD);
  77 BOOL16    WINAPI GetDriverInfo16(HDRVR16,DRIVERINFOSTRUCT16 *);
  78
  79 typedef void (CALLBACK *LPDRVCALLBACK16) (HDRVR16,UINT16,DWORD,DWORD,DWORD);
  80 typedef LPDRVCALLBACK16 LPWAVECALLBACK16;
  81
  82 UINT16    WINAPI mmsystemGetVersion16(void);
  83 BOOL16    WINAPI sndPlaySound16(LPCSTR,UINT16);
  84
  85 typedef struct {
  86     WORD        wMid;                   /* manufacturer ID */
  87     WORD        wPid;                   /* product ID */
  88     MMVERSION16 vDriverVersion;         /* version of the driver */
  89     CHAR        szPname[MAXPNAMELEN];   /* product name (0 terminated string) */
  90     DWORD       dwFormats;              /* formats supported */
  91     WORD        wChannels;              /* number of sources supported */
  92     DWORD       dwSupport;              /* functionality supported by driver */
  93 } WAVEOUTCAPS16, *LPWAVEOUTCAPS16;
  94
  95 typedef struct {
  96     WORD        wMid;                   /* manufacturer ID */
  97     WORD        wPid;                   /* product ID */
  98     MMVERSION16 vDriverVersion;         /* version of the driver */
  99     CHAR        szPname[MAXPNAMELEN];   /* product name (0 terminated string) */
 100     DWORD       dwFormats;              /* formats supported */
 101     WORD        wChannels;              /* number of channels supported */
 102 } WAVEINCAPS16, *LPWAVEINCAPS16;
 103
 104 UINT16    WINAPI waveOutGetNumDevs16(void);
 105 UINT16    WINAPI waveOutGetDevCaps16(UINT16,LPWAVEOUTCAPS16,UINT16);
 106 UINT16    WINAPI waveOutGetVolume16(UINT16,DWORD*);
 107 UINT16    WINAPI waveOutSetVolume16(UINT16,DWORD);
 108 UINT16    WINAPI waveOutGetErrorText16(UINT16,LPSTR,UINT16);
 109 UINT16    WINAPI waveOutOpen16(HWAVEOUT16*,UINT16,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
 110 UINT16    WINAPI waveOutClose16(HWAVEOUT16);
 111 UINT16    WINAPI waveOutPrepareHeader16(HWAVEOUT16,SEGPTR,UINT16);
 112 UINT16    WINAPI waveOutUnprepareHeader16(HWAVEOUT16,SEGPTR,UINT16);
 113 UINT16    WINAPI waveOutWrite16(HWAVEOUT16,WAVEHDR*,UINT16);
 114 UINT16    WINAPI waveOutPause16(HWAVEOUT16);
 115 UINT16    WINAPI waveOutRestart16(HWAVEOUT16);
 116 UINT16    WINAPI waveOutReset16(HWAVEOUT16);
 117 UINT16    WINAPI waveOutBreakLoop16(HWAVEOUT16);
 118 UINT16    WINAPI waveOutGetPosition16(HWAVEOUT16,LPMMTIME16,UINT16);
 119 UINT16    WINAPI waveOutGetPitch16(HWAVEOUT16,DWORD*);
 120 UINT16    WINAPI waveOutSetPitch16(HWAVEOUT16,DWORD);
 121 UINT16    WINAPI waveOutGetPlaybackRate16(HWAVEOUT16,DWORD*);
 122 UINT16    WINAPI waveOutSetPlaybackRate16(HWAVEOUT16,DWORD);
 123 UINT16    WINAPI waveOutGetID16(HWAVEOUT16,UINT16*);
 124 DWORD     WINAPI waveOutMessage16(HWAVEOUT16,UINT16,DWORD,DWORD);
 125 UINT16    WINAPI waveInGetNumDevs16(void);
 126 UINT16    WINAPI waveInGetDevCaps16(UINT16,LPWAVEINCAPS16,UINT16);
 127 UINT16    WINAPI waveInGetErrorText16(UINT16,LPSTR,UINT16);
 128 UINT16    WINAPI waveInOpen16(HWAVEIN16*,UINT16,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
 129 UINT16    WINAPI waveInClose16(HWAVEIN16);
 130 UINT16    WINAPI waveInPrepareHeader16(HWAVEIN16,SEGPTR,UINT16);
 131 UINT16    WINAPI waveInUnprepareHeader16(HWAVEIN16,SEGPTR,UINT16);
 132 UINT16    WINAPI waveInAddBuffer16(HWAVEIN16,WAVEHDR*,UINT16);
 133 UINT16    WINAPI waveInStart16(HWAVEIN16);
 134 UINT16    WINAPI waveInStop16(HWAVEIN16);
 135 UINT16    WINAPI waveInReset16(HWAVEIN16);
 136 UINT16    WINAPI waveInGetPosition16(HWAVEIN16,LPMMTIME16,UINT16);
 137 UINT16    WINAPI waveInGetID16(HWAVEIN16,UINT16*);
 138 DWORD     WINAPI waveInMessage16(HWAVEIN16,UINT16,DWORD,DWORD);
 139
 140 typedef LPDRVCALLBACK16 LPMIDICALLBACK16;
 141
 142 typedef struct {
 143     WORD        wMid;           /* manufacturer ID */
 144     WORD        wPid;           /* product ID */
 145     MMVERSION16 vDriverVersion; /* version of the driver */
 146     CHAR        szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
 147     WORD        wTechnology;    /* type of device */
 148     WORD        wVoices;        /* # of voices (internal synth only) */
 149     WORD        wNotes;         /* max # of notes (internal synth only) */
 150     WORD        wChannelMask;   /* channels used (internal synth only) */
 151     DWORD       dwSupport;      /* functionality supported by driver */
 152 } MIDIOUTCAPS16, *LPMIDIOUTCAPS16;
 153
 154 typedef struct {
 155     WORD        wMid;           /* manufacturer ID */
 156     WORD        wPid;           /* product ID */
 157     MMVERSION16 vDriverVersion; /* version of the driver */
 158     CHAR        szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
 159     DWORD       dwSupport;      /* included in win95 and higher */
 160 } MIDIINCAPS16, *LPMIDIINCAPS16;
 161
 162 typedef struct midihdr16_tag {
 163     LPSTR       lpData;         /* pointer to locked data block */
 164     DWORD       dwBufferLength; /* length of data in data block */
 165     DWORD       dwBytesRecorded;/* used for input only */
 166     DWORD       dwUser;         /* for client's use */
 167     DWORD       dwFlags;        /* assorted flags (see defines) */
 168     struct midihdr16_tag *lpNext;       /* reserved for driver */
 169     DWORD       reserved;       /* reserved for driver */
 170 } MIDIHDR16, *LPMIDIHDR16;
 171
 172 UINT16     WINAPI midiOutGetNumDevs16(void);
 173 UINT16     WINAPI midiOutGetDevCaps16(UINT16,LPMIDIOUTCAPS16,UINT16);
 174 UINT16     WINAPI midiOutGetVolume16(UINT16,DWORD*);
 175 UINT16     WINAPI midiOutSetVolume16(UINT16,DWORD);
 176 UINT16     WINAPI midiOutGetErrorText16(UINT16,LPSTR,UINT16);
 177 UINT16     WINAPI midiOutOpen16(HMIDIOUT16*,UINT16,DWORD,DWORD,DWORD);
 178 UINT16     WINAPI midiOutClose16(HMIDIOUT16);
 179 UINT16     WINAPI midiOutPrepareHeader16(HMIDIOUT16,SEGPTR,UINT16);
 180 UINT16     WINAPI midiOutUnprepareHeader16(HMIDIOUT16,SEGPTR,UINT16);
 181 UINT16     WINAPI midiOutShortMsg16(HMIDIOUT16,DWORD);
 182 UINT16     WINAPI midiOutLongMsg16(HMIDIOUT16,MIDIHDR16*,UINT16);
 183 UINT16     WINAPI midiOutReset16(HMIDIOUT16);
 184 UINT16     WINAPI midiOutCachePatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
 185 UINT16     WINAPI midiOutCacheDrumPatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
 186 UINT16     WINAPI midiOutGetID16(HMIDIOUT16,UINT16*);
 187 DWORD      WINAPI midiOutMessage16(HMIDIOUT16,UINT16,DWORD,DWORD);
 188 UINT16     WINAPI midiInGetNumDevs16(void);
 189 UINT16     WINAPI midiInGetDevCaps16(UINT16,LPMIDIINCAPS16,UINT16);
 190 UINT16     WINAPI midiInGetErrorText16(UINT16,LPSTR,UINT16);
 191 UINT16     WINAPI midiInOpen16(HMIDIIN16*,UINT16,DWORD,DWORD,DWORD);
 192 UINT16     WINAPI midiInClose16(HMIDIIN16);
 193 UINT16     WINAPI midiInPrepareHeader16(HMIDIIN16,SEGPTR,UINT16);
 194 UINT16     WINAPI midiInUnprepareHeader16(HMIDIIN16,SEGPTR,UINT16);
 195 UINT16     WINAPI midiInAddBuffer16(HMIDIIN16,MIDIHDR16*,UINT16);
 196 UINT16     WINAPI midiInStart16(HMIDIIN16);
 197 UINT16     WINAPI midiInStop16(HMIDIIN16);
 198 UINT16     WINAPI midiInReset16(HMIDIIN16);
 199 UINT16     WINAPI midiInGetID16(HMIDIIN16,UINT16*);
 200 DWORD      WINAPI midiInMessage16(HMIDIIN16,UINT16,DWORD,DWORD);
 201 MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms);
 202 MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16*,LPUINT16,DWORD,DWORD,DWORD,DWORD);
 203 MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16,LPMIDIHDR16,UINT16);
 204 MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16);
 205 MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16,LPMMTIME16,UINT16);
 206 MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16,LPBYTE,DWORD);
 207 MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16);
 208 MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16);
 209
 210 typedef struct {
 211     WORD        wMid;                   /* manufacturer ID */
 212     WORD        wPid;                   /* product ID */
 213     MMVERSION16 vDriverVersion;         /* version of the driver */
 214     CHAR        szPname[MAXPNAMELEN];   /* product name (NULL terminated string) */
 215     WORD        wTechnology;            /* type of device */
 216     DWORD       dwSupport;              /* functionality supported by driver */
 217 } AUXCAPS16, *LPAUXCAPS16;
 218
 219 typedef void (CALLBACK *LPTIMECALLBACK16)(UINT16,UINT16,DWORD,DWORD,DWORD);
 220
 221 typedef struct {
 222     UINT16      wPeriodMin;     /* minimum period supported  */
 223     UINT16      wPeriodMax;     /* maximum period supported  */
 224 } TIMECAPS16,*LPTIMECAPS16;
 225
 226 typedef struct {
 227     WORD wMid;                  /* manufacturer ID */
 228     WORD wPid;                  /* product ID */
 229     char szPname[MAXPNAMELEN];  /* product name (NULL terminated string) */
 230     UINT16 wXmin;               /* minimum x position value */
 231     UINT16 wXmax;               /* maximum x position value */
 232     UINT16 wYmin;               /* minimum y position value */
 233     UINT16 wYmax;               /* maximum y position value */
 234     UINT16 wZmin;               /* minimum z position value */
 235     UINT16 wZmax;               /* maximum z position value */
 236     UINT16 wNumButtons;         /* number of buttons */
 237     UINT16 wPeriodMin;          /* minimum message period when captured */
 238     UINT16 wPeriodMax;          /* maximum message period when captured */
 239                                 /* win95,nt4 additions: */
 240     UINT16 wRmin;               /* minimum r position value */
 241     UINT16 wRmax;               /* maximum r position value */
 242     UINT16 wUmin;               /* minimum u (5th axis) position value */
 243     UINT16 wUmax;               /* maximum u (5th axis) position value */
 244     UINT16 wVmin;               /* minimum v (6th axis) position value */
 245     UINT16 wVmax;               /* maximum v (6th axis) position value */
 246     UINT16 wCaps;               /* joystick capabilites */
 247     UINT16 wMaxAxes;            /* maximum number of axes supported */
 248     UINT16 wNumAxes;            /* number of axes in use */
 249     UINT16 wMaxButtons;         /* maximum number of buttons supported */
 250     CHAR szRegKey[MAXPNAMELEN]; /* registry key */
 251     CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; /* OEM VxD in use */
 252 } JOYCAPS16, *LPJOYCAPS16;
 253
 254 typedef struct {
 255     UINT16 wXpos;                 /* x position */
 256     UINT16 wYpos;                 /* y position */
 257     UINT16 wZpos;                 /* z position */
 258     UINT16 wButtons;              /* button states */
 259 } JOYINFO16, *LPJOYINFO16;
 260
 261 typedef struct {
 262     WORD         wMid;                  /* manufacturer id */
 263     WORD         wPid;                  /* product id */
 264     MMVERSION16  vDriverVersion;        /* version of the driver */
 265     CHAR         szPname[MAXPNAMELEN];  /* product name */
 266     DWORD        fdwSupport;            /* misc. support bits */
 267     DWORD        cDestinations;         /* count of destinations */
 268 } MIXERCAPS16,*LPMIXERCAPS16;
 269
 270 typedef struct {
 271     DWORD       cbStruct;               /* size of MIXERLINE structure */
 272     DWORD       dwDestination;          /* zero based destination index */
 273     DWORD       dwSource;               /* zero based source index (if source) */
 274     DWORD       dwLineID;               /* unique line id for mixer device */
 275     DWORD       fdwLine;                /* state/information about line */
 276     DWORD       dwUser;                 /* driver specific information */
 277     DWORD       dwComponentType;        /* component type line connects to */
 278     DWORD       cChannels;              /* number of channels line supports */
 279     DWORD       cConnections;           /* number of connections [possible] */
 280     DWORD       cControls;              /* number of controls at this line */
 281     CHAR        szShortName[MIXER_SHORT_NAME_CHARS];
 282     CHAR        szName[MIXER_LONG_NAME_CHARS];
 283     struct {
 284         DWORD   dwType;                 /* MIXERLINE_TARGETTYPE_xxxx */
 285         DWORD   dwDeviceID;             /* target device ID of device type */
 286         WORD    wMid;                   /* of target device */
 287         WORD    wPid;                   /*      " */
 288         MMVERSION16     vDriverVersion; /*      " */
 289         CHAR    szPname[MAXPNAMELEN];   /*      " */
 290     } Target;
 291 } MIXERLINE16, *LPMIXERLINE16;
 292
 293 typedef struct {
 294     DWORD               cbStruct;           /* size in bytes of MIXERCONTROL */
 295     DWORD               dwControlID;        /* unique control id for mixer device */
 296     DWORD               dwControlType;      /* MIXERCONTROL_CONTROLTYPE_xxx */
 297     DWORD               fdwControl;         /* MIXERCONTROL_CONTROLF_xxx */
 298     DWORD               cMultipleItems;     /* if MIXERCONTROL_CONTROLF_MULTIPLE set */
 299     CHAR                szShortName[MIXER_SHORT_NAME_CHARS];
 300     CHAR                szName[MIXER_LONG_NAME_CHARS];
 301     union {
 302         struct {
 303             LONG        lMinimum;       /* signed minimum for this control */
 304             LONG        lMaximum;       /* signed maximum for this control */
 305         } DUMMYSTRUCTNAME;
 306         struct {
 307             DWORD       dwMinimum;      /* unsigned minimum for this control */
 308             DWORD       dwMaximum;      /* unsigned maximum for this control */
 309         } DUMMYSTRUCTNAME1;
 310         DWORD           dwReserved[6];
 311     } Bounds;
 312     union {
 313         DWORD           cSteps;         /* # of steps between min & max */
 314         DWORD           cbCustomData;   /* size in bytes of custom data */
 315         DWORD           dwReserved[6];  /* !!! needed? we have cbStruct.... */
 316     } Metrics;
 317 } MIXERCONTROL16, *LPMIXERCONTROL16;
 318
 319 typedef struct {
 320     DWORD       cbStruct;       /* size in bytes of MIXERLINECONTROLS */
 321     DWORD       dwLineID;       /* line id (from MIXERLINE.dwLineID) */
 322     union {
 323         DWORD   dwControlID;    /* MIXER_GETLINECONTROLSF_ONEBYID */
 324         DWORD   dwControlType;  /* MIXER_GETLINECONTROLSF_ONEBYTYPE */
 325     } DUMMYUNIONNAME;
 326     DWORD       cControls;      /* count of controls pmxctrl points to */
 327     DWORD       cbmxctrl;       /* size in bytes of _one_ MIXERCONTROL */
 328     SEGPTR      pamxctrl;       /* pointer to first MIXERCONTROL array */
 329 } MIXERLINECONTROLS16, *LPMIXERLINECONTROLS16;
 330
 331 typedef struct {
 332     DWORD       cbStruct;       /* size in bytes of MIXERCONTROLDETAILS */
 333     DWORD       dwControlID;    /* control id to get/set details on */
 334     DWORD       cChannels;      /* number of channels in paDetails array */
 335     union {
 336         HWND16  hwndOwner;      /* for MIXER_SETCONTROLDETAILSF_CUSTOM */
 337         DWORD   cMultipleItems; /* if _MULTIPLE, the number of items per channel */
 338     } DUMMYUNIONNAME;
 339     DWORD       cbDetails;      /* size of _one_ details_XX struct */
 340     LPVOID      paDetails;      /* pointer to array of details_XX structs */
 341 } MIXERCONTROLDETAILS16,*LPMIXERCONTROLDETAILS16;
 342
 343 typedef struct {
 344     DWORD       dwParam1;
 345     DWORD       dwParam2;
 346     CHAR        szName[MIXER_LONG_NAME_CHARS];
 347 } MIXERCONTROLDETAILS_LISTTEXT16,*LPMIXERCONTROLDETAILS_LISTTEXT16;
 348
 349 typedef LRESULT (CALLBACK *LPMMIOPROC16)(LPSTR lpmmioinfo,UINT16 uMessage,
 350                                          LPARAM lParam1,LPARAM lParam2);
 351
 352 typedef struct {
 353         DWORD           dwFlags;        /* general status flags */
 354         FOURCC          fccIOProc;      /* pointer to I/O procedure */
 355         LPMMIOPROC16    pIOProc;        /* pointer to I/O procedure */
 356         UINT16          wErrorRet;      /* place for error to be returned */
 357         HTASK16         hTask;          /* alternate local task */
 358         /* fields maintained by MMIO functions during buffered I/O */
 359         LONG            cchBuffer;      /* size of I/O buffer (or 0L) */
 360         HPSTR           pchBuffer;      /* start of I/O buffer (or NULL) */
 361         HPSTR           pchNext;        /* pointer to next byte to read/write */
 362         HPSTR           pchEndRead;     /* pointer to last valid byte to read */
 363         HPSTR           pchEndWrite;    /* pointer to last byte to write */
 364         LONG            lBufOffset;     /* disk offset of start of buffer */
 365         /* fields maintained by I/O procedure */
 366         LONG            lDiskOffset;    /* disk offset of next read or write */
 367         DWORD           adwInfo[3];     /* data specific to type of MMIOPROC */
 368         /* other fields maintained by MMIO */
 369         DWORD           dwReserved1;    /* reserved for MMIO use */
 370         DWORD           dwReserved2;    /* reserved for MMIO use */
 371         HMMIO16         hmmio;          /* handle to open file */
 372 } MMIOINFO16, *LPMMIOINFO16;
 373
 374 typedef UINT16 (CALLBACK *YIELDPROC16)(UINT16,DWORD);
 375
 376 UINT16          WINAPI auxGetNumDevs16(void);
 377 UINT16          WINAPI auxGetDevCaps16 (UINT16,LPAUXCAPS16,UINT16);
 378 UINT16          WINAPI auxSetVolume16(UINT16,DWORD);
 379 UINT16          WINAPI auxGetVolume16(UINT16,LPDWORD);
 380 DWORD           WINAPI auxOutMessage16(UINT16,UINT16,DWORD,DWORD);
 381 MMRESULT16      WINAPI timeGetSystemTime16(LPMMTIME16,UINT16);
 382 MMRESULT16      WINAPI timeSetEvent16(UINT16,UINT16,LPTIMECALLBACK16,DWORD,UINT16);
 383 MMRESULT16      WINAPI timeKillEvent16(UINT16);
 384 MMRESULT16      WINAPI timeGetDevCaps16(LPTIMECAPS16,UINT16);
 385 MMRESULT16      WINAPI timeBeginPeriod16(UINT16);
 386 MMRESULT16      WINAPI timeEndPeriod16(UINT16);
 387 MMRESULT16      WINAPI joyGetDevCaps16 (UINT16,LPJOYCAPS16,UINT16);
 388 UINT16          WINAPI joyGetNumDevs16(void);
 389 MMRESULT16      WINAPI joyGetPos16(UINT16,LPJOYINFO16);
 390 MMRESULT16      WINAPI joyGetPosEx16(UINT16,LPJOYINFOEX);
 391 MMRESULT16      WINAPI joyGetThreshold16(UINT16,UINT16*);
 392 MMRESULT16      WINAPI joyReleaseCapture16(UINT16);
 393 MMRESULT16      WINAPI joySetCapture16(HWND16,UINT16,UINT16,BOOL16);
 394 MMRESULT16      WINAPI joySetThreshold16(UINT16,UINT16);
 395 UINT16          WINAPI mixerGetNumDevs16(void);
 396 UINT16          WINAPI mixerOpen16(LPHMIXER16,UINT16,DWORD,DWORD,DWORD);
 397 UINT16          WINAPI mixerClose16(HMIXER16);
 398 DWORD           WINAPI mixerMessage16(HMIXER16,UINT16,DWORD,DWORD);
 399 UINT16          WINAPI mixerGetDevCaps16(UINT16,LPMIXERCAPS16,UINT16);
 400 UINT16          WINAPI mixerGetLineInfo16(HMIXEROBJ16,LPMIXERLINE16,DWORD);
 401 UINT16          WINAPI mixerGetID16(HMIXEROBJ16,LPUINT16,DWORD);
 402 UINT16          WINAPI mixerGetLineControls16(HMIXEROBJ16,LPMIXERLINECONTROLS16,DWORD);
 403 UINT16          WINAPI mixerGetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
 404 UINT16          WINAPI mixerSetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
 405 LPMMIOPROC16    WINAPI mmioInstallIOProc16(FOURCC,LPMMIOPROC16,DWORD);
 406 FOURCC          WINAPI mmioStringToFOURCC16(LPCSTR,UINT16);
 407 HMMIO16         WINAPI mmioOpen16(LPSTR,MMIOINFO16*,DWORD);
 408 UINT16          WINAPI mmioRename16(LPCSTR,LPCSTR,MMIOINFO16*,DWORD);
 409 MMRESULT16      WINAPI mmioClose16(HMMIO16,UINT16);
 410 LONG            WINAPI mmioRead16(HMMIO16,HPSTR,LONG);
 411 LONG            WINAPI mmioWrite16(HMMIO16,HPCSTR,LONG);
 412 LONG            WINAPI mmioSeek16(HMMIO16,LONG,INT16);
 413 MMRESULT16      WINAPI mmioGetInfo16(HMMIO16,MMIOINFO16*,UINT16);
 414 MMRESULT16      WINAPI mmioSetInfo16(HMMIO16,const MMIOINFO16*,UINT16);
 415 UINT16          WINAPI mmioSetBuffer16(HMMIO16,LPSTR,LONG,UINT16);
 416 UINT16          WINAPI mmioFlush16(HMMIO16,UINT16);
 417 UINT16          WINAPI mmioAdvance16(HMMIO16,MMIOINFO16*,UINT16);
 418 LONG            WINAPI mmioSendMessage16(HMMIO16,UINT16,LPARAM,LPARAM);
 419 UINT16          WINAPI mmioDescend16(HMMIO16,MMCKINFO*,const MMCKINFO*,UINT16);
 420 UINT16          WINAPI mmioAscend16(HMMIO16,MMCKINFO*,UINT16);
 421 UINT16          WINAPI mmioCreateChunk16(HMMIO16,MMCKINFO*,UINT16);
 422 DWORD           WINAPI mciSendCommand16(UINT16,UINT16,DWORD,DWORD);
 423 DWORD           WINAPI mciSendString16(LPCSTR,LPSTR,UINT16,HWND16);
 424 UINT16          WINAPI mciGetDeviceID16(LPCSTR);
 425 UINT16          WINAPI mciGetDeviceIDFromElementID16(DWORD,LPCSTR);
 426 BOOL16          WINAPI mciGetErrorString16 (DWORD,LPSTR,UINT16);
 427 BOOL16          WINAPI mciSetYieldProc16(UINT16,YIELDPROC16,DWORD);
 428 HTASK16         WINAPI mciGetCreatorTask16(UINT16);
 429 YIELDPROC16     WINAPI mciGetYieldProc16(UINT16,DWORD*);
 430
 431 typedef struct {
 432     DWORD       dwCallback;
 433     WORD        wDeviceID;
 434     WORD        wReserved0;
 435     SEGPTR      lpstrDeviceType;
 436     SEGPTR      lpstrElementName;
 437     SEGPTR      lpstrAlias;
 438 } MCI_OPEN_PARMS16, *LPMCI_OPEN_PARMS16;
 439
 440 typedef struct {
 441     DWORD   dwCallback;
 442     SEGPTR  lpstrReturn;
 443     DWORD   dwRetSize;
 444 } MCI_INFO_PARMS16, *LPMCI_INFO_PARMS16;
 445
 446 typedef struct {
 447     DWORD       dwCallback;
 448     SEGPTR      lpstrReturn;
 449     DWORD       dwRetSize;
 450     DWORD       dwNumber;
 451     WORD        wDeviceType;
 452     WORD        wReserved0;
 453 } MCI_SYSINFO_PARMS16, *LPMCI_SYSINFO_PARMS16;
 454
 455 typedef struct {
 456     DWORD       dwCallback;
 457     UINT16      nVirtKey;
 458     WORD        wReserved0;
 459     HWND16      hwndBreak;
 460     WORD        wReserved1;
 461 } MCI_BREAK_PARMS16, *LPMCI_BREAK_PARMS16;
 462
 463 typedef struct {
 464     DWORD       dwCallback;
 465     LPCSTR      lpfilename;
 466 } MCI_LOAD_PARMS16, *LPMCI_LOAD_PARMS16;
 467
 468 typedef struct {
 469     DWORD       dwCallback;
 470     SEGPTR      lpstrCommand;
 471 } MCI_VD_ESCAPE_PARMS16, *LPMCI_VD_ESCAPE_PARMS16;
 472
 473 typedef struct {
 474     DWORD               dwCallback;
 475     MCIDEVICEID16       wDeviceID;
 476     WORD                wReserved0;
 477     SEGPTR              lpstrDeviceType;
 478     SEGPTR              lpstrElementName;
 479     SEGPTR              lpstrAlias;
 480     DWORD               dwBufferSeconds;
 481 } MCI_WAVE_OPEN_PARMS16, *LPMCI_WAVE_OPEN_PARMS16;
 482
 483 typedef struct {
 484     DWORD       dwCallback;
 485     DWORD       dwTimeFormat;
 486     DWORD       dwAudio;
 487     UINT16      wInput;
 488     UINT16      wReserved0;
 489     UINT16      wOutput;
 490     UINT16      wReserved1;
 491     UINT16      wFormatTag;
 492     UINT16      wReserved2;
 493     UINT16      nChannels;
 494     UINT16      wReserved3;
 495     DWORD       nSamplesPerSec;
 496     DWORD       nAvgBytesPerSec;
 497     UINT16      nBlockAlign;
 498     UINT16      wReserved4;
 499     UINT16      wBitsPerSample;
 500     UINT16      wReserved5;
 501 } MCI_WAVE_SET_PARMS16, * LPMCI_WAVE_SET_PARMS16;
 502
 503 typedef struct {
 504     DWORD   dwCallback;
 505     UINT16  wDeviceID;
 506     UINT16  wReserved0;
 507     SEGPTR  lpstrDeviceType;
 508     SEGPTR  lpstrElementName;
 509     SEGPTR  lpstrAlias;
 510     DWORD   dwStyle;
 511     HWND16  hWndParent;
 512     UINT16  wReserved1;
 513 } MCI_ANIM_OPEN_PARMS16, *LPMCI_ANIM_OPEN_PARMS16;
 514
 515 typedef struct {
 516     DWORD       dwCallback;
 517     HWND16      hWnd;
 518     WORD        wReserved1;
 519     WORD        nCmdShow;
 520     WORD        wReserved2;
 521     LPCSTR      lpstrText;
 522 } MCI_ANIM_WINDOW_PARMS16, *LPMCI_ANIM_WINDOW_PARMS16;
 523
 524 typedef struct {
 525     DWORD   dwCallback;
 526 #ifdef MCI_USE_OFFEXT
 527     POINT16 ptOffset;
 528     POINT16 ptExtent;
 529 #else   /* ifdef MCI_USE_OFFEXT */
 530     RECT16  rc;
 531 #endif  /* ifdef MCI_USE_OFFEXT */
 532 } MCI_ANIM_RECT_PARMS16, *LPMCI_ANIM_RECT_PARMS16;
 533
 534 typedef struct {
 535     DWORD   dwCallback;
 536     RECT16  rc;
 537     HDC16   hDC;
 538 } MCI_ANIM_UPDATE_PARMS16, *LPMCI_ANIM_UPDATE_PARMS16;
 539
 540 typedef struct {
 541     DWORD               dwCallback;
 542     MCIDEVICEID16       wDeviceID;
 543     WORD                wReserved0;
 544     LPCSTR              lpstrDeviceType;
 545     LPCSTR              lpstrElementName;
 546     LPCSTR              lpstrAlias;
 547     DWORD               dwStyle;
 548     HWND16              hWndParent;
 549     WORD                wReserved1;
 550 } MCI_OVLY_OPEN_PARMS16, *LPMCI_OVLY_OPEN_PARMS16;
 551
 552 typedef struct {
 553     DWORD       dwCallback;
 554     HWND16      hWnd;
 555     WORD        wReserved1;
 556     UINT16      nCmdShow;
 557     WORD        wReserved2;
 558     LPCSTR      lpstrText;
 559 } MCI_OVLY_WINDOW_PARMS16, *LPMCI_OVLY_WINDOW_PARMS16;
 560
 561 typedef struct {
 562     DWORD   dwCallback;
 563 #ifdef MCI_USE_OFFEXT
 564     POINT16 ptOffset;
 565     POINT16 ptExtent;
 566 #else   /* ifdef MCI_USE_OFFEXT */
 567     RECT16  rc;
 568 #endif  /* ifdef MCI_USE_OFFEXT */
 569 } MCI_OVLY_RECT_PARMS16, *LPMCI_OVLY_RECT_PARMS16;
 570
 571 typedef struct {
 572     DWORD   dwCallback;
 573     LPCSTR  lpfilename;
 574     RECT16  rc;
 575 } MCI_OVLY_SAVE_PARMS16, *LPMCI_OVLY_SAVE_PARMS16;
 576
 577 typedef struct {
 578     DWORD       dwCallback;
 579     LPCSTR      lpfilename;
 580     RECT16      rc;
 581 } MCI_OVLY_LOAD_PARMS16, *LPMCI_OVLY_LOAD_PARMS16;
 582
 583 #include "poppack.h"
 584
 585 #endif  /* __WINE_WINE_MMSYSTEM16_H */