{
    This file is part of the Free Pascal run time library.
    Copyright (c) 2008 Free Pascal development team.

    See the file COPYING.FPC, included in this distribution,
    for details about the copyright.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 ********************************************************************** }

//
// Module Name:mmsystem.h -- Include file for Multimedia API's
//
// *    If defined, the following flags inhibit inclusion
// *    of the indicated items:
// *
// *      MMNOSOUND       Sound support
// *      MMNOWAVE        Waveform support
// *      MMNOMCI         MCI API
// *      MMNOMMIO        file I/O
// *
// *

//
//  Microsoft Windows Mobile 6.0 for PocketPC SDK.
//

{$IFNDEF FPC_DOTTEDUNITS}
unit mmsystem;
{$ENDIF FPC_DOTTEDUNITS}

{$CALLING cdecl}

{$ifdef FPC_OS_UNICODE}
  {$define UNICODE}
{$endif}

interface

{$IFDEF FPC_DOTTEDUNITS}
uses WinApi.Windows, WinceAPI.Mmreg;
{$ELSE FPC_DOTTEDUNITS}
uses Windows, mmreg;
{$ENDIF FPC_DOTTEDUNITS}

{$PACKRECORDS 1} // #include "pshpack1.h"   // Assume byte packing throughout

{$DEFINE MMNOMIDI} // No midi audio support.

{$IFDEF WIN32}
{$DEFINE _WIN32}
{$ENDIF WIN32}

{****************************************************************************

                    General constants and data types

****************************************************************************}
//* general constants */
const
      MAXPNAMELEN      = 32;     // max product name length (including NULL)
      MAXERRORLENGTH   = 128;    // max error text length (including final NULL)

{*
 *  Microsoft Manufacturer and Product ID's
 *
    Used with wMid and wPid fields in WAVEOUTCAPS, WAVEINCAPS,
    MIDIOUTCAPS, MIDIINCAPS, AUXCAPS, JOYCAPS structures.
 *}
{*
 *  (these have been moved to
 *  MMREG.H for Windows 4.00 and above).
 *}
//* manufacturer IDs *
const
      MM_MICROSOFT            = 1;        // Microsoft Corporation


//* general data types */
type
     MMVERSION = UINT;      // major (high byte), minor (low byte)

     MMRESULT = UINT;       // error return code, 0 means no error
                                // call as if(err=xxxx(...)) Error(err); else

     LPUINT = ^UINT;


//* MMTIME data structure */
type
     mmtime_tag = record
       wType:UINT;      //* indicates the contents of the union */
       case UINT of
         0: (ms:DWORD);         //* milliseconds */
         1: (sample:DWORD);     //* samples */
         2: (cb:DWORD);         //* byte count */
         3: (ticks:DWORD);      //* ticks in MIDI stream */
         4: (smpte:record
                     hour:byte;       //* hours */
                     min:byte;        //* minutes */
                     sec:byte;        //* seconds */
                     frame:byte;      //* frames  */
                     fps:byte;        //* frames per second */
                     dummy:byte;      //* pad */
{$IFDEF _WIN32}
                     pad:array[0..1] of byte;
{$ENDIF _WIN32}
                   end);
         5: (midi:record
                    songptrpos:DWORD;   //* song pointer position */
                  end);
     end;
     MMTIME = mmtime_tag;
     PMMTIME = ^mmtime_tag;
     NPMMTIME = ^mmtime_tag;
     LPMMTIME = ^mmtime_tag;

//* types for wType field in MMTIME struct */
const
      TIME_MS         = $0001; //* time in milliseconds */
      TIME_SAMPLES    = $0002; //* number of wave samples */
      TIME_BYTES      = $0004; //* current byte offset */
      TIME_SMPTE      = $0008; //* SMPTE time */
      TIME_MIDI       = $0010; //* MIDI time */
      TIME_TICKS      = $0020; //* Ticks within MIDI stream */

{ Was declared as
      MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
      ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |   \
      ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))

      mmioFOURCC(ch0, ch1, ch2, ch3)  MAKEFOURCC(ch0, ch1, ch2, ch3)
}
function MAKEFOURCC(ch0:AnsiChar; ch1:AnsiChar; ch2:AnsiChar; ch3:AnsiChar):FOURCC;
function mmioFOURCC(ch0:AnsiChar; ch1:AnsiChar; ch2:AnsiChar; ch3:AnsiChar):FOURCC;


{****************************************************************************

            Multimedia Extensions Window Messages

****************************************************************************}
const
      MM_MCINOTIFY        = $3B9;           //* MCI */

      MM_WOM_OPEN         = $3BB;           //* waveform output */
      MM_WOM_CLOSE        = $3BC;
      MM_WOM_DONE         = $3BD;
      MM_WOM_ATTENUATED   = $3D8;           //* gain class support - stream attenuated */

      MM_WIM_OPEN         = $3BE;           //* waveform input */
      MM_WIM_CLOSE        = $3BF;
      MM_WIM_DATA         = $3C0;

      MM_MIM_OPEN         = $3C1;           //* MIDI input */
      MM_MIM_CLOSE        = $3C2;
      MM_MIM_DATA         = $3C3;
      MM_MIM_LONGDATA     = $3C4;
      MM_MIM_ERROR        = $3C5;
      MM_MIM_LONGERROR    = $3C6;

      MM_MOM_OPEN         = $3C7;           //* MIDI output */
      MM_MOM_CLOSE        = $3C8;
      MM_MOM_DONE         = $3C9;

//* these are also in msvideo.h */
      MM_DRVM_OPEN       = $3D0;           //* installable drivers */
      MM_DRVM_CLOSE      = $3D1;
      MM_DRVM_DATA       = $3D2;
      MM_DRVM_ERROR      = $3D3;

      MM_MCISYSTEM_STRING = $3CA;       //* internal */

//* these are used by msacm.h */
      MM_STREAM_OPEN      = $3D4;
      MM_STREAM_CLOSE     = $3D5;
      MM_STREAM_DONE      = $3D6;
      MM_STREAM_ERROR     = $3D7;

      MM_MOM_POSITIONCB   = $3CA;           //* Callback for MEVT_POSITIONCB */

      MM_MCISIGNAL        = $3CB;

      MM_MIM_MOREDATA      = $3CC;          //* MIM_DONE w/ pending events */

      MM_MIXM_LINE_CHANGE     = $3D0;       //* mixer line change notify */
      MM_MIXM_CONTROL_CHANGE  = $3D1;       //* mixer control change notify */

{****************************************************************************

        String resource number bases (internal use)

****************************************************************************}
const
      MMSYSERR_BASE          = 0;
      WAVERR_BASE            = 32;
      MIDIERR_BASE           = 64;
      TIMERR_BASE            = 96;
      MCIERR_BASE            = 256;
      MIXERR_BASE            = 1024;

      MCI_STRING_OFFSET      = 512;
      MCI_VD_OFFSET          = 1024;
      MCI_CD_OFFSET          = 1088;
      MCI_WAVE_OFFSET        = 1152;
      MCI_SEQ_OFFSET         = 1216;

{****************************************************************************

            General error return values

****************************************************************************}
const
//* general error return values */
      MMSYSERR_NOERROR      = 0;                  //* no error */
      MMSYSERR_ERROR        = MMSYSERR_BASE + 1;  //* unspecified error */
      MMSYSERR_BADDEVICEID  = MMSYSERR_BASE + 2;  //* device ID out of range */
      MMSYSERR_NOTENABLED   = MMSYSERR_BASE + 3;  //* driver failed enable */
      MMSYSERR_ALLOCATED    = MMSYSERR_BASE + 4;  //* device already allocated */
      MMSYSERR_INVALHANDLE  = MMSYSERR_BASE + 5;  //* device handle is invalid */
      MMSYSERR_NODRIVER     = MMSYSERR_BASE + 6;  //* no device driver present */
      MMSYSERR_NOMEM        = MMSYSERR_BASE + 7;  //* memory allocation error */
      MMSYSERR_NOTSUPPORTED = MMSYSERR_BASE + 8;  //* function isn't supported */
      MMSYSERR_BADERRNUM    = MMSYSERR_BASE + 9;  //* error value out of range */
      MMSYSERR_INVALFLAG    = MMSYSERR_BASE + 10; //* invalid flag passed */
      MMSYSERR_INVALPARAM   = MMSYSERR_BASE + 11; //* invalid parameter passed */
      MMSYSERR_HANDLEBUSY   = MMSYSERR_BASE + 12; //* handle being used */
                                                  //* simultaneously on another */
                                                  //* thread (eg callback) */
      MMSYSERR_INVALIDALIAS = MMSYSERR_BASE + 13; //* specified alias not found */
      MMSYSERR_BADDB        = MMSYSERR_BASE + 14; //* bad registry database */
      MMSYSERR_KEYNOTFOUND  = MMSYSERR_BASE + 15; //* registry key not found */
      MMSYSERR_READERROR    = MMSYSERR_BASE + 16; //* registry read error */
      MMSYSERR_WRITEERROR   = MMSYSERR_BASE + 17; //* registry write error */
      MMSYSERR_DELETEERROR  = MMSYSERR_BASE + 18; //* registry delete error */
      MMSYSERR_VALNOTFOUND  = MMSYSERR_BASE + 19; //* registry value not found */
      MMSYSERR_NODRIVERCB   = MMSYSERR_BASE + 20; //* driver does not call DriverCallback */
      MMSYSERR_LASTERROR    = MMSYSERR_BASE + 20; //* last error in range */

type
     HDRVR = HANDLE;

{$IFNDEF MMNODRV}
//
// Installable driver support was left out.
//
{$ENDIF MMNODRV}


{****************************************************************************

              Driver callback support

****************************************************************************}

//* flags used with waveOutOpen(), waveInOpen(), midiInOpen(), and */
//* midiOutOpen() to specify the type of the dwCallback parameter. */
const
      CALLBACK_TYPEMASK   = $00070000;    //* callback type mask */
      CALLBACK_NULL       = $00000000;    //* no callback */
      CALLBACK_WINDOW     = $00010000;    //* dwCallback is a HWND */
      CALLBACK_TASK       = $00020000;    //* dwCallback is a HTASK */
      CALLBACK_FUNCTION   = $00030000;    //* dwCallback is a FARPROC */
      CALLBACK_THREAD     = CALLBACK_TASK;//* thread ID replaces 16 bit task */
      CALLBACK_EVENT      = $00050000;    //* dwCallback is an EVENT Handle */
      CALLBACK_MSGQUEUE   = $00060000;    //* dwCallback is HANDLE returned by CreateMsgQueue or OpenMsgQueue (new in Windows CE 5.0) */


type
     DRVCALLBACK = procedure(_hdrvr:HANDLE; uMsg:UINT; dwUser:DWORD; dw1:DWORD; dw2:DWORD); cdecl;
     LPDRVCALLBACK = DRVCALLBACK;
     PDRVCALLBACK = DRVCALLBACK;

{* CALLBACK_MSGQUEUE - client process sets up a MsgQueuue that receives WAVEMSG structures.
*  Note that structure fields are identical to arguments to a callback function
*  but we put the message field first to allow for multi-functional message queues.
*}
type
     _tag_WAVEMSG = record
       uMsg:UINT;       // WOM_OPEN, WIM_OPEN, WOM_DONE, WIM_DATA, etc.
       hWav:HANDLE;       // stream handle returned by waveInOpen or waveOutOpen
       dwInstance:DWORD; // value of dwInstance argument passed into waveInOpen or waveOutOpen
       dwParam1:DWORD;   // completed WAVEHDR for WIM_DATA, WOM_DONE, reserved elsewhere
       dwParam2:DWORD;   // reserved
     end;
     WAVEMSG = _tag_WAVEMSG;
     PWAVEMSG = ^_tag_WAVEMSG;

{$IFNDEF MMNOSOUND}

function sndPlaySoundW(lpszSoundName:LPCWSTR; fuSound:UINT):BOOL; external KernelDLL name 'sndPlaySoundW'; // index 266
{$IFDEF UNICODE}
function sndPlaySound(lpszSoundName:LPCWSTR; fuSound:UINT):BOOL; external KernelDLL name 'sndPlaySoundW'; // index 266
{$ELSE} // UNICODE
//#define sndPlaySound  sndPlaySoundA
{$ENDIF} // UNICODE

function PlaySoundW(pszSound:LPCWSTR; hmod:HMODULE; fdwSound:DWORD):BOOL; external KernelDLL name 'PlaySoundW'; // index 267
{$IFDEF UNICODE}
function PlaySound(pszSound:LPCWSTR; hmod:HMODULE; fdwSound:DWORD):BOOL; external KernelDLL name 'PlaySoundW'; // index 267
{$ELSE} // UNICODE
//#define PlaySound  PlaySoundA
{$ENDIF} // UNICODE

{*
 *  flag values for fuSound arguments on [snd]PlaySound
 *  or dwFlags for PlaySound
 *}

