{******************************************************************}
{                                                       	   }
{       Borland Delphi Runtime Library                  	   }
{       Microsoft Audio Compression Manager interface unit         }
{ 								   }
{ Portions created by Microsoft are 				   }
{ Copyright (C) 1995-1999 Microsoft Corporation. 		   }
{ All Rights Reserved. 						   }
{ 								   }
{ The original file is: msacm.h, released 9 March 1999.            }
{ The original Pascal code is: MSAcm.pas, released 21 July 1999.   }
{ The initial developer of the Pascal code is Francois Piette      }
{ francois.piette@swing.be, http://www.rtfm.be/fpiette/indexuk.htm }
{ rue de Grady 24, 4053 Embourg, Belgium                           }
{ 								   }
{ Portions created by Francois Piette are			   }
{ Copyright (C) 1999 Francois Piette.    		           }
{ 								   }
{ Contributor(s): Marcel van Brakel (brakelm@bart.nl)              }
{ 								   }
{ Obtained through:                               	           }
{ Joint Endeavour of Delphi Innovators (Project JEDI)              }
{								   }
{ You may retrieve the latest version of this file at the Project  }
{ JEDI home page, located at http://delphi-jedi.org                }
{								   }
{ The contents of this file are used with permission, subject to   }
{ the Mozilla Public License Version 1.1 (the "License"); you may  }
{ not use this file except in compliance with the License. You may }
{ obtain a copy of the License at                                  }
{ http://www.mozilla.org/MPL/MPL-1.1.html	                   }
{                                                                  }
{ Software distributed under the License is distributed on an 	   }
{ "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or   }
{ implied. See the License for the specific language governing     }
{ rights and limitations under the License. 			   }
{ 								   }
{******************************************************************}

unit MSAcm;

{$WEAKPACKAGEUNIT}

interface

{$HPPEMIT ''}
{$HPPEMIT '#include "MSAcm.h"'}
{$HPPEMIT ''}

uses
  Windows, MMSystem;

type
  PWaveFilter = ^TWaveFilter;
  // Defined in mmreg.h
  WAVEFILTER = packed record
    cbStruct: DWORD;                    // Size of the filter in bytes
    dwFilterTag: DWORD;                 // filter type
    fdwFilter: DWORD;                   // Flags for the filter (Universal Dfns)
    dwReserved: array [0..4] of DWORD;  // Reserved for system use
  end;
  TWaveFilter = WAVEFILTER;

const
  DRV_MAPPER_PREFERRED_INPUT_GET  = DRV_USER + 0;
  {$EXTERNALSYM DRV_MAPPER_PREFERRED_INPUT_GET}
  DRV_MAPPER_PREFERRED_OUTPUT_GET = DRV_USER + 2;
  {$EXTERNALSYM DRV_MAPPER_PREFERRED_OUTPUT_GET}
  DRVM_MAPPER_STATUS              = $2000;
  {$EXTERNALSYM DRVM_MAPPER_STATUS}
  WIDM_MAPPER_STATUS              = DRVM_MAPPER_STATUS + 0;
  {$EXTERNALSYM WIDM_MAPPER_STATUS}
  WAVEIN_MAPPER_STATUS_DEVICE     = 0;
  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_DEVICE}
  WAVEIN_MAPPER_STATUS_MAPPED     = 1;
  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_MAPPED}
  WAVEIN_MAPPER_STATUS_FORMAT     = 2;
  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_FORMAT}
  WODM_MAPPER_STATUS              = DRVM_MAPPER_STATUS + 0;
  {$EXTERNALSYM WODM_MAPPER_STATUS}
  WAVEOUT_MAPPER_STATUS_DEVICE    = 0;
  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_DEVICE}
  WAVEOUT_MAPPER_STATUS_MAPPED    = 1;
  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_MAPPED}
  WAVEOUT_MAPPER_STATUS_FORMAT    = 2;
  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_FORMAT}

//--------------------------------------------------------------------------
//
//  ACM General API's and Defines
//
//--------------------------------------------------------------------------

//  there are four types of 'handles' used by the ACM. the first three
//  are unique types that define specific objects:
//
//  HACMDRIVERID: used to _identify_ an ACM driver. this identifier can be
//  used to _open_ the driver for querying details, etc about the driver.
//
//  HACMDRIVER: used to manage a driver (codec, filter, etc). this handle
//  is much like a handle to other media drivers--you use it to send
//  messages to the converter, query for capabilities, etc.
//
//  HACMSTREAM: used to manage a 'stream' (conversion channel) with the
//  ACM. you use a stream handle to convert data from one format/type
//  to another--much like dealing with a file handle.
//
//
//  the fourth handle type is a generic type used on ACM functions that
//  can accept two or more of the above handle types (for example the
//  acmMetrics and acmDriverID functions).
//
//  HACMOBJ: used to identify ACM objects. this handle is used on functions
//  that can accept two or more ACM handle types.

