unit MSACM;

// ----------------------------------------------------------------------
//
// msacm.pas
// 
// Description:
//
//   Audio Compression Manager Public Header File
//
//   Converted for Delphi 2.x by Armin Sander, Digital SimpleX
//                               (armin@dsx.de)
//
//   please mail any changes and fixes!
//
// History:
//
//   1.0 - first official release (3 Feb 1997)
//
// Disclaimer:
//
//   This product is supplied as is. The author disclaims all warranties,
//   expressed or implied, including, without limitation, the warranties
//   of merchantability and of fitness for any purpose. The author assumes
//   no liability for damages, direct or consequential, which may result
//   from the use of this product.
//
// ----------------------------------------------------------------------

interface
uses Windows, MMSystem;

// MMREG include

const
	WAVE_FILTER_UNKNOWN        =  $0000;
	WAVE_FILTER_DEVELOPMENT    = ($FFFF);

type
	PWAVEFILTER = ^TWAVEFILTER;
	TWAVEFILTER = 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..5] of DWORD;      // Reserved for system use
	end;

const
	DRV_MAPPER_PREFERRED_INPUT_GET  = (DRV_USER + 0);

const
	DRV_MAPPER_PREFERRED_OUTPUT_GET = (DRV_USER + 2);

	DRVM_MAPPER_STATUS = $2000;

const
	WIDM_MAPPER_STATUS          = (DRVM_MAPPER_STATUS + 0);
	WAVEIN_MAPPER_STATUS_DEVICE = 0;
	WAVEIN_MAPPER_STATUS_MAPPED = 1;
	WAVEIN_MAPPER_STATUS_FORMAT = 2;

const
	WODM_MAPPER_STATUS           = (DRVM_MAPPER_STATUS + 0);
	WAVEOUT_MAPPER_STATUS_DEVICE = 0;
	WAVEOUT_MAPPER_STATUS_MAPPED = 1;
	WAVEOUT_MAPPER_STATUS_FORMAT = 2;

type
	HACMDRIVERID = THandle;
	PHACMDRIVERID = ^HACMDRIVERID;

type
	HACMDRIVER = THandle;
	PHACMDRIVER = ^HACMDRIVER;

type
	HACMSTREAM = THandle;
	PHACMSTREAM = ^HACMSTREAM;

type
	HACMOBJ = THandle;
	PHACMOBJ = ^HACMOBJ;

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

const
	MM_ACM_OPEN        = (MM_STREAM_OPEN);  // conversion callback messages
	MM_ACM_CLOSE       = (MM_STREAM_CLOSE);
	MM_ACM_DONE        = (MM_STREAM_DONE);

function acmGetVersion : DWORD; stdcall;

function acmMetrics(hao : HACMOBJ; uMetric : UINT; var pMetric) : MMRESULT; stdcall;

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