//* sndAlias creates the alias identifier */
const
      SND_ALIAS_START  = 0;      // ??? must be > 4096 to keep strings in same section of resource file

function sndAlias(ch0:AnsiChar; ch1:AnsiChar):DWORD;

const
      SND_ALIAS_SYSTEMASTERISK        = SND_ALIAS_START+
                                        (DWORD(AnsiChar('S')) or
                                         DWORD(AnsiChar('*')));

      SND_ALIAS_SYSTEMQUESTION        = SND_ALIAS_START+
                                        (DWORD(AnsiChar('S')) or
                                         DWORD(AnsiChar('?')));

      SND_ALIAS_SYSTEMHAND            = SND_ALIAS_START+
                                        (DWORD(AnsiChar('S')) or
                                         DWORD(AnsiChar('H')));

      SND_ALIAS_SYSTEMEXIT            = SND_ALIAS_START+
                                        (DWORD(AnsiChar('S')) or
                                         DWORD(AnsiChar('E')));

      SND_ALIAS_SYSTEMSTART           = SND_ALIAS_START+
                                        (DWORD(AnsiChar('S')) or
                                         DWORD(AnsiChar('S')));

      SND_ALIAS_SYSTEMWELCOME         = SND_ALIAS_START+
                                        (DWORD(AnsiChar('S')) or
                                         DWORD(AnsiChar('W')));

      SND_ALIAS_SYSTEMEXCLAMATION     = SND_ALIAS_START+
                                        (DWORD(AnsiChar('S')) or
                                         DWORD(AnsiChar('!')));

      SND_ALIAS_SYSTEMDEFAULT         = SND_ALIAS_START+
                                        (DWORD(AnsiChar('S')) or
                                         DWORD(AnsiChar('D')));

      SND_ALIAS      = $00010000;   // name is a WIN.INI [sounds] entry
      SND_FILENAME   = $00020000;   // name is a file name
      SND_RESOURCE   = $00040004;   // name is a resource name or atom

      SND_SYNC       = $00000000;   // play synchronously (default)
      SND_ASYNC      = $00000001;   // play asynchronously
      SND_NODEFAULT  = $00000002;   // silence not default, if sound not found
      SND_MEMORY     = $00000004;   // lpszSoundName points to a memory file
      SND_LOOP       = $00000008;   // loop the sound until next sndPlaySound
      SND_NOSTOP     = $00000010;   // don't stop any currently playing sound

      SND_NOWAIT     = $00002000;   // don't wait if the driver is busy
      SND_VALIDFLAGS = $0017201F;   // Set of valid flag bits.  Anything outside
                                    // this range will raise an error
      SND_RESERVED   = $FF000000;   // In particular these flags are reserved
      SND_TYPE_MASK  = $00170007;
      SND_ALIAS_ID   = $00110000;   // name is a WIN.INI [sounds] entry identifier

{$ENDIF} // MMNOSOUND


{$IFNDEF MMNOWAVE}
{****************************************************************************

                        Waveform audio support

****************************************************************************}
const
//* waveform audio error return values */
      WAVERR_BADFORMAT      = WAVERR_BASE + 0;    // unsupported wave format
      WAVERR_STILLPLAYING   = WAVERR_BASE + 1;    // still something playing
      WAVERR_UNPREPARED     = WAVERR_BASE + 2;    // header not prepared
      WAVERR_SYNC           = WAVERR_BASE + 3;    // device is synchronous
      WAVERR_LASTERROR      = WAVERR_BASE + 3;    // last error in range

//* waveform audio data types */
type
     HWAVE = HANDLE;
     HWAVEIN = HANDLE;
     LPHWAVEIN = ^HWAVEIN;
     HWAVEOUT = HANDLE;
     LPHWAVEOUT = ^HWAVEOUT;

     WAVECALLBACK = DRVCALLBACK;
     LPWAVECALLBACK = WAVECALLBACK;

const
//* wave callback messages */
      WOM_OPEN        = MM_WOM_OPEN;
      WOM_CLOSE       = MM_WOM_CLOSE;
      WOM_DONE        = MM_WOM_DONE;
      WIM_OPEN        = MM_WIM_OPEN;
      WIM_CLOSE       = MM_WIM_CLOSE;
      WIM_DATA        = MM_WIM_DATA;

//* device ID for wave device mapper */
const
      WAVE_MAPPER     = DWORD(-1);

//* flags for dwFlags parameter in waveOutOpen() and waveInOpen() */
const
       WAVE_FORMAT_QUERY     = $00000001;
       WAVE_ALLOWSYNC        = $00000002;
       WAVE_MAPPED           = $00000004;
       WAVE_FORMAT_DIRECT    = $00000008;
       WAVE_FORMAT_DIRECT_QUERY = WAVE_FORMAT_QUERY or WAVE_FORMAT_DIRECT;
       WAVE_NOMIXER          = $00000080;           //* Windows CE only - bypass software mixer */


// Switch to DWORD packing for WAVEHDR
// Warning: This assumes that the start of headers is DWORD aligned, which is a change from previous implementations.
{$PACKRECORDS 4}// #include "pshpack4.h"
//* wave data block header */
type
     LPWAVEHDR = ^wavehdr_tag;
     wavehdr_tag = record
       lpData:LPSTR;                 //* pointer to locked data buffer */
       dwBufferLength:DWORD;         //* length of data buffer */
       dwBytesRecorded:DWORD;        //* used for input only */
       dwUser:DWORD;                 //* for client's use */
       dwFlags:DWORD;                //* assorted flags (see defines) */
       dwLoops:DWORD;                //* loop control counter */
       lpNext:LPWAVEHDR;     //* reserved for driver */
       reserved:DWORD;               //* reserved for driver */
     end;
     WAVEHDR = wavehdr_tag;
     PWAVEHDR = ^wavehdr_tag;
     NPWAVEHDR = ^wavehdr_tag;

// Switch back to previous packing
{$PACKRECORDS 1}// #include "poppack.h"


//* flags for dwFlags field of WAVEHDR */
const
      WHDR_DONE       = $00000001;  //* done bit */
      WHDR_PREPARED   = $00000002;  //* set if this header has been prepared */
      WHDR_BEGINLOOP  = $00000004;  //* loop start block */
      WHDR_ENDLOOP    = $00000008;  //* loop end block */
      WHDR_INQUEUE    = $00000010;  //* reserved for driver */

//* waveform output device capabilities structure */
type
     tagWAVEOUTCAPS = record
       wMid:word;                  //* manufacturer ID */
       wPid:word;                  //* product ID */
       vDriverVersion:MMVERSION;      //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of TCHAR;  //* product name (NULL terminated string) */
       dwFormats:DWORD;             //* formats supported */
       wChannels:word;             //* number of sources supported */
       wReserved1:word;            //* packing */
       dwSupport:DWORD;             //* functionality supported by driver */
     end;
     WAVEOUTCAPS = tagWAVEOUTCAPS;
     PWAVEOUTCAPS = ^tagWAVEOUTCAPS;
     NPWAVEOUTCAPS = ^tagWAVEOUTCAPS;
     LPWAVEOUTCAPS = ^tagWAVEOUTCAPS;

//* flags for dwSupport field of WAVEOUTCAPS */
const
      WAVECAPS_PITCH          = $0001;   //* supports pitch control */
      WAVECAPS_PLAYBACKRATE   = $0002;   //* supports playback rate control */
      WAVECAPS_VOLUME         = $0004;   //* supports volume control */
      WAVECAPS_LRVOLUME       = $0008;   //* separate left-right volume control */
//      WAVECAPS_SYNC           = $0010; //* Windows CE only supports asynchronous audio devices */
      WAVECAPS_SAMPLEACCURATE = $0020;
      WAVECAPS_DIRECTSOUND    = $0040;

//* waveform input device capabilities structure */
type
     tagWAVEINCAPS = record
       wMid:word;                    //* manufacturer ID */
       wPid:word;                    //* product ID */
       vDriverVersion:MMVERSION;     //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of TCHAR;    //* product name (NULL terminated string) */
       dwFormats:DWORD;              //* formats supported */
       wChannels:word;               //* number of channels supported */
       wReserved1:word;              //* structure packing */
     end;
     WAVEINCAPS = tagWAVEINCAPS;
     PWAVEINCAPS = ^tagWAVEINCAPS;
     NPWAVEINCAPS = ^tagWAVEINCAPS;
     LPWAVEINCAPS = ^tagWAVEINCAPS;

//* defines for dwFormat field of WAVEINCAPS and WAVEOUTCAPS */
const
      WAVE_INVALIDFORMAT     = $00000000;       //* invalid format */
      WAVE_FORMAT_1M08       = $00000001;       //* 11.025 kHz, Mono,   8-bit  */
      WAVE_FORMAT_1S08       = $00000002;       //* 11.025 kHz, Stereo, 8-bit  */
      WAVE_FORMAT_1M16       = $00000004;       //* 11.025 kHz, Mono,   16-bit */
      WAVE_FORMAT_1S16       = $00000008;       //* 11.025 kHz, Stereo, 16-bit */
      WAVE_FORMAT_2M08       = $00000010;       //* 22.05  kHz, Mono,   8-bit  */
      WAVE_FORMAT_2S08       = $00000020;       //* 22.05  kHz, Stereo, 8-bit  */
      WAVE_FORMAT_2M16       = $00000040;       //* 22.05  kHz, Mono,   16-bit */
      WAVE_FORMAT_2S16       = $00000080;       //* 22.05  kHz, Stereo, 16-bit */
      WAVE_FORMAT_4M08       = $00000100;       //* 44.1   kHz, Mono,   8-bit  */
      WAVE_FORMAT_4S08       = $00000200;       //* 44.1   kHz, Stereo, 8-bit  */
      WAVE_FORMAT_4M16       = $00000400;       //* 44.1   kHz, Mono,   16-bit */
      WAVE_FORMAT_4S16       = $00000800;       //* 44.1   kHz, Stereo, 16-bit */

//* property information for audio gain classes */

//* audio gain class property sets */
const
      MM_PROPSET_GAINCLASS_CLASS:GUID = '{E7E569A5-8498-43FE-8075-33D1FDAB15EF}';
      MM_PROPSET_GAINCLASS_STREAM:GUID = '{40E953AE-EE3E-493A-93EE-DA3E30764390}';
(*
#define MM_PROPSET_GAINCLASS_CLASS \
    { 0xe7e569a5, 0x8498, 0x43fe, { 0x80, 0x75, 0x33, 0xd1, 0xfd, 0xab, 0x15, 0xef } }
#define MM_PROPSET_GAINCLASS_STREAM \
    { 0x40e953ae, 0xee3e, 0x493a, { 0x93, 0xee, 0xda, 0x3e, 0x30, 0x76, 0x43, 0x90 } }
*)

const
//* MM_PROPSET_GAINCLASS_CLASS property IDs */
      MM_PROP_GAINCLASS_CLASS     = 1;

//* MM_PROPSET_GAINCLASS_STREAM property IDs */
      MM_PROP_GAINCLASS_STREAM    = 1;

//* structure to describe audio gain classes */
type
     tagAUDIOGAINCLASS = record
       dwPriority:DWORD;
       dwRelativeGain:DWORD;
     end;
     AUDIOGAINCLASS = tagAUDIOGAINCLASS;
     PAUDIOGAINCLASS = ^tagAUDIOGAINCLASS;
     CPAUDIOGAINCLASS = ^AUDIOGAINCLASS;

//* values for AUDIOGAINCLASS.dwPriority */
const
      WAGC_PRIORITY_CRITICAL  = 6;
      WAGC_PRIORITY_HIGH      = 4;
      WAGC_PRIORITY_NORMAL    = 2;

//* wave stream properties structure */
type
     tagSTREAMPROPS = record
       dwClassID:DWORD;
       dwFlags:DWORD;
     end;
     STREAMPROPS = tagSTREAMPROPS;
     PSTREAMPROPS = ^tagSTREAMPROPS;
     CPSTREAMPROPS = ^STREAMPROPS;

//* flag definitions for STREAMPROPS.dwFlags */
const
      SPSFL_NOTIFY_GAIN_CHANGE   = $00000001;      //* callback gets MM_WOM_ATTENUATED messages */
      SPSFL_EXCLUDE              = $00000002;      //* stream does not participate in gain-class operations */

//* values for STREAMPROPS.dwClassid */
const
      WAGC_CLASS_DEFAULT              = 0;
      WAGC_CLASS_NORMAL               = 1;
      WAGC_CLASS_AUDIO_ALERT          = 2;
      WAGC_CLASS_SPEECH_ALERT         = 3;
      WAGC_CLASS_SPEECH_NOTIFICATION  = 4;
      WAGC_CLASS_AUDIO_NOTIFICATION   = 5;
      WAGC_CLASS_FORCE_MUTE           = 6;
//* classes 7-15 are reserved for future use */
      WAGC_CLASS_MAX                  = 15; //* class ID's larger than this are illegal */