type
  HACMDRIVERID__ = record
    Unused: Integer;
  end;
  {$EXTERNALSYM HACMDRIVERID__}
  HACMDRIVERID = ^HACMDRIVERID__;
  {$EXTERNALSYM HACMDRIVERID}
  PHACMDRIVERID = ^HACMDRIVERID;
  {$EXTERNALSYM PHACMDRIVERID}
  LPHACMDRIVERID = ^HACMDRIVERID;
  {$EXTERNALSYM LPHACMDRIVERID}

  HACMDRIVER__ = record
    Unused: Integer;
  end;
  {$EXTERNALSYM HACMDRIVER__}
  HACMDRIVER = ^HACMDRIVER__;
  {$EXTERNALSYM HACMDRIVER}
  PHACMDRIVER = ^HACMDRIVER;
  {$EXTERNALSYM PHACMDRIVER}
  LPHACMDRIVER = ^HACMDRIVER;
  {$EXTERNALSYM LPHACMDRIVER}

  HACMSTREAM__ = record
    Unused: Integer;
  end;
  {$EXTERNALSYM HACMSTREAM__}
  HACMSTREAM = ^HACMSTREAM__;
  {$EXTERNALSYM HACMSTREAM}
  PHACMSTREAM = ^HACMSTREAM;
  {$EXTERNALSYM PHACMSTREAM}
  LPHACMSTREAM = ^HACMSTREAM;
  {$EXTERNALSYM LPHACMSTREAM}

  HACMOBJ__ = record
    Unused: Integer;
  end;
  {$EXTERNALSYM HACMOBJ__}
  HACMOBJ = ^HACMOBJ__;
  {$EXTERNALSYM HACMOBJ}
  PHACMOBJ = ^HACMOBJ;
  {$EXTERNALSYM PHACMOBJ}
  LPHACMOBJ = ^HACMOBJ;
  {$EXTERNALSYM LPHACMOBJ}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
//  ACM Error Codes
//
//  Note that these error codes are specific errors that apply to the ACM
//  directly--general errors are defined as MMSYSERR_*.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

type
  MMRESULT = UINT;
  {$EXTERNALSYM MMRESULT}

const
  ACMERR_BASE        = 512;
  {$EXTERNALSYM ACMERR_BASE}
  ACMERR_NOTPOSSIBLE = (ACMERR_BASE + 0);
  {$EXTERNALSYM ACMERR_NOTPOSSIBLE}
  ACMERR_BUSY        = (ACMERR_BASE + 1);
  {$EXTERNALSYM ACMERR_BUSY}
  ACMERR_UNPREPARED  = (ACMERR_BASE + 2);
  {$EXTERNALSYM ACMERR_UNPREPARED}
  ACMERR_CANCELED    = (ACMERR_BASE + 3);
  {$EXTERNALSYM ACMERR_CANCELED}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
//  ACM Window Messages
//
//  These window messages are sent by the ACM or ACM drivers to notify
//  applications of events.
//
//  Note that these window message numbers will also be defined in
//  mmsystem.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

const
  MM_ACM_OPEN  = MM_STREAM_OPEN;     // conversion callback messages
  {$EXTERNALSYM MM_ACM_OPEN}
  MM_ACM_CLOSE = MM_STREAM_CLOSE;
  {$EXTERNALSYM MM_ACM_CLOSE}
  MM_ACM_DONE  = MM_STREAM_DONE;
  {$EXTERNALSYM MM_ACM_DONE}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
//  acmGetVersion()
//
//  the ACM version is a 32 bit number that is broken into three parts as
//  follows:
//
//      bits 24 - 31:   8 bit _major_ version number
//      bits 16 - 23:   8 bit _minor_ version number
//      bits  0 - 15:   16 bit build number
//
//  this is then displayed as follows:
//
//      bMajor = (BYTE)(dwVersion >> 24)
//      bMinor = (BYTE)(dwVersion >> 16) &
//      wBuild = LOWORD(dwVersion)
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

function acmGetVersion: DWORD; stdcall;
{$EXTERNALSYM acmGetVersion}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmMetrics()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmMetrics(hao: HACMOBJ; uMetric: UINT; var pMetric): MMRESULT; stdcall;
{$EXTERNALSYM acmMetrics}

