msacm.par

Interface for Microsoft Audio Compression Manager. - Delphi Source The ACM uses existing driver i

type
{#BEGIN}
  PAcmFilterTagDetails{$} = ^TAcmFilterTagDetails{$};
{#END}
{#BEGIN}
  _ACMFILTERTAGDETAILS{$} = packed record
    cbStruct: DWORD;
    dwFilterTagIndex: DWORD;
    dwFilterTag: DWORD;
    cbFilterSize: DWORD;
    fdwSupport: DWORD;
    cStandardFilters: DWORD;
    szFilterTag: array [0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS-1] of TCHAR;
  end;
  {$EXTERNALSYM _ACMFILTERTAGDETAILS{$}}
{#END}
{#BEGIN}
  TAcmFilterTagDetails{$} = _ACMFILTERTAGDETAILS{$};
{#END}

{#BEGIN}
function acmFilterTagDetails{$}(had: HACMDRIVER; var paftd: TAcmFilterTagDetails{$};
  fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterTagDetails{$}}
{#END}

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

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFilterTagEnum()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

type
{#BEGIN}
  ACMFILTERTAGENUMCB{$} = function (hadid: HACMDRIVERID; paftd: PAcmFilterTagDetails{$};
    dwInstance: DWORD; fdwSupport: DWORD) : BOOL; stdcall;
  {$EXTERNALSYM ACMFILTERTAGENUMCB{$}}
{#END}

{#BEGIN}
function acmFilterTagEnum{$}(had: HACMDRIVER; var paftd: TAcmFilterTagDetails{$};
  fnCallback: ACMFILTERTAGENUMCB{$}; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterTagEnum{$}}
{#END}

//--------------------------------------------------------------------------;
//
//  ACM Filters
//
//--------------------------------------------------------------------------;

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFilterDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

const
  ACMFILTERDETAILS_FILTER_CHARS = 128;
  {$EXTERNALSYM ACMFILTERDETAILS_FILTER_CHARS}

type
{#BEGIN}
  PAcmFilterDetails{$} = ^TAcmFilterDetails{$};
{#END}
{#BEGIN}
  _ACMFILTERDETAILS{$} = packed record
    cbStruct: DWORD;
    dwFilterIndex: DWORD;
    dwFilterTag: DWORD;
    fdwSupport: DWORD;
    pwfltr: PWAVEFILTER;
    cbwfltr: DWORD;
    szFilter: array [0..ACMFILTERDETAILS_FILTER_CHARS - 1] of TCHAR;
  end;
  {$EXTERNALSYM _ACMFILTERDETAILS{$}}
{#END}
{#BEGIN}
  TAcmFilterDetails{$} = _ACMFILTERDETAILS{$};
{#END}

{#BEGIN}
function acmFilterDetails{$}(had: HACMDRIVER; var pafd: TAcmFilterDetails{$};
  fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterDetails{$}}
{#END}

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

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFilterEnum()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

type
{#BEGIN}
  ACMFILTERENUMCB{$} = function (hadid: HACMDRIVERID; pafd: PAcmFilterDetails{$};
    dwInstance: DWORD; fdwSupport: DWORD) : BOOL; stdcall;
{#END}

{#BEGIN}
function acmFilterEnum{$}(had: HACMDRIVER; var pafd: TAcmFilterDetails{$};
  fnCallback: ACMFILTERENUMCB{$}; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterEnum{$}}
{#END}

const
  ACM_FILTERENUMF_DWFILTERTAG = $00010000;
  {$EXTERNALSYM ACM_FILTERENUMF_DWFILTERTAG}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFilterChoose()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

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

const
  MM_ACM_FILTERCHOOSE           = $8000;
  {$EXTERNALSYM MM_ACM_FILTERCHOOSE}

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

type
{#BEGIN}
  ACMFILTERCHOOSEHOOKPROC{$} = function (hwd: HWND; uMsg: UINT; wParam: WPARAM;
    lParam: LPARAM): UINT; stdcall;
  {$EXTERNALSYM ACMFILTERCHOOSEHOOKPROC{$}}
{#END}

//
//  ACMFILTERCHOOSE
//
//

type
{#BEGIN}
  PAcmFilterChoose{$} = ^TAcmFilterChoose{$};
{#END}
{#BEGIN}
  _ACMFILTERCHOOSE{$} = packed record
    cbStruct: DWORD;
    fdwStyle: DWORD;
    hwndOwner: HWND;
    pwfltr: PWAVEFILTER;
    cbwfltr: DWORD;
    pszTitle: LPCTSTR;
    szFilterTag: array [0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS - 1] of TCHAR;
    szFilter: array [0..ACMFILTERDETAILS_FILTER_CHARS - 1] of TCHAR;
    pszName: LPTSTR;
    cchName: DWORD;
    fdwEnum: DWORD;
    pwfltrEnum: PWAVEFILTER;
    hInstance: HINST;
    pszTemplateName: LPCTSTR;
    lCustData: LPARAM;
    pfnHook: ACMFILTERCHOOSEHOOKPROC{$};
  end;
  {$EXTERNALSYM _ACMFILTERCHOOSE{$}}
{#END}
{#BEGIN}
  TAcmFilterChoose{$} = _ACMFILTERCHOOSE{$};
{#END}

//
//  ACMFILTERCHOOSE.fdwStyle
//

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

{#BEGIN}
function acmFilterChoose{$}(var pafltrc: TAcmFilterChoose{$}): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterChoose{$}}
{#END}

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

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmStreamOpen()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

type
  PAcmStreamHeader = ^TAcmStreamHeader;
  ACMSTREAMHEADER = packed record
    cbStruct: DWORD;
    fdwStatus: DWORD;
    dwUser: DWORD;
    pbSrc: PBYTE;
    cbSrcLength: DWORD;
    cbSrcLengthUsed: DWORD;
    dwSrcUser: DWORD;
    pbDst: PBYTE;
    cbDstLength: DWORD;
    cbDstLengthUsed: DWORD;
    dwDstUser: DWORD;
    dwReservedDriver: array [0..10 - 1] of DWORD;
  end;
  {$EXTERNALSYM tACMSTREAMHEADER}
  TAcmStreamHeader = ACMSTREAMHEADER;

//
//  ACMSTREAMHEADER.fdwStatus
//
//  ACMSTREAMHEADER_STATUSF_DONE: done bit for async conversions.
//

const
  ACMSTREAMHEADER_STATUSF_DONE     = $00010000;
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_DONE}
  ACMSTREAMHEADER_STATUSF_PREPARED = $00020000;
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_PREPARED}
  ACMSTREAMHEADER_STATUSF_INQUEUE  = $00100000;
  {$EXTERNALSYM ACMSTREAMHEADER_STATUSF_INQUEUE}

function acmStreamOpen(var phas: HACMSTREAM; had: HACMDRIVER; var pwfxSrc: TWAVEFORMATEX;
  var pwfxDst: TWAVEFORMATEX; pwfltr: PWAVEFILTER; dwCallback: DWORD; dwInstance: DWORD;
  fdwOpen: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmStreamOpen}

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

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmStreamClose()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmStreamClose(has: HACMSTREAM; fdwClose: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmStreamClose}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmStreamSize()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmStreamSize(has: HACMSTREAM; cbInput: DWORD; var pdwOutputBytes: DWORD;
  fdwSize: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmStreamSize}

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

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmStreamReset()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmStreamReset(has: HACMSTREAM; fdwReset: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmStreamReset}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmStreamMessage()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmStreamMessage(has: HACMSTREAM; uMsg: UINT; var lParam1: LPARAM;
  var lParam2: LPARAM): MMRESULT; stdcall;
{$EXTERNALSYM acmStreamMessage}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmStreamConvert()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmStreamConvert(has: HACMSTREAM; var pash: TAcmStreamHeader;
  fdwConvert: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmStreamConvert}

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

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmStreamPrepareHeader()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmStreamPrepareHeader(has: HACMSTREAM; var pash: TAcmStreamHeader;
  fdwPrepare: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmStreamPrepareHeader}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmStreamUnprepareHeader()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmStreamUnprepareHeader(has: HACMSTREAM; var pash: TAcmStreamHeader;
  fdwUnprepare: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmStreamUnprepareHeader}

implementation

const
  msacm32 = 'msacm32.dll';

function acmGetVersion;            external msacm32 name 'acmGetVersion';
function acmMetrics;               external msacm32 name 'acmMetrics';
function acmDriverEnum;            external msacm32 name 'acmDriverEnum';
function acmDriverID;              external msacm32 name 'acmDriverID';
{#BEGIN}
function acmDriverAdd{$};          external msacm32 name 'acmDriverAdd{%}';
{#END}
function acmDriverRemove;          external msacm32 name 'acmDriverRemove';
function acmDriverOpen;            external msacm32 name 'acmDriverOpen';
function acmDriverClose;           external msacm32 name 'acmDriverClose';
function acmDriverMessage;         external msacm32 name 'acmDriverMessage';
function acmDriverPriority;        external msacm32 name 'acmDriverPriority';
{#BEGIN}
function acmDriverDetails{$};      external msacm32 name 'acmDriverDetails{%}';
{#END}
{#BEGIN}
function acmFormatTagDetails{$};   external msacm32 name 'acmFormatTagDetails{%}';
{#END}
{#BEGIN}
function acmFormatDetails{$};      external msacm32 name 'acmFormatDetails{%}';
{#END}
{#BEGIN}
function acmFormatChoose{$};       external msacm32 name 'acmFormatChoose{%}';
{#END}
{#BEGIN}
function acmFormatEnum{$};         external msacm32 name 'acmFormatEnum{%}';
{#END}
{#BEGIN}
function acmFormatTagEnum{$};      external msacm32 name 'acmFormatTagEnum{%}';
{#END}
function acmFormatSuggest;         external msacm32 name 'acmFormatSuggest';
{#BEGIN}
function acmFilterTagDetails{$};   external msacm32 name 'acmFilterTagDetails{%}';
{#END}
{#BEGIN}
function acmFilterTagEnum{$};      external msacm32 name 'acmFilterTagEnum{%}';
{#END}
{#BEGIN}
function acmFilterDetails{$};      external msacm32 name 'acmFilterDetails{%}';
{#END}
{#BEGIN}
function acmFilterEnum{$};         external msacm32 name 'acmFilterEnum{%}';
{#END}
{#BEGIN}
function acmFilterChoose{$};       external msacm32 name 'acmFilterChoose{%}';
{#END}
function acmStreamOpen;            external msacm32 name 'acmStreamOpen';
function acmStreamClose;           external msacm32 name 'acmStreamClose';
function acmStreamSize;            external msacm32 name 'acmStreamSize';
function acmStreamReset;           external msacm32 name 'acmStreamReset';
function acmStreamMessage;         external msacm32 name 'acmStreamMessage';
function acmStreamConvert;         external msacm32 name 'acmStreamConvert';
function acmStreamPrepareHeader;   external msacm32 name 'acmStreamPrepareHeader';
function acmStreamUnprepareHeader; external msacm32 name 'acmStreamUnprepareHeader';

end.