//* Discontinuity detection property set */
     MM_PROPSET_DISCONTINUITY:GUID = '{B4389733-868E-4D06-B008-9A6FC8CE852E}';
{
#define MM_PROPSET_DISCONTINUITY \
    { 0xb4389733, 0x868e, 0x4d06, { 0xb0, 0x8, 0x9a, 0x6f, 0xc8, 0xce, 0x85, 0x2e } }
}

//* MM_PROPSET_DISCONTINUITY property IDs */
     MM_PROP_DISCONTINUITY   = 1;

//* bit values for MM_PROP_DISCONTINUITY parameter */
      WDSC_APP        = 1;
      WDSC_SWMIXER    = 2;
      WDSC_DRIVER     = 4;

//* structure to receive discontinuity information */
type
     tagAUDIODISCONTINUITY = record
       dwMask:DWORD;       // bitmask shows which values were set (see WDSC_* values above)
       dwApp:DWORD;        // # discontinuities detected at the application level
       dwSwMixer:DWORD;    // # discontinuities detected at the software mixer level
       dwDriver:DWORD;     // # discontinuities detected at the driver level
     end;
     AUDIODISCONTINUITY = tagAUDIODISCONTINUITY;
     PAUDIODISCONTINUITY = ^tagAUDIODISCONTINUITY;

//* waveform audio function prototypes */
function waveOutGetNumDevs:UINT; external KernelDLL name 'waveOutGetNumDevs'; // index 268
function waveOutGetDevCaps(uDeviceID:UINT; pwoc:LPWAVEOUTCAPS; cbwoc:UINT):MMRESULT; external KernelDLL name 'waveOutGetDevCaps'; // index 269
function waveOutGetVolume(hwo:HWAVEOUT; pdwVolume:LPDWORD):MMRESULT; external KernelDLL name 'waveOutGetVolume'; // index 26A
function waveOutSetVolume(hwo:HWAVEOUT; dwVolume:DWORD):MMRESULT; external KernelDLL name 'waveOutSetVolume'; // index 26B
function waveOutGetErrorText(mmrError:MMRESULT; pszText:PTSTR; cchText:UINT):MMRESULT; external KernelDLL name 'waveOutGetErrorText'; // index 26C
function waveOutClose(hwo:HWAVEOUT):MMRESULT; external KernelDLL name 'waveOutClose'; // index 26D
function waveOutPrepareHeader(hwo:HWAVEOUT; pwh:LPWAVEHDR; cbwh:UINT):MMRESULT; external KernelDLL name 'waveOutPrepareHeader'; // index 26E
function waveOutUnprepareHeader(hwo:HWAVEOUT; pwh:LPWAVEHDR; cbwh:UINT):MMRESULT; external KernelDLL name 'waveOutUnprepareHeader'; // index 26F
function waveOutWrite(hwo:HWAVEOUT; pwh:LPWAVEHDR; cbwh:UINT):MMRESULT; external KernelDLL name 'waveOutWrite'; // index 270
function waveOutPause(hwo:HWAVEOUT):MMRESULT; external KernelDLL name 'waveOutPause'; // index 271
function waveOutRestart(hwo:HWAVEOUT):MMRESULT; external KernelDLL name 'waveOutRestart'; // index 272
function waveOutReset(hwo:HWAVEOUT):MMRESULT; external KernelDLL name 'waveOutReset'; // index 273
function waveOutBreakLoop(hwo:HWAVEOUT):MMRESULT; external KernelDLL name 'waveOutBreakLoop'; // index 274
function waveOutGetPosition(hwo:HWAVEOUT; pmmt:LPMMTIME; cbmmt:UINT):MMRESULT; external KernelDLL name 'waveOutGetPosition'; // index 275
function waveOutGetPitch(hwo:HWAVEOUT; pdwPitch:LPDWORD):MMRESULT; external KernelDLL name 'waveOutGetPitch'; // index 276
function waveOutSetPitch(hwo:HWAVEOUT; dwPitch:DWORD):MMRESULT; external KernelDLL name 'waveOutSetPitch'; // index 277
function waveOutGetPlaybackRate(hwo:HWAVEOUT; pdwRate:LPDWORD):MMRESULT; external KernelDLL name 'waveOutGetPlaybackRate'; // index 278
function waveOutSetPlaybackRate(hwo:HWAVEOUT; dwRate:DWORD):MMRESULT; external KernelDLL name 'waveOutSetPlaybackRate'; // index 279
function waveOutGetID(hwo:HWAVEOUT; puDeviceID:LPUINT):MMRESULT; external KernelDLL name 'waveOutGetID'; // index 27A
function waveOutMessage(hwo:HWAVEOUT; uMsg:UINT; dw1:DWORD; dw2:DWORD):MMRESULT; external KernelDLL name 'waveOutMessage'; // index 27B
function waveOutOpen(Phwo:LPHWAVEOUT;
                     uDeviceID:UINT;
                     pwfx:LPCWAVEFORMATEX;
                     dwCallback:DWORD;
                     dwInstance:DWORD;
                     fdwOpen:DWORD):MMRESULT; external KernelDLL name 'waveOutOpen'; // index 27C
function waveOutGetProperty(uDeviceID:UINT;
                            pPropSetId:PGUID;
                            ulPropId:ULONG;
                            pvPropParams:LPVOID;
                            cbPropParams:ULONG;
                            pvPropData:LPVOID;
                            cbPropData:ULONG;
                            pcbReturn:PULONG):MMRESULT; external KernelDLL name 'waveOutGetProperty'; // index ?
function waveOutSetProperty(uDeviceID:UINT;
                            pPropSetId:PGUID;
                            ulPropId:ULONG;
                            pvPropParams:LPVOID;
                            cbPropParams:ULONG;
                            pvPropData:LPVOID;
                            cbPropData:ULONG):MMRESULT; external KernelDLL name 'waveOutSetProperty'; // index ?


function waveInGetNumDevs:UINT; external KernelDLL name 'waveInGetNumDevs'; // index 27D
function waveInGetDevCaps(uDeviceID:UINT; pwic:LPWAVEINCAPS; cbwic:UINT):MMRESULT; external KernelDLL name 'waveInGetDevCaps'; // index 27E
function waveInGetErrorText(mmrError:MMRESULT; pszText:LPTSTR; cchText:UINT):MMRESULT; external KernelDLL name 'waveInGetErrorText'; // index 27F
function waveInClose(hwi:HWAVEIN):MMRESULT; external KernelDLL name 'waveInClose'; // index 280
function waveInPrepareHeader(hwi:HWAVEIN; pwh:LPWAVEHDR; cbwh:UINT):MMRESULT; external KernelDLL name 'waveInPrepareHeader'; // index 281
function waveInUnprepareHeader(hwi:HWAVEIN; pwh:LPWAVEHDR; cbwh:UINT):MMRESULT; external KernelDLL name 'waveInUnprepareHeader'; // index 282
function waveInAddBuffer(hwi:HWAVEIN; pwh:LPWAVEHDR; cbwh:UINT):MMRESULT; external KernelDLL name 'waveInAddBuffer'; // index 283
function waveInStart(hwi:HWAVEIN):MMRESULT; external KernelDLL name 'waveInStart'; // index 284
function waveInStop(hwi:HWAVEIN):MMRESULT; external KernelDLL name 'waveInStop'; // index 285
function waveInReset(hwi:HWAVEIN):MMRESULT; external KernelDLL name 'waveInReset'; // index 286
function waveInGetPosition(hwi:HWAVEIN; pmmt:LPMMTIME; cbmmt:UINT):MMRESULT; external KernelDLL name 'waveInGetPosition'; // index 287
function waveInGetID(hwi:HWAVEIN; puDeviceID:LPUINT):MMRESULT; external KernelDLL name 'waveInGetID'; // index 288
function waveInMessage(hwi:HWAVEIN; uMsg:UINT; dw1:DWORD; dw2:DWORD):MMRESULT; external KernelDLL name 'waveInMessage'; // index 289
function waveInOpen(phwi:LPHWAVEIN;
                    uDeviceID:UINT;
                    pwfx:LPCWAVEFORMATEX;
                    dwCallback:DWORD;
                    dwInstance:DWORD;
                    fdwOpen:DWORD):MMRESULT; external KernelDLL name 'waveInOpen'; // index 28A
function waveInGetProperty(uDeviceID:UINT;
                           pPropSetId:PGUID;
                           ulPropId:ULONG;
                           pvPropParams:LPVOID;
                           cbPropParams:ULONG;
                           pvPropData:LPVOID;
                           cbPropData:ULONG;
                           pcbReturn:PULONG):MMRESULT; external KernelDLL name 'waveInGetProperty'; // index ?
function waveInSetProperty(uDeviceID:UINT;
                           pPropSetId:PGUID;
                           ulPropId:ULONG;
                           pvPropParams:LPVOID;
                           cbPropParams:ULONG;
                           pvPropData:LPVOID;
                           cbPropData:ULONG):MMRESULT; external KernelDLL name 'waveInSetProperty'; // index ?

{$ENDIF} // MMNOWAVE


{$IFNDEF MMNOMIDI}
{****************************************************************************

                            MIDI audio support

****************************************************************************}
const
//* MIDI error return values */
      MIDIERR_UNPREPARED    = MIDIERR_BASE + 0;   //* header not prepared */
      MIDIERR_STILLPLAYING  = MIDIERR_BASE + 1;   //* still something playing */
      MIDIERR_NOMAP         = MIDIERR_BASE + 2;   //* no configured instruments */
      MIDIERR_NOTREADY      = MIDIERR_BASE + 3;   //* hardware is still busy */
      MIDIERR_NODEVICE      = MIDIERR_BASE + 4;   //* port no longer connected */
      MIDIERR_INVALIDSETUP  = MIDIERR_BASE + 5;   //* invalid MIF */
      MIDIERR_BADOPENMODE   = MIDIERR_BASE + 6;   //* operation unsupported w/ open mode */
      MIDIERR_DONT_CONTINUE = MIDIERR_BASE + 7;   //* thru device 'eating' a message */
      MIDIERR_LASTERROR     = MIDIERR_BASE + 7;   //* last error in range */

//* MIDI audio data types */
type
     HMIDI = HANDLE;
     HMIDIIN = HANDLE;
     HMIDIOUT = HANDLE;
     HMIDISTRM = HANDLE;

     LPHMIDI = ^HMIDI;
     LPHMIDIIN = ^HMIDIIN;
     LPHMIDIOUT = ^HMIDIOUT;
     LPHMIDISTRM = ^HMIDISTRM;

     MIDICALLBACK = DRVCALLBACK;
     LPMIDICALLBACK = MIDICALLBACK;

const
      MIDIPATCHSIZE   = 128;
      
type
     PATCHARRAY = array[0..MIDIPATCHSIZE-1] of word;
     LPPATCHARRAY = ^PATCHARRAY;
     KEYARRAY = array[0..MIDIPATCHSIZE-1] of word;
     LPKEYARRAY = ^KEYARRAY;

//* MIDI callback messages */
const
      MIM_OPEN        = MM_MIM_OPEN;
      MIM_CLOSE       = MM_MIM_CLOSE;
      MIM_DATA        = MM_MIM_DATA;
      MIM_LONGDATA    = MM_MIM_LONGDATA;
      MIM_ERROR       = MM_MIM_ERROR;
      MIM_LONGERROR   = MM_MIM_LONGERROR;
      MOM_OPEN        = MM_MOM_OPEN;
      MOM_CLOSE       = MM_MOM_CLOSE;
      MOM_DONE        = MM_MOM_DONE;

      MIM_MOREDATA      = MM_MIM_MOREDATA;
      MOM_POSITIONCB    = MM_MOM_POSITIONCB;

//* device ID for MIDI mapper */
const
      MIDIMAPPER     = UINT(-1);
      MIDI_MAPPER    = UINT(-1);

//* flags for dwFlags parm of midiInOpen() */
const
      MIDI_IO_STATUS      = $00000020;
      MIDI_IO_CONTROL     = $00000008;                         //* Internal */
      MIDI_IO_INPUT       = $00000010;  //*future*/             /* Internal */
      MIDI_IO_OWNED       = $00004000;                         //* Internal */
      MIDI_IO_SHARED      = $00008000;                         //* Internal */
      MIDI_I_VALID        = $C027;                              //* Internal */
      MIDI_O_VALID        = $C00E;                              //* Internal */


//* flags for wFlags parm of midiOutCachePatches(), midiOutCacheDrumPatches() */
      MIDI_CACHE_ALL      = 1;
      MIDI_CACHE_BESTFIT  = 2;
      MIDI_CACHE_QUERY    = 3;
      MIDI_UNCACHE        = 4;
      MIDI_CACHE_VALID    = MIDI_CACHE_ALL or MIDI_CACHE_BESTFIT or MIDI_CACHE_QUERY or MIDI_UNCACHE;     //* Internal */


