//ÛßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßÛ
//Û                                                       Û
//Û      Virtual Pascal Runtime Library.  Version 2.1.    Û
//Û      OS/2 MultiMedia API interface                    Û
//Û      ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÛ
//Û      Copyright (C) 1996-2000 vpascal.com              Û
//Û                                                       Û
//ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß

Unit Os2MM;

{$Cdecl+,AlignRec+,OrgName+,T-,Delphi+,Use32+}

interface

uses Os2Def, Os2PmApi;

{----[ OS2MEDEF ]----}

type
  pVoid = Pointer;
  Short = SmallWord;

  Handle  = hwnd;

  mmTime  = Cardinal;
  pmmTime = ^mmTime;

  hmmIO   = uLong;
  phmmIO  = ^hmmIO;

  // spcbKey - Stream protocol Key
  spcbKey = record
    ulDataType    : uLong;
    ulDataSubType : uLong;
    ulIntKey      : uLong;              // Generated internal key
  end;
  pspcbKey = ^spcbKey;

  // MMTRACKINFO - This structure is used to represent a video, audio or
  // some other type of track within a digital video movie file.
  MMTrackInfo = record
    ulTrackID     : uLong;              // track identifier
    ulMediaType   : uLong;              // media type
    ulCountry     : uLong;              // country code for the track
    ulCodePage    : uLong;              // country code page for the track
    ulReserved1   : uLong;              // reserved must be 0
    ulReserved2   : uLong;              // reserved must be 0
  end;
  pMMTrackInfo = ^MMTrackInfo;

const
  // Bits Per Sample
  BPS_4     =  4;
  BPS_8     =  8;
  BPS_16    = 16;

  // Clipboard formats
  CF_RMID   = 10;
  CF_RIFF   = 11;
  CF_WAVE   = 12;
  CF_AVI    = 13;

  // Channels
  CH_1      = 1;          // Mono
  CH_2      = 2;          // Stereo
  CH_4      = 4;          // Quad

  // Sampling Rates
  HZ_8000   =  8000;
  HZ_11025  = 11025;
  HZ_14700  = 14700;      // SPV/2
  HZ_18900  = 18900;      // CD/XA Lvl C
  HZ_22050  = 22050;
  HZ_37800  = 37800;      // CD/XA Lvl B
  HZ_44100  = 44100;

  // Resource Formats
  RT_RMID   = 100;
  RT_RIFF   = 101;
  RT_WAVE   = 102;
  RT_AVI    = 103;
  RT_AVS    = 104;

const
  // Multimedia Datatypes (spcbKey values)
  DATATYPE_NULL           = $0000;
  SUBTYPE_NONE            = $0000;

  // WaveForm datatype
  DATATYPE_WAVEFORM       = $0001;
  // SubTypes for WaveForm
  WAVE_FORMAT_1M08        = $0001;
  WAVE_FORMAT_1S08        = $0002;
  WAVE_FORMAT_1M16        = $0003;
  WAVE_FORMAT_1S16        = $0004;
  WAVE_FORMAT_2M08        = $0005;
  WAVE_FORMAT_2S08        = $0006;
  WAVE_FORMAT_2M16        = $0007;
  WAVE_FORMAT_2S16        = $0008;
  WAVE_FORMAT_4M08        = $0009;
  WAVE_FORMAT_4S08        = $000a;
  WAVE_FORMAT_4M16        = $000b;
  WAVE_FORMAT_4S16        = $000c;
  WAVE_FORMAT_8M08        = $000d;
  WAVE_FORMAT_8S08        = $000e;
  WAVE_FORMAT_8M16        = $000f;
  WAVE_FORMAT_8S16        = $0010;

  // DigVideo datatypes
  DATATYPE_DIGVIDEO       = $0002;
  // Subtypes
  DIGVIDEO_PHOTOM         = $544F4850;  // Photmotion video, FOURCC value for phio
  DIGVIDEO_ULTIM          = $49544c55;  // Ultimotion video, FOURCC value for ulio
  DIGVIDEO_AVI            = $20495641;  // AVI video, FOURCC value for avio
  DIGVIDEO_MONITOR        = $206E6F6D;  // MONITOR video, FOURCC value for monitoring
  DIGVIDEO_FLC            = $63696C66;  // FLIC video, FOURCC value for flic
  DIGVIDEO_MPEG           = $4745504D;  // MPEG video, FOURCC value for MPEG

  // MuLaw datatypes
  DATATYPE_MULAW          = $0101;
  DATATYPE_RIFF_MULAW     = $0007;
  // SubTypes
  MULAW_8B8KS             = $0001;      // 8bit 8kHz stereo
  MULAW_8B11KS            = $0002;      // 8bit 11kHz stereo
  MULAW_8B22KS            = $0003;      // 8bit 22kHz stereo
  MULAW_8B44KS            = $0004;      // 8bit 44kHz stereo
  MULAW_8B8KM             = $0005;      // 8bit 8kHz mono
  MULAW_8B11KM            = $0006;      // 8bit 11kHz mono
  MULAW_8B22KM            = $0007;      // 8bit 22kHz mono
  MULAW_8B44KM            = $0008;      // 8bit 44kHz mono

  // ALaw datatypes
  DATATYPE_ALAW           = $0102;
  DATATYPE_RIFF_ALAW      = $0006;
  // Subtypes
  ALAW_8B8KS              = $0001;      // 8bit 8kHz stereo
  ALAW_8B11KS             = $0002;      // 8bit 11kHz stereo
  ALAW_8B22KS             = $0003;      // 8bit 22kHz stereo
  ALAW_8B44KS             = $0004;      // 8bit 44kHz stereo
  ALAW_8B8KM              = $0005;      // 8bit 8kHz mono
  ALAW_8B11KM             = $0006;      // 8bit 11kHz mono
  ALAW_8B22KM             = $0007;      // 8bit 22kHz mono
  ALAW_8B44KM             = $0008;      // 8bit 44kHz mono

  // ADPCM datatypes
  DATATYPE_ADPCM_AVC      = $0103;
  // Subtypes
  ADPCM_AVC_VOICE         = $0001;
  ADPCM_AVC_MUSIC         = $0002;
  ADPCM_AVC_STEREO        = $0003;
  ADPCM_AVC_HQ            = $0004;


  // CT_ADPCM datatypes
  DATATYPE_CT_ADPCM       = $0200;      // Creative Technologies
  // Subtypes
  CT_ADPCM_16B8KS         = $0001;      // 16bit 8kHz stereo
  CT_ADPCM_16B11KS        = $0002;      // 16bit 11kHz stereo
  CT_ADPCM_16B22KS        = $0003;      // 16bit 22kHz stereo
  CT_ADPCM_16B44KS        = $0004;      // 16bit 44kHz stereo
  CT_ADPCM_16B8KM         = $0005;      // 16bit 8kHz mono
  CT_ADPCM_16B11KM        = $0006;      // 16bit 11kHz mono
  CT_ADPCM_16B22KM        = $0007;      // 16bit 22kHz mono
  CT_ADPCM_16B44KM        = $0008;      // 16bit 44kHz mono

  // MIDI datatype
  DATATYPE_MIDI           = $0201;

  // Generic datatype
  DATATYPE_GENERIC        = $0202;

  // Speech Viewer Datatypes
  DATATYPE_SPV2           = $0203;
  // SubTypes
  SPV2_BPCM               = $0001;
  SPV2_PCM                = $0002;
  SPV2_NONE               = $0003;


  // CD-XA datatypes
  DATATYPE_CDXA_VIDEO     = $0204;      // CD-XA Video datatype
  DATATYPE_CDXA_DATA      = $0205;      // CD-XA sub-band data datatype
  DATATYPE_CDXA_AUDIO     = $0206;      // CD-XA ADPCM Audio datatype
  DATATYPE_CDXA_AUDIO_HD  = $0207;      // CD-XA ADPCM Audio with Headers
  DATATYPE_CDXA_HEADERS   = $0208;      // CD-XA Headers and Subheaders
  // Subtypes
  CDXA_LEVELB             = $0000;      // LEVEL B Audio Stereo
  CDXA_LEVELC             = $0001;      // LEVEL C Audio Stereo
  CDXA_LEVELB_MONO        = $0002;      // LEVEL B Audio Mono
  CDXA_LEVELC_MONO        = $0003;      // LEVEL C Audio Mono

  // Digispeech datatype
  DATATYPE_DIGISPEECH     = $0208;
  // Subtyoes
  DIGISPEECH_NATIVE       = $0001;

  // MPE>G-1 Audio Datatypes
  DATATYPE_MPEG1AUDIO     = $0050;
  // Subtypes
  MPEG1_FORMAT_3M16       = $0001;      // 32.000kHz,  Mono  , 16-bit
  MPEG1_FORMAT_3S16       = $0002;      // 32.000kHz,  Stereo, 16-bit
  MPEG1_FORMAT_4M16       = $0003;      // 44.1/48kHz, Mono  , 16-bit
  MPEG1_FORMAT_4S16       = $0004;      // 44.1/48kHz, Stereo, 16-bit

  // Unknown datatype
  DATATYPE_UNKNOWN        = $FFFFFFFF;

{----[ MEERROR ]----}

const
  // MCI Device Manager Error Return Codes
  MCIERR_BASE                       = 5000;
  MCIERR_SUCCESS                    = 0;
  MCIERR_INVALID_DEVICE_ID          = (MCIERR_BASE +   1);
  MCIERR_NO_MASTER                  = (MCIERR_BASE +   2);
  MCIERR_UNRECOGNIZED_KEYWORD       = (MCIERR_BASE +   3);
  MCIERR_MASTER_CONFLICT            = (MCIERR_BASE +   4);
  MCIERR_UNRECOGNIZED_COMMAND       = (MCIERR_BASE +   5);
  MCIERR_HARDWARE                   = (MCIERR_BASE +   6);
  MCIERR_INVALID_DEVICE_NAME        = (MCIERR_BASE +   7);
  MCIERR_OUT_OF_MEMORY              = (MCIERR_BASE +   8);
  MCIERR_DEVICE_OPEN                = (MCIERR_BASE +   9);
  MCIERR_CANNOT_LOAD_DRIVER         = (MCIERR_BASE +  10);
  MCIERR_MISSING_COMMAND_STRING     = (MCIERR_BASE +  11);
  MCIERR_PARAM_OVERFLOW             = (MCIERR_BASE +  12);
  MCIERR_MISSING_STRING_ARGUMENT    = (MCIERR_BASE +  13);
  MCIERR_BAD_INTEGER                = (MCIERR_BASE +  14);
  MCIERR_PARSER_INTERNAL            = (MCIERR_BASE +  15);
  MCIERR_DRIVER_INTERNAL            = (MCIERR_BASE +  16);
  MCIERR_MISSING_PARAMETER          = (MCIERR_BASE +  17);
  MCIERR_UNSUPPORTED_FUNCTION       = (MCIERR_BASE +  18);
  MCIERR_FILE_NOT_FOUND             = (MCIERR_BASE +  19);
  MCIERR_DEVICE_NOT_READY           = (MCIERR_BASE +  20);
  MCIERR_INTERNAL                   = (MCIERR_BASE +  21);
  MCIERR_DRIVER                     = (MCIERR_BASE +  22);
  MCIERR_CANNOT_USE_ALL             = (MCIERR_BASE +  23);
  MCIERR_MULTIPLE                   = (MCIERR_BASE +  24);
  MCIERR_EXTENSION_NOT_FOUND        = (MCIERR_BASE +  25);
  MCIERR_OUTOFRANGE                 = (MCIERR_BASE +  26);
  MCIERR_CANNOT_ADD_ALIAS           = (MCIERR_BASE +  27);
  MCIERR_FLAGS_NOT_COMPATIBLE       = (MCIERR_BASE +  28);
  MCIERR_CANNOT_USE_NOUNLOAD        = (MCIERR_BASE +  29);
  MCIERR_FILE_NOT_SAVED             = (MCIERR_BASE +  30);
  MCIERR_DEVICE_TYPE_REQUIRED       = (MCIERR_BASE +  31);
  MCIERR_DEVICE_LOCKED              = (MCIERR_BASE +  32);
  MCIERR_DUPLICATE_ALIAS            = (MCIERR_BASE +  33);
  MCIERR_INSTANCE_INACTIVE          = (MCIERR_BASE +  34);
  MCIERR_COMMAND_TABLE              = (MCIERR_BASE +  35);
  MCIERR_INI_FILE_LOCKED            = (MCIERR_BASE +  37);
  MCIERR_NO_AUDIO_SUPPORT           = (MCIERR_BASE +  40);
  MCIERR_NOT_IN_PM_SESSION          = (MCIERR_BASE +  41);
  MCIERR_DUPLICATE_KEYWORD          = (MCIERR_BASE +  42);
  MCIERR_COMMAND_STRING_OVERFLOW    = (MCIERR_BASE +  43);
  MCIERR_DRIVER_PROC_NOT_FOUND      = (MCIERR_BASE +  44);
  MCIERR_INVALID_DEVICE_TYPE        = (MCIERR_BASE +  45);
  MCIERR_INVALID_DEVICE_ORDINAL     = (MCIERR_BASE +  46);
  MCIERR_HEADPHONES_NOT_SET         = (MCIERR_BASE +  47);
  MCIERR_SPEAKERS_NOT_SET           = (MCIERR_BASE +  48);
  MCIERR_SOUND_NOT_SET              = (MCIERR_BASE +  49);
  MCIERR_INVALID_BUFFER             = (MCIERR_BASE +  50);
  MCIERR_INVALID_MEDIA_TYPE         = (MCIERR_BASE +  51);
  MCIERR_INVALID_CONNECTOR_INDEX    = (MCIERR_BASE +  52);
  MCIERR_NO_CONNECTION              = (MCIERR_BASE +  53);
  MCIERR_INVALID_FLAG               = (MCIERR_BASE +  54);
  MCIERR_CANNOT_LOAD_DSP_MOD        = (MCIERR_BASE +  55);
  MCIERR_ALREADY_CONNECTED          = (MCIERR_BASE +  56);
  MCIERR_INVALID_CALLBACK_HANDLE    = (MCIERR_BASE +  57);
  MCIERR_DRIVER_NOT_FOUND           = (MCIERR_BASE +  58);
  MCIERR_DUPLICATE_DRIVER           = (MCIERR_BASE +  59);
  MCIERR_INI_FILE                   = (MCIERR_BASE +  60);
  MCIERR_INVALID_GROUP_ID           = (MCIERR_BASE +  61);
  MCIERR_ID_ALREADY_IN_GROUP        = (MCIERR_BASE +  62);
  MCIERR_MEDIA_CHANGED              = (MCIERR_BASE +  63);
  MCIERR_MISSING_FLAG               = (MCIERR_BASE +  64);
  MCIERR_UNSUPPORTED_FLAG           = (MCIERR_BASE +  65);
  MCIERR_DRIVER_NOT_LOADED          = (MCIERR_BASE +  66);
  MCIERR_INVALID_MODE               = (MCIERR_BASE +  67);
  MCIERR_INVALID_ITEM_FLAG          = (MCIERR_BASE +  68);
  MCIERR_INVALID_TIME_FORMAT_FLAG   = (MCIERR_BASE +  69);
  MCIERR_SPEED_FORMAT_FLAG          = (MCIERR_BASE +  70);
  MCIERR_INVALID_AUDIO_FLAG         = (MCIERR_BASE +  71);
  MCIERR_NODEFAULT_DEVICE           = (MCIERR_BASE +  72);
  MCIERR_DUPLICATE_EXTENSION        = (MCIERR_BASE +  73);
  MCIERR_FILE_ATTRIBUTE             = (MCIERR_BASE +  74);
  MCIERR_DUPLICATE_CUEPOINT         = (MCIERR_BASE +  75);
  MCIERR_INVALID_CUEPOINT           = (MCIERR_BASE +  76);
  MCIERR_CUEPOINT_LIMIT_REACHED     = (MCIERR_BASE +  77);
  MCIERR_MISSING_ITEM               = (MCIERR_BASE +  78);
  MCIERR_MISSING_TIME_FORMAT        = (MCIERR_BASE +  79);
  MCIERR_MISSING_SPEED_FORMAT       = (MCIERR_BASE +  80);
  MCIERR_INVALID_CONNECTOR_TYPE     = (MCIERR_BASE +  81);
  MCIERR_TARGET_DEVICE_FULL         = (MCIERR_BASE +  82);
  MCIERR_UNSUPPORTED_CONN_TYPE      = (MCIERR_BASE +  83);
  MCIERR_CANNOT_MODIFY_CONNECTOR    = (MCIERR_BASE +  84);
  MCIERR_RECORD_ABORTED             = (MCIERR_BASE +  85);
  MCIERR_GROUP_COMMAND              = (MCIERR_BASE +  86);
  MCIERR_DEVICE_NOT_FOUND           = (MCIERR_BASE +  87);
  MCIERR_RESOURCE_NOT_AVAILABLE     = (MCIERR_BASE +  88);
  MCIERR_INVALID_IO_PROC            = (MCIERR_BASE +  89);
  MCIERR_WAVE_OUTPUTSINUSE          = (MCIERR_BASE +  90);
  MCIERR_WAVE_SETOUTPUTINUSE        = (MCIERR_BASE +  91);
  MCIERR_WAVE_INPUTSINUSE           = (MCIERR_BASE +  92);
  MCIERR_WAVE_SETINPUTINUSE         = (MCIERR_BASE +  93);
  MCIERR_WAVE_OUTPUTUNSPECIFIED     = (MCIERR_BASE +  94);
  MCIERR_WAVE_INPUTUNSPECIFIED      = (MCIERR_BASE +  95);
  MCIERR_WAVE_OUTPUTSUNSUITABLE     = (MCIERR_BASE +  96);
  MCIERR_WAVE_SETOUTPUTUNSUITABLE   = (MCIERR_BASE +  97);
  MCIERR_WAVE_INPUTSUNSUITABLE      = (MCIERR_BASE +  98);
  MCIERR_WAVE_SETINPUTUNSUITABLE    = (MCIERR_BASE +  99);
  MCIERR_SEQ_DIV_INCOMPATIBLE       = (MCIERR_BASE + 100);
  MCIERR_SEQ_PORT_INUSE             = (MCIERR_BASE + 101);
  MCIERR_SEQ_PORT_NONEXISTENT       = (MCIERR_BASE + 102);
  MCIERR_SEQ_PORT_MAPNODEVICE       = (MCIERR_BASE + 103);
  MCIERR_SEQ_PORT_MISCERROR         = (MCIERR_BASE + 104);
  MCIERR_SEQ_TIMER                  = (MCIERR_BASE + 105);
  MCIERR_VDP_COMMANDCANCELLED       = (MCIERR_BASE + 106);
  MCIERR_VDP_COMMANDFAILURE         = (MCIERR_BASE + 107);
  MCIERR_VDP_NOTSPUNUP              = (MCIERR_BASE + 108);
  MCIERR_VDP_NOCHAPTER              = (MCIERR_BASE + 109);
  MCIERR_VDP_NOSIDE                 = (MCIERR_BASE + 110);
  MCIERR_VDP_NOSIZE                 = (MCIERR_BASE + 111);
  MCIERR_VDP_INVALID_TIMEFORMAT     = (MCIERR_BASE + 112);
  MCIERR_CLIPBOARD_ERROR            = (MCIERR_BASE + 114);
  MCIERR_CANNOT_CONVERT             = (MCIERR_BASE + 115);
  MCIERR_CANNOT_REDO                = (MCIERR_BASE + 116);
  MCIERR_CANNOT_UNDO                = (MCIERR_BASE + 117);
  MCIERR_CLIPBOARD_EMPTY            = (MCIERR_BASE + 118);
  MCIERR_INVALID_WORKPATH           = (MCIERR_BASE + 119);
  MCIERR_INDETERMINATE_LENGTH       = (MCIERR_BASE + 120);
  MCIERR_DUPLICATE_EA               = (MCIERR_BASE + 121);
  MCIERR_INVALID_CONNECTION         = (MCIERR_BASE + 122);
  MCIERR_CHANNEL_OFF                = (MCIERR_BASE + 123);
  MCIERR_CANNOT_CHANGE_CHANNEL      = (MCIERR_BASE + 124);
  MCIERR_FILE_IO                    = (MCIERR_BASE + 125);
  MCIERR_SYSTEM_FILE                = (MCIERR_BASE + 126);
  MCIERR_DISPLAY_RESOLUTION         = (MCIERR_BASE + 127);
  MCIERR_NO_ASYNC_PLAY_ACTIVE       = (MCIERR_BASE + 128);
  MCIERR_UNSUPP_FORMAT_TAG          = (MCIERR_BASE + 129);
  MCIERR_UNSUPP_SAMPLESPERSEC       = (MCIERR_BASE + 130);
  MCIERR_UNSUPP_BITSPERSAMPLE       = (MCIERR_BASE + 131);
  MCIERR_UNSUPP_CHANNELS            = (MCIERR_BASE + 132);
  MCIERR_UNSUPP_FORMAT_MODE         = (MCIERR_BASE + 133);
  MCIERR_NO_DEVICE_DRIVER           = (MCIERR_BASE + 134);
  MCIERR_CODEC_NOT_SUPPORTED        = (MCIERR_BASE + 135);
  MCIERR_TUNER_NO_HW                = (MCIERR_BASE + 136);
  MCIERR_TUNER_NO_AFC               = (MCIERR_BASE + 137);
  MCIERR_TUNER_AFC_ON               = (MCIERR_BASE + 138);
  MCIERR_TUNER_CHANNEL_SKIPPED      = (MCIERR_BASE + 139);
  MCIERR_TUNER_CHANNEL_TOO_LOW      = (MCIERR_BASE + 140);
  MCIERR_TUNER_CHANNEL_TOO_HIGH     = (MCIERR_BASE + 141);
  MCIERR_AUD_CHANNEL_OUTOFRANGE     = (MCIERR_BASE + 142);
  MCIERR_TUNER_INVALID_REGION       = (MCIERR_BASE + 143);
  MCIERR_SIGNAL_INVALID             = (MCIERR_BASE + 144);
  MCIERR_TUNER_MODE                 = (MCIERR_BASE + 145);
  MCIERR_TUNER_REGION_NOT_SET       = (MCIERR_BASE + 146);
  MCIERR_TUNER_CHANNEL_NOT_SET      = (MCIERR_BASE + 147);
  MCIERR_CUSTOM_DRIVER_BASE         = (MCIERR_BASE + 256);

  // Sync/Stream Manager Error Return codes
  MEBASE                            = (MCIERR_BASE + 500);
  ERROR_INVALID_STREAM              = (MEBASE +   1);
  ERROR_INVALID_hID                 = (MEBASE +   2);
  ERROR_INVALID_OBJTYPE             = (MEBASE +   4);
  ERROR_INVALID_FLAG                = (MEBASE +   5);
  ERROR_INVALID_EVCB                = (MEBASE +   6);
  ERROR_INVALID_EVENT               = (MEBASE +   7);
  ERROR_INVALID_MMTIME              = (MEBASE +   8);
  ERROR_INVALID_NUMSLAVES           = (MEBASE +   9);
  ERROR_INVALID_REQUEST             = (MEBASE +  10);
  ERROR_INVALID_SPCBKEY             = (MEBASE +  11);
  ERROR_INVALID_HNDLR_NAME          = (MEBASE +  12);
  ERROR_INVALID_PROTOCOL            = (MEBASE +  13);
  ERROR_INVALID_BUFFER_SIZE         = (MEBASE +  14);
  ERROR_INVALID_BUFFER_RETURNED     = (MEBASE +  15);
  ERROR_INVALID_ACB                 = (MEBASE +  16);
  ERROR_INVALID_RECORD_RETURNED     = (MEBASE +  17);
  ERROR_INVALID_MESSAGE             = (MEBASE +  18);
  ERROR_STREAM_NOT_OWNER            = (MEBASE +  99);
  ERROR_STREAM_USED                 = (MEBASE + 100);
  ERROR_STREAM_CREATION             = (MEBASE + 101);
  ERROR_STREAM_NOTMASTER            = (MEBASE + 102);
  ERROR_STREAM_NOT_STOP             = (MEBASE + 103);
  ERROR_STREAM_OPERATION            = (MEBASE + 104);
  ERROR_STREAM_STOP_PENDING         = (MEBASE + 105);
  ERROR_STREAM_ALREADY_STOP         = (MEBASE + 106);
  ERROR_STREAM_ALREADY_PAUSE        = (MEBASE + 107);
  ERROR_STREAM_NOT_STARTED          = (MEBASE + 108);
  ERROR_STREAM_NOT_ACTIVE           = (MEBASE + 109);
  ERROR_START_STREAM                = (MEBASE + 110);
  ERROR_MASTER_USED                 = (MEBASE + 111);
  ERROR_SPCBKEY_MISMATCH            = (MEBASE + 112);
  ERROR_INSUFF_BUFFER               = (MEBASE + 113);
  ERROR_ALLOC_RESOURCES             = (MEBASE + 114);
  ERROR_ACCESS_OBJECT               = (MEBASE + 115);
  ERROR_HNDLR_REGISTERED            = (MEBASE + 116);
  ERROR_DATA_ITEM_NOT_SPECIFIED     = (MEBASE + 117);
  ERROR_INVALID_SEQUENCE            = (MEBASE + 118);
  ERROR_INITIALIZATION              = (MEBASE + 119);
  ERROR_READING_INI                 = (MEBASE + 120);
  ERROR_LOADING_HNDLR               = (MEBASE + 121);
  ERROR_HNDLR_NOT_FOUND             = (MEBASE + 122);
  ERROR_SPCB_NOT_FOUND              = (MEBASE + 123);
  ERROR_DEVICE_NOT_FOUND            = (MEBASE + 124);
  ERROR_TOO_MANY_EVENTS             = (MEBASE + 125);
  ERROR_DEVICE_OVERRUN              = (MEBASE + 126);
  ERROR_DEVICE_UNDERRUN             = (MEBASE + 127);
  ERROR_HNDLR_NOT_IN_INI            = (MEBASE + 128);
  ERROR_QUERY_STREAM_TIME           = (MEBASE + 129);
  ERROR_DATA_ITEM_NOT_SEEKABLE      = (MEBASE + 130);
  ERROR_NOT_SEEKABLE_BY_TIME        = (MEBASE + 131);
  ERROR_NOT_SEEKABLE_BY_BYTES       = (MEBASE + 132);
  ERROR_STREAM_NOT_SEEKABLE         = (MEBASE + 133);
  ERROR_PLAYLIST_STACK_OVERFLOW     = (MEBASE + 135);
  ERROR_PLAYLIST_STACK_UNDERFLOW    = (MEBASE + 136);
  ERROR_LOCKING_BUFFER              = (MEBASE + 137);
  ERROR_UNLOCKING_BUFFER            = (MEBASE + 138);
  ERROR_SEEK_PAST_END               = (MEBASE + 139);
  ERROR_SEEK_BACK_NOT_SUPPORTED     = (MEBASE + 140);
  ERROR_INTERNAL_ERROR              = (MEBASE + 141);
  ERROR_INTERNAL_CORRUPT            = (MEBASE + 142);
  ERROR_INSUFF_MEM                  = (MEBASE + 143);
  ERROR_LARGE_SEEK_BY_TIME          = (MEBASE + 144);
  ERROR_STREAM_PREROLLING           = (MEBASE + 145);
  ERROR_INI_FILE                    = (MEBASE + 146);
  ERROR_SEEK_BEFORE_BEGINNING       = (MEBASE + 147);
  ERROR_TOO_MANY_HANDLERS           = (MEBASE + 148);
  ERROR_ALLOC_HEAP                  = (MEBASE + 149);
  ERROR_END_OF_PLAYLIST             = (MEBASE + 150);
  ERROR_TOO_MANY_STREAMS            = (MEBASE + 151);
  ERROR_FILE_FORMAT_INCORRECT       = (MEBASE + 152);
  ERROR_DESTROY_STREAM              = (MEBASE + 153);
  ERROR_INVALID_NUMMASTERS          = (MEBASE + 154);
  ERROR_MASTER_CONFLICT             = (MEBASE + 155);
  ERROR_NO_MASTER                   = (MEBASE + 156);
  ERROR_NO_SYNC                     = (MEBASE + 157);
  ERROR_BUFFER_NOT_AVAILABLE        = (MEBASE + 400);
  ERROR_TOO_MANY_BUFFERS            = (MEBASE + 401);
  ERROR_TOO_MANY_RECORDS            = (MEBASE + 402);

  // ERROR_INVALID_PROTOCOL ulErrorStatus Defines
  // Refer to SHC_NEGOTIATE_RESULT api function
  PROTOCOL_SPCBLENGTH               =  1;
  PROTOCOL_SPCBKEY                  =  2;
  PROTOCOL_DATAFLAG                 =  3;
  PROTOCOL_NUMRECORDS               =  4;
  PROTOCOL_BLOCKSIZE                =  5;
  PROTOCOL_BUFFERSIZE               =  6;
  PROTOCOL_MINNUMBUFFERS            =  7;
  PROTOCOL_MAXNUMBUFFERS            =  8;
  PROTOCOL_SOURCESTART              =  9;
  PROTOCOL_TARGETSTART              = 10;
  PROTOCOL_BUFFERFLAG               = 11;
  PROTOCOL_HANDLERFLAG              = 12;
  PROTOCOL_SYNCTOLERANCE            = 13;
  PROTOCOL_SYNCINTERVAL             = 14;
  PROTOCOL_INTERNALERROR            = -1;

  // MMIO Manager error return codes
  MMIOERR_BASE                      = (MEBASE + 1000);
  MMIOERR_UNBUFFERED                = (MMIOERR_BASE +  1);
  MMIOERR_CANNOTWRITE               = (MMIOERR_BASE +  2);
  MMIOERR_CHUNKNOTFOUND             = (MMIOERR_BASE +  3);
  MMIOERR_INVALID_HANDLE            = (MMIOERR_BASE +  4);
  MMIOERR_INVALID_PARAMETER         = (MMIOERR_BASE +  5);
  MMIOERR_INTERNAL_SYSTEM           = (MMIOERR_BASE +  6);
  MMIOERR_NO_CORE                   = (MMIOERR_BASE +  7);
  MMIOERR_INI_OPEN                  = (MMIOERR_BASE +  8);
  MMIOERR_INI_READ                  = (MMIOERR_BASE +  9);
  MMIOERR_INVALID_BUFFER_LENGTH     = (MMIOERR_BASE + 10);
  MMIOERR_NO_BUFFER_ALLOCATED       = (MMIOERR_BASE + 11);
  MMIOERR_NO_FLUSH_FOR_MEM_FILE     = (MMIOERR_BASE + 12);
  MMIOERR_NO_FLUSH_NEEDED           = (MMIOERR_BASE + 13);
  MMIOERR_READ_ONLY_FILE            = (MMIOERR_BASE + 14);
  MMIOERR_WRITE_ONLY_FILE           = (MMIOERR_BASE + 15);
  MMIOERR_INSTALL_PROC_FAILED       = (MMIOERR_BASE + 16);
  MMIOERR_READ_FAILED               = (MMIOERR_BASE + 17);
  MMIOERR_WRITE_FAILED              = (MMIOERR_BASE + 18);
  MMIOERR_SEEK_FAILED               = (MMIOERR_BASE + 19);
  MMIOERR_CANNOTEXPAND              = (MMIOERR_BASE + 20);
  MMIOERR_FREE_FAILED               = (MMIOERR_BASE + 21);
  MMIOERR_EOF_SEEN                  = (MMIOERR_BASE + 22);
  MMIOERR_INVALID_ACCESS_FLAG       = (MMIOERR_BASE + 23);
  MMIOERR_INVALID_STRUCTURE         = (MMIOERR_BASE + 24);
  MMIOERR_INVALID_SIZE              = (MMIOERR_BASE + 25);
  MMIOERR_INVALID_FILENAME          = (MMIOERR_BASE + 26);
  MMIOERR_CF_DUPLICATE_SEEN         = (MMIOERR_BASE + 27);
  MMIOERR_CF_ENTRY_NO_CORE          = (MMIOERR_BASE + 28);
  MMIOERR_CF_WO_UNSUPPORTED         = (MMIOERR_BASE + 29);
  MMIOERR_CF_ELEMENTS_OPEN          = (MMIOERR_BASE + 30);
  MMIOERR_CF_NON_BND_FILE           = (MMIOERR_BASE + 31);
  MMIOERR_CF_ENTRY_NOT_FOUND        = (MMIOERR_BASE + 32);
  MMIOERR_DELETE_FAILED             = (MMIOERR_BASE + 33);
  MMIOERR_OUTOFMEMORY               = (MMIOERR_BASE + 34);
  MMIOERR_INVALID_DLLNAME           = (MMIOERR_BASE + 35);
  MMIOERR_INVALID_PROCEDURENAME     = (MMIOERR_BASE + 36);
  MMIOERR_MATCH_NOT_FOUND           = (MMIOERR_BASE + 37);
  MMIOERR_SEEK_BEFORE_BEGINNING     = (MMIOERR_BASE + 38);
  MMIOERR_INVALID_FILE              = (MMIOERR_BASE + 39);
  MMIOERR_QOSUNAVAILABLE            = (MMIOERR_BASE + 40);
  MMIOERR_MEDIA_NOT_FOUND           = (MMIOERR_BASE + 41);
  MMIOERR_ERROR_IN_FRAME_DATA       = (MMIOERR_BASE + 42);
  MMIOERR_INVALID_DIM_ALIGN         = (MMIOERR_BASE + 43);
  MMIOERR_CODEC_NOT_SUPPORTED       = (MMIOERR_BASE + 44);

  MMIOERR_UNSUPPORTED_FUNCTION      = (MMIOERR_BASE + 45);
  MMIOERR_CLIPBRD_ERROR             = (MMIOERR_BASE + 46);
  MMIOERR_CLIPBRD_ACTIVE            = (MMIOERR_BASE + 47);
  MMIOERR_CLIPBRD_EMPTY             = (MMIOERR_BASE + 48);
  MMIOERR_NEED_NEW_FILENAME         = (MMIOERR_BASE + 49);
  MMIOERR_INVALID_TRACK_OPERATION   = (MMIOERR_BASE + 50);
  MMIOERR_INCOMPATIBLE_DATA         = (MMIOERR_BASE + 51);
  MMIOERR_ACCESS_DENIED             = (MMIOERR_BASE + 52);
  MMIOERR_MISSING_FLAG              = (MMIOERR_BASE + 53);
  MMIOERR_INVALID_ITEM_FLAG         = (MMIOERR_BASE + 54);

  // User defined error return codes
  USERERR_BASE                      = (MMIOERR_BASE + 1000);

{-----[ MCIAPI ]----}

function mciPlayFile(hwndOwner: HWnd;           // Ownerwindow
                     pszFile: PChar;            // File
                     ulFlags: uLong;            // Flags
                     pszTitle: PChar;           // Title
                     hwndViewport: HWnd): ULong;// Viewport Window

function mciPlayResource(hwndOwner: HWnd;       // Owner Window
                         hmod: hModule;         // Module
                         resType: uLong;        // Resource Type
                         resID: uLong;          // Resource ID
                         ulFlags: uLong;        // Flags
                         pszTitle: pChar;       // Title
                         hwndViewport: HWnd): ULong;   // Viewport Window

function mciRecordAudioFile(hwndOwner: HWnd; pszFile, pszTitle: pCHar;
  ulFlags: uLong): uLong;

// Audio Macro Service Routines
function mmioRemoveElement(pszFileElement: pChar; ulFlag: uLong): Ulong;

function mmioFindElement(ulCode: ULong;         // Find Code
                         pszElement: pChar;     // Element
                         ulElementLen: uLong;   // Element Buffer Length
                         pszFile: pChar;
                         ulReserved: ULong)     // Compound File
                                            : uLong;

const
  MMIO_FE_FINDFIRST        = 1;
  MMIO_FE_FINDNEXT         = 2;
  MMIO_FE_FINDEND          = 3;
  MMIO_FE_FINDELEMENT      = 4;

  MMIO_RE_COMPACT          = 1;

  // Flags for mciPlayFile
  MCI_OWNERISPARENT        = $0001;      // digital and overlay
  MCI_STOPACTIVE           = $0002;      // stop playing whatever is playing
  MCI_ASYNCRENDEZVOUS      = $0004;      // play and return immediately
  MCI_RENDEZVOUS           = $0008;      // wait til prev is finished then play
  MCI_ASYNC                = $0010;      // no syncup will be done

{----[ SSM ]----}

// Sync/Stream Manager Definitions

const
  Max_SPI_Name             = 9;          // Maximum ASCIIZ stream handler name/class and device driver name

type
  hStream = uLong;               // Stream Handle
  phStream = ^hStream;           // Pointer to Stream Handle

  hEvent = uLong;                // Event Handle
  phEvent = ^hEvent;             // Pointer to Event Handle

  hID = uLong;                   // Stream Handler ID
  // The following define was deleted because it conflicts with an OS/2 PM define
  // phID = ^hID;                // Pointer to Stream Handler ID

  LockH = record                 // Memory locking handle (used by PDD)
    Lock: Array[0..15] of Byte;
  end;
  pLockH = ^LockH;

  rc = uLong;                    // Used for all return codes

  Slave = record
   hstreamSlave: hStream;        // Handle for this slave
   mmtimeStart: mmTime;          // Offset in master stream time to start this slave
  end;
  pSlave = ^Slave;

  Master = record
    hstreamMaster: hStream;        // Handle for this master
  end;
  pMaster = ^Master;

  Hand = record
    szHandlerClass: Array[0..MAX_SPI_NAME-1] of char; // Stream handler class
    szHandlerName:  Array[0..MAX_SPI_NAME-1] of char; // Stream handler name
  end;
  pHand = ^Hand;

{----[ SSM / SPCB ]----}

// Control Block Definitions

type
  // SPCB - Stream Protocol Control Block
  spcb = record
   ulSPCBLen       : uLong;       // SPCB struture length
   spcbkey         : SPCBKEY;
   ulDataFlags     : uLong;       // Data type flags
   ulNumRec        : uLong;       // Max # records/buffer (Only used for Split streams)
   ulBlockSize     : uLong;       // Block alignment in bytes.
   ulBufSize       : uLong;       // Buffer size (SSM allocated buffers) must be
                                  //  a multiple of Block size
   ulMinBuf        : uLong;       // Minimum number of buffers needed to stream
   ulMaxBuf        : uLong;       // Maximum number of buffers needed to stream
   ulSrcStart      : uLong;       // # of EMPTY buffers required to start Source
   ulTgtStart      : uLong;       // # of FULL buffers required to start Target
   ulBufFlags      : uLong;       // Handler Protocol negotiation flags
   ulHandFlags     : uLong;       // Handler Protocol flags
   mmtimeTolerance : mmTime;      // Sync tolerance value...Used as check by SSM
                                  //  to determine whether to send a sync pulse
                                  //  to this specific slave Stream Handler.
                                  //  Algorithm:
                                  //   diff = abs(master time - slave time)
                                  //   if  diff >= tolerance
                                  //     then send sync pulse
                                  // (Valid only for Slave stream handlers)
   mmtimeSync      : mmTime;      // Used to save sync pulse generation granularity
                                  //  if the master uses the Stream Manager Timer.
                                  //  if SpiSetSync passed NULL value for sync gran
                                  //   then use this default value. (since hardware
                                  //   must have it's own interrupt time interval.
                                  // (Valid only for Master stream handlers)
   ulBytesPerUnit  : uLong;       // Bytes/unit of time. This is used to do seeks
                                  // on linear data that is not compressed or
                                  // of variable length.
   mmtimePerUnit   : mmTime;      // The amount of mmtime each unit represents.
                                  // A unit can be a second, minute or whatever.
  end;
  pspcb = ^spcb;

const
  spcb_max_buf_Size        = 1024*1024;  // Largest buffer size in bytes

  // SPCB_ulDataFlags:
  spcbData_CueTime         = $0002; // This data type can support time cue points
  spcbData_CueData         = $0004; // This data type can support data cue points

  spcbData_Seek            = $0000; // Seeks can be performed on this data type.
  spcbData_NoSeek          = $0008; // NO seeks can be performed on this data type.
  spcbData_YieldTime       = $0010; // The ulBytes per unit field is used for a millisecond value
                                    // It represents the amount of yield time between reads of
                                    // each buffer. If this bit is set, the value of ulBytesPerUnit
                                    // is used as input to DosSleep to yield for that period of time
  ValidDataFlags           = spcbData_CueTime OR spcbData_CueData OR
                             spcbData_YieldTime OR spcbData_NoSeek;

  // SPCB_ulBufFlags:
  spcbBuf_USERPROVIDED     = $0001; // User provides buffers for stream
                                    // SSMgr will not allocate buffers,
                                    // but must lock down provided buffers,
                                    // so this will affect performance!!
                                    // (Source Handler only)
  spcbBuf_FIXEDBUF         = $0002; // Buffer size is fixed for this data type
                                    //  in this handler. Can not be used
                                    //  with the spcbBuf_USERPROVIDED flags.
  spcbBuf_NONCONTIGUOUS    = $0004; // Buffer do not need to be contiguous
                                    //  in physical memory.
  spcbBuf_INTERLEAVED      = $0008; // Stream buffers can be interleaved.
                                    //  Can not be use with the
                                    //  spcbBuf_USERPROVIDED flag.
                                    //  (Source Handler only)
  spcbBuf_MAXSIZE          = $0010; // ulBufSize is the maximum size that
                                    //  can be used by this stream handler
  spcbBuf_16MEG            = $0020; // The Stream buffers may be allocated
                                    //  above the 16 Meg line. This is used
                                    //  by stream handlers that can support
                                    //  greater than 16 Megabyte addresses.
  spcbBuf_FIXEDBLOCK       = $0040; // Use the ulBlockSize field to represent
                                    // the size of the IO reads that should
                                    // be performed (Interleaved streams)
  ValidBufFlags            = spcbBuf_UserProvided OR spcbBuf_FixedBuf OR
                             spcbBuf_NonContiguous OR spcbBuf_Interleaved OR
                             spcbBuf_16Meg OR spcbBuf_FixedBlock OR
                             spcbBuf_MaxSize;

  // SPCB_ulHandFlags:
  spcbHand_genSync         = $0001; // (INPUT FROM HANDLER ONLY)
                                    // This handler can generate sync pulses
                                    // if it is the master.
  spcbHand_RcvSync         = $0002; // (INPUT FROM HANDLER ONLY)
                                    // This handler can receive sync pulses
                                    // if it is a slave
  spcbHand_Timer           = $0004; // Use Stream Manager Timer for Sync
  spcbHand_NonStream       = $0008; // Stream Handler is non-streaming
  spcbHand_GenTime         = $0010; // This handler contains real
                                    // stream time. The handler that
                                    // supports the SpiGetTime, data/time
                                    // cue point calls for this stream.
  spcbHand_NoPreRoll       = $0020; // This stream can not be prerolled.
                                    // (i.e. recording streams)
  spcbHand_NoSync          = $0040; // This stream can be group into a
                                    // sync group, but does not send or
                                    // receive sync pulses.
  spcbHand_Phys_Seek       = $0080; // This handler does a seek to a physical
                                    // device or memory not just a time adjustment.
                                    // (ssm will always call this handler first on
                                    //  an SpiSeekStream call).

  ValidHandFlags           = spcbHand_GenSync OR spcbHand_RcvSync OR
                             spcbHand_Timer OR spcbHand_NonStream OR
                             spcbHand_GenTime OR spcbHand_NoPreRoll OR
                             spcbHand_NoSync OR spcbHand_Phys_Seek;


{----[ SSM / EVCB ]----}

// Block definitions

{ *********************************************
  * List of Implicit events:
  *    EVENT_EOS                 - Use IMPL_EVCB
  *    EVENT_ERROR               - Use IMPL_EVCB
  *    EVENT_STREAM_STOPPED      - Use IMPL_EVCB
  *    EVENT_SYNC_PREROLLED      - Use IMPL_EVCB
  *    EVENT_PLAYLISTMESSAGE     - Use PLAYL_EVCB
  *    EVENT_PLAYLISTCUEPOINT    - Use PLAYL_EVCB
  *    EVENT_QUEUE_OVERFLOW      - Use IMPL_EVCB
  ********************************************* }

{ *********************************************
  * List of Explicit events:
  *    EVENT_SYNCOVERRUN         - Use OVRU_EVCB
  *    EVENT_CUE_TIME            - Use TIME_EVCB
  *    EVENT_CUE_DATA            - Use DATA_EVCB
  *    EVENT_DATAUNDERRUN        - Use EVCB
  *    EVENT_DATAOVERRUN         - Use EVCB
  *    EVENT_CUE_TIME_PAUSE      - Use TIME_EVCB
  ********************************************* }

const
  Event_SYNCOVERRUN        = 4;
  Event_CUE_TIME           = 5;       // Cue point in terms of stream time
  Event_CUE_DATA           = 6;       // Cue point in terms of data items
  Event_DATAUNDERRUN       = 7;       // data underrun event from SH
  Event_DATAOVERRUN        = 8;       // data underrun event from SH
  Event_CUE_TIME_PAUSE     = 9;       // Pause when cue-point reached.
  Event_STATUS_LEVEL       = 10;      // Report status level

{*********************************************
 * SYNC_EVCB - Sync Pulse Event Control Block
 *             (This event is only seen by
 *              stream handlers)
 *********************************************}
  Event_SYNC               = 1;       // Synchronization point in stream
type
  sync_evcb = record
    ulType       : uLong;             // Event_SYNC
    ulSubType    : uLong;             // Not used
    ulSyncFlags  : uLong;             // 0 (input),status (output)
    hstream      : HStream;           // handle to stream for this event
    hid          : hID;               // Handler id
    ulStatus     : uLong;             // Event status (output)
    mmtimeStart  : mmTime;            // Filled in by Sync/Stream manager
                                      //  at SpiEnableSync time. (input)
    mmtimeMaster : mmTime;            // Filled in by Master SH (input)
    mmtimeSlave  : mmTime;            // Filled in by slave SH. (output)
  end;
  pSync_evcb = ^sync_Evcb;

const
  // ulSyncFlags
  SyncOverrun              = $0001;   // Set by SSM if sync pulse comes in before
                                      //  a has processed the current sync pulse.
  SyncPolling              = $0002;   // SSM set this after filling the handler EVCB.
                                      //  Handler resets it after it processes the
                                      //  contents of EVCB. The SSM must check this
                                      //  bit before modifying EVCB. If bit already
                                      //  set, set the SYNC overrun bit.

  Event_Reserved           = 2;       // RESERVED


{*********************************************
 * IMPL_EVCB - Implicit Event Control Block
 *             (This is a parameter on the
 *              SpiCreatStrem API)
 *********************************************}
  Event_Implicit_Type      = 3;      // These events are always supported

type
  impl_evcb = record
    ulType     : uLong;              // Event_IMPLICIT_TYPE
    ulSubType  : uLong;              // One of the implicit events (input)
    ulFlags    : uLong;              // 0 (Input), status (Output)
    hstream    : hStream;            // handle to stream for this event (input/output)
    hid        : hID;                // 0 (input), handler Id (output)
    ulStatus   : uLong;              // Event status/error return code (output)
    unused1    : uLong;              // 0 (input)
    unused2    : uLong;              // 0 (input)
    unused3    : uLong;              // 0 (input)
  end;
  pImpl_evcb = ^impl_evcb;

const
  // ulSubtype
 Event_EOS                 = 1;      // End of Stream
 Event_ERROR               = 2;      // Error in Stream handler or device driver
 Event_STREAM_STOPPED      = 3;      // Stream is in a stopped state (Discard or Flush)
 Event_SYNC_PREROLLED      = 4;      // All streams are prerolled (buffers
                                     //  have been filled by the Source SH's.
 Event_PLAYLISTMESSAGE     = 5;      // Memory SH playlist message event
 Event_PLAYLISTCUEPOINT    = 6;      // Memory SH playlist cue point
 Event_QUEUE_OVERFLOW      = 7;      // Event Queue overflow. Indicates lost
                                     //  events. Application must use this
                                     //  to clear any waiting conditions.

{*********************************************
 * PLAYL_EVCB - Playlist Message Event Control Block
 *********************************************}
type
  // (IMPLICIT EVENT)
  PlayL_evcb = record
    ulType         : uLong;             // Event_IMPLICIT_TYPE
    ulSubType      : uLong;             // Event_PLAYLISTMESSAGE or Event_PLAYLISTCUEPOINT
    ulFlags        : uLong;             // 0 (input), status (output)
    hstream        : hStream;           // handle to stream for this event (input/output)
    hid            : hID;               // 0 (input), handler Id (output)
    ulStatus       : uLong;             // Playlist Instruction number (output)
    ulMessageParm  : uLong;             // 0 (input), Message from playlist (output)
    unused1        : uLong;             // 0 (input)
    unused2        : uLong;             // 0 (input)
  end;
  pPlayL_evcb = ^PlayL_evcb;

{*********************************************
 * OVRU_EVCB - Sync Overrun Event Control Block
 *             (Applications can request to be
 *              notified whenever a Sync overrun
 *              occurs.
 *********************************************}
  Ovru_evcb = record
    ulType        : uLong;             // Event_SYNCOVERRUN
    ulSubType     : uLong;             // Not used
    ulFlags       : uLong;             // 0 (input), status (output)
    hstream       : hStream;           // handle to stream for this event (input/output)
    hid           : hID;               // handler Id (input/output)
    ulStatus      : uLong;             // Event status/error return code (output)
    mmtimeSlave   : mmTime;            // 0 (input), Slave stream time (output)
    mmtimeStart   : mmTime;            // 0 (input), Slave start offset (offset)
    mmtimeMaster  : mmTime;            // 0 (input), Master stream time (output)
  end;
  pOvru_evcb = ^Ovru_evcb;

{*********************************************
 * TIME_EVCB - Cue Time Event Control Block
 *             (Applications can request to be
 *              notified for a time cue point)
 *********************************************}
  time_evcb = record
    ulType         : uLong;            // Event_CUE_TIME
    ulSubType      : uLong;            // Not used
    ulFlags        : uLong;            // Single/Recurring(input/output)
    hstream        : HSTREAM;          // handle to stream for this event (input/output)
    hid            : hID;              // handler Id (input/output)
    ulStatus       : uLong;            // Event status/error return code (output)
    mmtimeStream   : MMTIME;           // Stream time (input/output)
    unused1        : uLong;            // 0 (input)
    unused2        : uLong;            // 0 (input)
  end;
  ptime_evcb = ^time_evcb;

const
  // ulFlags:
  Event_SINGLE             = 0;        // This is single one time event
  Event_RECURRING          = 1;        // This is recurring event

{*********************************************
 * DATA_EVCB - Cue Data Event Control Block
 *             (Applications can request to be
 *              notified for a data cue point)
 *********************************************}
type
  data_evcb = record
    ulType        : uLong;             // Event_CUE_DATA
    ulSubType     : uLong;             // Event SubType
    ulFlags       : uLong;             // Single/Recurring(input/output)
    hstream       : HSTREAM;           // handle to stream for this event (input/output)
    hid           : hID;               // handler Id (input/output)
    ulStatus      : uLong;             // Event status/error return code (output)
    mmtimeStream  : mmTime;            // Stream time (input/output)
    ulEventParm1  : uLong;             // Data to Cue on (input/output)
                                       //  This is interpreted by the stream handler
    ulEventParm2  : uLong;             // Length of data cue buffer (input/output)
  end;
  pdata_evcb = ^data_evcb;

const
  // ulFlags:
  Event_DATAPTR            = 2;        // ulEventParm1 if ptr to buffer and
                                       //  ulEventParm2 is a length of buffer,
                                       //  else ulEventParm1 is data.

{*****************
 * EVCB_ulType:  (Stream Handler defined types)
 *****************}
  sh_Type                  = $80000000;// Stream Handler defined types must
                                       // have the high order bit set in the
                                       // ulType field.
                                       // events: 0H - 7FFFFFFFH are reserved!

{*********************************************
 * EVCB - Generic Event Control Block (Use the
 *        specific one in the SSM.H if possible)
 *********************************************}
type
  evcb = record
    ulType       : uLong;              // Event type (input)
    ulSubType    : uLong;              // Event SubType (input)
    ulFlags      : uLong;              // 0 (Input), status (Output)
    hstream      : HSTREAM;            // handle to stream for this event
    hid          : hID;                // handler Id (input/output)
    ulStatus     : uLong;              // Event status (output)
    ulEventParm1 : uLong;              // Event parameters (input), hID if implicit event
    ulEventParm2 : uLong;              // Event parameters (input)
    ulEventParm3 : uLong;              // Event parameters (input)
  end;
  pevcb = ^evcb;

{*********************************************
 * STATUS_LEVEL_EVCB - Status Level Event Control Block
 *********************************************}
  Status_Level_evcb = record
    // standard part
    ulType          : uLong;            // Event type (input)
    ulSubType       : uLong;            // Event SubType (input)
    pMCDInstance    : uLong;            // for MCD use
    hstream         : hStream;          // handle to stream for this event
    hid             : hID;              // handler Id (input/output)
    // custom part
    ulSample        : Array[0..3] of uLong; // Samples
  end;
  pStatus_Level_evcb = ^Status_Level_evcb;

{----[ SSM / ACB ]----}

// Associate Control Block Definitions

const
  Max_Port_Name            = 40;        // Max port name length
  Max_Ports                = 16;        // Max number ports

{**********************************************
 *
 * ACB - Associate Control Block
 *
 *       Each stream handler must define the
 *       ACB for each data object type that
 *       expect ACB's from the application.
 *
 **********************************************}
type
  ACB = record                          // acb  -  Assoc. Control Block
    ulACBLen   : uLong;                 // length of structure
    ulObjType  : uLong;
    ulParm1    : uLong;
    ulParm2    : uLong;
  end;
  pACB = ^ACB;

{*****************************************************
 * FSSH - File system stream handler MMIO Object ACB
 *****************************************************}
const
  ACBType_mmIO             = $0001;     // MMIO object

type
  ACB_mmIO = record                     // acbmmio  - MMIO Assoc. Control Block
    ulACBLen  : uLong;                  // length of structure
    ulObjType : uLong;                  // ACBTYPE_MMIO
    hmmio     : HMMIO;                  // Handle of media element mgr obj
  end;
  pACB_mmIO = ^ACB_mmIO;

{*****************************************************
 * MSH - Memory stream handler Playlist Object ACB
 *****************************************************}
const
  ACBType_Mem_PlayL        = $0003;     // Memory playlist object

type
  ACB_Mem_PlayL = record                // acbplyl - File system Assoc. Control Block
    ulACBLen    : uLong;                // length of structure
    ulObjType   : uLong;                // ACBType_MEM_PLAYL
    pMemoryAddr : Pointer;              // Starting address of memory obj
  end;
  pACB_Mem_PlayL = ^ACB_Mem_PlayL;

{*****************************************************
 * CDDASH - CD DA stream handler Object ACB
 *****************************************************}
const
  ACBType_CDDA             = $0004;     //  Compact disk - digital audio obj

type
  ACB_CDDA = record                     // acbcdda - CD Assoc. Control Block
    ulACBLen   : uLong;                 // length of structure
    ulObjType  : uLong;                 // ACBType_CDDA
    bCDDrive   : CHAR;                  // CD drive letter
  end;
  pACB_CDDA = ^ACB_CDDA;

{*****************************************************
 * MISH - MIDI stream handler port-stream table ACB
 *****************************************************}
const
  ACBType_MISH             = $0005;     // MIDI port-stream table

type
  ACB_Mish = record                     // acbmish - MIDI Assoc. Control Block
    ulACBLen        : uLong;            // length of structure
    ulObjType       : uLong;            // ACBType_MISH
    hstreamDefault  : HSTREAM;          // Default hstream to use when mapper
                                        // is turned off.
    ulDeviceTypeID  : uLong;            // device type id
    ulpMapperPorts  : uLong;            // pointer to mapper port table
    ulNumInStreams  : uLong;
    hstreamIn       : Array[1..Max_Ports] of hStream; // Array of Input streams
    ulNumOutStreams : uLong;
    hstreamOut      : Array[1..Max_Ports] of hStream; // Array of Output streams
                                        // The index into the array is
                                        // the source channel for that
                                        // stream.
  end;
  pACB_Mish = ^ACB_Mish;

{*****************************************************
 * MISH - MIDI stream handler SET ACB
 *****************************************************}
const
  ACBType_SET              = $0006;     // MIDI set function

type
  ACB_Set = record                      // acbset - Set Assoc. Control Block
    ulACBLen   : uLong;                 // length of structure
    ulObjType  : uLong;                 // ACBType_SET
    ulFlags    : uLong;                 // Set flags
    ulReserved : uLong;                 // Reserved
  end;
  pACB_Set = ^ACB_Set;

const
  // ulFlags defines
  MIDI_MAP_ON              = $0000;     // turn mapping function on in MISH
  MIDI_MAP_OFF             = $0001;     // turn mapping function off in MISH

{*****************************************************
 * NULLSH - Null stream handler user ACB
 *****************************************************}
const
  ACBType_NULLSH           = $0007;     // User od Null stream handler

type
  ACB_NullSH = record                   // acbnullsh - NULLSH Assoc. Control Block
    ulACBLen   : uLong;                 // length of structure
    ulObjType  : uLong;                 // ACBType_NULLSH
    pfnEntry   : PFN;                   // user callback entry point
    ulReserved : uLong;                 // Reserved
  end;
  pACB_NullSh = ^ACB_NullSh;

{*****************************************************
 * MTSH - MultiTrack Stream Handler Object ACB
 *****************************************************}
const
  ACBType_MTSH             = $0008;     // MTSH object

type
  ACB_MTSH = record                     // acbmtsh  - MTSH Assoc. Control Block
    ulACBLen         : uLong;           // length of structure
    ulObjType        : uLong;           // ACBType_MTSH
    hmmio            : HMMIO;           // Handle of media element mgr obj
    mmtrackInfo      : MMTRACKINFO;     // track for this stream
    ulFlags          : uLong;           // flags
    ulMaxBytesPerSec : uLong;           // Max bytes per second
    ulAvgBytesPerSec : uLong;           // Avg bytes per second
    mmtimePerFrame   : MMTIME;          // frame display time or 0L
    ulTotalFrames    : uLong;           // total number of video frames
  end;
  pACB_MTSH = ^ACB_MTSH;

const
  // ulFlags defines
  Track_ACTIVATE           = $0000;     // Activate track in stream handler
  Track_DEACTIVATE         = $0001;     // Deactivate track in stream handler


{*****************************************************
 * CSH - CODEC stream handler Object ACB
 *****************************************************}
const
  ACBType_CODECSH          = $0009;     // CODEC object

type
  ACB_CodecSH = record                  // acbcodecsh - CODEC SH acb
    ulACBLen        : uLong;            // length of structure
    ulObjType       : uLong;            // ACBType_CODECSH
    hstreamToPair   : HSTREAM;          // 2nd stream of pair
    pMmioInfo       : Pointer;          // info for IO Proc
    ulInfoLength    : uLong;            // length of MmioInfo
    pCodecControl   : Pointer;          // CODEC control info
    ulControlLength : uLong;            // length of CodecControl
  end;
  pACB_CodecSH = ^ACB_CodecSH;

{----[ SSM / DCB ]----}

// Device Control Block Definitions

{**************************************************************************
 *
 * DCB - Common Device Control Block
 *               (*** PACKED STRUCTURE ***)
 **************************************************************************}
type
  DCB = packed record                   // dcb  -  Device Control Block
    ulDCBLen  : uLong;                  // length of structure
    szDevName : Array[0..MAX_SPI_NAME-1] of Char; // device driver name
  end;
  pDCB = ^DCB;

{**************************************************************************
 *
 * E_DCB - Extended Device Control Block
 *
 *         This structure will grow over time as new fields are added
 *         to the end of the structure.  If you manipulate the structure,
 *         be sure to check the length field.
 *
 *               (*** PACKED STRUCTURE ***)
 **************************************************************************}
 E_DCB = packed record                  // e_dcb  -  Extended Device Control Block
   ulDCBLen     : uLong;                // length of structure
   szDevName    : Array[0..MAX_SPI_NAME-1] of char; // device driver name
   ulSysFileNum : uLong;                // file handle number

   //    new fields will be added here
 end;
 DCB_AudioSH = E_DCB;
 pE_DCB = ^E_DCB;
 pDCB_AudioSH = ^DCB_AudioSH;

{**************************************************************************
 *
 * VSD_DCB - VSD Device Control Block
 *
 *         This structure will allow stream handlers to use the VSD DLL
 *         by using by the additional fields in the structure.
 *
 *               (*** PACKED STRUCTURE ***)
 **************************************************************************}
  VSD_DCB = packed record               // vsd_dcb - VSD Device Control Block
    ulDCBLen         : uLong;           // length of structure
    szDevName        : Array[0..MAX_SPI_NAME-1] of Char; // device driver name
    ulSysFileNum     : uLong;           // file handle number
    hvsd             : uLong;           // Handle to VSD instance
    pfnvsdEntryPoint : PFN;             // Address of VSD entry point
    ulReserved1      : uLong;           // Reserved for system
    ulReserved2      : uLong;           // Reserved for system
  end;
  pVSD_DCB = ^VSD_DCB;

{----[ SSM, cont'd ]----}

{**************************************************************************
  INI file support defines
 **************************************************************************}
const
  // RCDATA defines
  SPI_RESOURCE                  = 1;    // RCDATA resource number
  SH_DLL_TYPE                   = 0;    // DLL type stream handler
  SH_PDD_TYPE                   = 1;    // PDD type stream handler
  SPCBSIZE                      = 72;   // SPCB length, the Resource compiler
                                        //   doesn't allow sizeof(SPCB).

(**************************************************************************
//
//  Function Prototypes for Application event entry routine, SHC entry
//  routine, SMH entry routine. All use the Pure C calling convention
//
//**************************************************************************
typedef uLong (APIENTRY EVFN) (PEVCB  pevcb);
typedef EVFN (FAR *PEVFN);

typedef uLong (APIENTRY SHCFN) (pVoid pParmIn);
typedef SHCFN (FAR *PSHCFN);

typedef uLong (APIENTRY SMHFN) (pVoid pParmIn);
typedef SMHFN (FAR *PSMHFN);*)

type
  pEvfn = Pointer;
  pShcfn = Pointer;
  pSmhfn = Pointer;

{**************************************************************************
  Function Prototypes for SPI functions
  All use Pure C calling convention
  Six major categories:
     - stream creation
     - stream control
     - event handling
     - sync handling
     - configuration
     - stream protocol programming
 **************************************************************************}

{**************************************************************************
  Stream Creation
 **************************************************************************}

function SpiAssociate ( stream: hStream; ID: hID; pac: pACB ): uLong;

function SpiEnumerateHandlers ( Hand: PHand; // ptr to array handler name/class
                                NumHand: PuLong ): uLong;

function SpiGetHandler ( HName: pChar; var phidSrc,phidTgt: hID ): uLong;

function SpiCreateStream ( hidSrc: hID;        // input
                           hidTgt: hID;        // input
                           Key: pspcbkey;      // input
                           Src: PDCB;          // input - Src device info
                           Tgt: PDCB;              // input - Tgt device info
                           Evcb: PIMPL_EVCB;       // input
                           EventEntry: PEVFN;      // input
                           StreamBuf: HSTREAM;     // input
                           Stream: PHSTREAM;       // output
                           Event: PhEvent): uLong; // output - implicit hevent

function SpiSendMsg ( Stream: hStream; ID: hID; MsgType: uLong; Msg: pVoid): uLong;

// The first thing in the pMsg must be the length of the structure!
type
  Msg_Common = record
    ulMsgLen  : uLong;              // length of structure
  end;

//**************************************************************************
// Stream Control
//**************************************************************************

function SpiDestroyStream ( Stream: hStream ): uLong;
function SpiGetTime ( Stream: hStream; Time: pMMTime ): uLong;
function SpiSeekStream ( Stream: hStream; Flags: uLong; SeekPoint: Long ): uLong;

const
  // SpiSeekStream() Flags defines
  SPI_SEEK_ABSOLUTE             = $0000;         // Seek from beginning of stream
  SPI_SEEK_RELATIVE             = $0001;         // Seek from current location
  SPI_SEEK_FROMEND              = $0002;         // TEMP
  SPI_SEEK_SLAVES               = $0010;         // Seek all slave streams

  SPI_SEEK_MMTIME               = $0000;         // lSeekPoint == mmtime (default)
  SPI_SEEK_BYTES                = $0100;         // lSeekPoint == bytes

  SPI_SEEK_IFRAME               = $1000;         // Seek to nearest IFRAME

  VALIDSEEKFLAGS                = SPI_SEEK_RELATIVE OR
                                  SPI_SEEK_ABSOLUTE OR
                                  SPI_SEEK_FROMEND  OR
                                  SPI_SEEK_MMTIME OR
                                  SPI_SEEK_SLAVES OR
                                  SPI_SEEK_IFRAME OR
                                  SPI_SEEK_BYTES;

function SpiStartStream ( Stream: hStream; Flags: uLong ): uLong;

const
  // SpiStartStream() Flags defines
  SPI_START_STREAM              = $0000;         // Only start this one stream
  SPI_START_SLAVES              = $0001;         // Start this master and any slaves
  SPI_START_PREROLL             = $0002;         // Start the stream, but do preroll

  VALIDSTARTFLAGS               = SPI_START_STREAM OR
                                  SPI_START_SLAVES OR
                                  SPI_START_PREROLL;


function SpiStopStream ( Stream: hStream; Flags: uLong ): uLong;

const
  // SpiStopStream() Flags defines
  SPI_STOP_STREAM               = $0000;   // Only stop this one stream
                                           // The default is to pause the data
                                           //  stream. No change to data buffers.
                                           //  synchronous call (no event notification)
  SPI_STOP_SLAVES               = $0001;   // Stop this master and any slaves
  SPI_STOP_FLUSH                = $0002;   // Stop and flush all filled buffers.
                                           //  Stops the Src & Tgt SH, lets the
                                           //  Tgt SH run until out of buffers
                                           //  thereby, "flushing" all buffers.
                                           //  Tgt SH stops when out of buffers
                                           //  (This is a ASYNCHRONOUS call, event
                                           //   notification sent to appl when done.)
  SPI_STOP_DISCARD              = $0004;   // Stop and discard all filled buffers.
                                           //  Stops the Src & Tgt SH
                                           //  then discards all buffers current for
                                           //  this stream.
                                           //  (This is a ASYNCHRONOUS call, event
                                           //   notification sent to appl when done.)

  VALIDSTOPFLAGS                = SPI_STOP_STREAM OR
                                  SPI_STOP_SLAVES OR
                                  SPI_STOP_FLUSH OR
                                  SPI_STOP_DISCARD;

//**************************************************************************
// Event Handling
//**************************************************************************

function SpiDisableEvent ( Event: hEvent ): uLong;
function SpiEnableEvent ( ev: pEvcb; Event: phEvent ): uLong;

//**************************************************************************
// Sync Handling
//**************************************************************************


function SpiDisableSync  ( MasterStream: hStream ): uLong;
function SpiEnableSync ( MasterStream: hStream; SlaveList: pSlave;
  NumSlaves: uLong; TimeSync: mmTime ): uLong;
function SpiDetermineSyncMaster ( MasterStream: hStream; MasterList: pMaster;
  NumMasters: uLong ): uLong;

//**************************************************************************
// Protocol manipulation
//**************************************************************************

function SpiGetProtocol ( ID: hID; InKey: pspcbkey; OutKey: pspcb ): uLong;
function SpiInstallProtocol ( ID: hID; InKey: pspcbkey; InSpcb: pspcb;
  Flags: uLong ): uLong;

const
  // SpiInstallProtocol() Flags defines
  SPI_INSTALL_PROTOCOL          = $0000;         // Install this protocol
  SPI_DEINSTALL_PROTOCOL        = $0001;         // DeInstall this protocol

  VALIDINSTALLFLAGS             = SPI_INSTALL_PROTOCOL OR SPI_DEINSTALL_PROTOCOL;

function SpiEnumerateProtocols ( ID: hID;
                                 SPCBKeys: Pointer;            // ptr to buffer to fill with SPCB keys
                                 NumSPCBKeys: pUlong ): uLong; // # of entries buffer on input,
                                                               // # of SPCB key on output.

//**************************************************************************
//
//  Function Prototypes for SMH functions
//  All use Pure C calling convention
// NOTE ABOUT POINTERS:
//  0:32 linear addresses for ring 3 (DLL) stream handlers
//  16:16 selector/offset addresses for ring 0 (PDD) stream handlers
//**************************************************************************

type
  SMHEntryPoint = function( pParmIn: Pointer ): uLong;
  smh_Common = record             // smhfunc
    uFunction : uLong;            // SMH command function
    ID: hID;                      // handler ID
  end;
  psmh_Common = ^smh_Common;

const
  smh_Register                  = 0;           // (Valid only from ring 3 stream
                                               //  handler)
type
  Parm_Reg = record                            // smhreg
    ulFunction: uLong;                         // SMH command function
    pszSHName: pChar;                          // Max size = 8 characters
    phidSrc: ^hID;                             // (9 including null)
    phidTgt: ^hID;
    pshcfnEntry: PSHCFN;                       // Handler entry point for SHC's
                                               //  Only used for Ring 0 handlers.
    ulFlags: uLong;
    ulMaxNumStreams: uLong;                    // Max # of streams
    ulMaxNumEvents: uLong;                     // Max # of events/stream
  end;
  pParm_Reg = ^Parm_Reg;

const
  REGISTER_TGT_HNDLR            = $0001;         // This handler is Target.
  REGISTER_SRC_HNDLR            = $0002;         // This handler is Source.
                                                 // Handler can be both.
  REGISTER_NONSTREAMING         = $0004;         // Handler is non-streaming.
  VALIDREGISTERFLAGS            = REGISTER_TGT_HNDLR OR REGISTER_SRC_HNDLR OR REGISTER_NONSTREAMING;

// Notes:
//  - Since ring 0 (DD) stream handlers can not use the IDC interface to the
//    sync/stream manager during DD initialization time, it must use the IOCTL
//    function to perform the SMH_REGISTER function. The addresses are 16:16
//    for this IOCTl instead of 0:32, because it comes form a device driver.
  SSMDD_CATEGORY                = $0081;    // Category (For ring 0 stream handler)
  IOCTL_FUNC_SMH_REGISTER       = $0040;    // Function (For ring 0 stream handler)


//**************************************************************************
  SMH_DEREGISTER                = 1;           // SMH_Deregister()

type
  Parm_DeReg = record                          // smhder
    uFunction : uLong;                         // SMH command function
    pszSHName : pChar;                         // Max size = 8 char, 9 includes
  end;
  pParm_DeReg = ^Parm_DeReg;

//**************************************************************************
const
  SMH_REPORTEVENT               = 2;           // SMH_ReportEvent()

type
  Parm_Event = record                          // smhrev
    ulFunction : uLong;                        // SMH command function
    ID         : hID;
    Event      : HEvent;                       // Used only for explicit events
                                               //  Must be 0 for sync and implicit
                                               //  events (i.e. error events)
    pevcbEvent: PEVCB;                         // Event status & HSTREAM
  end;
  pParm_Event = ^Parm_Event;

//**************************************************************************
const
  SMH_NOTIFY                    = 3;           // SMH_Notify()

type
  Parm_Notify = record                         // smhnot
    ulFunction      : uLong;                   // Input - SMH command function
    hid             : hID;                     // Input
    hstream         : hStream;                 // Input
    ulFlags         : uLong;                   // Input/Output
    ulGetNumEntries : uLong;                   // Input/Output - # of entries in table
    ulRetNumEntries : uLong;                   // Input/Output - # of entries in table
    pGetBufTab      : pVoid;                   // Output - Ptr to buffer/record table
    pRetBufTab      : pVoid;                   // Input - Ptr to buffer/record table
  end;
  pParm_Notify = ^Parm_Notify;

  SrcBufTab = record                           // srcbuftab
    pBuffer       : pVoid;                     // Ptr to buffer
    pRecord       : pVoid;                     // Ptr to record in buffer (split-streams only)
    ulLength      : uLong;                     // Max buf length on GetEmpty, Filled
                                               // (actual) rec/buf length on ReturnFull.
    ulMessageParm : uLong;                     // Message to passed to application
    mmtimeOffset  : mmTime;                    // mmtime offset from beginning of buffer
  end;
  pSrcBufTab = ^SrcBufTab;

  TgtBufTab = record                           // tgtbuftab
    pBuffer       : pVoid;                     // Ptr to buffer
    ulBufId       : uLong;                     // Buffer ID. Passed to SH on GetFull, must
                                               // be passed back to SSM on ReturnEmpty.
    ulLength      : uLong;                     // Filled (actual) buffer length on GetFull,
                                               // unused on ReturnEmpty.
    ulMessageParm : uLong;                     // Message to passed to application
    mmtimeOffset  : mmTime;                    // mmtime offset from beginning of buffer
  end;
  pTgtBufTab = ^TgtBufTab;

// EXTENDED SMH_NOTIFY Structures

  Parm_Enotify = record                        // smhenot
    ulFunction      : uLong;                   // Input - SMH command function
    hid             : hID;                     // Input
    hstream         : hStream;                 // Input
    ulFlags         : uLong;                   // Input/Output
    ulGetNumEntries : uLong;                   // Input/Output - # of entries in table
    ulRetNumEntries : uLong;                   // Input/Output - # of entries in table
    pGetBufTab      : pVoid;                   // Output - Ptr to buffer/record table
    pRetBufTab      : pVoid;                   // Input - Ptr to buffer/record table
    ulParm1         : uLong;                   // Reserved for future use
    ulParm2         : uLong;                   // Reserved for future use
  end;
  pParm_Enotify = ^Parm_Enotify;

  ESrcBufTab = record                          // esrcbuftab
    pBuffer       : pVoid;                     // Ptr to buffer
    pRecord       : pVoid;                     // Ptr to record in buffer (split-streams only)
    ulLength      : uLong;                     // Max buf length on GetEmpty, Filled
                                               // (actual) rec/buf length on ReturnFull.
    ulMessageParm : uLong;                     // Message to passed to application
    mmtimeOffset  : mmTime;                    // mmtime offset from beginning of buffer
    ulParm1       : uLong;                     // Record or buffer specific data
    ulParm2       : uLong;                     // Record or buffer specific data
  end;
  pESrcBufTab = ^ESrcBufTab;

  ETgtBufTab = record                          // etgtbuftab
    pBuffer         : pVoid;                   // Ptr to buffer
    ulBufId         : uLong;                   // Buffer ID. Passed to SH on GetFull, must
                                               // be passed back to SSM on ReturnEmpty.
    ulLength        : uLong;                   // Filled (actual) buffer length on GetFull,
                                               // unused on ReturnEmpty.
    ulMessageParm   : uLong;                   // Message to passed to application
    mmtimeOffset    : mmTime;                  // mmtime offset from beginning of buffer
    ulParm1         : uLong;                   // Buffer specific data
    ulParm2         : uLong;                   // Buffer specific data
  end;
  pETgtBufTab = ^ETgtBufTab;

  EPSrcBufTab = record                         // epsrcbuftab
    pBuffer        : pVoid;                    // Ptr to buffer
    pRecord        : pVoid;                    // Ptr to record in buffer (split-streams only)
    ulLength       : uLong;                    // Max buf length on GetEmpty, Filled
                                               // (actual) rec/buf length on ReturnFull.
    ulMessageParm  : uLong;                    // Message to passed to application
    mmtimeOffset   : mmTime;                   // mmtime offset from beginning of buffer
    ulParm1        : uLong;                    // Record or buffer specific data
    ulParm2        : uLong;                    // Record or buffer specific data
    pProcessLin    : pVoid;                    // Process Linear record ptr
  end;
  pEPSrcBufTab = ^EPSrcBufTab;

  EPTgtBufTab = record                         // eptgtbuftab
    pBuffer        : pVoid;                    // Ptr to buffer
    ulBufId        : uLong;                    // Buffer ID. Passed to SH on GetFull, must
                                               // be passed back to SSM on ReturnEmpty.
    ulLength       : uLong;                    // Filled (actual) buffer length on GetFull,
                                               // unused on ReturnEmpty.
    ulMessageParm  : uLong;                    // Message to passed to application
    mmtimeOffset   : mmTime;                   // mmtime offset from beginning of buffer
    ulParm1        : uLong;                    // Buffer specific data
    ulParm2        : uLong;                    // Buffer specific data
    pProcessLin    : pVoid;                    // Process Linear buffer ptr
  end;
  pEPTgtBufTab = ^EPTgtBufTab;

const
  //SMH_ulFlags
  BUF_GETEMPTY                  = $00000001;   // Ptr returned in SMH_pGetBuffer
  BUF_RETURNFULL                = $00000002;   // Ptr passed in SMH_pRetBuffer
  BUF_GETFULL                   = $00000004;   // Ptr returned in SMH_pGetBuffer
  BUF_RETURNEMPTY               = $00000008;   // Ptr passed in SMH_pRetBuffer
  BUF_GIVEBUF                   = $00000010;   // Ptr passed in SMH_pRetBuffer
  BUF_EOS                       = $00000100;   // End of stream. Source sets this on
                                               //  last buffer. Target sets it after
                                               //  consuming the laset buffer.
  BUF_RECORDS                   = $00004000;   // One or more records (Split-stream)
  BUF_LASTRECORD                = $00008000;   // (BUF_RETURNFULL only) Mark
                                               // these record(s) as being the
                                               // last in the buffer. So the SSM
                                               // knows the maximum # of records
                                               // produced for this buffer.
                                               // (Split stream only)
  //SMH_ulFlags
  BUF_LINEAR                    = $00010000;   // Ptrs are Global linear
  BUF_PHYSICAL                  = $00020000;   // Ptrs are physical
                                               // (valid only for phyically
                                               //  contiguous buffers)
  BUF_RESERVED                  = $00040000;   // Reserved
  BUF_GDT                       = $00080000;   // Ptrs are GDT sel:offset
  BUF_EXTENDED                  = $80000000;   // Use Extended SMH_NOTIFY structures
  BUF_EXTENDEDPTR               = $40000000;   // Use Extendedptr SMH_NOTIFY structures
                                               //  Implies BUF_EXTENDED

  VALIDSOURCEFLAGS              = BUF_RETURNFULL or BUF_GETEMPTY or BUF_EOS or BUF_LASTRECORD or BUF_PHYSICAL or BUF_LINEAR or BUF_GDT or BUF_RECORDS or BUF_GIVEBUF or BUF_EXTENDED or BUF_EXTENDEDPTR;
  VALIDTARGETFLAGS              = BUF_RETURNEMPTY or BUF_GETFULL or BUF_PHYSICAL or BUF_LINEAR or BUF_GDT or BUF_EOS or BUF_EXTENDED or BUF_EXTENDEDPTR;


//**************************************************************************
const
  SMH_LOCKMEM                   = 4;              // SMH_LockMem()

type
  Parm_LockM = record                             // smhloc
    ulFunction  : uLong;                          // SMH command function
    pBuffer     : pVoid;
    ulBufSize   : uLong;
    lockh       : PLockH;
    Flags       : uLong;
  end;
  pParm_LockM = ^Parm_LockM;

const
  //SMH_ulFlags
  SSM_LOCKMEM                   = $0000;         // Lock Memory.
  SSM_UNLOCKMEM                 = $0001;         // Unlock memory.
  SSM_CONTIGLOCK                = $0002;         // Lock memory contiguously.
  SSM_LOCKMEM_RESERVED1         = $0100;         // reserved
  SSM_LOCKMEM_RESERVED2         = $0200;         // reserved
//**************************************************************************

//**************************************************************************
//
//  Function Prototypes for SHC functions (Stream Handler Functions)
//  All use Pure C calling convention
//
// NOTE ABOUT POINTERS:
//  0:32 linear addresses for ring 3 (DLL) stream handlers
//  16:16 selector/offset addresses for ring 0 (PDD) stream handlers
//  Use the System.SelToFlat or System.FlatToSel to convert one to the other
//**************************************************************************
type
  shc_Common = record                          // shcfunc
    uFunction  : uLong;                        // Handler command function
    ID         : hID;                          // handler ID
  end;
  pshc_Common = ^shc_Common;

//**************************************************************************
const
  SHC_ASSOCIATE                 = 0;

type
  Parm_Assoc = record                          // shcass
    ulFunction    : uLong;                     // Handler command function
    hid           : hID;                       // handler ID
    hstream       : hStream;                   // handle of stream instance
    pacb          : PACB;                      // pointer to associate control block
  end;
  pParm_Assoc = ^Parm_Assoc;

//**************************************************************************
const
  SHC_CLOSE                     = 1;

type
  Parm_Close = record                          // shcclo
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
  end;
  pParm_Close = ^Parm_Close;

//**************************************************************************
const
  SHC_CREATE                    = 2;

type
  Parm_Create = record                         // shccrt
    ulFunction   :  uLong;                     // Handler command function
    ID           :  hID;                       // handler ID
    Stream       :  hStream;                   // handle of stream instance
    spcbkey      :  SPCBKEY;                   // type of stream to create
    spcb         :  PSPCB;                     // Pointer to SPCB from handler
    hstreamBuf   :  hStream;                   // Used for split streams or to associate
                                               // another stream with this stream.
    Dcb          :  PDCB;                      // pointer to device control block
  end;
  pParm_Create = ^Parm_Create;

//**************************************************************************
const
  SHC_DESTROY                   = 3;

type
  Parm_Destroy = record                        // shcdes
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Stream        : hStream;                   // handle of stream instance
  end;
  pParm_Destroy = ^Parm_Destroy;

//**************************************************************************
const
  SHC_START                     = 4;

type
  Parm_Start = record                          // shcstr
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Stream        : hStream;                   // handle of stream instance
    Flags         : uLong;                     // Start flags
  end;
  pParm_Start = ^Parm_Start;

const
  // Flags
  FLUSH_START                   = $0001;       // This start is a result of a Flush Stop command.

//**************************************************************************
const
  SHC_STOP                      = 5;

type
  Parm_Stop = record                           // shcstp
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Stream        : hStream;                   // handle of stream instance
    Flags         : uLong;                     // Stop flags (refer to Flags defines under
                                               //  SpiStopStream() call.
  end;
  pParm_Stop = ^Parm_Stop;

//**************************************************************************
const
  SHC_SEEK                      = 6;

type
  Parm_Seek = record                           // shcsek
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Stream        : hStream;                   // handle of stream instance
    Flags         : uLong;                     // Seek flag (refer to Flags defines under
                                               //  SpiSeekStream() call.
    SeekPoint     : Long;                      // seek to point , mmtime or other
  end;
  pParm_Seek = ^Parm_Seek;

//**************************************************************************
const
  SHC_ENABLE_EVENT              = 7;

type
  Parm_EnEvent = record                        // shceev
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Event         : hEvent;                    // handle of event to enable
    evcbUser      : PEvcb;                     // User event information (e.g. hstream
                                               //  EventType, EventSubType)
  end;
  pParm_EnEvent = ^Parm_EnEvent;

//**************************************************************************
const
  SHC_DISABLE_EVENT             = 8;

type
  Parm_DisEvent = record                       // shcdev
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Stream        : hStream;                   // handle of stream for this event
    Event         : hEvent;                    // handle of event to disable
  end;
  pParm_DisEvent = ^Parm_DisEvent;

//**************************************************************************
const
  SHC_ENABLE_SYNC               = 9;

type
  Parm_EnSync = record                         // shcesy
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Stream        : hStream;                   // handle of stream instance
    Flags         : uLong;                     // Sync flags
    TimeSync      : mmTime;                    // granularity of sync interval (if null, use default)
    SyncPulse     : PSync_EVCB;                // Sync pulse EVCB information
    PulseSem      : uLong;                     // Optional 16 bit system
                                               // Semaphore for handler
  end;
  pParm_EnSync = ^Parm_EnSync;

const
  // Flags
  SYNC_MASTER                   = $0000;    // The handler will be a master for this sync
  SYNC_SLAVE                    = $0001;    // The handler will be a slave for this sync

//**************************************************************************
const
  SHC_DISABLE_SYNC              = 10;

type
  Parm_DisSync = record                        // shcdsy
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Stream        : hStream;                   // handle of stream instance
  end;
  pParm_DisSync = ^Parm_DisSync;

//**************************************************************************
const
  SHC_GET_TIME                  = 11;

type
  Parm_gTime = record                          // shcgti
    ulFunction    : uLong;                     // Handler command function
    ID            : hID;                       // handler ID
    Stream        : hStream;                   // handle of stream instance
    TimeCurrent   : mmTime;                    // Returns current stream time
  end;
  pParm_gTime = ^Parm_gTime;

//**************************************************************************
const
  SHC_GET_PROTOCOL              = 12;

type
  Parm_gProt = record                          // shcgpt
    ulFunction   :  uLong;                     // Handler command function
    ID           :  hID;                       // handler ID
    spcbkey      :  SPCBKEY;                   // Key of SPCB
    spcb         :  PSPCB;                     // Pointer to SPCB (output)
  end;
  pParm_gProt = ^Parm_gProt;

//**************************************************************************
const
  SHC_INSTALL_PROTOCOL          = 13;

type
  Parm_InstProt = record                       // shcipt
    ulFunction   :  uLong;                     // Handler command function
    ID           :  hID;                       // handler ID
    spcbkey      :  SPCBKEY;                   // Key of SPCB
    spcb         :  PSPCB;                     // Pointer to SPCB to install
    Flags        :  uLong;                     // Install / Deinstall flags
  end;
  pParm_InstProt = ^Parm_InstProt;

//**************************************************************************
const
  SHC_ENUMERATE_PROTOCOLS       = 14;

type
  Parm_EnumProt = record                       // shcqpi
    ulFunction   :  uLong;                     // Handler command function
    ID           :  hID;                       // handler ID
    SPCBKeys     :  Pointer;                   // ptr to buffer to fill with SPCB keys
    NumSPCBKeys  :  pUlong;                    // # of entries buffer on input,
                                               //  # of SPCB key on output.
  end;
  pParm_EnumProt = ^Parm_EnumProt;

//**************************************************************************
const
  SHC_NEGOTIATE_RESULT          = 15;

type
  Parm_Negotiate = record                      // shcneg
    ulFunction   :  uLong;                     // Handler command function
    ID           :  hID;                       // handler ID
    Stream       :  hStream;                   // handle of stream instance
    SPCB         :  pSPCB;                     // Ptr to negotiated SPCB
    ErrorStatus  :  uLong;                     // On error, indicates which field in the
  end;
  pParm_Negotiate = ^Parm_Negotiate;

//**************************************************************************
const
  SHC_SENDMSG                   = 16;

type
  Parm_SndMsg = record                         // shcsndmsg
    ulFunction   :  uLong;                     // Handler command function
    ID           :  hID;                       // handler ID
    Stream       :  hStream;                   // handle of stream instance
    MsgType      :  uLong;                     // Stream handler message type
    Msg          :  Pointer;                   // Pointer to Message control block
  end;
  pParm_SndMsg = ^Parm_SndMsg;

//**************************************************************************

{----[ MCIOS2 ]----}

const
  MCI_TRUE                      = 1;
  MCI_FALSE                     = 0;

  // MCI command messages identifiers
  MCI_OPEN                      = 1;
  MCI_CLOSE                     = 2;
  MCI_ESCAPE                    = 3;
  MCI_PLAY                      = 4;
  MCI_SEEK                      = 5;
  MCI_STOP                      = 6;
  MCI_PAUSE                     = 7;
  MCI_INFO                      = 8;
  MCI_GETDEVCAPS                = 9;
  MCI_STATUS                    = 10;
  MCI_SPIN                      = 11;
  MCI_SET                       = 12;
  MCI_STEP                      = 13;
  MCI_RECORD                    = 14;
  MCI_SYSINFO                   = 15;
  MCI_SAVE                      = 16;
  MCI_CUE                       = 17;
  MCI_UPDATE                    = 18;
  MCI_SET_CUEPOINT              = 19;
  MCI_SET_POSITION_ADVISE       = 20;
  MCI_SET_SYNC_OFFSET           = 21;
  MCI_LOAD                      = 22;
  MCI_ACQUIREDEVICE             = 23;
  MCI_RELEASEDEVICE             = 24;
  MCI_MASTERAUDIO               = 25;
  MCI_GETTOC                    = 26;
  MCI_DEVICESETTINGS            = 27;
  MCI_CONNECTOR                 = 28;
  MCI_RESUME                    = 29;
  MCI_CONNECTORINFO             = 31;
  MCI_DEFAULT_CONNECTION        = 32;
  MCI_CONNECTION                = 33;
  MCI_GROUP                     = 34;
  MCI_CAPTURE                   = 40;
  MCI_FREEZE                    = 41;
  MCI_GETIMAGEBUFFER            = 42;
  MCI_GETIMAGEPALETTE           = 43;
  MCI_PUT                       = 44;
  MCI_REALIZE                   = 45;
  MCI_REWIND                    = 46;
  MCI_RESTORE                   = 47;
  MCI_SETIMAGEBUFFER            = 48;
  MCI_SETIMAGEPALETTE           = 49;
  MCI_UNFREEZE                  = 50;
  MCI_WHERE                     = 51;
  MCI_WINDOW                    = 52;
  MCI_DELETE                    = 53;
  MCI_CUT                       = 54;
  MCI_PASTE                     = 55;
  MCI_COPY                      = 56;
  MCI_REDO                      = 57;
  MCI_UNDO                      = 58;
  MCI_MIXNOTIFY                 = 59;
  MCI_SETTUNER                  = 60;
  MCI_MAX_COMMAND               = 60;
  MCI_USER_MESSAGES             = 2000;

type
  RECT = uLong;
  HDCT = uLong;

const
  // Special device ID for 'all'
  MCI_ALL_DEVICE_ID             = $FFFF;

  // MCI implementation limits
  MAX_DEVICE_NAME               = 20;
  MAX_ALIAS_NAME                = 20;
  MAX_PRODINFO                  = 40;
  MAX_EXTENSION_NAME            = 4;
  MAX_DEV_PARAMS                = 128;
  MAX_VERSION_NUMBER            = 6;
  MAX_PDD_NAME                  = 9;
  MAX_DLL_NAME                  = 260;
  MAX_CLASSES                   = 10;
  MAX_CONNECTORS                = 10;
  MAX_EXTENSIONS                = 25;
  MAX_TYPEBUFFER                = 256;

  // MCI Device Type Constants
  MCI_DEVTYPE_VIDEOTAPE         = 1;
  MCI_DEVTYPE_VIDEODISC         = 2;
  MCI_DEVTYPE_CD_AUDIO          = 3;
  MCI_DEVTYPE_DAT               = 4;
  MCI_DEVTYPE_AUDIO_TAPE        = 5;
  MCI_DEVTYPE_OTHER             = 6;
  MCI_DEVTYPE_WAVEFORM_AUDIO    = 7;
  MCI_DEVTYPE_SEQUENCER         = 8;
  MCI_DEVTYPE_AUDIO_AMPMIX      = 9;
  MCI_DEVTYPE_OVERLAY           = 10;
  MCI_DEVTYPE_ANIMATION         = 11;
  MCI_DEVTYPE_DIGITAL_VIDEO     = 12;
  MCI_DEVTYPE_SPEAKER           = 13;
  MCI_DEVTYPE_HEADPHONE         = 14;
  MCI_DEVTYPE_MICROPHONE        = 15;
  MCI_DEVTYPE_MONITOR           = 16;
  MCI_DEVTYPE_CDXA              = 17;

  // MCI Device Type Names
  MCI_DEVTYPE_VIDEOTAPE_NAME    = 'Videotape';
  MCI_DEVTYPE_VIDEODISC_NAME    = 'Videodisc';
  MCI_DEVTYPE_CD_AUDIO_NAME     = 'CDaudio';
  MCI_DEVTYPE_DAT_NAME          = 'DAT';
  MCI_DEVTYPE_AUDIO_TAPE_NAME   = 'Audiotape';
  MCI_DEVTYPE_OTHER_NAME        = 'Other';
  MCI_DEVTYPE_WAVEFORM_AUDIO_NAME = 'Waveaudio';
  MCI_DEVTYPE_SEQUENCER_NAME    = 'Sequencer';
  MCI_DEVTYPE_AUDIO_AMPMIX_NAME = 'Ampmix';
  MCI_DEVTYPE_OVERLAY_NAME      = 'Overlay';
  MCI_DEVTYPE_ANIMATION_NAME    = 'Animation';
  MCI_DEVTYPE_DIGITAL_VIDEO_NAME= 'Digitalvideo';
  MCI_DEVTYPE_SPEAKER_NAME      = 'Speaker';
  MCI_DEVTYPE_HEADPHONE_NAME    = 'Headphone';
  MCI_DEVTYPE_MICROPHONE_NAME   = 'Microphone';
  MCI_DEVTYPE_MONITOR_NAME      = 'Monitor';
  MCI_DEVTYPE_CDXA_NAME         = 'CDXA';

  MCI_MAX_SYSTEM_DEVICE_NAMES   = 17;

  // GetDevCaps, set, and status item base values
  MCI_AMP_ITEM_BASE             = $1000;
  MCI_CD_ITEM_BASE              = $2000;
  MCI_CDXA_ITEM_BASE            = $3000;
  MCI_VD_ITEM_BASE              = $4000;
  MCI_SEQ_ITEM_BASE             = $5000;
  MCI_WAVE_ITEM_BASE            = $6000;
  MCI_VID_ITEM_BASE             = $7000;
  MCI_DGV_ITEM_BASE             = $8000;
  MCI_OVLY_ITEM_BASE            = $9000;

  // Flags for mciDriverNotify
  MCI_NOTIFY_SUCCESSFUL         = $0000;
  MCI_NOTIFY_SUPERSEDED         = $0001;
  MCI_NOTIFY_ABORTED            = $0002;
  MCI_NOTIFY_ERROR              = $0003;

  // mciDriverNotify Message Types
  MM_MCINOTIFY                  = $0500;
  MM_MCIPASSDEVICE              = $0501;
  MM_MCIPOSITIONCHANGE          = $0502;
  MM_MCICUEPOINT                = $0503;
  MM_MCIPLAYLISTMESSAGE         = $0504;
  MM_MCIEVENT                   = $0505;
  MM_MCISYNCH                   = $0506;

  MCI_LOSING_USE                = $00000001;
  MCI_GAINING_USE               = $00000002;

  // Common message flags. $00000$x are reserved for common flags.
  MCI_NOTIFY                    = $00000001;
  MCI_WAIT                      = $00000002;
  MCI_FROM                      = $00000004;
  MCI_TO                        = $00000008;
  MCI_MILLISECONDS              = $00000010;
  MCI_TRACK                     = $00000020;
  MCI_OVER                      = $00000040;
  MCI_TEST                      = $00000080;
  MCI_TO_BUFFER                 = $00000100;
  MCI_FROM_BUFFER               = $00000200;
  MCI_CONVERT_FORMAT            = $00000400;

  // Time formats
  MCI_FORMAT_MILLISECONDS       = $00000001;
  MCI_FORMAT_mmTime             = $00000002;
  MCI_FORMAT_MSF                = $00000005;
  MCI_FORMAT_TMSF               = $00000006;
  MCI_FORMAT_CHAPTERS           = $00000007;
  MCI_FORMAT_FRAMES             = $00000008;
  MCI_FORMAT_HMS                = $00000009;
  MCI_FORMAT_TRACKS             = $0000000A;
  MCI_FORMAT_BYTES              = $0000000B;
  MCI_FORMAT_SAMPLES            = $0000000C;
  MCI_FORMAT_HMSF               = $0000000D;
  MCI_FORMAT_SET_SMPTE_24       = $0000000E;
  MCI_FORMAT_SET_SMPTE_25       = $0000000F;
  MCI_FORMAT_SET_SMPTE_30       = $00000010;
  MCI_FORMAT_SET_SMPTE_30DROP   = $00000011;
  MCI_FORMAT_SET_SONGPTR        = $00000012;
  MCI_FORMAT_uSec               = $00000013;

  // Speed formats
  MCI_FORMAT_PERCENTAGE         = $00000003;
  MCI_FORMAT_FPS                = $00000004;

// Time format conversion macros
function mSecToMM(Value: Cardinal): mmTime; inline;
begin
  If Value > $FFFFFFFF div 3 then
    Result := 0
  else
    Result := Value div 3;
end;

function mSecFromMM(Value: mmTime): uLong; inline;
begin
  Result := (Value+1) div 3;
end;

function RedBookToMM(Value: Cardinal): mmTime; inline;
begin
  Result := ( Value and $0000FF ) * 60 * 3000 +
            ( Value and $00FF00 ) * $100 * 3000 +
            ( Value and $FF0000 ) * $10000 * 3000 div 75;

end;

function fps24ToMM(Value: Cardinal): mmTime; inline;
begin
  Result := ( Value and $000000FF ) * 60 * 60 * 3000 +
            ( Value and $0000FF00 ) * $100 * 60 * 3000 +
            ( Value and $00FF0000 ) * $10000 * 3000 +
            ( Value and $FF000000 ) * $10000 * 3000 div 24;
end;

function fps25ToMM(Value: Cardinal): mmTime; inline;
begin
  Result := ( Value and $000000FF ) * 60 * 60 * 3000 +
            ( Value and $0000FF00 ) * $100 * 60 * 3000 +
            ( Value and $00FF0000 ) * $10000 * 3000 +
            ( Value and $FF000000 ) * $10000 * 3000 div 25;
end;

function fps30ToMM(Value: Cardinal): mmTime; inline;
begin
  Result := ( Value and $000000FF ) * 60 * 60 * 3000 +
            ( Value and $0000FF00 ) * $100 * 60 * 3000 +
            ( Value and $00FF0000 ) * $10000 * 3000 +
            ( Value and $FF000000 ) * $10000 * 3000 div 30;
end;

function HMSToMM(Value: Cardinal): mmTime; inline;
begin
  Result := ( Value and $0000FF ) * 60 * 60 * 3000 +
            ( Value and $00FF00 ) * $100 * 60 * 3000 +
            ( Value and $FF0000 ) * $10000 * 3000;

end;

// The +20 is used for rounding purposes.  It is derived by:
// 1/2 * ((300 MMTIME/SEC / (75 FRAMES/SEC)) = 20 MMTIME/HALF-FRAME
function RedBookFromMM(Value: mmTime): Cardinal; inline;
begin
  if Value+20 >= $100*60*3000 then
    Result := 0
  else
    Result := (Value+20) div (60*3000) +
              ((Value+20) mod ((60*3000) div 3000)) shl 8 +
              ((Value+20) div ((3000 div 75) mod 75)) shl 16;
end;

function FPS24FromMM(Value: mmTime): Cardinal; inline;
begin
  if Value+63 >= $A4CB8000 then // $100*60*60*3000 then
    Result := 0
  else
    Result := ((((Value+63) mod 3000) div (3000 div 24)) shl 24) and $FF000000 +
              ((((Value+63) div 3000) mod 60) shl 16) and $00FF0000 +
              (((((Value+63) div 3000) div 60) mod 60) shl 8) and $0000FF00 +
              ((((Value+63) div 3000) div 60) div 60) and $000000FF;
end;

function FPS25FromMM(value: mmTime): Cardinal; inline;
begin
  if Value+60 >= $A4CB8000 then // $100*60*60*3000
    Result := 0
  else
    Result := ((((Value+60) mod 3000) div (3000 div 25)) shl 24) and $FF000000 +
              ((((Value+60) div 3000) mod 60) shl 16) and $00FF0000 +
              (((((Value+60) div 3000) div 60) mod 60) shl 8) and $0000FF00 +
              ((((Value+60) div 3000) div 60) div 60) and $000000FF;
end;

function FPS30FromMM(value: mmTime): Cardinal; inline;
begin
  if Value+50 >= $A4CB8000 then // $100*60*60*3000
    Result := 0
  else
    Result := ((((Value+50) mod 3000) div (3000 div 30)) shl 24) and $FF000000 +
              ((((Value+50) div 3000) mod 60) shl 16) and $00FF0000 +
              (((((Value+50) div 3000) div 60) mod 60) shl 8) and $0000FF00 +
              ((((Value+50) div 3000) div 60) div 60) and $000000FF;
end;

function HMSFromMM(value: mmTime): Cardinal; inline;
begin
  if Value+50 >= $A4CB8000 then // $100*60*60*3000
    Result := 0
  else
    Result := (((( Value+50) div 3000) mod 60) shl 16) and $00FF0000 +
              (((((Value+50) div 3000) div 60) mod 60) shl 8) and $0000FF00 +
              (((( Value+50) div 3000) div 60) div 60) and $000000FF;
end;

function tmsf_track(time: mmTime): Byte; inline;
begin
  Result := byte(time);
end;

function tmsf_minute(time: mmTime): Byte; inline;
begin
  Result := pbyte(pchar(@time)+1)^;
end;

function tmsf_second(time: mmTime): Byte; inline;
begin
  Result := pbyte(pchar(@time)+2)^;
end;

function tmsf_frame(time: mmTime): Byte; inline;
begin
  Result := pbyte(pchar(@time)+3)^;
end;

function msf_minute(time: mmTime): Byte; inline;
begin
  Result := byte(time);
end;

function msf_second(time: mmTime): Byte; inline;
begin
  Result := pbyte(pchar(@time)+1)^;
end;

function msf_frame(time: mmTime): Byte; inline;
begin
  Result := pbyte(pchar(@time)+2)^;
end;

// Byte access with dWord macros
function uLong_lwlb(var ul): Byte; inline;  // Low word low byte
begin
  Result := uLong(ul);
end;

function uLong_lwhb(var ul): Byte; inline;  // Low word high byte
begin
  Result := pbyte(pchar(@ul)+1)^;
end;

function uLong_hwlb(var ul): Byte; inline;  // High word low byte
begin
  Result := pbyte(pchar(@ul)+2)^;
end;
function uLong_hwhb(var ul): Byte; inline;  // High word high byte
begin
  Result := pbyte(pchar(@ul)+3)^;
end;

function uLong_lowd(var ul): SmallWord; inline;  // Low word
begin
  Result := pSmallWord(pchar(@ul))^;
end;

function uLong_hiwd(var ul): SmallWord; inline;  // High word
begin
  Result := pSmallWord(pchar(@ul)+Sizeof(SmallWord))^;
end;

// Parameters for default command messages with empty parameter lists
type
  mci_Generic_Parms = record
    hwndCallback : hwnd;
  end;
  pmci_Generic_Parms = ^mci_Generic_Parms;

const
  // Flags for the MCI_ACQUIREDEVICE message
  //     $0000$00 are reserved for MCI_ACQUIREDEVICE flags
  MCI_EXCLUSIVE                 = $00000100;
  MCI_EXCLUSIVE_INSTANCE        = $00000200;
  MCI_ACQUIRE_QUEUE             = $00000400;

  // flags for the MCI_CAPTURE message
  //   $000$X00 are reserved for MCI_CAPTURE flags
  //   MCI_CONVERT is used by MCI_GETIMAGEBUFFER, MCI_SETIMAGEBUFFER
  //                          MCI_CAPTURE, and MCI_RESTORE
  MCI_CAPTURE_RECT              = $00000100;
  MCI_CONVERT                   = $00001000;

type
  // Parameter structure for the MCI_CAPTURE message
  mci_Capture_Parms = record
    hwndCallback : hwnd;
    Rect         : RectL;
  end;
  pmci_Capture_Parms = ^mci_Capture_Parms;

const
  // Flags for MCI_CONNECTOR and MCI_CONNECTION messages
  MCI_ENABLE_CONNECTOR          = $00000100;
  MCI_DISABLE_CONNECTOR         = $00000200;
  MCI_QUERY_CONNECTOR_STATUS    = $00000400;
  MCI_CONNECTOR_TYPE            = $00000800;
  MCI_CONNECTOR_INDEX           = $00001000;
  MCI_TO_CONNECTOR_INDEX        = $00002000;
  MCI_TO_CONNECTOR_TYPE         = $00004000;
  MCI_QUERY_CONNECTION          = $00008000;
  MCI_MAKE_CONNECTION           = $00010000;
  MCI_BREAK_CONNECTION          = $00020000;
  MCI_ENUMERATE_CONNECTORS      = $00040000;
  MCI_QUERY_CONNECTOR_TYPE      = $00080000;
  MCI_QUERY_VALID_CONNECTION    = $00100000;
  MCI_CONNECTOR_ALIAS           = $00200000;

  // Connector types
  MCI_MIDI_STREAM_CONNECTOR     = $00000001;
  MCI_CD_STREAM_CONNECTOR       = $00000002;
  MCI_WAVE_STREAM_CONNECTOR     = $00000003;
  MCI_AMP_STREAM_CONNECTOR      = $00000004;
  MCI_XA_STREAM_CONNECTOR       = $00000005;
  MCI_HEADPHONES_CONNECTOR      = $00000006;
  MCI_SPEAKERS_CONNECTOR        = $00000007;
  MCI_MICROPHONE_CONNECTOR      = $00000008;
  MCI_LINE_IN_CONNECTOR         = $00000009;
  MCI_LINE_OUT_CONNECTOR        = $0000000a;
  MCI_VIDEO_IN_CONNECTOR        = $0000000b;
  MCI_VIDEO_OUT_CONNECTOR       = $0000000c;
  MCI_PHONE_SET_CONNECTOR       = $0000000d;
  MCI_PHONE_LINE_CONNECTOR      = $0000000e;
  MCI_AUDIO_IN_CONNECTOR        = $0000000f;
  MCI_AUDIO_OUT_CONNECTOR       = $00000010;
  MCI_UNIVERSAL_CONNECTOR       = $00000011;

type
  // Parameter structure for the MCI_CONNECTION message
  mci_Connection_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    ulConnectorType  : uLong;                  // Connector type
    ulConnectorIndex : uLong;                  // Connector index
    pszAlias         : pChar;                  // Connection device alias
    usToDeviceID     : uShort;                 // Connected to device ID
    usReserved0      : uShort;                 // Reserved field
    ulReserved1      : uLong;                  // Reserved field
    ulReserved2      : uLong;                  // Reserved field
  end;
  pmci_Connection_Parms = ^mci_Connection_Parms;

  // Parameter structure for the MCI_CONNECTOR message
  mci_Connector_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    ulReturn         : uLong;                  // Return information
    ulConnectorType  : uLong;                  // If specified, ulConnectorIndex is relative
                                               // to the specified connector type
    ulConnectorIndex : uLong;                  // Connector number
  end;
  pmci_Connector_Parms = ^mci_Connector_Parms;

  // Parameter structure for the MCI_CONNECTORINFO message
  mci_ConnectorInfo_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    ulReturn         : uLong;                  // Return information
    ulDeviceTypeID   : uLong;                  // MCI device type
    ulConnectorType  : uLong;                  // If specified, ulConnectorIndex is relative
                                               // to the specified connector type
    ulConnectorIndex : uLong;                  // Connector number
    ulToConnectorType: uLong;                  // Connector type to test if
                                               // MCI_QUERY_VALID_CONNECTION is specified
  end;
  pmci_ConnectorInfo_Parms = ^mci_ConnectorInfo_Parms;

const
  // Flags for the MCI_CUE message
  //  $0000$00 are reserved for MCI_CUE flags
  MCI_CUE_INPUT                 = $00000100;
  MCI_CUE_OUTPUT                = $00000200;
  // Additional flags for Wave Audio for MCI_CUE
  MCI_WAVE_INPUT                = $00001000;
  MCI_WAVE_OUTPUT               = $00002000;

type
  // Parameter structure for the MCI_DEFAULT_CONNECTION message
  mci_Default_Connection_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    pszDevice        : pChar;                  // Device name
    ulConnectorType  : uLong;                  // If specified, ulConnectorIndex is relative
                                               // to the specified connector type
    ulConnectorIndex : uLong;                  // Connector number
    pszToDevice      : pChar;                  // Return device name to which the connection exists
    ulToConnectorType: uLong;                  // Connector type
    ulToConnectorIndex:uLong;                  // Connector number
  end;
  pmci_Default_Connection_Parms = ^mci_Default_Connection_Parms;

  // Parameter structure for the MCI_DEVICESETTINGS message
  mci_DeviceSettings_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    hwndNotebook     : hwnd;                   // Hwhd to notebook window
    usDeviceType     : uShort;                 // Device type
    pszDeviceName    : pChar;                  // Device name
  end;
  pmci_DeviceSettings_Parms = ^mci_DeviceSettings_Parms;

  // Parameter structure for the MCI_CUT / COPY / DELETE / UNDO / etc.
  mci_Edit_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    ulStructLen      : uLong;                  // Length of the Structure
    ulFrom           : uLong;                  // Beginning Point of Range
    ulTo             : uLong;                  // ending point of range
    pBuff            : Pointer;                // user buffer
    ulBufLen         : uLong;                  // length of user buffer
    pHeader          : Pointer;                // header which describes the buffer
  end;
  pmci_Edit_Parms = ^mci_Edit_Parms;

const
  // flags and parameter structure for the MCI_ESCAPE message
  //     $0000$00 are reserved for MCI_ESCAPE flags
  mci_Escape_String             = $00000100;

type
  mci_Escape_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    pszCommand       : pChar;                  // Command to send to the device
  end;
  pmci_Escape_Parms = ^mci_Escape_Parms;

const
  // Flags for the MCI_FREEZE message
  //  $000$X00 are reserved for MCI_FREEZE flags
  MCI_OVLY_FREEZE_RECT          = $00000100;
  MCI_OVLY_FREEZE_RECT_OUTSIDE  = $00000200;

  // Flags for the MCI_GETDEVCAPS message
  //   $0$XXX00 are reserved for MCI_GETDEVCAPS flags
  MCI_GETDEVCAPS_MESSAGE        = $00000100;
  MCI_GETDEVCAPS_ITEM           = $00000200;
  MCI_GETDEVCAPS_EXTENDED       = $00000400;

  // General MCI_GETDEVCAPS item values
  MCI_GETDEVCAPS_CAN_EJECT                                                = $00000001;
  MCI_GETDEVCAPS_CAN_LOCKEJECT  = $00000002;
  MCI_GETDEVCAPS_CAN_PLAY       = $00000003;
  MCI_GETDEVCAPS_CAN_PROCESS_INTERNAL = $00000004;
  MCI_GETDEVCAPS_CAN_RECORD     = $00000005;
  MCI_GETDEVCAPS_CAN_RECORD_INSERT    = $00000006;
  MCI_GETDEVCAPS_CAN_SAVE       = $00000007;
  MCI_GETDEVCAPS_CAN_SETVOLUME  = $00000008;
  MCI_GETDEVCAPS_CAN_STREAM     = $00000009;
  MCI_GETDEVCAPS_DEVICE_TYPE    = $0000000A;
  MCI_GETDEVCAPS_HAS_AUDIO      = $0000000B;
  MCI_GETDEVCAPS_HAS_VIDEO      = $0000000C;
  MCI_GETDEVCAPS_PREROLL_TIME   = $0000000D;
  MCI_GETDEVCAPS_PREROLL_TYPE   = $0000000E;
  MCI_GETDEVCAPS_USES_FILES     = $0000000F;
  MCI_GETDEVCAPS_HAS_IMAGE      = $00000010;
  MCI_GETDEVCAPS_WAVE_FORMAT    = $00000011;

  // Return ID's for videodisc MCI_GETDEVCAPS
  MCI_VD_MEDIA_CLV=$00000001;
  MCI_VD_MEDIA_CAV=$00000002;
  MCI_VD_MEDIA_OTHER=$00000003;

  // MCI_GETDEVCAPS item values for video devices
  MCI_VID_GETDEVCAPS_CAN_STRETCH         = MCI_VID_ITEM_BASE;
  MCI_VID_GETDEVCAPS_CAN_DISTORT         = MCI_VID_ITEM_BASE+1;
  MCI_VID_GETDEVCAPS_VIDEO_X_EXTENT      = MCI_VID_ITEM_BASE+2;
  MCI_VID_GETDEVCAPS_VIDEO_Y_EXTENT      = MCI_VID_ITEM_BASE+3;
  MCI_VID_GETDEVCAPS_IMAGE_X_EXTENT      = MCI_VID_ITEM_BASE+4;
  MCI_VID_GETDEVCAPS_IMAGE_Y_EXTENT      = MCI_VID_ITEM_BASE+5;
  MCI_VID_GETDEVCAPS_MAX_WINDOWS         = MCI_VID_ITEM_BASE+6;
  MCI_VID_GETDEVCAPS_CAN_FREEZE          = MCI_VID_ITEM_BASE+7;
  MCI_VID_GETDEVCAPS_OVERLAY_GRAPHICS    = MCI_VID_ITEM_BASE+8;
  MCI_VID_GETDEVCAPS_CAN_REVERSE         = MCI_VID_ITEM_BASE+9;
  MCI_VID_GETDEVCAPS_FAST_RATE           = MCI_VID_ITEM_BASE+10;
  MCI_VID_GETDEVCAPS_SLOW_RATE           = MCI_VID_ITEM_BASE+11;
  MCI_VID_GETDEVCAPS_NORMAL_RATE         = MCI_VID_ITEM_BASE+12;
  MCI_VID_GETDEVCAPS_MINIMUM_RATE        = MCI_VID_ITEM_BASE+13;
  MCI_VID_GETDEVCAPS_MAXIMUM_RATE        = MCI_VID_ITEM_BASE+14;

  // MCI_GETDEVCAPS flag values for Videodisc
  MCI_VD_GETDEVCAPS_CLV                  = $00000400;
  MCI_VD_GETDEVCAPS_CAV                  = $00000800;

  // MCI_GETDEVCAPS item values for Videodisc
  MCI_VD_GETDEVCAPS_CAN_REVERSE          = MCI_VID_GETDEVCAPS_CAN_REVERSE;
  MCI_VD_GETDEVCAPS_FAST_RATE            = MCI_VID_GETDEVCAPS_FAST_RATE;
  MCI_VD_GETDEVCAPS_SLOW_RATE            = MCI_VID_GETDEVCAPS_SLOW_RATE;
  MCI_VD_GETDEVCAPS_NORMAL_RATE          = MCI_VID_GETDEVCAPS_NORMAL_RATE;
  MCI_VD_GETDEVCAPS_MINIMUM_RATE         = MCI_VID_GETDEVCAPS_MINIMUM_RATE;
  MCI_VD_GETDEVCAPS_MAXIMUM_RATE         = MCI_VID_GETDEVCAPS_MAXIMUM_RATE;

  // MCI_GETDEVCAPS item values for Digital Video
  MCI_DGV_GETDEVCAPS_CAN_REVERSE         = MCI_VID_GETDEVCAPS_CAN_REVERSE;
  MCI_DGV_GETDEVCAPS_CAN_STRETCH         = MCI_VID_GETDEVCAPS_CAN_STRETCH;
  MCI_DGV_GETDEVCAPS_CAN_DISTORT         = MCI_VID_GETDEVCAPS_CAN_DISTORT;
  MCI_DGV_GETDEVCAPS_FAST_RATE           = MCI_VID_GETDEVCAPS_FAST_RATE;
  MCI_DGV_GETDEVCAPS_SLOW_RATE           = MCI_VID_GETDEVCAPS_SLOW_RATE;
  MCI_DGV_GETDEVCAPS_NORMAL_RATE         = MCI_VID_GETDEVCAPS_NORMAL_RATE;
  MCI_DGV_GETDEVCAPS_MINIMUM_RATE        = MCI_VID_GETDEVCAPS_MINIMUM_RATE;
  MCI_DGV_GETDEVCAPS_MAXIMUM_RATE        = MCI_VID_GETDEVCAPS_MAXIMUM_RATE;
  MCI_DGV_GETDEVCAPS_VIDEO_X_EXTENT      = MCI_VID_GETDEVCAPS_VIDEO_X_EXTENT;
  MCI_DGV_GETDEVCAPS_VIDEO_Y_EXTENT      = MCI_VID_GETDEVCAPS_VIDEO_Y_EXTENT;
  MCI_DGV_GETDEVCAPS_IMAGE_X_EXTENT      = MCI_VID_GETDEVCAPS_IMAGE_X_EXTENT;
  MCI_DGV_GETDEVCAPS_IMAGE_Y_EXTENT      = MCI_VID_GETDEVCAPS_IMAGE_Y_EXTENT;
  MCI_DGV_GETDEVCAPS_MAX_WINDOWS         = MCI_VID_GETDEVCAPS_MAX_WINDOWS;
  MCI_DGV_GETDEVCAPS_OVERLAY_GRAPHICS    = MCI_VID_GETDEVCAPS_OVERLAY_GRAPHICS;
  MCI_DGV_GETDEVCAPS_HAS_TUNER           = MCI_DGV_ITEM_BASE;
  MCI_DGV_GETDEVCAPS_HAS_TELETEX         = MCI_DGV_ITEM_BASE+1;
  MCI_DGV_GETDEVCAPS_HAS_AFC             = MCI_DGV_ITEM_BASE+2;

  // MCI_GETDEVCAPS item values for Video Overlay
  MCI_OVLY_GETDEVCAPS_CAN_STRETCH        = MCI_VID_GETDEVCAPS_CAN_STRETCH;
  MCI_OVLY_GETDEVCAPS_CAN_DISTORT        = MCI_VID_GETDEVCAPS_CAN_DISTORT;
  MCI_OVLY_GETDEVCAPS_VIDEO_X_EXTENT     = MCI_VID_GETDEVCAPS_VIDEO_X_EXTENT;
  MCI_OVLY_GETDEVCAPS_VIDEO_Y_EXTENT     = MCI_VID_GETDEVCAPS_VIDEO_Y_EXTENT;
  MCI_OVLY_GETDEVCAPS_IMAGE_X_EXTENT     = MCI_VID_GETDEVCAPS_IMAGE_X_EXTENT;
  MCI_OVLY_GETDEVCAPS_IMAGE_Y_EXTENT     = MCI_VID_GETDEVCAPS_IMAGE_Y_EXTENT;
  MCI_OVLY_GETDEVCAPS_MAX_WINDOWS        = MCI_VID_GETDEVCAPS_MAX_WINDOWS;
  MCI_OVLY_GETDEVCAPS_CAN_FREEZE         = MCI_VID_GETDEVCAPS_CAN_FREEZE;
  MCI_OVLY_GETDEVCAPS_OVERLAY_GRAPHICS   = MCI_VID_GETDEVCAPS_OVERLAY_GRAPHICS;

  MCI_PREROLL_NOTIFIED                   = $00000001;
  MCI_PREROLL_DETERMINISTIC              = $00000002;
  MCI_PREROLL_NONE                       = $00000003;

type
  // Parameter structure for the MCI_GETDEVCAPS message
  mci_GetDevCaps_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    ulReturn         : uLong;                  // Return field
    ulItem           : uLong;                  // Item field for GETDEVCAPS item to query
    usMessage        : uShort;                 // Field to hold MCI message to query
    usReserved0      : uShort;                 // Reserved field
  end;
  pmci_GetDevCaps_Parms = ^mci_GetDevCaps_Parms;

  // Parameter structure for the MCI_WAVE_GETDEVCAPS
  mci_Wave_GetDevCaps_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    ulReturn         : uLong;                  // Return field
    ulItem           : uLong;                  // Item field for GETDEVCAPS item to query
    usMessage        : uShort;                 // Field to hold MCI message to query
    usReserved0      : uShort;                 // Reserved field
    ulLength         : uLong;                  // Length of structure in ULONGS
    ulBitsPerSample  : uLong;                  // Number of Bits per Sample
    ulFormatTag      : uLong;                  // Format Tag
    ulSamplesPerSec  : uLong;                  // Sampling Rate
    ulChannels       : uLong;                  // Number of channels
    ulFormatMode     : uLong;                  // Either MCI_RECORD or MCI_PLAY
  end;
  pmci_Wave_GetDevCaps_Parms = ^mci_Wave_GetDevCaps_Parms;

const
  // General MCI_SET item values
  MCI_SET_MONITOR                 = $00000001;
  MCI_SET_MONITOR_AUDIO           = $00000002;
  MCI_SET_MONITOR_VIDEO           = $00000003;
  MCI_SET_RECORD                  = $00000004;

  // MCI_SET flags for amp/mixer;
  MCI_AMP_SET_BALANCE             = $00100000;
  MCI_AMP_SET_PITCH               = $00200000;
  MCI_AMP_SET_TREBLE              = $00400000;
  MCI_AMP_SET_BASS                = $00800000;
  MCI_AMP_SET_GAIN                = $01000000;
  MCI_AMP_SET_ALC                 = $00000004;
  MCI_AMP_SET_AUDIO               = $00000008;
  MCI_AMP_SET_CROSSOVER           = $00000010;
  MCI_AMP_SET_LOUDNESS            = $00000020;
  MCI_AMP_SET_MUTE                = $00000040;
  MCI_AMP_SET_REVERB              = $00000080;
  MCI_AMP_SET_STEREOENHANCE       = $00000100;
  MCI_AMP_SET_CUSTOM1             = $00000200;
  MCI_AMP_SET_CUSTOM2             = $00000400;
  MCI_AMP_SET_CUSTOM3             = $00000800;
  MCI_AMP_SET_LRVOLUME            = $00001000;
  MCI_AMP_SET_MID                 = $00020000;
  MCI_AMP_SET_CHORUS              = $00004000;  // typo? 40000?
  MCI_AMP_SET_VOLUME              = $00080000;  // MCI_SET_VOLUME;
  MCI_AMP_SET_MONITOR             = MCI_SET_MONITOR_AUDIO;

  // Potential values for the ulValue field of MCI_AMP_GETDEVCAPS
  MCI_AMP_CAN_SET_MONITOR         = MCI_AMP_SET_MONITOR;
  MCI_AMP_CAN_SET_BALANCE         = MCI_AMP_SET_BALANCE;
  MCI_AMP_CAN_SET_ALC             = MCI_AMP_SET_ALC;
  MCI_AMP_CAN_SET_CROSSOVER       = MCI_AMP_SET_CROSSOVER;
  MCI_AMP_CAN_SET_LOUDNESS        = MCI_AMP_SET_LOUDNESS;
  MCI_AMP_CAN_SET_MUTE            = MCI_AMP_SET_MUTE;
  MCI_AMP_CAN_SET_REVERB          = MCI_AMP_SET_REVERB;
  MCI_AMP_CAN_SET_STEREOENHANCE   = MCI_AMP_SET_STEREOENHANCE;
  MCI_AMP_CAN_SET_CUSTOM1         = MCI_AMP_SET_CUSTOM1;
  MCI_AMP_CAN_SET_CUSTOM2         = MCI_AMP_SET_CUSTOM2;
  MCI_AMP_CAN_SET_CUSTOM3         = MCI_AMP_SET_CUSTOM3;
  MCI_AMP_CAN_SET_LRVOLUME        = MCI_AMP_SET_LRVOLUME;
  MCI_AMP_CAN_SET_BASS            = MCI_AMP_SET_BASS;
  MCI_AMP_CAN_SET_MID             = MCI_AMP_SET_MID;
  MCI_AMP_CAN_SET_TREBLE          = MCI_AMP_SET_TREBLE;
  MCI_AMP_CAN_SET_PITCH           = MCI_AMP_SET_PITCH;
  MCI_AMP_CAN_SET_GAIN            = MCI_AMP_SET_GAIN;
  MCI_AMP_CAN_SET_CHORUS          = MCI_AMP_SET_CHORUS;
  MCI_AMP_CAN_SET_VOLUME          = MCI_AMP_SET_VOLUME;

  // Potential values for the ulExtended field of MCI_AMP_GETDEVCAPS_PARMS
  MCI_MIXER_LINE                  = $00000001;

type
  // Parameter structure for the MCI_AMP_GETDEVCAPS
  mci_Amp_GetDevCaps_Parms = record
    hwndCallback  : uLong;                     // PM window handle for MCI notify message
    ulReturn      : uLong;                     // Return field
    ulItem        : uLong;                     // Item field for GETDEVCAPS item to query
    usMessage     : uShort;                    // Field to hold MCI message to query
    usReserved0   : uShort;                    // Reserved field
    ulLength      : uLong;                     // Length of structure in uLongS
    ulValue       : uLong;                     // Value to determine caps
    ulAttribute   : uLong;                     // Flags to modified the extended parms
    ulExtended    : uLong;                     // Extended flags field
  end;
  pmci_Amp_GetDevCaps_Parms = ^mci_Amp_GetDevCaps_Parms;

const
  // Values for the ulFlags field of MCI_MIXEVENT_PARMS
  MCI_MIX_ATTRIBUTE             = $00000001;
  MCI_MIX_CONNECTOR             = $00000002;

  // Values for the lParam field for mix_notify
  MCI_MIXNOTIFY_ON              = $00000004;
  MCI_MIXNOTIFY_OFF             = $00000008;

  // Value to indicate type of MM_MCIEVENT
  MCI_MIXEVENT                  = $00000001;

type
  // Parameter structure for the MCI_MIXEVENT_PARMS
  mci_MixEvent_Parms = record
    ulLength         : uLong;                  // Length of struct
    hwndMixer        : hwnd;                   // window to inform of mixer changes
    ulFlags          : uLong;                  // Either MCI_MIX_ATTRIBUTE
                                               //      or MCI_MIX_CONNECTOR
    usDeviceID       : uShort;                 // device id to notify of the change
    ulDeviceType     : uLong;                  // Device Type which generated the change
    ulDeviceOrdinal  : uLong;                  // Ordinal of device Type
    ulAttribute      : uLong;                  // Attribute that changed(volume, bass etc.)
    ulValue          : uLong;                  // new value of the attribute which changed
    ulConnectorType  : uLong;                  // Connector Type
    ulConnectorIndex : uLong;                  // Connector Index
    ulConnStatus     : uLong;                  // Is connector enabled/disabled.
  end;
  pmci_MixEvent_Parms = ^mci_MixEvent_Parms;

const
  // flag values for the MCI_GETIMAGEBUFFER and MCI_SETIMAGEBUFFER msg
  //   $000$X00 are reserved for MCI_GETIMAGEBUFFER and
  //     MCI_SETIMAGEBUFFER Flags
  //   MCI_CONVERT is defined by MCI_CAPTURE message as $00001000
  MCI_USE_HW_BUFFER             = $00000400;
  MCI_GET_HW_BUFFER_PTR         = $00000800;

type
  // parm structure for MCI_GETIMAGEBUFFER and
  //                    MCI_SETIMAGEBUFFER messages
  mci_Image_Parms = record
    hwndCallback       : hwnd;                 // PM window handle for MCI notify message
    ulPelFormat        : uLong;                // Format of the image data returned
    usBitCount         : uShort;               // Number of bitsimage data returned
    usReserved0        : uShort;               // Reserved field
    ulImageCompression : uLong;                //
    rect               : RectL;                // Image area to get/set
    pPelBuffer         : Pointer;              // Pel data buffer
    ulPelBufferHeight  : uLong;                // Number of rows in buffer
    ulPelBufferWidth   : uLong;                // Pels per row in buffer
    ulBufLen           : uLong;                // Pel data buffer length in bytes
  end;
  pmci_Image_Parms = ^mci_Image_Parms;

const
  // flags for the MCI_GETIMAGEPALETTE message
  //  $000$X00 are reserved for MCI_GETIMAGEPALETTE flags
  MCI_FIND_BEST_REGISTERED      = $00000100;
  MCI_QUERY_REGISTERED_MAP      = $00000200;
  MCI_QUERY_REGISTERED_MAP_SIZE = $00000400;

type
  // parameter structure for MCI_GETIMAGEPALETTE and
  //    MCI_SETIMAGEPALETTE messages
  mci_Palette_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    usRegisteredMap  : uShort;                 // Id of the palette from the registed color map
    usReserved0      : uShort;                 // Reserved field
    ulPalEntries     : uLong;                  // size of the palette returned
    pPalette         : Pointer;                // pointer to the palette
  end;
  pmci_Palette_Parms = ^mci_Palette_Parms;

  // Parameter structure for the MCI_GETTOC message
  mci_Toc_Rec = record
    TrackNum         : BYTE;                   // Returned Track Number
    ulStartAddr      : uLong;                  // Starting address of the track in MMTIME format
    ulEndAddr        : uLong;                  // Ending address of the track in MMTIME format
    Control          : BYTE;                   // Track Control information
    usCountry        : uShort;                 // Country
    ulOwner          : uLong;                  // Owner
    ulSerialNum      : uLong;                  // Serial Number
  end;
  pTocRec = ^mci_Toc_Rec;

  mci_Toc_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    pBuf             : pTocRec;                // Pointer to array MCI_TOC_REC structures to
                                               // be filled in by the mci device
    ulBufSize        : uLong;                  // Size of the array
  end;
  pmci_Toc_Parms = ^mci_Toc_Parms;

const
  // parameters for the MCI_GROUP message
  //     $0$XXX00 are reserved for MCI_GROUP flags
  MCI_SYNCHRONIZE               = $00000100;
  MCI_NOPIECEMEAL               = $00000200;
  MCI_GROUP_MAKE                = $00000400;
  MCI_GROUP_DELETE              = $00000800;
  MCI_GROUP_ALIAS               = $00001000;
  MCI_GROUP_MASTER              = $00002000;
  MCI_GROUP_NONE                = $00004000;   // No group!

type
  mci_Group_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message.
    usGroupID                   : uShort;      // GroupID
    usReserved0                 : uShort;      // RESERVED
    ulStructLength              : uLong;       // Length of Structure in ULONGS.
    usMasterID                  : uShort;      // ID of Master device in Synchrounous groups.
    usReserved1                 : uShort;      // RESERVED
    pszGroupAlias               : pChar;       // Pointer to Alias Name.
    ulNumDevices                : uLong;       // Number of Devices in group.
    paulDeviceID                : PuLong;      // Array of Device ids in the group.
  end;
  pmci_Group_Parms = ^mci_Group_Parms;

const
  // flags for the MCI_INFO message
  //     $0000$00 are reserved for MCI_INFO flags
  MCI_INFO_PRODUCT              = $00000100;
  MCI_INFO_FILE                 = $00000200;

  // CD Audio                MCI_INFO
  MCI_CD_INFO_ID                = $00010000;
  MCI_CD_INFO_UPC               = $00020000;

  // Videodisc               MCI_INFO
  MCI_VD_INFO_LABEL             = $00001000;

  // Digital Video           MCI_INFO
  MCI_DGV_INFO_VIDEO_FILE       = $00001000;
  MCI_DGV_INFO_IMAGE_FILE       = $00002000;
  MCI_DGV_INFO_REGION           = $00004000;
  MCI_DGV_INFO_REGION_TEXT      = $00008000;
  MCI_DGV_INFO_TEXT             = $00010000;

  // Video Overlay           MCI_INFO
  MCI_OVLY_INFO_TEXT            = $00010000;

type
  mci_Info_Parms = record
    hwndCallback      : hwnd;                  // PM window handle for MCI notify message
    pszReturn         : pChar;                 // Pointer to return buffer
    ulRetSize         : uLong;                 // Return buffer size
  end;
  pmci_Info_Parms = ^mci_Info_Parms;

  // Parameters and flags for the MCI_LOAD message
  //     $0000$00 are reserved for MCI_LOAD flags
  mci_Load_Parms = record
    hwndCallback      : hwnd;                  // PM window handle for MCI notify message
    pszElementName    : pChar;                 // File name to loads
  end;
  pmci_Load_Parms = ^mci_Load_Parms;

const
  // Parameters and flags for the MCI_MASTERAUDIO
  //     $00$XX00 are reserved for MCI_MASTERAUDIO flags
  MCI_ON                        = $00000100;
  MCI_OFF                       = $00000200;
  MCI_HEADPHONES                = $00000400;
  MCI_SPEAKERS                  = $00000800;
  MCI_MASTERVOL                 = $00001000;
  MCI_SAVESETTING               = $00002000;
  MCI_QUERYSAVEDSETTING         = $00004000;
  MCI_QUERYCURRENTSETTING       = $00008000;

type
  mci_MasterAudio_Parms = record
    hwndDummyCallback : hwnd;                  // Notify not allowed for this message
    ulReturn          : uLong;                 // Return field for query information
    ulMasterVolume    : uLong;                 // Master volume field
  end;
  pmci_MasterAudio_Parms = ^mci_MasterAudio_Parms;

const
  // Parameters and flags for the MCI_OPEN message
  //     $000$X00 are reserved for MCI_OPEN flags
  MCI_OPEN_ELEMENT              = $00000100;
  MCI_OPEN_ALIAS                = $00000200;
  MCI_OPEN_ELEMENT_ID           = $00000400;
  MCI_OPEN_PLAYLIST             = $00000800;
  MCI_OPEN_TYPE_ID              = $00001000;
  MCI_OPEN_SHAREABLE            = $00002000;
  MCI_OPEN_MMIO                 = $00004000;
  MCI_READONLY                  = $00008000;

  // Parameters and flags for the MCI_OPEN message
  // Digital Video, Video Overlay specific
  MCI_VID_OPEN_PARENT           = $01000000;
  MCI_DGV_OPEN_PARENT           = MCI_VID_OPEN_PARENT;
  MCI_OVLY_OPEN_PARENT          = MCI_VID_OPEN_PARENT;

type
  mci_Open_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    usDeviceID       : uShort;                 // Device ID returned to user
    usReserved0      : uShort;                 // Reserved
    pszDeviceType    : pChar;                  // Device name from SYSTEM.INI
    pszElementName   : pChar;                  // Typically a file name or NULL
    pszAlias         : pChar;                  // Optional device alias
  end;
  pmci_Open_Parms = ^mci_Open_Parms;

  // Parameters for the AMP MCI_OPEN message
  mci_Amp_Open_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    usDeviceID       : uShort;                 // Device ID returned to user
    usReserved0      : uShort;                 // Reserved field
    pszDeviceType    : pChar;                  // Device name from SYSTEM.INI
    pszElementName   : pChar;                  // Typically a file name or NULL
    pszAlias         : pChar;                  // Optional device alias
    pDevDataPtr      : Pointer;                // Pointer to device data
  end;
  pmci_Amp_Open_Parms = ^mci_Amp_Open_Parms;

  // Parameters for MCI_OPEN message for video devices
  mci_Vid_Open_Parms = record
    hwndCallback     : hwnd;                   // PM window handle for MCI notify message
    usDeviceID       : uShort;                 // Device ID returned to user
    usReserved0      : uShort;                 // Reserved field
    pszDeviceType    : pChar;                  // Device name from SYSTEM.INI
    pszElementName   : pChar;                  // Typically a file name or NULL
    pszAlias         : pChar;                  // Optional device alias
    hwndParent       : hwnd;                   // Parent window handle
  end;
  pmci_Vid_Open_Parms = ^mci_Vid_Open_Parms;

  mci_dgv_Open_Parms   = mci_Vid_Open_Parms;
  pmci_dgv_Open_Parms  = ^mci_dgv_Open_Parms;

  mci_Ovly_Open_Parms  = mci_Vid_Open_Parms;
  pmci_Ovly_Open_Parms = ^mci_Ovly_Open_Parms;

const
  // MCI_PLAY flag values for videodisc
  MCI_VD_PLAY_REVERSE           = $00001000;
  MCI_VD_PLAY_FAST              = $00002000;
  MCI_VD_PLAY_SPEED             = $00004000;
  MCI_VD_PLAY_SCAN              = $00008000;
  MCI_VD_PLAY_SLOW              = $00010000;

  // MCI_PLAY flag values for digital video
  MCI_DGV_PLAY_REVERSE          = $00001000;
  MCI_DGV_PLAY_FAST             = $00002000;
  MCI_DGV_PLAY_SPEED            = $00004000;
  MCI_DGV_PLAY_SCAN             = $00008000;
  MCI_DGV_PLAY_SLOW             = $00010000;
  MCI_DGV_PLAY_REPEAT           = $00020000;

type
  mci_Play_Parms = record
    hwndCallback      : hwnd;
    ulFrom            : uLong;
    ulTo              : uLong;
  end;
  pmci_Play_Parms = ^mci_Play_Parms;

  mci_VD_Play_Parms = record
    hwndCallback      : hwnd;
    ulFrom            : uLong;
    ulTo              : uLong;
    ulFactor          : uLong;
  end;
  pmci_VD_Play_Parms = ^mci_VD_Play_Parms;

  mci_DGV_play_Parms = record
    hwndCallback      : hwnd;
    ulFrom            : uLong;
    ulTo              : uLong;
    ulSpeed           : uLong;
  end;
  pmci_DGV_play_Parms = ^mci_DGV_play_Parms;

const
  // Parameters for the MCI_PUT  message
  //     $0000$00 are reserved for MCI_PUT  flags
  MCI_VID_PUT_RECT              = $00000100;
  MCI_VID_PUT_DESTINATION       = $00000200;
  MCI_VID_PUT_SOURCE            = $00000400;
  MCI_VID_PUT_WINDOW_MOVE       = $00000800;
  MCI_VID_PUT_WINDOW_SIZE       = $00001000;

  MCI_DGV_PUT_RECT              = MCI_VID_PUT_RECT;
  MCI_DGV_PUT_DESTINATION       = MCI_VID_PUT_DESTINATION;
  MCI_DGV_PUT_SOURCE            = MCI_VID_PUT_SOURCE;
  MCI_DGV_PUT_WINDOW_MOVE       = MCI_VID_PUT_WINDOW_MOVE;
  MCI_DGV_PUT_WINDOW_SIZE       = MCI_VID_PUT_WINDOW_SIZE;
  MCI_DGV_MONITOR               = $00010000;
  MCI_DGV_RECORD                = $00020000;

  MCI_OVLY_PUT_RECT             = MCI_VID_PUT_RECT;
  MCI_OVLY_PUT_DESTINATION      = MCI_VID_PUT_DESTINATION;
  MCI_OVLY_PUT_SOURCE           = MCI_VID_PUT_SOURCE;
  MCI_OVLY_PUT_WINDOW_MOVE      = MCI_VID_PUT_WINDOW_MOVE;
  MCI_OVLY_PUT_WINDOW_SIZE      = MCI_VID_PUT_WINDOW_SIZE;

type
  // Rectangle parameters for MCI_PUT, MCI_WHERE,
  // MCI_FREEZE, and MCI_UNFREEZE
  mci_Vid_Rect_Parms = record
    hwndCallback      : hwnd;                  // PM window handle for MCI notify message
    rc                : RectL;                 // rectangle array specifying the offset
                                               // and size of a rectangle
  end;

  mci_Dgv_Rect_Parms            = mci_Vid_Rect_Parms;
  pmci_Dgv_Rect_Parms           = ^mci_Dgv_Rect_Parms;

  mci_Ovly_Rect_Parms           = mci_Vid_Rect_Parms;
  pmci_Ovly_Rect_Parms          = ^mci_Ovly_Rect_Parms;

const
  // Parameters for the MCI_RECORD message
  //    $0000$00 are reserved for MCI_RECORD flags
  MCI_RECORD_INSERT             = $00000100;
  MCI_RECORD_OVERWRITE          = $00000200;

  MCI_DGV_RECORD_RECT           = $00000400;

type
  mci_Record_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulFrom                      : uLong;       // Record from position
    ulTo                        : uLong;       // Record to position
  end;
  pmci_Record_Parms = ^mci_Record_Parms;

const
  // Parameters for the MCI_RELEASEDEVICE message
  //     $XXXXXX00 are reserved for MCI_RELEASEDEVICE message
  MCI_RETURN_RESOURCE           = $00000100;

  // parameters for the MCI_RESTORE message
  //     $000$X00 are reserved for MCI_RESTORE flags
  //     MCI_CONVERT is defined by MCI_CAPTURE message as $00001000
  MCI_RESTORE_SRC_RECT          = $00000100;
  MCI_RESTORE_DEST_RECT         = $00000200;

type
  mci_Restore_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    SrcRect                     : RectL;       // Rectangle array specifying the source
                                               // area to be restored
    RestRect                    : RectL;       // Rectangle array specifying the destination
                                               // area to be restored
  end;
  pmci_Restore_Parms = ^mci_Restore_Parms;

const
  //  parameters for the MCI_SAVE  message
  //      $0000$00 are reserved for MCI_SAVE flags
  MCI_SAVE_FILE                 = $00000100;

  // Digital Video               MCI_SAVE
  MCI_DGV_SAVE_VIDEO_FILE       = $00001000;
  MCI_DGV_SAVE_IMAGE_FILE       = $00002000;

type
  mci_Save_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    pszFileName                 : pChar;       // Filename to save data to
  end;
  pmci_Save_Parms = ^mci_Save_Parms;

const
  // parameters for the MCI_SEEK message
  //     $0000$00 are reserved for MCI_SEEK flags
  MCI_TO_START                  = $00000100;
  MCI_TO_END                    = $00000200;

  // Digital Video               MCI_SEEK

  MCI_DGV_SEEK_TO_NEAREST_IFRAME = $00100000;

  // Videodisc                   MCI_SEEK
  MCI_VD_SEEK_REVERSE           = $00001000;

type
  mci_Seek_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulTo                        : uLong;       // Seek to this position
  end;
  pmci_Seek_Parms = ^mci_Seek_Parms;

const
  // Flags for the MCI_SET message
  //     $0$XXX00 are reserved for MCI_SET flags
  MCI_SET_ITEM                  = $00000100;
  MCI_SET_ON                    = $00000200;
  MCI_SET_OFF                   = $00000400;
  MCI_SET_VIDEO                 = $00000800;
  MCI_SET_AUDIO                 = $00001000;
  MCI_SET_DOOR_OPEN             = $00002000;
  MCI_SET_DOOR_CLOSED           = $00004000;
  MCI_SET_SPEED_FORMAT          = $00008000;
  MCI_SET_TIME_FORMAT           = $00010000;
  MCI_SET_DOOR_LOCK             = $00020000;
  MCI_SET_DOOR_UNLOCK           = $00040000;
  MCI_SET_VOLUME                = $00080000;
  MCI_SET_ITEM_FOURCC           = $00100000;
  MCI_SET_REVERSE               = $00200000;

  // Values for the ulAudio field
  MCI_SET_AUDIO_ALL             = $00000000;
  MCI_SET_AUDIO_LEFT            = $00000001;
  MCI_SET_AUDIO_RIGHT           = $00000002;

  // MCI_SET flags for CDXA
  MCI_CDXA_SET_CHANNEL          = $01000000;
  MCI_CDXA_AUDIO_DEVICE         = $10000000;
  MCI_CDXA_AUDIO_BUFFER         = $02000000;
  MCI_CDXA_VIDEO_BUFFER         = $04000000;
  MCI_CDXA_DATA_BUFFER          = $08000000;

  // MCI_SET flags for videodisc
  MCI_VD_SET_ON                 = MCI_SET_ON;
  MCI_VD_SET_OFF                = MCI_SET_OFF;
  MCI_VD_SET_VIDEO              = MCI_SET_VIDEO;
  MCI_VD_SET_CHANNEL            = $00100000;
  MCI_VD_SET_DISPLAY            = $00200000;
  MCI_VD_SET_DONTCARE           = $00400000;   // Dont care!

  // Generic MCI_SET item values for video devices
  MCI_VID_SET_VIDEO_COMPRESSION = MCI_VID_ITEM_BASE;
  MCI_VID_SET_IMAGE_COMPRESSION = MCI_VID_ITEM_BASE+1;
  MCI_VID_SET_IMAGE_BITSPERPEL  = MCI_VID_ITEM_BASE+2;
  MCI_VID_SET_IMAGE_PELFORMAT   = MCI_VID_ITEM_BASE+3;
  MCI_VID_SET_BRIGHTNESS        = MCI_VID_ITEM_BASE+4;
  MCI_VID_SET_CONTRAST          = MCI_VID_ITEM_BASE+5;
  MCI_VID_SET_HUE               = MCI_VID_ITEM_BASE+6;
  MCI_VID_SET_SATURATION        = MCI_VID_ITEM_BASE+7;
  MCI_VID_SET_SHARPNESS         = MCI_VID_ITEM_BASE+8;
  MCI_VID_SET_GREYSCALE         = MCI_VID_ITEM_BASE+9;
  MCI_VID_SET_IMAGE_QUALITY     = MCI_VID_ITEM_BASE+10;
  MCI_VID_SET_VIDEO_QUALITY     = MCI_VID_ITEM_BASE+11;
  MCI_VID_SET_IMAGE_COMPRESSION_METHOD = MCI_VID_ITEM_BASE+12;
  MCI_VID_SET_MINIMUM_VIDEO_REFRESH_RATE = MCI_VID_ITEM_BASE+13;
  MCI_VID_SET_IMAGE_FILE_FORMAT = MCI_VID_ITEM_BASE+14;
  MCI_VID_SET_REF_INTERVAL      = MCI_VID_ITEM_BASE+15;
  MCI_VID_SET_MAXDATARATE       = MCI_VID_ITEM_BASE+16;
  MCI_VID_SET_VIDEO_FILE_FORMAT = MCI_VID_ITEM_BASE+17;

  // MCI_SET item values for video overlay
  MCI_OVLY_SET_IMAGE_COMPRESSION = MCI_VID_SET_IMAGE_COMPRESSION;
  MCI_OVLY_SET_IMAGE_BITSPERPEL = MCI_VID_SET_IMAGE_BITSPERPEL;
  MCI_OVLY_SET_IMAGE_PELFORMAT  = MCI_VID_SET_IMAGE_PELFORMAT;
  MCI_OVLY_SET_BRIGHTNESS       = MCI_VID_SET_BRIGHTNESS;
  MCI_OVLY_SET_CONTRAST         = MCI_VID_SET_CONTRAST;
  MCI_OVLY_SET_HUE              = MCI_VID_SET_HUE;
  MCI_OVLY_SET_SATURATION       = MCI_VID_SET_SATURATION;
  MCI_OVLY_SET_SHARPNESS        = MCI_VID_SET_SHARPNESS;
  MCI_OVLY_SET_GREYSCALE        = MCI_VID_SET_GREYSCALE;
  MCI_OVLY_SET_IMAGE_QUALITY    = MCI_VID_SET_IMAGE_QUALITY;
  MCI_OVLY_SET_IMAGE_COMPRESSION_METHOD = MCI_VID_SET_IMAGE_COMPRESSION_METHOD;
  MCI_OVLY_SET_MINIMUM_VIDEO_REFRESH_RATE = MCI_VID_SET_MINIMUM_VIDEO_REFRESH_RATE;
  MCI_OVLY_SET_IMAGE_FILE_FORMAT = MCI_VID_SET_IMAGE_FILE_FORMAT;

  // MCI_SET item values for digital video
  MCI_DGV_SET_VIDEO_COMPRESSION = MCI_VID_SET_VIDEO_COMPRESSION;
  MCI_DGV_SET_IMAGE_COMPRESSION = MCI_VID_SET_IMAGE_COMPRESSION;
  MCI_DGV_SET_IMAGE_BITSPERPEL  = MCI_VID_SET_IMAGE_BITSPERPEL;
  MCI_DGV_SET_IMAGE_PELFORMAT   = MCI_VID_SET_IMAGE_PELFORMAT;
  MCI_DGV_SET_BRIGHTNESS        = MCI_VID_SET_BRIGHTNESS;
  MCI_DGV_SET_CONTRAST          = MCI_VID_SET_CONTRAST;
  MCI_DGV_SET_HUE               = MCI_VID_SET_HUE;
  MCI_DGV_SET_SATURATION        = MCI_VID_SET_SATURATION;
  MCI_DGV_SET_SHARPNESS         = MCI_VID_SET_SHARPNESS;
  MCI_DGV_SET_GREYSCALE         = MCI_VID_SET_GREYSCALE;
  MCI_DGV_SET_IMAGE_QUALITY     = MCI_VID_SET_IMAGE_QUALITY;
  MCI_DGV_SET_VIDEO_QUALITY     = MCI_VID_SET_VIDEO_QUALITY;
  MCI_DGV_SET_IMAGE_COMPRESSION_METHOD = MCI_VID_SET_IMAGE_COMPRESSION_METHOD;
  MCI_DGV_SET_MONITOR           = MCI_SET_MONITOR;
  MCI_DGV_SET_MINIMUM_VIDEO_REFRESH_RATE = MCI_VID_SET_MINIMUM_VIDEO_REFRESH_RATE;
  MCI_DGV_SET_IMAGE_FILE_FORMAT = MCI_VID_SET_IMAGE_FILE_FORMAT;
  MCI_DGV_SET_REF_INTERVAL      = MCI_VID_SET_REF_INTERVAL;
  MCI_DGV_SET_MAXDATARATE       = MCI_VID_SET_MAXDATARATE;
  MCI_DGV_SET_VIDEO_FILE_FORMAT = MCI_VID_SET_VIDEO_FILE_FORMAT;

  MCI_DGV_SET_AUDIO_COMPRESSION = MCI_DGV_ITEM_BASE;
  MCI_DGV_SET_AUDIO_QUALITY     = MCI_DGV_ITEM_BASE+1;
  MCI_DGV_SET_CHANNELS          = MCI_DGV_ITEM_BASE+2;
  MCI_DGV_SET_BITSPERSAMPLE     = MCI_DGV_ITEM_BASE+3;
  MCI_DGV_SET_SAMPLESPERSEC     = MCI_DGV_ITEM_BASE+4;
  MCI_DGV_SET_FORMATTAG         = MCI_DGV_ITEM_BASE+5;
  MCI_DGV_SET_BLOCKALIGN        = MCI_DGV_ITEM_BASE+6;
  MCI_DGV_SET_AVGBYTESPERSEC    = MCI_DGV_ITEM_BASE+7;

  MCI_DGV_SET_VIDEO_COMPRESSION_SUBTYPE = MCI_DGV_ITEM_BASE+8;
  MCI_DGV_SET_VIDEO_RECORD_RATE = MCI_DGV_ITEM_BASE+9;
  MCI_DGV_SET_VIDEO_RECORD_FRAME_DURATION = MCI_DGV_ITEM_BASE+10;
  MCI_DGV_SET_RECORD_AUDIO      = MCI_DGV_ITEM_BASE+11;
  MCI_DGV_SET_TRANSPARENT_COLOR = MCI_DGV_ITEM_BASE+12;
  MCI_DGV_SET_GRAPHIC_TRANSPARENT_COLOR = MCI_DGV_ITEM_BASE+12;
  MCI_DGV_SET_AUDIOSYNC         = MCI_DGV_ITEM_BASE+13;
  MCI_DGV_SET_VIDEO_TRANSPARENT_COLOR = MCI_DGV_ITEM_BASE+14;

  // Video file format
  MCI_VID_FILE_FORMAT_AVI       = $20495641;

  // Audio/video/image compression types
  MCI_AUD_COMP_ADPCM4           = $00000001;
  MCI_AUD_COMP_PCM8             = $00000002;

  MCI_VID_COMP_RTV_2_0          = $00000101;
  MCI_VID_COMP_RTV_2_1          = $00000102;
  MCI_VID_COMP_ULTI             = $49544C55;
  MCI_VID_COMP_RT21             = $31325452;
  MCI_VID_COMP_NONE             = $20424944;   // This is 'DIB ' now.

  MCI_IMG_COMP_NONE             = $00000201;
  MCI_IMG_COMP_PIC9_1_0         = $00000202;
  MCI_IMG_COMP_PIC16_1_0        = $00000203;
  MCI_IMG_COMP_JPEG9            = $00000204;
  MCI_IMG_COMP_JPEG9_1_0        = MCI_IMG_COMP_JPEG9;
  MCI_IMG_COMP_BMP_RLE4         = $00000205;
  MCI_IMG_COMP_BMP_RLE8         = $00000206;
  MCI_IMG_COMP_JPEGN            = $00000207;

  // PEL Formats (video/image)
  MCI_VID_PALETTE               = $00000001;
  MCI_VID_RGB                   = $00000002;
  MCI_VID_YUV                   = $00000003;

  MCI_IMG_PALETTE               = MCI_VID_PALETTE;
  MCI_IMG_RGB                   = MCI_VID_RGB;
  MCI_IMG_YUV                   = MCI_VID_YUV;

  // Audio/video/image quality levels
  MCI_AUD_QUALITY_HIGH          = $00000001;
  MCI_AUD_QUALITY_MED           = $00000002;
  MCI_AUD_QUALITY_LOW           = $00000003;

  MCI_VID_QUALITY_HIGH          = $00000101;
  MCI_VID_QUALITY_MED           = $00000102;
  MCI_VID_QUALITY_LOW           = $00000103;
  MCI_VID_QUALITY_BEST          = MCI_VID_QUALITY_HIGH;
  MCI_VID_QUALITY_CDROM         = MCI_VID_QUALITY_MED;
  MCI_VID_QUALITY_COMPACT       = MCI_VID_QUALITY_LOW;
  MCI_VID_QUALITY_BETTER        = MCI_VID_QUALITY_MED;
  MCI_VID_QUALITY_GOOD          = MCI_VID_QUALITY_LOW;

  MCI_IMG_QUALITY_HIGH          = $00000201;
  MCI_IMG_QUALITY_MED           = $00000202;
  MCI_IMG_QUALITY_LOW           = $00000203;

  // MCI_SET flags for wave audio
  MCI_WAVE_SET_SAMPLESPERSEC    = $01000000;
  MCI_WAVE_SET_AVGBYTESPERSEC   = $02000000;
  MCI_WAVE_SET_BLOCKALIGN       = $04000000;
  MCI_WAVE_SET_FORMATTAG        = $08000000;
  MCI_WAVE_SET_CHANNELS         = $10000000;
  MCI_WAVE_SET_BITSPERSAMPLE    = $80000000;

  // Wave format tag defines
  MCI_WAVE_FORMAT_PCM           = DATATYPE_WAVEFORM;
  MCI_WAVE_FORMAT_ADPCM         = $0002;
  MCI_WAVE_FORMAT_IBM_CVSD      = $0005;
  MCI_WAVE_FORMAT_ALAW          = DATATYPE_RIFF_ALAW;
  MCI_WAVE_FORMAT_MULAW         = DATATYPE_RIFF_MULAW;
  MCI_WAVE_FORMAT_OKI_ADPCM     = $0010;
  MCI_WAVE_FORMAT_DVI_ADPCM     = $0011;
  MCI_WAVE_FORMAT_DIGISTD       = $0015;
  MCI_WAVE_FORMAT_DIGIFIX       = $0016;
  MCI_WAVE_FORMAT_AVC_ADPCM     = DATATYPE_ADPCM_AVC;
  MCI_WAVE_FORMAT_IBM_ADPCM     = DATATYPE_ADPCM_AVC;
  MCI_WAVE_FORMAT_IBM_MULAW     = DATATYPE_MULAW;
  MCI_WAVE_FORMAT_IBM_ALAW      = DATATYPE_ALAW;
  MCI_WAVE_FORMAT_CT_ADPCM      = DATATYPE_CT_ADPCM;
  MCI_WAVE_FORMAT_MPEG1         = DATATYPE_MPEG1AUDIO;

  // MCI_SET flags for sequencer
  MCI_SEQ_SET_TEMPO             = $00100000;
  MCI_SEQ_SET_PORT              = $00200000;
  MCI_SEQ_ENABLE_PORT_MAPPER    = $00400000;
  MCI_SEQ_DISABLE_PORT_MAPPER   = $00800000;
  MCI_SEQ_SET_OFFSET            = $01000000;
  MCI_SEQ_SET_MASTER            = $02000000;
  MCI_SEQ_SET_SLAVE             = $04000000;

  // SEQ time formats
  MCI_SEQ_SET_SMPTE_24          = $00000100;
  MCI_SEQ_SET_SMPTE_25          = $00000200;
  MCI_SEQ_SET_SMPTE_30          = $00000300;
  MCI_SEQ_SET_SMPTE_30DROP      = $00000400;
  MCI_SEQ_SET_SONGPTR           = $00000500;

  // SEQ synchronization types
  MCI_SEQ_MIDI                  = $00000001;
  MCI_SEQ_SMPTE                 = $00000002;
  MCI_SEQ_FILE                  = $00000003;
  MCI_SEQ_NONE                  = $00000004;

  // SEQ PORT TYPES
  MCI_SET_NONE                  = $10000000;
  MIDI_MAPPER                   = $20000000;
  MCI_MIDI_MAPPER               = MIDI_MAPPER;

type
  mci_Set_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulTimeFormat                : uLong;       // Time format to be used by the device
    ulSpeedFormat               : uLong;       // Speed format used by this device
    ulAudio                     : uLong;       // Channel number for this operation
                                               // (MCI_SET_AUDIO_LEFT, MCI_SET_AUDIO_RIGHT,
                                               //  MCI_SET_AUDIO_ALL)
    ulLevel                     : uLong;       // Volume, treble or bass level as % of max.
    ulOver                      : uLong;       // Delay time for vectored change in millisecond
    ulItem                      : uLong;       // Item field for set item flags
    ulValue                     : uLong;       // Value associated with item flag
  end;
  pmci_Set_Parms = ^mci_Set_Parms;

  mci_Amp_Set_Parms            = mci_Set_Parms;
  pmci_Amp_Set_Parms           = ^mci_Amp_Set_Parms;

  mci_DGV_Set_Parms            = mci_Set_Parms;
  pmci_DGV_Set_Parms           = ^mci_DGV_Set_Parms;

  mci_Ovly_Set_Parms           = mci_Set_Parms;
  pmci_Ovly_Set_Parms          = ^mci_Ovly_Set_Parms;

  mci_CDXA_Set_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulTimeFormat                : uLong;       // Time format to be used by the device
    ulSpeedFormat               : uLong;       // Speed format used by this device
    ulAudio                     : uLong;       // Channel number for this operation
                                               // (MCI_SET_AUDIO_LEFT, MCI_SET_AUDIO_RIGHT,
                                               //  MCI_SET_AUDIO_ALL)
    ulLevel                     : uLong;       // Volume, treble or bass level as % of max.
    ulOver                      : uLong;       // Delay time for vectored change in milliseconds
    ulItem                      : uLong;       // Item field for set item flags
    ulValue                     : uLong;       // Value associated with item flag
    ulChannel                   : uLong;       // Channel number
    pPlayList                   : Pointer;     // Pointer to play list
    ulPlayListSize              : uLong;       // Play list size
  end;
  pmci_CDXA_Set_Parms = ^mci_CDXA_Set_Parms;

  mci_VD_Set_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulTimeFormat                : uLong;       // Time format to be used by the device
    ulSpeedFormat               : uLong;       // Speed format used by this device
    ulAudio                     : uLong;       // Channel number for this operation
                                               // (MCI_SET_AUDIO_LEFT, MCI_SET_AUDIO_RIGHT,
                                               //  MCI_SET_AUDIO_ALL)
    ulLevel                     : uLong;       // Volume, treble or bass level as % of max.
    ulOver                      : uLong;       // Delay time for vectored change in milliseconds
    ulItem                      : uLong;       // Item field for set item flags
    ulValue                     : uLong;       // Value associated with item flag
    ulChannel                   : uLong;       // Videodisc channel
  end;
  pmci_VD_Set_Parms = ^mci_VD_Set_Parms;

  mci_Wave_Set_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulTimeFormat                : uLong;       // Time format to be used by the device
    ulSpeedFormat               : uLong;       // Speed format used by this device
    ulAudio                     : uLong;       // Channel number for this operation
                                               // (MCI_SET_AUDIO_LEFT, MCI_SET_AUDIO_RIGHT,
                                               //  MCI_SET_AUDIO_ALL)
    ulLevel                     : uLong;       // Volume, trebble or bass level as % of max.
    ulOver                      : uLong;       // Delay time for vectored change in milliseconds
    ulItem                      : uLong;       // Item field for set item flags
    ulValue                     : uLong;       // Value associated with item flag
    usInput                     : uShort;      // Channel for input
    usReserved0                 : uShort;      // Reserved field
    usOutput                    : uShort;      // Channel for output
    usReserved1                 : uShort;      // Reserved field
    usFormatTag                 : uShort;      // Format tag
    usReserved2                 : uShort;      // Reserved field
    usChannels                  : uShort;      // mono(1) or stereo(2)
    usReserved3                 : uShort;      // Reserved field
    ulSamplesPerSec             : uLong;       // Samples per seconds
    ulAvgBytesPerSec            : uLong;       // Bytes per seconds
    usBlockAlign                : uShort;      // Block alignment of data
    usReserved4                 : uShort;      // Reserved field
    usBitsPerSample             : uShort;      // Bits per seconds
    usReserved5                 : uShort;      // Reserved field
  end;
  pmci_Wave_Set_Parms = ^mci_Wave_Set_Parms;

  mci_Seq_Set_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulTimeFormat                : uLong;       // Time format to be used by the device
    ulSpeedFormat               : uLong;       // Speed format used by this device
    ulAudio                     : uLong;       // Channel number for this operation
                                               // (MCI_SET_AUDIO_LEFT, MCI_SET_AUDIO_RIGHT,
                                               //  MCI_SET_AUDIO_ALL)
    ulLevel                     : uLong;       // Volume, trebble or bass level as % of max.
    ulOver                      : uLong;       // Delay time for vectored change in millisecond
    ulItem                      : uLong;       // Item field for set item flags
    ulValue                     : uLong;       // Value associated with item flag
    ulTempo                     : uLong;       // Specified the tempo
    ulPort                      : uLong;       // Output port
    ulSlave                     : uLong;       // Unused field
    ulMaster                    : uLong;       // Unused field
    ulOffset                    : uLong;       // Specified the data offset
  end;
  pmci_Seq_Set_Parms = ^mci_Seq_Set_Parms;

const
  // parameters for the MCI_SET_CUEPOINT message
  //     $0000$00 are reserved for MCI_SET_CUEPOINT flags
  MCI_SET_CUEPOINT_ON           = $00000100;
  MCI_SET_CUEPOINT_OFF          = $00000200;

type
  mci_CuePoint_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulCuepoint                  : uLong;       // Specifies the cuepoint location
    usUserParm                  : uShort;      // User parmameter returned on cuepoint
                                               // notify message
    usReserved0                 : uShort;      // Reserved field
  end;
  pmci_CuePoint_Parms = ^mci_CuePoint_Parms;

const
  // parameters for the MCI_SETIMAGEPALETTE message
  //   $00$XX00 are reserved for MCI_SETIMAGEPALETTE flags
  MCI_SET_REGISTERED            = $00000100;

  // Flags and parameter structure for the MCI_SET_POSITION_ADVISE msg
  //     $0000$00 are reserved for MCI_SET_POSITION_ADVISE flags
  MCI_SET_POSITION_ADVISE_ON    = $00000100;
  MCI_SET_POSITION_ADVISE_OFF   = $00000200;

type
  mci_Position_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulUnits                     : uLong;       // Specifies position change notifiication
                                               // granularity
    usUserParm                  : uShort;      // User parameter returned on position change
                                               // notification message.
    Reserved0                   : uShort;      // Reserved field
    Reserved1                   : uLong;       // Reserved field
  end;
  pmci_Position_Parms = ^mci_Position_Parms;

  mci_Sync_Offset_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulOffset                    : uLong;       // Specifies the device media position offset
                                               // in the currently specified device units.
  end;
  pmci_Sync_Offset_Parms = ^mci_Sync_Offset_Parms;

const
  // Flags for the MCI_SPIN message
  //     $0000$00 are reserved for MCI_SPIN flags
  MCI_SPIN_UP                   = $00000100;
  MCI_SPIN_DOWN                 = $00000200;

  // MCI_STATUS message flags
  //     $00$XX00 are reserved for MCI_STATUS flags
  //     MCI_VOLUME and MCI_VOLUME_DELAY are $00000100 and $00000200
  MCI_STATUS_ITEM               = $00000100;
  MCI_STATUS_START              = $00000200;
  MCI_STATUS_CONNECTOR          = $00000400;

  // General MCI_STATUS item values
  MCI_STATUS_CURRENT_TRACK      = $00000001;
  MCI_STATUS_LENGTH             = $00000002;
  MCI_STATUS_MODE               = $00000003;
  MCI_STATUS_NUMBER_OF_TRACKS   = $00000004;
  MCI_STATUS_POSITION           = $00000005;
  MCI_STATUS_POSITION_IN_TRACK  = $00000006;
  MCI_STATUS_MEDIA_PRESENT      = $00000007;
  MCI_STATUS_VOLUME             = $00000008;
  MCI_STATUS_READY              = $00000009;
  MCI_STATUS_TIME_FORMAT        = $0000000A;
  MCI_STATUS_SPEED_FORMAT       = $0000000B;
  MCI_STATUS_MONITOR            = $0000000C;
  MCI_STATUS_AUDIO              = $0000000D;
  MCI_STATUS_VIDEO              = $0000000E;
  MCI_STATUS_CLIPBOARD          = $0000000F;
  MCI_STATUS_CAN_PASTE          = $00000010;
  MCI_STATUS_CAN_REDO           = $00000020;
  MCI_STATUS_CAN_UNDO           = $00000030;

  // ulValue field values for MCI_STATUS_AUDIO
  MCI_STATUS_AUDIO_ALL          = $00000000;
  MCI_STATUS_AUDIO_LEFT         = $00000001;
  MCI_STATUS_AUDIO_RIGHT        = $00000002;

  // MCI_STATUS item values for amp/mixer
  MCI_AMP_STATUS_PITCH          = MCI_AMP_ITEM_BASE;
  MCI_AMP_STATUS_TREBLE         = MCI_AMP_ITEM_BASE+1;
  MCI_AMP_STATUS_BASS           = MCI_AMP_ITEM_BASE+2;
  MCI_AMP_STATUS_BALANCE        = MCI_AMP_ITEM_BASE+3;
  MCI_AMP_STATUS_GAIN           = MCI_AMP_ITEM_BASE+4;
  MCI_AMP_STATUS_MONITOR        = MCI_AMP_ITEM_BASE+5;
  MCI_AMP_STATUS_MID            = MCI_AMP_ITEM_BASE+6;
  MCI_AMP_STATUS_VOLUME         = MCI_STATUS_VOLUME;
  MCI_AMP_STATUS_LOUDNESS       = MCI_AMP_ITEM_BASE+7;
  MCI_AMP_STATUS_CROSSOVER      = MCI_AMP_ITEM_BASE+8;
  MCI_AMP_STATUS_REVERB         = MCI_AMP_ITEM_BASE+9;
  MCI_AMP_STATUS_ALC            = MCI_AMP_ITEM_BASE+10;
  MCI_AMP_STATUS_CHORUS         = MCI_AMP_ITEM_BASE+11;
  MCI_AMP_STATUS_CUSTOM1        = MCI_AMP_ITEM_BASE+12;
  MCI_AMP_STATUS_CUSTOM2        = MCI_AMP_ITEM_BASE+13;
  MCI_AMP_STATUS_CUSTOM3        = MCI_AMP_ITEM_BASE+14;

  // MCI_STATUS item values for cd audio
  MCI_CD_STATUS_TRACK_TYPE      = MCI_CD_ITEM_BASE;
  MCI_CD_STATUS_TRACK_COPYPERMITTED = MCI_CD_ITEM_BASE+1;
  MCI_CD_STATUS_TRACK_CHANNELS  = MCI_CD_ITEM_BASE+2;
  MCI_CD_STATUS_TRACK_PREEMPHASIS = MCI_CD_ITEM_BASE+3;

  // return values for CD MCI_STATUS message with
  //   MCI_CD_STATUS_TRACK_TYPE set
  MCI_CD_TRACK_AUDIO            = $00000001;
  MCI_CD_TRACK_DATA             = $00000002;
  MCI_CD_TRACK_OTHER            = $00000003;

  // MCI_STATUS item values for CDXA
  MCI_CDXA_STATUS_CHANNEL       = MCI_CDXA_ITEM_BASE;

  //returned from call for MCI_CDXA_STATUS_CHANNEL
  MCI_CDXA_NONE                 = $00000000;

  // MCI_STATUS item values for sequencer
  MCI_SEQ_STATUS_TEMPO          = MCI_SEQ_ITEM_BASE;
  MCI_SEQ_STATUS_OFFSET         = MCI_SEQ_ITEM_BASE+1;
  MCI_SEQ_STATUS_DIVTYPE        = MCI_SEQ_ITEM_BASE+2;
  MCI_SEQ_STATUS_MASTER         = MCI_SEQ_ITEM_BASE+3;
  MCI_SEQ_STATUS_PORT           = MCI_SEQ_ITEM_BASE+4;
  MCI_SEQ_STATUS_SLAVE          = MCI_SEQ_ITEM_BASE+5;

  // Return value for current division type
  MCI_SEQ_DIV_PPQN              = $00000001;
  MCI_SEQ_DIV_SMPTE_24          = $00000002;
  MCI_SEQ_DIV_SMPTE_25          = $00000003;
  MCI_SEQ_DIV_SMPTE_30DROP      = $00000004;
  MCI_SEQ_DIV_SMPTE_30          = $00000005;

  // MCI_STATUS items for videodisc
  MCI_VD_STATUS_SPEED           = MCI_VD_ITEM_BASE;
  MCI_VD_STATUS_FORWARD         = MCI_VD_ITEM_BASE+1;
  MCI_VD_MEDIA_TYPE             = MCI_VD_ITEM_BASE+2;
  MCI_VD_STATUS_SIDE            = MCI_VD_ITEM_BASE+3;
  MCI_VD_STATUS_DISC_SIZE       = MCI_VD_ITEM_BASE+4;

  // Return values for videodisc status command
  MCI_VD_SPEED_NORMAL           = $00000000;
  MCI_VD_SPEED_FAST             = $00000001;
  MCI_VD_SPEED_SLOW             = $00000002;

  // MCI_STATUS items for wave audio
  MCI_WAVE_STATUS_LEVEL         = MCI_WAVE_ITEM_BASE;
  MCI_WAVE_STATUS_SAMPLESPERSEC = MCI_WAVE_ITEM_BASE+1;
  MCI_WAVE_STATUS_AVGBYTESPERSEC = MCI_WAVE_ITEM_BASE+2;
  MCI_WAVE_STATUS_BLOCKALIGN    = MCI_WAVE_ITEM_BASE+3;
  MCI_WAVE_STATUS_FORMATTAG     = MCI_WAVE_ITEM_BASE+4;
  MCI_WAVE_STATUS_CHANNELS      = MCI_WAVE_ITEM_BASE+5;
  MCI_WAVE_STATUS_BITSPERSAMPLE = MCI_WAVE_ITEM_BASE+6;

  // Common video MCI_STATUS items
  MCI_VID_STATUS_hwnd                          = MCI_VID_ITEM_BASE;
  MCI_VID_STATUS_AUDIO_COMPRESSION             = MCI_VID_ITEM_BASE+1;
  MCI_VID_STATUS_VIDEO_COMPRESSION             = MCI_VID_ITEM_BASE+2;
  MCI_VID_STATUS_IMAGE_COMPRESSION             = MCI_VID_ITEM_BASE+3;
  MCI_VID_STATUS_AUDIO_QUALITY                 = MCI_VID_ITEM_BASE+4;
  MCI_VID_STATUS_VIDEO_QUALITY                 = MCI_VID_ITEM_BASE+5;
  MCI_VID_STATUS_IMAGE_QUALITY                 = MCI_VID_ITEM_BASE+6;
  MCI_VID_STATUS_IMAGE_BITSPERPEL              = MCI_VID_ITEM_BASE+7;
  MCI_VID_STATUS_IMAGE_PELFORMAT               = MCI_VID_ITEM_BASE+8;
  MCI_VID_STATUS_FORWARD                       = MCI_VID_ITEM_BASE+9;
  MCI_VID_STATUS_NORMAL_RATE                   = MCI_VID_ITEM_BASE+10;
  MCI_VID_STATUS_VIDEO_X_EXTENT                = MCI_VID_ITEM_BASE+11;
  MCI_VID_STATUS_VIDEO_Y_EXTENT                = MCI_VID_ITEM_BASE+12;
  MCI_VID_STATUS_IMAGE_X_EXTENT                = MCI_VID_ITEM_BASE+13;
  MCI_VID_STATUS_IMAGE_Y_EXTENT                = MCI_VID_ITEM_BASE+14;
  MCI_VID_STATUS_BRIGHTNESS                    = MCI_VID_ITEM_BASE+15;
  MCI_VID_STATUS_CONTRAST                      = MCI_VID_ITEM_BASE+16;
  MCI_VID_STATUS_HUE                           = MCI_VID_ITEM_BASE+17;
  MCI_VID_STATUS_SATURATION                    = MCI_VID_ITEM_BASE+18;
  MCI_VID_STATUS_GREYSCALE                     = MCI_VID_ITEM_BASE+19;
  MCI_VID_STATUS_SHARPNESS                     = MCI_VID_ITEM_BASE+20;
  MCI_VID_STATUS_SPEED                         = MCI_VID_ITEM_BASE+21;
  MCI_VID_STATUS_IMAGE_FILE_FORMAT             = MCI_VID_ITEM_BASE+22;
  MCI_VID_STATUS_TRANSPARENT_TYPE              = MCI_VID_ITEM_BASE+23;
  MCI_VID_STATUS_REF_INTERVAL                  = MCI_VID_ITEM_BASE+24;
  MCI_VID_STATUS_MAXDATARATE                   = MCI_VID_ITEM_BASE+25;
  MCI_VID_STATUS_VIDEO_FILE_FORMAT             = MCI_VID_ITEM_BASE+26;

  // Status Transparent Type returns
  // MCI_VID_PALETTE
  // MCI_VID_RGB
  // MCI_VID_YUV
  MCI_VID_STATUS_TRANSPARENT_COLOR             = MCI_VID_ITEM_BASE+24;

  // MCI_STATUS items for digital video
  MCI_DGV_STATUS_hwnd                          = MCI_VID_STATUS_hwnd;
  MCI_DGV_STATUS_AUDIO_COMPRESSION             = MCI_VID_STATUS_AUDIO_COMPRESSION;
  MCI_DGV_STATUS_VIDEO_COMPRESSION             = MCI_VID_STATUS_VIDEO_COMPRESSION;
  MCI_DGV_STATUS_IMAGE_COMPRESSION             = MCI_VID_STATUS_IMAGE_COMPRESSION;
  MCI_DGV_STATUS_AUDIO_QUALITY                 = MCI_VID_STATUS_AUDIO_QUALITY;
  MCI_DGV_STATUS_VIDEO_QUALITY                 = MCI_VID_STATUS_VIDEO_QUALITY;
  MCI_DGV_STATUS_IMAGE_QUALITY                 = MCI_VID_STATUS_IMAGE_QUALITY;
  MCI_DGV_STATUS_IMAGE_BITSPERPEL              = MCI_VID_STATUS_IMAGE_BITSPERPEL;
  MCI_DGV_STATUS_IMAGE_PELFORMAT               = MCI_VID_STATUS_IMAGE_PELFORMAT;
  MCI_DGV_STATUS_FORWARD                       = MCI_VID_STATUS_FORWARD;
  MCI_DGV_STATUS_NORMAL_RATE                   = MCI_VID_STATUS_NORMAL_RATE;
  MCI_DGV_STATUS_VIDEO_X_EXTENT                = MCI_VID_STATUS_VIDEO_X_EXTENT;
  MCI_DGV_STATUS_VIDEO_Y_EXTENT                = MCI_VID_STATUS_VIDEO_Y_EXTENT;
  MCI_DGV_STATUS_IMAGE_X_EXTENT                = MCI_VID_STATUS_IMAGE_X_EXTENT;
  MCI_DGV_STATUS_IMAGE_Y_EXTENT                = MCI_VID_STATUS_IMAGE_Y_EXTENT;
  MCI_DGV_STATUS_BRIGHTNESS                    = MCI_VID_STATUS_BRIGHTNESS;
  MCI_DGV_STATUS_CONTRAST                      = MCI_VID_STATUS_CONTRAST;
  MCI_DGV_STATUS_HUE                           = MCI_VID_STATUS_HUE;
  MCI_DGV_STATUS_SATURATION                    = MCI_VID_STATUS_SATURATION;
  MCI_DGV_STATUS_SPEED                         = MCI_VID_STATUS_SPEED;
  MCI_DGV_STATUS_SHARPNESS                     = MCI_VID_STATUS_SHARPNESS;
  MCI_DGV_STATUS_REF_INTERVAL                  = MCI_VID_STATUS_REF_INTERVAL;
  MCI_DGV_STATUS_MAXDATARATE                   = MCI_VID_STATUS_MAXDATARATE;
  MCI_DGV_STATUS_VIDEO_FILE_FORMAT             = MCI_VID_STATUS_VIDEO_FILE_FORMAT;

  MCI_DGV_STATUS_CHANNELS                      = MCI_DGV_ITEM_BASE+13;
  MCI_DGV_STATUS_BITSPERSAMPLE                 = MCI_DGV_ITEM_BASE+14;
  MCI_DGV_STATUS_SAMPLESPERSEC                 = MCI_DGV_ITEM_BASE+15;
  MCI_DGV_STATUS_FORMATTAG                     = MCI_DGV_ITEM_BASE+16;
  MCI_DGV_STATUS_BLOCKALIGN                    = MCI_DGV_ITEM_BASE+17;
  MCI_DGV_STATUS_AVGBYTESPERSEC                = MCI_DGV_ITEM_BASE+18;
  MCI_DGV_STATUS_VIDEO_COMPRESSION_SUBTYPE     = MCI_DGV_ITEM_BASE+19;
  MCI_DGV_STATUS_VIDEO_RECORD_RATE             = MCI_DGV_ITEM_BASE+20;
  MCI_DGV_STATUS_VIDEO_RECORD_FRAME_DURATION   = MCI_DGV_ITEM_BASE+21;
  MCI_DGV_STATUS_RECORD_AUDIO                  = MCI_DGV_ITEM_BASE+22;
  MCI_DGV_STATUS_TRANSPARENT_COLOR             = MCI_DGV_ITEM_BASE+23;
  MCI_DGV_STATUS_GRAPHIC_TRANSPARENT_COLOR     = MCI_DGV_ITEM_BASE+23;  // MUST BE SAME AS TRANSPARENT COLOR
  MCI_DGV_STATUS_hwnd_MONITOR                  = MCI_DGV_ITEM_BASE+24;
  MCI_DGV_STATUS_DROPPED_FRAME_PCT             = MCI_DGV_ITEM_BASE+25;
  MCI_DGV_STATUS_AUDIOSYNC                     = MCI_DGV_ITEM_BASE+26;
  MCI_DGV_STATUS_AUDIOSYNC_DIRECTION           = MCI_DGV_ITEM_BASE+27;
  MCI_DGV_STATUS_VIDEO_TRANSPARENT_COLOR       = MCI_DGV_ITEM_BASE+28;  // MUST BE SAME AS TRANSPARENT COLOR
  MCI_DGV_STATUS_TUNER_TV_CHANNEL              = MCI_DGV_ITEM_BASE+29;
  MCI_DGV_STATUS_TUNER_LOW_TV_CHANNEL          = MCI_DGV_ITEM_BASE+29;
  MCI_DGV_STATUS_TUNER_HIGH_TV_CHANNEL         = MCI_DGV_ITEM_BASE+29;
  MCI_DGV_STATUS_TUNER_REGION                  = MCI_DGV_ITEM_BASE+30;
  MCI_DGV_STATUS_TUNER_FINETUNE                = MCI_DGV_ITEM_BASE+31;
  MCI_DGV_STATUS_TUNER_FREQUENCY               = MCI_DGV_ITEM_BASE+32;
  MCI_DGV_STATUS_TUNER_AUDIO_CHANNEL           = MCI_DGV_ITEM_BASE+33;
  MCI_DGV_STATUS_TUNER_AFC                     = MCI_DGV_ITEM_BASE+34;
  MCI_DGV_STATUS_VALID_SIGNAL                  = MCI_DGV_ITEM_BASE+35;

  // MCI_STATUS item values for video overlay
  MCI_OVLY_STATUS_hwnd                         = MCI_VID_STATUS_hwnd;
  MCI_OVLY_STATUS_IMAGE_COMPRESSION            = MCI_VID_STATUS_IMAGE_COMPRESSION;
  MCI_OVLY_STATUS_IMAGE_BITSPERPEL             = MCI_VID_STATUS_IMAGE_BITSPERPEL;
  MCI_OVLY_STATUS_IMAGE_PELFORMAT              = MCI_VID_STATUS_IMAGE_PELFORMAT;
  MCI_OVLY_STATUS_IMAGE_X_EXTENT               = MCI_VID_STATUS_IMAGE_X_EXTENT;
  MCI_OVLY_STATUS_IMAGE_Y_EXTENT               = MCI_VID_STATUS_IMAGE_Y_EXTENT;
  MCI_OVLY_STATUS_BRIGHTNESS                   = MCI_VID_STATUS_BRIGHTNESS;
  MCI_OVLY_STATUS_CONTRAST                     = MCI_VID_STATUS_CONTRAST;
  MCI_OVLY_STATUS_HUE                          = MCI_VID_STATUS_HUE;
  MCI_OVLY_STATUS_SATURATION                   = MCI_VID_STATUS_SATURATION;
  MCI_OVLY_STATUS_GREYSCALE                    = MCI_VID_STATUS_GREYSCALE;
  MCI_OVLY_STATUS_IMAGE_QUALITY                = MCI_VID_STATUS_IMAGE_QUALITY;
  MCI_OVLY_STATUS_SHARPNESS                    = MCI_VID_STATUS_SHARPNESS;
  MCI_OVLY_STATUS_IMAGE_FILE_FORMAT            = MCI_VID_STATUS_IMAGE_FILE_FORMAT;
  MCI_OVLY_STATUS_TRANSPARENT_TYPE             = MCI_VID_STATUS_TRANSPARENT_TYPE;
  MCI_OVLY_STATUS_TRANSPARENT_COLOR            = MCI_VID_STATUS_TRANSPARENT_COLOR;

  // Status Mode return values
  MCI_MODE_NOT_READY            = $00000001;
  MCI_MODE_PAUSE                = $00000002;
  MCI_MODE_PLAY                 = $00000003;
  MCI_MODE_STOP                 = $00000004;
  MCI_MODE_RECORD               = $00000005;
  MCI_MODE_SEEK                 = $00000006;

  // Status Direction return values
  MCI_FORWARD                   = $00000000;
  MCI_REVERSE                   = $00000001;

type
  mci_Status_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulReturn                    : uLong;       // Return field
    ulItem                      : uLong;       // Item field for STATUS item to query
    ulValue                     : uLong;       // Status value field (this used to be)
                                               //  ulTrack but was changed in Rel 1.1
                                               //  to extend the status structure.
                                               //  See the programming reference on when
                                               //  ulValue is used and how...
  end;
  pmci_Status_Parms = ^mci_Status_Parms;

  mci_CDXA_Status_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulReturn                    : uLong;       // Return field
    ulItem                      : uLong;       // Item field for STATUS item to query
    ulValue                     : uLong;       // Status value field (this used to be)
                                               //  ulTrack but was changed in Rel 1.1
                                               //  to extend the status structure.
                                               //  See the programming reference on when
                                               //  ulValue is used and how...
    ulChannel                   : uLong;       // Channel
  end;
  pmci_CDXA_Status_Parms = ^mci_CDXA_Status_Parms;

const
  // flags and parameter structure for the MCI_STEP message
  //     $0000$00 are reserved for MCI_STEP flags
  MCI_STEP_FRAMES               = $00000100;
  MCI_STEP_REVERSE              = $00000200;

type
  mci_Step_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulStep                      : uLong;       // amount to step in current time format
  end;
  pmci_Step_Parms = ^mci_Step_Parms;

const
  // Flags for the MCI_SYSINFO message
  //     $XXXXXX00 are reserved for MCI_SYSINFO flags
  MCI_SYSINFO_QUANTITY          = $00000100;
  MCI_SYSINFO_OPEN              = $00000200;
  MCI_SYSINFO_NAME              = $00000400;
  MCI_SYSINFO_INSTALLNAME       = $00000800;
  MCI_SYSINFO_ITEM              = $00001000;
  MCI_SYSINFO_INI_LOCK          = $00002000;

  // Extended SYSINFO functions
  MCI_SYSINFO_INSTALL_DRIVER    = $00000001;
  MCI_SYSINFO_QUERY_DRIVER      = $00000002;
  MCI_SYSINFO_DELETE_DRIVER     = $00000004;
  MCI_SYSINFO_SET_PARAMS        = $00000008;
  MCI_SYSINFO_QUERY_PARAMS      = $00000010;
  MCI_SYSINFO_SET_CONNECTORS    = $00000020;
  MCI_SYSINFO_QUERY_CONNECTORS  = $00000040;
  MCI_SYSINFO_SET_EXTENSIONS    = $00000080;
  MCI_SYSINFO_QUERY_EXTENSIONS  = $00000100;
  MCI_SYSINFO_SET_ALIAS         = $00000200;
  MCI_SYSINFO_QUERY_NAMES       = $00000400;
  MCI_SYSINFO_SET_DEFAULT       = $00000800;
  MCI_SYSINFO_QUERY_DEFAULT     = $00001000;
  MCI_SYSINFO_SET_TYPES         = $00002000;
  MCI_SYSINFO_QUERY_TYPES       = $00004000;

  // Device Flags
  MCI_SYSINFO_DEV_CONTROLLABLE  = $00000001;
  MCI_SYSINFO_DEV_NONCONTROLLABLE = $00000002;
  MCI_SYSINFO_DEVICESETTINGS    = $00000004;

type
  MaxDevNameChar = array [0..Max_Device_Name-1] of CHAR;
  MaxVerNumChar = array [0..Max_Version_Number-1] of CHAR;
  MaxProdInfChar = array [0..Max_ProdInfo-1] of CHAR;
  MaxPddNameChar = array [0..Max_Pdd_Name-1] of CHAR;
  MaxClsShort    = array [0..Max_Classes-1] of uShort;
  MaxClsShort2   = array [0..Max_Classes-1,0..Max_Classes-1] of uShort;
  MaxDevParmChar = array [0..Max_Dev_Params-1] of CHAR;
  // Parameter structures for the MCI_SYSINFO message
  mci_SysInfo_Parms = record
    hwndDummyCallback        : hwnd;           // NOTIFY not allowed for SYSINFO
    pszReturn                : pChar;          // Pointer to return buffer
    ulRetSize                : uLong;          // Return buffer size
    ulNumber                 : uLong;          // Ordinal Number
    usDeviceType             : uShort;         // MCI device type number
    usReserved0              : uShort;         // Reserved field
    ulItem                   : uLong;          // Used to indicate the MCI_SYSINFO
    pSysInfoParm             : Pointer;        // extended function to perform
  end;
  pmci_SysInfo_Parms = ^mci_SysInfo_Parms;

  mci_SysInfo_LogDevice = packed record
    szInstallName            : MaxDevNameChar; // Device install name
    usDeviceType             : uShort;         // Device type number
    ulDeviceFlag             : uLong;          // Flag indicating whether device
                                               //  device is controllable or not
    szVersionNumber          : MaxVerNumChar;  // INI file version number
    szProductInfo            : MaxProdInfChar; // Textual product description
    szMCDDriver              : MaxDevNameChar; // MCI Driver dll name
    szVSDDriver              : MaxDevNameChar; // VSD dll name
    szPDDName                : MaxPddNameChar; // Device PDD name
    szMCDTable               : MaxDevNameChar; // Device type command table
    szVSDTable               : MaxDevNameChar; // Device specific command table
    usShareType              : uShort;         // Device sharing mode
    szResourceName           : MaxDevNameChar; // Resource name
    usResourceUnits          : uShort;         // Total resource units available
                                               //  for this device
    usResourceClasses        : uShort;         // Number of resource classes for
                                               //  this device
    ausClassArray            : MaxClsShort;    // Maximum number of resource
                                               //  units for each class
    ausValidClassArray       : MaxClsShort2;   // Valid class combinations
  end;
  pmci_SysInfo_LogDevice = ^mci_SysInfo_LogDevice;

  mci_SysInfo_DevParams = record
    szInstallName            : MaxDevNameChar; // Device install name
    szDevParams              : MaxDevParmChar; // Device specific parameters
  end;
  pmci_SysInfo_DevParams = ^mci_SysInfo_DevParams;

type
  Connect = record
    usConnectType            : uShort;         // Connector type
    szToInstallName          : MaxDevNameChar; // Install name this connector
                                               //  is connected to
    usToConnectIndex         : uShort;         // Connector index this connector
                                               //  is connected to
  end;
  pConnect = ^Connect;

  MaxCnctCnct      = array[0..MAX_CONNECTORS-1] of Connect;
  MaxExtChar2      = array[0..MAX_EXTENSIONS-1,0..MAX_EXTENSION_NAME-1] of CHAR;
  MaxAliasNameChar = array[0..Max_Alias_Name-1] of Char;
  MaxTypeBufChar   = array[0..Max_TypeBuffer] of Char;

  mci_SysInfo_ConParams = record
    szInstallName            : MaxDevNameChar; // Device install name
    usNumConnectors          : uShort;         // Number of device connectors
    ConnectorList            : MaxCnctCnct;    // Connector list array
  end;
  pmci_SysInfo_ConParams = ^mci_SysInfo_ConParams;

  mci_SysInfo_Extension = record
    szInstallName            : MaxDevNameChar; // Device install name
    usNumExtensions          : uShort;         // Number of extensions
    szExtension              : MaxExtChar2;    // Extension name array
  end;
  pmci_SysInfo_Extension = ^mci_SysInfo_Extension;

  mci_SysInfo_Alias = record
    szInstallName            : MaxDevNameChar;   // Device install name
    szAliasName              : MaxAliasNameChar; // Alias name
  end;
  pmci_SysInfo_Alias = ^mci_SysInfo_Alias;

  mci_SysInfo_DefaultDevice = record
    szInstallName            : MaxDevNameChar; // Device install name
    usDeviceType             : uShort;         // Device type number
  end;
  pmci_SysInfo_DefaultDevice = ^mci_SysInfo_DefaultDevice;

  mci_SysInfo_Query_Name = record
    szInstallName            : MaxDevNameChar; // Device install name
    szLogicalName            : MaxDevNameChar; // Logical device name
    szAliasName              : MaxAliasNameChar; // Alias name
    usDeviceType             : uShort;         // Device type number
    usDeviceOrd              : uShort;         // Device type ordinal
  end;
  pmci_SysInfo_Query_Name = ^mci_SysInfo_Query_Name;

  mci_SysInfo_Types = record
    szInstallName            : MaxDevNameChar; // Device install name
    szTypes                  : MaxTypeBufChar; // EA types
  end;
  pmci_SysInfo_Types = ^mci_SysInfo_Types;


const
  // Flags for the MCI_UNFREEZE message
  //     $0000$00 are reserved for MCI_UNFREEZE flags
  MCI_OVLY_UNFREEZE_RECT         = $00000100;
  MCI_OVLY_UNFREEZE_RECT_OUTSIDE = $00000200;

  // Flags for the MCI_WHERE message
  //     $000$X00 are reserved for MCI_WHERE flags
  MCI_VID_WHERE_DESTINATION     = $00000100;
  MCI_VID_WHERE_SOURCE          = $00000200;
  MCI_VID_WHERE_WINDOW          = $00000400;

  MCI_DGV_WHERE_DESTINATION     = MCI_VID_WHERE_DESTINATION;
  MCI_DGV_WHERE_SOURCE          = MCI_VID_WHERE_SOURCE;
  MCI_DGV_WHERE_WINDOW          = MCI_VID_WHERE_WINDOW;
  MCI_DGV_WHERE_ADJUSTED        = $00000800;

  MCI_OVLY_WHERE_DESTINATION    = MCI_VID_WHERE_DESTINATION;
  MCI_OVLY_WHERE_SOURCE         = MCI_VID_WHERE_SOURCE;
  MCI_OVLY_WHERE_WINDOW         = MCI_VID_WHERE_WINDOW;

  // Flags and parameter structure for the MCI_WINDOW message
  //     $000$X00   are reserved for MCI_WINDOW flags
  MCI_VID_WINDOW_hwnd           = $00000100;
  MCI_VID_WINDOW_STATE          = $00000200;
  MCI_VID_WINDOW_TEXT           = $00000400;
  MCI_VID_WINDOW_DEFAULT        = $00000800;

  MCI_DGV_WINDOW_hwnd           = MCI_VID_WINDOW_hwnd;
  MCI_DGV_WINDOW_STATE          = MCI_VID_WINDOW_STATE;
  MCI_DGV_WINDOW_TEXT           = MCI_VID_WINDOW_TEXT;
  MCI_DGV_WINDOW_DEFAULT        = MCI_VID_WINDOW_DEFAULT;

  MCI_OVLY_WINDOW_hwnd          = MCI_VID_WINDOW_hwnd;
  MCI_OVLY_WINDOW_STATE         = MCI_VID_WINDOW_STATE;
  MCI_OVLY_WINDOW_TEXT          = MCI_VID_WINDOW_TEXT;
  MCI_OVLY_WINDOW_DEFAULT       = MCI_VID_WINDOW_DEFAULT;

type
  mci_Vid_Window_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    hwndDest                    : hwnd;        // Handle to the client window used for
                                               // the destination of the video image
    usCmdShow                   : uShort;      // Specifies how the window is displayed
    usReserved1                 : uShort;      // Reserved
    pszText                     : pChar;       // The text to use as the window caption
    pszAlias                    : pChar;       // The window alias for the display window
  end;
  pmci_Vid_Window_Parms = ^mci_Vid_Window_Parms;

  mci_dgv_Window_Parms = mci_Vid_Window_Parms;
  pmci_dgv_Window_Parms = ^mci_dgv_Window_Parms;

  mci_Ovly_Window_Parms = mci_Vid_Window_Parms;
  pmci_Ovly_Window_Parms = ^mci_Ovly_Window_Parms;

const
  // flags and parameter structure for the MCI_TUNER  message
  MCI_DGV_AUDIO_CHANNEL         = $00010000;
  MCI_DGV_TV_CHANNEL            = $00020000;
  MCI_DGV_FREQUENCY             = $00040000;
  MCI_DGV_FINETUNE_PLUS         = $00080000;
  MCI_DGV_FINETUNE_MINUS        = $00100000;
  MCI_DGV_REGION                = $00200000;
  MCI_DGV_AFC_ON                = $00400000;
  MCI_DGV_AFC_OFF               = $00800000;

type
  mci_Dgv_Tuner_Parms = record
    hwndCallback                : hwnd;        // PM window handle for MCI notify message
    ulFrequency                 : uLong;       // Tuner Frequency
    ulReserved0                 : uLong;       // Reserved 0
    ulTVChannel                 : uLong;       // TV Channel
    lFineTune                   : Long;        // Fine tuning adjustments.
    pszRegion                   : pChar;       // TV Channel Region
    ulReserved1                 : uLong;       // Reserved 1
    ulReserved2                 : uLong;       // Reserved 2
  end;
  pmci_Dgv_Tuner_Parms = ^mci_Dgv_Tuner_Parms;

const
  //  MCI system value defines
  MSV_CLOSEDCAPTION             = $0;
  MSV_MASTERVOLUME              = $1;
  MSV_HEADPHONES                = $2;
  MSV_SPEAKERS                  = $3;
  MSV_WORKPATH                  = $4;
  MSV_SYSQOSVALUE               = $5;
  MSV_SYSQOSERRORFLAG           = $6;

  MSV_MAX                       = $7;

  // Playlist defines
  DATA_OPERATION                = 0;
  BRANCH_OPERATION              = 1;
  LOOP_OPERATION                = 2;
  CALL_OPERATION                = 3;
  RETURN_OPERATION              = 4;
  EXIT_OPERATION                = 5;
  NOP_OPERATION                 = 6;
  MESSAGE_OPERATION             = 7;
  CUEPOINT_OPERATION            = 8;

function mciSendCommand(usDeviceID: uShort; usMessage: uShort; ulParam1: uLong;
         var Param2; usUserParm: uShort): Ulong;

function mciSendString(pszCommandBuf: pChar; pszReturnString: pChar;
         wReturnLength: uShort; hwndCallBack: hwnd; usUserParm: uShort): Ulong;

function mciGetErrorString(ulError: uLong; pszBuffer: pChar; usLength: uShort): Ulong;

function mciMakeGroup(var usDeviceGroupID:uShort; usDeviceCount: uShort;
             var ausDeviceList: uShort; ulFlags: uLong; ulMMTime: uLong): Ulong;

function mciDeleteGroup(usGroupID:uShort): Ulong;

function mciSetSysValue(iSysValue: uShort; var Value): Bool;

function mciQuerySysValue(iSysValue: uShort;var Value): Bool;

function mciGetDeviceID(pszName: pChar): uLong;

{----[ MMDRVOS2 ]----}  // 13k

type
  gID = uShort;

const
  //             MCI Driver  message identifiers
  MCIDRV_SAVE                   = 900;
  MCIDRV_RESTORE                = 901;
  MCIDRV_SYNC                   = 902;
  MCIDRV_CHANGERESOURCE         = 903;
  MCIDRV_CONNECT                = 904;
  MCIDRV_ASSOCIATE              = 905;
  MCIDRV_DISCONNECT             = 906;
  MCIDRV_TEST_CONNECTION        = 907;
  MCIDRV_START                  = 908;
  MCIDRV_SEEK                   = 909;
  MCIDRV_STOP                   = 910;
  MCIDRV_MODIFY_CONNECTION      = 911;
  MCIDRV_INIT_CONNECTION        = 912;
  MCIDRV_DEINIT_CONNECTION      = 913;

  // The following messages are used by the MCIDRV_CONNECT message
  MCIDRV_CONNECT_TARGET         = $00010000;
  MCIDRV_CONNECT_SOURCE         = $00020000;
  MCIDRV_SET_CONNNECTOR_TYPE    = $00040000;
  MCIDRV_CHANGE_SEM             = $00080000;

  // The following messages are used by MCIDRV_START
  MCIDRV_CUE_PLAYBACK           = $00010000;
  MCIDRV_CUE_RECORD             = $00020000;
  MCIDRV_START_PLAYBACK         = $00040000;
  MCIDRV_START_RECORD           = $00080000;
  MCIDRV_START_PREROLL          = $00100000;

  // The following messages are used by MCIDRV_ASSOCIATE
  MCIDRV_OUTPUT                 = $00010000;
  MCIDRV_INPUT                  = $00020000;

  // The following messages are used by MCIDRV_STOP
  MCIDRV_PAUSE_STREAM_NETWORK   = $00010000;
  MCIDRV_FLUSH_STREAM_NETWORK   = $00020000;
  MCIDRV_DISCARD_STREAM_NETWORK = $00040000;

  // The following range of message ID's are reserved for internal use
  //  by MCI drivers
  MCI_INTERNAL_MESSAGES_START   = 1000;
  MCI_INTERNAL_MESSAGES_END     = 1999;

  // Flags used by the string parser for command tables
  MCI_COMMAND_HEAD              = $00000001;
  MCI_END_COMMAND               = $00000002;
  MCI_END_COMMAND_LIST          = $00000003;
  MCI_RETURN                    = $00000004;
  MCI_STRING                    = $00000005;
  MCI_FLAG                      = $00000006;
  MCI_INTEGER                   = $00000007;
  MCI_CONSTANT                  = $00000008;
  MCI_CONSTANT_INTEGER          = $00000009;
  MCI_CONSTANT_STRING           = $0000000A;
  MCI_END_CONSTANT              = $0000000B;
  MCI_DEFAULT_STRING            = $0000000C;
  MCI_DEFAULT_INTEGER           = $0000000D;
  MCI_RETURN_TYPE               = $0000000E;
  MCI_RETURN_TYPE_STRING        = $0000000F;
  MCI_END_RETURN_TYPE           = $00000010;
  MCI_CONSTANT_2                = $00000011;
  MCI_END_CONSTANT_2            = $00000012;
  MCI_CONSTANT_PAIR             = $00000013;
  MCI_END_CONSTANT_PAIR         = $00000014;
  MCI_CONSTANT_INTEGER_PAIR     = $00000015;
  MCI_CONSTANT_STRING_PAIR      = $00000016;
  MCI_RECTL                     = $00000017;
  MCI_CONSTANT_4                = $00000018;
  MCI_END_CONSTANT_4            = $00000019;
  MCI_FOURCC                    = $0000001A;
  MCI_OR                        = $0000001B;
  MCI_END_OR                    = $0000001C;
  MCI_STRING_LIST               = $0000001D;

  // Return types supported by mciSendString
  //   Values $0000 -> $FF00  are reserved by MMPM2
  //   Values $FF01 -> $FFFF  are user definable
  MCI_INTEGER_RETURNED          = $1000;
  MCI_COLONIZED2_RETURN         = $2000;
  MCI_COLONIZED3_RETURN         = $3000;
  MCI_COLONIZED4_RETURN         = $4000;
  MCI_TRUE_FALSE_RETURN         = $5000;
  MCI_ON_OFF_RETURN             = $6000;
  MCI_DEVICENAME_RETURN         = $7000;
  MCI_TIME_FORMAT_RETURN        = $8000;
  MCI_SPEED_FORMAT_RETURN       = $9000;
  MCI_MODE_RETURN               = $A000;
  MCI_MEDIA_TYPE_RETURN         = $B000;
  MCI_TRACK_TYPE_RETURN         = $C000;
  MCI_CONNECTOR_TYPE_RETURN     = $D000;
  MCI_CDXA_CHANNEL_DESTINATION_RETURN = $E000;
  MCI_PREROLL_TYPE_RETURN       = $F000;
  MCI_FORMAT_TAG_RETURN         = $F100;
  MCI_SEQ_SYNCHRONIZATION_RETURN = $F200;
  MCI_VIDEO_QUALITY_RETURN      = $F300;
  MCI_AUDIO_QUALITY_RETURN      = $F400;
  MCI_IMAGE_QUALITY_RETURN      = $F500;
  MCI_VIDEO_COMPRESSION_RETURN  = $F600;
  MCI_AUDIO_COMPRESSION_RETURN  = $F700;
  MCI_IMAGE_COMPRESSION_RETURN  = $F800;
  MCI_RECTL_RETURN              = $F900;
  MCI_FOURCC_RETURN             = $FA00;
  MCI_IMAGE_PELFORMAT_RETURN    = $FB00;
  MCI_DIRECTION_RETURN          = $FC00;
  MCI_SIGNED_INTEGER_RETURN     = $FD00;

  MCI_USER_RETURN               = $FF01;

  // End of msg text used by mciGetErrorString
  MCIERR_MSG_TABLE_END          = MCIERR_BASE + 7000;

  //  MCI DEVICE shareability categories
  FIXEDSINGLECONTEXT            = $0001;
  DYNAMICSINGLECONTEXT          = $0002;
  LIMITEDMULTIPLECONTEXT        = $0003;
  UNLIMITEDMULTIPLECONTEXT      = $0004;

  // MCI driver flag for close during exit list processing
  MCI_CLOSE_EXIT                = $10000000;

  // MCI driver specific error table resource number base
  MMERROR_TABLE_BASE            = 500;

  //  MCIDRV_CHANGERESOURCE  message flags
type
  mciDrv_ChangeResource_Parms = record
    pInstance                   : Pointer;     // pointer to device instance
    usResourceUnits             : uShort;      // required resource units
    usResourceClass             : uShort;      // resource class
    usResourcePriority          : uShort;      // resource priority
  end;
  pmciDrv_ChangeResource_Parms = ^mciDrv_ChangeResource_Parms;

const
  //  MCIDRV_SYNC  message flags
  MCIDRV_SYNC_ENABLE            = $00000100;
  MCIDRV_SYNC_DISABLE           = $00000200;
  MCIDRV_SYNC_REC_PULSE         = $00000400;
  MCIDRV_SYNC_MASTER            = $00000800;
  MCIDRV_SYNC_SET_MASTER        = $00001000;

type
  mciDrv_Sync_Parms = record
    hStreams                    : ^hStream;    // Pointer to list of stream IDs
    ulNumStreams                : uLong;       // number of stream IDs
    mmTime                      : mmTime;      // Sync Pulse Time
    NonStreamMaster             : Bool;        // TRUE if this device can be master
    pevcbSyncPulse              : pSync_evcb;  // pointer to EVCB address (output)
    hidMaster                   : hID;         // Master NULL sh ID (valid only on
                                               //    MCIDRV_SYNC_MASTER
    ulReserved1                 : uLong;       // Reserved field
    ulReserved2                 : uLong;       // Reserved field
  end;
  pmciDrv_Sync_Parms = ^mciDrv_Sync_Parms;

  // Contains information for open message for MCI drivers
  mmDrv_Open_Parms = record
    hwndCallback                : hwnd;        // call back handle
    usDeviceID                  : uShort;      // The device ID assigned to this instance
    usDeviceType                : uShort;      // The device type number
    usDeviceOrd                 : uShort;      // The device ordinal number
    pInstance                   : Pointer;     //  pointer to the instance structure allocated
                                               //  initialized by the driver. The MCI driver
                                               // will fill in this parameter.
    szDevDLLName : Array[0..259] of Char;      // Character string containing the device
                                               // specific DLL name to call for the open.
                                               // (ie. ACPA.DLL)
    pszElementName              : pChar;       //   typically a file name or NULL
    usDevParmLen                : uShort;      // Device parameters data block length.
    pDevParm                    : Pointer;     // Device parameters data block. This data
                                               // block is unique to each type of device.
                                               // (ie. LVD "COM1 9600 N 7 1").
    Reserved0                   : Pointer;
    usResourceUnitsRequired     : uShort;      // number of resource units this instance
                                               // requires.
    usResourceClass             : uShort;      // resource class this instance belongs to
    usResourcePriority          : uShort;      // resource priority for this instance
    ulParam2                    : uLong;       // Pointer to MCI_OPEN structure
  end;
  pmmDrv_Open_Parms = ^mmDrv_Open_Parms;


function mdmDriverNotify( usDeviceID: uShort; wnd: Hwnd; usMsgType: uShort;
                          usUserParm: uShort; ulMsgParm: uLong): uLong;

{----[ MMIOOS2 ]----}

type
  hmmcf = hmmIO;
  FourCC = uLong;
  pFourCC = ^FourCC;
  hPStr = pChar;

// Define MMIO public data structures.
  mmCkInfo = record
    ckid              : FourCC;                // Chunk id (FourCC)
    ckSize            : uLong;                 // Chunk Size (bytes)
    fccType           : FourCC;                // FourCC Type (if ckid RIFF or LIST)
    ulDataOffset      : uLong;                 // File Offset of data portion of chunk
    ulFlags           : uLong;                 // MMIO_DIRTY (if new chunk)
  end;
  pmmCkInfo = ^mmCkInfo;

  mmIOProc = function( pmmIOInfo: Pointer; usMsg: uShort; lp1, lp2: Long): Long;
  pmmIOProc = mmIOProc;
  pCodecProc = mmIOProc;

  mmIOInfo = record
    ulFlags           : uLong;                 // Open flags
    fccIOProc         : FourCC;                // FourCC of the IOProc to use
    pIOProc           : mmIOProc;              // Function Pointer to IOProc to use
    ulErrorRet        : uLong;                 // Extended Error return code
    cchBuffer         : Long;                  // I/O buff size (if used), Fsize if MEM
    pchBuffer         : pChar;                 // Start of I/O buff
    pchNext           : pChar;                 // Next char to read or write in buff
    pchEndRead        : pChar;                 // Last char in buff can be read + 1
    pchEndWrite       : pChar;                 // Last char in buff can be written + 1
    lBufOffset        : Long;                  // Offset in buff to pchNext
    lDiskOffset       : Long;                  // Disk offset in file
    aulInfo           : Array[0..3] of uLong;  // IOProc specific fields
    lLogicalFilePos   : Long;                  // Actual file position, buffered or not
    ulTranslate       : uLong;                 // Translation field
    fccChildIOProc    : FourCC;                // FourCC of Child IOProc
    pExtraInfoStruct  : Pointer;               // Pointer to a structure of related data
    mmio              : hmmIO;                 // Handle to media element
  end;
  pmmIOInfo = ^mmIOInfo;

  mmCfInfo = record
    ulHeaderSize      : uLong;                 // CTOC header size
    ulEntriesTotal    : uLong;                 // Num of CTOC table entries
    ulEntriesDeleted  : uLong;                 // Num of CTOC table entries deleted
    ulEntriesUnused   : uLong;                 // Num of unused CTOC entries
    ulBytesTotal      : uLong;                 // Combined byte size of all CGRP elements
    ulBytesDeleted    : uLong;                 // Byte size of all deleted CGRP elements
    ulHeaderFlags     : uLong;                 // Info about entire compound file (CF)
    usEntrySize       : uShort;                // Size of each CTOC table entry
    usNameSize        : uShort;                // Size of name field in entry, default 13
    usExHdrFields     : uShort;                // Num CTOC header extra fields
    usExEntFields     : uShort;                // Num CTOC entry extra fields
  end;

// Note:  These are variable length uLong arrays that may be present
//        at the end of the MMCFINFO structure.

//   uLong    (*aulExHdrFldUsage)[]   * Array of header extra usage fields
//   uLong    (*aulExtEntFldUsage)[]  * Array of entry extra usage fields
//   uLong    (*aulExHdrField)[]      * Array of header extra fields

  pmmCfInfo = ^mmCfInfo;

  mmCtocEntry = record
    ulOffset          : uLong;                 // Offset of element within CGRP
    ulSize            : uLong;                 // Size of element
    ulMedType         : uLong;                 // Fourcc of element
    ulMedUsage        : uLong;                 // Possible sub type
    ulCompressTech    : uLong;                 // Compression technique used
    ulUncompressBytes : uLong;                 // Actual size of uncompressed element
  end;

// Note:  A variable length name field and possibly a uLong array may
//        be present at the end of the MMCTOCENTRY structure.

//   uLong    (*aulExEntField)[];  * Array of entry extra fields
//   PSZ      pszElementName[];    * Name of element, variable length

  pmmCtocEntry = ^mmCtocEntry;


const
  // Conversion Flags/Data Structures:
  MMIO_MEDIATYPE_IMAGE          = $00000001;  // Image media
  MMIO_MEDIATYPE_AUDIO          = $00000002;  // Audio media
  MMIO_MEDIATYPE_MIDI           = $00000004;  // MIDI media
  MMIO_MEDIATYPE_COMPOUND       = $00000008;  // Cmpd media
  MMIO_MEDIATYPE_OTHER          = $00000010;  // Other media
  MMIO_MEDIATYPE_UNKNOWN        = $00000020;  // Unknown media
  MMIO_MEDIATYPE_DIGITALVIDEO   = $00000040;  // Digital Video
  MMIO_MEDIATYPE_ANIMATION      = $00000080;  // Future: Not Supported
  MMIO_MEDIATYPE_MOVIE          = $00000100;  // Movie File

  MMIO_CANREADTRANSLATED        = $00000001;  //IOProc Cpbilty Flgs
  MMIO_CANWRITETRANSLATED       = $00000002;  // "       "       "
  MMIO_CANREADWRITETRANSLATED   = $00000004;  // "       "       "
  MMIO_CANREADUNTRANSLATED      = $00000008;  // "       "       "
  MMIO_CANWRITEUNTRANSLATED     = $00000010;  // "       "       "
  MMIO_CANREADWRITEUNTRANSLATED = $00000020;  // "       "       "
  MMIO_CANSEEKTRANSLATED        = $00000040;  // "       "       "
  MMIO_CANSEEKUNTRANSLATED      = $00000080;  // "       "       "
  MMIO_CANINSERTUNTRANSLATED    = $00000100;  // "       "       "
  MMIO_CANSAVEUNTRANSLATED      = $00000200;  // "       "       "
  MMIO_CANINSERTTRANSLATED      = $00000400;  // "       "       "
  MMIO_CANSAVETRANSLATED        = $00000800;  // "       "       "
  MMIO_CANMULTITRACKREADTRANSLATED = $00001000; // "       "       "
  MMIO_CANMULTITRACKREADUNTRANSLATED = $00002000; // "       "       "
  MMIO_CANMULTITRACKWRITETRANSLATED = $00004000; // "       "       "
  MMIO_CANMULTITRACKWRITEUNTRANSLATED = $00008000; // "       "       "
  MMIO_CANTRACKSEEKTRANSLATED   = $00010000;  // "       "       "
  MMIO_CANTRACKSEEKUNTRANSLATED = $00020000;  // "       "       "
  MMIO_CANTRACKREADTRANSLATED   = $00040000;  // "       "       "
  MMIO_CANTRACKREADUNTRANSLATED = $00080000;  // "       "       "
  MMIO_CANTRACKWRITETRANSLATED  = $00100000;  // "       "       "
  MMIO_CANTRACKWRITEUNTRANSLATED = $00200000; // "       "       "

  MMIO_IOPROC_STORAGESYSTEM     = $00000001;  // IOProc Types
  MMIO_IOPROC_FILEFORMAT        = $00000002;
  MMIO_IOPROC_DATAFORMAT        = $00000004;

type
  mmFormatInfo = record
    ulStructLen       : uLong;                 // Length of this structure
    fccIOProc         : FourCC;                // IOProc identifier
    ulIOProcType      : uLong;                 // Type of IOProc
    ulMediaType       : uLong;                 // Media Type
    ulFlags           : uLong;                 // IOProc capability flags
    szDefaultFormatExt : Array[0..Sizeof(FourCC)] of Char;
                                               // Default extension 4 + null
    ulCodePage        : uLong;                 // Code Page
    ulLanguage        : uLong;                 // Language
    lNameLength       : Long;                  // length of identifier string
  end;
  pmmFormatInfo = ^mmFormatInfo;

const
  MMIO_IMAGE_UNKNOWN            = $00000000;   // Unknown image content
  MMIO_IMAGE_DRAWING            = $00000001;   // Simple drawing
  MMIO_IMAGE_GRAPH              = $00000002;   // Graphs & Cartoons
  MMIO_IMAGE_PHOTO              = $00000004;   // Varying Color & Shades

  MAX_PALETTE                   = 256;

type
  xdibHdr_Prefix = record
    ulMemSize         : uLong;                 // Length of bitmap
    ulPelFormat       : uLong;
    usTransType       : uShort;
    ulTransVal        : uLong;
  end;

  mmxdibHeader = record                        // XDIB Header
    XDIBHeaderPrefix  : XDIBHDR_PREFIX;
    BMPInfoHeader2    : BITMAPINFOHEADER2;
  end;
  pmmxdibHeader = ^mmxdibHeader;

  mmImageHeader = record
    ulHeaderLength    : uLong;                 // Length in Bytes
    ulContentType     : uLong;                 // Image content
    ulMediaType       : uLong;                 // Media Type
    mmXDIBHeader      : mmXDIBHeader;          // OS/2 2.0 PM compat header
    bmiColors         : Array[0..MAX_PALETTE-1] of RGB2; // PM compatible palette
  end;
  pmmImageHeader = ^mmImageHeader;

const
  MMIO_AUDIO_UNKNOWN            = $00000000;   // Unknown image content
  MMIO_AUDIO_VOICE              = $00000001;   // Limited Range
  MMIO_AUDIO_MUSIC              = $00000002;   // FM Radio or equivalent
  MMIO_AUDIO_HIFI               = $00000004;   // High quality recording

type
  Wave_Header = record
    usFormatTag       : uShort;                // Type of wave format
    usChannels        : uShort;                // Number of channels
    ulSamplesPerSec   : uLong;                 // Sampling rate
    ulAvgBytesPerSec  : uLong;                 // Avg bytes per sec
    usBlockAlign      : uShort;                // Block Alignment in bytes
    usBitsPerSample   : uShort;                // Bits per sample
  end;

  xWav_HeaderInfo = record
    ulAudioLengthInMS      : uLong;            // Audio data in millisecs
    ulAudioLengthInBytes   : uLong;            // Audio data in bytes
    pAdditionalInformation : Pointer;
  end;

  mmxWav_Header = record
    WAVEHeader        : WAVE_HEADER;           // Per RIFF WAVE Definition
    XWAVHeaderInfo    : XWAV_HEADERINFO;       // Extended wave definition
  end;

  mmAudioHeader = record
    ulHeaderLength    : uLong;                 // Length in Bytes
    ulContentType     : uLong;                 // Image content
    ulMediaType       : uLong;                 // Media Type
    mmXWAVHeader      : MMXWAV_HEADER;         // header
  end;
  pmmAudioHeader = ^mmAudioHeader;

const
  MMIO_MIDI_UNKNOWN             = $00000000;  // Unknown midi content
  MMIO_MIDI_VOICE               = $00000001;  // Limited Range
  MMIO_MIDI_MUSIC               = $00000002;  // FM Radio or equivalent
  MMIO_MIDI_HIFI                = $00000004;  // High quality recording

// MMPMMMIO.INI file structure and definitions.

  DLLNAME_SIZE                  = CCHMAXPATH;
  PROCNAME_SIZE                 = 32;

type
  mmIniFileInfo = record
    fccIOProc         : FourCC;                // IOProc identifier
    szDLLName         : Array[0..DLLName_Size-1] of Char;  // DLL name string
    szProcName        : Array[0..ProcName_Size-1] of Char; // Procedure name string
    ulFlags           : uLong;                 // Flags for Preload
    ulExtendLen       : uLong;                 // Length of ext fields
    ulMediaType       : uLong;                 // Media type
    ulIOProcType      : uLong;                 // Type of IOProc
    szDefExt          : Array[0..Max_Extension_Name] of Char;
  end;
  pmmIniFileInfo = ^mmIniFileInfo;

// CODEC Structures and type definitions for Rel. 1.1

const
  CODEC_INFO_SIZE               = 8;
  CODEC_HW_NAME_SIZE            = 32;

type
  CodecIniFileInfo = record
    ulStructLen       : uLong;                 // length of this structure
    fcc               : FourCC;                // File Format ID
    szDLLName         : Array[0..DLLName_Size-1] of Char;       // DLL name string
    szProcName        : Array[0..ProcName_Size-1] of Char;      // Procedure name string
    ulCompressType    : uLong;                 // Compression Type
    ulCompressSubType : uLong;                 // Compression SubType
    ulMediaType       : uLong;                 // Media type
    ulCapsFlags       : uLong;                 // capabilities flags
    ulFlags           : uLong;                 // flags
    szHWID            : Array[0..Codec_HW_Name_Size-1] of Char; // specific information
    ulMaxSrcBufLen    : uLong;                 // max source buffer length
    ulSyncMethod      : uLong;                 // Synchronization method
    fccPreferredFormat: uLong;                 // Preferred output format
    ulXalignment      : uLong;                 // x alignment - video only
    ulYalignment      : uLong;                 // y alignment - video only
    ulSpecInfo        : Array[0..Codec_Info_Size-1] of uLong;   // specific information
  end;
  pCodecIniFileInfo = ^CodecIniFileInfo;

const
  // CODECINIFILEINFO synchronization method (ulSyncMethod) values.
  CODEC_SYNC_METHOD_NO_DROP_FRAMES = 0;
  CODEC_SYNC_METHOD_DROP_FRAMES_IMMEDIATELY = 1;
  CODEC_SYNC_METHOD_DROP_FRAMES_PRECEDING_KEY = 2;
  CODEC_SYNC_METHOD_HARDWARE    = 3;

  // CODECINIFILEINFO capabilities (ulCapsFlags) values.
  CODEC_COMPRESS                = $00000001;
  CODEC_DECOMPRESS              = $00000002;
  CODEC_WINDOW_CLIPPING         = $00000004;
  CODEC_PALETTE_TRANS           = $00000008;
  CODEC_SELFHEAL                = $00000010;
  CODEC_SCALE_PEL_DOUBLE        = $00000020;
  CODEC_SCALE_PEL_HALVED        = $00000040;
  CODEC_SCALE_CONTINUOUS        = $00000080;
  CODEC_MULAPERTURE             = $00000100;
  CODEC_4_BIT_COLOR             = $00000200;
  CODEC_8_BIT_COLOR             = $00000400;
  CODEC_16_BIT_COLOR            = $00000800;
  CODEC_24_BIT_COLOR            = $00001000;
  CODEC_HARDWARE                = $00002000;
  CODEC_SYMMETRIC               = $00004000;
  CODEC_ASYMMETRIC              = $00008000;
  CODEC_DIRECT_DISPLAY          = $00010000;
  CODEC_DEFAULT                 = $00020000;
  CODEC_ORIGIN_LOWERLEFT        = $00040000;
  CODEC_ORIGIN_UPPERLEFT        = $00080000;
  CODEC_SET_QUALITY             = $00100000;  // quality level is settable
  CODEC_DATA_CONSTRAINT         = $00200000;  // data constraint supported
  CODEC_HW_OVERLAY              = $00400000;
  CODEC_MULTI_BUFFER            = $00800000;
  CODEC_DITHER_OUTPUT           = $01000000;

  // Audio related flags
  CODEC_COMP_REALTIME           = $00020000;
  CODEC_DECOMP_REALTIME         = $00040000;

// CODECINIFILEINFO Flag Values (ulFlags) values.

  // Bit definitions for mmioSet()
  MMIO_SET_EXTENDEDINFO         = $0001;
  MMIO_QUERY_EXTENDEDINFO_BASE  = $0002;
  MMIO_QUERY_EXTENDEDINFO_ALL   = $0004;

type
  // CODECASSOC structure
  CodecAssoc = record
   pCodecOpen         : Pointer;               // codec specific open header
   pCODECIniInfo      : PCodecIniFileInfo;     // codecinifileinfo
  end;
  pCodecAssoc = ^CodecAssoc;

  // MMEXTENDINFO structure
  mmExtendInfo = record
    ulStructLen       : uLong;             // length of this structure
    ulBufSize         : uLong;             // total buffer size
    ulFlags           : uLong;             // flags
    ulTrackID         : uLong;             // track ID
    ulNumCODECs       : uLong;             // number of codec entries
    pCODECAssoc       : PCodecAssoc;       // pointer to codec info array
  end;
  pmmExtendInfo = ^mmExtendInfo;

const
  // MMEXTENDINFO operation (ulFlags) values.
  MMIO_TRACK                    = $00000001;
  MMIO_NORMAL_READ              = $00000002;
  MMIO_SCAN_READ                = $00000004;
  MMIO_REVERSE_READ             = $00000008;
  MMIO_CODEC_ASSOC              = $00000100;

// Audio Related defines

  MMIO_REALTIME_CODEC           = $00000200;

  MMIO_RESETTRACKS              = -1;       //  Turns off the active track number.

  CODEC_START                   = $0EC0;
  CODEC_END                     = $0EFF;

  MMIOM_CODEC_CLOSE             = CODEC_START + 1;
  MMIOM_CODEC_OPEN              = CODEC_START + 2;
  MMIOM_CODEC_QUERYNAME         = CODEC_START + 3;
  MMIOM_CODEC_QUERYNAMELENGTH   = CODEC_START + 4;
  MMIOM_CODEC_COMPRESS          = CODEC_START + 5;
  MMIOM_CODEC_DECOMPRESS        = CODEC_START + 6;

// End CODEC include

  // Flags:
  MMIO_CREATE                   = $00000001;       // Open
  MMIO_CTOCFIRST                = $00000002;       // Open
  MMIO_READ                     = $00000004;       // Open
  MMIO_WRITE                    = $00000008;       // Open
  MMIO_READWRITE                = $00000010;       // Open
  MMIO_COMPAT                   = $00000020;       // Open
  MMIO_EXCLUSIVE                = $00000040;       // Open
  MMIO_DENYWRITE                = $00000080;       // Open
  MMIO_DENYREAD                 = $00000100;       // Open
  MMIO_DENYNONE                 = $00000200;       // Open
  MMIO_ALLOCBUF                 = $00000400;       // Open
  MMIO_DELETE                   = $00000800;       // Open

  MMIO_USE_TEMP                 = $00001000;       // Open/Close/Save

  MMIO_INSERTON                 = $00000001;       // Insert
  MMIO_INSERTOFF                = $00000002;       // Insert

  MMIO_RWMODE                   = $00001000;       // Open
  MMIO_SHAREMODE                = $00002000;       // Open

  MMIO_DIRTY                    = $00004000;       // Write

  MMIO_VERTBAR                  = $00008000;       // Open
  MMIO_BUFSHARED                = $00010000;       // Open
  MMIO_APPEND                   = $00020000;       // Open
  MMIO_NOIDENTIFY               = $00040000;       // Open

  MMIO_FINDFIRST                = $00000001;       // CF Find Entry
  MMIO_FINDNEXT                 = $00000002;       // CF Find Entry
  MMIO_FINDUNUSED               = $00000004;       // CF Find Entry
  MMIO_FINDDELETED              = $00000008;       // CF Find Entry

  MMIO_CHANGEDELETED            = $0001;         // CF Change Entry

  MMIO_CF_FQNAME                = $0001;         // CF Compact

  MMIO_FHOPEN                   = $0001;           // Close

  MMIO_EMPTYBUF                 = $0001;           // Flush

  MMIO_CREATERIFF               = $0001;           // CreateChunk
  MMIO_CREATELIST               = $0002;           // CreateChunk
  MMIO_FINDCHUNK                = $0004;           // Descend
  MMIO_FINDRIFF                 = $0008;           // Descend
  MMIO_FINDLIST                 = $0010;           // Descend

  CTOC_HF_SEQUENTIAL            = $00000001;    // CTOC ulHeaderFlags
  CTOC_HF_MEDSUBTYPE            = $00000002;    // CTOC ulHeaderFlags

  CTOC_EFU_UNUSED               = $00000000; // CTOC extra usage code
  CTOC_EFU_LASTMODTIME          = $00000001; // CTOC extra usage code
  CTOC_EFU_CODEPAGE             = $00000002; // CTOC extra usage code
  CTOC_EFU_LANGUAGE             = $00000003; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM0       = $00000005; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM1       = $00000006; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM2       = $00000007; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM3       = $00000008; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM4       = $00000009; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM5       = $0000000A; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM6       = $0000000B; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM7       = $0000000C; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM8       = $0000000D; // CTOC extra usage code
  CTOC_EFU_COMPRESSPARAM9       = $0000000E; // CTOC extra usage code
  CTOC_CharSET_STANDARD         = $00000000; // CTOC charset value

  MMIO_INSTALLPROC              = $00000001; // Install IO Proc
  MMIO_REMOVEPROC               = $00000002; // Install IO Proc
  MMIO_FINDPROC                 = $00000004; // Install IO Proc

  MMIO_MATCHFIRST               = $00000010; // Ini File Handler
  MMIO_MATCHNEXT                = $00000020; // Ini File Handler
  MMIO_MATCHFourCC              = $00000040; // Ini File Handler
  MMIO_MATCHDLL                 = $00000080; // Ini File Handler
  MMIO_MATCHPROCEDURENAME       = $00000100; // Ini File Handler
  MMIO_FULLPATH                 = $00000200; // Ini File Handler
  MMIO_NOVERIFY                 = $00000400; // Ini File Handler
  MMIO_MATCHCOMPRESSTYPE        = $00000800; // Ini File Handler
  MMIO_EXTENDED_STRUCT          = $00001000; // Ini File ulFlags
  MMIO_MATCHCOMPRESSSUBTYPE     = $00002000; // Ini File Handler
  MMIO_MATCHHWID                = $00004000; // Ini File Handler
  MMIO_MATCHCAPSFLAGS           = $00008000; // Ini File Handler
  MMIO_SKIPMATCH                = $00010000; // Ini/Load Handler

  MMIO_TOUPPER                  = $0001;      // StringToFourcc

  MMIO_CF_ENTRY_EXISTS          = $00000001; // Add CGRP element

  MMIO_FORCE_IDENTIFY_SS        = $00000001; // Identify
  MMIO_FORCE_IDENTIFY_FF        = $00000002; // Identify

  MMIO_NOTRANSLATE              = $00000000; // Translation
  MMIO_TRANSLATEDATA            = $00000001; // Translation
  MMIO_TRANSLATEHEADER          = $00000002; // Translation
  MMIO_DECOMPRESS               = $00000004; // CODEC Decompress

  MMIO_DEFAULTBUFFER            = 8192;    // two pages under OS/2 2.0

  MMIO_SEEK_IFRAME              = $00010000;  // Seek to nearest previous IFRAME

  // Messages :
  MMIOM_START                   = $0E00;
  MMIOM_END                     = $0EFF;

  MMIOM_GETCF                   = MMIOM_START + 1;
  MMIOM_GETCFENTRY              = MMIOM_START + 2;

  MMIOM_CLOSE                   = MMIOM_START + 3;
  MMIOM_OPEN                    = MMIOM_START + 4;
  MMIOM_READ                    = MMIOM_START + 5;
  MMIOM_SEEK                    = MMIOM_START + 6;
  MMIOM_WRITE                   = MMIOM_START + 7;

  MMIOM_IDENTIFYFILE            = MMIOM_START + 8;
  MMIOM_GETHEADER               = MMIOM_START + 9;
  MMIOM_SETHEADER               = MMIOM_START + 10;
  MMIOM_QUERYHEADERLENGTH       = MMIOM_START + 11;
  MMIOM_GETFORMATNAME           = MMIOM_START + 12;
  MMIOM_GETFORMATINFO           = MMIOM_START + 13;
  MMIOM_SEEKBYTIME              = MMIOM_START + 14;
  MMIOM_TEMPCHANGE              = MMIOM_START + 15;
  MMIOM_BEGININSERT             = MMIOM_START + 16;
  MMIOM_ENDINSERT               = MMIOM_START + 17;
  MMIOM_SAVE                    = MMIOM_START + 18;
  MMIOM_SET                     = MMIOM_START + 19;
  MMIOM_COMPRESS                = MMIOM_START + 20;
  MMIOM_DECOMPRESS              = MMIOM_START + 21;
  MMIOM_MULTITRACKREAD          = MMIOM_START + 22;
  MMIOM_MULTITRACKWRITE         = MMIOM_START + 23;
  MMIOM_DELETE                  = MMIOM_START + 24;
  MMIOM_BEGINGROUP              = MMIOM_START + 25;
  MMIOM_ENDGROUP                = MMIOM_START + 26;
  MMIOM_UNDO                    = MMIOM_START + 27;
  MMIOM_REDO                    = MMIOM_START + 28;
  MMIOM_BEGINSTREAM             = MMIOM_START + 29;
  MMIOM_ENDSTREAM               = MMIOM_START + 30;


  MMIOM_CUT                     = MMIOM_START + 31;
  MMIOM_COPY                    = MMIOM_START + 32;
  MMIOM_PASTE                   = MMIOM_START + 33;
  MMIOM_CLEAR                   = MMIOM_START + 34;
  MMIOM_STATUS                  = MMIOM_START + 35;
  MMIOM_WINMSG                  = MMIOM_START + 36;
  MMIOM_BEGINRECORD             = MMIOM_START + 37;
  MMIOM_ENDRECORD               = MMIOM_START + 38;


  // These 3 new messages were added with feature 11710
  MMIOM_QUERYIMAGE              = MMIOM_START + 39;
  MMIOM_QUERYIMAGECOUNT         = MMIOM_START + 40;
  MMIOM_SETIMAGE                = MMIOM_START + 41;


  MMIO_REALTIME                 = $00000001;
  MMIO_NONREALTIME              = $00000002;

  MMIOM_USER                    = $0F00;
  MMIOM_USER_END                = $0FFF;

type
  // Parameter structure for MMIOM_STATUS
  mmIO_Status_Parms = record
    hwndWindow        : hwnd;                  // Some items require a window handle
    ulReturn          : uLong;                 // Return field
    ulItem            : uLong;                 // Use MCI_STATUS_... flags here
    ulValue           : uLong;                 // Status value field
    ulType            : uLong;                 // MCI_FORMAT_... of ulReturn
  end;
  pmmIO_Status_Parms = ^mmIO_Status_Parms;

// Parameter structure for MMIOM_COPY, MMIOM_CUT, MMIOM_CLEAR and MMIOM_PASTE

  uSec = Long;                                 // microsecond time format

  mmIO_mEdit_Parms = record
    ulStrucLen        : uLong;                 // length of this structure
    hwndWindow        : hwnd;                  // window handle
    ulStartTime       : uSec;                  // starting time in usec
    ulDuration        : uSec;                  // duration in usec
    ulCurrentFilePosition : uLong;             // current file position in usec
    ulNewFilePosition : uLong;                 // returned by IO proc in usec, MCD will issue a seek
    ulNewFileLength   : uLong;                 // return by IO proc in usec, MCD updates its headers
    pBuffer           : Pointer;               // optional buffer
    ulBufferLength    : uLong;                 // optional buffer's length
    pHeader           : Pointer;               // optional pointer to header for buffer
  end;
  pmmIO_mEdit_Parms = ^mmIO_mEdit_Parms;

  // Parameter structure for MMIOM_WIN_MESSAGE
  mmIO_WinMsg = record
    hwndWindow        : hwnd;                  // these are the parameters
    usMessage         : uShort;                //  ... passed to the
    pParam1           : Pointer;               //  ... window procedure
    pParam2           : Pointer;               //  ... by PM
  end;
  pmmIO_WinMsg = ^mmIO_WinMsg;

const
  // Include error codes for MMIO
  MMIO_SUCCESS                  = 0;
  MMIO_WARNING                  = 2;
  MMIO_ERROR                    = -1;
  MMIOERR_UNSUPPORTED_MESSAGE   = -2;

  MMIO_CF_SUCCESS               = 0;
  MMIO_CF_FAILURE               = 1;

function mmioFourCC( ch0, ch1, ch2, ch3: Char ): uLong; inline;
begin
  Result := ord(ch0) or (ord(ch1) shl 8) or
            (ord(ch2) shl 16) or (ord(ch3) shl 24);
end;

const
  // FourCCs will be initialized in Initialization section
  FourCC_RIFF                   : FourCC = 0;
  FourCC_LIST                   : FourCC = 0;
  FourCC_MEM                    : FourCC = 0;
  FourCC_DOS                    : FourCC = 0;
  FourCC_BND                    : FourCC = 0;
  FourCC_FREE                   : FourCC = 0;
  FourCC_DEL                    : FourCC = 0;
  FourCC_CTOC                   : FourCC = 0;
  FourCC_CGRP                   : FourCC = 0;
  FourCC_CF                     : FourCC = 0;

const
  MMIO_NLS_CharSET_INFO         = 8000;   // RCDATA Name ID for NLS
  MMIO_IOPROC_NAME_TABLE        = 8500;   // RCDATA Name ID for string table
  MMIO_CODEC_NAME_TABLE         = 9000;   // RCDATA Name ID for Codec  table

  // Numeric equivalents of fourcc's.  These are needed for the resource
  // compiler.
  HEX_FourCC_DOS                = $20534f44;
  HEX_FourCC_MEM                = $204d454d;
  HEX_FourCC_BND                = $20444e42;
  HEX_FourCC_CF                 = $20204643;

  // Country codes (CC), languages (LC), and dialects (DC).
  MMIO_DEFAULT_CODE_PAGE        = 437;

  MMIO_CC_NONE                  = 000;
  MMIO_CC_USA                   = 001;
  MMIO_CC_CANADA                = 002;
  MMIO_CC_LATIN_AMERICA         = 003;
  MMIO_CC_GREECE                = 030;
  MMIO_CC_NETHERLANDS           = 031;
  MMIO_CC_BELGIUM               = 032;
  MMIO_CC_FRANCE                = 033;
  MMIO_CC_SPAIN                 = 034;
  MMIO_CC_ITALY                 = 039;
  MMIO_CC_SWITZERLAND           = 041;
  MMIO_CC_AUSTRIA               = 043;
  MMIO_CC_UNITED_KINGDOM        = 044;
  MMIO_CC_DENMARK               = 045;
  MMIO_CC_SWEDEN                = 046;
  MMIO_CC_NORWAY                = 047;
  MMIO_CC_WEST_GERMANY          = 049;
  MMIO_CC_MEXICO                = 052;
  MMIO_CC_BRAZIL                = 055;
  MMIO_CC_AUSTRALIA             = 061;
  MMIO_CC_NEW_ZEALAND           = 064;
  MMIO_CC_JAPAN                 = 081;
  MMIO_CC_KOREA                 = 082;
  MMIO_CC_CHINA                 = 086;
  MMIO_CC_TAIWAN                = 088;
  MMIO_CC_TURKEY                = 090;
  MMIO_CC_PORTUGAL              = 351;
  MMIO_CC_LUXEMBOURG            = 352;
  MMIO_CC_ICELAND               = 354;
  MMIO_CC_FINLAND               = 358;

  MMIO_LC_NONE                  = 0;
  MMIO_DC_NONE                  = 0;
  MMIO_LC_ARABIC                = 1;
  MMIO_DC_ARABIC                = 1;
  MMIO_LC_BULGARIAN             = 2;
  MMIO_DC_BULGARIAN             = 1;
  MMIO_LC_CATALAN               = 3;
  MMIO_DC_CATALAN               = 1;
  MMIO_LC_TRADITIONAL_CHINESE   = 4;
  MMIO_DC_TRADITIONAL_CHINESE   = 1;
  MMIO_LC_SIMPLE_CHINESE        = 4;
  MMIO_DC_SIMPLE_CHINESE        = 2;
  MMIO_LC_CZECH                 = 5;
  MMIO_DC_CZECH                 = 1;
  MMIO_LC_DANISH                = 6;
  MMIO_DC_DANISH                = 1;
  MMIO_LC_GERMAN                = 7;
  MMIO_DC_GERMAN                = 1;
  MMIO_LC_SWISS_GERMAN          = 7;
  MMIO_DC_SWISS_GERMAN          = 2;
  MMIO_LC_GREEK                 = 8;
  MMIO_DC_GREEK                 = 1;
  MMIO_LC_US_ENGLISH            = 9;
  MMIO_DC_US_ENGLISH            = 1;
  MMIO_LC_UK_ENGLISH            = 9;
  MMIO_DC_UK_ENGLISH            = 2;
  MMIO_LC_SPANISH               = 10;
  MMIO_DC_SPANISH               = 1;
  MMIO_LC_SPANISH_MEXICAN       = 10;
  MMIO_DC_SPANISH_MEXICAN       = 2;
  MMIO_LC_FINNISH               = 11;
  MMIO_DC_FINNISH               = 1;
  MMIO_LC_FRENCH                = 12;
  MMIO_DC_FRENCH                = 1;
  MMIO_LC_BELGIAN_FRENCH        = 12;
  MMIO_DC_BELGIAN_FRENCH        = 2;
  MMIO_LC_CANADIAN_FRENCH       = 12;
  MMIO_DC_CANADIAN_FRENCH       = 3;
  MMIO_LC_SWISS_FRENCH          = 12;
  MMIO_DC_SWISS_FRENCH          = 4;
  MMIO_LC_HEBREW                = 13;
  MMIO_DC_HEBREW                = 1;
  MMIO_LC_HUNGARIAN             = 14;
  MMIO_DC_HUNGARIAN             = 1;
  MMIO_LC_ICELANDIC             = 15;
  MMIO_DC_ICELANDIC             = 1;
  MMIO_LC_ITALIAN               = 16;
  MMIO_DC_ITALIAN               = 1;
  MMIO_LC_SWISS_ITALIAN         = 16;
  MMIO_DC_SWISS_ITALIAN         = 2;
  MMIO_LC_JAPANESE              = 17;
  MMIO_DC_JAPANESE              = 1;
  MMIO_LC_KOREAN                = 18;
  MMIO_DC_KOREAN                = 1;
  MMIO_LC_DUTCH                 = 19;
  MMIO_DC_DUTCH                 = 1;
  MMIO_LC_BELGIAN_DUTCH         = 19;
  MMIO_DC_BELGIAN_DUTCH         = 2;
  MMIO_LC_NORWEGIAN_BOKMAL      = 20;
  MMIO_DC_NORWEGIAN_BOKMAL      = 1;
  MMIO_LC_NORWEGIAN_NYNORSK     = 20;
  MMIO_DC_NORWEGIAN_NYNORSK     = 2;
  MMIO_LC_POLISH                = 21;
  MMIO_DC_POLISH                = 1;
  MMIO_LC_BRAZILIAN_PORTUGUESE  = 22;
  MMIO_DC_BRAZILIAN_PORTUGUESE  = 1;
  MMIO_LC_PORTUGUESE            = 22;
  MMIO_DC_PORTUGUESE            = 2;
  MMIO_LC_RHAETO_ROMANIC        = 23;
  MMIO_DC_RHAETO_ROMANIC        = 1;
  MMIO_LC_ROMANIAN              = 24;
  MMIO_DC_ROMANIAN              = 1;
  MMIO_LC_RUSSIAN               = 25;
  MMIO_DC_RUSSIAN               = 1;
  MMIO_LC_SERBO_CROATIAN_LATIN  = 26;
  MMIO_DC_SERBO_CROATIAN_LATIN  = 1;
  MMIO_LC_SERBO_CROATIAN_CYRILLIC = 26;
  MMIO_DC_SERBO_CROATIAN_CYRILLIC = 2;
  MMIO_LC_SLOVAK                = 27;
  MMIO_DC_SLOVAK                = 1;
  MMIO_LC_ALBANIAN              = 28;
  MMIO_DC_ALBANIAN              = 1;
  MMIO_LC_SWEDISH               = 29;
  MMIO_DC_SWEDISH               = 1;
  MMIO_LC_THAI                  = 30;
  MMIO_DC_THAI                  = 1;
  MMIO_LC_TURKISH               = 31;
  MMIO_DC_TURKISH               = 1;
  MMIO_LC_URDU                  = 32;
  MMIO_DC_URDU                  = 1;
  MMIO_LC_BAHASA                = 33;
  MMIO_DC_BAHASA                = 1;

// Base function prototypes:

function mmioAdvance( mmIO: hmmio; Info: pmmioinfo; usFlags: uShort ): uShort;
function mmioAscend( mmIO: hmmio; pckinfo: pmmCkInfo; usFlags: uShort ): uShort;
function mmioClose( mmIO: hmmio; usFlags: uShort ): uShort;
function mmioCreateChunk( mmio: hmmio; pckinfo: pmmCkInfo; usFlags: uShort ): uShort;
function mmioDescend( mmIO: hmmio; pckinfo, pckinfoParent: pMMCkInfo; usFlags: uShort ): uShort;
function mmioFlush( mmIO: hmmio; usFlags: uShort ): uShort;
function mmioGetInfo( mmIO: hmmio; Info: pmmioinfo; usFlags: uShort ): uShort;
function mmioGetLastError( mmIO: hmmio ): uLong;
function mmioInstallIOProc( fccIOProc: FourCC; pIOProc: pMMIOProc; ulFlags: uLong ): pmmIOProc;
function mmioIOProc( mmIOInfo: pMMioInfo; usMsg: uShort; lParam1, lParam2: Long): Long;
function mmioOpen( pszFileName: pChar; mmIOInfo: pmmioinfo; ulOpenFlags: uLong ): hMMIO;
function mmioRead( mmIO: hmmio; pchBuffer: pChar; cBytes: Long ): Long;
function mmioSeek( mmIO: hmmio; lOffset, lOrigin: Long ): Long;
function mmioSendMessage( mmIO: hmmio; usMsg: uShort; lParam1, lParam2: Long ): Long;
function mmioSetBuffer( mmIO: hmmio; pchBuffer: pChar; cBytes: Long; usFlags: uShort ): uShort;
function mmioSetInfo( mmIO: hmmio; mmIOInfo: pmmioinfo; usFlags: uShort ): uSHort;
function mmioStringToFourCC( pszString: pChar; usFlags: uShort ): FourCC;
function mmioWrite( mmIO: hmmio; pchBuffer: pChar; cBytes: Long ): Long;

// Compound File function prototypes:

function mmioCFOpen( pszFileName: pChar; CfInfo, IOInfo: pmmcfinfo; ulFlags: uLong ): hMMCF;
function mmioCFClose( mmCf: hmmcf; ulFlags: uLong ): uLong;
function mmioCFGetInfo( mmCf: hmmcf; CfInfo: pmmcfinfo; cBytes: uLong ): uLong;
function mmioCFSetInfo( mmCf: hmmcf; CfInfo: pmmcfinfo; cBytes: uLong ): uLong;
function mmioCFFindEntry( mmCf: hmmcf; ctocEntry: mmctocentry; ulFlags: uLong ): uLong;
function mmioCFAddEntry( mmCf: hmmcf; cTocEntry: mmctocentry; ulFlags: uLong ): uLong;
function mmioCFChangeEntry( mmCf: hmmcf; CTocEntry: pmmctocentry; ulFlags: uLong ): uLong;
function mmioCFDeleteEntry( mmCf: hmmcf; CTocEntry: pmmctocentry; ulFlags: uLong ): uLong;
function mmioCFAddElement( mmCf: hmmcf; pszElementName: pChar; fccType: FourCC;
  pchBuffer: pChar; cchBytes: Long; ulFlags: uLong ): uLong;

function mmioCFCopy( mmCfSource: hmmcf; pszDestFileName: pChar; ulFlags: uLong ): uLong;

// Conversion Utility function prototypes:

function mmioQueryFormatCount( FormatInfo: pmmformatinfo;
  plNumFormats: pLong; ulReserved: uLong; ulFlags: uLong ): uLong;

function mmioGetFormats( FormatInfo: pmmformatinfo;
  lNumFormats: Long; pFormatInfoList: Pointer; plFormatsRead: pLong;
  ulReserved: uLong; ulFlags: uLong ): uLong;

function mmioGetFormatName( FormatInfo: pmmformatinfo; pszFormatName: pChar;
  plBytesRead: pLong; ulReserved: uLong; ulFlags: uLong ): uLong;

function mmioIdentifyFile( pszFileName: pChar; MMIoInfo: pmmioinfo;
  FormatInfo: pmmformatinfo; pfccStorageSystem: pFourCC; ulReserved: uLong;
  ulFlags: uLong ): uLong;

function mmioQueryHeaderLength( mmIO: hmmio; plHeaderLength: pLong;
  ulReserved: uLong; ulFlags: uLong ): uLong;

function mmioGetHeader( mmIO: hmmio; pHeader: Pointer; lHeaderLength: Long;
  plBytesRead: pLong; ulReserved: uLong; ulFlags: uLong ): uLong;

function mmioSetHeader( mmIO: hmmio; pHeader: Pointer; lHeaderLength: Long;
  plBytesWritten: pLong; ulReserved: uLong; ulFlags: uLong ): uLong;

function mmioIniFileHandler( IniFileInfo: pmminifileinfo; ulFlags: uLong ): uLong;

function mmioIdentifyStorageSystem( pszFileName: pChar;
  MMIoInfo: pmmioinfo; pfccStorageSystem: pFourCC ): uLong;

function mmioDetermineSSIOProc( pszFileName: pChar; MMIoInfo: pmmioinfo;
  pfccStorageSystem: pFourCC; pszParsedRemainder: pChar ): uLong;

function mmioQueryIOProcModuleHandle( IOProc: pMMIOProc;
  IOProcModule: phModule ): uLong;

function mmioCFCompact( pszFileName: pChar; ulFlags: uLong ): uLong;

// MMPMMMIO.INI file migration utility

function mmioMigrateIniFile( ulFlags: uLong ): uLong;

// MMIO CODEC APIs

function mmioIniFileCODEC( IniFile: pCODECIniFileInfo; ulFlags: uLong ): uLong;
function mmioSet( mmIO: hmmio; ExtendInfo: pmmExtendInfo; ulFlags: uLong): uLong;
function mmioQueryCODECName( IniInfo: pCODECIniFileinfo;
  pszCODECName: pChar; pulBytesRead: pUlong ): uLong;

function mmioQueryCODECNameLength( IniInfo: pCODECIniFileinfo;
  pulNameLength: pUlong ): uLong;

function mmioLoadCODECProc( IniInfo: pCODECIniFileInfo;
  Module: phModule; ulFlags: uLong ): pCodecProc;

function mmioGetData( mmIO: hmmio; mmIOInfo: pmmioinfo; usFlags: uShort ): uShort;

{----[ CODEC ]----}

const
  // Ultimotion CODEC type for CODECINIFILEINFO ulCompressType
  FOURCC_ULTI                   : FourCC = 0;
  HEX_FOURCC_ULTI               = $49544C55;    // ITLU

// Indeo CODEC type for CODECINIFILEINFO ulCompressType
  FOURCC_RT21                   : FourCC = 0;
  HEX_FOURCC_RT21               = $31325452;     // 12TR

  // Mondo CODEC type for CODECINIFILEINFO ulCompressType
  FOURCC_DIB                    : FourCC = 0;
  HEX_FOURCC_DIB                = $20424944;     //  BID

type
  // GENPAL - Generic Header Palette
  GenPal = record
    ulStartIndex      : uLong;                 // starting RGB index
    ulNumColors       : uLong;                 // number of following entries
    prgb2Entries      : pRGB2;                 // 256 RGB entries
  end;
  pGenPal = ^GenPal;

  // CODECVIDEOHEADER - CODEC video Header
  CodecVideoHeader = record
    ulStructLen       : uLong;
    cx                : uLong;
    cy                : uLong;
    cPlanes           : uShort;
    cBitCount         : uShort;
    ulColorEncoding   : uLong;
    genpal            : GenPal;
  end;
  pCodecVideoHeader = ^CodecVideoHeader;

const
  // ulColorEncoding defines:
  MMIO_RGB_5_6_5                = $0001;  // Each pixel is a RGB_5_6_5 datatype
  MMIO_RGB_24                   = $0002;  // Each pixel is a RGB_24 datatype
  MMIO_YUV_4_1_1                = $0004;  // Each pixel is a YUV_4_1_1 datatype
  MMIO_COMPRESSED               = $0008;  // The data is compressed
  MMIO_YUV_24                   = $0010;  // Each pixel is a YUV_24 datatype
  MMIO_PALETTIZED               = $0020;  // The data is palettized
  MMIO_OS2_BITMAP24             = $0020;  // The data is palettized


{*********************************************
 *
 * MMVIDEOOPEN - Video Open Structure
 *
 * This structure is passed on the CODEC open
 * message when video compression is being done
 * to indicate information such as quality,
 * frame rate, data rate, and key frame rate.
 *
 * Quality:
 *
 * The ulQuality field specifies a scalar value
 * in the range 0 - 10000, where 0 is the lowest
 * quality and 10000 is the highest quality.  A
 * value of -1 specifies the default quality level,
 * and the default quality level (e.g. 5000) is
 * returned in the ulQuality field.
 *
 *
 * Key Frame rate:
 *
 * The ulKeyFrameRate structure specifies the key
 * frame (aka I-frame, reference frame) frequency.
 * Every Nth frame is a key frame as specified.
 * A value of zero specifies that no periodic key
 * are to be compressed.  Additional key frames may
 * be inserted at any point by specifying
 * MMIO_IS_KEY_FRAME in the MMCOMPRESS structure.
 *
 * example:  ulKeyFrameRate = 5  results in:
 *
 *    key delta delta delta delta key delta delta delta delta key delta...
 *
 *
 * Frame rate:
 *
 * Rate = number of time units per second
 * Scale = number of time units per frame
 *
 * examples:  Rate = 30  Scale = 1     =>    30 FPS
 *            Rate = 15  Scale = 1     =>    15 FPS
 *            Rate = 25  Scale = 2     =>    12.5 FPS
 *
 *
 * Data Constraint:
 *
 * Compressors which are capable of constraining the
 * resultant compressed video data rate use the
 * information in the ulDataConstraint and
 * ulConstraintInterval fields.  A non-zero value
 * in ulDataConstraint specifies the number of bytes
 * which is not to be exceeded over an interval of
 * frames in the output data stream, regardless of
 * the requested quality level.  This value only
 * considers video data, i.e. audio data and file format
 * overhead must be considered seperately when determining
 * the final output file data rate.  The interval of
 * frames over which the data is constrained is specified
 * in ulConstraintInterval.  A value of zero for
 * ulDataContraint specifies that the data rate is not
 * to be constrained and is compressed according to
 * the requested quality level.
 *
 * example 1:  ulDataConstraint = 150000   ulConstraintInterval = 15
 *
 *             This results in an output stream wherein the sizes of any 15
 *             consecutive frames does not exceed 150000 bytes.  If the
 *             frame rate is 15 FPS, the resultant data rate will not
 *             exceed 150000 bytes per second.
 *
 * example 2:  ulDataConstraint = 10000    ulConstraintInterval = 1
 *
 *             This results in an output stream wherein any single frame
 *             does not exceed 10000 bytes.  If the frame rate is 15 FPS,
 *             the resultant data rate will not exceed 150000 bytes per
 *             second.  Note the difference between this case and example 1
 *             where individual frames may exceed 10000 bytes (the average)
 *             so long other frames in any 15 frame sequence are sufficiently
 *             smaller to satisfy the constraint within the constraint interval.
 *
 *********************************************}

type
  mmVideoOpen = record
    ulStructLen          : uLong;
    ulQuality            : uLong;
    ulKeyFrameRate       : uLong;
    ulScale              : uLong;
    ulRate               : uLong;
    ulDataConstraint     : uLong;
    ulConstraintInterval : uLong;
  end;
  pmmVideoOpen = ^mmVideoOpen;

  mmAudioOpen = record
    ulStructLen          : uLong;              // Length of struct
    ulSamplesPerBlock    : uLong;              // Samples in each block of compressed data
    ulBytesPerBlock      : uLong;              // uncompressed bytes in each block
    ulFlags              : uLong;              // Compression flags
    ulBestGuess          : uLong;              // Guess at avg. compression ratio
    ulBlockAlignment     : uLong;              // Block alignment of codec
    ulLength             : uLong;              // Length of the file
    hCodec               : uLong;              // Codec handle
    pfnCodec             : PCODECPROC;
  end;
  pmmAudioOpen = ^mmAudioOpen;

const
  // defines for the ulFlags field of the BUFER_INFORMATION
  BLOCK_ORIENTED                = $00000001;
  NON_LINEAR                    = $00000002;
  INIT_CODEC                    = $00000004;

type
  // CODECOPEN - CODEC open structure
  CodecOpen = record
    ulFlags           : uLong;                 // flags & events - Refer to ulCapsFlags in CODECINIFILEINFO
    pControlHdr       : Pointer;               // control header - (codec specific)
    pSrcHdr           : Pointer;               // source header - Ptr CODECVIDEOHEADER
    pDstHdr           : Pointer;               // destination header - Ptr CODECVIDEOHEADER
    pOtherInfo        : Pointer;               // other information - Ptr MMVIDEOOPEN/MMAUDIOOPEN
  end;
  pCodecOpen = ^CodecOpen;

const
  Valid_CodecOpen_InputFlags = CODEC_DECOMPRESS or
                               CODEC_WINDOW_CLIPPING or
                               CODEC_PALETTE_TRANS or
                               CODEC_SELFHEAL or
                               CODEC_SCALE_PEL_DOUBLE or
                               CODEC_SCALE_PEL_HALVED or
                               CODEC_SCALE_CONTINUOUS or
                               CODEC_MULAPERTURE or
                               CODEC_HARDWARE or
                               CODEC_DIRECT_DISPLAY;

type
  // Stream handler communication
  Audio_Codec_Info = record
    ulStructLen       : uLong;       // Length of struct
    ulBytesPerBlock   : uLong;       // uncompressed bytes in each block
    ulBlockAlignment  : uLong;       // Block alignment of codec
    hCodec            : uLong;       // Codec handle
    pfnCodec          : PCODECPROC;  //  LONG (* APIENTRY pfnCodec) (Pointer, SHORT, LONG, LONG);
  end;

const
  AUDIO_CODEC_INF               = 1000;

type
  // MMCOMPRESS - Compress structure
  mmCompress = record
    ulStructLen       : uLong;                 // length of this structure
    ulFlags           : uLong;                 // command and status flags
    ulSrcBufLen       : uLong;                 // source buffer size
    pSrcBuf           : Pointer;               // source buffer
    ulDstBufLen       : uLong;                 // destination buffer length
    pDstBuf           : Pointer;               // destination buffer
    pRunTimeInfo      : Pointer;               // control information
  end;
  pmmCompress = ^mmCompress;

// ulFlags Input values for MMCOMPRESS structure:
// Note:  MMIO_IS_KEY_FRAME and MMIO_IS_PALETTE are defined
// below, but are listed here for information purposes only.
// MMIO_IS_KEY_FRAME         This bit is set by the application
//                           to instruct the IOProc to compress
//                           the pSrcBuf into a key or reference
//                           frame.  If the bit is not set, a
//                           delta frame is compressed.
// MMIO_IS_PALETTE           A video palette is provided.  This
//                           is set by the application.

type
  // MMVIDEOCOMPRESS - Video Compress structure
  mmVideoCompress = record
    ulStructLen       : uLong;                 // Structure length
    genpalVideo       : GENPAL;                // Video stream palette
    pControlHdr       : Pointer;               // control header (codec specific)
  end;
  pmmVideoCompress = ^mmVideoCompress;

const
  START_DECOMPRESSION           = $00000001;
  CONTINUE_DECOMPRESSION        = $00000002;
  START_SEEK                    = $00000004;
  CONTINUE_SEEK                 = $00000008;

type
  //MMDECOMPRESS - Decompress Structure
  mmDecompress = record
    ulStructLen       : uLong;                 // length of this structure
    ulFlags           : uLong;                 // command and status flags
    ulSrcBufLen       : uLong;                 // source buffer size
    pSrcBuf           : Pointer;               // source buffer
    ulDstBufLen       : uLong;                 // destination buffer length
    pDstBuf           : Pointer;               // destination buffer
    pRunTimeInfo      : Pointer;               // control information Ptr to MMVIDEODECOMPRESS
  end;
  pmmDecompress = ^mmDecompress;

const
  // ulFlags defines:
  MMIO_DROP_DELTA_FRAME         = $0001; // Input/Output - Tells the IOProc to drop the delta
                                         // frame if the pSrcBuf contains a delta
                                         // frame.  On return, the bit is reset
                                         // if the delta frame is dropped.
  MMIO_IS_KEY_FRAME             = $0002; // Output - This bit is set by the IOProc when
                                         // the data contained in the pSrcBuf is
                                         // a key or reference frame.
  MMIO_IS_PALETTE               = $0004; // Output - A video palette has been found.
                                         // This is set by the IOProc.
  MMIO_PALETTE_CHANGE           = $0008; // Input - The physical palette has been changed
                                         // in...  This is set by the application.
  MMIO_ORIGIN_LOWERLEFT         = $0010; // Input - The video frame origin
  MMIO_RECTL_CHANGE             = $0020; // Input - The valid rectl list has changed.
  MMIO_ORIGIN_UPPERLEFT         = $0040; // Input - The video frame origin
  MMIO_DROP_FRAME_DECODE        = $0080; // Input - Tells the IOProc to drop decoding
  MMIO_HIGH_QUALITY             = $0100; // Input - Tells Codec to render best
                                         // quality image - not time critical
  MMIO_IGNORE_CLIPPING          = $0200; // Ignore clipping rectangles used for bitmap capture
                                         // high performance
  MMIO_OUTPUT_FULL_IMAGE        = $0400; // Output a complete image on decompress, even if this
                                         // is a delta frame
                                         // of the frame.

  VALID_DECOMPRESS_INPUTFLAGS   = MMIO_DROP_DELTA_FRAME or
                                  MMIO_PALETTE_CHANGE or
                                  MMIO_ORIGIN_LOWERLEFT or
                                  MMIO_RECTL_CHANGE or
                                  MMIO_DROP_FRAME_DECODE or
                                  MMIO_ORIGIN_UPPERLEFT or
                                  MMIO_HIGH_QUALITY or
                                  MMIO_IGNORE_CLIPPING or
                                  MMIO_OUTPUT_FULL_IMAGE;

  START_COMPRESSION             = $00000001;
  CONTINUE_COMPRESSION          = $00000002;
  SOURCE_UNUSED                 = $00000004;
  TARGET_UNUSED                 = $00000008;

type
  // MMVIDEODECOMPRESS - Video Decompress structure
  mmVideoDeCompress = record
    ulStructLen       : uLong;                 // Structure length
    ulRectlCount      : uLong;                 // Valid rectangle count - for clipping
    prectl            : pRectL;                // Valid rectangle array - for clipping
    ulSkipLength      : uLong;                 // Skipped line length
    ulDecodeLines     : uLong;                 // Num of lines to decompress
    genpalPhysical    : GenPal;                // Physical palette
    genpalVideo       : GenPal;                // Video stream palette
    rectlSrc          : RectL;                 // Source window rectangle
    rectlDst          : RectL;                 // Destination window rectangle
    ulDeltaCount      : uLong;                 // Number of remaining delta frames before the next I-Frame
    ulParm1           : uLong;                 // Codec specific parm
    ulParm2           : uLong;                 // Codec specific parm
    ulParm3           : uLong;                 // Codec specific parm
    ulParm4           : uLong;                 // Codec specific parm
  end;
  pmmVideoDeCompress = ^mmVideoDeCompress;

// RECORDTAB - Record table
// NOTE: This structure maps to ESRCBUFTAB
  RecordTab = record
    ulReserved1       : uLong;                 // reserved for system
    pRecord           : Pointer;               // ptr to record in buffer
    ulLength          : uLong;                 // length of record
    ulReserved2       : uLong;                 // reserved for system
    ulReserved3       : uLong;                 // reserved for system
    ulParm1           : uLong;                 // Record specific data
    ulParm2           : uLong;                 // Record specific data
  end;
  pRecordTab = ^RecordTab;

// RECORDTABWRITE - Record table for video write
// NOTE: This structure maps to ETGTBUFTAB
  RecordTabWrite = record
    pRecord           : Pointer;               // ptr to record in buffer
    ulReserved1       : uLong;                 // reserved for system
    ulLength          : uLong;                 // length of record
    ulReserved2       : uLong;                 // reserved for system
    ulReserved3       : uLong;                 // reserved for system
    ulParm1           : uLong;                 // Record specific data
    ulParm2           : uLong;                 // Record specific data
  end;
  pRecordTabWrite = ^RecordTabWrite;

const
  // ulParm1 Return values for MULTITRACK_READ only:
  // Note:  MMIO_IS_KEY_FRAME and MMIO_IS_PALETTE are defined
  // above, but are listed here for information purposes only
  // as they are valid ulParm1 Return values for MULTITRACK_READ.
  // MMIO_IS_KEY_FRAME         Frame is a Key frame
  // MMIO_IS_PALETTE           Buffer contains a video palette
  MMIO_INVISIBLE_FRAME          = $1000;       // Indicates a invisible video frame
  MMIO_NULL_FRAME               = $2000;       // Indicates a null video frame (zero length)

  // ulParm2 Return values for MULTITRACK_READ only:
  //    This field contains the frame number for this video frame
  //    if this track is a video track.

  // ulParm1 Input values for MULTITRACK_WRITE only:
  // Note:  MMIO_IS_KEY_FRAME and MMIO_IS_PALETTE are defined
  // above, but are listed here for information purposes only
  // as they are valid ulParm1 Input values for MULTITRACK_WRITE.
  // MMIO_IS_KEY_FRAME         Frame is a Key frame
  // MMIO_IS_PALETTE           Buffer contains a video palette

  // ulParm2 Input values for MULTITRACK_WRITE only:
  //    This field contains the number of null frames
  //    that should be inserted before this frame
  //    (this recordtab entry).

type
  // TRACKMAP - This structure maps a track to a record table.
  TrackMap = record
    ulTrackID         : uLong;                 // Input - track ID
    ulNumEntries      : uLong;                 // Input - number of record entries
    pRecordTabList    : pRecordTab;            // Input/Output - Ptr to a record table
  end;
  pTrackMap = ^TrackMap;

  // MMMULTITRACKREAD - Multiple Track Read
  mmMultiTrackRead = record
    ulLength          : uLong;                 // Input - Size of buffer to read.  The IO should be performed on this size of
                                               //          buffer.  The actual buffer size may be bigger and is given in the
                                               //          ulBufferLength field below.  Video frames can span pBuffer+ulLength
                                               //          as long as the frame is less than the ulBufferLength in size.
                                               //          The purpose of this is to break the IO reads into smaller sizes
                                               //          while still allowing large frame sizes.
    pBuffer           : Pointer;               // Input - ptr to read buffer
    ulFlags           : uLong;                 // Input/Output - read flags
    ulNumTracks       : uLong;                 // Input - number of track entries
    pTrackMapList     : pTrackMap;             // Input - ptr to track-to-record list
    ulBufferLength    : uLong;                 // Input - Actual length of read buffer
    ulReserved        : uLong;                 // Input - Reserved (must be 0)
  end;
  pmmMultiTrackRead = ^mmMultiTrackRead;

const
  // ulFlags Input Values:
  MULTITRACKREAD_EXTENDED       = $0004;       // Indicates that the new extended multitrack
                                               // read structure is passed from caller instead
                                               // of the previous multitrack read structure.

  // ulFlags Return Values:
  MULTITRACKREAD_NOTDONE        = $0001;       // Read is not done.  Another read of the same
                                               // buffer is necessary.  There were not enough record
                                               // entries in the record table passed to this api.
  MULTITRACKREAD_EOF            = $0002;       // End of File.  Used because # bytes read may not
                                               // match the length of the buffer in cases of a
                                               // record that spans in the next buffer.

type
  // MMMULTITRACKWRITE - Multiple Track Write
  mmMultiTrackWrite = record
    ulNumTracks       : uLong;                 // Input - number of track entries
    pTrackMapList     : pTrackMap;             // Input - ptr to track-to-record list
    ulFlags           : uLong;                 // Input - write flags (Default = 0)
    ulReserved        : uLong;                 // Input - Reserved (must be 0)
  end;
  pmmMultiTrackWrite = ^mmMultiTrackWrite;

const
  // ulFlags Input Values:
  MULTITRACKWRITE_MERGE         = $0001;       // Attempt to interleave the data on the write.
                                               // The default (without this flag set) is to
                                               // write all records for each track then write
                                               // all records of the next track and so on.

type
  // MMMOVIEHEADER - standard movie header data
  mmMovieHeader = record
    ulStructLen           : uLong;             // length of this structure
    ulContentType         : uLong;             // movie content type
    ulMediaType           : uLong;             // video media type
    ulMovieCapsFlags      : uLong;             // capabilities
    ulMaxBytesPerSec      : uLong;             // maximum transfer rate
    ulPaddingGranularity  : uLong;             // pad to a multiple of this size
    ulSuggestedBufferSize : uLong;
    ulStart               : uLong;             // delay time marking beginning or start of movie
    ulLength              : uLong;
    ulNextTrackID         : uLong;             // next available track id
    ulNumEntries          : uLong;             // number of track entries
    pmmTrackInfoList      : pmmTrackInfo;      // track information
    pszMovieTitle         : pChar;             // movie title
    ulCountry             : uLong;             // country code for the title string
    ulCodePage            : uLong;             // country code page the title string
    ulAvgBytesPerSec      : uLong;             // average transfer rate
  end;
  pmmMovieHeader = ^mmMovieHeader;

const
  // ulMovieCapsFlags Defines:
  MOVIE_HAS_VIDEO               = $0001;       // The movie contains video.
  MOVIE_HAS_AUDIO               = $0002;       // The movie contains audio.
  MOVIE_CAN_SEEK                = $0004;       // The movie can seek.
  MOVIE_CAN_SCAN                = $0008;       // The movie can fast scan.
  MOVIE_HAS_COPYRIGHT           = $0010;       // The movie contains copyrighted data.
  MOVIE_WAS_CAPTUREFILE         = $0020;       // The movie is a specially allocated
                                               // file used for capturing real-time
                                               // video.  Applications should warn
                                               // the user before writing over a file
                                               // with this flag set because the user
                                               // probably defragmented this file.
                                               // If this flag is set, then there is a chance
                                               // that not all of the records will be written
                                               // on the call. Caller must check for this whether
                                               // this flag is set or not.

type
  // MMVIDEOHEADER - Movie Video Track Header
  mmVideoHeader = record
    ulStructLen           : uLong;             // length of this structure
    ulContentType         : uLong;             // video content type
    ulMediaType           : uLong;             // video media type
    ulVideoCapsFlags      : uLong;             // capabilities
    ulWidth               : uLong;             // video width in pels
    ulHeight              : uLong;             // video height in pels
    ulScale               : uLong;
    ulRate                : uLong;             // Rate / Scale == frames/second
    ulStart               : uLong;             // delay time marking beginning or start of stream
    ulLength              : uLong;
    ulTotalFrames         : uLong;             // total number of video frames
    ulInitialFrames       : uLong;
    mmtimePerFrame        : mmTime;            // frame display time or 0L
    ulSuggestedBufferSize : uLong;
    genpalVideo           : GenPal;            // palette
    pmmXDIBHeader         : pmmXDIBHeader;     // windows DIB compatible header
  end;
  pmmVideoHeader = ^mmVideoHeader;

const
  // ulContentType Defines:
  MMIO_VIDEO_UNKNOWN            = $00000000;   // Unknown video content
  MMIO_VIDEO_DATA               = $00000001;   // Video

{----[ SW ]----}

// Secondary Windows and Graphic Buttons

const
  MAX_SMBDTEXT                  = 35;

  MB_ICONCUSTOM                 = $0001;

  SC_DEFAULTSIZE                = $c000;       // WM_COMMAND from SysMenu

  WM_INITSECONDARYWINDOW        = $0519;       // MP1: NULL, MP2: CreateParams

  QS_FRAME                      = $1;          // Flag set to query frame
  QS_DIALOG                     = $2;          // Flag set to query dialog

type
  smbd = record
    achText   : Array[0..MAX_SMBDTEXT] of char; // Text of the button. eg. "~Cancel"
    idButton  : uLong;                         // Button ID returned when user chooses button
    flStyle   : Long;                          // Button style or'ed with internal styles
  end;
  psmbd = ^smbd;

  smbInfo = record
    hIcon             : hPointer;              // Icon handle
    cButtons          : uLong;                 // Number of buttons
    flStyle           : uLong;                 // Icon style flags (MB_ICONQUESTION, etc...)
    hwndNotify        : hwnd;                  // Reserved
    psmbd             : psmbd;                 // Array of button definitions
  end;
  psmbInfo = ^smbInfo;

// Analogous to WinDlgBox
function WinSecondaryWindow( hwndParent: hwnd; hwndOwner: hwnd;
  pfnDlgProc: fnWp; hmod: hModule; idDlg: uLong; pCreateParams: Pointer): uLong;

// Analogous to WinLoadDlg
function WinLoadSecondaryWindow( hwndParent: hwnd; hwndOwner: hwnd;
  pfnDlgProc: fnWp; hmod: hModule; idDlg: uLong; pCreateParams: Pointer): hwnd;

// Analogous to WinProcessDlg
function WinProcessSecondaryWindow( hwndSW: hwnd ): uLong;

// Analogous to WinCreateDlg
function WinCreateSecondaryWindow( hwndParent: hwnd; hwndOwner: hwnd;
  pfnDlgProc: fnWp; idDlg: uLong; pCreateParams: Pointer): hwnd;

function WinDefaultSize( Wnd: hwnd): Bool;

function WinInsertDefaultSize(Wnd: hwnd; pszDefaultSize: pChar): bool;

function WinQuerySecondaryhwnd(Wnd: hwnd; ulFlag: uLong): hwnd;

//**********************************************************************
// WinSecondaryMessageBox
//
// Parameters: hwnd   hwndParent   - handle of the parent window.
//             hwnd   hwndOwner    - handle of the owner window.
//             PSZ    pszText      - message text.
//             PSZ    pszCaption   - title of the message box.
//             uLong  idWindow     - Message box id
//             PSMBINFO psmbinfo   - pointer to button/icon info
//**********************************************************************
function WinSecondaryMessageBox( hwndParent: hwnd; hwndOwner: hwnd;
  pszText: pChar; pszCaption: pChar; idWindow: uLong; smb: psmbinfo): uLong;

//**********************************************************************
// WinDismissSecondaryWindow
//
// This function should be called from within the dlg proc. The hwnd
// passed in MUST be the handle to the actual dialog.
//**********************************************************************
function WinDismissSecondaryWindow(hwndDlg: hwnd; ulResult: uLong): Bool;

//**********************************************************************
// The parameter hwnd can be either the secondary window or the actual
// dialog.
//**********************************************************************
function WinDestroySecondaryWindow(Wnd: hwnd): Bool;

function WinDefSecondaryWindowProc(Wnd: hwnd; msg: uLong;
  mp1: mParam; mp2: mParam): mResult;


//**********************************************************************
//                         Graphic Buttons
//**********************************************************************

//**********************************************************************
// Notes on Using GraphicButtons
//
// GraphicButton CONTROL DATA
//
//  The format of the control data for GraphicButtons is
//         "button Text, number of bitmaps, bitmap resource id's ..."
//
//
//  Following are two example window templates of GraphicButtons:
//
//      1)  CONTROL  "", IDD_MP_REV, 120, 10, TS_PB_WIDTH, TS_PB_HEIGHT,
//                 WC_GRAPHICBUTTON,
//                 GBS_TWOSTATE | GBS_HILITEBITMAP |
//                 WS_VISIBLE | WS_TABSTOP
//                 CTLDATA GB_RESOURCE,"~REV", 2, ID_MP_REV1, ID_MP_REV0
//
//  The above graphicbutton has id IDD_MP_REV and is of type
//  GBS_TWOSTATE and GBS_HILITEBITMAP.  The GBS_HILITEBITMAP allows
//  a different bitmap to be displayed when the button is in the
//  hilite state. The graphicbutton will be displayed with text
//  "REV" and has "R" as the mnemonic.  It has 2 bitmaps associated
//  with it.  Their resource id are ID_MP_REV1 and ID_MP_REV0.
//
//
//      2)   CONTROL  "", IDD_MP_PLAY, 175, 10, TS_PB_WIDTH,
//                        TS_PB_HEIGHT, WC_GRAPHICBUTTON,
//                        GBS_AUTOTWOSTATE | GBS_AUTOANIMATION |
//                        WS_VISIBLE | WS_TABSTOP
//                        CTLDATA GB_RESOURCE, "~PLAY", 9,
//                                ID_MP_STOP0, ID_MP_PLAY1, ID_MP_PLAY2,
//                                ID_MP_PLAY3, ID_MP_PLAY4, ID_MP_PLAY5,
//                                ID_MP_PLAY6, ID_MP_PLAY7, ID_MP_REV1
//
//  The above graphicbutton has id IDD_MP_PLAY and is of type
//  GBS_AUTOTWOSTATE and GBS_AUTOANIMATE.  When clicked upon,
//  the button will automatically toggle the state and animation.
//  The graphicbutton will be displayed with text "PLAY"
//  and mnemonic "P".  It has 9 bitmaps associated with it.
//
//
//
//  GraphicButton Painting
//
//  Due to the PM design, whenever a graphicbutton is clicked,
//  it is sent a BN_PAINT (to paint a non-hilite state) and then
//  BN_CLICKED.  Thus, for GBS_AUTO* style graphicbuttons, a paint
//  request is generated before the button has a chance to change
//  its state (BN_CLICKED).  To avoid this premature painting,
//  code was inserted to delay the painting of graphicbuttons
//  GB_PAINT_RESOLUTION milliseconds whenever the button is switching
//  FROM the hilite paint state.
//
//**********************************************************************

function WinRegisterGraphicButton: Boolean;

const
  WC_GRAPHICBUTTON              = pChar( $ffff0040 );

  //             GraphicButton Animation/TwoState constants

  //                     Graphic Button Style bits
  GBS_TWOSTATE                  = $1000;       // indicates TwoState button
  GBS_AUTOTWOSTATE              = $2000;       // will auto toggle state up/down
  GBS_ANIMATION                 = $4000;       // indicates Animatable button
  GBS_AUTOANIMATION             = $8000;       // will auto toggle anim. on/off
  GBS_DISABLEBITMAP             = $0010;       // allows a diff. bitmap when disabled
  GBS_HILITEBITMAP              = $0020;       // allows a diff. bitmap when hilited
  GBS_3D_TEXTRECESSED           = $0040;       // display text in 3-D recessed
  GBS_3D_TEXTRAISED             = $0080;       // display text in 3-D raised
  GBS_MINIBUTTON                = $0001;       // mini button style

  //                     Graphic Button User Constants

  // Codes to reference allowed GraphicButton states (or paint states)
  GB_ERROR                      = -1;          // GraphicButton Error
  GB_UP                         = 1;           // GraphicButton up (and paint) state
  GB_DOWN                       = 2;           // GraphicButton down (and paint) state
  GB_DISABLE                    = 3;           // GraphicButton disabled state
  GB_HILITE                     = 4;           // GraphicButton paint state only
  GB_OUTOFHILITE                = 5;           // Changing out of hilite paint state

  // Codes for various GraphicButton message function parameters
  GB_TOGGLE                     = 10;          // GraphicButton toggle
  GB_CURRENTSTATE               = 11;          // GraphicButton's current state
  GB_ANIMATIONBEGIN             = 12;          // when refering to index of anim start
  GB_ANIMATIONEND               = 13;          // when refering to index of anim end
  GB_MAXINDEX                   = 14;          // GraphicButton max. index

  // Codes to set/query text position relative to the bitmap
  GB_TEXTBELOW                  = 1;           // place text below bitmap
  GB_TEXTABOVE                  = 2;           // place text above bitmap

  // Codes used to set the animation frame with message GBM_SETBITMAPINDEX

  GB_INDEX_FORWARD              = -1;          // advance one frame foward
  GB_INDEX_BACKWARD             = -2;          // advance one frame backwards
  GB_INDEX_FIRST                = -3;          // set to first frame of sequence
  GB_INDEX_LAST                 = -4;          // set to last frame of sequence

type
  gbtnCdata = packed record
    usReserved   : uShort;
    pszText      : pChar;
    hmod         : hModule;
    cBitmaps     : uShort;
    aidBitmap    : Array[0..1] of uShort;
  end;
  pgbtnCdata = ^gbtnCdata;

const
  GB_RESOURCE                   = 1;
  GB_STRUCTURE                  = 0;


  //**********************************************************************
  //          Notification Messages received by GraphicButton Parent
  //*********************************************************************
  //**********************************************************************
  // GBN_BUTTONDOWN, GBN_BUTTONUP, and GBN_BUTTONHILITE
  //
  // The notification messages are passed as part of the WM_CONTROL
  // message.
  //
  // msg = WM_CONTROL
  // mp1 = MPFROM2SHORT(gpb_id, button_state)
  //         gpd_id       = identity of the displayed graphic pushbutton
  //         button_state = GBN_BUTTONUP, GBN_BUTTONDOWN, or
  //                        GBN_BUTTONHILITE
  //
  //**********************************************************************

  GBN_BUTTONUP                  = $0524;
  GBN_BUTTONDOWN                = $0525;
  GBN_BUTTONHILITE              = $0526;
  GBN_SETFOCUS                  = $0527;   // mp2 TRUE for gaining focus

  //**********************************************************************
  //          Messages to GraphicButton Windows
  //**********************************************************************

  //**********************************************************************
  //                             GBM_SETGRAPHICDATA
  //**********************************************************************
  // mp1 = MPFROMP((PGBTNCDATA)&gbtncdata);    Graphic button control data
  // mp2 = NULL;                               not used
  //
  // WARNING: This message resets all button parameters.
  //
  //**********************************************************************

  GBM_SETGRAPHICDATA            = $052A;

  //**********************************************************************
  //                             GBM_ANIMATE
  //**********************************************************************
  // mp1 = MPFROMSHORT(fStart)      TRUE to start animation, FALSE to stop
  // mp2 = MPFROMSHORT(fContinue)   TRUE continue anim. at currently
  //                                displayed bitmap, FALSE restart at
  //                                the beginning.
  //
  // Returns TRUE on Success
  //         FALSE on Failure
  //
  //**********************************************************************

  GBM_ANIMATE                   = $052B;

  //**********************************************************************
  //                             GBM_SETANIMATIONRATE
  //**********************************************************************
  // mp1 = MPFROMSHORT(ULmIL);      Animation rate in milliseconds
  // mp2 = NULL                     not used
  //
  //
  // Returns TRUE on Success
  //         FALSE on Failure
  //
  //**********************************************************************

  GBM_SETANIMATIONRATE          = $052C;


  //**********************************************************************
  //                             GBM_QUERYANIMATIONACTIVE
  //**********************************************************************
  // mp1 = NULL;                    not used
  // mp2 = NULL;                    not used
  //
  //
  // Returns TRUE if animation is active, else GB_ERROR
  //
  //
  //**********************************************************************

  GBM_QUERYANIMATIONACTIVE      = $052D;


  //**********************************************************************
  //                             GBM_QUERYANIMATIONRATE
  //**********************************************************************
  // mp1 = NULL;                    not used
  // mp2 = NULL;                    not used
  //
  //
  // Returns uLong sepcifying animation rate in milliseconds
  //
  //
  //**********************************************************************

  GBM_QUERYANIMATIONRATE        = $052E;


  //**********************************************************************
  //                             GBM_SETBITMAPINDEX
  //**********************************************************************
  // mp1 = MPFROMSHORT(usGB_State)       Bitmap index to change
  //             GB_UP,
  //             GB_DOWN,
  //             GB_DISABLE,
  //             GB_HILITE,
  //             GB_ANIMATIONBEGIN,
  //             GB_ANIMATIONEND,
  //          or GB_CURRENTSTATE    chng current state (up or down) bitmap
  // mp2 = MPFROMSHORT(sFrameCode)  Set according to code or frame desire
  //             GB_INDEX_FORWARD,  chng to next bitmap in circular array
  //             GB_INDEX_BACKWARD, "   "  prev   "    "     "       "
  //             GB_INDEX_FIRST,    "   "  first  "    "     "       "
  //             GB_INDEX_LAST,     "   "  last   "    "     "       "
  //          or desired_bitmap     otherwise desired bmp index specified
  //
  // Returns TRUE on Success, otherwise FALSE
  //
  //**********************************************************************

  GBM_SETBITMAPINDEX            = $052F;


  //**********************************************************************
  //                             GBM_QUERYBITMAPINDEX
  //**********************************************************************
  //  mp1 = MPFROMSHORT(usGB_State)       Query bitmap index
  //            GB_UP,
  //            GB_DOWN,
  //            GB_DISABLE,
  //            GB_HILITE,
  //            GB_ANIMATIONBEGIN,
  //            GB_ANIMATIONEND,
  //         or GB_CURRENTSTATE  query current state (up or down) bitmap
  //  mp2 = NULL;                    not used
  //
  //  Returns USHORT specifying the index
  //
  //
  //**********************************************************************

  GBM_QUERYBITMAPINDEX          = $0530;

  //**********************************************************************
  //                             GBM_SETSTATE
  //**********************************************************************
  // mp1 = MPFROMSHORT(usStateCode)   Set twostate button to specified
  //                                  state
  //             GB_UP,
  //             GB_DOWN,
  //          or GB_TOGGLE          toggle (up/down) to (down/up)
  // mp2 = MPFROMBOOL(fRepaint)     TRUE  - state changed and displayed
  //                                FALSE - state changed, not displayed
  //
  // Returns TRUE on Success
  //         FALSE on Failure
  //
  //
  //**********************************************************************

  GBM_SETSTATE                  = $0531;

  //**********************************************************************
  //                             GBM_QUERYSTATE
  //**********************************************************************
  //
  // mp1 = NULL                        not used
  // mp2 = NULL                        not used
  //
  // Returns the state (GB_UP or GB_DOWN) else GB_ERROR.
  //
  //
  //**********************************************************************

  GBM_QUERYSTATE                = $0532;

  //**********************************************************************
  //                             GBM_SETTEXTPOSITION
  //**********************************************************************
  // mp1 = MPFROMSHORT(usTextPos)   How to position text relative to
  //                                  bitmap
  //               GB_TEXTBELOW,
  //            or GB_TEXTABOVE
  //   mp2 = NULL                     not used
  //
  //   Returns TRUE on Success, otherwise FALSE
  //
  //**********************************************************************

  GBM_SETTEXTPOSITION           = $0533;

  //**********************************************************************
  //                             GBM_QUERYTEXTPOSITION
  //**********************************************************************
  //
  //  mp1 = NULL                          not used
  //  mp2 = NULL                          not used
  //
  //  Returns GB_TEXTBELOW, GB_TEXTABOVE, GB_TEXTRIGHT, GB_TEXTLEFT
  //  on success, otherwise FALSE
  //
  //**********************************************************************

  GBM_QUERYTEXTPOSITION         = $0534;


  //**********************************************************************
  //                             GraphicButton END
  //**********************************************************************

  MM_TABHELP                    = $054C;

{----[ DIVE ]----}

const
  Max_Dive_Instances = 64;

type
  hDive  = ULong;

const
  Dive_Success                     = $00000000;
  Dive_Err_Invalid_Instance        = $00001000;
  Dive_Err_Source_Format           = $00001001;
  Dive_Err_Destination_Format      = $00001002;
  Dive_Err_Blitter_Not_Ssetup      = $00001003;
  Dive_Err_Insufficient_Length     = $00001004;
  Dive_Err_Too_Many_Instances      = $00001005;
  Dive_Err_No_Direct_Access        = $00001006;
  Dive_Err_Not_Bank_Switched       = $00001007;
  Dive_Err_Invalid_Bank_Number     = $00001008;
  Dive_Err_FB_Not_Acquired         = $00001009;
  Dive_Err_FB_Already_Acquired     = $0000100a;
  Dive_Err_Acquire_Failed          = $0000100b;
  Dive_Err_Bank_Switch_Failed      = $0000100c;
  Dive_Err_DeAcquire_Failed        = $0000100d;
  Dive_Err_Invalid_Palette         = $0000100e;
  Dive_Err_Invalid_Destination_Rectl=$0000100f;
  Dive_Err_Invalid_Buffer_Number   = $00001010;
  Dive_Err_SSMDD_Not_Installed     = $00001011;
  Dive_Err_Buffer_Already_Accessed = $00001012;
  Dive_Err_Buffer_Not_Accessed     = $00001013;
  Dive_Err_Too_Many_BufferS        = $00001014;
  Dive_Err_Allocation_Error        = $00001015;
  Dive_Warn_No_Size                = $00001100;

  Dive_Buffer_Screen               = $00000000;
  Dive_Buffer_Graphics_Plane       = $00000001;
  Dive_Buffer_Alternate_Plane      = $00000002;

{ Notes:
      Associated/Allocated memory buffers start at:      $00000010

      Specifing Dive_Buffer_GRAPHICS_PLANE results in the image being
            transferred to the graphics plane.
      Specifing Dive_Buffer_ALTERNATE_PLANE results in the image being
            transferred to the alternate (e.g. overlay) plane.  If your
            hardware doesn't support such a plane, this is an error.
      Specifing Dive_Buffer_Screen will result in the image being
            transferred to either the graphics plane buffer or the alternate
            plane buffer based on if an alternate buffer exists and based on
            the suitability the overlay plane to accelerate the scaling of
            the image.  If Dive chooses to use the alternate buffer, it
            will also paint the overlay "key" color on the graphics plane.
            This automatic painting does not occur if the alternate plane
            is explicitly specified.
}

type
  Dive_Caps = record
    ulStructLen           : ULong;   // Set equal to sizeof(Dive_CAPS)
    ulPlaneCount          : ULong;   // Number of defined planes.

    // Info returned in the following fields pertains to ulPlaneID.
    fScreenDirect         : Bool;    // TRUE if can get addressability to vram.
    fBankSwitched         : Bool;    // TRUE if vram is bank-switched.
    ulDepth               : ULong;   // Number of bits per pixel.
    ulHorizontalResolution: ULong;   // Screen width in pixels.
    ulVerticalResolution  : ULong;   // Screen height in pixels.
    ulScanLineBytes       : ULong;   // Screen scan line size in bytes.
    fccColorEncoding      : FourCC;  // Colorspace encoding of the screen.
    ulApertureSize        : ULong;   // Size of vram aperture in bytes.

    ulInputFormats        : ULong;   // Number of input color formats.
    ulOutputFormats       : ULong;   // Number of output color formats.
    ulFormatLength        : ULong;   // Length of format buffer.
    pFormatData           : Pointer; // Pointer to color format buffer FourCC's.
  end;

  pDive_Caps=^Dive_Caps;


{ Notes:
      DiveSetupBlitter may be called with a structure length at any of the
      breaks below (i.e. 8, 28, 32, 52, 60, or 68):
}

  Setup_Blitter = record
    ulStructLen           : ULong;   // Set equal to sizeof(SETUP_Blitter)
    fInvert               : Bool;    // TRUE if we are to invert image on blit.

    fccSrcColorFormat     : FourCC;  // Color format of Source data.
    ulSrcWidth            : ULong;   // Source width in pixels.
    ulSrcHeight           : ULong;   // Source height in pixels.
    ulSrcPosX             : ULong;   // Source start X position.
    ulSrcPosY             : ULong;   // Source start Y position.

    ulDitherType          : ULong;   // Where 0 is no dither, 1 is 2x2 dither.

    fccDstColorFormat     : FourCC;  // Color format of destination data.
    ulDstWidth            : ULong;   // Destination width in pixels.
    ulDstHeight           : ULong;   // Destination height in pixels.
    lDstPosX              : Long;    // Destination start X position.
    lDstPosY              : Long;    // Destination start Y position.

    lScreenPosX           : Long;    // Destination start X position on screen.
    lScreenPosY           : Long;    // Destination start Y position on screen.

    ulNumDstRects         : ULong;   // Number of visible rectangles.
    pVisDstRects          : PRectl;  // Pointer to array of visible rectangles.
  end;

  pSetup_Blitter = ^Setup_Blitter;

Function DiveQueryCaps( var DiveCaps: Dive_Caps; ulPlaneBufNum: ULong): ULong;
Function DiveOpen( var hDiveInst: hDive; fNonScreenInstance: Bool;
                   var pFrameBuffer: Pointer): ULong;
Function DiveSetupBlitter( hDiveInst: hDive; pSetupBlitter: pSetup_Blitter): ULong;
Function DiveBlitImage( hDiveInst: hDive; ulSrcBufNumber: ULong;
                        ulDstBufNumber: ULong): ULong;
Function DiveClose( hDiveInst: hDive ): ULong;
Function DiveAcquireFrameBuffer( hDiveInst: ULong; var rectlDst: RectL ): ULong;
Function DiveSwitchBank( hDiveInst: hDive; ulBankNumber: ULong): ULong;
Function DiveDeacquireFrameBuffer( hDiveInst: hDive ): ULong;
Function DiveCalcFrameBufferAddress( hDiveInst: hDive;
                                     var rectlDest: RECTL;
                                     var pDestinationAddress: Pointer;
                                     var ulBankNumber: ULong;
                                     var ulRemLinesInBank: ULong): ULong;

{ Notes on DiveAllocImageBuffer:
      If ImageBuffer is not NULL, the buffer is associated rather than
      allocated.  If ImageBuffer is not NULL and the buffer number
      pointed to by pulBufferNumber is non-zero, a new buffer pointer is
      associated with the buffer number.  Even though no memory is
      allocated by DiveAllocImageBuffer when user-allocated buffers are
      associated, DiveFreeImageBuffer should be called to release the
      buffer association to avoid using up available buffer indexes.
      The specified line size will be used if a buffer is allocated in
      system memory, or if a user buffer is associated.  If the
      specified line size is zero, the allocated line size is rounded up
      to the nearest DWORD boundary. }

Function DiveAllocImageBuffer( hDiveInst: hDive; var ulBufferNumber: ULong;
                               fccColorSpace: FourCC; ulWidth: ULong;
                               ulHeight: ULong; ulLineSizeBytes: ULong;
                               ImageBuffer: Pointer): ULong;
Function DiveFreeImageBuffer( hDiveInst: hDive; ulBufferNumber: ULong):ULong;
Function DiveBeginImageBufferAccess( hDiveInst: hDive; ulBufferNumber: ULong;
                                     var pbImageBuffer: Pointer;
                                     var ulBufferScanLineBytes: ULong;
                                     var ulBufferScanLines: ULong): ULong;

Function DiveEndImageBufferAccess( hDiveInst: hDive; ulBufferNumber: ULong): ULong;

{ Notes on palettes:
      Neither DiveSetSourcePalette nor DiveSetDestinationPalette API's will set
      the physical palette.  If your application MUST set the PHYSICAL palette,
      try using no more than 236 entries (the middle 236: 10-245, thus leaving
      the top and bottom 10 entries for the Workplace Shell).  If your
      application MUST use ALL 256 entries, it must do so as a full-screen
      (i.e. maximized) application.  Remember, No WM_REALIZEPALETTE message
      will be sent to other running applications, meaning they will not redraw
      and their colors will be all wrong.  It is not recommended that a
      developer use these commands:

   To set physical palette, do the following:
            hps := WinGetPS( HWND_DESKTOP );
            hdc := GpiQueryDevice( hps );
            GpiCreateLogColorTable( hps, LCOL_PURECOLOR OR LCOL_REALIZABLE,
                           LCOLF_CONSECRGB, 0, 256, @plRGB2Entries );
            DiveSetPhysicalPalette( hDiveInst, hdc );
            Gre32EntrY3 ( hdc, 0, $000060C6L );
            WinInvalidateRect ( HWND_DESKTOP, nil, ord(TRUE) );
            WinReleasePS ( hps );

   To reset physical palette, do the following:
            hps := WinGetPS ( HWND_DESKTOP );
            hdc := GpiQueryDevice ( hps );
            Gre32EntrY3 ( hdc, 0, $000060C7L );
            WinInvalidateRect ( HWND_DESKTOP, nil, ord(TRUE) );
            WinReleasePS ( hps ); }

Function DiveSetDestinationPalette( hDiveInst: hDive; ulStartIndex: ULong;
                                    ulNumEntries: ULong; pbRGB2Entries: Pointer): ULong;

Function DiveSetSourcePalette( hDiveInst: hDive; ulStartIndex: ULong;
                               ulNumEntries: ULong; pbRGB2Entries: Pointer): ULong;

{----[ MIDIOS2 ]----}

// Multimedia Extensions Midi structures and definitions

const
  STATUS_BIT                    = $80;

  TRACK_OFF                     = 0;
  TRACK_ON                      = 1;


  NORMAL_SYSEX                  = $f0;
  ESCAPE_SYSEX                  = $f7;
  META                          = $ff;

  // user defined messages for IO PROC
  MMIO_SEQ                      = MMIOM_USER + 1;
  MMIO_MERGE                    = MMIOM_USER + 2;
  MMIO_FROM_SEQ                 = MMIOM_USER + 3;
  MMIO_TIMED_READ               = MMIOM_USER + 4;
  MMIO_SET_TRACKS               = MMIOM_USER + 5;
  MMIO_FORMAT_0                 = MMIOM_USER + 6;
  MMIO_GETHEADER                = MMIOM_GETHEADER;
  MMIOM_GETFILELENGTH           = MMIOM_USER + 10;
  MMIOM_GETTRACKLENGTH          = MMIOM_USER + 11;

type
  MidiHeader = record
    chHeaderChunk               : array[0..3] of Char;
    ulHeaderLength              : uLong;
    usFormat                    : uShort;
    usNumTracks                 : uShort;
    usDivision                  : uShort;
    vpAdditionalInformation     : Pointer;
  end;
  pMidiHeader = ^MidiHeader;

  mmMidiHeader = record
    ulHeaderLength    : uLong;                 // Length in Bytes
    ulContentType     : uLong;                 // Image content
    ulMediaType       : uLong;                 // type of media
    midiheader        : MidiHeader;            // header
  end;
  pmmMidiHeader = ^mmMidiHeader;

{----[ MIDITYPE2 ]----}

const
  MIDINAMESIZE                  = 40;
  MIDIPATCHNUM                  = 128;
  MIDITYPEAPPNAME               = 'MidiTypes';    // Appname in MIDITYPE.INI

type
  // These structures describe the format of the MIDI maps that are
  // located in the MIDITYPE.INI file.
  MidiTypeEntry = record
    uGenMidiPatchNumber  : uShort;             // Device To General Midi Conversion
    uDevMidiPatchNumber  : uShort;             // General Midi to Device Conversion
    uVolumePercent       : uShort;             // Channel Patch Volume Scaler
    uGenMidiKeyNumber    : uShort;             // Device To General Midi Perc. Key Conversion
    uDevMidiKeyNumber    : uShort;             // General Midi to Device Perc. Key Conversion
  end;
  pMidiTypeEntry = ^MidiTypeEntry;

  MidiType = record
    uStyle            : uShort;                // Midi Style
    uDrums10          : uShort;                // Patch 10 Drums if Perckey not supported
    uDrums16          : uShort;                // Patch 16 Drums if Perckey not supported
    ulReserved        : uLong;                 // Reserved
    MidiTypeEntry     : array[0..midiPatchNum-1] of MIDITYPEENTRY;
                                               // Array of MIDITYPEENTRYs
    szPatchAndPercKeyName: array[0..2*MIDIPATCHNUM*MIDINAMESIZE-1] of char;
                                               // List of 128 Patch Names
                                               // that are null terminated, then a
                                               // list of 128 Percussion key names that
                                               // are double null terminated
                                               // Each item is null terminated
  end;
  pMidiType = ^MidiType;

const
  // Style Flags
  MT_PERCUSSIONKEYS             = $1;          // Percussion Keys are supported
  MT_MAPPERCKEYPATCHES          = $2;          // Map Percussion Key Patches

{----[ AUDIO ]----}

// Multimedia Extensions Audio Structures and definitions.

const
  // * AUDIODD version level
  CURRENT_VERSION               = $01020000;

  // ACPA control definitions
  AUDIO_IOCTL_CAT               = $80;

  AUDIO_INIT                    = $40;
  AUDIO_STATUS                  = $41;
  AUDIO_CONTROL                 = $42;
  AUDIO_BUFFER                  = $43;
  AUDIO_LOAD                    = $44;
  AUDIO_WAIT                    = $45;
  AUDIO_HPI                     = $46;
  AUDIO_CAPABILITY              = $48;

  MIX_GETCONNECTIONS            = $60;
  MIX_SETCONNECTIONS            = $61;
  MIX_GETLINEINFO               = $62;
  MIX_GETCONTROL                = $63;
  MIX_SETCONTROL                = $64;

  // AUDIO_INIT declarations and defines
  LOAD_PATH                     = 260;

  // Values for AUDIO_INIT.sMode
  ADPCM                         = 1;           // AVC type ADPCM
  PCM                           = 2;           // Pulse Coded Modulation
  MU_LAW                        = 3;           // mu-law
  MIDI                          = 4;           // MIDI data
  A_LAW                         = 5;           // a-law
  SOURCE_MIX                    = 6;           // External audio source
  SPV2                          = 7;           // Speech Viewer/2
  ADPCMXA                       = 8;           // XA CD ROM
  SPV2BCPCM                     = 25;          // Speech Viewer/2
  SPV2PCM                       = 26;
  SPV2NONE                      = 27;
  IDLE                          = 999;
  CLAIM_HDWR                    = 32000;       // Serialize access to hardware

  // Values for AUDIO_INIT.ulFlags
  FIXED                         = $00000001;   // Fixed length data
  LEFT_ALIGNED                  = $00000002;   // Left align bits on byte bndry
  RIGHT_ALIGNED                 = $00000004;   // Right align bits on byte bndry
  TWOS_COMPLEMENT               = $00000008;   // 2's complement data
  SIGNED                        = $00000010;   // Signed data
  BIG_ENDIAN                    = $00000020;   // MSB's first (motorola format)
  RIFF_DATATYPE                 = $00000040;   // sMode contains a RIFF datatype
  PITCH                         = $00100000;   // Pitch control is supported
  INPUT                         = $00200000;   // Input select is supported
  OUTPUT                        = $00400000;   // Output select is supported
  MONITOR                       = $00800000;   // Monitor is supported
  VOLUME                        = $01000000;   // Volume control is supported
  VOLUME_DELAY                  = $02000000;   // Volume delay is supported
  BALANCE                       = $04000000;   // Balance control is supported
  BALANCE_DELAY                 = $08000000;   // Balance delay is supported
  TREBLE                        = $10000000;   // Treble control is supported
  BASS                          = $20000000;   // Bass control supported
  BESTFIT_PROVIDED              = $40000000;   // bestfit returned
  LOAD_CODE                     = $80000000;   // DSP load needed

  // Values for AUDIO_INIT.ulOperation
  OPERATION_PLAY                = 1;
  OPERATION_RECORD              = 2;
  PLAY_AND_RECORD               = 3;
  ANALYSIS                      = 6;           // Speech Viewer/2
  DISTANCE                      = 7;           // Speech Viewer/2
  MIGRATION                     = 8;           // Speech Viewer/2

  // Values for AUDIO_INIT.sReturnCode
  NO_PLAY                       = 1;
  NO_RECORD                     = 2;
  NO_RECORD_AND_PLAY            = 3;
  INVALID_REQUEST               = 4;
  CONFLICT                      = 5;
  OVERLOADED                    = 6;
  DOWNLEVEL_DD                  = 7;           // DD is down level from appl.
  DSP_LOAD_PENDING_ON_OTHER_TRK = 8;           // Other trk hasn't loaded dsp

  AUDIO_IGNORE                  = -1;

  // Values for AUDIO_INIT.sDeviceID
  MINIDD                        = 0;
  ACPA                          = 1;
  MACPA                         = 2;
  MPU401                        = 3;
  SOUND_BLASTER                 = 4;
  IMF                           = 5;
  PS1                           = 6;
  PAS16                         = 7;

type
  // AUDIO_INIT structure declaration
  mci_Audio_Init = record
    lSRate            : Long;
    lBitsPerSRate     : Long;
    lBsize            : Long;
    sMode             : Short;
    sChannels         : Short;
    lResolution       : Long;
    abLoadPath        : array[0..Load_Path-1] of Char;
    ulFlags           : uLong;
    ulOperation       : uLong;
    sReturnCode       : Short;
    sSlotNumber       : Short;
    sDeviceID         : Short;
    pvReserved        : Pointer; // MMPM2 uses this to pass back sysfilenum
    ulVersionLevel    : uLong;
  end;
  lpmci_Audio_Init = ^mci_Audio_Init;

  // AUDIO_DEVID declarations and defines
  mci_Audio_DevID = record
    ulDevType         : uLong;
    ulDevNum          : uLong;
  end;
  lpmci_Audio_DevID = ^mci_Audio_DevID;

const
  // Input devices
  NULL_INPUT                    = 0;
  STEREO_LINE_INPUT             = 1;
  LEFT_LINE_INPUT               = 2;
  RIGHT_LINE_INPUT              = 3;
  MIC_INPUT                     = 4;
  BOOSTED_MIC_INPUT             = 5;
  PHONE_LINE_INPUT              = 6;
  HANDSET_INPUT                 = 7;
  SYNTH_INPUT                   = 8;
  DIGITAL_PHONE_LINE_INPUT      = 9;
  DIGITAL_HANDSET_INPUT         = 10;
  MIDI_IN_PORT                  = 11;
  LOOPBACK                      = 11;
  DEFAULT_INPUT                 = $FFFFFFFF;

  // Output devices
  NULL_OUTPUT                   = 0;
  STEREO_LINE_OUTPUT            = 1;
  LEFT_LINE_OUTPUT              = 2;
  RIGHT_LINE_OUTPUT             = 3;
  SPEAKER_OUTPUT                = 4;
  HEADSET_OUTPUT                = 5;
  PHONE_LINE_OUTPUT             = 6;
  HANDSET_OUTPUT                = 7;
  SYNTH_OUTPUT                  = 8;
  DIGITAL_PHONE_LINE_OUTPUT     = 9;
  DIGITAL_HANDSET_OUTPUT        = 10;
  MIDI_OUT_PORT                 = 11;
  DEFAULT_OUTPUT                = $FFFFFFFF;

  // Defined values for DevNum
  DEFAULT_DEVICE                = 0;
  DEVICE_1                      = 1;
  DEVICE_2                      = 2;

  // Valid Return codes for the ulSupport field of MCI_AUDIO_CAPS
  SUPPORT_SUCCESS               = $00000000;
  UNSUPPORTED_RATE              = $00000001;
  UNSUPPORTED_CHANNELS          = $00000002;
  UNSUPPORTED_BPS               = $00000004;
  UNSUPPORTED_DATATYPE          = $00000008;
  UNSUPPORTED_OPERATION         = $00000010;

type
  mci_Audio_Caps = record
    ulLength          : uLong;                 // in     Structure length
    ulSamplingRate    : uLong;                 // in out Sampling rate to query
    ulChannels        : uLong;                 // in out Channels to query
    ulBitsPerSample   : uLong;                 // in out BPS to query
    ulDataType        : uLong;                 // in out RIFF Datatype to query
    ulOperation       : uLong;                 // in out OPERATION_PLAY or OPERATION_RECORD
    ulSupport         : uLong;                 //    out BOOLEAN-does DD support this mode
    ulDataSubType     : uLong;                 //    out Data-subtype to use
    ulResourceUnits   : uLong;                 //    out Resource units this mode
    ulResourceClass   : uLong;                 //    out Resource class for this mode
    ulBlockAlign      : uLong;                 //    out Block alignment for this mode.
    fCanRecord        : uLong;                 //    out Is recording possbile - this mode
    ulFlags           : uLong;                 //    out
    ulCapability      : uLong;                 //    out Capability of the device.
  end;
  pAudio_Caps = ^mci_Audio_Caps;

const
  // Valid Return codes for the ul field of MCI_AUDIO_CAPS
  SUPPORT_MIX                   = $00000001; // supports mixer functions
  SUPPORT_RIFF_MODES            = $00000002; // supports RIFF modes for AUDIO_INIT
  SUPPORT_CAP                   = $80000000; // Capability IOCTL supported

  // AUDIO_CHANGE declarations and defines

  // Values for AUDIO_CHANGE.lMonitor
  MONITOR_OFF                   = 0;
  MONITOR_UNCOMPRESSED          = 1;
  MONITOR_COMPRESSED            = 2;

  // Values for AUDIO_CHANGE.lInput
  HIGH_GAIN_MIC                 = 0;
  LINE_1                        = 1;
  LINE_2                        = 2;
  LINES_1AND2                   = 3;
  LOW_GAIN_MIC                  = 4;
  ALL_LINES                     = $FFFF;
  INPUTS_LISTED                 = $5555;

  // Values for AUDIO_CHANGE.lOutput
  EXTERNAL_SPEAKER              = 1;
  INTERNAL_SPEAKER              = 2;
  OUTPUT_1                      = 4;
  OUTPUTS_LISTED                = $5555;

type
  // AUDIO_CHANGE structure declaration
  mci_Audio_Change = record
    pvDevInfo         : Pointer;
    lInput            : Long;
    lOutput           : Long;
    lMonitor          : Long;
    lVolume           : Long;
    lVolumeDelay      : Long;
    lBalance          : Long;
    lBalanceDelay     : Long;
    lTreble           : Long;
    lBass             : Long;
    lPitch            : Long;
    rInputList        : array[0..7] of MCI_AUDIO_DEVID;
    rOutputList       : array[0..7] of MCI_AUDIO_DEVID;

    prMoreInputs      : LPMCI_AUDIO_DEVID;
    prMoreOutputs     : LPMCI_AUDIO_DEVID;
    lGain             : Long;
    pvModeInfo        : Pointer;
  end;
  lmmci_Audio_Change = ^mci_Audio_Change;

  Midi_Info = record
    sTempo            : Short;
    sCPQN             : Short;
    sMidiSwitches     : Short;
    sReserved         : Array[0..4] of Short;
  end;

const
  // MIDI Switches
  MIDI_THRU_THRU                = 0;
  MIDI_THRU_OUT                 = 1;

  // AUDIO_STATUS declarations and defines

  // Values for AUDIO_STATUS.ulOperation
  STOPPED                       = 0;
  PLAYING                       = 1;
  RECORDING                     = 2;
  PLAYING_AND_RECORDING         = 3;
  UNITIALIZED                   = $FFFFFFFF;

type
  // AUDIO_STATUS structure declaration
  mci_Audio_Status = record
    lSRate            : Long;
    lBitsPerSRate     : Long;
    lBsize            : Long;
    sMode             : Short;
    sChannels         : Short;
    ulFlags           : uLong;
    ulOperation       : uLong;
    rAudioChange      : MCI_AUDIO_CHANGE;
  end;
  lpmci_Audio_Status = ^mci_Audio_Status;

const
  // AUDIO_CONTROL declarations and defines

  // Values for AUDIO_CONTROL.usIOCtlRequest
  AUDIO_CHANGE                  = 0;
  AUDIO_START                   = 1;
  AUDIO_STOP                    = 2;
  AUDIO_PAUSE                   = 3;
  AUDIO_RESUME                  = 4;

  // Values for AUDIO_CONTROL.sReturnCode
  AC_UNINITED                   = 1;           // Device must be init'ed or loaded first
  FULL_QUEUE                    = 2;           // Maximum # requests exceeded
  AC_UNPAUSED                   = 3;           // Resume issued, but dev not paused
//  INVALID_REQUEST               = 4;           // bad audio_control.ioctl_request
  AC_UNSTARTED                  = 5;           // Device must be started first
  INVALID_INPUT_LIST            = 7;           // invalid change.input_list entry
  INVALID_OUTPUT_LIST           = 8;           // invalid change.output_list entry

type
  // AUDIO_CONTROL structure declaration
  mci_Audio_Control = record
    usIOCtlRequest    : uShort;
    pbRequestInfo     : Pointer;
    ulPosition        : uLong;
    sReturnCode       : Short;
  end;
  lpmci_Audio_Control = ^mci_Audio_Control;

const
  // AUDIO_BUFFER declarations and defines

  // Values for AUDIO_BUFFER.ulFlags
  AUDIO_UNDERRUN                = 1;
  AUDIO_OVERRUN                 = 2;

  // Values for AUDIO_BUFFER.ulPositionType
  POS_MSECS                     = 0;
  MIDI_CLOCKS                   = 1;
  SMPTE_24                      = 24;
  SMPTE_25                      = 25;
  SMPTE_30DF                    = 29;
  SMPTE_30                      = 30;

type
  mci_Audio_Buffer = record
    ulFlags           : uLong;
    ulReadBufSize     : uLong;
    ulWriteBufSize    : uLong;
    ulReadBufTime     : uLong;
    ulWriteBufTime    : uLong;
    ulReadBufMax      : uLong;
    ulWriteBufMax     : uLong;
    ulPosition        : uLong;
    ulPositionType    : uLong;
    lReadBufCap       : Long;
    lWriteBufCap      : Long;
    lRequestBufCap    : Long;
  end;
  lpmci_Audio_Buffer = ^mci_Audio_Buffer;

const
  // AUDIO_LOAD declarations and defines

  // Values for AUDIO_LOAD.ulFlags
  LOAD_START                    = $01;
  LOAD_END                      = $02;
  LOAD_32BIT                    = $10;

type
  mci_Audio_load = record
    pbBuffer          : pChar;
    ulSize            : uLong;
    ulFlags           : uLong;
  end;
  lpmci_Audio_load = ^mci_Audio_load;

  // Track info declarations and defines

  // Track Info structure declaration
  mci_Track_Info = record
     usMasterVolume        : UShort;
     usDitherPct           : UShort;   // Percent of a bit dither during record
     usMasterVolumeDelay   : UShort;
     usMasterBalance       : UShort;
     usMasterBalanceDelay  : UShort;
  end;
  lpmci_Track_Info = ^mci_Track_Info;

const
  // IOBUFFER declarations and defines

  STARTED                       = 1;
  PAUSED                        = 2;

type
  mci_Audio_IOBuffer = record
    lSize             : uLong;
    pHead             : pChar;
    pTail             : pChar;
    lCount            : Long;
    ulPosition        : uLong;
    lDelay            : Long;
    usRunFlags        : UShort;
    usSelInc          : UShort;
    pBuffer           : pChar;
  end;
  lpmci_Audio_IOBuffer = ^mci_Audio_IOBuffer;

const
  // AUDIO_HPI declarations and defines
  CBXMIT                        = 1;
  CBREC                         = 2;
  CRTIMER                       = 4;

  EP_OPEN                       = 0;
  EP_CLOSE                      = 1;
  EP_READ                       = 2;
  EP_WRITE                      = 3;
  EP_INIT                       = 4;
  EP_STATUS                     = 5;
  EP_CONTROL                    = 6;
  EP_BUFFER                     = 7;
  EP_LOAD                       = 8;
  EP_WAIT                       = 9;

type
  mci_Audio_hpi = record
    pvEntry           : procedure;             // VOID (FAR *pvEntry)();
    pvCallBack        : procedure;             // VOID (FAR *pvCallBack)();
    prXBuff           : lpmci_Audio_IOBuffer;
    prRBuff           : lpmci_Audio_IOBuffer;
    usFlags           : uShort;
  end;
  lpmci_Audio_hpi = ^mci_Audio_hpi;

  // AUDIO_UPDATE Structure
  Audio_Update = record
    iobuf_type        : Char;                  // 0 - XMITIO, 1 - RECIO to be updated
    buffer_address    : pChar;                 // address to buffer to be added to array
    buffer_length     : uLong;                 // length of buffer to be added
    rc                : uShort;                // return code
    reserved          : Pointer;               // future use
  end;
  Update = ^Audio_Update;

const
  // audio_update.iobuf_type definitions
  XMIT_IOBUF                    = 0;
  REC_IOBUF                     = 1;

  // audio_update.rc definitions
  MAX_NUM_BUFFERS_REACHED       = 9;
  UPDATE_GENERAL_FAILURE        = 10;
  INVALID_BUFFER_LENGTH         = 11;

{----[ CDAUDOS2 ]----}

// Macro definition and common record structures used between the
// CD Audio MCI Driver, its VSDs (Vendor Specific Drivers), and the
// CD look-up table, MMPMCD.INI.

// CD MCD and VSD values and inter-modual communications

const
  // Macro Definitions
  UPC_SIZE                      = 7;           // UPC code size, CD serial number
  CDMCD_CUEPOINT_MAX            = 20;          // maximum number of cuepoints
  CDROM_SPEC_START              = 6000;        // 2 seconds, greatest min start address


  // Internal messages between the MCI Driver and the VSD.
  MCIDRV_REGISTER_DISC          = MCI_INTERNAL_MESSAGES_START + 1;
  MCIDRV_REGISTER_DRIVE         = MCI_INTERNAL_MESSAGES_START + 2;
  MCIDRV_REGISTER_TRACKS        = MCI_INTERNAL_MESSAGES_START + 3;
  MCIDRV_CD_READ_Long           = MCI_INTERNAL_MESSAGES_START + 4;
  MCIDRV_CD_SET_VERIFY          = MCI_INTERNAL_MESSAGES_START + 5;
  MCIDRV_CD_STATUS_CVOL         = MCI_INTERNAL_MESSAGES_START + 6;

type
  // Internal callback routine to the VSD from the MCI Driver.
  fnCDvsd = function( a: Pointer; b: UShort; c: puLong; d: Pointer; e: UShort ): uLong;
  // (typedef ULONG (APIENTRY FNCDVSD) (PVOID, USHORT, ULONG *, PVOID, USHORT);)

  // Internal callback routine from the VSD to the MCI Driver.
  fnCMmcd = procedure( a,b,c: uLong );
  // (typedef VOID (*PFNCDMCD) (uLong, uLong, uLong);)

type
  // CDAudRegister record structures
  //** ID a disc, used to verify a disc change **
  mci_CD_ID = record                           // must stay at 8 bytes to equal size of UPC
    Mode              : Byte;                  // mode, 0=UPC, 1=ID
    usTrack1          : UShort;                // address of track one in MMTIME
    NumTracks         : Byte;                  // number of tracks
    ulLeadOut         : uLong;                 // address of lead out track
  end;

  //** CD-ROM Drive information, determines capabilities **
  mci_RegDrive_Parms = record
    usCaps            : UShort;                // capabilities
    ulPrerollType     : uLong;                 // preroll type
    ulPrerollTime     : uLong;                 // preroll time
    ulMinStartTime    : uLong;                 // minimum starting time
    ulCDMCDID         : uLong;                 // CD MCD ID for instance
    pCDMCDReturn      : fnCMMcd;               // addr of CD MCD Return function
  end;

const
  // These flags are valid for the usCaps Field
  CDVSD_CAP_CAN_RECORD          = $0001;       // Can record audio
  CDVSD_CAP_HAS_AUDIO           = $0002;       // Can play audio
  CDVSD_CAP_HAS_VIDEO           = $0004;       // Can play video
  CDVSD_CAP_CAN_EJECT           = $0010;       // Can eject disc
  CDVSD_CAP_CAN_STREAM          = $0020;       // Can stream
  CDVSD_CAP_HAS_DAC             = $0040;       // Can process internal
  CDVSD_CAP_CAN_LOCK            = $0080;       // Can disable manual eject
  CDVSD_CAP_CAN_VOLUME          = $0100;       // Can manipulate volume settings
  CDVSD_CAP_CAN_REVERSE         = $0200;       // Can play in reverse
  CDVSD_CAP_CAN_V_SPEED         = $0400;       // Can vary play speed
  CDVSD_CAP_CAN_CUE             = $0800;       // Can read sequent. after break
                                               // Used for Cue, Pause, and Seek

type
  //** Information about the disc **
  mci_CD_RegDisc_Parms = record
    LowestTrackNum    : Byte;                  // lowest track number
    HighestTrackNum   : Byte;                  // highest track number
    UPC               : array[0..upc_Size-1] of Byte; // upc, 13 BCD + 4bit 0
    DiscID            : mci_CD_ID;             // Disc ID
  end;

  //** Information about each track **
  mci_CD_RegTrack_Rec = record
    TrackNum          : Byte;                  // track number
    ulStartAddr       : uLong;                 // starting address in MMTIME
    ulEndAddr         : uLong;                 // ending address
    TrackControl      : Byte;                  // track control information
  end;

  //** Track information, used to verify address **
  mci_CD_RegTracks_Parms = record
   TrackRecArr        : ^mci_CD_RegTrack_Rec;  // ptr to array of track recs
   ulBufSize          : uLong;                 // size of buffer
  end;

  // Environment settings to save and restore
  mciDrv_CD_Save_Parms = record
    ulPosition        : uLong;                 // current position in MMTIME
    ulEndPlay         : uLong;                 // end play position
    ulMode            : uLong;                 // Play mode: playing, paused, etc.
    ulLevel           : uLong;                 // volume levels
    ulVSDData         : uLong;                 // Extra VSD data storage area
  end;

const
  // Read Long (2352-Byte) Sectors

  // Flag for the MCIDRV_CD_READ_Long message
  //   Default addressing mode for the ulFrom field is Hardware Red Book.
  //   Absolute sector addressing for ISO-9660, or High Sierra Group
  //   requires a flag, as does an MMTIME address.

  MCI_CD_READLong_HSG           = $00000100;
  MCI_CD_READLong_MMTIME        = $00000200;

type
  mci_CD_ReadLong_Parms = record
    ulFrom            : uLong;                 // read from this position
    usCount           : UShort;                // Number of sectors to read
    pReturn           : Pointer;               // Pointer to return buffer
    ulRetSize         : uLong;                 // Return buffer size
  end;

const
  // CD Table INI file, MMPMCD.INI, values

  // Capability Flags I from the CD drive look-up table, MMPMCD.INI
  CDHW_CAP_CAN_EJECT            = $00000001;  // Can software eject disc
  CDHW_CAP_CAN_LOCK             = $00000002;  // Can lock drive/disable eject
  CDHW_CAP_READS_RAW            = $00000004;  // Can read raw sectors
  CDHW_CAP_CAN_WRITE            = $00000008;  // Can write to disc
  CDHW_CAP_CAN_PLAY             = $00000010;  // Can play CD-DA tracks
  CDHW_CAP_CAN_INTERLEV         = $00000020;  // Supports ISO-9660 interleaving
  CDHW_CAP_CAN_PREFETCH         = $00000080;  // Can prefetch internally
  CDHW_CAP_MANIP_AUDIO          = $00000100;  // Can manipulte audio channels
  CDHW_CAP_USES_REDBOOK         = $00000200;  // Can use Red Book mode
  CDHW_CAP_READS_XA             = $00000400;  // Can read CD-ROM/XA data
  CDHW_CAP_CONT_READS           = $00000800;  // Continues to read DA after stop
  CDHW_CAP_CAN_REVERSE          = $00001000;  // Can play in reverse
  CDHW_CAP_READS_CDDA           = $40000000;  // Can read CD-DA audio tracks

  // Capability Flags II from the CD drive look-up table, MMPMCD.INI
  CDHW_VOL_DEP_MASK             = $00000007;  // Volume dependency mask
  CDHW_VOL_DEP_NONE             = 0;  // Volume without dependency
  CDHW_VOL_DEP_HIGH             = 2;  // Volume is highest value
  CDHW_VOL_DEP_LOW              = 3;  // Volume is lowest value
  CDHW_VOL_DEP_LEFT             = 4;  // Volume is left volume
  CDHW_VOL_DEP_RIGHT            = 5;  // Volume is right volume
  CDHW_VOL_INDEP_MUTE           = $00000008;  // Mute has no dependency
  CDHW_CAP_LOCK_MOUNT           = $00000010;  // Can only lock when mounted
  CDHW_CAP_PLAY_VIDEO           = $00000020;  // Can play video
  CDHW_CAP_MODAL_ONLY           = $00000040;  // Stop req to interrupt PLAY
  CDHW_CAP_SUP_SEEK             = $00000080;  // Supports SEEK IOCTL
  CDHW_CAP_SUP_UPC              = $00000100;  // Supports UPC IOCTL
  CDHW_CAP_SUP_SUBCHAN          = $00000200;  // Supports sub-channel IOCTL
  CDHW_CAP_CAN_CLS_TRAY         = $00000400;  // Can close door/retract caddy
  CDHW_CAP_NO_STREAM            = $00001000;  // Cannot stream CD-DA when PDD
                                          //   says it can
  CDHW_CAP_VAR_PLAY             = $80000000;  // Supports variable speeds

// INI file record structure
  CDINI_APPSIZE                 = 8;           // Application name size
  CDINI_KEYSIZE                 = 16;          // Key name size
  CDINI_VSD_NAME_SIZE           = 8;           // size of file name
  VOLUME_CONTROL                = 101;         // num of values, 0% - 100%

type
  mmpmCD_Rec = record
    usEntryVer        : UShort;                // Entry version
    ulCaps1           : uLong;                 // Capability flag I
    ulCaps2           : uLong;                 // Capability flag II
    VSDName           : array[0..CDINI_VSD_NAME_SIZE-1] of Char; // DLL name for VSD
    ulMinStart        : uLong;                 // Min starting addr, 0x00MMSSFF
    usVolCnt          : UShort;                // volume level counter
    ausVolValues      : array[0..Volume_Control] of UShort;  // volume control values
  end;

{----[ MCDOS2 ]----}

const
  // Multimedia Extensions MCD structures and definitions

  LIST_LEN                      = 8;

  LINE_IN_ON                    = $00000001;
  MIC_ON                        = $00000002;
  LINE_OUT_ON                   = $00000004;

type
  // RIFF to ACPA Mode conversion Table
  RiffTable = record
    ulDataType        : uLong;
    ulAUDIODDMode     : uLong;
  end;

  mci_Port_list = record
    ulDevType         : uLong;
    ulDevNum          : uLong;
  end;

type
  // Amp/Mixer instance structure declaration
  mci_Amp_Instance = record
    szDeviceName             : array[0..127] of Char;
    szDriverName             : array[0..15] of Char;
    hFile                    : HFILE;
    usDeviceID               : UShort;
    ulGlobalFile             : uLong;

    usMasterVolume           : UShort;
    lLeftVolume              : Long;
    lRightVolume             : Long;
    lVolumeDelay             : Long;

    lBalance                 : Long;

    lBalanceDelay            : Long;

    lBass                    : Long;

    lTreble                  : Long;

    lPitch                   : Long;
    lGain                    : Long;

    lSRate                   : Long;
    lBitsPerSRate            : Long;
    lBsize                   : Long;
    sMode                    : Short;
    sChannels                : Short;
    ulFlags                  : uLong;
    lMonitor                 : Long;
    lInput                   : Long;
    lOutput                  : Long;
    ulOperation              : uLong;
    ulGainLevel              : uLong;


    ulStoreRVolume           : uLong;
    ulStoreLVolume           : uLong;


    ulDosOpened              : uLong;
    ulInitOpen               : uLong;
    ulMasterVolume           : uLong;
    ulActive                 : uLong;
    lStoreSRate              : Long;
    lStoreBitsPerSRate       : Long;
    ulStoreOperation         : uLong;
    sStoreMode               : Short;
    sStoreChannels           : Short;
    ulSetAmpDefaults         : uLong;
    ulDefaultsSet            : uLong;

    ulOutputDev              : uLong;
    ulInputDev               : uLong;
    ulResourcesUsed          : uLong;
    ulRestoreNotify          : uLong;
    ulCallback               : uLong;
    sUserParm                : Short;
    lNotifyFlag              : Long;

// NEEDS THINKING!
//  Long  ( * APIENTRY pfnAUDIOIF) ( Pointer, Long, Long, Long, Long);
    hmtxInstanceSem          : HMTX;
    ulClass                  : uLong;
    ulBlockAlignment         : uLong;
    ulHardwareMode           : uLong;
    rInputList               : array[ 0..LIST_LEN ] of mci_Port_List;
    rOutputList              : array[ 0..LIST_LEN ] of mci_Port_List;
    ulNumInputs              : uLong;
    ulNumOutputs             : uLong;

    ulDataType               : uLong;
    ulSubType                : uLong;
    ulBytesPerBlock          : uLong;
    ulMMTimePerBlock         : uLong;

    // New resource management stuff
    pAudioModeData           : Pointer;      // ptr to dev. specific resource data
    pResourceDLL             : array[0..127] of Char;

    pProdInfo                : pChar;     // pointer to the product name
    ulDeviceID               : uLong;     // pointer to the device id.
    ulNumMappingRows         : uLong;     // num of RIFF->AUDIODD mapping modes
    ulMatch                  : uLong;
    pMapTable                : ^RiffTable; // additional RIFF->AUDIODD mappings

    ulNumDataTypes           : uLong;     // number of datatypes to check
    pDataTypeTable           : Pointer;
    fMute                    : Bool;
    ulResourceID             : uLong;     // offset in the resource dll to use
    ulConnDefaults           : uLong;     // Default values for connectors
  end;
  pmci_Amp_Instance = ^mci_Amp_Instance;

{----[ OS2MIXER ]----}

// Multimedia Mixer Software Development Kit Include File

type
  hMixer  = uLong;
  phMixer = ^hMixer;

  MixerLineInfo = record
    ulLength              : uLong;    //length of the struct
    ulNumChannels         : uLong;    // number of channels on input
    ulSupport             : uLong;    // supported functionality (MIXLINEINFO)
    ulConnectionsPossible : uLong;    // lines connectable to
    ulLine                : uLong;    // which line to operate on
  end;
  pMixerLineInfo = ^MixerLineInfo;

  LineConnections = record
    ulLength              : uLong;    // length of the struct
    ulConnection          : uLong;
    ulLine                : uLong;
    ulFlags               : uLong;
  end;
  pLineConnections = ^LineConnections;

  MixerControl = record
    ulLength              : uLong;    // length of the struct
    ulLine                : uLong;
    ulControl             : uLong;
    ulSetting             : uLong;
  end;
  pMixerControl = ^MixerControl;

const
  // -- need masteraudio command for the following.
  // flags for MIXERLINEINFO ulSupport field
  MIX_BALANCE                   = MCI_AMP_SET_BALANCE;     // separate balance volume control
  MIX_ALC                       = MCI_AMP_SET_ALC;         // supports Auto Level Control
  MIX_MONITOR                   = MCI_AMP_SET_MONITOR;     // supports Monitor Control
  MIX_CROSSOVER                 = MCI_AMP_SET_CROSSOVER;   // supports crossover change
  MIX_LOUDNESS                  = MCI_AMP_SET_LOUDNESS;    // supports loudness equalization
  MIX_MUTE                      = MCI_AMP_SET_MUTE;        // supports channel mute
  MIX_REVERB                    = MCI_AMP_SET_REVERB;      // supports reverb
  MIX_STEREOENHANCE             = MCI_AMP_SET_STEREOENHANCE;// supports stereo enhance
  MIX_CUSTOM1                   = MCI_AMP_SET_CUSTOM1;     // supports custom effect #1
  MIX_CUSTOM2                   = MCI_AMP_SET_CUSTOM2;     // supports custom effect #2
  MIX_CUSTOM3                   = MCI_AMP_SET_CUSTOM3;     // supports custom effect #3
  MIX_LRVOLUME                  = MCI_AMP_SET_LRVOLUME;    // separate left-right volume control
  MIX_BASS                      = MCI_AMP_SET_BASS;        // supports Bass
  MIX_MID                       = MCI_AMP_SET_MID;         // supports Mid
  MIX_TREBLE                    = MCI_AMP_SET_TREBLE;      // supports Treble
  MIX_PITCH                     = MCI_AMP_SET_PITCH;       // supports pitch modifications
  MIX_GAIN                      = MCI_AMP_SET_GAIN;        // supports gain modifications
  MIX_CHORUS                    = MCI_AMP_SET_CHORUS;      // supports Bass
  MIX_VOLUME                    = MCI_AMP_SET_VOLUME;      // supports volume controls

  MIX_STEREO_OFF                = $00000000;
  MIX_STEREO_STUDIO             = $40004000;
  MIX_STEREO_HALL               = $80008000;
  MIX_STEREO_STADIUM            = $c000c000;

  MCI_STEREO_OFF                = $00000000;
  MCI_STEREO_STUDIO             = $00000001;
  MCI_STEREO_HALL               = $00000002;
  MCI_STEREO_STADIUM            = $00000004;


  MIX_LOUDNESS_OFF              = $00000000;
  MIX_LOUDNESS_ON               = $FFFFFFFF;

  MCI_LOUDNESS_OFF              = $00000000;
  MCI_LOUDNESS_ON               = $00000001;

  // ERROR MESSAGES
  MIXERR_BASE                   = 512;

  MIXERR_NOERR                  = 0;
  MIXERR_INVALIDHANDLE          = MIXERR_BASE+0;
  MIXERR_INVALIDINPUT           = MIXERR_BASE+1;
  MIXERR_INVALIDOUTPUT          = MIXERR_BASE+2;
  MIXERR_NOTSUPPORTED           = MIXERR_BASE+7;

  // INPUT LINES
  // SOURCES
  IN_SYNTHESIZER                = 0;
  IN_MIXER                      = 1;
  IN_EXTERNAL                   = 2;
  IN_INTERNAL                   = 3;
  IN_MICROPHONE                 = 4;
  IN_PCM                        = 5;
  IN_PC_SPEAKER                 = 6;

  // SINKS
  OUT_AMPLIFIER                 = 0;
  OUT_PCM                       = 1;

  // SOURCES
  SOURCE_SYNTHESIZER            = $000000001;
  SOURCE_LINE                   = $000000002;
  SOURCE_INTERNAL_AUDIO         = $000000004;
  SOURCE_MICROPHONE             = $000000008;
  SOURCE_WAVE                   = $000000010;
  SOURCE_PC_SPEAKER             = $000000020;

  // SINKS
  SINK_LINE_OUT                 = $000000001;
  SINK_SPEAKER                  = $000000002;
  SINK_HEADPHONES               = $000000004;
  SINK_NULL                     = $000000008;
  SINK_ALL                      = $000000010;

{----[ SHDD ]----}

// Multimedia Extensions Stream Handler Device Driver Interfaces
// Block defintions.

type
  shdfn = pointer;
  ddcmdfn = pointer;

const
  // DDCMD Defines
  DDCMD_SETUP                   = 0;
  DDCMD_READ                    = 1;
  DDCMD_WRITE                   = 2;
  DDCMD_STATUS                  = 3;
  DDCMD_CONTROL                 = 4;
  DDCMD_REG_STREAM              = 5;
  DDCMD_DEREG_STREAM            = 6;

type
  ddCmdCommon = record
    ulFunction        : uLong;                 // Function requested by SH
    Stream            : hStream;               // data stream instance
  end;
  pddCmdCommon = ^ddCmdCommon;

  ddCmdSetup = record
    ulFunction        : uLong;                 // Function requested by SH
    hStream           : HSTREAM;
    pSetupParm        : Pointer;               // see SETUP_PARM struct
    ulSetupParmSize   : uLong;                 // see SETUP_PARM struct
  end;
  pddCmdSetup = ^ddCmdSetup;

  // SETUP_PARM structure
  Setup_Parm = record                          //  DDCMDSETUP parameter block
    ulStreamTime      : uLong;                 // stream time in milliseconds
    ulFlags           : uLong;                 // various flags (input/output)
    // NOTE: new fields will be added here
  end;
  pSetup_Parm = ^Setup_Parm;

const
  // ulFlag defines
  SETUP_RECURRING_EVENTS        = $00000001;
                // the device driver sets this flag on return from the
                // DDCMD_SETUP command if the device driver assumes events
                // are recurring events---in this case, the stream handler
                // will not have to re-enable a recurring event each time
                // the event occurs by sending a DDCMD_CONTROL command to
                // the device driver.  this is useful when CUE_TIME or
                // DATA_CUE events are expected to be used as RECURRING

type
  ccCmdReadWrite = record
    ulFunction        : uLong;                 // Function requested by SH
    hStream           : HSTREAM;
    pBuffer           : Pointer;
    ulBufferSize      : uLong;
    pProcessLin       : Pointer;
  end;
  pccCmdReadWrite = ^ccCmdReadWrite;
  ppccCmdReadWrite = ^pccCmdReadWrite;

  ccCmdStatus = record
    ulFunction        : uLong;                 // Function requested by SH
    hStream           : HSTREAM;
    pStatus           : Pointer;               // (output)ptr to current position time
    ulStatusSize      : uLong;                 // (output)size of position time
  end;
  pccCmdStatus = ^ccCmdStatus;

  // STATUS_PARM structure
  Status_Parm = record                         // DDCMDSTATUS parameter block
    ulTime            : uLong;                 // current position time in milliseconds
    // NOTE: new fields will be added here
  end;
  pStatus_Parm = ^Status_Parm;

  ddCmdControl = record
    ulFunction        : uLong;                 // Function requested by SH
    hStream           : HSTREAM;
    hEvent            : hEvent;                // used for EVENTS only
    ulCmd             : uLong;
    pParm             : Pointer;               // see CONTROL_PARM structure
    ulParmSize        : uLong;                 // see CONTROL_PARM structure
  end;
  pddCmdControl = ^ddCmdControl;

const
  // ulCmd defines
  DDCMD_START                   = 1;           // start device
  DDCMD_STOP                    = 2;           // stop device and return current position in pParm
  DDCMD_PAUSE                   = 3;           // pause device and return current position in pParm
  DDCMD_RESUME                  = 4;           // resume device
  DDCMD_ENABLE_EVENT            = 5;           // ask PDD to create this event
  DDCMD_DISABLE_EVENT           = 6;           // ask PDD to purge this event
  DDCMD_PAUSE_TIME              = 7;           // pause time keeping, but not the stream
  DDCMD_RESUME_TIME             = 8;           // resume time keeping.

type
  // CONTROL_PARM structure
  Control_Parm = record                        // DDCMDCONTROL parameter block
    ulTime            : uLong;                 // time in milliseconds
                                               // SH sets cuetime when ulCmd is ENABLE_EVENT
                                               // PDD returns current time for STOP, PAUSE
    evcb              : TIME_EVCB;
  end;
  pControl_Parm = ^Control_Parm;

  ddCmdRegister = record
    ulFunction        : uLong;                 // Function requested by SH
    hStream           : HSTREAM;               // Stream handle needed @ interrupt time
    ulSysFileNum      : uLong;                 // Device Handle so pdd can map device instance to hstream
    pSHDEntryPoint    : SHDFN;                 // Stream handler entry point
    ulStreamOperation : uLong;                 // SH input Record or play
    spcbkey           : SPCBKEY;
    ulBufSize         : uLong;                 // PDD output (optional) buffer size in bytes for SPCB
    ulNumBufs         : uLong;                 // PDD output (optional) # of buffers for SPCB
    ulAddressType     : uLong;                 // PDD output (required) addr ptr type to data buffer
    ulBytesPerUnit    : uLong;                 // PDD output (required)
    mmtimePerUnit     : MMTIME;                // PDD output (required)
    dcbAudio          : E_DCB;                 // SH input Device Control Block
    hid               : HID;                   // SH input stream handler id
  end;
  pddCmdRegister = ^ddCmdRegister;

const
  // ulStreamOperation  defines
  STREAM_OPERATION_MASK         = $C000;
  STREAM_OPERATION_CONSUME      = $8000;
  STREAM_OPERATION_PRODUCE      = $C000;

  // ulAddressType  defines
  // The PDD will tell the SH what type of address ptr it expects the data buffer
  // to be.  The SH will then request this address type to the SSM, so that the
  // SSM will send the correct type of each buffer request.
  ADDRESS_TYPE_VIRTUAL          = 0;
  ADDRESS_TYPE_PHYSICAL         = 1;              //default
  ADDRESS_TYPE_LINEAR           = 2;

type
  ddCmdDeregister = record
    ulFunction        : uLong;                 // Function requested by SH
    Stream            : hStream;               // Stream handle needed @ interrupt time
  end;
  pddCmdDeregister = ^ddCmdDeregister;

//*** RING 0 Stream Handler SHD Interfaces                                **

const
  // RING 0 Stream Handler  SHD's:
  SHD_REPORT_INT                = 0;           // PDD reports interrupt has arrived
  SHD_REPORT_EVENT              = 1;           // PDD reports cuetime has arrived

type
  shd_Common = record
    ulFunction        : uLong;                 // Function requested by PDD
    Stream            : hStream;               // Stream handle needed @ interrupt time
  end;
  pshd_Common = ^shd_Common;

  shd_ReportInt = record
    ulFunction        : uLong;                 // Function requested by PDD
    hStream           : HSTREAM;               // so SH knows which stream to process
    pBuffer           : Pointer;               // return ptr to last used buffer
    ulFlag            : uLong;                 // reason for interrupt
    ulStatus          : uLong;                 // rc or bytes read/written
    ulStreamTime      : uLong;                 // time in milliseconds of stream position
  end;
  pshd_ReportInt = ^shd_ReportInt;

const
  // ulFlag settings
  ERROR                         = $80;
  STREAM_STOP_NOW               = $40;
  SHD_READ_COMPLETE             = 1;
  SHD_WRITE_COMPLETE            = 2;

type
  shd_ReportEvent = record
    ulFunction        : uLong;                 // Function requested by PDD
    hStream           : HSTREAM;               // so SH knows which stream to process
    hEvent            : hEvent;                // event handle pass back to stream handler
    ulStreamTime      : uLong;                 // time in milliseconds of stream position
  end;
  pshd_ReportEvent = ^shd_ReportEvent;


//*** RING 3 Stream Handler SHD Interfaces                                **

const
  // RING 3 Stream Handler  SHD's: (Uses SpiSendMsg as interface)
  SHC_REPORT_INT                = $80000000;   // ulMsgType for SHD_REPORT_INT
  SHC_REPORT_EVENT              = $80000001;   // ulMsgType for SHD_REPORT_EVENT

type
  // MSG_REPORTINT Control Block.
  // pMsg field of SpiSendMsg api
  msg_ReportInt = record
    ulMsgLen          : uLong;                 // Length of structure
    pBuffer           : Pointer;               // return ptr to last used buffer
    ulFlag            : uLong;                 // reason for interrupt
    ulStatus          : uLong;                 // rc or bytes read/written
    ulStreamTime      : uLong;                 // time in milliseconds of stream position
  end;
  pmsg_ReportInt = ^msg_ReportInt;

   // For ulFlag defines, refer to the _shd_reportint_parm structure

type
  // MSG_REPORTEVENT Control Block.
  //  pMsg field of SpiSendMsg api
  msg_ReportEvent = record
    ulMsgLen          : uLong;                 // Length of structure
    hevent            : hEvent;                // event handle pass back to stream handler
    ulStreamTime      : uLong;                 // time in milliseconds of stream position
  end;
  pmsg_ReportEvent = ^msg_ReportEvent;

implementation

function mciPlayFile;                          external;
function mciPlayResource;                      external;
function mciRecordAudioFile;                   external;
function mciSendCommand;                       external;
function mciSendString;                        external;
function mciGetErrorString;                    external;
function mciMakeGroup;                         external;
function mciDeleteGroup;                       external;
function mciSetSysValue;                       external;
function mciQuerySysValue;                     external;
function mciGetDeviceID;                       external;

function SpiAssociate;                         external;
function SpiEnumerateHandlers;                 external;
function SpiGetHandler;                        external;
function SpiCreateStream;                      external;
function SpiSendMsg;                           external;
function SpiDestroyStream;                     external;
function SpiGetTime;                           external;
function SpiSeekStream;                        external;
function SpiStartStream;                       external;
function SpiStopStream;                        external;
function SpiDisableEvent;                      external;
function SpiEnableEvent;                       external;
function spiDisableSync;                       external;
function spiEnableSync;                        external;
function spiDetermineSyncMaster;               external;
function spiGetProtocol;                       external;
function spiInstallProtocol;                   external;
function spiEnumerateProtocols;                external;

function mdmDriverNotify;                      external;

function mmioRemoveElement;                    external;
function mmioFindElement;                      external;
function mmioAdvance;                          external;
function mmioAscend;                           external;
function mmioClose;                            external;
function mmioCreateChunk;                      external;
function mmioDescend;                          external;
function mmioFlush;                            external;
function mmioGetInfo;                          external;
function mmioGetLastError;                     external;
function mmioInstallIOProc;                    external;
function mmioIOProc;                           external;
function mmioOpen;                             external;
function mmioRead;                             external;
function mmioSeek;                             external;
function mmioSendMessage;                      external;
function mmioSetBuffer;                        external;
function mmioSetInfo;                          external;
function mmioStringToFourCC;                   external;
function mmioWrite;                            external;

function mmioCFOpen;                           external;
function mmioCFClose;                          external;
function mmioCFGetInfo;                        external;
function mmioCFSetInfo;                        external;
function mmioCFFindEntry;                      external;
function mmioCFAddEntry;                       external;
function mmioCFChangeEntry;                    external;
function mmioCFDeleteEntry;                    external;
function mmioCFAddElement;                     external;
function mmioCFCopy;                           external;

function mmioQueryFormatCount;                 external;
function mmioGetFormats;                       external;
function mmioGetFormatName;                    external;
function mmioIdentifyFile;                     external;
function mmioQueryHeaderLength;                external;
function mmioGetHeader;                        external;
function mmioSetHeader;                        external;
function mmioIniFileHandler;                   external;
function mmioIdentifyStorageSystem;            external;
function mmioDetermineSSIOProc;                external;
function mmioQueryIOProcModuleHandle;          external;
function mmioCFCompact;                        external;
function mmioMigrateIniFile;                   external;
function mmioIniFileCODEC;                     external;
function mmioSet;                              external;
function mmioQueryCODECName;                   external;
function mmioQueryCODECNameLength;             external;
function mmioLoadCODECProc;                    external;
function mmioGetData;                          external;

function WinSecondaryWindow;                   external;
function WinLoadSecondaryWindow;               external;
function WinProcessSecondaryWindow;            external;
function WinCreateSecondaryWindow;             external;
function WinDefaultSize;                       external;
function WinInsertDefaultSize;                 external;
function WinQuerySecondaryhwnd;                external;
function WinSecondaryMessageBox;               external;
function WinDismissSecondaryWindow;            external;
function WinDestroySecondaryWindow;            external;
function WinDefSecondaryWindowProc;            external;

function WinRegisterGraphicButton;             external;

Function DiveQueryCaps;                        external;
Function DiveOpen;                             external;
Function DiveSetupBlitter;                     external;
Function DiveBlitImage;                        external;
Function DiveClose;                            external;
Function DiveAcquireFrameBuffer;               external;
Function DiveSwitchBank;                       external;
Function DiveDeacquireFrameBuffer;             external;
Function DiveCalcFrameBufferAddress;           external;
Function DiveAllocImageBuffer;                 external;
Function DiveFreeImageBuffer;                  external;
Function DiveBeginImageBufferAccess;           external;
Function DiveEndImageBufferAccess;             external;
Function DiveSetDestinationPalette;            external;
Function DiveSetSourcePalette;                 external;

initialization
  FourCC_RIFF := mmioFourCC( 'R', 'I', 'F', 'F' );
  FourCC_LIST := mmioFourCC( 'L', 'I', 'S', 'T' );
  FourCC_MEM  := mmioFourCC( 'M', 'E', 'M', ' ' );
  FourCC_DOS  := mmioFourCC( 'D', 'O', 'S', ' ' );
  FourCC_BND  := mmioFourCC( 'B', 'N', 'D', ' ' );
  FourCC_FREE := mmioFourCC( 'F', 'R', 'E', 'E' );
  FourCC_DEL  := mmioFourCC( 'D', 'E', 'L', ' ' );
  FourCC_CTOC := mmioFourCC( 'C', 'T', 'O', 'C' );
  FourCC_CGRP := mmioFourCC( 'C', 'G', 'R', 'P' );
  FourCC_CF   := mmioFourCC( 'C', 'F', ' ', ' ' );
  FOURCC_ULTI := mmioFOURCC( 'U', 'L', 'T', 'I' );
  FourCC_RT21 := mmioFOURCC( 'R', 'T', '2', '1' );
  FourCC_DIB  := mmioFOURCC( 'D', 'I', 'B', ' ' );
end.

