/common/unaMsAcmAPI.pas

Large files files are truncated, but you can click here to view the full file

(*
	----------------------------------------------
	Microsoft Audio Compression Manager (ACM) interface

	Original Delphi conversion by Armin Sander,
		Digital SimpleX / armin@dsx.de

	Additional programming:

	  Copyright (c) 2002-2010 Lake of Soft
		     All rights reserved

	  http://lakeofsoft.com/

	----------------------------------------------
	  modified by:
		Lake, Jan-Dec 2002
		Lake, Feb 2003
	----------------------------------------------
*)

{$I unaDef.inc }

{*
  This unit contains Object Pascal version of MSAcm.h originally done by Armin Sander, Digital SimpleX
  Most of the functions in this unit are documented in Microsoft Platform SDK.

  @Author Additional modification by Lake

  2.5.2008.07 Still here
}

unit
  unaMsAcmAPI;

interface

uses
   Windows, unaTypes, MMSystem;

   // C++Builders stuff

{$HPPEMIT '#include "MMREG.H"' }
{$HPPEMIT '#include "msacm.h"' }

type
  {$EXTERNALSYM WAVEFORMATEX }
  WAVEFORMATEX = tWAVEFORMATEX;

// some MMREG.H and MMSYSTEM.H includes missed from MMSystem.pas

const
  {$EXTERNALSYM WAVE_FILTER_UNKNOWN }
  WAVE_FILTER_UNKNOWN        	= $0000;
  {$EXTERNALSYM WAVE_FILTER_DEVELOPMENT }
  WAVE_FILTER_DEVELOPMENT	= $FFFF;

  {$EXTERNALSYM WAVE_FORMAT_DIRECT}
  WAVE_FORMAT_DIRECT        	= $0008;

type
  pWAVEFILTER = ^WAVEFILTER;
  {$EXTERNALSYM WAVEFILTER}
  WAVEFILTER = record
    cbStruct   : DWORD;        // Size of the filter in bytes
    dwFilterTag: DWORD;        // filter type
    fdwFilter  : DWORD;        // Flags for the filter (Universal Dfns)
    dwReserved : array[0..5] of DWORD;      // Reserved for system use
  end;

const
  {$EXTERNALSYM DRV_MAPPER_PREFERRED_INPUT_GET }
  DRV_MAPPER_PREFERRED_INPUT_GET = (DRV_USER + 0);
  {$EXTERNALSYM DRV_MAPPER_PREFERRED_OUTPUT_GET }
  DRV_MAPPER_PREFERRED_OUTPUT_GET = (DRV_USER + 2);

  {$EXTERNALSYM DRVM_MAPPER_STATUS }
  DRVM_MAPPER_STATUS = $2000;

  {$EXTERNALSYM WIDM_MAPPER_STATUS }
  WIDM_MAPPER_STATUS = (DRVM_MAPPER_STATUS + 0);

  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_DEVICE }
  WAVEIN_MAPPER_STATUS_DEVICE = 0;
  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_MAPPED }
  WAVEIN_MAPPER_STATUS_MAPPED = 1;
  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_FORMAT }
  WAVEIN_MAPPER_STATUS_FORMAT = 2;

  {$EXTERNALSYM WODM_MAPPER_STATUS }
  WODM_MAPPER_STATUS = (DRVM_MAPPER_STATUS + 0);

  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_DEVICE }
  WAVEOUT_MAPPER_STATUS_DEVICE = 0;
  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_MAPPED }
  WAVEOUT_MAPPER_STATUS_MAPPED = 1;
  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_FORMAT }
  WAVEOUT_MAPPER_STATUS_FORMAT = 2;

// MSACM.H

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

type
  {
	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.
  }
  pHACMDRIVERID = ^HACMDRIVERID;
  {$EXTERNALSYM HACMDRIVERID }
  HACMDRIVERID  = tHandle;

  {
	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.
  }
  pHACMDRIVER = ^HACMDRIVER;
  {$EXTERNALSYM HACMDRIVER }
  HACMDRIVER  = tHandle;

  {
	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.
  }
  pHACMSTREAM = ^HACMSTREAM;
  {$EXTERNALSYM HACMSTREAM }
  HACMSTREAM  = tHandle;

  {
	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.
  }
  pHACMOBJ = ^HACMOBJ;
  {$EXTERNALSYM HACMOBJ }
  HACMOBJ  = tHandle;

const
  {
	ACM Error Codes

	Note that these error codes are specific errors that apply to the ACM
	directly--general errors are defined as MMSYSERR_*.
  }
  {$EXTERNALSYM ACMERR_BASE }
  ACMERR_BASE         	= 512;
  {$EXTERNALSYM ACMERR_NOTPOSSIBLE }
  ACMERR_NOTPOSSIBLE	= ACMERR_BASE + 0;
  {$EXTERNALSYM ACMERR_BUSY }
  ACMERR_BUSY         	= ACMERR_BASE + 1;
  {$EXTERNALSYM ACMERR_UNPREPARED }
  ACMERR_UNPREPARED   	= ACMERR_BASE + 2;
  {$EXTERNALSYM ACMERR_CANCELED }
  ACMERR_CANCELED     	= ACMERR_BASE + 3;

  {
	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.
  }
  {$EXTERNALSYM MM_ACM_OPEN }
  MM_ACM_OPEN        	= MM_STREAM_OPEN;  // conversion callback messages
  {$EXTERNALSYM MM_ACM_CLOSE }
  MM_ACM_CLOSE       	= MM_STREAM_CLOSE;
  {$EXTERNALSYM MM_ACM_DONE }
  MM_ACM_DONE		= MM_STREAM_DONE;

  {
	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)
  }
{$EXTERNALSYM acm_GetVersion}
function acm_getVersion: DWORD; stdcall;

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

const
  {$EXTERNALSYM ACM_METRIC_COUNT_DRIVERS }
  ACM_METRIC_COUNT_DRIVERS            = 1;
  {$EXTERNALSYM ACM_METRIC_COUNT_CODECS }
  ACM_METRIC_COUNT_CODECS             = 2;
  {$EXTERNALSYM ACM_METRIC_COUNT_CONVERTERS }
  ACM_METRIC_COUNT_CONVERTERS         = 3;
  {$EXTERNALSYM ACM_METRIC_COUNT_FILTERS }
  ACM_METRIC_COUNT_FILTERS            = 4;
  {$EXTERNALSYM ACM_METRIC_COUNT_DISABLED }
  ACM_METRIC_COUNT_DISABLED           = 5;
  {$EXTERNALSYM ACM_METRIC_COUNT_HARDWARE }
  ACM_METRIC_COUNT_HARDWARE           = 6;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_DRIVERS }
  ACM_METRIC_COUNT_LOCAL_DRIVERS      = 20;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_CODECS }
  ACM_METRIC_COUNT_LOCAL_CODECS       = 21;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_CONVERTERS }
  ACM_METRIC_COUNT_LOCAL_CONVERTERS   = 22;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_FILTERS }
  ACM_METRIC_COUNT_LOCAL_FILTERS      = 23;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_DISABLED }
  ACM_METRIC_COUNT_LOCAL_DISABLED     = 24;

  {$EXTERNALSYM ACM_METRIC_HARDWARE_WAVE_INPUT }
  ACM_METRIC_HARDWARE_WAVE_INPUT      = 30;
  {$EXTERNALSYM ACM_METRIC_HARDWARE_WAVE_OUTPUT }
  ACM_METRIC_HARDWARE_WAVE_OUTPUT     = 31;
  {$EXTERNALSYM ACM_METRIC_MAX_SIZE_FORMAT }
  ACM_METRIC_MAX_SIZE_FORMAT          = 50;
  {$EXTERNALSYM ACM_METRIC_MAX_SIZE_FILTER }
  ACM_METRIC_MAX_SIZE_FILTER          = 51;
  {$EXTERNALSYM ACM_METRIC_DRIVER_SUPPORT }
  ACM_METRIC_DRIVER_SUPPORT           = 100;
  {$EXTERNALSYM ACM_METRIC_DRIVER_PRIORITY }
  ACM_METRIC_DRIVER_PRIORITY          = 101;

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