//* MIDI output device capabilities structure */
{$IFDEF _WIN32}
type
     tagMIDIOUTCAPSA = record
       wMid:word;                  //* manufacturer ID */
       wPid:word;                  //* product ID */
       vDriverVersion:MMVERSION;      //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of AnsiChar;  //* product name (NULL terminated string) */
       wTechnology:word;           //* type of device */
       wVoices:word;               //* # of voices (internal synth only) */
       wNotes:word;                //* max # of notes (internal synth only) */
       wChannelMask:word;          //* channels used (internal synth only) */
       dwSupport:DWORD;             //* functionality supported by driver */
     end;
     MIDIOUTCAPSA = tagMIDIOUTCAPSA;
     PMIDIOUTCAPSA = ^tagMIDIOUTCAPSA;
     NPMIDIOUTCAPSA = ^tagMIDIOUTCAPSA;
     LPMIDIOUTCAPSA = ^tagMIDIOUTCAPSA;

type
     tagMIDIOUTCAPSW = record
       wMid:word;                  //* manufacturer ID */
       wPid:word;                  //* product ID */
       vDriverVersion:MMVERSION;      //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of WCHAR;  //* product name (NULL terminated string) */
       wTechnology:word;           //* type of device */
       wVoices:word;               //* # of voices (internal synth only) */
       wNotes:word;                //* max # of notes (internal synth only) */
       wChannelMask:word;          //* channels used (internal synth only) */
       dwSupport:DWORD;             //* functionality supported by driver */
     end;
     MIDIOUTCAPSW = tagMIDIOUTCAPSW;
     PMIDIOUTCAPSW = ^tagMIDIOUTCAPSW;
     NPMIDIOUTCAPSW = ^tagMIDIOUTCAPSW;
     LPMIDIOUTCAPSW = ^tagMIDIOUTCAPSW;

{$IFDEF UNICODE}
     MIDIOUTCAPS = MIDIOUTCAPSW;
     PMIDIOUTCAPS = PMIDIOUTCAPSW;
     NPMIDIOUTCAPS = NPMIDIOUTCAPSW;
     LPMIDIOUTCAPS = LPMIDIOUTCAPSW;
{$ELSE} // UNICODE
     MIDIOUTCAPS = MIDIOUTCAPSA;
     PMIDIOUTCAPS = PMIDIOUTCAPSA;
     NPMIDIOUTCAPS = NPMIDIOUTCAPSA;
     LPMIDIOUTCAPS = LPMIDIOUTCAPSA;
{$ENDIF} // UNICODE

{$ELSE} // _WIN32
type
     midioutcaps_tag = record
       wMid:word;                  //* manufacturer ID */
       wPid:word;                  //* product ID */
       vDriverVersion:MMVERSION;        //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of AnsiChar;  //* product name (NULL terminated string) */
       wTechnology:word;           //* type of device */
       wVoices:word;               //* # of voices (internal synth only) */
       wNotes:word;                //* max # of notes (internal synth only) */
       wChannelMask:word;          //* channels used (internal synth only) */
       dwSupport:DWORD;             //* functionality supported by driver */
     end;
     MIDIOUTCAPS = midioutcaps_tag;
     PMIDIOUTCAPS = ^midioutcaps_tag;
     NPMIDIOUTCAPS = ^midioutcaps_tag;
     LPMIDIOUTCAPS = ^midioutcaps_tag;
{$ENDIF} // _WIN32

const
//* flags for wTechnology field of MIDIOUTCAPS structure */
      MOD_MIDIPORT    = 1;  //* output port */
      MOD_SYNTH       = 2;  //* generic internal synth */
      MOD_SQSYNTH     = 3;  //* square wave internal synth */
      MOD_FMSYNTH     = 4;  //* FM internal synth */
      MOD_MAPPER      = 5;  //* MIDI mapper */

//* flags for dwSupport field of MIDIOUTCAPS structure */
      MIDICAPS_VOLUME          = $0001;  //* supports volume control */
      MIDICAPS_LRVOLUME        = $0002;  //* separate left-right volume control */
      MIDICAPS_CACHE           = $0004;

      MIDICAPS_STREAM          = $0008;  //* driver supports midiStreamOut directly */



//* MIDI input device capabilities structure */
{$IFDEF _WIN32}
type
     tagMIDIINCAPSA = record
       wMid:word;                   //* manufacturer ID */
       wPid:word;                   //* product ID */
       vDriverVersion:MMVERSION;         //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of AnsiChar;   //* product name (NULL terminated string) */
//#if (WINVER >= 0x0400)
       dwSupport:DWORD;             //* functionality supported by driver */
//#endif
     end;
     MIDIINCAPSA = tagMIDIINCAPSA;
     PMIDIINCAPSA = ^tagMIDIINCAPSA;
     NPMIDIINCAPSA = ^tagMIDIINCAPSA;
     LPMIDIINCAPSA = ^tagMIDIINCAPSA;

type
     tagMIDIINCAPSW = record
       wMid:word;                   //* manufacturer ID */
       wPid:word;                   //* product ID */
       vDriverVersion:MMVERSION;         //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of WCHAR;   //* product name (NULL terminated string) */
//#if (WINVER >= 0x0400)
       dwSupport:DWORD;             //* functionality supported by driver */
//#endif
     end;
     MIDIINCAPSW = tagMIDIINCAPSW;
     PMIDIINCAPSW = ^tagMIDIINCAPSW;
     NPMIDIINCAPSW = ^tagMIDIINCAPSW;
     LPMIDIINCAPSW = ^tagMIDIINCAPSW;

{$IFDEF UNICODE}
     MIDIINCAPS = MIDIINCAPSW;
     PMIDIINCAPS = PMIDIINCAPSW;
     NPMIDIINCAPS = NPMIDIINCAPSW;
     LPMIDIINCAPS = LPMIDIINCAPSW;
{$ELSE} // UNICODE
     MIDIINCAPS = MIDIINCAPSA;
     PMIDIINCAPS = PMIDIINCAPSA;
     NPMIDIINCAPS = NPMIDIINCAPSA;
     LPMIDIINCAPS = LPMIDIINCAPSA;
{$ENDIF} // UNICODE

{$ELSE} // _WIN32
type
     midiincaps_tag = record
       wMid:word;                  //* manufacturer ID */
       wPid:word;                  //* product ID */
       vDriverVersion:MMVERSION;        //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of AnsiChar;  //* product name (NULL terminated string) */
//#if (WINVER >= 0x0400)
       dwSupport:DWORD;             //* functionality supported by driver */
//#endif
     end;
     MIDIINCAPS = midiincaps_tag;
     PMIDIINCAPS = ^midiincaps_tag;
     NPMIDIINCAPS = ^midiincaps_tag;
     LPMIDIINCAPS = ^midiincaps_tag;
{$ENDIF} // _WIN32


//* MIDI data block header */
type
     LPMIDIHDR = ^midihdr_tag;
     midihdr_tag = record
       lpData:LPSTR;               //* pointer to locked data block */
       dwBufferLength:DWORD;       //* length of data in data block */
       dwBytesRecorded:DWORD;      //* used for input only */
       dwUser:DWORD;               //* for client's use */
       dwFlags:DWORD;              //* assorted flags (see defines) */
       lpNext:LPMIDIHDR;           //* reserved for driver */
       reserved:DWORD;             //* reserved for driver */
//#if (WINVER >= 0x0400)
       dwOffset:DWORD;             //* Callback offset into buffer */
       dwReserved:array[0..7] of DWORD;        //* Reserved for MMSYSTEM */
//#endif
     end;
     MIDIHDR = midihdr_tag;
     PMIDIHDR = ^midihdr_tag;
     NPMIDIHDR = ^midihdr_tag;

type
     midievent_tag = record
       dwDeltaTime:DWORD;          //* Ticks since last event */
       dwStreamID:DWORD;           //* Reserved; must be zero */
       dwEvent:DWORD;              //* Event type and parameters */
       dwParms:array[0..0] of DWORD;  //* Parameters if this is a long event */
     end;
     MIDIEVENT = midievent_tag;

type
     midistrmbuffver_tag = record
       dwVersion:DWORD;                  //* Stream buffer format version */
       dwMid:DWORD;                      //* Manufacturer ID as defined in MMREG.H */
       dwOEMVersion:DWORD;               //* Manufacturer version for custom ext */
     end;
     MIDISTRMBUFFVER = midistrmbuffver_tag;

const
//* flags for dwFlags field of MIDIHDR structure */
      MHDR_DONE       = $00000001;       //* done bit */
      MHDR_PREPARED   = $00000002;       //* set if header prepared */
      MHDR_INQUEUE    = $00000004;       //* reserved for driver */
      MHDR_ISSTRM     = $00000008;       //* Buffer is stream buffer */
      MHDR_SENDING    = $00000020;       //* Internal */
      MHDR_MAPPED     = $00001000;       //* thunked header */   /* Internal */
      MHDR_SHADOWHDR  = $00002000;       //* MIDIHDR is 16-bit shadow */ /* Internal */
      MHDR_VALID      = $e000302F;       //* valid flags */      /* Internal */

      MHDR_SAVE       = $e0003000;       //* Save these flags */  /* Internal */
                                         //* past driver calls */ /* Internal */

//* Dreamcast-only flags for tonebank support */
      MHDR_WRITEABLE    = $e0000000;
      MHDR_GENERALMIDI  = $80000000;     //* Indicates a tonebank that is to be used */
                                         //* by General MIDI stream ports */
      MHDR_GMDRUM       = $40000000;     //* In combination with GENERALMIDI, indicates */
                                         //* a GM drum tonebank.  By itself, indicates an */
                                         //* "alternate" GM drum tonebank */
      MHDR_MAPPINGTABLE = $20000000;     //* Indicates that this MIDIHDR is for a */
                                         //* program mapping table rather than an actual */
                                         //* tonebank */

//* */
//* Type codes which go in the high byte of the event DWORD of a stream buffer */
//* */
//* Type codes 00-7F contain parameters within the low 24 bits */
//* Type codes 80-FF contain a length of their parameter in the low 24 */
//* bits, followed by their parameter data in the buffer. The event */
//* DWORD contains the exact byte length; the parm data itself must be */
//* padded to be an even multiple of 4 bytes long. */
//* */
const
      MEVT_F_SHORT        = $00000000;
      MEVT_F_LONG         = $80000000;
      MEVT_F_CALLBACK     = $40000000;

      MEVT_SHORTMSG       = byte($00);    //* parm = shortmsg for midiOutShortMsg */
      MEVT_TEMPO          = byte($01);    //* parm = new tempo in microsec/qn     */
      MEVT_NOP            = byte($02);    //* parm = unused; does nothing         */

function MEVT_EVENTTYPE(x:DWORD):byte;
function MEVT_EVENTPARM(x:DWORD):DWORD;

//* 0x04-0x7F reserved */
const
      MEVT_LONGMSG        = byte($80);    //* parm = bytes to send verbatim       */
      MEVT_COMMENT        = byte($82);    //* parm = comment data                 */
      MEVT_VERSION        = byte($84);    //* parm = MIDISTRMBUFFVER struct       */

//* 0x81-0xFF reserved */

      MIDISTRM_ERROR      = -2;

//* */
//* Structures and defines for midiStreamProperty */
//* */
      MIDIPROP_SET        = $80000000;
      MIDIPROP_GET        = $40000000;

//* These are intentionally both non-zero so the app cannot accidentally */
//* leave the operation off and happen to appear to work due to default */
//* action. */

function MIDIPROP_PROPERTY(mp:DWORD):DWORD;

const
      MIDIPROP_TIMEDIV     = 00000001;
      MIDIPROP_TEMPO       = 00000002;
      MIDIPROP_SMF         = 00000003;
      MIDIPROP_BUFFERED    = 00000004;
      MIDIPROP_LOOPING     = 00000005;
      MIDIPROP_GENERALMIDI = 00000006;

//* Some useful defines to help with Standard MIDI File Format stuff */
      SMF_TIMEDIV_QUARTERNOTE = 0;
      SMF_TIMEDIV_SECONDS     = 1;


function SMF_TIMEDIV(format:DWORD; division:DWORD):DWORD;
function SMF_TIMEDIV_SMPTE(smpte:DWORD; division:DWORD):DWORD;
function SMF_TIMEDIV_ISSMPTE(dw:DWORD):DWORD;
function SMF_TIMEDIV_GETSMPTE(dw:DWORD):byte;
function SMF_TIMEDIV_GETTPF(dw:DWORD):DWORD;
function SMF_TIMEDIV_GETTPQN(dw:DWORD):DWORD;

type
     midiproptimediv_tag = record
       cbStruct:DWORD;
       dwTimeDiv:DWORD;
     end;
     MIDIPROPTIMEDIV = midiproptimediv_tag;
     LPMIDIPROPTIMEDIV = ^midiproptimediv_tag;

type
     midiproptempo_tag = record
       cbStruct:DWORD;
       dwTempo:DWORD;
     end;
     MIDIPROPTEMPO = midiproptempo_tag;
     LPMIDIPROPTEMPO = ^midiproptempo_tag;

