Home Units Hierarchy Routines All identifiers

Unit unaMsAcmAPI

DescriptionUsesClasses, Interfaces, Objects and RecordsFunctions and ProceduresTypesConstantsVariables

Description

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.

2.5.2008.07 Still here

Uses

Overview

Classes, Interfaces, Objects and Records

Name Description
record ACMDRIVERDETAILSA  
record ACMDRIVERDETAILSW  
record ACMDRVFORMATSUGGEST structure containing the information for the ACMDM_FORMAT_SUGGEST message
record ACMDRVSTREAMHEADER  
record ACMDRVSTREAMINSTANCE – MSACMDRV.H –
record ACMDRVSTREAMSIZE structure for ACMDM_STREAM_SIZE message
record ACMFILTERCHOOSEA  
record ACMFILTERCHOOSEW  
record ACMFILTERDETAILSA  
record ACMFILTERDETAILSW  
record ACMFILTERTAGDETAILSA  
record ACMFILTERTAGDETAILSW  
record ACMFORMATCHOOSEA  
record ACMFORMATCHOOSEW  
record ACMFORMATDETAILSA  
record ACMFORMATDETAILSW  
record ACMFORMATTAGDETAILSA  
record ACMFORMATTAGDETAILSW  
record ACMSTREAMHEADER  
record ADPCMCOEFSET  
record ADPCMWAVEFORMAT  
record WAVEFILTER  
record WAVEFORMATEXTENSIBLE  
record WAVEFORMATEXTENSIBLE_SAMPLES you

New wave format development should be based on the WAVEFORMATEXTENSIBLE structure.

Functions and Procedures

