unamsacmapi.pas

Voice Commnucation Components for Delphi

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

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

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

{$EXTERNALSYM acm_FilterTagDetailsA }
function acm_filterTagDetailsA(had: HACMDRIVER; var paftd: ACMFILTERTAGDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterTagDetailsW }
function acm_filterTagDetailsW(had: HACMDRIVER; var paftd: ACMFILTERTAGDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterTagDetails }
function acm_filterTagDetails (had: HACMDRIVER; var paftd: ACMFILTERTAGDETAILS;  fdwDetails: DWORD): MMRESULT; stdcall;

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

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

{$EXTERNALSYM acm_FilterTagEnumA }
function acm_filterTagEnumA(had: HACMDRIVER; var paftd: ACMFILTERTAGDETAILSA; fnCallback: ACMFILTERTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterTagEnumW }
function acm_filterTagEnumW(had: HACMDRIVER; var paftd: ACMFILTERTAGDETAILSW; fnCallback: ACMFILTERTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterTagEnum }
function acm_filterTagEnum (had: HACMDRIVER; var paftd: ACMFILTERTAGDETAILS;  fnCallback: ACMFILTERTAGENUMCB;  dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;

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

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

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

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

{$EXTERNALSYM acm_FilterDetailsA }
function acm_filterDetailsA(had: HACMDRIVER; var pafd: ACMFILTERDETAILSA; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterDetailsW }
function acm_filterDetailsW(had: HACMDRIVER; var pafd: ACMFILTERDETAILSW; fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterDetails }
function acm_filterDetails (had: HACMDRIVER; var pafd: ACMFILTERDETAILS;  fdwDetails: DWORD): MMRESULT; stdcall;

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

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

{$EXTERNALSYM acm_FilterEnumA }
function acm_filterEnumA(had: HACMDRIVER; var pafd: ACMFILTERDETAILSA; fnCallback: ACMFILTERENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterEnumW }
function acm_filterEnumW(had: HACMDRIVER; var pafd: ACMFILTERDETAILSW; fnCallback: ACMFILTERENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterEnum }
function acm_filterEnum (had: HACMDRIVER; var pafd: ACMFILTERDETAILS;  fnCallback: ACMFILTERENUMCB;  dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_FILTERENUMF_DWFILTERTAG }
  ACM_FILTERENUMF_DWFILTERTAG	= $00010000;

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

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

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

  pACMFILTERCHOOSEA = ^ACMFILTERCHOOSEA;
  {$EXTERNALSYM ACMFILTERCHOOSEA }
  ACMFILTERCHOOSEA = 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;

  pACMFILTERCHOOSEW = ^ACMFILTERCHOOSEW;
  {$EXTERNALSYM ACMFILTERCHOOSEW }
  ACMFILTERCHOOSEW = 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;

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

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

{$EXTERNALSYM acm_FilterChooseA }
function acm_filterChooseA(var pafltrc: ACMFILTERCHOOSEA): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterChooseW }
function acm_filterChooseW(var pafltrc: ACMFILTERCHOOSEW): MMRESULT; stdcall;
{$EXTERNALSYM acm_FilterChoose }
function acm_filterChoose (var pafltrc: ACMFILTERCHOOSE): MMRESULT; stdcall;

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

type
  pACMSTREAMHEADER = ^ACMSTREAMHEADER;
  {$EXTERNALSYM ACMSTREAMHEADER }
  ACMSTREAMHEADER = 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.fdwStatus
//
//  ACMSTREAMHEADER_STATUSF_DONE: done bit for async conversions.
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_DONE }
  ACMSTREAMHEADER_STATUSF_DONE     = $00010000;
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_PREPARED }
  ACMSTREAMHEADER_STATUSF_PREPARED = $00020000;
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_INQUEUE }
  ACMSTREAMHEADER_STATUSF_INQUEUE  = $00100000;

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

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

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

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