const
      MIDIPROP_PROPVAL    = $3FFFFFFF; //* Internal */

// The library exports midi-functions.
{$IFDEF _WIN32}
const
      MIDIDLL = 'winmm.dll';
{$ELSE _WIN32}
const
      MIDIDLL = KernelDLL;
{$ENDIF _WIN32}

//* MIDI function prototypes */
function midiOutGetNumDevs:UINT; external MIDIDLL name 'midiOutGetNumDevs';
function midiStreamOpen(phms:LPHMIDISTRM; puDeviceID:LPUINT; cMidi:DWORD; dwCallback:DWORD; dwInstance:DWORD; fdwOpen:DWORD):MMRESULT; external MIDIDLL name 'midiStreamOpen'; // index
function midiStreamClose(hms:HMIDISTRM):MMRESULT; external MIDIDLL name 'midiStreamClose'; // index

function midiStreamProperty(hms:HMIDISTRM; lppropdata:LPBYTE; dwProperty:DWORD):MMRESULT; external MIDIDLL name 'midiStreamProperty'; // index
function midiStreamPosition(hms:HMIDISTRM; lpmmt:LPMMTIME; cbmmt:UINT):MMRESULT; external MIDIDLL name 'midiStreamPosition'; // index

function midiStreamOut(hms:HMIDISTRM; pmh:LPMIDIHDR; cbmh:UINT):MMRESULT; external MIDIDLL name 'midiStreamOut'; // index
function midiStreamPause(hms:HMIDISTRM):MMRESULT; external MIDIDLL name 'midiStreamPause'; // index
function midiStreamRestart(hms:HMIDISTRM):MMRESULT; external MIDIDLL name 'midiStreamRestart'; // index
function midiStreamStop(hms:HMIDISTRM):MMRESULT; external MIDIDLL name 'midiStreamStop'; // index

{$IFDEF _WIN32}
function midiConnect(hmi:HMIDI; hmo:HMIDIOUT; pReserved:LPVOID):MMRESULT; external MIDIDLL name 'midiConnect'; // index
function midiDisconnect(hmi:HMIDI; hmo:HMIDIOUT; pReserved:LPVOID):MMRESULT; external MIDIDLL name 'midiDisconnect'; // index
{$ENDIF} // _WIN32


{$IFDEF _WIN32}
function midiOutGetDevCapsA(uDeviceID:UINT; pmoc:LPMIDIOUTCAPSA; cbmoc:UINT):MMRESULT; external MIDIDLL name 'midiOutGetDevCapsA'; // index
function midiOutGetDevCapsW(uDeviceID:UINT; pmoc:LPMIDIOUTCAPSW; cbmoc:UINT):MMRESULT; external MIDIDLL name 'midiOutGetDevCapsW'; // index
{$IFDEF UNICODE}
function midiOutGetDevCaps(uDeviceID:UINT; pmoc:LPMIDIOUTCAPSW; cbmoc:UINT):MMRESULT; external MIDIDLL name 'midiOutGetDevCapsW'; // index
{$ELSE} // UNICODE
function midiOutGetDevCaps(uDeviceID:UINT; pmoc:LPMIDIOUTCAPSA; cbmoc:UINT):MMRESULT; external MIDIDLL name 'midiOutGetDevCapsA'; // index
{$ENDIF} // UNICODE

{$ELSE} // _WIN32
function midiOutGetDevCaps(uDeviceID:UINT; pmoc:LPMIDIOUTCAPS; cbmoc:UINT):MMRESULT; external MIDIDLL name 'midiOutGetDevCaps'; // index
{$ENDIF} // _WIN32

function midiOutGetVolume(hmo:HMIDIOUT; pdwVolume:LPDWORD):MMRESULT; external MIDIDLL name 'midiOutGetVolume'; // index
function midiOutSetVolume(hmo:HMIDIOUT; dwVolume:DWORD):MMRESULT; external MIDIDLL name 'midiOutSetVolume'; // index