type
  {$EXTERNALSYM ACMDRIVERENUMCB }
  ACMDRIVERENUMCB = function(hadid: HACMDRIVERID; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;

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

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

{$EXTERNALSYM acm_DriverID }
function acm_driverID(hao: HACMOBJ; phadid: pHACMDRIVERID; fdwDriverID: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverAddA }
function acm_driverAddA(phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverAddW }
function acm_driverAddW(phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverAdd }
function acm_driverAdd (phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;

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

type
  {
	prototype for ACM driver procedures that are installed as _functions_
	or _notifations_ instead of as a standalone installable driver.
  }
  {$EXTERNALSYM ACMDRIVERPROC }
  ACMDRIVERPROC = function(a_0: DWORD; a_1: HACMDRIVERID; a_2: UINT; a_3: LPARAM; a_4: LPARAM): LRESULT; stdcall;
  {$EXTERNALSYM LPACMDRIVERPROC }
  LPACMDRIVERPROC = ^ACMDRIVERPROC;

{$EXTERNALSYM acm_DriverRemove }
function acm_driverRemove(hadid: HACMDRIVERID; fdwRemove: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverOpen }
function acm_driverOpen(phad: pHACMDRIVER; hadid: HACMDRIVERID; fdwOpen: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverClose }
function acm_driverClose(had: HACMDRIVER; fdwClose: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverMessage }
function acm_driverMessage(had: HACMDRIVER; uMsg: UINT; lParam1: LPARAM; lParam2: LPARAM): LRESULT; stdcall;

const
  {$EXTERNALSYM ACMDM_USER }
  ACMDM_USER          = (DRV_USER + $0000);
  {$EXTERNALSYM ACMDM_RESERVED_LOW }
  ACMDM_RESERVED_LOW  = (DRV_USER + $2000);
  {$EXTERNALSYM ACMDM_RESERVED_HIGH }
  ACMDM_RESERVED_HIGH = (DRV_USER + $2FFF);
  {$EXTERNALSYM ACMDM_BASE }
  ACMDM_BASE          = ACMDM_RESERVED_LOW;
  {$EXTERNALSYM ACMDM_DRIVER_ABOUT }
  ACMDM_DRIVER_ABOUT  = (ACMDM_BASE + 11);

// -- MSACMDRV.H --

type
//
//
  ACMDRVSTREAMINSTANCE = record
    cbStruct  : DWORD;
    pwfxSrc   : PWAVEFORMATEX;
    pwfxDst   : PWAVEFORMATEX;
    pwfltr    : PWAVEFILTER;
    dwCallback: DWORD;
    dwInstance: DWORD;
    fdwOpen   : DWORD;
    fdwDriver : DWORD;
    dwDriver  : DWORD;
    has       : HACMSTREAM;
  end;

//
//  structure for ACMDM_STREAM_SIZE message
//
//
  ACMDRVSTREAMSIZE = record
    cbStruct:    DWORD;
    fdwSize:     DWORD;
    cbSrcLength: DWORD;
    cbDstLength: DWORD;
  end;


//
//  NOTE! this structure must match the ACMSTREAMHEADER in msacm.h but
//  defines more information for the driver writing convenience
//
  PACMDRVSTREAMHEADER = ^ACMDRVSTREAMHEADER;
  ACMDRVSTREAMHEADER = record
    cbStruct:        DWORD;
    fdwStatus:       DWORD;
    dwUser:          DWORD_PTR;
    pbSrc:           PBYTE;
    cbSrcLength:     DWORD;
    cbSrcLengthUsed: DWORD;
    dwSrcUser:       DWORD_PTR;
    pbDst:           PBYTE;
    cbDstLength:     DWORD;
    cbDstLengthUsed: DWORD;
    dwDstUser:       DWORD_PTR;

    fdwConvert:      DWORD;               // flags passed from convert func
    padshNext:       PACMDRVSTREAMHEADER; // for async driver queueing
    fdwDriver:       DWORD;               // driver instance flags
    dwDriver:        DWORD;               // driver instance data

    //
    //  all remaining fields are used by the ACM for bookkeeping purposes.
    //  an ACM driver should never use these fields (though than can be
    //  helpful for debugging)--note that the meaning of these fields
    //  may change, so do NOT rely on them in shipping code.
    //
    fdwPrepared:         DWORD;
    dwPrepared:          DWORD;
    pbPreparedSrc:       PBYTE;
    cbPreparedSrcLength: DWORD;
    pbPreparedDst:       PBYTE;
    cbPreparedDstLength: DWORD;
  end;



//
//  structure containing the information for the ACMDM_FORMAT_SUGGEST message
//
//
  ACMDRVFORMATSUGGEST = record
    cbStruct: DWORD;		// sizeof(ACMDRVFORMATSUGGEST)
    fdwSuggest: DWORD;		// Suggest flags
    pwfxSrc: PWAVEFORMATEX;	// Source Format
    cbwfxSrc: DWORD;		// Source Size
    pwfxDst: PWAVEFORMATEX;	// Dest format
    cbwfxDst: DWORD;		// Dest Size
  end;


const
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  ACM Driver Messages
//
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

  ACMDM_DRIVER_NOTIFY             = (ACMDM_BASE + 1);
  ACMDM_DRIVER_DETAILS            = (ACMDM_BASE + 10);

  ACMDM_HARDWARE_WAVE_CAPS_INPUT  = (ACMDM_BASE + 20);
  ACMDM_HARDWARE_WAVE_CAPS_OUTPUT = (ACMDM_BASE + 21);

  ACMDM_FORMATTAG_DETAILS         = (ACMDM_BASE + 25);
  ACMDM_FORMAT_DETAILS            = (ACMDM_BASE + 26);
  ACMDM_FORMAT_SUGGEST            = (ACMDM_BASE + 27);

  ACMDM_FILTERTAG_DETAILS         = (ACMDM_BASE + 50);
  ACMDM_FILTER_DETAILS            = (ACMDM_BASE + 51);

  ACMDM_STREAM_OPEN               = (ACMDM_BASE + 76);
  ACMDM_STREAM_CLOSE              = (ACMDM_BASE + 77);
  ACMDM_STREAM_SIZE               = (ACMDM_BASE + 78);
  ACMDM_STREAM_CONVERT            = (ACMDM_BASE + 79);
  ACMDM_STREAM_RESET              = (ACMDM_BASE + 80);
  ACMDM_STREAM_PREPARE            = (ACMDM_BASE + 81);
  ACMDM_STREAM_UNPREPARE          = (ACMDM_BASE + 82);

  
{$EXTERNALSYM acm_DriverPriority }
function acm_driverPriority(hadid: HACMDRIVERID; dwPriority: DWORD; fdwPriority: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_DRIVERPRIORITYF_ENABLE }
  ACM_DRIVERPRIORITYF_ENABLE      = $00000001;
  {$EXTERNALSYM ACM_DRIVERPRIORITYF_DISABLE }
  ACM_DRIVERPRIORITYF_DISABLE     = $00000002;
  {$EXTERNALSYM ACM_DRIVERPRIORITYF_ABLEMASK }
  ACM_DRIVERPRIORITYF_ABLEMASK    = $00000003;
  {$EXTERNALSYM ACM_DRIVERPRIORITYF_BEGIN }
  ACM_DRIVERPRIORITYF_BEGIN       = $00010000;
  {$EXTERNALSYM ACM_DRIVERPRIORITYF_END }
  ACM_DRIVERPRIORITYF_END         = $00020000;
  {$EXTERNALSYM ACM_DRIVERPRIORITYF_DEFERMASK }
  ACM_DRIVERPRIORITYF_DEFERMASK   = $00030000;

  {
	ACMDRIVERDETAILS

	the ACMDRIVERDETAILS structure is used to get various capabilities from
	an ACM driver (codec, converter, filter).
  }
  {$EXTERNALSYM ACMDRIVERDETAILS_SHORTNAME_CHARS }
  ACMDRIVERDETAILS_SHORTNAME_CHARS    = 32;
  {$EXTERNALSYM ACMDRIVERDETAILS_LONGNAME_CHARS }
  ACMDRIVERDETAILS_LONGNAME_CHARS     = 128;
  {$EXTERNALSYM ACMDRIVERDETAILS_COPYRIGHT_CHARS }
  ACMDRIVERDETAILS_COPYRIGHT_CHARS    = 80;
  {$EXTERNALSYM ACMDRIVERDETAILS_LICENSING_CHARS }
  ACMDRIVERDETAILS_LICENSING_CHARS    = 128;
  {$EXTERNALSYM ACMDRIVERDETAILS_FEATURES_CHARS }
  ACMDRIVERDETAILS_FEATURES_CHARS     = 512;

type
  pACMDRIVERDETAILSA = ^ACMDRIVERDETAILSA;
  {$EXTERNALSYM ACMDRIVERDETAILSA }
  ACMDRIVERDETAILSA = record
    cbStruct      : DWORD;              // number of valid bytes in structure
    fccType       : FOURCC;             // compressor type 'audc'
    fccComp       : FOURCC;             // sub-type (not used; reserved)
    wMid          : WORD;               // manufacturer id
    wPid          : WORD;               // product id
    vdwACM        : DWORD;              // version of the ACM *compiled* for
    vdwDriver     : DWORD;              // version of the driver
    fdwSupport    : DWORD;              // misc. support flags
    cFormatTags   : DWORD;              // total unique format tags supported
    cFilterTags   : DWORD;              // total unique filter tags supported
    hicon         : HICON;              // handle to custom icon
    szShortName   : array[0..ACMDRIVERDETAILS_SHORTNAME_CHARS - 1] of aChar;
    szLongName    : array[0..ACMDRIVERDETAILS_LONGNAME_CHARS - 1] of aChar;
    szCopyright   : array[0..ACMDRIVERDETAILS_COPYRIGHT_CHARS - 1] of aChar;
    szLicensing   : array[0..ACMDRIVERDETAILS_LICENSING_CHARS - 1] of aChar;
    szFeatures    : array[0..ACMDRIVERDETAILS_FEATURES_CHARS - 1] of aChar;
  end;

  pACMDRIVERDETAILSW = ^ACMDRIVERDETAILSW;
  {$EXTERNALSYM ACMDRIVERDETAILSW }
  ACMDRIVERDETAILSW = record
    cbStruct      : DWORD;              // number of valid bytes in structure
    fccType       : FOURCC;             // compressor type 'audc'
    fccComp       : FOURCC;             // sub-type (not used; reserved)
    wMid          : WORD;               // manufacturer id
    wPid          : WORD;               // product id
    vdwACM        : DWORD;              // version of the ACM *compiled* for
    vdwDriver     : DWORD;              // version of the driver
    fdwSupport    : DWORD;              // misc. support flags
    cFormatTags   : DWORD;              // total unique format tags supported
    cFilterTags   : DWORD;              // total unique filter tags supported
    hicon         : HICON;              // handle to custom icon
    szShortName   : array[0..ACMDRIVERDETAILS_SHORTNAME_CHARS - 1] of wChar;
    szLongName    : array[0..ACMDRIVERDETAILS_LONGNAME_CHARS  - 1] of wChar;
    szCopyright   : array[0..ACMDRIVERDETAILS_COPYRIGHT_CHARS - 1] of wChar;
    szLicensing   : array[0..ACMDRIVERDETAILS_LICENSING_CHARS - 1] of wChar;
    szFeatures    : array[0..ACMDRIVERDETAILS_FEATURES_CHARS  - 1] of wChar;
  end;

  {$EXTERNALSYM ACMDRIVERDETAILS }
  ACMDRIVERDETAILS  = ACMDRIVERDETAILSA;
  pACMDRIVERDETAILS = pACMDRIVERDETAILSA;

//  ACMDRIVERDETAILS.fccType
//
//  ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC: the FOURCC used in the fccType
//  field of the ACMDRIVERDETAILS structure to specify that this is an ACM
//  codec designed for audio.
//  ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC = mmioFOURCC('a', 'u', 'd', 'c');
{$EXTERNALSYM ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC }
function ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC(): FOURCC;

const
//  ACMDRIVERDETAILS.fccComp
//
//  ACMDRIVERDETAILS_FCCCOMP_UNDEFINED: the FOURCC used in the fccComp
//  field of the ACMDRIVERDETAILS structure. this is currently an unused
//  field.
//
  {$EXTERNALSYM ACMDRIVERDETAILS_FCCCOMP_UNDEFINED }
  ACMDRIVERDETAILS_FCCCOMP_UNDEFINED = 0;

const
//
//  the following flags are used to specify the type of conversion(s) that
//  the converter/codec/filter supports. these are placed in the fdwSupport
//  field of the ACMDRIVERDETAILS structure. note that a converter can
//  support one or more of these flags in any combination.
//
//  ACMDRIVERDETAILS_SUPPORTF_CODEC: this flag is set if the driver supports
//  conversions from one format tag to another format tag. for example, if a
//  converter compresses WAVE_FORMAT_PCM to WAVE_FORMAT_ADPCM, then this bit
//  should be set.
//
  {$EXTERNALSYM ACMDRIVERDETAILS_SUPPORTF_CODEC }
  ACMDRIVERDETAILS_SUPPORTF_CODEC     = $00000001;

//  ACMDRIVERDETAILS_SUPPORTF_CONVERTER: this flags is set if the driver
//  supports conversions on the same format tag. as an example, the PCM
//  converter that is built into the ACM sets this bit (and only this bit)
//  because it converts only PCM formats (bits, sample rate).
  {$EXTERNALSYM ACMDRIVERDETAILS_SUPPORTF_CONVERTER }
  ACMDRIVERDETAILS_SUPPORTF_CONVERTER = $00000002;

//  ACMDRIVERDETAILS_SUPPORTF_FILTER: this flag is set if the driver supports
//  transformations on a single format. for example, a converter that changed
//  the 'volume' of PCM data would set this bit. 'echo' and 'reverb' are
//  also filter types.
  {$EXTERNALSYM ACMDRIVERDETAILS_SUPPORTF_FILTER }
  ACMDRIVERDETAILS_SUPPORTF_FILTER    = $00000004;

//  ACMDRIVERDETAILS_SUPPORTF_HARDWARE: this flag is set if the driver supports
//  hardware input and/or output through a waveform device.
  {$EXTERNALSYM ACMDRIVERDETAILS_SUPPORTF_HARDWARE }
  ACMDRIVERDETAILS_SUPPORTF_HARDWARE  = $00000008;

//  ACMDRIVERDETAILS_SUPPORTF_ASYNC: this flag is set if the driver supports
//  async conversions.
  {$EXTERNALSYM ACMDRIVERDETAILS_SUPPORTF_ASYNC }
  ACMDRIVERDETAILS_SUPPORTF_ASYNC     = $00000010;

//
//  ACMDRIVERDETAILS_SUPPORTF_LOCAL: this flag is set _by the ACM_ if a
//  driver has been installed local to the current task. this flag is also
//  set in the fdwSupport argument to the enumeration callback function
//  for drivers.
  {$EXTERNALSYM ACMDRIVERDETAILS_SUPPORTF_LOCAL }
  ACMDRIVERDETAILS_SUPPORTF_LOCAL     = $40000000;

//  ACMDRIVERDETAILS_SUPPORTF_DISABLED: this flag is set _by the ACM_ if a
//  driver has been disabled. this flag is also passed set in the fdwSupport
//  argument to the enumeration callback function for drivers.
  {$EXTERNALSYM ACMDRIVERDETAILS_SUPPORTF_DISABLED }
  ACMDRIVERDETAILS_SUPPORTF_DISABLED  = $80000000;

{$EXTERNALSYM acm_DriverDetailsA }
function acm_driverDetailsA(hadid: hACMDRIVERID; padd: pACMDRIVERDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverDetailsW }
function acm_driverDetailsW(hadid: hACMDRIVERID; padd: pACMDRIVERDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverDetails }
function acm_driverDetails (hadid: hACMDRIVERID; padd: pACMDRIVERDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;

//--------------------------------------------------------------------------
//
//  ACM Format Tags
//
const
  {$EXTERNALSYM ACMFORMATTAGDETAILS_FORMATTAG_CHARS }
  ACMFORMATTAGDETAILS_FORMATTAG_CHARS = 48;

type
  pACMFORMATTAGDETAILSA = ^ACMFORMATTAGDETAILSA;
  {$EXTERNALSYM ACMFORMATTAGDETAILSA }
  ACMFORMATTAGDETAILSA = record
    cbStruct         : DWORD;
    dwFormatTagIndex : DWORD;
    dwFormatTag      : DWORD;
    cbFormatSize     : DWORD;
    fdwSupport       : DWORD;
    cStandardFormats : DWORD;
    szFormatTag      : array[0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS - 1] of aChar;
  end;

  pACMFORMATTAGDETAILSW = ^ACMFORMATTAGDETAILSW;
  {$EXTERNALSYM ACMFORMATTAGDETAILSW }
  ACMFORMATTAGDETAILSW = record
    cbStruct         : DWORD;
    dwFormatTagIndex : DWORD;
    dwFormatTag      : DWORD;
    cbFormatSize     : DWORD;
    fdwSupport       : DWORD;
    cStandardFormats : DWORD;
    szFormatTag      : array[0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS - 1] of wChar;
  end;

  {$EXTERNALSYM ACMFORMATTAGDETAILS }
  ACMFORMATTAGDETAILS = ACMFORMATTAGDETAILSA;
  pACMFORMATTAGDETAILS = pACMFORMATTAGDETAILSA;

{$EXTERNALSYM acm_FormatTagDetailsA }
function acm_formatTagDetailsA(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatTagDetailsW }
function acm_formatTagDetailsW(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatTagDetails }
function acm_formatTagDetails (had: HACMDRIVER; paftd: pACMFORMATTAGDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_FORMATTAGDETAILSF_INDEX }
  ACM_FORMATTAGDETAILSF_INDEX         = $00000000;
  {$EXTERNALSYM ACM_FORMATTAGDETAILSF_FORMATTAG }
  ACM_FORMATTAGDETAILSF_FORMATTAG     = $00000001;
  {$EXTERNALSYM ACM_FORMATTAGDETAILSF_LARGESTSIZE }
  ACM_FORMATTAGDETAILSF_LARGESTSIZE   = $00000002;
  {$EXTERNALSYM ACM_FORMATTAGDETAILSF_QUERYMASK }
  ACM_FORMATTAGDETAILSF_QUERYMASK     = $0000000F;

type
  {$EXTERNALSYM ACMFORMATTAGENUMCBA }
  ACMFORMATTAGENUMCBA = function(hadid: HACMDRIVERID; paftd: pACMFORMATTAGDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
  {$EXTERNALSYM ACMFORMATTAGENUMCBW }
  ACMFORMATTAGENUMCBW = function(hadid: HACMDRIVERID; paftd: pACMFORMATTAGDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
  {$EXTERNALSYM ACMFORMATTAGENUMCB }
  ACMFORMATTAGENUMCB = ACMFORMATTAGENUMCBA;

{$EXTERNALSYM acm_FormatTagEnumA }
function acm_formatTagEnumA(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSA; fnCallback: ACMFORMATTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatTagEnumW }
function acm_formatTagEnumW(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSW; fnCallback: ACMFORMATTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatTagEnum }
function acm_formatTagEnum (had: HACMDRIVER; paftd: pACMFORMATTAGDETAILS;  fnCallback: ACMFORMATTAGENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;

//--------------------------------------------------------------------------;
//
//  ACM Formats
//
const
  {$EXTERNALSYM ACMFORMATDETAILS_FORMAT_CHARS }
  ACMFORMATDETAILS_FORMAT_CHARS   = 128;

type
  pACMFORMATDETAILSA = ^ACMFORMATDETAILSA;
  {$EXTERNALSYM ACMFORMATDETAILSA }
  ACMFORMATDETAILSA = record
    cbStruct      : DWORD;
    dwFormatIndex : DWORD;
    dwFormatTag   : DWORD;
    fdwSupport    : DWORD;
    pwfx          : PWAVEFORMATEX;
    cbwfx         : DWORD;
    szFormat      : array[0..ACMFORMATDETAILS_FORMAT_CHARS - 1] of aChar;
  end;

  pACMFORMATDETAILSW = ^ACMFORMATDETAILSW;
  {$EXTERNALSYM ACMFORMATDETAILSW }
  ACMFORMATDETAILSW = record
    cbStruct      : DWORD;
    dwFormatIndex : DWORD;
    dwFormatTag   : DWORD;
    fdwSupport    : DWORD;
    pwfx          : PWAVEFORMATEX;
    cbwfx         : DWORD;
    szFormat      : array[0..ACMFORMATDETAILS_FORMAT_CHARS - 1] of wChar;
  end;

type
  pACMFORMATDETAILS = pACMFORMATDETAILSA;
  {$EXTERNALSYM ACMFORMATDETAILS }
  ACMFORMATDETAILS = ACMFORMATDETAILSA;

{$EXTERNALSYM acm_FormatDetailsA }
function acm_formatDetailsA(had: HACMDRIVER; pafd: pACMFORMATDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatDetailsW }
function acm_formatDetailsW(had: HACMDRIVER; pafd: pACMFORMATDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatDetails }
function acm_formatDetails (had: HACMDRIVER; pafd: pACMFORMATDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_FORMATDETAILSF_INDEX }
  ACM_FORMATDETAILSF_INDEX        = $00000000;
  {$EXTERNALSYM ACM_FORMATDETAILSF_FORMAT }
  ACM_FORMATDETAILSF_FORMAT       = $00000001;
  {$EXTERNALSYM ACM_FORMATDETAILSF_QUERYMASK }
  ACM_FORMATDETAILSF_QUERYMASK    = $0000000F;

type
  {$EXTERNALSYM ACMFORMATENUMCBA }
  ACMFORMATENUMCBA = function(hadid: HACMDRIVERID; pafd: pACMFORMATDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
  {$EXTERNALSYM ACMFORMATENUMCBW }
  ACMFORMATENUMCBW = function(hadid: HACMDRIVERID; pafd: pACMFORMATDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
  {$EXTERNALSYM ACMFORMATENUMCB }
  ACMFORMATENUMCB = ACMFORMATENUMCBA;

{$EXTERNALSYM acm_FormatEnumA }
function acm_formatEnumA(had: HACMDRIVER; pafd: pACMFORMATDETAILSA; fnCallback: ACMFORMATENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatEnumW }
function acm_formatEnumW(had: HACMDRIVER; pafd: pACMFORMATDETAILSW; fnCallback: ACMFORMATENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatEnum }
function acm_formatEnum (had: HACMDRIVER; pafd: pACMFORMATDETAILS;  fnCallback: ACMFORMATENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_FORMATENUMF_WFORMATTAG }
  ACM_FORMATENUMF_WFORMATTAG       = $00010000;
  {$EXTERNALSYM ACM_FORMATENUMF_NCHANNELS }
  ACM_FORMATENUMF_NCHANNELS        = $00020000;
  {$EXTERNALSYM ACM_FORMATENUMF_NSAMPLESPERSEC }
  ACM_FORMATENUMF_NSAMPLESPERSEC   = $00040000;
  {$EXTERNALSYM ACM_FORMATENUMF_WBITSPERSAMPLE }
  ACM_FORMATENUMF_WBITSPERSAMPLE   = $00080000;
  {$EXTERNALSYM ACM_FORMATENUMF_CONVERT }
  ACM_FORMATENUMF_CONVERT          = $00100000;
  {$EXTERNALSYM ACM_FORMATENUMF_SUGGEST }
  ACM_FORMATENUMF_SUGGEST          = $00200000;
  {$EXTERNALSYM ACM_FORMATENUMF_HARDWARE }
  ACM_FORMATENUMF_HARDWARE         = $00400000;
  {$EXTERNALSYM ACM_FORMATENUMF_INPUT }
  ACM_FORMATENUMF_INPUT            = $00800000;
  {$EXTERNALSYM ACM_FORMATENUMF_OUTPUT }
  ACM_FORMATENUMF_OUTPUT           = $01000000;

{$EXTERNALSYM acm_FormatSuggest }
function acm_formatSuggest(had: HACMDRIVER; pwfxSrc: pWAVEFORMATEX; pwfxDst: pWAVEFORMATEX; cbwfxDst: DWORD; fdwSuggest: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_FORMATSUGGESTF_WFORMATTAG }
  ACM_FORMATSUGGESTF_WFORMATTAG       = $00010000;
  {$EXTERNALSYM ACM_FORMATSUGGESTF_NCHANNELS }
  ACM_FORMATSUGGESTF_NCHANNELS        = $00020000;
  {$EXTERNALSYM ACM_FORMATSUGGESTF_NSAMPLESPERSEC }
  ACM_FORMATSUGGESTF_NSAMPLESPERSEC   = $00040000;
  {$EXTERNALSYM ACM_FORMATSUGGESTF_WBITSPERSAMPLE }
  ACM_FORMATSUGGESTF_WBITSPERSAMPLE   = $00080000;

  {$EXTERNALSYM ACM_FORMATSUGGESTF_TYPEMASK }
  ACM_FORMATSUGGESTF_TYPEMASK         = $00FF0000;

  {$EXTERNALSYM ACMHELPMSGSTRINGA }
  ACMHELPMSGSTRINGA       = 'acmchoose_help';
  {$EXTERNALSYM ACMHELPMSGSTRINGW }
  ACMHELPMSGSTRINGW       = 'acmchoose_help';
  {$EXTERNALSYM ACMHELPMSGCONTEXTMENUA }
  ACMHELPMSGCONTEXTMENUA  = 'acmchoose_contextmenu';
  {$EXTERNALSYM ACMHELPMSGCONTEXTMENUW }
  ACMHELPMSGCONTEXTMENUW  = 'acmchoose_contextmenu';
  {$EXTERNALSYM ACMHELPMSGCONTEXTHELPA }
  ACMHELPMSGCONTEXTHELPA  = 'acmchoose_contexthelp';
  {$EXTERNALSYM ACMHELPMSGCONTEXTHELPW }
  ACMHELPMSGCONTEXTHELPW  = 'acmchoose_contexthelp';

  {$EXTERNALSYM ACMHELPMSGSTRING }
  ACMHELPMSGSTRING        = ACMHELPMSGSTRINGA;
  {$EXTERNALSYM ACMHELPMSGCONTEXTMENU }
  ACMHELPMSGCONTEXTMENU   = ACMHELPMSGCONTEXTMENUA;
  {$EXTERNALSYM ACMHELPMSGCONTEXTHELP }
  ACMHELPMSGCONTEXTHELP   = ACMHELPMSGCONTEXTHELPA;

  {$EXTERNALSYM MM_ACM_FORMATCHOOSE }
  MM_ACM_FORMATCHOOSE             = ($8000);

  {$EXTERNALSYM FORMATCHOOSE_MESSAGE }
  FORMATCHOOSE_MESSAGE            = 0;
  {$EXTERNALSYM FORMATCHOOSE_FORMATTAG_VERIFY }
  FORMATCHOOSE_FORMATTAG_VERIFY   = (FORMATCHOOSE_MESSAGE + 0);
  {$EXTERNALSYM FORMATCHOOSE_FORMAT_VERIFY }
  FORMATCHOOSE_FORMAT_VERIFY      = (FORMATCHOOSE_MESSAGE + 1);
  {$EXTERNALSYM FORMATCHOOSE_CUSTOM_VERIFY }
  FORMATCHOOSE_CUSTOM_VERIFY      = (FORMATCHOOSE_MESSAGE + 2);

type
  {$EXTERNALSYM ACMFORMATCHOOSEHOOKPROCA }
  ACMFORMATCHOOSEHOOKPROCA = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
  {$EXTERNALSYM ACMFORMATCHOOSEHOOKPROCW }
  ACMFORMATCHOOSEHOOKPROCW = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
  {$EXTERNALSYM ACMFORMATCHOOSEHOOKPROC }
  ACMFORMATCHOOSEHOOKPROC  = ACMFORMATCHOOSEHOOKPROCA;

  pACMFORMATCHOOSEA = ^ACMFORMATCHOOSEA;
  {$EXTERNALSYM ACMFORMATCHOOSEA }
  ACMFORMATCHOOSEA = record
    cbStruct        : DWORD;            	// sizeof(ACMFORMATCHOOSE)
    fdwStyle        : DWORD;            	// chooser style flags
    hwndOwner       : hWND;            		// caller's window handle
    pwfx            : pWAVEFORMATEX;            // ptr to wfx buf to receive choice
    cbwfx           : DWORD;            	// size of mem buf for pwfx
    pszTitle        : LPCSTR;            	// dialog box title bar
    szFormatTag     : array[0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of aChar;
    szFormat        : array[0..ACMFORMATDETAILS_FORMAT_CHARS-1] of aChar;
    pszName         : LPSTR;            	// custom name selection
    cchName         : DWORD;            	// size in chars of mem buf for pszName
    fdwEnum         : DWORD;            	// format enumeration restrictions
    pwfxEnum        : pWAVEFORMATEX;            // format describing restrictions
    hInstance       : tHandle;            	// app instance containing dlg template
    pszTemplateName : LPCSTR;            	// custom template name
    lCustData       : LPARAM;            	// data passed to hook fn.
    pfnHook         : ACMFORMATCHOOSEHOOKPROCA;	// ptr to hook function
  end;

  pACMFORMATCHOOSEW = ^ACMFORMATCHOOSEW;
  {$EXTERNALSYM ACMFORMATCHOOSEW }
  ACMFORMATCHOOSEW = record
    cbStruct        : DWORD;            	// sizeof(ACMFORMATCHOOSE)
    fdwStyle        : DWORD;            	// chooser style flags
    hwndOwner       : hWND;            		// caller's window handle
    pwfx            : pWAVEFORMATEX;            // ptr to wfx buf to receive choice
    cbwfx           : DWORD;            	// size of mem buf for pwfx
    pszTitle        : LPCWSTR;          	// dialog box title bar
    szFormatTag     : array[0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of wChar;
    szFormat        : array[0..ACMFORMATDETAILS_FORMAT_CHARS-1] of wChar;
    pszName         : LPWSTR;            	// custom name selection
    cchName         : DWORD;            	// size in chars of mem buf for pszName
    fdwEnum         : DWORD;            	// format enumeration restrictions
    pwfxEnum        : PWAVEFORMATEX;            // format describing restrictions
    hInstance       : tHandle;            	// app instance containing dlg template
    pszTemplateName : LPCWSTR;            	// custom template name
    lCustData       : LPARAM;            	// data passed to hook fn.
    pfnHook         : ACMFORMATCHOOSEHOOKPROCW;	// ptr to hook function
  end;

  {$EXTERNALSYM ACMFORMATCHOOSE }
  ACMFORMATCHOOSE = ACMFORMATCHOOSEA;
  pACMFORMATCHOOSE = pACMFORMATCHOOSEA;

const
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_SHOWHELP }
  ACMFORMATCHOOSE_STYLEF_SHOWHELP              = $00000004;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_ENABLEHOOK }
  ACMFORMATCHOOSE_STYLEF_ENABLEHOOK            = $00000008;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE }
  ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE        = $00000010;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE }
  ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE  = $00000020;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT }
  ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT       = $00000040;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_CONTEXTHELP }
  ACMFORMATCHOOSE_STYLEF_CONTEXTHELP           = $00000080;

{$EXTERNALSYM acm_FormatChooseA }
function acm_formatChooseA(pafmtc: pACMFORMATCHOOSEA): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatChooseW }
function acm_formatChooseW(pafmtc: pACMFORMATCHOOSEW): MMRESULT; stdcall;
{$EXTERNALSYM acm_FormatChoose }
function acm_formatChoose (pafmtc: pACMFORMATCHOOSE ): MMRESULT; stdcall;

//--------------------------------------------------------------------------;
//
//  ACM Filter Tags
//
const
  {$EXTERNALSYM ACMFILTERTAGDETAILS_FILTERTAG_CHARS }
  ACMFILTERTAGDETAILS_FILTERTAG_CHARS = 48;

type
  pACMFILTERTAGDETAILSA = ^ACMFILTERTAGDETAILSA;
  {$EXTERNALSYM ACMFILTERTAGDETAILSA }
  ACMFILTERTAGDETAILSA = record
    cbStruct         : DWORD;
    dwFilterTagIndex : DWORD;
    dwFilterTag      : DWORD;
    cbFilterSize     : DWORD;
    fdwSupport       : DWORD;
    cStandardFilters : DWORD;
    szFilterTag      : array[0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS - 1] of aChar;
  end;

  pACMFILTERTAGDETAILSW = ^ACMFILTERTAGDETAILSW;
  {$EXTERNALSYM ACMFILTERTAGDETAILSW }
  ACMFILTERTAGDETAILSW = record
    cbStruct         : DWORD;
    dwFilterTagIndex : DWORD;
    dwFilterTag      : DWORD;
    cbFilterSize     : DWORD;
    fdwSupport       : DWORD;
    cStandardFilters : DWORD;
    szFilterTag      : array[0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS - 1] of wChar;
  end;

  {$EXTERNALSYM ACMFILTERTAGDETAILS }
  ACMFILTERTAGDETAILS = ACMFILTERTAGDETAILSA;
  pACMFILTERTAGDETAILS = pACMFILTERTAGDETAILSA;

{$EXTERNALSYM acm_FilterTagDetailsA }
function acm_filterTagDetailsA(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterTagDetailsW }
function acm_filterTagDetailsW(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterTagDetails }
function acm_filterTagDetails (had: HACMDRIVER; paftd: pACMFILTERTAGDETAILS;  fdwDetails: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_FILTERTAGDETAILSF_INDEX }
  ACM_FILTERTAGDETAILSF_INDEX         = $00000000;
  {$EXTERNALSYM ACM_FILTERTAGDETAILSF_FILTERTAG }
  ACM_FILTERTAGDETAILSF_FILTERTAG     = $00000001;
  {$EXTERNALSYM ACM_FILTERTAGDETAILSF_LARGESTSIZE }
  ACM_FILTERTAGDETAILSF_LARGESTSIZE   = $00000002;
  {$EXTERNALSYM ACM_FILTERTAGDETAILSF_QUERYMASK }
  ACM_FILTERTAGDETAILSF_QUERYMASK     = $0000000F;

type
  {$EXTERNALSYM ACMFILTERTAGENUMCBA }
  ACMFILTERTAGENUMCBA = function(hadid: HACMDRIVERID; paftd: pACMFILTERTAGDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
  {$EXTERNALSYM ACMFILTERTAGENUMCBW }
  ACMFILTERTAGENUMCBW = function(hadid: HACMDRIVERID; paftd: pACMFILTERTAGDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
  {$EXTERNALSYM ACMFILTERTAGENUMCB }
  ACMFILTERTAGENUMCB  = ACMFILTERTAGENUMCBA;

{$EXTERNALSYM acm_FilterTagEnumA }
function acm_filterTagEnumA(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSA; fnCallback: ACMFILTERTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterTagEnumW }
function acm_filterTagEnumW(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSW; fnCallback: ACMFILTERTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterTagEnum }
function acm_filterTagEnum (had: HACMDRIVER; paftd: pACMFILTERTAGDETAILS;  fnCallback: ACMFILTERTAGENUMCB;  dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;

//--------------------------------------------------------------------------;
//
//  ACM Filters
//
const
  {$EXTERNALSYM ACMFILTERDETAILS_FILTER_CHARS }
  ACMFILTERDETAILS_FILTER_CHARS   = 128;

type
  pACMFILTERDETAILSA = ^ACMFILTERDETAILSA;
  {$EXTERNALSYM ACMFILTERDETAILSA }
  ACMFILTERDETAILSA = record
    cbStruct      : DWORD;
    dwFilterIndex : DWORD;
    dwFilterTag   : DWORD;
    fdwSupport    : DWORD;
    pwfltr        : pWAVEFILTER;
    cbwfltr       : DWORD;
    szFilter      : array[0..ACMFILTERDETAILS_FILTER_CHARS - 1] of aChar;
  end;

  pACMFILTERDETAILSW = ^ACMFILTERDETAILSW;
  {$EXTERNALSYM ACMFILTERDETAILSW }
  ACMFILTERDETAILSW = record
    cbStruct      : DWORD;
    dwFilterIndex : DWORD;
    dwFilterTag   : DWORD;
    fdwSupport    : DWORD;
    pwfltr        : pWAVEFILTER;
    cbwfltr       : DWORD;
    szFilter      : array[0..ACMFILTERDETAILS_FILTER_CHARS - 1] of wChar;
  end;

  {$EXTERNALSYM ACMFILTERDETAILS }
  ACMFILTERDETAILS = ACMFILTERDETAILSA;
  pACMFILTERDETAILS = pACMFILTERDETAILSA;

{$EXTERNALSYM acm_FilterDetailsA }
function acm_filterDetailsA(had: HACMDRIVER; pafd: pACMFILTERDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterDetailsW }
function acm_filterDetailsW(had: HACMDRIVER; pafd: pACMFILTERDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterDetails }
function acm_filterDetails (had: HACMDRIVER; pafd: pACMFILTERDETAILS;  fdwDetails: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_FILTERDETAILSF_INDEX }
  ACM_FILTERDETAILSF_INDEX        = $00000000;
  {$EXTERNALSYM ACM_FILTERDETAILSF_FILTER }
  ACM_FILTERDETAILSF_FILTER       = $00000001;
  {$EXTERNALSYM ACM_FILTERDETAILSF_QUERYMASK }
  ACM_FILTERDETAILSF_QUERYMASK    = $0000000F;

type
  {$EXTERNALSYM ACMFILTERENUMCBA }
  ACMFILTERENUMCBA = function(hadid: hACMDRIVERID; pafd: pACMFILTERDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
  {$EXTERNALSYM ACMFILTERENUMCBW }
  ACMFILTERENUMCBW = function(hadid: hACMDRIVERID; pafd: pACMFILTERDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
  {$EXTERNALSYM ACMFILTERENUMCB }
  ACMFILTERENUMCB = ACMFILTERENUMCBA;

{$EXTERNALSYM acm_FilterEnumA }
function acm_filterEnumA(had: HACMDRIVER; pafd: pACMFILTERDETAILSA; fnCallback: ACMFILTERENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterEnumW }
function acm_filterEnumW(had: HACMDRIVER; pafd: pACMFILTERDETAILSW; fnCallback: ACMFILTERENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterEnum }
function acm_filterEnum (had: HACMDRIVER; pafd: pACMFILTERDETAILS;  fnCallback: ACMFILTERENUMCB;  dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_FILTERENUMF_DWFILTERTAG }
  ACM_FILTERENUMF_DWFILTERTAG	= $00010000;

//
//  MM_ACM_FILTERCHOOSE is sent to hook callbacks by the Filter Chooser
//  Dialog...
//
  {$EXTERNALSYM MM_ACM_FILTERCHOOSE }
  MM_ACM_FILTERCHOOSE          	= ($8000);

  {$EXTERNALSYM FILTERCHOOSE_MESSAGE }
  FILTERCHOOSE_MESSAGE			= 0;
  {$EXTERNALSYM FILTERCHOOSE_FILTERTAG_VERIFY }
  FILTERCHOOSE_FILTERTAG_VERIFY   	= (FILTERCHOOSE_MESSAGE+0);
  {$EXTERNALSYM FILTERCHOOSE_FILTER_VERIFY }
  FILTERCHOOSE_FILTER_VERIFY      	= (FILTERCHOOSE_MESSAGE+1);
  {$EXTERNALSYM FILTERCHOOSE_CUSTOM_VERIFY }
  FILTERCHOOSE_CUSTOM_VERIFY      	= (FILTERCHOOSE_MESSAGE+2);

type
  {$EXTERNALSYM ACMFILTERCHOOSEHOOKPROCA }
  ACMFILTERCHOOSEHOOKPROCA = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
  {$EXTERNALSYM ACMFILTERCHOOSEHOOKPROCW }
  ACMFILTERCHOOSEHOOKPROCW = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
  {$EXTERNALSYM ACMFILTERCHOOSEHOOKPROC }
  ACMFILTERCHOOSEHOOKPROC  = ACMFILTERCHOOSEHOOKPROCA;

  pACMFILTERCHOOSEA = ^ACMFILTERCHOOSEA;
  {$EXTERNALSYM ACMFILTERCHOOSEA }
  ACMFILTERCHOOSEA = record
    cbStruct        : DWORD;            	// sizeof(ACMFILTERCHOOSE)
    fdwStyle        : DWORD;            	// chooser style flags
    hwndOwner       : hWND;            		// caller's window handle
    pwfltr          : pWAVEFILTER;            	// ptr to wfltr buf to receive choice
    cbwfltr         : DWORD;            	// size of mem buf for pwfltr
    pszTitle        : LPCSTR;
    szFilterTag     : array[0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS - 1] of aChar;
    szFilter        : array[0..ACMFILTERDETAILS_FILTER_CHARS - 1] of aChar;
    pszName         : LPSTR;            	// custom name selection
    cchName         : DWORD;            	// size in chars of mem buf for pszName
    fdwEnum         : DWORD;            	// filter enumeration restrictions
    pwfltrEnum      : pWAVEFILTER;            	// filter describing restrictions
    hInstance       : tHandle;            	// app instance containing dlg template
    pszTemplateName : LPCSTR;            	// custom template name
    lCustData       : LPARAM;            	// data passed to hook fn.
    pfnHook         : ACMFILTERCHOOSEHOOKPROCA;	// ptr to hook function
  end;

  pACMFILTERCHOOSEW = ^ACMFILTERCHOOSEW;
  {$EXTERNALSYM ACMFILTERCHOOSEW }
  ACMFILTERCHOOSEW = record
    cbStruct        : DWORD;            	// sizeof(ACMFILTERCHOOSE)
    fdwStyle        : DWORD;            	// chooser style flags
    hwndOwner       : hWND;            		// caller's window handle
    pwfltr          : pWAVEFILTER;            	// ptr to wfltr buf to receive choice
    cbwfltr         : DWORD;            	// size of mem buf for pwfltr
    pszTitle        : LPCWSTR;
    szFilterTag     : array[0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS - 1] of wChar;
    szFilter        : array[0..ACMFILTERDETAILS_FILTER_CHARS - 1] of wChar;
    pszName         : LPWSTR;            	// custom name selection
    cchName         : DWORD;            	// size in chars of mem buf for pszName
    fdwEnum         : DWORD;            	// filter enumeration restrictions
    pwfltrEnum      : pWAVEFILTER;            	// filter describing restrictions
    hInstance       : tHandle;            	// app instance containing dlg template
    pszTemplateName : LPCWSTR;            	// custom template name
    lCustData       : LPARAM;            	// data passed to hook fn.
    pfnHook         : ACMFILTERCHOOSEHOOKPROCW;	// ptr to hook function
  end;

  {$EXTERNALSYM ACMFILTERCHOOSE }
  ACMFILTERCHOOSE = ACMFILTERCHOOSEA;
  pACMFILTERCHOOSE = pACMFILTERCHOOSEA;

const
//  ACMFILTERCHOOSE.fdwStyle
  {$EXTERNALSYM ACMFILTERCHOOSE_STYLEF_SHOWHELP }
  ACMFILTERCHOOSE_STYLEF_SHOWHELP              = $00000004;
  {$EXTERNALSYM ACMFILTERCHOOSE_STYLEF_ENABLEHOOK }
  ACMFILTERCHOOSE_STYLEF_ENABLEHOOK            = $00000008;
  {$EXTERNALSYM ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE }
  ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE        = $00000010;
  {$EXTERNALSYM ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE }
  ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE  = $00000020;
  {$EXTERNALSYM ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT }
  ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT    = $00000040;
  {$EXTERNALSYM ACMFILTERCHOOSE_STYLEF_CONTEXTHELP }
  ACMFILTERCHOOSE_STYLEF_CONTEXTHELP           = $00000080;

{$EXTERNALSYM acm_FilterChooseA }
function acm_filterChooseA(pafltrc: pACMFILTERCHOOSEA): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterChooseW }
function acm_filterChooseW(pafltrc: pACMFILTERCHOOSEW): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterChoose }
function acm_filterChoose (pafltrc: pACMFILTERCHOOSE): MMRESULT; stdcall;

//--------------------------------------------------------------------------;
//
//  ACM Stream API's

const
  //#ifdef  _WIN64
  {$IFDEF CPU64 }
    //#define _DRVRESERVED    15
    _DRVRESERVED = 15;
  //#else
  {$ELSE }
    //#define _DRVRESERVED    10
    _DRVRESERVED = 10;
  //#endif  // _WIN64
  {$ENDIF CPU64 }

type
  pACMSTREAMHEADER = ^ACMSTREAMHEADER;
  {$EXTERNALSYM ACMSTREAMHEADER }

  ACMSTREAMHEADER = record
    cbStruct         : DWORD;              	// sizeof(ACMSTREAMHEADER)
    fdwStatus        : DWORD;              	// ACMSTREAMHEADER_STATUSF_*
    dwUser           : DWORD_PTR;              	// user instance data for hdr
    pbSrc            : PBYTE;
    cbSrcLength      : DWORD;
    cbSrcLengthUsed  : DWORD;
    dwSrcUser        : DWORD_PTR;             	// user instance data for src
    pbDst            : PBYTE;
    cbDstLength      : DWORD;
    cbDstLengthUsed  : DWORD;
    dwDstUser        : DWORD_PTR;              	// user instance data for dst
    dwReservedDriver : array [0.._DRVRESERVED - 1] of DWORD;	// driver reserved work space
  end;

const
//  ACMSTREAMHEADER.fdwStatus
//
//  ACMSTREAMHEADER_STATUSF_DONE: done bit for async conversions.
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_DONE }
  ACMSTREAMHEADER_STATUSF_DONE     = $00010000;
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_PREPARED }
  ACMSTREAMHEADER_STATUSF_PREPARED = $00020000;
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_INQUEUE }
  ACMSTREAMHEADER_STATUSF_INQUEUE  = $00100000;

  {$EXTERNALSYM ACM_STREAMOPENF_QUERY }
  ACM_STREAMOPENF_QUERY           = $00000001;
  {$EXTERNALSYM ACM_STREAMOPENF_ASYNC }
  ACM_STREAMOPENF_ASYNC           = $00000002;
  {$EXTERNALSYM ACM_STREAMOPENF_NONREALTIME }
  ACM_STREAMOPENF_NONREALTIME     = $00000004;

  {$EXTERNALSYM ACM_STREAMSIZEF_SOURCE }
  ACM_STREAMSIZEF_SOURCE          = $00000000;
  {$EXTERNALSYM ACM_STREAMSIZEF_DESTINATION }
  ACM_STREAMSIZEF_DESTINATION     = $00000001;
  {$EXTERNALSYM ACM_STREAMSIZEF_QUERYMASK }
  ACM_STREAMSIZEF_QUERYMASK       = $0000000F;

  {$EXTERNALSYM ACM_STREAMCONVERTF_BLOCKALIGN }
  ACM_STREAMCONVERTF_BLOCKALIGN   = $00000004;
  {$EXTERNALSYM ACM_STREAMCONVERTF_START }
  ACM_STREAMCONVERTF_START        = $00000010;
  {$EXTERNALSYM ACM_STREAMCONVERTF_END }
  ACM_STREAMCONVERTF_END          = $00000020;

{$EXTERNALSYM acm_StreamOpen }
function acm_streamOpen(phas: pHACMSTREAM; had: HACMDRIVER; pwfxSrc: pWAVEFORMATEX; pwfxdst: pWAVEFORMATEX; pwfltr: pWAVEFILTER; dwCallback: DWORD; dwInstance: DWORD; fdwOpen: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_StreamClose }
function acm_streamClose(has: HACMSTREAM; fdwClose: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_StreamSize }
function acm_streamSize(has: HACMSTREAM; cbInput: DWORD; var pdwOutputByte: DWORD; fdwSize: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_StreamReset }
function acm_streamReset(has: HACMSTREAM; fdwReset: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_StreamMessage }
function acm_streamMessage(has: HACMSTREAM; uMsg: UINT; lParam1: LPARAM; lParam2: LPARAM): MMRESULT; stdcall;
{$EXTERNALSYM acm_StreamConvert }
function acm_streamConvert(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwConvert: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_StreamPrepareHeader }
function acm_streamPrepareHeader(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwPrepare: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_StreamUnprepareHeader }
function acm_streamUnprepareHeader(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwUnprepare: DWORD): MMRESULT; stdcall;

// back to  MMREG.H

const
{$EXTERNALSYM MM_MICROSOFT				}
{$EXTERNALSYM MM_CREATIVE                               }
{$EXTERNALSYM MM_MEDIAVISION                            }
{$EXTERNALSYM MM_FUJITSU                                }
{$EXTERNALSYM MM_PRAGMATRAX                             }
{$EXTERNALSYM MM_CYRIX                                  }
{$EXTERNALSYM MM_PHILIPS_SPEECH_PROCESSING              }
{$EXTERNALSYM MM_NETXL                                  }
{$EXTERNALSYM MM_ZYXEL                                  }
{$EXTERNALSYM MM_BECUBED                                }
{$EXTERNALSYM MM_AARDVARK                               }
{$EXTERNALSYM MM_BINTEC                                 }
{$EXTERNALSYM MM_HEWLETT_PACKARD                        }
{$EXTERNALSYM MM_ACULAB                                 }
{$EXTERNALSYM MM_FAITH                                  }
{$EXTERNALSYM MM_MITEL                                  }
{$EXTERNALSYM MM_QUANTUM3D                              }
{$EXTERNALSYM MM_SNI                                    }
{$EXTERNALSYM MM_EMU                                    }
{$EXTERNALSYM MM_ARTISOFT                               }
{$EXTERNALSYM MM_TURTLE_BEACH                           }
{$EXTERNALSYM MM_IBM                                    }
{$EXTERNALSYM MM_VOCALTEC                               }
{$EXTERNALSYM MM_ROLAND                                 }
{$EXTERNALSYM MM_DSP_SOLUTIONS                          }
{$EXTERNALSYM MM_NEC                                    }
{$EXTERNALSYM MM_ATI                                    }
{$EXTERNALSYM MM_WANGLABS                               }
{$EXTERNALSYM MM_TANDY                                  }
{$EXTERNALSYM MM_VOYETRA                                }
{$EXTERNALSYM MM_ANTEX                                  }
{$EXTERNALSYM MM_ICL_PS                                 }
{$EXTERNALSYM MM_INTEL                                  }
{$EXTERNALSYM MM_GRAVIS                                 }
{$EXTERNALSYM MM_VAL                                    }
{$EXTERNALSYM MM_INTERACTIVE                            }
{$EXTERNALSYM MM_YAMAHA                                 }
{$EXTERNALSYM MM_EVEREX                                 }
{$EXTERNALSYM MM_ECHO                                   }
{$EXTERNALSYM MM_SIERRA                                 }
{$EXTER…

Large files files are truncated, but you can click here to view the full file