function acm_getVersion: DWORD; stdcall;
function acm_metrics(hao: HACMOBJ; uMetric: UINT; var pMetric): MMRESULT; stdcall;
function acm_driverEnum(fnCallback: ACMDRIVERENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_driverID(hao: HACMOBJ; phadid: pHACMDRIVERID; fdwDriverID: DWORD): MMRESULT; stdcall;
function acm_driverAddA(phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
function acm_driverAddW(phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
function acm_driverAdd (phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
function acm_driverRemove(hadid: HACMDRIVERID; fdwRemove: DWORD): MMRESULT; stdcall;
function acm_driverOpen(phad: pHACMDRIVER; hadid: HACMDRIVERID; fdwOpen: DWORD): MMRESULT; stdcall;
function acm_driverClose(had: HACMDRIVER; fdwClose: DWORD): MMRESULT; stdcall;
function acm_driverMessage(had: HACMDRIVER; uMsg: UINT; lParam1: LPARAM; lParam2: LPARAM): LRESULT; stdcall;
function acm_driverPriority(hadid: HACMDRIVERID; dwPriority: DWORD; fdwPriority: DWORD): MMRESULT; stdcall;
function ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC(): FOURCC;
function acm_driverDetailsA(hadid: hACMDRIVERID; padd: pACMDRIVERDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_driverDetailsW(hadid: hACMDRIVERID; padd: pACMDRIVERDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_driverDetails (hadid: hACMDRIVERID; padd: pACMDRIVERDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_formatTagDetailsA(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_formatTagDetailsW(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_formatTagDetails (had: HACMDRIVER; paftd: pACMFORMATTAGDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_formatTagEnumA(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSA; fnCallback: ACMFORMATTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_formatTagEnumW(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSW; fnCallback: ACMFORMATTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_formatTagEnum (had: HACMDRIVER; paftd: pACMFORMATTAGDETAILS; fnCallback: ACMFORMATTAGENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_formatDetailsA(had: HACMDRIVER; pafd: pACMFORMATDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_formatDetailsW(had: HACMDRIVER; pafd: pACMFORMATDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_formatDetails (had: HACMDRIVER; pafd: pACMFORMATDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_formatEnumA(had: HACMDRIVER; pafd: pACMFORMATDETAILSA; fnCallback: ACMFORMATENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_formatEnumW(had: HACMDRIVER; pafd: pACMFORMATDETAILSW; fnCallback: ACMFORMATENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_formatEnum (had: HACMDRIVER; pafd: pACMFORMATDETAILS; fnCallback: ACMFORMATENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_formatSuggest(had: HACMDRIVER; pwfxSrc: pWAVEFORMATEX; pwfxDst: pWAVEFORMATEX; cbwfxDst: DWORD; fdwSuggest: DWORD): MMRESULT; stdcall;
function acm_formatChooseA(pafmtc: pACMFORMATCHOOSEA): MMRESULT; stdcall;
function acm_formatChooseW(pafmtc: pACMFORMATCHOOSEW): MMRESULT; stdcall;
function acm_formatChoose (pafmtc: pACMFORMATCHOOSE ): MMRESULT; stdcall;
function acm_filterTagDetailsA(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_filterTagDetailsW(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_filterTagDetails (had: HACMDRIVER; paftd: pACMFILTERTAGDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_filterTagEnumA(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSA; fnCallback: ACMFILTERTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_filterTagEnumW(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSW; fnCallback: ACMFILTERTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_filterTagEnum (had: HACMDRIVER; paftd: pACMFILTERTAGDETAILS; fnCallback: ACMFILTERTAGENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_filterDetailsA(had: HACMDRIVER; pafd: pACMFILTERDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_filterDetailsW(had: HACMDRIVER; pafd: pACMFILTERDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_filterDetails (had: HACMDRIVER; pafd: pACMFILTERDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
function acm_filterEnumA(had: HACMDRIVER; pafd: pACMFILTERDETAILSA; fnCallback: ACMFILTERENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_filterEnumW(had: HACMDRIVER; pafd: pACMFILTERDETAILSW; fnCallback: ACMFILTERENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_filterEnum (had: HACMDRIVER; pafd: pACMFILTERDETAILS; fnCallback: ACMFILTERENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
function acm_filterChooseA(pafltrc: pACMFILTERCHOOSEA): MMRESULT; stdcall;
function acm_filterChooseW(pafltrc: pACMFILTERCHOOSEW): MMRESULT; stdcall;
function acm_filterChoose (pafltrc: pACMFILTERCHOOSE): MMRESULT; stdcall;
function acm_streamOpen(phas: pHACMSTREAM; had: HACMDRIVER; pwfxSrc: pWAVEFORMATEX; pwfxdst: pWAVEFORMATEX; pwfltr: pWAVEFILTER; dwCallback: DWORD; dwInstance: DWORD; fdwOpen: DWORD): MMRESULT; stdcall;
function acm_streamClose(has: HACMSTREAM; fdwClose: DWORD): MMRESULT; stdcall;
function acm_streamSize(has: HACMSTREAM; cbInput: DWORD; var pdwOutputByte: DWORD; fdwSize: DWORD): MMRESULT; stdcall;
function acm_streamReset(has: HACMSTREAM; fdwReset: DWORD): MMRESULT; stdcall;
function acm_streamMessage(has: HACMSTREAM; uMsg: UINT; lParam1: LPARAM; lParam2: LPARAM): MMRESULT; stdcall;
function acm_streamConvert(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwConvert: DWORD): MMRESULT; stdcall;
function acm_streamPrepareHeader(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwPrepare: DWORD): MMRESULT; stdcall;
function acm_streamUnprepareHeader(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwUnprepare: DWORD): MMRESULT; stdcall;
function getAcmVersion(var major, minor: byte; var build: Word): bool;
function mid2str(mid: unsigned): string;
function waveFormat2str(const format: WAVEFORMATEX): aString;
function str2waveFormat(const str: aString; var format: WAVEFORMATEX; var size: unsigned): bool; overload;
function str2waveFormat(const str: aString; var format: pWAVEFORMATEX; var size: unsigned): bool; overload;
function str2waveFormat(const str: aString; var format: pWAVEFORMATEX): bool; overload;
function getFormatDescription(const format: WAVEFORMATEX; driver: HACMDRIVER = 0; defStr: string = ''): string;
function allocateWaveFormat(out format: pWAVEFORMATEX; driver: HACMOBJ = 0): unsigned; overload;
function allocateWaveFormat(const srcFormat: WAVEFORMATEX; out format: pWAVEFORMATEX): unsigned; overload;
function deleteWaveFormat(format: pWAVEFORMATEX): bool;
function getMaxWaveFormatSize(driver: HACMOBJ = 0): unsigned;
function getMaxWaveFilterSize(driver: HACMOBJ = 0): unsigned;

Types

WAVEFORMATEX = tWAVEFORMATEX;
pWAVEFILTER = ˆWAVEFILTER;
pHACMDRIVERID = ˆHACMDRIVERID;
HACMDRIVERID = tHandle;
pHACMDRIVER = ˆHACMDRIVER;
HACMDRIVER = tHandle;
pHACMSTREAM = ˆHACMSTREAM;
HACMSTREAM = tHandle;
pHACMOBJ = ˆHACMOBJ;
HACMOBJ = tHandle;
ACMDRIVERENUMCB = function(hadid: HACMDRIVERID; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMDRIVERPROC = function(a_0: DWORD; a_1: HACMDRIVERID; a_2: UINT; a_3: LPARAM; a_4: LPARAM): LRESULT; stdcall;
LPACMDRIVERPROC = ˆACMDRIVERPROC;
PACMDRVSTREAMHEADER = ˆACMDRVSTREAMHEADER;
pACMDRIVERDETAILSA = ˆACMDRIVERDETAILSA;
pACMDRIVERDETAILSW = ˆACMDRIVERDETAILSW;
ACMDRIVERDETAILS = ACMDRIVERDETAILSA;
pACMDRIVERDETAILS = pACMDRIVERDETAILSA;
pACMFORMATTAGDETAILSA = ˆACMFORMATTAGDETAILSA;
pACMFORMATTAGDETAILSW = ˆACMFORMATTAGDETAILSW;
ACMFORMATTAGDETAILS = ACMFORMATTAGDETAILSA;
pACMFORMATTAGDETAILS = pACMFORMATTAGDETAILSA;
ACMFORMATTAGENUMCBA = function(hadid: HACMDRIVERID; paftd: pACMFORMATTAGDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMFORMATTAGENUMCBW = function(hadid: HACMDRIVERID; paftd: pACMFORMATTAGDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMFORMATTAGENUMCB = ACMFORMATTAGENUMCBA;
pACMFORMATDETAILSA = ˆACMFORMATDETAILSA;
pACMFORMATDETAILSW = ˆACMFORMATDETAILSW;
pACMFORMATDETAILS = pACMFORMATDETAILSA;
ACMFORMATDETAILS = ACMFORMATDETAILSA;
ACMFORMATENUMCBA = function(hadid: HACMDRIVERID; pafd: pACMFORMATDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMFORMATENUMCBW = function(hadid: HACMDRIVERID; pafd: pACMFORMATDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMFORMATENUMCB = ACMFORMATENUMCBA;
ACMFORMATCHOOSEHOOKPROCA = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
ACMFORMATCHOOSEHOOKPROCW = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
ACMFORMATCHOOSEHOOKPROC = ACMFORMATCHOOSEHOOKPROCA;
pACMFORMATCHOOSEA = ˆACMFORMATCHOOSEA;
pACMFORMATCHOOSEW = ˆACMFORMATCHOOSEW;
ACMFORMATCHOOSE = ACMFORMATCHOOSEA;
pACMFORMATCHOOSE = pACMFORMATCHOOSEA;
pACMFILTERTAGDETAILSA = ˆACMFILTERTAGDETAILSA;
pACMFILTERTAGDETAILSW = ˆACMFILTERTAGDETAILSW;
ACMFILTERTAGDETAILS = ACMFILTERTAGDETAILSA;
pACMFILTERTAGDETAILS = pACMFILTERTAGDETAILSA;
ACMFILTERTAGENUMCBA = function(hadid: HACMDRIVERID; paftd: pACMFILTERTAGDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMFILTERTAGENUMCBW = function(hadid: HACMDRIVERID; paftd: pACMFILTERTAGDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMFILTERTAGENUMCB = ACMFILTERTAGENUMCBA;
pACMFILTERDETAILSA = ˆACMFILTERDETAILSA;
pACMFILTERDETAILSW = ˆACMFILTERDETAILSW;
ACMFILTERDETAILS = ACMFILTERDETAILSA;
pACMFILTERDETAILS = pACMFILTERDETAILSA;
ACMFILTERENUMCBA = function(hadid: hACMDRIVERID; pafd: pACMFILTERDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMFILTERENUMCBW = function(hadid: hACMDRIVERID; pafd: pACMFILTERDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
ACMFILTERENUMCB = ACMFILTERENUMCBA;
ACMFILTERCHOOSEHOOKPROCA = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
ACMFILTERCHOOSEHOOKPROCW = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
ACMFILTERCHOOSEHOOKPROC = ACMFILTERCHOOSEHOOKPROCA;
pACMFILTERCHOOSEA = ˆACMFILTERCHOOSEA;
pACMFILTERCHOOSEW = ˆACMFILTERCHOOSEW;
ACMFILTERCHOOSE = ACMFILTERCHOOSEA;
pACMFILTERCHOOSE = pACMFILTERCHOOSEA;
pACMSTREAMHEADER = ˆACMSTREAMHEADER;
PWAVEFORMATEXTENSIBLE = ˆWAVEFORMATEXTENSIBLE;
WAVEFORMATPCMEX = WAVEFORMATEXTENSIBLE;
PWAVEFORMATPCMEX = ˆWAVEFORMATPCMEX;
NPWAVEFORMATPCMEX = ˆWAVEFORMATPCMEX;
LPWAVEFORMATPCMEX = ˆWAVEFORMATPCMEX;
WAVEFORMATIEEEFLOATEX = WAVEFORMATEXTENSIBLE;
PWAVEFORMATIEEEFLOATEX = ˆWAVEFORMATIEEEFLOATEX;
NPWAVEFORMATIEEEFLOATEX = ˆWAVEFORMATIEEEFLOATEX;
LPWAVEFORMATIEEEFLOATEX = ˆWAVEFORMATIEEEFLOATEX;
PADPCMCOEFSET = ˆADPCMCOEFSET;
NPADPCMCOEFSET = ˆADPCMCOEFSET;
LPADPCMCOEFSET = ˆADPCMCOEFSET;
PADPCMWAVEFORMAT = ˆADPCMWAVEFORMAT;
NPADPCMWAVEFORMAT = ˆADPCMWAVEFORMAT;
LPADPCMWAVEFORMAT = ˆADPCMWAVEFORMAT;

Constants

ACMDM_BASE = ACMDM_RESERVED_LOW;
ACMDM_DRIVER_ABOUT = (ACMDM_BASE + 11);
ACMDM_DRIVER_DETAILS = (ACMDM_BASE + 10);
ACMDM_DRIVER_NOTIFY = (ACMDM_BASE + 1);
ACMDM_FILTERTAG_DETAILS = (ACMDM_BASE + 50);
ACMDM_FILTER_DETAILS = (ACMDM_BASE + 51);
ACMDM_FORMATTAG_DETAILS = (ACMDM_BASE + 25);
ACMDM_FORMAT_DETAILS = (ACMDM_BASE + 26);
ACMDM_FORMAT_SUGGEST = (ACMDM_BASE + 27);
ACMDM_HARDWARE_WAVE_CAPS_INPUT = (ACMDM_BASE + 20);
ACMDM_HARDWARE_WAVE_CAPS_OUTPUT = (ACMDM_BASE + 21);
ACMDM_RESERVED_HIGH = (DRV_USER + $2FFF);
ACMDM_RESERVED_LOW = (DRV_USER + $2000);
ACMDM_STREAM_CLOSE = (ACMDM_BASE + 77);
ACMDM_STREAM_CONVERT = (ACMDM_BASE + 79);
ACMDM_STREAM_OPEN = (ACMDM_BASE + 76);
ACMDM_STREAM_PREPARE = (ACMDM_BASE + 81);
ACMDM_STREAM_RESET = (ACMDM_BASE + 80);
ACMDM_STREAM_SIZE = (ACMDM_BASE + 78);
ACMDM_STREAM_UNPREPARE = (ACMDM_BASE + 82);
ACMDM_USER = (DRV_USER + $0000);
ACMDRIVERDETAILS_COPYRIGHT_CHARS = 80;
ACMDRIVERDETAILS_FCCCOMP_UNDEFINED = 0;
ACMDRIVERDETAILS_FEATURES_CHARS = 512;
ACMDRIVERDETAILS_LICENSING_CHARS = 128;
ACMDRIVERDETAILS_LONGNAME_CHARS = 128;
ACMDRIVERDETAILS_SHORTNAME_CHARS = 32;
ACMDRIVERDETAILS_SUPPORTF_ASYNC = $00000010;
ACMDRIVERDETAILS_SUPPORTF_CODEC = $00000001;
ACMDRIVERDETAILS_SUPPORTF_CONVERTER = $00000002;
ACMDRIVERDETAILS_SUPPORTF_DISABLED = $80000000;
ACMDRIVERDETAILS_SUPPORTF_FILTER = $00000004;
ACMDRIVERDETAILS_SUPPORTF_HARDWARE = $00000008;
ACMDRIVERDETAILS_SUPPORTF_LOCAL = $40000000;
ACMERR_BASE = 512;
ACMERR_BUSY = ACMERR_BASE + 1;
ACMERR_CANCELED = ACMERR_BASE + 3;
ACMERR_NOTPOSSIBLE = ACMERR_BASE + 0;
ACMERR_UNPREPARED = ACMERR_BASE + 2;
ACMFILTERCHOOSE_STYLEF_CONTEXTHELP = $00000080;
ACMFILTERCHOOSE_STYLEF_ENABLEHOOK = $00000008;
ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE = $00000010;
ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = $00000020;
ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT = $00000040;
ACMFILTERCHOOSE_STYLEF_SHOWHELP = $00000004;
ACMFILTERDETAILS_FILTER_CHARS = 128;
ACMFILTERTAGDETAILS_FILTERTAG_CHARS = 48;
ACMFORMATCHOOSE_STYLEF_CONTEXTHELP = $00000080;
ACMFORMATCHOOSE_STYLEF_ENABLEHOOK = $00000008;
ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE = $00000010;
ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = $00000020;
ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT = $00000040;
ACMFORMATCHOOSE_STYLEF_SHOWHELP = $00000004;
ACMFORMATDETAILS_FORMAT_CHARS = 128;
ACMFORMATTAGDETAILS_FORMATTAG_CHARS = 48;
ACMHELPMSGCONTEXTHELP = ACMHELPMSGCONTEXTHELPA;
ACMHELPMSGCONTEXTHELPA = 'acmchoose_contexthelp';
ACMHELPMSGCONTEXTHELPW = 'acmchoose_contexthelp';
ACMHELPMSGCONTEXTMENU = ACMHELPMSGCONTEXTMENUA;
ACMHELPMSGCONTEXTMENUA = 'acmchoose_contextmenu';
ACMHELPMSGCONTEXTMENUW = 'acmchoose_contextmenu';
ACMHELPMSGSTRING = ACMHELPMSGSTRINGA;
ACMHELPMSGSTRINGA = 'acmchoose_help';
ACMHELPMSGSTRINGW = 'acmchoose_help';
ACMSTREAMHEADER_STATUSF_DONE = $00010000;
ACMSTREAMHEADER_STATUSF_INQUEUE = $00100000;
ACMSTREAMHEADER_STATUSF_PREPARED = $00020000;
ACM_DRIVERADDF_FUNCTION = $00000003;
ACM_DRIVERADDF_GLOBAL = $00000008;
ACM_DRIVERADDF_LOCAL = $00000000;
ACM_DRIVERADDF_NOTIFYHWND = $00000004;
ACM_DRIVERADDF_TYPEMASK = $00000007;
ACM_DRIVERENUMF_DISABLED = $80000000;
ACM_DRIVERENUMF_NOLOCAL = $40000000;
ACM_DRIVERPRIORITYF_ABLEMASK = $00000003;
ACM_DRIVERPRIORITYF_BEGIN = $00010000;
ACM_DRIVERPRIORITYF_DEFERMASK = $00030000;
ACM_DRIVERPRIORITYF_DISABLE = $00000002;
ACM_DRIVERPRIORITYF_ENABLE = $00000001;
ACM_DRIVERPRIORITYF_END = $00020000;
ACM_FILTERDETAILSF_FILTER = $00000001;
ACM_FILTERDETAILSF_INDEX = $00000000;
ACM_FILTERDETAILSF_QUERYMASK = $0000000F;
ACM_FILTERENUMF_DWFILTERTAG = $00010000;
ACM_FILTERTAGDETAILSF_FILTERTAG = $00000001;
ACM_FILTERTAGDETAILSF_INDEX = $00000000;
ACM_FILTERTAGDETAILSF_LARGESTSIZE = $00000002;
ACM_FILTERTAGDETAILSF_QUERYMASK = $0000000F;
ACM_FORMATDETAILSF_FORMAT = $00000001;
ACM_FORMATDETAILSF_INDEX = $00000000;
ACM_FORMATDETAILSF_QUERYMASK = $0000000F;
ACM_FORMATENUMF_CONVERT = $00100000;
ACM_FORMATENUMF_HARDWARE = $00400000;
ACM_FORMATENUMF_INPUT = $00800000;
ACM_FORMATENUMF_NCHANNELS = $00020000;
ACM_FORMATENUMF_NSAMPLESPERSEC = $00040000;
ACM_FORMATENUMF_OUTPUT = $01000000;
ACM_FORMATENUMF_SUGGEST = $00200000;
ACM_FORMATENUMF_WBITSPERSAMPLE = $00080000;
ACM_FORMATENUMF_WFORMATTAG = $00010000;
ACM_FORMATSUGGESTF_NCHANNELS = $00020000;
ACM_FORMATSUGGESTF_NSAMPLESPERSEC = $00040000;
ACM_FORMATSUGGESTF_TYPEMASK = $00FF0000;
ACM_FORMATSUGGESTF_WBITSPERSAMPLE = $00080000;
ACM_FORMATSUGGESTF_WFORMATTAG = $00010000;
ACM_FORMATTAGDETAILSF_FORMATTAG = $00000001;
ACM_FORMATTAGDETAILSF_INDEX = $00000000;
ACM_FORMATTAGDETAILSF_LARGESTSIZE = $00000002;
ACM_FORMATTAGDETAILSF_QUERYMASK = $0000000F;
ACM_METRIC_COUNT_CODECS = 2;
ACM_METRIC_COUNT_CONVERTERS = 3;
ACM_METRIC_COUNT_DISABLED = 5;
ACM_METRIC_COUNT_DRIVERS = 1;
ACM_METRIC_COUNT_FILTERS = 4;
ACM_METRIC_COUNT_HARDWARE = 6;
ACM_METRIC_COUNT_LOCAL_CODECS = 21;
ACM_METRIC_COUNT_LOCAL_CONVERTERS = 22;
ACM_METRIC_COUNT_LOCAL_DISABLED = 24;
ACM_METRIC_COUNT_LOCAL_DRIVERS = 20;
ACM_METRIC_COUNT_LOCAL_FILTERS = 23;
ACM_METRIC_DRIVER_PRIORITY = 101;
ACM_METRIC_DRIVER_SUPPORT = 100;
ACM_METRIC_HARDWARE_WAVE_INPUT = 30;
ACM_METRIC_HARDWARE_WAVE_OUTPUT = 31;
ACM_METRIC_MAX_SIZE_FILTER = 51;
ACM_METRIC_MAX_SIZE_FORMAT = 50;
ACM_STREAMCONVERTF_BLOCKALIGN = $00000004;
ACM_STREAMCONVERTF_END = $00000020;
ACM_STREAMCONVERTF_START = $00000010;
ACM_STREAMOPENF_ASYNC = $00000002;
ACM_STREAMOPENF_NONREALTIME = $00000004;
ACM_STREAMOPENF_QUERY = $00000001;
ACM_STREAMSIZEF_DESTINATION = $00000001;
ACM_STREAMSIZEF_QUERYMASK = $0000000F;
ACM_STREAMSIZEF_SOURCE = $00000000;
DRVM_MAPPER_STATUS = $2000;
DRV_MAPPER_PREFERRED_INPUT_GET = (DRV_USER + 0);
DRV_MAPPER_PREFERRED_OUTPUT_GET = (DRV_USER + 2);
FILTERCHOOSE_CUSTOM_VERIFY = (FILTERCHOOSE_MESSAGE+2);
FILTERCHOOSE_FILTERTAG_VERIFY = (FILTERCHOOSE_MESSAGE+0);
FILTERCHOOSE_FILTER_VERIFY = (FILTERCHOOSE_MESSAGE+1);
FILTERCHOOSE_MESSAGE = 0;
FORMATCHOOSE_CUSTOM_VERIFY = (FORMATCHOOSE_MESSAGE + 2);
FORMATCHOOSE_FORMATTAG_VERIFY = (FORMATCHOOSE_MESSAGE + 0);
FORMATCHOOSE_FORMAT_VERIFY = (FORMATCHOOSE_MESSAGE + 1);
FORMATCHOOSE_MESSAGE = 0;
KSAUDIO_SPEAKER_5POINT1 = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT;
KSAUDIO_SPEAKER_5POINT1_BACK = KSAUDIO_SPEAKER_5POINT1;
KSAUDIO_SPEAKER_5POINT1_SURROUND = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or SPEAKER_SIDE_LEFT or SPEAKER_SIDE_RIGHT;
KSAUDIO_SPEAKER_7POINT1 = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT or SPEAKER_FRONT_LEFT_OF_CENTER or SPEAKER_FRONT_RIGHT_OF_CENTER;
KSAUDIO_SPEAKER_7POINT1_SURROUND = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT or SPEAKER_SIDE_LEFT or SPEAKER_SIDE_RIGHT;
KSAUDIO_SPEAKER_7POINT1_WIDE = KSAUDIO_SPEAKER_7POINT1;
KSAUDIO_SPEAKER_DIRECTOUT = 0;
KSAUDIO_SPEAKER_GROUND_FRONT_CENTER = SPEAKER_FRONT_CENTER;
KSAUDIO_SPEAKER_GROUND_FRONT_LEFT = SPEAKER_FRONT_LEFT;
KSAUDIO_SPEAKER_GROUND_FRONT_RIGHT = SPEAKER_FRONT_RIGHT;
KSAUDIO_SPEAKER_GROUND_REAR_LEFT = SPEAKER_BACK_LEFT;
KSAUDIO_SPEAKER_GROUND_REAR_RIGHT = SPEAKER_BACK_RIGHT;
KSAUDIO_SPEAKER_MONO = SPEAKER_FRONT_CENTER;
KSAUDIO_SPEAKER_QUAD = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT;
KSAUDIO_SPEAKER_STEREO = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT;
KSAUDIO_SPEAKER_SUPER_WOOFER = SPEAKER_LOW_FREQUENCY;
KSAUDIO_SPEAKER_SURROUND = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_BACK_CENTER;
KSAUDIO_SPEAKER_TOP_MIDDLE = SPEAKER_TOP_CENTER;
KSDATAFORMAT_SUBTYPE_ADPCM : tGuid = '{00000002-0000-0010-8000-00aa00389b71}';
KSDATAFORMAT_SUBTYPE_ALAW : tGuid = '{00000006-0000-0010-8000-00aa00389b71}';
KSDATAFORMAT_SUBTYPE_ANALOG : tGuid = '{6dba3190-67bd-11cf-a0f7-0020afd156e4}';
KSDATAFORMAT_SUBTYPE_DRM : tGuid = '{00000009-0000-0010-8000-00aa00389b71}';
KSDATAFORMAT_SUBTYPE_IEEE_FLOAT: tGuid = '{00000003-0000-0010-8000-00aa00389b71}';
KSDATAFORMAT_SUBTYPE_MPEG : tGuid = '{00000050-0000-0010-8000-00aa00389b71}';
KSDATAFORMAT_SUBTYPE_MULAW : tGuid = '{00000007-0000-0010-8000-00aa00389b71}';
KSDATAFORMAT_SUBTYPE_PCM : tGuid = '{00000001-0000-0010-8000-00aa00389b71}';
MEDIASUBTYPE_AIFF : tGuid = '{e436eb8d-524f-11ce-9f53-0020af0ba770}';
MEDIASUBTYPE_AU : tGuid = '{e436eb8c-524f-11ce-9f53-0020af0ba770}';
MEDIASUBTYPE_DOLBY_AC3_SPDIF : tGuid = '{00000092-0000-0010-8000-00aa00389b71}';
MEDIASUBTYPE_DRM_Audio : tGuid = '{00000009-0000-0010-8000-00aa00389b71}';
MEDIASUBTYPE_IEEE_FLOAT : tGuid = '{00000003-0000-0010-8000-00aa00389b71}';
MEDIASUBTYPE_PCM : tGuid = '{00000001-0000-0010-8000-00AA00389B71}';
MEDIASUBTYPE_RAW_SPORT : tGuid = '{00000240-0000-0010-8000-00aa00389b71}';
MEDIASUBTYPE_SPDIF_TAG_241h : tGuid = '{00000241-0000-0010-8000-00aa00389b71}';
MEDIASUBTYPE_WAVE : tGuid = '{e436eb8b-524f-11ce-9f53-0020af0ba770}';
MM_3COM = 260;
MM_AARDVARK = 11 ;
MM_ACM_CLOSE = MM_STREAM_CLOSE;
MM_ACM_DONE = MM_STREAM_DONE;
MM_ACM_FILTERCHOOSE = ($8000);
MM_ACM_FORMATCHOOSE = ($8000);
MM_ACM_OPEN = MM_STREAM_OPEN;
MM_ACTIVEVOICE = 225;
MM_ACULAB = 14 ;
MM_ADDX = 118;
MM_ADLACC = 91 ;
MM_ADMOS = 235;
MM_AHEAD = 77 ;
MM_ALARIS = 174;
MM_ALDIGITAL = 143;
MM_ALESIS = 243;
MM_AMD = 146;
MM_ANALOGDEVICES = 252;
MM_ANTEX = 31 ;
MM_APICOM = 116;
MM_APPLE = 99 ;
MM_APPS = 42 ;
MM_APT = 56 ;
MM_ARRAY = 231;
MM_ARTISOFT = 20 ;
MM_AST = 64 ;
MM_ATI = 27 ;
MM_ATT = 185;
MM_ATT_MICROELECTRONICS = 139;
MM_AUDIOFILE = 47 ;
MM_AUDIOPT = 74 ;
MM_AUDIOSCIENCE = 217;
MM_AURAVISION = 80 ;
MM_AUREAL = 181;
MM_AZTECH = 52 ;
MM_BCB = 192;
MM_BECUBED = 10 ;
MM_BERCOS = 199;
MM_BERKOM = 189;
MM_BINTEC = 12 ;
MM_BROOKTREE = 121;
MM_CANAM = 148;
MM_CANOPUS = 49 ;
MM_CASIO = 162;
MM_CAT = 41 ;
MM_CHROMATIC = 155;
MM_CIRRUSLOGIC = 105;
MM_COLORGRAPH = 179;
MM_COMPAQ = 92 ;
MM_COMPUSIC = 89 ;
MM_COMPUTER_FRIENDS = 45 ;
MM_CONCEPTS = 108;
MM_CONNECTIX = 158;
MM_CONTROLRES = 84 ;
MM_COREDYNAMICS = 147;
MM_CREATIVE = 2 ;
MM_CRYSTAL = 132;
MM_CRYSTAL_NET = 154;
MM_CS = 242;
MM_CYRIX = 6 ;
MM_DATAFUSION = 196;
MM_DATARAN = 232;
MM_DDD = 151;
MM_DIACOUSTICS = 129;
MM_DIALOGIC = 93 ;
MM_DIAMONDMM = 163;
MM_DICTAPHONE = 214;
MM_DIGIGRAM = 227;
MM_DIGITAL = 100;
MM_DIGITAL_AUDIO_LABS = 136;
MM_DOLBY = 78 ;
MM_DPSINC = 191;
MM_DSP_GROUP = 43 ;
MM_DSP_SOLUTIONS = 25 ;
MM_DTS = 226;
MM_DUCK = 197;
MM_DVISION = 165;
MM_ECHO = 39 ;
MM_ECS = 145;
MM_EES = 219;
MM_EMAGIC = 208;
MM_EMU = 19 ;
MM_ENET = 206;
MM_ENSONIQ = 125;
MM_EPSON = 50 ;
MM_ESS = 46 ;
MM_ETEK = 241;
MM_EUPHONICS = 152;
MM_EVEREX = 38 ;
MM_EXAN = 63 ;
MM_FAITH = 15 ;
MM_FAST = 126;
MM_FLEXION = 249;
MM_FORTEMEDIA = 229;
MM_FRAUNHOFER_IIS = 172;
MM_FRONTIER = 160;
MM_FTR = 198;
MM_FUJITSU = 4 ;
MM_GADGETLABS = 159;
MM_GRANDE = 117;
MM_GRAVIS = 34 ;
MM_GUILLEMOT = 207;
MM_GULBRANSEN = 130;
MM_HAFTMANN = 220;
MM_HEADSPACE = 222;
MM_HEWLETT_PACKARD = 13 ;
MM_HORIZONS = 107;
MM_HP = 253;
MM_HYPERACTIVE = 246;
MM_IBM = 22 ;
MM_ICCC = 259;
MM_ICE = 239;
MM_ICL_PS = 32 ;
MM_ICS = 57 ;
MM_INSOFT = 94 ;
MM_INTEL = 33 ;
MM_INTERACTIVE = 36 ;
MM_INTERNET = 244;
MM_INVISION = 188;
MM_IODD = 258;
MM_IOMAGIC = 82 ;
MM_IPI = 238;
MM_ISOLUTION = 106;
MM_ITERATEDSYS = 58 ;
MM_I_LINK = 233;
MM_KAY_ELEMETRICS = 131;
MM_KORG = 55 ;
MM_LERNOUT_AND_HAUSPIE = 97 ;
MM_LEXICON = 236;
MM_LOGITECH = 60 ;
MM_LUCENT = 184;
MM_LUCID = 221;
MM_LUMINOSITI = 224;
MM_LYNX = 212;
MM_LYRRUS = 88 ;
MM_MALDEN = 261;
MM_MARIAN = 190;
MM_MATROX_DIV = 254;
MM_MATSUSHITA = 83 ;
MM_MEDIASONIC = 71 ;
MM_MEDIATRIX = 141;
MM_MEDIAVISION = 3 ;
MM_MELABS = 44 ;
MM_MERGING_TECHNOLOGIES = 177;
MM_METHEUS = 59 ;
MM_MICRONAS = 251;
MM_MICROSOFT = 1 ;
MM_MIRO = 104;
MM_MITEL = 16 ;
MM_MOSCOM = 68 ;
MM_MOTIONPIXELS = 193;
MM_MOTOROLA = 48 ;
MM_MOTU = 101;
MM_MPTUS = 95 ;
MM_MSFT_ACM_G711 = 37;
MM_MSFT_ACM_GSM610 = 36;
MM_MSFT_ACM_IMAADPCM = 34;
MM_MSFT_ACM_MSADPCM = 33;
MM_MSFT_ACM_MSFILTER = 35;
MM_MSFT_ACM_PCM = 38;
MM_MSFT_GENERIC_AUX_CD = 30;
MM_MSFT_GENERIC_AUX_LINE = 28;
MM_MSFT_GENERIC_AUX_MIC = 29;
MM_MSFT_GENERIC_MIDIIN = 25;
MM_MSFT_GENERIC_MIDIOUT = 26;
MM_MSFT_GENERIC_MIDISYNTH = 27;
MM_MSFT_GENERIC_WAVEIN = 23;
MM_MSFT_GENERIC_WAVEOUT = 24;
MM_MSFT_MSACM = 32;
MM_MSFT_WSS_AUX = 21;
MM_MSFT_WSS_FMSYNTH_STEREO = 16;
MM_MSFT_WSS_MIXER = 17;
MM_MSFT_WSS_OEM_AUX = 22;
MM_MSFT_WSS_OEM_FMSYNTH_STEREO = 20;
MM_MSFT_WSS_OEM_MIXER = 31;
MM_MSFT_WSS_OEM_WAVEIN = 18;
MM_MSFT_WSS_OEM_WAVEOUT = 19;
MM_MSFT_WSS_WAVEIN = 14;
MM_MSFT_WSS_WAVEOUT = 15;
MM_MWM = 209;
MM_NCR = 62 ;
MM_NEC = 26 ;
MM_NEOMAGIC = 176;
MM_NETSCAPE = 166;
MM_NETXL = 8 ;
MM_NEWMEDIA = 86 ;
MM_NMP = 195;
MM_NMS = 87 ;
MM_NOGATECH = 75 ;
MM_NORRIS = 150;
MM_NORTHERN_TELECOM = 115;
MM_NVIDIA = 127;
MM_OKI = 79 ;
MM_OKSORI = 128;
MM_OLIVETTI = 81 ;
MM_ONLIVE = 200;
MM_OPCODE = 113;
MM_OPTI = 90 ;
MM_OSITECH = 103;
MM_OSPREY = 140;
MM_OTI = 180;
MM_PACIFICRESEARCH = 210;
MM_PHILIPS_SPEECH_PROCESSING = 7 ;
MM_PHONET = 203;
MM_PICTURETEL = 138;
MM_PID_UNMAPPED = MM_UNMAPPED;
MM_PINNACLE = 218;
MM_PRAGMATRAX = 5 ;
MM_PRECEPT = 153;
MM_QCIAR = 98 ;
MM_QDESIGN = 194;
MM_QTEAM = 169;
MM_QUALCOMM = 215;
MM_QUANTUM3D = 17 ;
MM_QUARTERDECK = 134;
MM_QUICKAUDIO = 255;
MM_QUICKNET = 173;
MM_RADIUS = 110;
MM_RHETOREX = 120;
MM_RICHMOND = 257;
MM_ROCKWELL = 111;
MM_ROLAND = 24 ;
MM_RZS = 216;
MM_S3 = 164;
MM_SANYO = 72 ;
MM_SCALACS = 54 ;
MM_SEERSYS = 137;
MM_SELSIUS_SYSTEMS = 234;
MM_SGI = 237;
MM_SHARP = 183;
MM_SICRESOURCE = 175;
MM_SIEMENS_SBC = 201;
MM_SIERRA = 40 ;
MM_SILICONSOFT = 69 ;
MM_SIPROLAB = 211;
MM_SNI = 18 ;
MM_SOFTLAB_NSK = 228;
MM_SOFTSOUND = 149;
MM_SONICFOUNDRY = 66 ;
MM_SONORUS = 230;
MM_SONY = 245;
MM_SORVIS = 187;
MM_SOUNDESIGNS = 142;
MM_SOUNDSPACE = 167;
MM_SPECTRUM_PRODUCTIONS = 213;
MM_SPECTRUM_SIGNAL_PROCESSING = 144;
MM_SPEECHCOMP = 76 ;
MM_SPLASH_STUDIOS = 133;
MM_STUDER = 171;
MM_SUNCOM = 186;
MM_SUPERMAC = 73 ;
MM_SYDEC_NV = 248;
MM_TANDY = 29 ;
MM_TDK = 135;
MM_TERALOGIC = 202;
MM_TERRATEC = 70 ;
MM_TRUEVISION = 51 ;
MM_TURTLE_BEACH = 21 ;
MM_UHER_INFORMATIC = 247;
MM_UNISYS = 223;
MM_UNMAPPED = $ffff;
MM_VAL = 35 ;
MM_VANKOEVERING = 168;
MM_VIA = 250;
MM_VIDEOLOGIC = 53 ;
MM_VIENNASYS = 157;
MM_VIONA = 161;
MM_VIRTUALMUSIC = 205;
MM_VITEC = 67 ;
MM_VIVO = 182;
MM_VOCALTEC = 23 ;
MM_VOICEINFO = 156;
MM_VOXWARE = 114;
MM_VOYETRA = 30 ;
MM_VQST = 240;
MM_VTG = 109;
MM_WANGLABS = 28 ;
MM_WEITEK = 96 ;
MM_WILDCAT = 119;
MM_WILLOWPOND = 65 ;
MM_WINBOND = 204;
MM_WINNOV = 61 ;
MM_WORKBIT = 102;
MM_XEBEC = 85 ;
MM_XIRLINK = 178;
MM_XYZ = 112;
MM_YAMAHA = 37 ;
MM_YOUCOM = 256;
MM_ZEFIRO = 170;
MM_ZYXEL = 9 ;
SPEAKER_ALL = $80000000;
SPEAKER_BACK_CENTER = $100;
SPEAKER_BACK_LEFT = $10;
SPEAKER_BACK_RIGHT = $20;
SPEAKER_DEFAULT = $A0000000;
SPEAKER_FRONT_CENTER = $4;
SPEAKER_FRONT_LEFT = $1;
SPEAKER_FRONT_LEFT_OF_CENTER = $40;
SPEAKER_FRONT_RIGHT = $2;
SPEAKER_FRONT_RIGHT_OF_CENTER = $80;
SPEAKER_LOW_FREQUENCY = $8;
SPEAKER_RESERVED = $7FFC0000;
SPEAKER_SIDE_LEFT = $200;
SPEAKER_SIDE_RIGHT = $400;
SPEAKER_TOP_BACK_CENTER = $10000;
SPEAKER_TOP_BACK_LEFT = $8000;
SPEAKER_TOP_BACK_RIGHT = $20000;
SPEAKER_TOP_CENTER = $800;
SPEAKER_TOP_FRONT_CENTER = $2000;
SPEAKER_TOP_FRONT_LEFT = $1000;
SPEAKER_TOP_FRONT_RIGHT = $4000;
WAVEIN_MAPPER_STATUS_DEVICE = 0;
WAVEIN_MAPPER_STATUS_FORMAT = 2;
WAVEIN_MAPPER_STATUS_MAPPED = 1;
WAVEOUT_MAPPER_STATUS_DEVICE = 0;
WAVEOUT_MAPPER_STATUS_FORMAT = 2;
WAVEOUT_MAPPER_STATUS_MAPPED = 1;
WAVE_FILTER_DEVELOPMENT = $FFFF;
WAVE_FILTER_UNKNOWN = $0000;
WAVE_FORMAT_ADPCM = $00002;
WAVE_FORMAT_ALAW = $00006;
WAVE_FORMAT_ANTEX_ADPCME = $00033;
WAVE_FORMAT_APTX = $00025;
WAVE_FORMAT_AUDIOFILE_AF10 = $00026;
WAVE_FORMAT_AUDIOFILE_AF36 = $00024;
WAVE_FORMAT_BTV_DIGITAL = $00400;
WAVE_FORMAT_CANOPUS_ATRAC = $00063;
WAVE_FORMAT_CIRRUS = $00060;
WAVE_FORMAT_CONTROL_RES_CR10 = $00037;
WAVE_FORMAT_CONTROL_RES_VQLPC = $00034;
WAVE_FORMAT_CREATIVE_ADPCM = $00200;
WAVE_FORMAT_CREATIVE_FASTSPEECH10 = $00203;
WAVE_FORMAT_CREATIVE_FASTSPEECH8 = $00202;
WAVE_FORMAT_CS2 = $00260;
WAVE_FORMAT_CS_IMAADPCM = $00039;
WAVE_FORMAT_CU_CODEC = $00019;
WAVE_FORMAT_DEVELOPMENT = $0FFFF;
WAVE_FORMAT_DF_G726 = $00085;
WAVE_FORMAT_DF_GSM610 = $00086;
WAVE_FORMAT_DIALOGIC_OKI_ADPCM = $00017;
WAVE_FORMAT_DIGIADPCM = $00036;
WAVE_FORMAT_DIGIFIX = $00016;
WAVE_FORMAT_DIGIREAL = $00035;
WAVE_FORMAT_DIGISTD = $00015;
WAVE_FORMAT_DIGITAL_G723 = $00123;
WAVE_FORMAT_DIRECT = $0008;
WAVE_FORMAT_DOLBY_AC2 = $00030;
WAVE_FORMAT_DOLBY_AC3_SPDIF = $00092;
WAVE_FORMAT_DSAT_DISPLAY = $00067;
WAVE_FORMAT_DSPGROUP_TRUESPEECH = $00022;
WAVE_FORMAT_DTS = $00008;
WAVE_FORMAT_DVI_ADPCM = $00011;
WAVE_FORMAT_DVM = $02000;
WAVE_FORMAT_ECHOSC1 = $00023;
WAVE_FORMAT_ECHOSC3 = $0003A;
WAVE_FORMAT_ESPCM = $00061;
WAVE_FORMAT_EXTENSIBLE = $0FFFE;
WAVE_FORMAT_FM_TOWNS_SND = $00300;
WAVE_FORMAT_G721_ADPCM = $00040;
WAVE_FORMAT_G722_ADPCM = $00065;
WAVE_FORMAT_G723_ADPCM = $00014;
WAVE_FORMAT_G726ADPCM = $00140;
WAVE_FORMAT_G726_ADPCM = $00064;
WAVE_FORMAT_G728_CELP = $00041;
WAVE_FORMAT_G729A = $00083;
WAVE_FORMAT_GSM610 = $00031;
WAVE_FORMAT_IBM_CVSD = $00005;
WAVE_FORMAT_IEEE_FLOAT = $00003;
WAVE_FORMAT_ILINK_VC = $00230;
WAVE_FORMAT_IMA_ADPCM = WAVE_FORMAT_DVI_ADPCM;
WAVE_FORMAT_IPI_HSX = $00250;
WAVE_FORMAT_IPI_RPELP = $00251;
WAVE_FORMAT_IRAT = $00101;
WAVE_FORMAT_ISIAUDIO = $00088;
WAVE_FORMAT_LH_CODEC = $01100;
WAVE_FORMAT_LRC = $00028;
WAVE_FORMAT_LUCENT_G723 = $00059;
WAVE_FORMAT_MALDEN_PHONYTALK = $000A0;
WAVE_FORMAT_MEDIASONIC_G723 = $00093;
WAVE_FORMAT_MEDIASPACE_ADPCM = $00012;
WAVE_FORMAT_MEDIAVISION_ADPCM = $00018;
WAVE_FORMAT_MPEG = $00050;
WAVE_FORMAT_MPEGLAYER3 = $00055;
WAVE_FORMAT_MSAUDIO1 = $00160;
WAVE_FORMAT_MSG723 = $00042;
WAVE_FORMAT_MSNAUDIO = $00032;
WAVE_FORMAT_MSRT24 = $00082;
WAVE_FORMAT_MULAW = $00007;
WAVE_FORMAT_MVI_MVI2 = $00084;
WAVE_FORMAT_NMS_VBXADPCM = $00038;
WAVE_FORMAT_NORRIS = $01400;
WAVE_FORMAT_OKI_ADPCM = $00010;
WAVE_FORMAT_OLIADPCM = $01001;
WAVE_FORMAT_OLICELP = $01002;
WAVE_FORMAT_OLIGSM = $01000;
WAVE_FORMAT_OLIOPR = $01004;
WAVE_FORMAT_OLISBC = $01003;
WAVE_FORMAT_ONLIVE = $00089;
WAVE_FORMAT_PAC = $00053;
WAVE_FORMAT_PACKED = $00099;
WAVE_FORMAT_PHILIPS_LPCBB = $00098;
WAVE_FORMAT_PROSODY_1612 = $00027;
WAVE_FORMAT_PROSODY_8KBPS = $00094;
WAVE_FORMAT_QDESIGN_MUSIC = $00450;
WAVE_FORMAT_QUALCOMM_HALFRATE = $00151;
WAVE_FORMAT_QUALCOMM_PUREVOICE = $00150;
WAVE_FORMAT_QUARTERDECK = $00220;
WAVE_FORMAT_RAW_SPORT = $00240;
WAVE_FORMAT_RHETOREX_ADPCM = $00100;
WAVE_FORMAT_ROCKWELL_ADPCM = $0003B;
WAVE_FORMAT_ROCKWELL_DIGITALK = $0003C;
WAVE_FORMAT_RT24 = $00052;
WAVE_FORMAT_SANYO_LD_ADPCM = $00125;
WAVE_FORMAT_SBC24 = $00091;
WAVE_FORMAT_SIERRA_ADPCM = $00013;
WAVE_FORMAT_SIPROLAB_ACELP4800 = $00131;
WAVE_FORMAT_SIPROLAB_ACELP8V3 = $00132;
WAVE_FORMAT_SIPROLAB_ACEPLNET = $00130;
WAVE_FORMAT_SIPROLAB_G729 = $00133;
WAVE_FORMAT_SIPROLAB_G729A = $00134;
WAVE_FORMAT_SIPROLAB_KELVIN = $00135;
WAVE_FORMAT_SOFTSOUND = $00080;
WAVE_FORMAT_SONARC = $00021;
WAVE_FORMAT_SONY_SCX = $00270;
WAVE_FORMAT_SOUNDSPACE_MUSICOMPRESS = $01500;
WAVE_FORMAT_TPC = $00681;
WAVE_FORMAT_TUBGSM = $00155;
WAVE_FORMAT_UHER_ADPCM = $00210;
WAVE_FORMAT_UNKNOWN = $00000;
WAVE_FORMAT_VIVO_G723 = $00111;
WAVE_FORMAT_VIVO_SIREN = $00112;
WAVE_FORMAT_VME_VMPCM = $00680;
WAVE_FORMAT_VOXWARE = $00062;
WAVE_FORMAT_VOXWARE_AC10 = $00071;
WAVE_FORMAT_VOXWARE_AC16 = $00072;
WAVE_FORMAT_VOXWARE_AC20 = $00073;
WAVE_FORMAT_VOXWARE_AC8 = $00070;
WAVE_FORMAT_VOXWARE_BYTE_ALIGNED = $00069;
WAVE_FORMAT_VOXWARE_RT24 = $00074;
WAVE_FORMAT_VOXWARE_RT29 = $00075;
WAVE_FORMAT_VOXWARE_RT29HW = $00076;
WAVE_FORMAT_VOXWARE_TQ40 = $00079;
WAVE_FORMAT_VOXWARE_TQ60 = $00081;
WAVE_FORMAT_VOXWARE_VR12 = $00077;
WAVE_FORMAT_VOXWARE_VR18 = $00078;
WAVE_FORMAT_VSELP = $00004;
WAVE_FORMAT_XEBEC = $0003D;
WAVE_FORMAT_YAMAHA_ADPCM = $00020;
WAVE_FORMAT_ZYXEL_ADPCM = $00097;
WIDM_MAPPER_STATUS = (DRVM_MAPPER_STATUS + 0);
WODM_MAPPER_STATUS = (DRVM_MAPPER_STATUS + 0);
_DRVRESERVED = 10;

Description

Functions and Procedures

function acm_getVersion: DWORD; stdcall;

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 acm_metrics(hao: HACMOBJ; uMetric: UINT; var pMetric): MMRESULT; stdcall;
 
function acm_driverEnum(fnCallback: ACMDRIVERENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_driverID(hao: HACMOBJ; phadid: pHACMDRIVERID; fdwDriverID: DWORD): MMRESULT; stdcall;
 
function acm_driverAddA(phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
 
function acm_driverAddW(phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
 
function acm_driverAdd (phadid: pHACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
 
function acm_driverRemove(hadid: HACMDRIVERID; fdwRemove: DWORD): MMRESULT; stdcall;
 
function acm_driverOpen(phad: pHACMDRIVER; hadid: HACMDRIVERID; fdwOpen: DWORD): MMRESULT; stdcall;
 
function acm_driverClose(had: HACMDRIVER; fdwClose: DWORD): MMRESULT; stdcall;
 
function acm_driverMessage(had: HACMDRIVER; uMsg: UINT; lParam1: LPARAM; lParam2: LPARAM): LRESULT; stdcall;
 
function acm_driverPriority(hadid: HACMDRIVERID; dwPriority: DWORD; fdwPriority: DWORD): MMRESULT; stdcall;
 
function ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC(): FOURCC;

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');

function acm_driverDetailsA(hadid: hACMDRIVERID; padd: pACMDRIVERDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_driverDetailsW(hadid: hACMDRIVERID; padd: pACMDRIVERDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_driverDetails (hadid: hACMDRIVERID; padd: pACMDRIVERDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_formatTagDetailsA(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_formatTagDetailsW(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_formatTagDetails (had: HACMDRIVER; paftd: pACMFORMATTAGDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_formatTagEnumA(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSA; fnCallback: ACMFORMATTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_formatTagEnumW(had: HACMDRIVER; paftd: pACMFORMATTAGDETAILSW; fnCallback: ACMFORMATTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_formatTagEnum (had: HACMDRIVER; paftd: pACMFORMATTAGDETAILS; fnCallback: ACMFORMATTAGENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_formatDetailsA(had: HACMDRIVER; pafd: pACMFORMATDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_formatDetailsW(had: HACMDRIVER; pafd: pACMFORMATDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_formatDetails (had: HACMDRIVER; pafd: pACMFORMATDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_formatEnumA(had: HACMDRIVER; pafd: pACMFORMATDETAILSA; fnCallback: ACMFORMATENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_formatEnumW(had: HACMDRIVER; pafd: pACMFORMATDETAILSW; fnCallback: ACMFORMATENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_formatEnum (had: HACMDRIVER; pafd: pACMFORMATDETAILS; fnCallback: ACMFORMATENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_formatSuggest(had: HACMDRIVER; pwfxSrc: pWAVEFORMATEX; pwfxDst: pWAVEFORMATEX; cbwfxDst: DWORD; fdwSuggest: DWORD): MMRESULT; stdcall;
 
function acm_formatChooseA(pafmtc: pACMFORMATCHOOSEA): MMRESULT; stdcall;
 
function acm_formatChooseW(pafmtc: pACMFORMATCHOOSEW): MMRESULT; stdcall;
 
function acm_formatChoose (pafmtc: pACMFORMATCHOOSE ): MMRESULT; stdcall;
 
function acm_filterTagDetailsA(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_filterTagDetailsW(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_filterTagDetails (had: HACMDRIVER; paftd: pACMFILTERTAGDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_filterTagEnumA(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSA; fnCallback: ACMFILTERTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_filterTagEnumW(had: HACMDRIVER; paftd: pACMFILTERTAGDETAILSW; fnCallback: ACMFILTERTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_filterTagEnum (had: HACMDRIVER; paftd: pACMFILTERTAGDETAILS; fnCallback: ACMFILTERTAGENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_filterDetailsA(had: HACMDRIVER; pafd: pACMFILTERDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_filterDetailsW(had: HACMDRIVER; pafd: pACMFILTERDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_filterDetails (had: HACMDRIVER; pafd: pACMFILTERDETAILS; fdwDetails: DWORD): MMRESULT; stdcall;
 
function acm_filterEnumA(had: HACMDRIVER; pafd: pACMFILTERDETAILSA; fnCallback: ACMFILTERENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_filterEnumW(had: HACMDRIVER; pafd: pACMFILTERDETAILSW; fnCallback: ACMFILTERENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_filterEnum (had: HACMDRIVER; pafd: pACMFILTERDETAILS; fnCallback: ACMFILTERENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
 
function acm_filterChooseA(pafltrc: pACMFILTERCHOOSEA): MMRESULT; stdcall;
 
function acm_filterChooseW(pafltrc: pACMFILTERCHOOSEW): MMRESULT; stdcall;
 
function acm_filterChoose (pafltrc: pACMFILTERCHOOSE): MMRESULT; stdcall;
 
function acm_streamOpen(phas: pHACMSTREAM; had: HACMDRIVER; pwfxSrc: pWAVEFORMATEX; pwfxdst: pWAVEFORMATEX; pwfltr: pWAVEFILTER; dwCallback: DWORD; dwInstance: DWORD; fdwOpen: DWORD): MMRESULT; stdcall;
 
function acm_streamClose(has: HACMSTREAM; fdwClose: DWORD): MMRESULT; stdcall;
 
function acm_streamSize(has: HACMSTREAM; cbInput: DWORD; var pdwOutputByte: DWORD; fdwSize: DWORD): MMRESULT; stdcall;
 
function acm_streamReset(has: HACMSTREAM; fdwReset: DWORD): MMRESULT; stdcall;
 
function acm_streamMessage(has: HACMSTREAM; uMsg: UINT; lParam1: LPARAM; lParam2: LPARAM): MMRESULT; stdcall;
 
function acm_streamConvert(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwConvert: DWORD): MMRESULT; stdcall;
 
function acm_streamPrepareHeader(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwPrepare: DWORD): MMRESULT; stdcall;
 
function acm_streamUnprepareHeader(has: HACMSTREAM; pash: pACMSTREAMHEADER; fdwUnprepare: DWORD): MMRESULT; stdcall;
 
function getAcmVersion(var major, minor: byte; var build: Word): bool;

Returns ACM version and true if ACM is retail (Build = 0)

function mid2str(mid: unsigned): string;

Converts mid value to string representation.

function waveFormat2str(const format: WAVEFORMATEX): aString;

Converts format value to string representation (using base64 encoding).

function str2waveFormat(const str: aString; var format: WAVEFORMATEX; var size: unsigned): bool; overload;

Converts string representation of WAVEFORMATEX structure (encoded using base64) to format value.

If size is too small to hold the structure, this function returns false and size parameter will be set to required size of structure. Otherwise it fills the format and returns true.

function str2waveFormat(const str: aString; var format: pWAVEFORMATEX; var size: unsigned): bool; overload;

Converts string representation of WAVEFORMATEX structure (encoded using base64) to format value.

Allocates necessary amount of memory for format parameter.

function str2waveFormat(const str: aString; var format: pWAVEFORMATEX): bool; overload;
 
function getFormatDescription(const format: WAVEFORMATEX; driver: HACMDRIVER = 0; defStr: string = ''): string;

Returns description of given wave format.

Returns

defStr if format is not supported by driver(s).

function allocateWaveFormat(out format: pWAVEFORMATEX; driver: HACMOBJ = 0): unsigned; overload;

Allocates wave format with maximum possible size for specified driver.

Returns

number of bytes allocated.

function allocateWaveFormat(const srcFormat: WAVEFORMATEX; out format: pWAVEFORMATEX): unsigned; overload;

Allocates wave format equal to specified source format.

Returns

number of bytes allocated.

function deleteWaveFormat(format: pWAVEFORMATEX): bool;

Deallocates memory used by format.

function getMaxWaveFormatSize(driver: HACMOBJ = 0): unsigned;

Returns maximum possible size of wave format for specified driver.

If driver = 0 function queries all installed drivers.

function getMaxWaveFilterSize(driver: HACMOBJ = 0): unsigned;

Returns maximum possible size of wave filter for specified driver.

If driver = 0 function queries all installed drivers.

Types

WAVEFORMATEX = tWAVEFORMATEX;

C++Builders stuff

pWAVEFILTER = ˆWAVEFILTER;
 
pHACMDRIVERID = ˆHACMDRIVERID;

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.

HACMDRIVERID = tHandle;
 
pHACMDRIVER = ˆHACMDRIVER;

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.

HACMDRIVER = tHandle;
 
pHACMSTREAM = ˆHACMSTREAM;

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.

HACMSTREAM = tHandle;
 
pHACMOBJ = ˆHACMOBJ;

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.

HACMOBJ = tHandle;
 
ACMDRIVERENUMCB = function(hadid: HACMDRIVERID; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;

————————————————————————–

ACM Drivers

ACMDRIVERPROC = function(a_0: DWORD; a_1: HACMDRIVERID; a_2: UINT; a_3: LPARAM; a_4: LPARAM): LRESULT; stdcall;

prototype for ACM driver procedures that are installed as _functions_ or _notifations_ instead of as a standalone installable driver.

LPACMDRIVERPROC = ˆACMDRIVERPROC;
 
PACMDRVSTREAMHEADER = ˆACMDRVSTREAMHEADER;

NOTE! this structure must match the ACMSTREAMHEADER in msacm.h but defines more information for the driver writing convenience

pACMDRIVERDETAILSA = ˆACMDRIVERDETAILSA;
 
pACMDRIVERDETAILSW = ˆACMDRIVERDETAILSW;
 
ACMDRIVERDETAILS = ACMDRIVERDETAILSA;
 
pACMDRIVERDETAILS = pACMDRIVERDETAILSA;
 
pACMFORMATTAGDETAILSA = ˆACMFORMATTAGDETAILSA;
 
pACMFORMATTAGDETAILSW = ˆACMFORMATTAGDETAILSW;
 
ACMFORMATTAGDETAILS = ACMFORMATTAGDETAILSA;
 
pACMFORMATTAGDETAILS = pACMFORMATTAGDETAILSA;
 
ACMFORMATTAGENUMCBA = function(hadid: HACMDRIVERID; paftd: pACMFORMATTAGDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
 
ACMFORMATTAGENUMCBW = function(hadid: HACMDRIVERID; paftd: pACMFORMATTAGDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
 
ACMFORMATTAGENUMCB = ACMFORMATTAGENUMCBA;
 
pACMFORMATDETAILSA = ˆACMFORMATDETAILSA;
 
pACMFORMATDETAILSW = ˆACMFORMATDETAILSW;
 
pACMFORMATDETAILS = pACMFORMATDETAILSA;
 
ACMFORMATDETAILS = ACMFORMATDETAILSA;
 
ACMFORMATENUMCBA = function(hadid: HACMDRIVERID; pafd: pACMFORMATDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
 
ACMFORMATENUMCBW = function(hadid: HACMDRIVERID; pafd: pACMFORMATDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
 
ACMFORMATENUMCB = ACMFORMATENUMCBA;
 
ACMFORMATCHOOSEHOOKPROCA = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
 
ACMFORMATCHOOSEHOOKPROCW = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
 
ACMFORMATCHOOSEHOOKPROC = ACMFORMATCHOOSEHOOKPROCA;
 
pACMFORMATCHOOSEA = ˆACMFORMATCHOOSEA;
 
pACMFORMATCHOOSEW = ˆACMFORMATCHOOSEW;

ptr to hook function

ACMFORMATCHOOSE = ACMFORMATCHOOSEA;

ptr to hook function

pACMFORMATCHOOSE = pACMFORMATCHOOSEA;
 
pACMFILTERTAGDETAILSA = ˆACMFILTERTAGDETAILSA;
 
pACMFILTERTAGDETAILSW = ˆACMFILTERTAGDETAILSW;
 
ACMFILTERTAGDETAILS = ACMFILTERTAGDETAILSA;
 
pACMFILTERTAGDETAILS = pACMFILTERTAGDETAILSA;
 
ACMFILTERTAGENUMCBA = function(hadid: HACMDRIVERID; paftd: pACMFILTERTAGDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
 
ACMFILTERTAGENUMCBW = function(hadid: HACMDRIVERID; paftd: pACMFILTERTAGDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
 
ACMFILTERTAGENUMCB = ACMFILTERTAGENUMCBA;
 
pACMFILTERDETAILSA = ˆACMFILTERDETAILSA;
 
pACMFILTERDETAILSW = ˆACMFILTERDETAILSW;
 
ACMFILTERDETAILS = ACMFILTERDETAILSA;
 
pACMFILTERDETAILS = pACMFILTERDETAILSA;
 
ACMFILTERENUMCBA = function(hadid: hACMDRIVERID; pafd: pACMFILTERDETAILSA; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
 
ACMFILTERENUMCBW = function(hadid: hACMDRIVERID; pafd: pACMFILTERDETAILSW; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;
 
ACMFILTERENUMCB = ACMFILTERENUMCBA;
 
ACMFILTERCHOOSEHOOKPROCA = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
 
ACMFILTERCHOOSEHOOKPROCW = function(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
 
ACMFILTERCHOOSEHOOKPROC = ACMFILTERCHOOSEHOOKPROCA;
 
pACMFILTERCHOOSEA = ˆACMFILTERCHOOSEA;
 
pACMFILTERCHOOSEW = ˆACMFILTERCHOOSEW;

ptr to hook function

ACMFILTERCHOOSE = ACMFILTERCHOOSEA;

ptr to hook function

pACMFILTERCHOOSE = pACMFILTERCHOOSEA;
 
pACMSTREAMHEADER = ˆACMSTREAMHEADER;

#endif // _WIN64

PWAVEFORMATEXTENSIBLE = ˆWAVEFORMATEXTENSIBLE;

If neither applies, set to zero. */

WAVEFORMATPCMEX = WAVEFORMATEXTENSIBLE;

Extended PCM waveform format structure based on WAVEFORMATEXTENSIBLE. Use this for multiple channel and hi-resolution PCM data

PWAVEFORMATPCMEX = ˆWAVEFORMATPCMEX;

Format.cbSize = 22 */

NPWAVEFORMATPCMEX = ˆWAVEFORMATPCMEX;
 
LPWAVEFORMATPCMEX = ˆWAVEFORMATPCMEX;
 
WAVEFORMATIEEEFLOATEX = WAVEFORMATEXTENSIBLE;

Extended format structure using IEEE Float data and based on WAVEFORMATEXTENSIBLE. Use this for multiple channel and hi-resolution PCM data in IEEE floating point format.

PWAVEFORMATIEEEFLOATEX = ˆWAVEFORMATIEEEFLOATEX;

Format.cbSize = 22 */

NPWAVEFORMATIEEEFLOATEX = ˆWAVEFORMATIEEEFLOATEX;
 
LPWAVEFORMATIEEEFLOATEX = ˆWAVEFORMATIEEEFLOATEX;
 
PADPCMCOEFSET = ˆADPCMCOEFSET;

Define data for MS ADPCM */

NPADPCMCOEFSET = ˆADPCMCOEFSET;
 
LPADPCMCOEFSET = ˆADPCMCOEFSET;
 
PADPCMWAVEFORMAT = ˆADPCMWAVEFORMAT;
 
NPADPCMWAVEFORMAT = ˆADPCMWAVEFORMAT;
 
LPADPCMWAVEFORMAT = ˆADPCMWAVEFORMAT;
 

Constants

ACMDM_BASE = ACMDM_RESERVED_LOW;
 
ACMDM_DRIVER_ABOUT = (ACMDM_BASE + 11);
 
ACMDM_DRIVER_DETAILS = (ACMDM_BASE + 10);
 
ACMDM_DRIVER_NOTIFY = (ACMDM_BASE + 1);

Dest Size - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

ACM Driver Messages

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

ACMDM_FILTERTAG_DETAILS = (ACMDM_BASE + 50);
 
ACMDM_FILTER_DETAILS = (ACMDM_BASE + 51);
 
ACMDM_FORMATTAG_DETAILS = (ACMDM_BASE + 25);
 
ACMDM_FORMAT_DETAILS = (ACMDM_BASE + 26);
 
ACMDM_FORMAT_SUGGEST = (ACMDM_BASE + 27);
 
ACMDM_HARDWARE_WAVE_CAPS_INPUT = (ACMDM_BASE + 20);
 
ACMDM_HARDWARE_WAVE_CAPS_OUTPUT = (ACMDM_BASE + 21);
 
ACMDM_RESERVED_HIGH = (DRV_USER + $2FFF);
 
ACMDM_RESERVED_LOW = (DRV_USER + $2000);
 
ACMDM_STREAM_CLOSE = (ACMDM_BASE + 77);
 
ACMDM_STREAM_CONVERT = (ACMDM_BASE + 79);
 
ACMDM_STREAM_OPEN = (ACMDM_BASE + 76);
 
ACMDM_STREAM_PREPARE = (ACMDM_BASE + 81);
 
ACMDM_STREAM_RESET = (ACMDM_BASE + 80);
 
ACMDM_STREAM_SIZE = (ACMDM_BASE + 78);
 
ACMDM_STREAM_UNPREPARE = (ACMDM_BASE + 82);
 
ACMDM_USER = (DRV_USER + $0000);
 
ACMDRIVERDETAILS_COPYRIGHT_CHARS = 80;
 
ACMDRIVERDETAILS_FCCCOMP_UNDEFINED = 0;

ACMDRIVERDETAILS.fccComp

ACMDRIVERDETAILS_FCCCOMP_UNDEFINED: the FOURCC used in the fccComp field of the ACMDRIVERDETAILS structure. this is currently an unused field.

ACMDRIVERDETAILS_FEATURES_CHARS = 512;
 
ACMDRIVERDETAILS_LICENSING_CHARS = 128;
 
ACMDRIVERDETAILS_LONGNAME_CHARS = 128;
 
ACMDRIVERDETAILS_SHORTNAME_CHARS = 32;

ACMDRIVERDETAILS

the ACMDRIVERDETAILS structure is used to get various capabilities from an ACM driver (codec, converter, filter).

ACMDRIVERDETAILS_SUPPORTF_ASYNC = $00000010;

ACMDRIVERDETAILS_SUPPORTF_ASYNC: this flag is set if the driver supports async conversions.

ACMDRIVERDETAILS_SUPPORTF_CODEC = $00000001;

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.

ACMDRIVERDETAILS_SUPPORTF_CONVERTER = $00000002;

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).

ACMDRIVERDETAILS_SUPPORTF_DISABLED = $80000000;

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.

ACMDRIVERDETAILS_SUPPORTF_FILTER = $00000004;

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.

ACMDRIVERDETAILS_SUPPORTF_HARDWARE = $00000008;

ACMDRIVERDETAILS_SUPPORTF_HARDWARE: this flag is set if the driver supports hardware input and/or output through a waveform device.

ACMDRIVERDETAILS_SUPPORTF_LOCAL = $40000000;

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.

ACMERR_BASE = 512;

ACM Error Codes

Note that these error codes are specific errors that apply to the ACM directly–general errors are defined as MMSYSERR_*.

ACMERR_BUSY = ACMERR_BASE + 1;
 
ACMERR_CANCELED = ACMERR_BASE + 3;
 
ACMERR_NOTPOSSIBLE = ACMERR_BASE + 0;
 
ACMERR_UNPREPARED = ACMERR_BASE + 2;
 
ACMFILTERCHOOSE_STYLEF_CONTEXTHELP = $00000080;
 
ACMFILTERCHOOSE_STYLEF_ENABLEHOOK = $00000008;
 
ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE = $00000010;
 
ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = $00000020;
 
ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT = $00000040;
 
ACMFILTERCHOOSE_STYLEF_SHOWHELP = $00000004;

ACMFILTERCHOOSE.fdwStyle

ACMFILTERDETAILS_FILTER_CHARS = 128;

————————————————————————–;

ACM Filters

ACMFILTERTAGDETAILS_FILTERTAG_CHARS = 48;

————————————————————————–;

ACM Filter Tags

ACMFORMATCHOOSE_STYLEF_CONTEXTHELP = $00000080;
 
ACMFORMATCHOOSE_STYLEF_ENABLEHOOK = $00000008;
 
ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE = $00000010;
 
ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = $00000020;
 
ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT = $00000040;
 
ACMFORMATCHOOSE_STYLEF_SHOWHELP = $00000004;
 
ACMFORMATDETAILS_FORMAT_CHARS = 128;

————————————————————————–;

ACM Formats

ACMFORMATTAGDETAILS_FORMATTAG_CHARS = 48;

————————————————————————–

ACM Format Tags

ACMHELPMSGCONTEXTHELP = ACMHELPMSGCONTEXTHELPA;
 
ACMHELPMSGCONTEXTHELPA = 'acmchoose_contexthelp';
 
ACMHELPMSGCONTEXTHELPW = 'acmchoose_contexthelp';
 
ACMHELPMSGCONTEXTMENU = ACMHELPMSGCONTEXTMENUA;
 
ACMHELPMSGCONTEXTMENUA = 'acmchoose_contextmenu';
 
ACMHELPMSGCONTEXTMENUW = 'acmchoose_contextmenu';
 
ACMHELPMSGSTRING = ACMHELPMSGSTRINGA;
 
ACMHELPMSGSTRINGA = 'acmchoose_help';
 
ACMHELPMSGSTRINGW = 'acmchoose_help';
 
ACMSTREAMHEADER_STATUSF_DONE = $00010000;

driver reserved work space ACMSTREAMHEADER.fdwStatus

ACMSTREAMHEADER_STATUSF_DONE: done bit for async conversions.

ACMSTREAMHEADER_STATUSF_INQUEUE = $00100000;
 
ACMSTREAMHEADER_STATUSF_PREPARED = $00020000;
 
ACM_DRIVERADDF_FUNCTION = $00000003;
 
ACM_DRIVERADDF_GLOBAL = $00000008;

is local to current task

ACM_DRIVERADDF_LOCAL = $00000000;

driver type mask

ACM_DRIVERADDF_NOTIFYHWND = $00000004;

lParam is a procedure

ACM_DRIVERADDF_TYPEMASK = $00000007;

lParam is notify hwnd

ACM_DRIVERENUMF_DISABLED = $80000000;
 
ACM_DRIVERENUMF_NOLOCAL = $40000000;
 
ACM_DRIVERPRIORITYF_ABLEMASK = $00000003;
 
ACM_DRIVERPRIORITYF_BEGIN = $00010000;
 
ACM_DRIVERPRIORITYF_DEFERMASK = $00030000;
 
ACM_DRIVERPRIORITYF_DISABLE = $00000002;
 
ACM_DRIVERPRIORITYF_ENABLE = $00000001;
 
ACM_DRIVERPRIORITYF_END = $00020000;
 
ACM_FILTERDETAILSF_FILTER = $00000001;
 
ACM_FILTERDETAILSF_INDEX = $00000000;
 
ACM_FILTERDETAILSF_QUERYMASK = $0000000F;
 
ACM_FILTERENUMF_DWFILTERTAG = $00010000;
 
ACM_FILTERTAGDETAILSF_FILTERTAG = $00000001;
 
ACM_FILTERTAGDETAILSF_INDEX = $00000000;
 
ACM_FILTERTAGDETAILSF_LARGESTSIZE = $00000002;
 
ACM_FILTERTAGDETAILSF_QUERYMASK = $0000000F;
 
ACM_FORMATDETAILSF_FORMAT = $00000001;
 
ACM_FORMATDETAILSF_INDEX = $00000000;
 
ACM_FORMATDETAILSF_QUERYMASK = $0000000F;
 
ACM_FORMATENUMF_CONVERT = $00100000;
 
ACM_FORMATENUMF_HARDWARE = $00400000;
 
ACM_FORMATENUMF_INPUT = $00800000;
 
ACM_FORMATENUMF_NCHANNELS = $00020000;
 
ACM_FORMATENUMF_NSAMPLESPERSEC = $00040000;
 
ACM_FORMATENUMF_OUTPUT = $01000000;
 
ACM_FORMATENUMF_SUGGEST = $00200000;
 
ACM_FORMATENUMF_WBITSPERSAMPLE = $00080000;
 
ACM_FORMATENUMF_WFORMATTAG = $00010000;
 
ACM_FORMATSUGGESTF_NCHANNELS = $00020000;
 
ACM_FORMATSUGGESTF_NSAMPLESPERSEC = $00040000;
 
ACM_FORMATSUGGESTF_TYPEMASK = $00FF0000;
 
ACM_FORMATSUGGESTF_WBITSPERSAMPLE = $00080000;
 
ACM_FORMATSUGGESTF_WFORMATTAG = $00010000;
 
ACM_FORMATTAGDETAILSF_FORMATTAG = $00000001;
 
ACM_FORMATTAGDETAILSF_INDEX = $00000000;
 
ACM_FORMATTAGDETAILSF_LARGESTSIZE = $00000002;
 
ACM_FORMATTAGDETAILSF_QUERYMASK = $0000000F;
 
ACM_METRIC_COUNT_CODECS = 2;
 
ACM_METRIC_COUNT_CONVERTERS = 3;
 
ACM_METRIC_COUNT_DISABLED = 5;
 
ACM_METRIC_COUNT_DRIVERS = 1;
 
ACM_METRIC_COUNT_FILTERS = 4;
 
ACM_METRIC_COUNT_HARDWARE = 6;
 
ACM_METRIC_COUNT_LOCAL_CODECS = 21;
 
ACM_METRIC_COUNT_LOCAL_CONVERTERS = 22;
 
ACM_METRIC_COUNT_LOCAL_DISABLED = 24;
 
ACM_METRIC_COUNT_LOCAL_DRIVERS = 20;
 
ACM_METRIC_COUNT_LOCAL_FILTERS = 23;
 
ACM_METRIC_DRIVER_PRIORITY = 101;
 
ACM_METRIC_DRIVER_SUPPORT = 100;
 
ACM_METRIC_HARDWARE_WAVE_INPUT = 30;
 
ACM_METRIC_HARDWARE_WAVE_OUTPUT = 31;
 
ACM_METRIC_MAX_SIZE_FILTER = 51;
 
ACM_METRIC_MAX_SIZE_FORMAT = 50;
 
ACM_STREAMCONVERTF_BLOCKALIGN = $00000004;
 
ACM_STREAMCONVERTF_END = $00000020;
 
ACM_STREAMCONVERTF_START = $00000010;
 
ACM_STREAMOPENF_ASYNC = $00000002;
 
ACM_STREAMOPENF_NONREALTIME = $00000004;
 
ACM_STREAMOPENF_QUERY = $00000001;
 
ACM_STREAMSIZEF_DESTINATION = $00000001;
 
ACM_STREAMSIZEF_QUERYMASK = $0000000F;
 
ACM_STREAMSIZEF_SOURCE = $00000000;
 
DRVM_MAPPER_STATUS = $2000;
 
DRV_MAPPER_PREFERRED_INPUT_GET = (DRV_USER + 0);

Reserved for system use

DRV_MAPPER_PREFERRED_OUTPUT_GET = (DRV_USER + 2);
 
FILTERCHOOSE_CUSTOM_VERIFY = (FILTERCHOOSE_MESSAGE+2);
 
FILTERCHOOSE_FILTERTAG_VERIFY = (FILTERCHOOSE_MESSAGE+0);
 
FILTERCHOOSE_FILTER_VERIFY = (FILTERCHOOSE_MESSAGE+1);
 
FILTERCHOOSE_MESSAGE = 0;
 
FORMATCHOOSE_CUSTOM_VERIFY = (FORMATCHOOSE_MESSAGE + 2);
 
FORMATCHOOSE_FORMATTAG_VERIFY = (FORMATCHOOSE_MESSAGE + 0);
 
FORMATCHOOSE_FORMAT_VERIFY = (FORMATCHOOSE_MESSAGE + 1);
 
FORMATCHOOSE_MESSAGE = 0;
 
KSAUDIO_SPEAKER_5POINT1 = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT;
 
KSAUDIO_SPEAKER_5POINT1_BACK = KSAUDIO_SPEAKER_5POINT1;

The following are obsolete 5.1 and 7.1 settings (they lack side speakers). Note this means that the default 5.1 and 7.1 settings (KSAUDIO_SPEAKER_5POINT1 and KSAUDIO_SPEAKER_7POINT1 are similarly obsolete but are unchanged for compatibility reasons).

KSAUDIO_SPEAKER_5POINT1_SURROUND = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or SPEAKER_SIDE_LEFT or SPEAKER_SIDE_RIGHT;
 
KSAUDIO_SPEAKER_7POINT1 = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT or SPEAKER_FRONT_LEFT_OF_CENTER or SPEAKER_FRONT_RIGHT_OF_CENTER;
 
KSAUDIO_SPEAKER_7POINT1_SURROUND = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT or SPEAKER_SIDE_LEFT or SPEAKER_SIDE_RIGHT;
 
KSAUDIO_SPEAKER_7POINT1_WIDE = KSAUDIO_SPEAKER_7POINT1;
 
KSAUDIO_SPEAKER_DIRECTOUT = 0;

DVD Speaker Positions

DirectSound Speaker Config

KSAUDIO_SPEAKER_GROUND_FRONT_CENTER = SPEAKER_FRONT_CENTER;
 
KSAUDIO_SPEAKER_GROUND_FRONT_LEFT = SPEAKER_FRONT_LEFT;

DVD Speaker Positions

KSAUDIO_SPEAKER_GROUND_FRONT_RIGHT = SPEAKER_FRONT_RIGHT;
 
KSAUDIO_SPEAKER_GROUND_REAR_LEFT = SPEAKER_BACK_LEFT;
 
KSAUDIO_SPEAKER_GROUND_REAR_RIGHT = SPEAKER_BACK_RIGHT;
 
KSAUDIO_SPEAKER_MONO = SPEAKER_FRONT_CENTER;
 
KSAUDIO_SPEAKER_QUAD = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT;
 
KSAUDIO_SPEAKER_STEREO = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT;
 
KSAUDIO_SPEAKER_SUPER_WOOFER = SPEAKER_LOW_FREQUENCY;
 
KSAUDIO_SPEAKER_SURROUND = SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or SPEAKER_FRONT_CENTER or SPEAKER_BACK_CENTER;
 
KSAUDIO_SPEAKER_TOP_MIDDLE = SPEAKER_TOP_CENTER;
 
KSDATAFORMAT_SUBTYPE_ADPCM : tGuid = '{00000002-0000-0010-8000-00aa00389b71}';
 
KSDATAFORMAT_SUBTYPE_ALAW : tGuid = '{00000006-0000-0010-8000-00aa00389b71}';
 
KSDATAFORMAT_SUBTYPE_ANALOG : tGuid = '{6dba3190-67bd-11cf-a0f7-0020afd156e4}';

format guids

KSDATAFORMAT_SUBTYPE_DRM : tGuid = '{00000009-0000-0010-8000-00aa00389b71}';
 
KSDATAFORMAT_SUBTYPE_IEEE_FLOAT: tGuid = '{00000003-0000-0010-8000-00aa00389b71}';
 
KSDATAFORMAT_SUBTYPE_MPEG : tGuid = '{00000050-0000-0010-8000-00aa00389b71}';
 
KSDATAFORMAT_SUBTYPE_MULAW : tGuid = '{00000007-0000-0010-8000-00aa00389b71}';
 
KSDATAFORMAT_SUBTYPE_PCM : tGuid = '{00000001-0000-0010-8000-00aa00389b71}';
 
MEDIASUBTYPE_AIFF : tGuid = '{e436eb8d-524f-11ce-9f53-0020af0ba770}';

MEDIASUBTYPE_AIFF

MEDIASUBTYPE_AU : tGuid = '{e436eb8c-524f-11ce-9f53-0020af0ba770}';

MEDIASUBTYPE_AU

MEDIASUBTYPE_DOLBY_AC3_SPDIF : tGuid = '{00000092-0000-0010-8000-00aa00389b71}';

derived from WAVE_FORMAT_DOLBY_AC3_SPDIF

MEDIASUBTYPE_DRM_Audio : tGuid = '{00000009-0000-0010-8000-00aa00389b71}';

derived from WAVE_FORMAT_DRM

MEDIASUBTYPE_IEEE_FLOAT : tGuid = '{00000003-0000-0010-8000-00aa00389b71}';

derived from WAVE_FORMAT_IEEE_FLOAT

MEDIASUBTYPE_PCM : tGuid = '{00000001-0000-0010-8000-00AA00389B71}';

MEDIASUBTYPE_PCM

MEDIASUBTYPE_RAW_SPORT : tGuid = '{00000240-0000-0010-8000-00aa00389b71}';

derived from WAVE_FORMAT_RAW_SPORT

MEDIASUBTYPE_SPDIF_TAG_241h : tGuid = '{00000241-0000-0010-8000-00aa00389b71}';

derived from wave format tag 0x241, call it SPDIF_TAG_241h for now

MEDIASUBTYPE_WAVE : tGuid = '{e436eb8b-524f-11ce-9f53-0020af0ba770}';

MEDIASUBTYPE_WAVE

MM_3COM = 260;

/* ICCC A/S */

MM_AARDVARK = 11 ;

/* BeCubed Software Inc. */

MM_ACM_CLOSE = MM_STREAM_CLOSE;

conversion callback messages

MM_ACM_DONE = MM_STREAM_DONE;
 
MM_ACM_FILTERCHOOSE = ($8000);

MM_ACM_FILTERCHOOSE is sent to hook callbacks by the Filter Chooser Dialog...

MM_ACM_FORMATCHOOSE = ($8000);
 
MM_ACM_OPEN = MM_STREAM_OPEN;

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.

MM_ACTIVEVOICE = 225;

/* Luminositi, Inc. */

MM_ACULAB = 14 ;

/* Hewlett-Packard Company */

MM_ADDX = 118;

/* Grande Software */

MM_ADLACC = 91 ;

/* OPTi Computers Inc. */

MM_ADMOS = 235;

/* Selsius Systems Inc. */

MM_AHEAD = 77 ;

/* Speech Compression */

MM_ALARIS = 174;

/* Quicknet Technologies */

MM_ALDIGITAL = 143;

/* SounDesignS M.C.S. Ltd. */

MM_ALESIS = 243;

/* Consistent Software */

MM_AMD = 146;

/* Electronic Courseware Systems, Inc. */

MM_ANALOGDEVICES = 252;

/* Micronas Semiconductors, Inc. */

MM_ANTEX = 31 ;

/* Voyetra */

MM_APICOM = 116;

/* Northern Telecom Limited */

MM_APPLE = 99 ;

/* Quanta Computer Inc. */

MM_APPS = 42 ;

/* Computer Aided Technologies */

MM_APT = 56 ;

/* Korg Inc. */

MM_ARRAY = 231;

/* Sonorus, Inc. */

MM_ARTISOFT = 20 ;

/* E-mu Systems, Inc. */

MM_AST = 64 ;

/* EXAN */

MM_ATI = 27 ;

/* NEC */

MM_ATT = 185;

/* Lucent Technologies */

MM_ATT_MICROELECTRONICS = 139;

/* PictureTel Corporation */

MM_AUDIOFILE = 47 ;

/* ESS Technology */

MM_AUDIOPT = 74 ;

/* Supermac */

MM_AUDIOSCIENCE = 217;

/* Ring Zero Systems, Inc */

MM_AURAVISION = 80 ;

/* OKI */

MM_AUREAL = 181;

/* Oak Technology, Inc. */

MM_AZTECH = 52 ;

/* Truevision */

MM_BCB = 192;

/* Digital Processing Systems, Inc. */

MM_BECUBED = 10 ;

/* ZyXEL Communications, Inc. */

MM_BERCOS = 199;

/* Future Technology Resources Pty Ltd */

MM_BERKOM = 189;

/* InVision Interactive */

MM_BINTEC = 12 ;

/* Aardvark Computer Systems, Inc. */

MM_BROOKTREE = 121;

/* Rhetorex Inc. */

MM_CANAM = 148;

/* Core Dynamics */

MM_CANOPUS = 49 ;

/* Motorola, Inc. */

MM_CASIO = 162;

/* Viona Development GmbH */

MM_CAT = 41 ;

/* Sierra Semiconductor Corp */

MM_CHROMATIC = 155;

/* Crystal Net Corporation */

MM_CIRRUSLOGIC = 105;

/* miro Computer Products AG */

MM_COLORGRAPH = 179;

/* Xirlink, Inc. */

MM_COMPAQ = 92 ;

/* Adlib Accessories Inc. */

MM_COMPUSIC = 89 ;

/* Lyrrus Inc. */

MM_COMPUTER_FRIENDS = 45 ;

/* microEngineering Labs */

MM_CONCEPTS = 108;

/* Horizons Technology, Inc. */

MM_CONNECTIX = 158;

/* Vienna Systems */

MM_CONTROLRES = 84 ;

/* Matsushita Electric Industrial Co., Ltd. */

MM_COREDYNAMICS = 147;

/* AMD */

MM_CREATIVE = 2 ;

/* Microsoft Corporation */

MM_CRYSTAL = 132;

/* Kay Elemetrics, Inc. */

MM_CRYSTAL_NET = 154;

/* Precept Software, Inc. */

MM_CS = 242;

/* eTEK Labs Inc. */

MM_CYRIX = 6 ;

/* PRAGMATRAX Software */

MM_DATAFUSION = 196;

/* Nokia Mobile Phones */

MM_DATARAN = 232;

/* Array Microsystems, Inc. */

MM_DDD = 151;

/* Norris Communications, Inc. */

MM_DIACOUSTICS = 129;

/* OKSORI Co., Ltd. */

MM_DIALOGIC = 93 ;

/* Compaq Computer Corp. */

MM_DIAMONDMM = 163;

/* Casio Computer Co., LTD */

MM_DICTAPHONE = 214;

/* Spectrum Productions */

MM_DIGIGRAM = 227;

/* Digital Theater Systems, Inc. */

MM_DIGITAL = 100;

/* Apple Computer, Inc. */

MM_DIGITAL_AUDIO_LABS = 136;

/* TDK Corporation */

MM_DOLBY = 78 ;

/* Ahead, Inc. */

MM_DPSINC = 191;

/* Marian GbR Leipzig */

MM_DSP_GROUP = 43 ;

/* APPS Software International */

MM_DSP_SOLUTIONS = 25 ;

/* Roland */

MM_DTS = 226;

/* ACTIVE VOICE CORPORATION */

MM_DUCK = 197;

/* DataFusion Systems (Pty) (Ltd) */

MM_DVISION = 165;

/* S3 */

MM_ECHO = 39 ;

/* Everex Systems, Inc. */

MM_ECS = 145;

/* Spectrum Signal Processing, Inc. */

MM_EES = 219;

/* Pinnacle Systems, Inc. */

MM_EMAGIC = 208;

/* Guillemot International */

MM_EMU = 19 ;

/* Siemens-Nixdorf */

MM_ENET = 206;

/* Virtual Music, Inc. */

MM_ENSONIQ = 125;

/* Brooktree Corporation */

MM_EPSON = 50 ;

/* Canopus, co., Ltd. */

MM_ESS = 46 ;

/* Computer Friends, Inc. */

MM_ETEK = 241;

/* ViewQuest Technologies Inc. */

MM_EUPHONICS = 152;

/* Danka Data Devices */

MM_EVEREX = 38 ;

/* Yamaha Corporation of America */

MM_EXAN = 63 ;

/* NCR Corporation */

MM_FAITH = 15 ;

/* Aculab plc */

MM_FAST = 126;

/* ENSONIQ Corporation */

MM_FLEXION = 249;

/* Sydec NV */

MM_FORTEMEDIA = 229;

/* Softlab-Nsk */

MM_FRAUNHOFER_IIS = 172;

/* Studer Professional Audio AG */

MM_FRONTIER = 160;

/* Gadget Labs LLC */

MM_FTR = 198;

/* The Duck Corporation */

MM_FUJITSU = 4 ;

/* Media Vision, Inc. */

MM_GADGETLABS = 159;

/* Connectix Corporation */

MM_GRANDE = 117;

/* APICOM */

MM_GRAVIS = 34 ;

/* Intel Corporation */

MM_GUILLEMOT = 207;

/* e-Net, Inc. */

MM_GULBRANSEN = 130;

/* DiAcoustics, Inc. */

MM_HAFTMANN = 220;

/* EES Technik fur Musik GmbH */

MM_HEADSPACE = 222;

/* Lucid Technology, Symetrix Inc. */

MM_HEWLETT_PACKARD = 13 ;

/* Bin Tec Communications GmbH */

MM_HORIZONS = 107;

/* ISOLUTION B.V. */

MM_HP = 253;

/* Analog Devices, Inc. */

MM_HYPERACTIVE = 246;

/* Sony Corporation */

MM_IBM = 22 ;

/* Turtle Beach, Inc. */

MM_ICCC = 259;

/* I-O Data Device, Inc. */

MM_ICE = 239;

/* Interactive Product Inc. */

MM_ICL_PS = 32 ;

/* Antex Electronics Corporation */

MM_ICS = 57 ;

/* Audio Processing Technology */

MM_INSOFT = 94 ;

/* Dialogic Corporation */

MM_INTEL = 33 ;

/* ICL Personal Systems */

MM_INTERACTIVE = 36 ;

/* Video Associates Labs, Inc. */

MM_INTERNET = 244;

/* Alesis Studio Electronics */

MM_INVISION = 188;

/* Sorenson Vision */

MM_IODD = 258;

/* Richmond Sound Design Ltd. */

MM_IOMAGIC = 82 ;

/* Ing C. Olivetti & C., S.p.A. */

MM_IPI = 238;

/* Silicon Graphics Inc. */

MM_ISOLUTION = 106;

/* Cirrus Logic */

MM_ITERATEDSYS = 58 ;

/* Integrated Circuit Systems, Inc. */

MM_I_LINK = 233;

/* Data Translation, Inc. */

MM_KAY_ELEMETRICS = 131;

/* Gulbransen, Inc. */

MM_KORG = 55 ;

/* SCALACS */

MM_LERNOUT_AND_HAUSPIE = 97 ;

/* Weitek */

MM_LEXICON = 236;

/* AdMOS Technology, Inc. */

MM_LOGITECH = 60 ;

/* Metheus */

MM_LUCENT = 184;

/* Sharp */

MM_LUCID = 221;

/* haftmann#software */

MM_LUMINOSITI = 224;

/* UNISYS CORPORATION */

MM_LYNX = 212;

/* Sipro Lab Telecom Inc. */

MM_LYRRUS = 88 ;

/* Natural MicroSystems */

MM_MALDEN = 261;

/* 3COM Corporation */

MM_MARIAN = 190;

/* Deutsche Telekom Berkom GmbH */

MM_MATROX_DIV = 254;

/* Hewlett Packard Company */

MM_MATSUSHITA = 83 ;

/* I/O Magic Corporation */

MM_MEDIASONIC = 71 ;

/* TerraTec Electronic GmbH */

MM_MEDIATRIX = 141;

/* Osprey Technologies, Inc. */

MM_MEDIAVISION = 3 ;

/* Creative Labs, Inc. */

MM_MELABS = 44 ;

/* DSP Group, Inc. */

MM_MERGING_TECHNOLOGIES = 177;

/* NeoMagic Corporation */

MM_METHEUS = 59 ;

/* Iterated Systems, Inc. */

MM_MICRONAS = 251;

/* Via Technologies, Inc. */

MM_MICROSOFT = 1 ;

back to MMREG.H

MM_MIRO = 104;

/* Ositech Communications Inc. */

MM_MITEL = 16 ;

/* Faith,Inc. */

MM_MOSCOM = 68 ;

/* Vitec Multimedia */

MM_MOTIONPIXELS = 193;

/* BCB Holdings Inc. */

MM_MOTOROLA = 48 ;

/* Audio, Inc. */

MM_MOTU = 101;

/* Digital Equipment Corporation */

MM_MPTUS = 95 ;

/* InSoft, Inc. */

MM_MSFT_ACM_G711 = 37;

GSM 610 codec */

MM_MSFT_ACM_GSM610 = 36;

MS Filter */

MM_MSFT_ACM_IMAADPCM = 34;

MS ADPCM Codec */

MM_MSFT_ACM_MSADPCM = 33;

MS Audio Compression Manager */

MM_MSFT_ACM_MSFILTER = 35;

IMA ADPCM Codec */

MM_MSFT_ACM_PCM = 38;

G.711 codec */

MM_MSFT_GENERIC_AUX_CD = 30;

MS Vanilla driver aux (mic) */

MM_MSFT_GENERIC_AUX_LINE = 28;

MS Vanilla driver MIDI synthesizer */

MM_MSFT_GENERIC_AUX_MIC = 29;

MS Vanilla driver aux (line in) */

MM_MSFT_GENERIC_MIDIIN = 25;

MS Vanilla driver wavefrom output */

MM_MSFT_GENERIC_MIDIOUT = 26;

MS Vanilla driver MIDI in */

MM_MSFT_GENERIC_MIDISYNTH = 27;

MS Vanilla driver MIDI external out */

MM_MSFT_GENERIC_WAVEIN = 23;

MS OEM Audio Aux Port */

MM_MSFT_GENERIC_WAVEOUT = 24;

MS Vanilla driver waveform input */

MM_MSFT_MSACM = 32;

MS OEM Audio Board Mixer Driver */

MM_MSFT_WSS_AUX = 21;

MS OEM Audio Board Stereo FM Synth */

MM_MSFT_WSS_FMSYNTH_STEREO = 16;

MS Audio Board waveform output */

MM_MSFT_WSS_MIXER = 17;

MS Audio Board Stereo FM synth */

MM_MSFT_WSS_OEM_AUX = 22;

MS Audio Board Aux. Port */

MM_MSFT_WSS_OEM_FMSYNTH_STEREO = 20;

MS OEM Audio Board waveform output */

MM_MSFT_WSS_OEM_MIXER = 31;

MS Vanilla driver aux (CD) */

MM_MSFT_WSS_OEM_WAVEIN = 18;

MS Audio Board Mixer Driver */

MM_MSFT_WSS_OEM_WAVEOUT = 19;

MS OEM Audio Board waveform input */

MM_MSFT_WSS_WAVEIN = 14;

extensible PID mapping */ some of MS pids

MM_MSFT_WSS_WAVEOUT = 15;

MS Audio Board waveform input */

MM_MWM = 209;

/* Emagic Soft- und Hardware GmbH */

MM_NCR = 62 ;

/* Winnov, Inc. */

MM_NEC = 26 ;

/* DSP Solutions, Inc. */

MM_NEOMAGIC = 176;

/* SIC Resource Inc. */

MM_NETSCAPE = 166;

/* D-Vision Systems, Inc. */

MM_NETXL = 8 ;

/* Philips Speech Processing */

MM_NEWMEDIA = 86 ;

/* Xebec Multimedia Solutions Limited */

MM_NMP = 195;

/* QDesign Corporation */

MM_NMS = 87 ;

/* New Media Corporation */

MM_NOGATECH = 75 ;

/* Audio Processing Technology */

MM_NORRIS = 150;

/* Softsound, Ltd. */

MM_NORTHERN_TELECOM = 115;

/* Voxware Inc. */

MM_NVIDIA = 127;

/* FAST Multimedia AG */

MM_OKI = 79 ;

/* Dolby Laboratories */

MM_OKSORI = 128;

/* NVidia Corporation */

MM_OLIVETTI = 81 ;

/* AuraVision Corporation */

MM_ONLIVE = 200;

/* BERCOS GmbH */

MM_OPCODE = 113;

/* Co. XYZ for testing */

MM_OPTI = 90 ;

/* Compusic */

MM_OSITECH = 103;

/* Workbit Corporation */

MM_OSPREY = 140;

/* AT&T Microelectronics */

MM_OTI = 180;

/* Colorgraph (UK) Ltd */

MM_PACIFICRESEARCH = 210;

/* MWM Acoustics LLC */

MM_PHILIPS_SPEECH_PROCESSING = 7 ;

/* Cyrix Corporation */

MM_PHONET = 203;

/* TeraLogic, Inc. */

MM_PICTURETEL = 138;

/* Seer Systems, Inc. */

MM_PID_UNMAPPED = MM_UNMAPPED;

extensible MID mapping */

MM_PINNACLE = 218;

/* AudioScience Inc. */

MM_PRAGMATRAX = 5 ;

/* Fujitsu Corp. */

MM_PRECEPT = 153;

/* EuPhonics */

MM_QCIAR = 98 ;

/* Lernout & Hauspie */

MM_QDESIGN = 194;

/* Motion Pixels */

MM_QTEAM = 169;

/* VanKoevering Company */

MM_QUALCOMM = 215;

/* Dictaphone Corporation */

MM_QUANTUM3D = 17 ;

/* Mitel Corporation */

MM_QUARTERDECK = 134;

/* Splash Studios */

MM_QUICKAUDIO = 255;

/* Matrox */

MM_QUICKNET = 173;

/* Fraunhofer IIS */

MM_RADIUS = 110;

/* Voice Technologies Group, Inc. */

MM_RHETOREX = 120;

/* Wildcat Canyon Software */

MM_RICHMOND = 257;

/* You/Com Audiocommunicatie BV */

MM_ROCKWELL = 111;

/* Radius */

MM_ROLAND = 24 ;

/* Vocaltec Ltd. */

MM_RZS = 216;

/* QUALCOMM, Inc. */

MM_S3 = 164;

/* Diamond Multimedia */

MM_SANYO = 72 ;

/* MediaSonic Ltd. */

MM_SCALACS = 54 ;

/* Videologic */

MM_SEERSYS = 137;

/* Digital Audio Labs, Inc. */

MM_SELSIUS_SYSTEMS = 234;

/* I-link Worldwide */

MM_SGI = 237;

/* Lexicon Inc. */

MM_SHARP = 183;

/* Vivo Software */

MM_SICRESOURCE = 175;

/* Alaris, Inc. */

MM_SIEMENS_SBC = 201;

/* OnLive! Technologies, Inc. */

MM_SIERRA = 40 ;

/* Echo Speech Corporation */

MM_SILICONSOFT = 69 ;

/* MOSCOM Corporation */

MM_SIPROLAB = 211;

/* Pacific Research and Engineering Corporation */

MM_SNI = 18 ;

/* Quantum3D, Inc. */

MM_SOFTLAB_NSK = 228;

/* DIGIGRAM */

MM_SOFTSOUND = 149;

/* CANAM Computers */

MM_SONICFOUNDRY = 66 ;

/* Willow Pond Corporation */

MM_SONORUS = 230;

/* ForteMedia, Inc */

MM_SONY = 245;

/* INTERNET Corporation */

MM_SORVIS = 187;

/* Sun Communications, Inc. */

MM_SOUNDESIGNS = 142;

/* Mediatrix Peripherals */

MM_SOUNDSPACE = 167;

/* Netscape Communications */

MM_SPECTRUM_PRODUCTIONS = 213;

/* Lynx Studio Technology, Inc. */

MM_SPECTRUM_SIGNAL_PROCESSING = 144;

/* A.L. Digital Ltd. */

MM_SPEECHCOMP = 76 ;

/* NOGATECH Ltd. */

MM_SPLASH_STUDIOS = 133;

/* Crystal Semiconductor Corporation */

MM_STUDER = 171;

/* Zefiro Acoustics */

MM_SUNCOM = 186;

/* AT&T Labs, Inc. */

MM_SUPERMAC = 73 ;

/* SANYO Electric Co., Ltd. */

MM_SYDEC_NV = 248;

/* UHER informatic GmbH */

MM_TANDY = 29 ;

/* Wang Laboratories, Inc. */

MM_TDK = 135;

/* Quarterdeck Corporation */

MM_TERALOGIC = 202;

/* Siemens Business Communications Systems */

MM_TERRATEC = 70 ;

/* Silicon Soft, Inc. */

MM_TRUEVISION = 51 ;

/* Seiko Epson Corporation */

MM_TURTLE_BEACH = 21 ;

/* Artisoft, Inc. */

MM_UHER_INFORMATIC = 247;

/* Hyperactive Audio Systems, Inc. */

MM_UNISYS = 223;

/* Headspace, Inc */

MM_UNMAPPED = $ffff;

/* Malden Electronics Ltd. */

MM_VAL = 35 ;

/* Advanced Gravis */

MM_VANKOEVERING = 168;

/* Soundspace Audio */

MM_VIA = 250;

/* Flexion Systems Ltd. */

MM_VIDEOLOGIC = 53 ;

/* Aztech Labs, Inc. */

MM_VIENNASYS = 157;

/* Voice Information Systems, Inc. */

MM_VIONA = 161;

/* Frontier Design Group LLC */

MM_VIRTUALMUSIC = 205;

/* Winbond Electronics Corp */

MM_VITEC = 67 ;

/* Sonic Foundry */

MM_VIVO = 182;

/* Aureal Semiconductor */

MM_VOCALTEC = 23 ;

/* IBM Corporation */

MM_VOICEINFO = 156;

/* Chromatic Research, Inc. */

MM_VOXWARE = 114;

/* Opcode Systems */

MM_VOYETRA = 30 ;

/* Tandy Corporation */

MM_VQST = 240;

/* IC Ensemble, Inc. */

MM_VTG = 109;

/* Computer Concepts Ltd. */

MM_WANGLABS = 28 ;

/* ATI Technologies Inc. */

MM_WEITEK = 96 ;

/* M.P. Technologies, Inc. */

MM_WILDCAT = 119;

/* ADDX */

MM_WILLOWPOND = 65 ;

/* AST Research Inc. */

MM_WINBOND = 204;

/* PhoNet Communications Ltd. */

MM_WINNOV = 61 ;

/* Logitech, Inc. */

MM_WORKBIT = 102;

/* Mark of the Unicorn */

MM_XEBEC = 85 ;

/* Control Resources Limited */

MM_XIRLINK = 178;

/* Merging Technologies S.A. */

MM_XYZ = 112;

/* Rockwell International */

MM_YAMAHA = 37 ;

/* InterActive Inc. */

MM_YOUCOM = 256;

/* Quick Audio, GbR */

MM_ZEFIRO = 170;

/* Q-Team */

MM_ZYXEL = 9 ;

/* NetXL, Inc. */

SPEAKER_ALL = $80000000;

Used to specify that any possible permutation of speaker configurations

SPEAKER_BACK_CENTER = $100;
 
SPEAKER_BACK_LEFT = $10;
 
SPEAKER_BACK_RIGHT = $20;
 
SPEAKER_DEFAULT = $A0000000;

specific to Lake of Soft, do not use

SPEAKER_FRONT_CENTER = $4;
 
SPEAKER_FRONT_LEFT = $1;

Speaker Positions for dwChannelMask in WAVEFORMATEXTENSIBLE:

SPEAKER_FRONT_LEFT_OF_CENTER = $40;
 
SPEAKER_FRONT_RIGHT = $2;
 
SPEAKER_FRONT_RIGHT_OF_CENTER = $80;
 
SPEAKER_LOW_FREQUENCY = $8;
 
SPEAKER_RESERVED = $7FFC0000;

Bit mask locations reserved for future use

SPEAKER_SIDE_LEFT = $200;
 
SPEAKER_SIDE_RIGHT = $400;
 
SPEAKER_TOP_BACK_CENTER = $10000;
 
SPEAKER_TOP_BACK_LEFT = $8000;
 
SPEAKER_TOP_BACK_RIGHT = $20000;
 
SPEAKER_TOP_CENTER = $800;
 
SPEAKER_TOP_FRONT_CENTER = $2000;
 
SPEAKER_TOP_FRONT_LEFT = $1000;
 
SPEAKER_TOP_FRONT_RIGHT = $4000;
 
WAVEIN_MAPPER_STATUS_DEVICE = 0;
 
WAVEIN_MAPPER_STATUS_FORMAT = 2;
 
WAVEIN_MAPPER_STATUS_MAPPED = 1;
 
WAVEOUT_MAPPER_STATUS_DEVICE = 0;
 
WAVEOUT_MAPPER_STATUS_FORMAT = 2;
 
WAVEOUT_MAPPER_STATUS_MAPPED = 1;
 
WAVE_FILTER_DEVELOPMENT = $FFFF;
 
WAVE_FILTER_UNKNOWN = $0000;

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

WAVE_FORMAT_ADPCM = $00002;

Microsoft Corporation */

WAVE_FORMAT_ALAW = $00006;

IBM Corporation */

WAVE_FORMAT_ANTEX_ADPCME = $00033;

Microsoft Corporation */

WAVE_FORMAT_APTX = $00025;

Virtual Music, Inc. */

WAVE_FORMAT_AUDIOFILE_AF10 = $00026;

Audio Processing Technology */

WAVE_FORMAT_AUDIOFILE_AF36 = $00024;

Echo Speech Corporation */

WAVE_FORMAT_BTV_DIGITAL = $00400;

Fujitsu Corp. */

WAVE_FORMAT_CANOPUS_ATRAC = $00063;

Voxware Inc */

WAVE_FORMAT_CIRRUS = $00060;

Lucent Technologies */

WAVE_FORMAT_CONTROL_RES_CR10 = $00037;

DSP Solutions, Inc. */

WAVE_FORMAT_CONTROL_RES_VQLPC = $00034;

Antex Electronics Corporation */

WAVE_FORMAT_CREATIVE_ADPCM = $00200;

Microsoft Corporation */

WAVE_FORMAT_CREATIVE_FASTSPEECH10 = $00203;

Creative Labs, Inc */

WAVE_FORMAT_CREATIVE_FASTSPEECH8 = $00202;

Creative Labs, Inc */

WAVE_FORMAT_CS2 = $00260;

Interactive Products, Inc. */

WAVE_FORMAT_CS_IMAADPCM = $00039;

Natural MicroSystems */

WAVE_FORMAT_CU_CODEC = $00019;

Media Vision, Inc. */

WAVE_FORMAT_DEVELOPMENT = $0FFFF;

Microsoft */

New wave format development should be based on the WAVEFORMATEXTENSIBLE structure. WAVEFORMATEXTENSIBLE allows you to avoid having to register a new format tag with Microsoft. However, if you must still define a new format tag, the WAVE_FORMAT_DEVELOPMENT format tag can be used during the development phase of a new wave format. Before shipping, you MUST acquire an official format tag from Microsoft.

WAVE_FORMAT_DF_G726 = $00085;

Motion Pixels */

WAVE_FORMAT_DF_GSM610 = $00086;

DataFusion Systems (Pty) (Ltd) */

WAVE_FORMAT_DIALOGIC_OKI_ADPCM = $00017;

DSP Solutions, Inc. */

WAVE_FORMAT_DIGIADPCM = $00036;

DSP Solutions, Inc. */

WAVE_FORMAT_DIGIFIX = $00016;

DSP Solutions, Inc. */

WAVE_FORMAT_DIGIREAL = $00035;

Control Resources Limited */

WAVE_FORMAT_DIGISTD = $00015;

Antex Electronics Corporation */

WAVE_FORMAT_DIGITAL_G723 = $00123;

Vivo Software */

WAVE_FORMAT_DIRECT = $0008;
 
WAVE_FORMAT_DOLBY_AC2 = $00030;

Merging Technologies S.A. */

WAVE_FORMAT_DOLBY_AC3_SPDIF = $00092;

Siemens Business Communications Sys */

WAVE_FORMAT_DSAT_DISPLAY = $00067;

APICOM */

WAVE_FORMAT_DSPGROUP_TRUESPEECH = $00022;

Speech Compression */

WAVE_FORMAT_DTS = $00008;

Microsoft Corporation */

WAVE_FORMAT_DVI_ADPCM = $00011;

OKI */

WAVE_FORMAT_DVM = $02000;

AT&T Labs, Inc. */

WAVE_FORMAT_ECHOSC1 = $00023;

DSP Group, Inc */

WAVE_FORMAT_ECHOSC3 = $0003A;

Crystal Semiconductor IMA ADPCM */

WAVE_FORMAT_ESPCM = $00061;

Cirrus Logic */

WAVE_FORMAT_EXTENSIBLE = $0FFFE;

FAST Multimedia AG */

WAVE_FORMAT_FM_TOWNS_SND = $00300;

Sony Corp. */

WAVE_FORMAT_G721_ADPCM = $00040;

Xebec Multimedia Solutions Limited */

WAVE_FORMAT_G722_ADPCM = $00065;

APICOM */

WAVE_FORMAT_G723_ADPCM = $00014;

Sierra Semiconductor Corp */

WAVE_FORMAT_G726ADPCM = $00140;

Sipro Lab Telecom Inc. */

WAVE_FORMAT_G726_ADPCM = $00064;

Canopus, co., Ltd. */

WAVE_FORMAT_G728_CELP = $00041;

Antex Electronics Corporation */

WAVE_FORMAT_G729A = $00083;

Microsoft Corporation */

WAVE_FORMAT_GSM610 = $00031;

Dolby Laboratories */

WAVE_FORMAT_IBM_CVSD = $00005;

Compaq Computer Corp. */

WAVE_FORMAT_IEEE_FLOAT = $00003;

Microsoft Corporation */

WAVE_FORMAT_ILINK_VC = $00230;

Quarterdeck Corporation */

WAVE_FORMAT_IMA_ADPCM = WAVE_FORMAT_DVI_ADPCM;

Intel Corporation */

WAVE_FORMAT_IPI_HSX = $00250;

Aureal Semiconductor */

WAVE_FORMAT_IPI_RPELP = $00251;

Interactive Products, Inc. */

WAVE_FORMAT_IRAT = $00101;

Rhetorex Inc. */

WAVE_FORMAT_ISIAUDIO = $00088;

DataFusion Systems (Pty) (Ltd) */

WAVE_FORMAT_LH_CODEC = $01100;

Ing C. Olivetti & C., S.p.A. */

WAVE_FORMAT_LRC = $00028;

Aculab plc */

WAVE_FORMAT_LUCENT_G723 = $00059;

ISO/MPEG Layer3 Format Tag */

WAVE_FORMAT_MALDEN_PHONYTALK = $000A0;

Studer Professional Audio AG */

WAVE_FORMAT_MEDIASONIC_G723 = $00093;

Sonic Foundry */

WAVE_FORMAT_MEDIASPACE_ADPCM = $00012;

Intel Corporation */

WAVE_FORMAT_MEDIAVISION_ADPCM = $00018;

Dialogic Corporation */

WAVE_FORMAT_MPEG = $00050;

Microsoft Corporation */

WAVE_FORMAT_MPEGLAYER3 = $00055;

InSoft, Inc. */

WAVE_FORMAT_MSAUDIO1 = $00160;

Ring Zero Systems, Inc. */

WAVE_FORMAT_MSG723 = $00042;

Antex Electronics Corporation */

WAVE_FORMAT_MSNAUDIO = $00032;

Microsoft Corporation */

WAVE_FORMAT_MSRT24 = $00082;

Voxware Inc */

WAVE_FORMAT_MULAW = $00007;

Microsoft Corporation */

WAVE_FORMAT_MVI_MVI2 = $00084;

AT&T Labs, Inc. */

WAVE_FORMAT_NMS_VBXADPCM = $00038;

Control Resources Limited */

WAVE_FORMAT_NORRIS = $01400;

Lernout & Hauspie */

WAVE_FORMAT_OKI_ADPCM = $00010;

Microsoft Corporation */

WAVE_FORMAT_OLIADPCM = $01001;

Ing C. Olivetti & C., S.p.A. */

WAVE_FORMAT_OLICELP = $01002;

Ing C. Olivetti & C., S.p.A. */

WAVE_FORMAT_OLIGSM = $01000;

AT&T Labs, Inc. */

WAVE_FORMAT_OLIOPR = $01004;

Ing C. Olivetti & C., S.p.A. */

WAVE_FORMAT_OLISBC = $01003;

Ing C. Olivetti & C., S.p.A. */

WAVE_FORMAT_ONLIVE = $00089;

Iterated Systems, Inc. */

WAVE_FORMAT_PAC = $00053;

InSoft, Inc. */

WAVE_FORMAT_PACKED = $00099;

Philips Speech Processing */

WAVE_FORMAT_PHILIPS_LPCBB = $00098;

ZyXEL Communications, Inc. */

WAVE_FORMAT_PROSODY_1612 = $00027;

Virtual Music, Inc. */

WAVE_FORMAT_PROSODY_8KBPS = $00094;

MediaSonic */

WAVE_FORMAT_QDESIGN_MUSIC = $00450;

Brooktree Corporation */

WAVE_FORMAT_QUALCOMM_HALFRATE = $00151;

Qualcomm, Inc. */

WAVE_FORMAT_QUALCOMM_PUREVOICE = $00150;

Dictaphone Corporation */

WAVE_FORMAT_QUARTERDECK = $00220;

UHER informatic GmbH */

WAVE_FORMAT_RAW_SPORT = $00240;

I-link Worldwide */

WAVE_FORMAT_RHETOREX_ADPCM = $00100;

Malden Electronics Ltd. */

WAVE_FORMAT_ROCKWELL_ADPCM = $0003B;

Echo Speech Corporation */

WAVE_FORMAT_ROCKWELL_DIGITALK = $0003C;

Rockwell International */

WAVE_FORMAT_RT24 = $00052;

Microsoft Corporation */

WAVE_FORMAT_SANYO_LD_ADPCM = $00125;

Digital Equipment Corporation */

WAVE_FORMAT_SBC24 = $00091;

OnLive! Technologies, Inc. */

WAVE_FORMAT_SIERRA_ADPCM = $00013;

Videologic */

WAVE_FORMAT_SIPROLAB_ACELP4800 = $00131;

Sipro Lab Telecom Inc. */

WAVE_FORMAT_SIPROLAB_ACELP8V3 = $00132;

Sipro Lab Telecom Inc. */

WAVE_FORMAT_SIPROLAB_ACEPLNET = $00130;

Sanyo Electric Co., Ltd. */

WAVE_FORMAT_SIPROLAB_G729 = $00133;

Sipro Lab Telecom Inc. */

WAVE_FORMAT_SIPROLAB_G729A = $00134;

Sipro Lab Telecom Inc. */

WAVE_FORMAT_SIPROLAB_KELVIN = $00135;

Sipro Lab Telecom Inc. */

WAVE_FORMAT_SOFTSOUND = $00080;

Voxware Inc */

WAVE_FORMAT_SONARC = $00021;

Yamaha Corporation of America */

WAVE_FORMAT_SONY_SCX = $00270;

Consistent Software */

WAVE_FORMAT_SOUNDSPACE_MUSICOMPRESS = $01500;

Norris Communications, Inc. */

WAVE_FORMAT_TPC = $00681;

AT&T Labs, Inc. */

WAVE_FORMAT_TUBGSM = $00155;

Qualcomm, Inc. */

WAVE_FORMAT_UHER_ADPCM = $00210;

Creative Labs, Inc */

WAVE_FORMAT_UNKNOWN = $00000;

PCM converter */ WAVE form wFormatTag IDs */

WAVE_FORMAT_VIVO_G723 = $00111;

BeCubed Software Inc. */

WAVE_FORMAT_VIVO_SIREN = $00112;

Vivo Software */

WAVE_FORMAT_VME_VMPCM = $00680;

QDesign Corporation */

WAVE_FORMAT_VOXWARE = $00062;

ESS Technology */

WAVE_FORMAT_VOXWARE_AC10 = $00071;

Voxware Inc */

WAVE_FORMAT_VOXWARE_AC16 = $00072;

Voxware Inc */

WAVE_FORMAT_VOXWARE_AC20 = $00073;

Voxware Inc */

WAVE_FORMAT_VOXWARE_AC8 = $00070;

Voxware Inc */

WAVE_FORMAT_VOXWARE_BYTE_ALIGNED = $00069;

Microsoft Corporation */

WAVE_FORMAT_VOXWARE_RT24 = $00074;

Voxware Inc */

WAVE_FORMAT_VOXWARE_RT29 = $00075;

Voxware Inc */

WAVE_FORMAT_VOXWARE_RT29HW = $00076;

Voxware Inc */

WAVE_FORMAT_VOXWARE_TQ40 = $00079;

Voxware Inc */

WAVE_FORMAT_VOXWARE_TQ60 = $00081;

Softsound, Ltd. */

WAVE_FORMAT_VOXWARE_VR12 = $00077;

Voxware Inc */

WAVE_FORMAT_VOXWARE_VR18 = $00078;

Voxware Inc */

WAVE_FORMAT_VSELP = $00004;

Microsoft Corporation */

WAVE_FORMAT_XEBEC = $0003D;

Rockwell International */

WAVE_FORMAT_YAMAHA_ADPCM = $00020;

Hewlett-Packard Company */

WAVE_FORMAT_ZYXEL_ADPCM = $00097;

Aculab plc */

WIDM_MAPPER_STATUS = (DRVM_MAPPER_STATUS + 0);
 
WODM_MAPPER_STATUS = (DRVM_MAPPER_STATUS + 0);
 
_DRVRESERVED = 10;

————————————————————————–;

ACM Stream API's #ifdef _WIN64 #define _DRVRESERVED 10

Author

(c) 2012 Lake of Soft

Generated by PasDoc 0.12.1 on 2012-10-09