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 = {viewgit}{/viewgit}00;
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 = 00;
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 = 000000;
ACM_DRIVERENUMF_DISABLED = 000000;
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 = {viewgit}{/viewgit}000003; // lParam is a procedure
ACM_DRIVERADDF_NOTIFYHWND = {viewgit}{/viewgit}000004; // lParam is notify hwnd
ACM_DRIVERADDF_TYPEMASK = {viewgit}{/viewgit}000007; // driver type mask
ACM_DRIVERADDF_LOCAL = {viewgit}{/viewgit}000000; // is local to current task
ACM_DRIVERADDF_GLOBAL = {viewgit}{/viewgit}000008; // 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 + {viewgit}{/viewgit}00);
ACMDM_RESERVED_LOW = (DRV_USER + 00);
ACMDM_RESERVED_HIGH = (DRV_USER + FFF);
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 = {viewgit}{/viewgit}000001;
ACM_DRIVERPRIORITYF_DISABLE = {viewgit}{/viewgit}000002;
ACM_DRIVERPRIORITYF_ABLEMASK = {viewgit}{/viewgit}000003;
ACM_DRIVERPRIORITYF_BEGIN = {viewgit}{/viewgit}010000;
ACM_DRIVERPRIORITYF_END = {viewgit}{/viewgit}020000;
ACM_DRIVERPRIORITYF_DEFERMASK = {viewgit}{/viewgit}030000;
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 = {viewgit}{/viewgit}000001;
ACMDRIVERDETAILS_SUPPORTF_CONVERTER = {viewgit}{/viewgit}000002;
ACMDRIVERDETAILS_SUPPORTF_FILTER = {viewgit}{/viewgit}000004;
ACMDRIVERDETAILS_SUPPORTF_HARDWARE = {viewgit}{/viewgit}000008;
ACMDRIVERDETAILS_SUPPORTF_ASYNC = {viewgit}{/viewgit}000010;
ACMDRIVERDETAILS_SUPPORTF_LOCAL = 000000;
ACMDRIVERDETAILS_SUPPORTF_DISABLED = 000000;
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;
end;
type
TACMFORMATTAGDETAILS = TACMFORMATTAGDETAILSA;
PACMFORMATTAGDETAILS = PACMFORMATTAGDETAILSA;
function acmFormatTagDetailsA(had : HACMDRIVER; var paftd : TACMFORMATTAGDETAILSA; fdwDetails : DWORD) : MMRESULT; stdcall;
function acmFormatTagDetailsW(had : HACMDRIVER; var paftd : TACMFORMATTAGDETAILSW; fdwDetails : DWORD) : MMRESULT; stdcall;
function acmFormatTagDetails(had : HACMDRIVER; var paftd : TACMFORMATTAGDETAILS; fdwDetails : DWORD) : MMRESULT; stdcall;
const
ACM_FORMATTAGDETAILSF_INDEX = {viewgit}{/viewgit}000000;
ACM_FORMATTAGDETAILSF_FORMATTAG = {viewgit}{/viewgit}000001;
ACM_FORMATTAGDETAILSF_LARGESTSIZE = {viewgit}{/viewgit}000002;
ACM_FORMATTAGDETAILSF_QUERYMASK = {viewgit}{/viewgit}00000F;
type
ACMFORMATTAGENUMCBA = function(hadid : HACMDRIVERID; const paftd : TACMFORMATTAGDETAILSA; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;
function acmFormatTagEnumA(had : HACMDRIVER; var paftd : TACMFORMATTAGDETAILSA; fnCallback : ACMFORMATTAGENUMCBA; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
type
ACMFORMATTAGENUMCBW = function(hadid : HACMDRIVERID; const paftd : TACMFORMATTAGDETAILSW; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;
function acmFormatTagEnumW(had : HACMDRIVER; var paftd : TACMFORMATTAGDETAILSW; fnCallback : ACMFORMATTAGENUMCBW; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
type
ACMFORMATTAGENUMCB = ACMFORMATTAGENUMCBA;
function acmFormatTagEnum(had : HACMDRIVER; var paftd : TACMFORMATTAGDETAILS; fnCallback : ACMFORMATTAGENUMCB; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
const
ACMFORMATDETAILS_FORMAT_CHARS = 128;
type
PACMFORMATDETAILSA = ^TACMFORMATDETAILSA;
TACMFORMATDETAILSA = packed record
cbStruct : DWORD;
dwFormatIndex : DWORD;
dwFormatTag : DWORD;
fdwSupport : DWORD;
pwfx : PWAVEFORMATEX;
cbwfx : DWORD;
szFormat : array[0..ACMFORMATDETAILS_FORMAT_CHARS-1] of char;
end;
type
PACMFORMATDETAILSW = ^TACMFORMATDETAILSW;
TACMFORMATDETAILSW = packed 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;
TACMFORMATDETAILS = TACMFORMATDETAILSA;
function acmFormatDetailsA(had : HACMDRIVER; var pafd : TACMFORMATDETAILSA; fdwDetails : DWORD) : MMRESULT; stdcall;
function acmFormatDetailsW(had : HACMDRIVER; var pafd : TACMFORMATDETAILSW; fdwDetails : DWORD) : MMRESULT; stdcall;
function acmFormatDetails(had : HACMDRIVER; var pafd : TACMFORMATDETAILS; fdwDetails : DWORD) : MMRESULT; stdcall;
const
ACM_FORMATDETAILSF_INDEX = {viewgit}{/viewgit}000000;
ACM_FORMATDETAILSF_FORMAT = {viewgit}{/viewgit}000001;
ACM_FORMATDETAILSF_QUERYMASK = {viewgit}{/viewgit}00000F;
type
ACMFORMATENUMCBA = function(hadid : HACMDRIVERID; const pafd : TACMFORMATDETAILSA; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;
function acmFormatEnumA(had : HACMDRIVER; var pafd : TACMFORMATDETAILSA; fnCallback : ACMFORMATENUMCBA; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
type
ACMFORMATENUMCBW = function(hadid : HACMDRIVERID; const pafd : TACMFORMATDETAILSW; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;
function acmFormatEnumW(had : HACMDRIVER; var pafd : TACMFORMATDETAILSW; fnCallback : ACMFORMATENUMCBW; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
type
ACMFORMATENUMCB = ACMFORMATENUMCBA;
function acmFormatEnum(had : HACMDRIVER; var pafd : TACMFORMATDETAILS; fnCallback : ACMFORMATENUMCB; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
const
ACM_FORMATENUMF_WFORMATTAG = {viewgit}{/viewgit}010000;
ACM_FORMATENUMF_NCHANNELS = {viewgit}{/viewgit}020000;
ACM_FORMATENUMF_NSAMPLESPERSEC = {viewgit}{/viewgit}040000;
ACM_FORMATENUMF_WBITSPERSAMPLE = {viewgit}{/viewgit}080000;
ACM_FORMATENUMF_CONVERT = {viewgit}{/viewgit}100000;
ACM_FORMATENUMF_SUGGEST = {viewgit}{/viewgit}200000;
ACM_FORMATENUMF_HARDWARE = {viewgit}{/viewgit}400000;
ACM_FORMATENUMF_INPUT = {viewgit}{/viewgit}800000;
ACM_FORMATENUMF_OUTPUT = 000000;
function acmFormatSuggest(had : HACMDRIVER; const pwfxSrc : TWAVEFORMATEX; var pwfxDst : TWAVEFORMATEX; cbwfxDst : DWORD; fdwSuggest : DWORD) : MMRESULT; stdcall;
const
ACM_FORMATSUGGESTF_WFORMATTAG = {viewgit}{/viewgit}010000;
ACM_FORMATSUGGESTF_NCHANNELS = {viewgit}{/viewgit}020000;
ACM_FORMATSUGGESTF_NSAMPLESPERSEC = {viewgit}{/viewgit}040000;
ACM_FORMATSUGGESTF_WBITSPERSAMPLE = {viewgit}{/viewgit}080000;
ACM_FORMATSUGGESTF_TYPEMASK = {viewgit}{/viewgit}FF0000;
const
ACMHELPMSGSTRINGA = 'acmchoose_help';
ACMHELPMSGSTRINGW = 'acmchoose_help';
ACMHELPMSGCONTEXTMENUA = 'acmchoose_contextmenu';
ACMHELPMSGCONTEXTMENUW = 'acmchoose_contextmenu';
ACMHELPMSGCONTEXTHELPA = 'acmchoose_contexthelp';
ACMHELPMSGCONTEXTHELPW = 'acmchoose_contexthelp';
const
ACMHELPMSGSTRING = ACMHELPMSGSTRINGA;
ACMHELPMSGCONTEXTMENU = ACMHELPMSGCONTEXTMENUA;
ACMHELPMSGCONTEXTHELP = ACMHELPMSGCONTEXTHELPA;
const
MM_ACM_FORMATCHOOSE = (00);
FORMATCHOOSE_MESSAGE = 0;
FORMATCHOOSE_FORMATTAG_VERIFY = (FORMATCHOOSE_MESSAGE+0);
FORMATCHOOSE_FORMAT_VERIFY = (FORMATCHOOSE_MESSAGE+1);
FORMATCHOOSE_CUSTOM_VERIFY = (FORMATCHOOSE_MESSAGE+2);
type
ACMFORMATCHOOSEHOOKPROCA = function(hwnd : HWND; uMsg : UINT; wParam : WPARAM; lParam : LPARAM) : UINT; stdcall;
type
ACMFORMATCHOOSEHOOKPROCW = function(hwnd : HWND; uMsg : UINT; wParam : WPARAM; lParam : LPARAM) : UINT; stdcall;
type
ACMFORMATCHOOSEHOOKPROC = ACMFORMATCHOOSEHOOKPROCA;
type
PACMFORMATCHOOSEA = ^TACMFORMATCHOOSEA;
TACMFORMATCHOOSEA = packed 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 char;
szFormat : array[0..ACMFORMATDETAILS_FORMAT_CHARS-1] of char;
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;
type
PACMFORMATCHOOSEW = ^TACMFORMATCHOOSEW;
TACMFORMATCHOOSEW = packed 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;
type
TACMFORMATCHOOSE = TACMFORMATCHOOSEA;
PACMFORMATCHOOSE = PACMFORMATCHOOSEA;
const
ACMFORMATCHOOSE_STYLEF_SHOWHELP = {viewgit}{/viewgit}000004;
ACMFORMATCHOOSE_STYLEF_ENABLEHOOK = {viewgit}{/viewgit}000008;
ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE = {viewgit}{/viewgit}000010;
ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = {viewgit}{/viewgit}000020;
ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT = {viewgit}{/viewgit}000040;
ACMFORMATCHOOSE_STYLEF_CONTEXTHELP = {viewgit}{/viewgit}000080;
function acmFormatChooseA(var pafmtc : TACMFORMATCHOOSEA) : MMRESULT; stdcall;
function acmFormatChooseW(var pafmtc : TACMFORMATCHOOSEW) : MMRESULT; stdcall;
function acmFormatChoose(var pafmtc : TACMFORMATCHOOSE) : MMRESULT; stdcall;
const
ACMFILTERTAGDETAILS_FILTERTAG_CHARS = 48;
type
PACMFILTERTAGDETAILSA = ^TACMFILTERTAGDETAILSA;
TACMFILTERTAGDETAILSA = packed record
cbStruct : DWORD ;
dwFilterTagIndex : DWORD ;
dwFilterTag : DWORD ;
cbFilterSize : DWORD ;
fdwSupport : DWORD ;
cStandardFilters : DWORD ;
szFilterTag : array[0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS-1] of char;
end;
type
PACMFILTERTAGDETAILSW = ^TACMFILTERTAGDETAILSW;
TACMFILTERTAGDETAILSW = packed record
cbStruct : DWORD ;
dwFilterTagIndex : DWORD ;
dwFilterTag : DWORD ;
cbFilterSize : DWORD ;
fdwSupport : DWORD ;
cStandardFilters : DWORD ;
szFilterTag : array[0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS-1] of wchar;
end;
type
PACMFILTERTAGDETAILS = PACMFILTERTAGDETAILSA;
TACMFILTERTAGDETAILS = TACMFILTERTAGDETAILSA;
function acmFilterTagDetailsA(had : HACMDRIVER; var paftd : TACMFILTERTAGDETAILSA; fdwDetails : DWORD) : MMRESULT; stdcall;
function acmFilterTagDetailsW(had : HACMDRIVER; var paftd : TACMFILTERTAGDETAILSW; fdwDetails : DWORD) : MMRESULT; stdcall;
function acmFilterTagDetails(had : HACMDRIVER; var paftd : TACMFILTERTAGDETAILS; fdwDetails : DWORD) : MMRESULT; stdcall;
const
ACM_FILTERTAGDETAILSF_INDEX = {viewgit}{/viewgit}000000;
ACM_FILTERTAGDETAILSF_FILTERTAG = {viewgit}{/viewgit}000001;
ACM_FILTERTAGDETAILSF_LARGESTSIZE = {viewgit}{/viewgit}000002;
ACM_FILTERTAGDETAILSF_QUERYMASK = {viewgit}{/viewgit}00000F;
type
ACMFILTERTAGENUMCBA = function(hadid : HACMDRIVERID; const paftd : TACMFILTERTAGDETAILSA; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;
function acmFilterTagEnumA(had : HACMDRIVER; var paftd : TACMFILTERTAGDETAILSA; fnCallback : ACMFILTERTAGENUMCBA; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
type
ACMFILTERTAGENUMCBW = function(hadid : HACMDRIVERID; const paftd : TACMFILTERTAGDETAILSW; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;
function acmFilterTagEnumW(had : HACMDRIVER; var paftd : TACMFILTERTAGDETAILSW; fnCallback : ACMFILTERTAGENUMCBW; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
type
ACMFILTERTAGENUMCB = ACMFILTERTAGENUMCBA;
function acmFilterTagEnum(had : HACMDRIVER; var paftd : TACMFILTERTAGDETAILS; fnCallback : ACMFILTERTAGENUMCB; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
const
ACMFILTERDETAILS_FILTER_CHARS = 128;
type
PACMFILTERDETAILSA = ^TACMFILTERDETAILSA;
TACMFILTERDETAILSA = packed record
cbStruct : DWORD ;
dwFilterIndex : DWORD ;
dwFilterTag : DWORD ;
fdwSupport : DWORD ;
pwfltr : PWAVEFILTER ;
cbwfltr : DWORD ;
szFilter : array[0..ACMFILTERDETAILS_FILTER_CHARS-1] of char;
end;
type
PACMFILTERDETAILSW = ^TACMFILTERDETAILSW;
TACMFILTERDETAILSW = packed record
cbStruct : DWORD ;
dwFilterIndex : DWORD ;
dwFilterTag : DWORD ;
fdwSupport : DWORD ;
pwfltr : PWAVEFILTER ;
cbwfltr : DWORD ;
szFilter : array[0..ACMFILTERDETAILS_FILTER_CHARS-1] of wchar;
end;
type
PACMFILTERDETAILS = PACMFILTERDETAILSA;
TACMFILTERDETAILS = TACMFILTERDETAILSA;
function acmFilterDetailsA(had : HACMDRIVER; var pafd : TACMFILTERDETAILSA; fdwDetails : DWORD) : MMRESULT; stdcall;
function acmFilterDetailsW(had : HACMDRIVER; var pafd : TACMFILTERDETAILSW; fdwDetails : DWORD) : MMRESULT; stdcall;
function acmFilterDetails(had : HACMDRIVER; var pafd : TACMFILTERDETAILS; fdwDetails : DWORD) : MMRESULT; stdcall;
const
ACM_FILTERDETAILSF_INDEX = {viewgit}{/viewgit}000000;
ACM_FILTERDETAILSF_FILTER = {viewgit}{/viewgit}000001;
ACM_FILTERDETAILSF_QUERYMASK = {viewgit}{/viewgit}00000F;
type
ACMFILTERENUMCBA = function(hadid : HACMDRIVERID; const pafd : TACMFILTERDETAILSA; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;
function acmFilterEnumA(had : HACMDRIVER; var pafd : TACMFILTERDETAILSA; fnCallback : ACMFILTERENUMCBA; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
type
ACMFILTERENUMCBW = function(hadid : HACMDRIVERID; const pafd : TACMFILTERDETAILSW; dwInstance : DWORD; fdwSupport : DWORD) : BOOL; stdcall;
function acmFilterEnumW(had : HACMDRIVER; var pafd : TACMFILTERDETAILSW; fnCallback : ACMFILTERENUMCBW; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
type
ACMFILTERENUMCB = ACMFILTERENUMCBA;
function acmFilterEnum(had : HACMDRIVER; var pafd : TACMFILTERDETAILS; fnCallback : ACMFILTERENUMCB; dwInstance : DWORD; fdwEnum : DWORD) : MMRESULT; stdcall;
const
ACM_FILTERENUMF_DWFILTERTAG = {viewgit}{/viewgit}010000;
const
MM_ACM_FILTERCHOOSE = (00);
FILTERCHOOSE_MESSAGE = 0;
FILTERCHOOSE_FILTERTAG_VERIFY = (FILTERCHOOSE_MESSAGE+0);
FILTERCHOOSE_FILTER_VERIFY = (FILTERCHOOSE_MESSAGE+1);
FILTERCHOOSE_CUSTOM_VERIFY = (FILTERCHOOSE_MESSAGE+2);
type
ACMFILTERCHOOSEHOOKPROCA = function(hwnd : HWND; uMsg : UINT; wParam : WPARAM; lParam : LPARAM) : UINT; stdcall;
type
ACMFILTERCHOOSEHOOKPROCW = function(hwnd : HWND; uMsg : UINT; wParam : WPARAM; lParam : LPARAM) : UINT; stdcall;
type
ACMFILTERCHOOSEHOOKPROC = ACMFILTERCHOOSEHOOKPROCA;
type
PACMFILTERCHOOSEA = ^TACMFILTERCHOOSEA;
TACMFILTERCHOOSEA = packed 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 char;
szFilter : array[0..ACMFILTERDETAILS_FILTER_CHARS-1] of char;
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;
type
PACMFILTERCHOOSEW = ^TACMFILTERCHOOSEW;
TACMFILTERCHOOSEW = packed 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;
type
PACMFILTERCHOOSE = PACMFILTERCHOOSEA;
TACMFILTERCHOOSE = TACMFILTERCHOOSEA;
const
ACMFILTERCHOOSE_STYLEF_SHOWHELP = {viewgit}{/viewgit}000004;
ACMFILTERCHOOSE_STYLEF_ENABLEHOOK = {viewgit}{/viewgit}000008;
ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE = {viewgit}{/viewgit}000010;
ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = {viewgit}{/viewgit}000020;
ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT = {viewgit}{/viewgit}000040;
ACMFILTERCHOOSE_STYLEF_CONTEXTHELP = {viewgit}{/viewgit}000080;
function acmFilterChooseA(var pafltrc : TACMFILTERCHOOSEA) : MMRESULT; stdcall;
function acmFilterChooseW(var pafltrc : TACMFILTERCHOOSEW) : MMRESULT; stdcall;
function acmFilterChoose(var pafltrc : TACMFILTERCHOOSE) : MMRESULT; stdcall;
type
PACMSTREAMHEADER = ^TACMSTREAMHEADER;
TACMSTREAMHEADER = packed record
cbStruct : DWORD ; // sizeof(ACMSTREAMHEADER)
fdwStatus : DWORD ; // ACMSTREAMHEADER_STATUSF_*
dwUser : DWORD ; // user instance data for hdr
pbSrc : PBYTE ;
cbSrcLength : DWORD ;
cbSrcLengthUsed : DWORD ;
dwSrcUser : DWORD ; // user instance data for src
pbDst : PBYTE ;
cbDstLength : DWORD ;
cbDstLengthUsed : DWORD ;
dwDstUser : DWORD ; // user instance data for dst
dwReservedDriver : array [0..9] of DWORD; // driver reserved work space
end;
const
ACMSTREAMHEADER_STATUSF_DONE = {viewgit}{/viewgit}010000;
ACMSTREAMHEADER_STATUSF_PREPARED = {viewgit}{/viewgit}020000;
ACMSTREAMHEADER_STATUSF_INQUEUE = {viewgit}{/viewgit}100000;
function acmStreamOpen(phas : PHACMSTREAM; had : HACMDRIVER; const pwfxSrc : TWAVEFORMATEX; const pwfxdst : TWAVEFORMATEX; pwfltr : PWAVEFILTER; dwCallback : DWORD; dwInstance : DWORD; fdwOpen : DWORD) : MMRESULT; stdcall;
const
ACM_STREAMOPENF_QUERY = {viewgit}{/viewgit}000001;
ACM_STREAMOPENF_ASYNC = {viewgit}{/viewgit}000002;
ACM_STREAMOPENF_NONREALTIME = {viewgit}{/viewgit}000004;
function acmStreamClose(has : HACMSTREAM; fdwClose : DWORD) : MMRESULT; stdcall;
function acmStreamSize(has : HACMSTREAM; cbInput : DWORD; var pdwOutputByte : DWORD; fdwSize : DWORD) : MMRESULT; stdcall;
const
ACM_STREAMSIZEF_SOURCE = {viewgit}{/viewgit}000000;
ACM_STREAMSIZEF_DESTINATION = {viewgit}{/viewgit}000001;
ACM_STREAMSIZEF_QUERYMASK = {viewgit}{/viewgit}00000F;
function acmStreamReset(has : HACMSTREAM; fdwReset : DWORD) : MMRESULT; stdcall;
function acmStreamMessage(has : HACMSTREAM; uMsg : UINT; lParam1 : LPARAM; lParam2 : LPARAM) : MMRESULT; stdcall;
function acmStreamConvert(has : HACMSTREAM; var pash : TACMSTREAMHEADER; fdwConvert : DWORD) : MMRESULT; stdcall;
const
ACM_STREAMCONVERTF_BLOCKALIGN = {viewgit}{/viewgit}000004;
ACM_STREAMCONVERTF_START = {viewgit}{/viewgit}000010;
ACM_STREAMCONVERTF_END = {viewgit}{/viewgit}000020;
function acmStreamPrepareHeader(has : HACMSTREAM; var pash : TACMSTREAMHEADER; fdwPrepare : DWORD) : MMRESULT; stdcall;
function acmStreamUnprepareHeader(has : HACMSTREAM; var pash : TACMSTREAMHEADER; fdwUnprepare : DWORD) : MMRESULT; stdcall;
implementation
const
msacm32 = 'msacm32.dll';
// acm
function acmGetVersion; external msacm32 name 'acmGetVersion';
function acmMetrics; external msacm32 name 'acmMetrics';
// acmDriver
function acmDriverEnum; external msacm32 name 'acmDriverEnum';
function acmDriverID; external msacm32 name 'acmDriverID';
function acmDriverAddA; external msacm32 name 'acmDriverAddA';
function acmDriverAddW; external msacm32 name 'acmDriverAddW';
function acmDriverAdd; external msacm32 name 'acmDriverAddA';
function acmDriverRemove; external msacm32 name 'acmDriverRemove';
function acmDriverOpen; external msacm32 name 'acmDriverOpen';
function acmDriverClose; external msacm32 name 'acmDriverClose';
function acmDriverMessage; external msacm32 name 'acmDriverMessage';
function acmDriverPriority; external msacm32 name 'acmDriverPriority';
function ACMDRIVERDETAILS_FCCTYPE_AUDIOCODE : FOURCC;
begin
Result := MMSystem.mmioStringToFOURCC('audc', 0);
end;
function acmDriverDetailsA; external msacm32 name 'acmDriverDetailsA';
function acmDriverDetailsW; external msacm32 name 'acmDriverDetailsW';
function acmDriverDetails; external msacm32 name 'acmDriverDetailsA';
// acmFormat
function acmFormatTagDetailsA; external msacm32 name 'acmFormatTagDetailsA';
function acmFormatTagDetailsW; external msacm32 name 'acmFormatTagDetailsW';
function acmFormatTagDetails; external msacm32 name 'acmFormatTagDetailsA';
function acmFormatTagEnumA; external msacm32 name 'acmFormatTagEnumA';
function acmFormatTagEnumW; external msacm32 name 'acmFormatTagEnumW';
function acmFormatTagEnum; external msacm32 name 'acmFormatTagEnumA';
function acmFormatDetailsA; external msacm32 name 'acmFormatDetailsA';
function acmFormatDetailsW; external msacm32 name 'acmFormatDetailsW';
function acmFormatDetails; external msacm32 name 'acmFormatDetailsA';
function acmFormatEnumA; external msacm32 name 'acmFormatEnumA';
function acmFormatEnumW; external msacm32 name 'acmFormatEnumW';
function acmFormatEnum; external msacm32 name 'acmFormatEnumA';
function acmFormatSuggest; external msacm32 name 'acmFormatSuggest';
function acmFormatChooseA; external msacm32 name 'acmFormatChooseA';
function acmFormatChooseW; external msacm32 name 'acmFormatChooseW';
function acmFormatChoose; external msacm32 name 'acmFormatChooseA';
// acmFilter
function acmFilterTagDetailsA; external msacm32 name 'acmFilterTagDetailsA';
function acmFilterTagDetailsW; external msacm32 name 'acmFilterTagDetailsW';
function acmFilterTagDetails; external msacm32 name 'acmFilterTagDetailsA';
function acmFilterTagEnumA; external msacm32 name 'acmFilterTagEnumA';
function acmFilterTagEnumW; external msacm32 name 'acmFilterTagEnumW';
function acmFilterTagEnum; external msacm32 name 'acmFilterTagEnumA';
function acmFilterDetailsA; external msacm32 name 'acmFilterDetailsA';
function acmFilterDetailsW; external msacm32 name 'acmFilterDetailsW';
function acmFilterDetails; external msacm32 name 'acmFilterDetailsA';
function acmFilterEnumA; external msacm32 name 'acmFilterEnumA';
function acmFilterEnumW; external msacm32 name 'acmFilterEnumW';
function acmFilterEnum; external msacm32 name 'acmFilterEnumA';
function acmFilterChooseA; external msacm32 name 'acmFilterChooseA';
function acmFilterChooseW; external msacm32 name 'acmFilterChooseW';
function acmFilterChoose; external msacm32 name 'acmFilterChooseA';
// acmStream
function acmStreamOpen; external msacm32 name 'acmStreamOpen';
function acmStreamClose; external msacm32 name 'acmStreamClose';
function acmStreamSize; external msacm32 name 'acmStreamSize';
function acmStreamReset; external msacm32 name 'acmStreamReset';
function acmStreamMessage; external msacm32 name 'acmStreamMessage';
function acmStreamConvert; external msacm32 name 'acmStreamConvert';
function acmStreamPrepareHeader; external msacm32 name 'acmStreamPrepareHeader';
function acmStreamUnprepareHeader; external msacm32 name 'acmStreamUnprepareHeader';
end.