{$IFDEF _WIN32}
function midiOutGetErrorTextA(mmrError:MMRESULT; pszText:LPSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiOutGetErrorTextA'; // index
function midiOutGetErrorTextW(mmrError:MMRESULT; pszText:LPWSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiOutGetErrorTextW'; // index
{$IFDEF UNICODE}
function midiOutGetErrorText(mmrError:MMRESULT; pszText:LPWSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiOutGetErrorTextW'; // index
{$ELSE} // UNICODE
function midiOutGetErrorText(mmrError:MMRESULT; pszText:LPSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiOutGetErrorTextA'; // index
{$ENDIF} // UNICODE
{$ELSE} // _WIN32
function midiOutGetErrorText(mmrError:MMRESULT; pszText:LPSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiOutGetErrorText'; // index
{$ENDIF} // _WIN32

function midiOutOpen(phmo:LPHMIDIOUT; uDeviceID:UINT;
    dwCallback:DWORD; dwInstance:DWORD; fdwOpen:DWORD):MMRESULT; external MIDIDLL name 'midiOutOpen'; // index
function midiOutClose(hmo:HMIDIOUT):MMRESULT; external MIDIDLL name 'midiOutClose'; // index
function midiOutPrepareHeader(hmo:HMIDIOUT; pmh:LPMIDIHDR; cbmh:UINT):MMRESULT; external MIDIDLL name 'midiOutPrepareHeader'; // index
function midiOutUnprepareHeader(hmo:HMIDIOUT; pmh:LPMIDIHDR; cbmh:UINT):MMRESULT; external MIDIDLL name 'midiOutUnprepareHeader'; // index
function midiOutShortMsg(hmo:HMIDIOUT; dwMsg:DWORD):MMRESULT; external MIDIDLL name 'midiOutShortMsg'; // index
function midiOutLongMsg(hmo:HMIDIOUT; pmh:LPMIDIHDR; cbmh:UINT):MMRESULT; external MIDIDLL name 'midiOutLongMsg'; // index
function midiOutReset(hmo:HMIDIOUT):MMRESULT; external MIDIDLL name 'midiOutReset'; // index
function midiOutCachePatches(hmo:HMIDIOUT; uBank:UINT; pwpa:LPWORD; fuCache:UINT):MMRESULT; external MIDIDLL name 'midiOutCachePatches'; // index
function midiOutCacheDrumPatches(hmo:HMIDIOUT; uPatch:UINT; pwkya:LPWORD; fuCache:UINT):MMRESULT; external MIDIDLL name 'midiOutCacheDrumPatches'; // index
function midiOutGetID(hmo:HMIDIOUT; puDeviceID:LPUINT):MMRESULT; external MIDIDLL name 'midiOutGetID'; // index

{$IFDEF _WIN32}
function midiOutMessage(hmo:HMIDIOUT; uMsg:UINT; dw1:DWORD; dw2:DWORD):MMRESULT; external MIDIDLL name 'midiOutMessage'; // index
{$ELSE} // _WIN32
function midiOutMessage(hmo:HMIDIOUT; uMsg:UINT; dw1:DWORD; dw2:DWORD):DWORD; external MIDIDLL name 'midiOutMessage'; // index
{$ENDIF} // _WIN32

function midiInGetNumDevs:UINT; external MIDIDLL name 'midiInGetNumDevs'; // index

{$IFDEF _WIN32}
function midiInGetDevCapsA(uDeviceID:UINT; pmic:LPMIDIINCAPSA; cbmic:UINT):MMRESULT; external MIDIDLL name 'midiInGetDevCapsA'; // index
function midiInGetDevCapsW(uDeviceID:UINT; pmic:LPMIDIINCAPSW; cbmic:UINT):MMRESULT; external MIDIDLL name 'midiInGetDevCapsW'; // index
{$IFDEF UNICODE}
function midiInGetDevCaps(uDeviceID:UINT; pmic:LPMIDIINCAPSW; cbmic:UINT):MMRESULT; external MIDIDLL name 'midiInGetDevCapsW'; // index
{$ELSE} // UNICODE
function midiInGetDevCaps(uDeviceID:UINT; pmic:LPMIDIINCAPSA; cbmic:UINT):MMRESULT; external MIDIDLL name 'midiInGetDevCapsA'; // index
{$ENDIF} // UNICODE

function midiInGetErrorTextA(mmrError:MMRESULT; pszText:LPSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiInGetErrorTextA'; // index
function midiInGetErrorTextW(mmrError:MMRESULT; pszText:LPWSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiInGetErrorTextW'; // index
{$IFDEF UNICODE}
function midiInGetErrorText(mmrError:MMRESULT; pszText:LPWSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiInGetErrorTextW'; // index
{$ELSE} // UNICODE
function midiInGetErrorText(mmrError:MMRESULT; pszText:LPSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiInGetErrorTextA'; // index
{$ENDIF} // UNICODE

{$ELSE} // _WIN32
function midiInGetDevCaps(uDeviceID:UINT; pmic:LPMIDIINCAPS; cbmic:UINT):MMRESULT; external MIDIDLL name 'midiInGetDevCaps'; // index
function midiInGetErrorText(mmrError:MMRESULT; pszText:LPSTR; cchText:UINT):MMRESULT; external MIDIDLL name 'midiInGetErrorText'; // index
{$ENDIF} // _WIN32

function midiInOpen(phmi:LPHMIDIIN; uDeviceID:UINT;
        dwCallback:DWORD; dwInstance:DWORD; fdwOpen:DWORD):MMRESULT; external MIDIDLL name 'midiInOpen'; // index
function midiInClose(hmi:HMIDIIN):MMRESULT; external MIDIDLL name 'midiInClose'; // index
function midiInPrepareHeader(hmi:HMIDIIN; pmh:LPMIDIHDR; cbmh:UINT):MMRESULT; external MIDIDLL name 'midiInPrepareHeader'; // index
function midiInUnprepareHeader(hmi:HMIDIIN; pmh:LPMIDIHDR; cbmh:UINT):MMRESULT; external MIDIDLL name 'midiInUnprepareHeader'; // index
function midiInAddBuffer(hmi:HMIDIIN; pmh:LPMIDIHDR; cbmh:UINT):MMRESULT; external MIDIDLL name 'midiInAddBuffer'; // index
function midiInStart(hmi:HMIDIIN):MMRESULT; external MIDIDLL name 'midiInStart'; // index
function midiInStop(hmi:HMIDIIN):MMRESULT; external MIDIDLL name 'midiInStop'; // index
function midiInReset(hmi:HMIDIIN):MMRESULT; external MIDIDLL name 'midiInReset'; // index
function midiInGetID(hmi:HMIDIIN; puDeviceID:LPUINT):MMRESULT; external MIDIDLL name 'midiInGetID'; // index

{$IFDEF _WIN32}
function midiInMessage(hmi:HMIDIIN; uMsg:UINT; dw1:DWORD; dw2:DWORD):MMRESULT; external MIDIDLL name 'midiInMessage'; // index
{$ELSE} // _WIN32
function midiInMessage(hmi:HMIDIIN; uMsg:UINT; dw1:DWORD; dw2:DWORD):DWORD; external MIDIDLL name 'midiInMessage'; // index
{$ENDIF} // _WIN32

{$ENDIF} // MMNOMIDI 



{$IFNDEF MMNOMIXER}
{****************************************************************************

                            Mixer Support

****************************************************************************}

type
     HMIXEROBJ = HANDLE;
     LPHMIXEROBJ = ^HMIXEROBJ;

     HMIXER = HANDLE;
     LPHMIXER = ^HMIXER;

const
      MIXER_SHORT_NAME_CHARS   = 16;
      MIXER_LONG_NAME_CHARS    = 64;

//* */
//*  MMRESULT error return values specific to the mixer API */
//* */
//* */
const
      MIXERR_INVALLINE            = MIXERR_BASE + 0;
      MIXERR_INVALCONTROL         = MIXERR_BASE + 1;
      MIXERR_INVALVALUE           = MIXERR_BASE + 2;
      MIXERR_LASTERROR            = MIXERR_BASE + 2;

      MIXER_OBJECTF_HANDLE    = $80000000;
      MIXER_OBJECTF_MIXER     = $00000000;
      MIXER_OBJECTF_HMIXER    = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_MIXER;
      MIXER_OBJECTF_WAVEOUT   = $10000000;
      MIXER_OBJECTF_HWAVEOUT  = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_WAVEOUT;
      MIXER_OBJECTF_WAVEIN    = $20000000;
      MIXER_OBJECTF_HWAVEIN   = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_WAVEIN;
      MIXER_OBJECTF_MIDIOUT   = $30000000;
      MIXER_OBJECTF_HMIDIOUT  = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_MIDIOUT;
      MIXER_OBJECTF_MIDIIN    = $40000000;
      MIXER_OBJECTF_HMIDIIN   = MIXER_OBJECTF_HANDLE or MIXER_OBJECTF_MIDIIN;
      MIXER_OBJECTF_AUX       = $50000000;

function mixerGetNumDevs:UINT; external KernelDLL name 'mixerGetNumDevs'; // index 2AE

type
     tagMIXERCAPS = record
       wMid:word;                   //* manufacturer id */
       wPid:word;                   //* product id */
       vDriverVersion:MMVERSION;    //* version of the driver */
       szPname:array[0..MAXPNAMELEN-1] of TCHAR;  //* product name */
       fdwSupport:DWORD;             //* misc. support bits */
       cDestinations:DWORD;          //* count of destinations */
     end;
     MIXERCAPS = tagMIXERCAPS;
     PMIXERCAPS = ^tagMIXERCAPS;
     LPMIXERCAPS = ^tagMIXERCAPS;

function mixerGetDevCaps(uMxId:UINT; pmxcaps:LPMIXERCAPS; cbmxcaps:UINT):MMRESULT; external KernelDLL name 'mixerGetDevCaps'; // index 2AA

function mixerOpen(phmx:LPHMIXER; uMxId:UINT; dwCallback:DWORD; dwInstance:DWORD; fdwOpen:DWORD):MMRESULT; external KernelDLL name 'mixerOpen'; // index 2B0

function mixerClose(hmx:HMIXER):MMRESULT; external KernelDLL name 'mixerClose'; // index 2B2

function mixerMessage(hmx:HMIXER; uMsg:UINT; dwParam1:DWORD; dwParam2:DWORD):DWORD; external KernelDLL name 'mixerMessage'; // index 2AF

type
     tMIXERLINE = record
       cbStruct:DWORD;               //* size of MIXERLINE structure */
       dwDestination:DWORD;          //* zero based destination index */
       dwSource:DWORD;               //* zero based source index (if source) */
       dwLineID:DWORD;               //* unique line id for mixer device */
       fdwLine:DWORD;                //* state/information about line */
       dwUser:DWORD;                 //* driver specific information */
       dwComponentType:DWORD;        //* component type line connects to */
       cChannels:DWORD;              //* number of channels line supports */
       cConnections:DWORD;           //* number of connections [possible] */
       cControls:DWORD;              //* number of controls at this line */
       szShortName:array[0..MIXER_SHORT_NAME_CHARS-1] of TCHAR;
       szName:array[0..MIXER_LONG_NAME_CHARS-1] of TCHAR;
       Target:record
         dwType:DWORD;                 //* MIXERLINE_TARGETTYPE_xxxx */
         dwDeviceID:DWORD;             //* target device ID of device type */
         wMid:word;                   //* of target device */
         wPid:word;                   //*      " */
         vDriverVersion:MMVERSION;         //*      " */
         szPname:array[0..MAXPNAMELEN-1] of TCHAR;   //*      " */
       end;
     end;
     MIXERLINE = tMIXERLINE;
     PMIXERLINE = ^tMIXERLINE;
     LPMIXERLINE = ^tMIXERLINE;

//* */
//*  MIXERLINE.fdwLine */
//* */
//* */
const
      MIXERLINE_LINEF_ACTIVE              = $00000001;
      MIXERLINE_LINEF_DISCONNECTED        = $00008000;
      MIXERLINE_LINEF_SOURCE              = $80000000;

//* */
//*  MIXERLINE.dwComponentType */
//* */
//*  component types for destinations and sources */
//* */
//* */
      MIXERLINE_COMPONENTTYPE_DST_FIRST       = $00000000;
      MIXERLINE_COMPONENTTYPE_DST_UNDEFINED   = MIXERLINE_COMPONENTTYPE_DST_FIRST + 0;
      MIXERLINE_COMPONENTTYPE_DST_DIGITAL     = MIXERLINE_COMPONENTTYPE_DST_FIRST + 1;
      MIXERLINE_COMPONENTTYPE_DST_LINE        = MIXERLINE_COMPONENTTYPE_DST_FIRST + 2;
      MIXERLINE_COMPONENTTYPE_DST_MONITOR     = MIXERLINE_COMPONENTTYPE_DST_FIRST + 3;
      MIXERLINE_COMPONENTTYPE_DST_SPEAKERS    = MIXERLINE_COMPONENTTYPE_DST_FIRST + 4;
      MIXERLINE_COMPONENTTYPE_DST_HEADPHONES  = MIXERLINE_COMPONENTTYPE_DST_FIRST + 5;
      MIXERLINE_COMPONENTTYPE_DST_TELEPHONE   = MIXERLINE_COMPONENTTYPE_DST_FIRST + 6;
      MIXERLINE_COMPONENTTYPE_DST_WAVEIN      = MIXERLINE_COMPONENTTYPE_DST_FIRST + 7;
      MIXERLINE_COMPONENTTYPE_DST_VOICEIN     = MIXERLINE_COMPONENTTYPE_DST_FIRST + 8;
      MIXERLINE_COMPONENTTYPE_DST_LAST        = MIXERLINE_COMPONENTTYPE_DST_FIRST + 8;

      MIXERLINE_COMPONENTTYPE_SRC_FIRST       = $00001000;
      MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED   = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 0;
      MIXERLINE_COMPONENTTYPE_SRC_DIGITAL     = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 1;
      MIXERLINE_COMPONENTTYPE_SRC_LINE        = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 2;
      MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE  = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 3;
      MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 4;
      MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 5;
      MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE   = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 6;
      MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER   = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 7;
      MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT     = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 8;
      MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY   = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 9;
      MIXERLINE_COMPONENTTYPE_SRC_ANALOG      = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 10;
      MIXERLINE_COMPONENTTYPE_SRC_LAST        = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 10;

//* */
//*  MIXERLINE.Target.dwType */
//* */
//* */
      MIXERLINE_TARGETTYPE_UNDEFINED      = 0;
      MIXERLINE_TARGETTYPE_WAVEOUT        = 1;
      MIXERLINE_TARGETTYPE_WAVEIN         = 2;
      MIXERLINE_TARGETTYPE_MIDIOUT        = 3;
      MIXERLINE_TARGETTYPE_MIDIIN         = 4;
      MIXERLINE_TARGETTYPE_AUX            = 5;


function mixerGetLineInfo(hmxobj:HMIXEROBJ; pmxl:LPMIXERLINE; fdwInfo:DWORD):MMRESULT; external KernelDLL name 'mixerGetLineInfo'; // index 2AD

const
      MIXER_GETLINEINFOF_DESTINATION      = $00000000;
      MIXER_GETLINEINFOF_SOURCE           = $00000001;
      MIXER_GETLINEINFOF_LINEID           = $00000002;
      MIXER_GETLINEINFOF_COMPONENTTYPE    = $00000003;
      MIXER_GETLINEINFOF_TARGETTYPE       = $00000004;

      MIXER_GETLINEINFOF_QUERYMASK        = $0000000F;

function mixerGetID(hmxobj:HMIXEROBJ; puMxId:LPUINT; fdwId:DWORD):MMRESULT; external KernelDLL name 'mixerGetID'; // index 2AB

//* */
//*  MIXERCONTROL */
//* */
//* */
type
     tMIXERCONTROL = record
       cbStruct:DWORD;           //* size in bytes of MIXERCONTROL */
       dwControlID:DWORD;        //* unique control id for mixer device */
       dwControlType:DWORD;      //* MIXERCONTROL_CONTROLTYPE_xxx */
       fdwControl:DWORD;         //* MIXERCONTROL_CONTROLF_xxx */
       cMultipleItems:DWORD;     //* if MIXERCONTROL_CONTROLF_MULTIPLE set */
       szShortName:array[0..MIXER_SHORT_NAME_CHARS-1] of TCHAR;
       szName:array[0..MIXER_LONG_NAME_CHARS-1] of TCHAR;
       Bounds:record
         case DWORD of
           0: (lMinimum:LONG;           //* signed minimum for this control */
               lMaximum:LONG);           //* signed maximum for this control */
           1: (dwMinimum:DWORD;          //* unsigned minimum for this control */
               dwMaximum:DWORD);          //* unsigned maximum for this control */
           2: (dwReserved:array[0..5] of DWORD);
       end;
       Metrics:record
         case DWORD of
           0: (cSteps:DWORD);             //* # of steps between min & max */
           1: (cbCustomData:DWORD);       //* size in bytes of custom data */
           2: (dwReserved:array[0..5] of DWORD);
       end;
    end;
    MIXERCONTROL = tMIXERCONTROL;
    PMIXERCONTROL = ^tMIXERCONTROL;
    LPMIXERCONTROL = ^tMIXERCONTROL;

const    
//* */
//*  MIXERCONTROL.fdwControl */
//* */
//* */
      MIXERCONTROL_CONTROLF_UNIFORM   = $00000001;
      MIXERCONTROL_CONTROLF_MULTIPLE  = $00000002;
      MIXERCONTROL_CONTROLF_DISABLED  = $80000000;

//* */
//*  MIXERCONTROL_CONTROLTYPE_xxx building block defines */
//* */
//* */
      MIXERCONTROL_CT_CLASS_MASK          = $F0000000;
      MIXERCONTROL_CT_CLASS_CUSTOM        = $00000000;
      MIXERCONTROL_CT_CLASS_METER         = $10000000;
      MIXERCONTROL_CT_CLASS_SWITCH        = $20000000;
      MIXERCONTROL_CT_CLASS_NUMBER        = $30000000;
      MIXERCONTROL_CT_CLASS_SLIDER        = $40000000;
      MIXERCONTROL_CT_CLASS_FADER         = $50000000;
      MIXERCONTROL_CT_CLASS_TIME          = $60000000;
      MIXERCONTROL_CT_CLASS_LIST          = $70000000;

      MIXERCONTROL_CT_SUBCLASS_MASK       = $0F000000;

      MIXERCONTROL_CT_SC_SWITCH_BOOLEAN   = $00000000;
      MIXERCONTROL_CT_SC_SWITCH_BUTTON    = $01000000;

      MIXERCONTROL_CT_SC_METER_POLLED     = $00000000;

      MIXERCONTROL_CT_SC_TIME_MICROSECS   = $00000000;
      MIXERCONTROL_CT_SC_TIME_MILLISECS   = $01000000;

      MIXERCONTROL_CT_SC_LIST_SINGLE      = $00000000;
      MIXERCONTROL_CT_SC_LIST_MULTIPLE    = $01000000;

      MIXERCONTROL_CT_UNITS_MASK          = $00FF0000;
      MIXERCONTROL_CT_UNITS_CUSTOM        = $00000000;
      MIXERCONTROL_CT_UNITS_BOOLEAN       = $00010000;
      MIXERCONTROL_CT_UNITS_SIGNED        = $00020000;
      MIXERCONTROL_CT_UNITS_UNSIGNED      = $00030000;
      MIXERCONTROL_CT_UNITS_DECIBELS      = $00040000; //* in 10ths */
      MIXERCONTROL_CT_UNITS_PERCENT       = $00050000; //* in 10ths */

//* */
//*  Commonly used control types for specifying MIXERCONTROL.dwControlType */
//* */

      MIXERCONTROL_CONTROLTYPE_CUSTOM         = MIXERCONTROL_CT_CLASS_CUSTOM or MIXERCONTROL_CT_UNITS_CUSTOM;
      MIXERCONTROL_CONTROLTYPE_BOOLEANMETER   = MIXERCONTROL_CT_CLASS_METER or MIXERCONTROL_CT_SC_METER_POLLED or MIXERCONTROL_CT_UNITS_BOOLEAN;
      MIXERCONTROL_CONTROLTYPE_SIGNEDMETER    = MIXERCONTROL_CT_CLASS_METER or MIXERCONTROL_CT_SC_METER_POLLED or MIXERCONTROL_CT_UNITS_SIGNED;
      MIXERCONTROL_CONTROLTYPE_PEAKMETER      = MIXERCONTROL_CONTROLTYPE_SIGNEDMETER + 1;
      MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER  = MIXERCONTROL_CT_CLASS_METER or MIXERCONTROL_CT_SC_METER_POLLED or MIXERCONTROL_CT_UNITS_UNSIGNED;
      MIXERCONTROL_CONTROLTYPE_BOOLEAN        = MIXERCONTROL_CT_CLASS_SWITCH or MIXERCONTROL_CT_SC_SWITCH_BOOLEAN or MIXERCONTROL_CT_UNITS_BOOLEAN;
      MIXERCONTROL_CONTROLTYPE_ONOFF          = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 1;
      MIXERCONTROL_CONTROLTYPE_MUTE           = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 2;
      MIXERCONTROL_CONTROLTYPE_MONO           = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 3;
      MIXERCONTROL_CONTROLTYPE_LOUDNESS       = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 4;
      MIXERCONTROL_CONTROLTYPE_STEREOENH      = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 5;

// - mmreg.h
      MIXERCONTROL_CONTROLTYPE_SRS_MTS                = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 6;
      MIXERCONTROL_CONTROLTYPE_SRS_ONOFF              = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 7;
      MIXERCONTROL_CONTROLTYPE_SRS_SYNTHSELECT        = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 8;
// - end of mmreg.h

      MIXERCONTROL_CONTROLTYPE_BUTTON         = MIXERCONTROL_CT_CLASS_SWITCH or MIXERCONTROL_CT_SC_SWITCH_BUTTON or MIXERCONTROL_CT_UNITS_BOOLEAN;
      MIXERCONTROL_CONTROLTYPE_DECIBELS       = MIXERCONTROL_CT_CLASS_NUMBER or MIXERCONTROL_CT_UNITS_DECIBELS;
      MIXERCONTROL_CONTROLTYPE_SIGNED         = MIXERCONTROL_CT_CLASS_NUMBER or MIXERCONTROL_CT_UNITS_SIGNED;
      MIXERCONTROL_CONTROLTYPE_UNSIGNED       = MIXERCONTROL_CT_CLASS_NUMBER or MIXERCONTROL_CT_UNITS_UNSIGNED;
      MIXERCONTROL_CONTROLTYPE_PERCENT        = MIXERCONTROL_CT_CLASS_NUMBER or MIXERCONTROL_CT_UNITS_PERCENT;
      MIXERCONTROL_CONTROLTYPE_SLIDER         = MIXERCONTROL_CT_CLASS_SLIDER or MIXERCONTROL_CT_UNITS_SIGNED;
      MIXERCONTROL_CONTROLTYPE_PAN            = MIXERCONTROL_CONTROLTYPE_SLIDER + 1;
      MIXERCONTROL_CONTROLTYPE_QSOUNDPAN      = MIXERCONTROL_CONTROLTYPE_SLIDER + 2;
      MIXERCONTROL_CONTROLTYPE_FADER          = MIXERCONTROL_CT_CLASS_FADER or MIXERCONTROL_CT_UNITS_UNSIGNED;
      MIXERCONTROL_CONTROLTYPE_VOLUME         = MIXERCONTROL_CONTROLTYPE_FADER + 1;
      MIXERCONTROL_CONTROLTYPE_BASS           = MIXERCONTROL_CONTROLTYPE_FADER + 2;
      MIXERCONTROL_CONTROLTYPE_TREBLE         = MIXERCONTROL_CONTROLTYPE_FADER + 3;
      MIXERCONTROL_CONTROLTYPE_EQUALIZER      = MIXERCONTROL_CONTROLTYPE_FADER + 4;
      MIXERCONTROL_CONTROLTYPE_SINGLESELECT   = MIXERCONTROL_CT_CLASS_LIST or MIXERCONTROL_CT_SC_LIST_SINGLE or MIXERCONTROL_CT_UNITS_BOOLEAN;
      MIXERCONTROL_CONTROLTYPE_MUX            = MIXERCONTROL_CONTROLTYPE_SINGLESELECT + 1;
      MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT = MIXERCONTROL_CT_CLASS_LIST or MIXERCONTROL_CT_SC_LIST_MULTIPLE or MIXERCONTROL_CT_UNITS_BOOLEAN;
      MIXERCONTROL_CONTROLTYPE_MIXER          = MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT + 1;
      MIXERCONTROL_CONTROLTYPE_MICROTIME      = MIXERCONTROL_CT_CLASS_TIME or MIXERCONTROL_CT_SC_TIME_MICROSECS or MIXERCONTROL_CT_UNITS_UNSIGNED;
      MIXERCONTROL_CONTROLTYPE_MILLITIME      = MIXERCONTROL_CT_CLASS_TIME or MIXERCONTROL_CT_SC_TIME_MILLISECS or MIXERCONTROL_CT_UNITS_UNSIGNED;

//* */
//*  MIXERLINECONTROLS */
//* */
type
     tMIXERLINECONTROLS = record
       cbStruct:DWORD;       //* size in bytes of MIXERLINECONTROLS */
       dwLineID:DWORD;       //* line id (from MIXERLINE.dwLineID) */
       case DWORD of
         0: (dwControlID:DWORD); //* MIXER_GETLINECONTROLSF_ONEBYID */
         1: (dwControlType:DWORD;  //* MIXER_GETLINECONTROLSF_ONEBYTYPE */
             cControls:DWORD;      //* count of controls pmxctrl points to */
             cbmxctrl:DWORD;       //* size in bytes of _one_ MIXERCONTROL */
             pamxctrl:LPMIXERCONTROL);  //* pointer to first MIXERCONTROL array */
       end;
       MIXERLINECONTROLS = tMIXERLINECONTROLS;
       PMIXERLINECONTROLS = ^tMIXERLINECONTROLS;
       LPMIXERLINECONTROLS = ^tMIXERLINECONTROLS;

function mixerGetLineControls(hmxobj:HMIXEROBJ; pmxlc:LPMIXERLINECONTROLS; fdwControls:DWORD):MMRESULT; external KernelDLL name 'mixerGetLineControls'; // index 2AC

const
      MIXER_GETLINECONTROLSF_ALL          = $00000000;
      MIXER_GETLINECONTROLSF_ONEBYID      = $00000001;
      MIXER_GETLINECONTROLSF_ONEBYTYPE    = $00000002;

      MIXER_GETLINECONTROLSF_QUERYMASK    = $0000000F;

type
     tMIXERCONTROLDETAILS = record
       cbStruct:DWORD;       //* size in bytes of MIXERCONTROLDETAILS */
       dwControlID:DWORD;    //* control id to get/set details on */
       cChannels:DWORD;      //* number of channels in paDetails array */
       case DWORD of
         0: (hwndOwner:HWND);      //* for MIXER_SETCONTROLDETAILSF_CUSTOM */
         1: (cMultipleItems:DWORD; //* if _MULTIPLE, the number of items per channel */
             cbDetails:DWORD;      //* size of _one_ details_XX struct */
             paDetails:LPVOID);      //* pointer to array of details_XX structs */
     end;
     MIXERCONTROLDETAILS = tMIXERCONTROLDETAILS;
     PMIXERCONTROLDETAILS = ^tMIXERCONTROLDETAILS;
     LPMIXERCONTROLDETAILS = ^tMIXERCONTROLDETAILS;

//* */
//*  MIXER_GETCONTROLDETAILSF_LISTTEXT */
//* */
//* */
type
     tMIXERCONTROLDETAILS_LISTTEXT = record
       dwParam1:DWORD;
       dwParam2:DWORD;
       szName:array[0..MIXER_LONG_NAME_CHARS-1] of TCHAR;
     end;
     MIXERCONTROLDETAILS_LISTTEXT = tMIXERCONTROLDETAILS_LISTTEXT;
     PMIXERCONTROLDETAILS_LISTTEXT = ^tMIXERCONTROLDETAILS_LISTTEXT;
     LPMIXERCONTROLDETAILS_LISTTEXT = ^tMIXERCONTROLDETAILS_LISTTEXT;

//* */
//*  MIXER_GETCONTROLDETAILSF_VALUE */
//* */
//* */
type
     tMIXERCONTROLDETAILS_BOOLEAN = record
       fValue:LONG;
     end;
     MIXERCONTROLDETAILS_BOOLEAN = tMIXERCONTROLDETAILS_BOOLEAN;
     PMIXERCONTROLDETAILS_BOOLEAN = ^tMIXERCONTROLDETAILS_BOOLEAN;
     LPMIXERCONTROLDETAILS_BOOLEAN = ^tMIXERCONTROLDETAILS_BOOLEAN;

type
     tMIXERCONTROLDETAILS_SIGNED = record
       lValue:LONG;
     end;
     MIXERCONTROLDETAILS_SIGNED = tMIXERCONTROLDETAILS_SIGNED;
     PMIXERCONTROLDETAILS_SIGNED = ^tMIXERCONTROLDETAILS_SIGNED;
     LPMIXERCONTROLDETAILS_SIGNED = ^tMIXERCONTROLDETAILS_SIGNED;

type
     tMIXERCONTROLDETAILS_UNSIGNED = record
       dwValue:DWORD;
     end;
     MIXERCONTROLDETAILS_UNSIGNED = tMIXERCONTROLDETAILS_UNSIGNED;
     PMIXERCONTROLDETAILS_UNSIGNED = ^tMIXERCONTROLDETAILS_UNSIGNED;
     LPMIXERCONTROLDETAILS_UNSIGNED = ^tMIXERCONTROLDETAILS_UNSIGNED;

function mixerGetControlDetails(hmxobj:HMIXEROBJ; pmxcd:LPMIXERCONTROLDETAILS; fdwDetails:DWORD):MMRESULT; external KernelDLL name 'mixerGetControlDetails'; // index 2A9

const
      MIXER_GETCONTROLDETAILSF_VALUE      = $00000000;
      MIXER_GETCONTROLDETAILSF_LISTTEXT   = $00000001;

      MIXER_GETCONTROLDETAILSF_QUERYMASK  = $0000000F;

function mixerSetControlDetails(hmxobj:HMIXEROBJ; pmxcd:LPMIXERCONTROLDETAILS; fdwDetails:DWORD):MMRESULT; external KernelDLL name 'mixerSetControlDetails'; // index 2B1

const
      MIXER_SETCONTROLDETAILSF_VALUE      = $00000000;
      MIXER_SETCONTROLDETAILSF_CUSTOM     = $00000001;

      MIXER_SETCONTROLDETAILSF_QUERYMASK  = $0000000F;

{$ENDIF} // MMNOMIXER 


{$IFNDEF MMNOTIMER}
{****************************************************************************

                            Timer support

****************************************************************************}

//* timer error return values */
const
      TIMERR_NOERROR        = 0;                  //* no error */
      TIMERR_NOCANDO        = TIMERR_BASE+1;      //* request not completed */
      TIMERR_STRUCT         = TIMERR_BASE+33;     //* time struct size */

//* timer data types */
type
     TIMECALLBACK = procedure(uTimerID:UINT; uMsg:UINT; dwUser:DWORD; dw1:DWORD; dw2:DWORD); cdecl;
     LPTIMECALLBACK = TIMECALLBACK;

//* flags for fuEvent parameter of timeSetEvent() function */
const
      TIME_ONESHOT    = $0000;   //* program timer for single event */
      TIME_PERIODIC   = $0001;   //* program for continuous periodic event */

{.$IFDEF _WIN32}
      TIME_CALLBACK_FUNCTION      = $0000;  //* callback is function */
      TIME_CALLBACK_EVENT_SET     = $0010;  //* callback is event - use SetEvent */
      TIME_CALLBACK_EVENT_PULSE   = $0020;  //* callback is event - use PulseEvent */
      TIME_CALLBACK_TYPEMASK      = $00F0;  //* Internal */
{.$ENDIF} // _WIN32


//* timer device capabilities data structure */
type
     timecaps_tag = record
       wPeriodMin:UINT;     //* minimum period supported  */
       wPeriodMax:UINT;     //* maximum period supported  */
     end;
     TIMECAPS = timecaps_tag;
     PTIMECAPS = ^timecaps_tag;
     NPTIMECAPS = ^timecaps_tag;
     LPTIMECAPS = ^timecaps_tag;

{$IFDEF _WIN32}
const
      MMTimerDLL = 'winmm.dll';
{$ELSE _WIN32}
const
      MMTimerDLL = 'mmtimer.dll';
{$ENDIF _WIN32}

//* timer function prototypes */
function timeGetSystemTime(pmmt:LPMMTIME; cbmmt:UINT):MMRESULT; external MMTimerDLL name 'timeGetSystemTime'; // index
function timeGetTime:DWORD; external MMTimerDLL name 'timeGetTime'; // index
function timeSetEvent(uDelay:UINT;
                      uResolution:UINT;
                      fptc:LPTIMECALLBACK;
                      dwUser:DWORD;
                      fuEvent:UINT):MMRESULT; external MMTimerDLL name 'timeSetEvent'; // index
function timeKillEvent(uTimerID:UINT):MMRESULT; external MMTimerDLL name 'timeKillEvent'; // index
function timeGetDevCaps(ptc:LPTIMECAPS; cbtc:UINT):MMRESULT; external MMTimerDLL name 'timeGetDevCaps'; // index
function timeBeginPeriod(uPeriod:UINT):MMRESULT; external MMTimerDLL name 'timeBeginPeriod'; // index
function timeEndPeriod(uPeriod:UINT):MMRESULT; external MMTimerDLL name 'timeEndPeriod'; // index
function timeGetTimeSinceInterrupt:DWORD; external MMTimerDLL name 'timeGetTimeSinceInterrupt'; // index
function timeGetHardwareFrequency:DWORD; external MMTimerDLL name 'timeGetHardwareFrequency'; // index

{$ENDIF} // MMNOTIMER


{$IFNDEF MMNOMMIO}
{****************************************************************************

                        Multimedia File I/O support

****************************************************************************}

const
//* MMIO error return values */
      MMIOERR_BASE                = 256;
      MMIOERR_FILENOTFOUND        = MMIOERR_BASE + 1;  //* file not found */
      MMIOERR_OUTOFMEMORY         = MMIOERR_BASE + 2;  //* out of memory */
      MMIOERR_CANNOTOPEN          = MMIOERR_BASE + 3;  //* cannot open */
      MMIOERR_CANNOTCLOSE         = MMIOERR_BASE + 4;  //* cannot close */
      MMIOERR_CANNOTREAD          = MMIOERR_BASE + 5;  //* cannot read */
      MMIOERR_CANNOTWRITE         = MMIOERR_BASE + 6;  //* cannot write */
      MMIOERR_CANNOTSEEK          = MMIOERR_BASE + 7;  //* cannot seek */
      MMIOERR_CANNOTEXPAND        = MMIOERR_BASE + 8;  //* cannot expand file */
      MMIOERR_CHUNKNOTFOUND       = MMIOERR_BASE + 9;  //* chunk not found */
      MMIOERR_UNBUFFERED          = MMIOERR_BASE + 10; //*  */
      MMIOERR_PATHNOTFOUND        = MMIOERR_BASE + 11; //* path incorrect */
      MMIOERR_ACCESSDENIED        = MMIOERR_BASE + 12; //* file was protected */
      MMIOERR_SHARINGVIOLATION    = MMIOERR_BASE + 13; //* file in use */
      MMIOERR_NETWORKERROR        = MMIOERR_BASE + 14; //* network not responding */
      MMIOERR_TOOMANYOPENFILES    = MMIOERR_BASE + 15; //* no more file handles  */
      MMIOERR_INVALIDFILE         = MMIOERR_BASE + 16; //* default error file error */

//* MMIO constants */
      CFSEPCHAR       = '+';             //* compound file name separator AnsiChar. */

//* MMIO data types */
type
      HPSTR = ^AnsiChar;          //* a huge version of LPSTR */

      HMMIO = HANDLE;                  //* a handle to an open file */

type
     MMIOPROC = function(lpmmioinfo:LPSTR; uMsg:UINT; lParam1:LPARAM; lParam2:LPARAM):LRESULT; cdecl;
     LPMMIOPROC = MMIOPROC;

//* general MMIO information data structure */
type
     _MMIOINFO = record
      //* general fields */
       dwFlags:DWORD;        //* general status flags */
       fccIOProc:FOURCC;      //* pointer to I/O procedure */
       pIOProc:LPMMIOPROC;    //* pointer to I/O procedure */
       wErrorRet:UINT;      //* place for error to be returned */
       htask:HTASK;          //* alternate local task */

      //* fields maintained by MMIO functions during buffered I/O */
       cchBuffer:LONG;      //* size of I/O buffer (or 0L) */
       pchBuffer:HPSTR;      //* start of I/O buffer (or NULL) */
       pchNext:HPSTR;        //* pointer to next byte to read/write */
       pchEndRead:HPSTR;     //* pointer to last valid byte to read */
       pchEndWrite:HPSTR;    //* pointer to last byte to write */
       lBufOffset:LONG;     //* disk offset of start of buffer */

      //* fields maintained by I/O procedure */
       lDiskOffset:LONG;    //* disk offset of next read or write */
       adwInfo:array[0..2] of DWORD;     //* data specific to type of MMIOPROC */

      //* other fields maintained by MMIO */
       dwReserved1:DWORD;    //* reserved for MMIO use */
       dwReserved2:DWORD;    //* reserved for MMIO use */
       hmmio:HMMIO;          //* handle to open file */
     end;
     MMIOINFO = _MMIOINFO;
     PMMIOINFO = ^_MMIOINFO;
     NPMMIOINFO = ^_MMIOINFO;
     LPMMIOINFO = ^_MMIOINFO;
     LPCMMIOINFO = ^MMIOINFO;

//* RIFF chunk information data structure */
type
     _MMCKINFO = record
       ckid:FOURCC;           //* chunk ID */
       cksize:DWORD;         //* chunk size */
       fccType:FOURCC;        //* form type or list type */
       dwDataOffset:DWORD;   //* offset of data portion of chunk */
       dwFlags:DWORD;        //* flags used by MMIO functions */
     end;
     MMCKINFO = _MMCKINFO;
     PMMCKINFO = ^_MMCKINFO;
     NPMMCKINFO = ^_MMCKINFO;
     LPMMCKINFO = ^_MMCKINFO;
     LPCMMCKINFO = ^MMCKINFO;

const
//* bit field masks */
      MMIO_RWMODE     = $00000003;      //* open file for reading/writing/both */
      MMIO_SHAREMODE  = $00000070;      //* file sharing mode number */

//* read/write mode numbers (bit field MMIO_RWMODE) */
      MMIO_READ       = $00000000;      //* open file for reading only */
      MMIO_WRITE      = $00000001;      //* open file for writing only */
      MMIO_READWRITE  = $00000002;      //* open file for reading and writing */
      
//* various MMIO flags */
      MMIO_FHOPEN             = $0010;  //* mmioClose: keep file handle open */
      MMIO_EMPTYBUF           = $0010;  //* mmioFlush: empty the I/O buffer */
      MMIO_TOUPPER            = $0010;  //* mmioStringToFOURCC: to u-case */
      MMIO_INSTALLPROC    = $00010000;  //* mmioInstallIOProc: install MMIOProc */
      MMIO_GLOBALPROC     = $10000000;  //* mmioInstallIOProc: install globally */
      MMIO_REMOVEPROC     = $00020000;  //* mmioInstallIOProc: remove MMIOProc */
      MMIO_UNICODEPROC    = $01000000;  //* mmioInstallIOProc: Unicode MMIOProc */
      MMIO_FINDPROC       = $00040000;  //* mmioInstallIOProc: find an MMIOProc */
      MMIO_FINDCHUNK          = $0010;  //* mmioDescend: find a chunk by ID */
      MMIO_FINDRIFF           = $0020;  //* mmioDescend: find a LIST chunk */
      MMIO_FINDLIST           = $0040;  //* mmioDescend: find a RIFF chunk */
      MMIO_CREATERIFF         = $0020;  //* mmioCreateChunk: make a LIST chunk */
      MMIO_CREATELIST         = $0040;  //* mmioCreateChunk: make a RIFF chunk */

      MMIO_VALIDPROC      = $10070000;  //* valid for mmioInstallIOProc */ /* Internal */

//* constants for dwFlags field of MMIOINFO */
      MMIO_CREATE     = $00001000;      //* create new file (or truncate file) */
      MMIO_PARSE      = $00000100;      //* parse new file returning path */
      MMIO_DELETE     = $00000200;      //* create new file (or truncate file) */
      MMIO_EXIST      = $00004000;      //* checks for existence of file */
      MMIO_ALLOCBUF   = $00010000;      //* mmioOpen() should allocate a buffer */
      MMIO_GETTEMP    = $00020000;      //* mmioOpen() should retrieve temp name */

      MMIO_DIRTY      = $10000000;      //* I/O buffer is dirty */

      MMIO_OPEN_VALID = $0003FFFF;      //* valid flags for mmioOpen */ /* Internal */
      MMIO_FLUSH_VALID = MMIO_EMPTYBUF;  //* valid flags for mmioFlush */ /* Internal */
      MMIO_ADVANCE_VALID = MMIO_WRITE or MMIO_READ;     //* valid flags for mmioAdvance */ /* Internal */
      MMIO_FOURCC_VALID = MMIO_TOUPPER;  //* valid flags for mmioStringToFOURCC */ /* Internal */
      MMIO_DESCEND_VALID = MMIO_FINDCHUNK or MMIO_FINDRIFF or MMIO_FINDLIST; //* Internal */
      MMIO_CREATE_VALID = MMIO_CREATERIFF or MMIO_CREATELIST;   //* Internal */

//* share mode numbers (bit field MMIO_SHAREMODE) */
      MMIO_COMPAT     = $00000000;      //* compatibility mode */
      MMIO_EXCLUSIVE  = $00000010;      //* exclusive-access mode */
      MMIO_DENYWRITE  = $00000020;      //* deny writing to other processes */
      MMIO_DENYREAD   = $00000030;      //* deny reading to other processes */
      MMIO_DENYNONE   = $00000040;      //* deny nothing to other processes */

//* message numbers for MMIOPROC I/O procedure functions */
      MMIOM_READ      = MMIO_READ;       //* read */
      MMIOM_WRITE    = MMIO_WRITE;       //* write */
      MMIOM_SEEK              = 2;       //* seek to a new position in file */
      MMIOM_OPEN              = 3;       //* open file */
      MMIOM_CLOSE             = 4;       //* close file */
      MMIOM_WRITEFLUSH        = 5;       //* write and flush */

      MMIOM_RENAME            = 6;       //* rename specified file */

      MMIOM_USER         = $8000;        //* beginning of user-defined messages */

//* standard four character codes */
const
      FOURCC_RIFF     = FOURCC(byte(AnsiChar('R')) or
                               (byte(AnsiChar('I')) shl 8) or
                               (byte(AnsiChar('F')) shl 16) or
                               (byte(AnsiChar('F')) shl 24)
                              );


      FOURCC_LIST     = FOURCC(byte(AnsiChar('L')) or
                               (byte(AnsiChar('I')) shl 8) or
                               (byte(AnsiChar('S')) shl 16) or
                               (byte(AnsiChar('T')) shl 24)
                              );

//* four character codes used to identify standard built-in I/O procedures */
      FOURCC_DOS      = FOURCC(byte(AnsiChar('D')) or
                               (byte(AnsiChar('O')) shl 8) or
                               (byte(AnsiChar('S')) shl 16) or
                               (byte(AnsiChar(' ')) shl 24)
                              );

      FOURCC_MEM      = FOURCC(byte(AnsiChar('M')) or
                               (byte(AnsiChar('E')) shl 8) or
                               (byte(AnsiChar('M')) shl 16) or
                               (byte(AnsiChar(' ')) shl 24)
                              );

//* flags for mmioSeek() */
const
      SEEK_SET        = 0;               //* seek to an absolute position */
      SEEK_CUR        = 1;               //* seek relative to current position */
      SEEK_END        = 2;               //* seek relative to end of file */

//* other constants */
const
      MMIO_DEFAULTBUFFER      = 8192;    //* default buffer size */

{$ENDIF} // MMNOMMIO

{$PACKRECORDS DEFAULT} // #include "poppack.h"        /* Revert to default packing */

implementation

{ Was declared as
      MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
      ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |   \
      ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))

      mmioFOURCC(ch0, ch1, ch2, ch3)  MAKEFOURCC(ch0, ch1, ch2, ch3)
}
function MAKEFOURCC(ch0:AnsiChar; ch1:AnsiChar; ch2:AnsiChar; ch3:AnsiChar):FOURCC; inline;
begin
  MAKEFOURCC:=DWORD(ch0) or
              (DWORD(ch1) shl 8) or
              (DWORD(ch2) shl 16) or
              (DWORD(ch3) shl 24);
end;

function mmioFOURCC(ch0:AnsiChar; ch1:AnsiChar; ch2:AnsiChar; ch3:AnsiChar):FOURCC;
begin
  mmioFOURCC:=MAKEFOURCC(ch0,ch1,ch2,ch3);
end;

{ Was declared as
#define sndAlias( ch0, ch1 ) \
                ( SND_ALIAS_START + (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ))
}
function sndAlias(ch0:AnsiChar; ch1:AnsiChar):DWORD; inline;
begin
  sndAlias:=SND_ALIAS_START+(DWORD(ch0) or (DWORD(ch1) shl 8));
end;

function MEVT_EVENTTYPE(x:DWORD):byte; inline;
begin
  MEVT_EVENTTYPE:=byte(((x shr 24) and $FF));
end;

function MEVT_EVENTPARM(x:DWORD):DWORD; inline;
begin
  MEVT_EVENTPARM:=DWORD(x and $00FFFFFF);
end;

{$IFNDEF MMNOMIDI}
function MIDIPROP_PROPERTY(mp:DWORD):DWORD; inline;
begin
  MIDIPROP_PROPERTY:=mp and (not (MIDIPROP_SET or MIDIPROP_GET));
end;

function SMF_TIMEDIV(format:DWORD; division:DWORD):DWORD; inline;
begin
  SMF_TIMEDIV:=(format shr 15) or division;
end;

function SMF_TIMEDIV_SMPTE(smpte:DWORD; division:DWORD):DWORD; inline;
begin
  SMF_TIMEDIV_SMPTE:=(smpte shl 8) or division;
end;

function SMF_TIMEDIV_ISSMPTE(dw:DWORD):DWORD; inline;
begin
  SMF_TIMEDIV_ISSMPTE:=dw shr 15;
end;

function SMF_TIMEDIV_GETSMPTE(dw:DWORD):byte; inline;
begin
  SMF_TIMEDIV_GETSMPTE:=byte((dw shr 8) and $ff);
end;

function SMF_TIMEDIV_GETTPF(dw:DWORD):DWORD; inline;
begin
  SMF_TIMEDIV_GETTPF:=dw and $ff;
end;

function SMF_TIMEDIV_GETTPQN(dw:DWORD):DWORD; inline;
begin
  SMF_TIMEDIV_GETTPQN:=dw and $7fff;
end;

{$ENDIF MMNOMIDI}

end.