const
  ACM_METRIC_COUNT_DRIVERS          = 1;
  {$EXTERNALSYM ACM_METRIC_COUNT_DRIVERS}
  ACM_METRIC_COUNT_CODECS           = 2;
  {$EXTERNALSYM ACM_METRIC_COUNT_CODECS}
  ACM_METRIC_COUNT_CONVERTERS       = 3;
  {$EXTERNALSYM ACM_METRIC_COUNT_CONVERTERS}
  ACM_METRIC_COUNT_FILTERS          = 4;
  {$EXTERNALSYM ACM_METRIC_COUNT_FILTERS}
  ACM_METRIC_COUNT_DISABLED         = 5;
  {$EXTERNALSYM ACM_METRIC_COUNT_DISABLED}
  ACM_METRIC_COUNT_HARDWARE         = 6;
  {$EXTERNALSYM ACM_METRIC_COUNT_HARDWARE}
  ACM_METRIC_COUNT_LOCAL_DRIVERS    = 20;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_DRIVERS}
  ACM_METRIC_COUNT_LOCAL_CODECS     = 21;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_CODECS}
  ACM_METRIC_COUNT_LOCAL_CONVERTERS = 22;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_CONVERTERS}
  ACM_METRIC_COUNT_LOCAL_FILTERS    = 23;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_FILTERS}
  ACM_METRIC_COUNT_LOCAL_DISABLED   = 24;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_DISABLED}
  ACM_METRIC_HARDWARE_WAVE_INPUT    = 30;
  {$EXTERNALSYM ACM_METRIC_HARDWARE_WAVE_INPUT}
  ACM_METRIC_HARDWARE_WAVE_OUTPUT   = 31;
  {$EXTERNALSYM ACM_METRIC_HARDWARE_WAVE_OUTPUT}
  ACM_METRIC_MAX_SIZE_FORMAT        = 50;
  {$EXTERNALSYM ACM_METRIC_MAX_SIZE_FORMAT}
  ACM_METRIC_MAX_SIZE_FILTER        = 51;
  {$EXTERNALSYM ACM_METRIC_MAX_SIZE_FILTER}
  ACM_METRIC_DRIVER_SUPPORT         = 100;
  {$EXTERNALSYM ACM_METRIC_DRIVER_SUPPORT}
  ACM_METRIC_DRIVER_PRIORITY        = 101;
  {$EXTERNALSYM ACM_METRIC_DRIVER_PRIORITY}

//--------------------------------------------------------------------------;
//
//  ACM Drivers
//
//--------------------------------------------------------------------------;

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmDriverEnum()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

type
  ACMDRIVERENUMCB = function (hadif: HACMDRIVERID; dwInstance, fdwSupport: DWORD): BOOL; stdcall;
  {$EXTERNALSYM ACMDRIVERENUMCB}

function acmDriverEnum(fnCallback: ACMDRIVERENUMCB; dwInstance: DWORD;
  fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverEnum}

const
  ACM_DRIVERENUMF_NOLOCAL  = $40000000;
  {$EXTERNALSYM ACM_DRIVERENUMF_NOLOCAL}
  ACM_DRIVERENUMF_DISABLED = $80000000;
  {$EXTERNALSYM ACM_DRIVERENUMF_DISABLED}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmDriverID()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmDriverID(hao: HACMOBJ; var phadid: HACMDRIVERID; fdwDriverID: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverID}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmDriverAdd()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmDriverAddA(var phadid: HACMDRIVERID; hinstModule: HINST; Param: LPARAM;
  dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverAddA}
function acmDriverAddW(var phadid: HACMDRIVERID; hinstModule: HINST; Param: LPARAM;
  dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverAddW}
function acmDriverAdd(var phadid: HACMDRIVERID; hinstModule: HINST; Param: LPARAM;
  dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverAdd}

const
  ACM_DRIVERADDF_FUNCTION   = $00000003; // lParam is a procedure
  {$EXTERNALSYM ACM_DRIVERADDF_FUNCTION}
  ACM_DRIVERADDF_NOTIFYHWND = $00000004; // lParam is notify hwnd
  {$EXTERNALSYM ACM_DRIVERADDF_NOTIFYHWND}
  ACM_DRIVERADDF_TYPEMASK   = $00000007; // driver type mask
  {$EXTERNALSYM ACM_DRIVERADDF_TYPEMASK}
  ACM_DRIVERADDF_LOCAL      = $00000000; // is local to current task
  {$EXTERNALSYM ACM_DRIVERADDF_LOCAL}
  ACM_DRIVERADDF_GLOBAL     = $00000008; // is global
  {$EXTERNALSYM ACM_DRIVERADDF_GLOBAL}

//
//  prototype for ACM driver procedures that are installed as _functions_
//  or _notifations_ instead of as a standalone installable driver.
//
type
  ACMDRIVERPROC = function (dwID: DWORD; hdrvr: HACMDRIVERID; uMsg: UINT;
    lParam1: LPARAM; lParam2: LPARAM) : LRESULT; stdcall;
  {$EXTERNALSYM ACMDRIVERPROC}
  LPACMDRIVERPROC = ^ACMDRIVERPROC;
  {$EXTERNALSYM LPACMDRIVERPROC}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmDriverRemove()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmDriverRemove(hadid: HACMDRIVERID; fdwRemove: DWORD): MMRESULT; stdcall;