type
	ACMDRIVERENUMCB = function(hadid : HACMDRIVERID; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;

function acmDriverEnum(fnCallback : ACMDRIVERENUMCB; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;

const
	ACM_DRIVERENUMF_NOLOCAL     = $40000000;
	ACM_DRIVERENUMF_DISABLED    = $80000000;

function acmDriverID(hao : HACMOBJ; var phadid : HACMDRIVERID; fdwDriverID : DWORD) : MMRESULT; stdcall;

function acmDriverAddA(var phadid : HACMDRIVERID; hinstModule : THandle; lParam : LPARAM; dwPriority : DWORD; fdwAdd : DWORD) : MMRESULT; stdcall;

function acmDriverAddW(var phadid : HACMDRIVERID; hinstModule : THandle; lParam : LPARAM; dwPriority : DWORD; fdwAdd : DWORD) : MMRESULT; stdcall;

function acmDriverAdd(var phadid : HACMDRIVERID; hinstModule : THandle; lParam : LPARAM; dwPriority : DWORD; fdwAdd : DWORD) : MMRESULT; stdcall;

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

type
	ACMDRIVERPROC = function(_0 : DWORD; _1 : HACMDRIVERID; _2 : UINT; _3 : LPARAM; _4 : LPARAM) : LRESULT; stdcall;
	LPACMDRIVERPROC = ^ACMDRIVERPROC;

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

function acmDriverOpen(var phad : HACMDRIVER; hadid : HACMDRIVERID; fdwOpen : DWORD) : MMRESULT; stdcall;

function acmDriverClose(had : HACMDRIVER; fdwClose : DWORD) : MMRESULT; stdcall;

function acmDriverMessage(had : HACMDRIVER; uMsg : UINT; lParam1 : LPARAM; lParam2 : LPARAM) : LRESULT; stdcall;

const
	ACMDM_USER                  = (DRV_USER + $0000);
	ACMDM_RESERVED_LOW          = (DRV_USER + $2000);
	ACMDM_RESERVED_HIGH         = (DRV_USER + $2FFF);

	ACMDM_BASE                  = ACMDM_RESERVED_LOW;

	ACMDM_DRIVER_ABOUT          = (ACMDM_BASE + 11);

function acmDriverPriority(hadid : HACMDRIVERID; dwPriority : DWORD; fdwPriority : DWORD) : MMRESULT; stdcall;

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

const
	ACMDRIVERDETAILS_SHORTNAME_CHARS    = 32;
	ACMDRIVERDETAILS_LONGNAME_CHARS     = 128;
	ACMDRIVERDETAILS_COPYRIGHT_CHARS    = 80;
	ACMDRIVERDETAILS_LICENSING_CHARS    = 128;
	ACMDRIVERDETAILS_FEATURES_CHARS     = 512;

type
	PACMDRIVERDETAILSA = ^TACMDRIVERDETAILSA;
	TACMDRIVERDETAILSA = packed 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 char;
		szLongName    : array[0..ACMDRIVERDETAILS_LONGNAME_CHARS-1] of char;
		szCopyright   : array[0..ACMDRIVERDETAILS_COPYRIGHT_CHARS-1] of char;
		szLicensing   : array[0..ACMDRIVERDETAILS_LICENSING_CHARS-1] of char;
		szFeatures    : array[0..ACMDRIVERDETAILS_FEATURES_CHARS-1] of char;
	end;

type
	PACMDRIVERDETAILSW = ^TACMDRIVERDETAILSW;
	TACMDRIVERDETAILSW = packed 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;

type
	TACMDRIVERDETAILS       = TACMDRIVERDETAILSA;
	PACMDRIVERDETAILS       = PACMDRIVERDETAILSA;

const
	// ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC = mmioFOURCC('a', 'u', 'd', 'c');
	ACMDRIVERDETAILS_FCCCOMP_UNDEFINED  = 0;

function ACMDRIVERDETAILS_FCCTYPE_AUDIOCODE : FOURCC;

const
	ACMDRIVERDETAILS_SUPPORTF_CODEC     = $00000001;
	ACMDRIVERDETAILS_SUPPORTF_CONVERTER = $00000002;
	ACMDRIVERDETAILS_SUPPORTF_FILTER    = $00000004;
	ACMDRIVERDETAILS_SUPPORTF_HARDWARE  = $00000008;
	ACMDRIVERDETAILS_SUPPORTF_ASYNC     = $00000010;
	ACMDRIVERDETAILS_SUPPORTF_LOCAL     = $40000000;
	ACMDRIVERDETAILS_SUPPORTF_DISABLED  = $80000000;

function acmDriverDetailsA(hadid : HACMDRIVERID; var padd : TACMDRIVERDETAILSA; fdwDetails : DWORD) : MMRESULT; stdcall;

function acmDriverDetailsW(hadid : HACMDRIVERID; var padd : TACMDRIVERDETAILSW; fdwDetails : DWORD) : MMRESULT; stdcall;

function acmDriverDetails(hadid : HACMDRIVERID; var padd : TACMDRIVERDETAILS; fdwDetails : DWORD) : MMRESULT; stdcall;

const
	ACMFORMATTAGDETAILS_FORMATTAG_CHARS = 48;

type
	PACMFORMATTAGDETAILSA = ^TACMFORMATTAGDETAILSA;
	TACMFORMATTAGDETAILSA = packed record
		cbStruct         : DWORD;
		dwFormatTagIndex : DWORD;
		dwFormatTag      : DWORD;
		cbFormatSize     : DWORD;
		fdwSupport       : DWORD;
		cStandardFormats : DWORD;
		szFormatTag      : array[0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of char;
	end;

type
	PACMFORMATTAGDETAILSW = ^TACMFORMATTAGDETAILSW;
	TACMFORMATTAGDETAILSW = packed record
		cbStruct         : DWORD;
		dwFormatTagIndex : DWORD;
		dwFormatTag      : DWORD;
		cbFormatSize     : DWORD;
		fdwSupport       : DWORD;
		cStandardFormats : DWORD;
		szFormatTag      : array[0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of wchar;