msacm.par

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

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

const
  ACMDRIVERDETAILS_SHORTNAME_CHARS = 32;
  {$EXTERNALSYM ACMDRIVERDETAILS_SHORTNAME_CHARS}
  ACMDRIVERDETAILS_LONGNAME_CHARS  = 128;
  {$EXTERNALSYM ACMDRIVERDETAILS_LONGNAME_CHARS}
  ACMDRIVERDETAILS_COPYRIGHT_CHARS = 80;
  {$EXTERNALSYM ACMDRIVERDETAILS_COPYRIGHT_CHARS}
  ACMDRIVERDETAILS_LICENSING_CHARS = 128;
  {$EXTERNALSYM ACMDRIVERDETAILS_LICENSING_CHARS}
  ACMDRIVERDETAILS_FEATURES_CHARS  = 512;
  {$EXTERNALSYM ACMDRIVERDETAILS_FEATURES_CHARS}

type
{#BEGIN}
  PAcmDriverDetails{$} = ^TAcmDriverDetails{$};
{#END}
{#BEGIN}
  _ACMDRIVERDETAILS{$} = packed record
    cbStruct: DWORD;
    fccType: FOURCC;
    fccComp: FOURCC;
    wMid: Word;
    wPid: Word;
    vdwACM: DWORD;
    vdwDriver: DWORD;
    fdwSupport: DWORD;
    cFormatTags: DWORD;
    cFilterTags: DWORD;
    hicon: HICON;
    szShortName: array [0..ACMDRIVERDETAILS_SHORTNAME_CHARS - 1] of TCHAR;
    szLongName: array [0..ACMDRIVERDETAILS_LONGNAME_CHARS - 1]  of TCHAR;
    szCopyright: array [0..ACMDRIVERDETAILS_COPYRIGHT_CHARS - 1] of TCHAR;
    szLicensing: array [0..ACMDRIVERDETAILS_LICENSING_CHARS - 1] of TCHAR;
    szFeatures: array [0..ACMDRIVERDETAILS_FEATURES_CHARS - 1]  of TCHAR;
  end;
  {$EXTERNALSYM _ACMDRIVERDETAILS{$}}
{#END}
{#BEGIN}
  TAcmDriverDetails{$} = _ACMDRIVERDETAILS{$};
{#END}

//
//  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.fccComp
//
//  ACMDRIVERDETAILS_FCCCOMP_UNDEFINED: the FOURCC used in the fccComp
//  field of the ACMDRIVERDETAILS structure. this is currently an unused
//  field.
//

const
  ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC = $63647561;   // 'audc';
  {$EXTERNALSYM ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC}
  ACMDRIVERDETAILS_FCCCOMP_UNDEFINED  = 0;           // '0000';
  {$EXTERNALSYM ACMDRIVERDETAILS_FCCCOMP_UNDEFINED}

//
//  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: 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_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: this flag is set if the driver supports
//  hardware input and/or output through a waveform device.
//
//  ACMDRIVERDETAILS_SUPPORTF_ASYNC: this flag is set if the driver supports
//  async conversions.
//
//
//  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.
//
//  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.
//

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

{#BEGIN}
function acmDriverDetails{$}(hadid: HACMDRIVERID; var padd: TAcmDriverDetails{$};
  fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverDetails{$}}
{#END}

//--------------------------------------------------------------------------;
//
//  ACM Format Tags
//
//--------------------------------------------------------------------------;

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFormatTagDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

const
  ACMFORMATTAGDETAILS_FORMATTAG_CHARS = 48;
  {$EXTERNALSYM ACMFORMATTAGDETAILS_FORMATTAG_CHARS}

type
{#BEGIN}
  PAcmFormatTagDetails{$} = ^TAcmFormatTagDetails{$};
{#END}
{#BEGIN}
  _ACMFORMATTAGDETAILS{$} = packed record
    cbStruct: DWORD;
    dwFormatTagIndex: DWORD;
    dwFormatTag: DWORD;
    cbFormatSize: DWORD;
    fdwSupport: DWORD;
    cStandardFormats: DWORD;
    szFormatTag: array [0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS - 1] of TCHAR;
  end;
  {$EXTERNALSYM _ACMFORMATTAGDETAILS{$}}
{#END}
{#BEGIN}
  TAcmFormatTagDetails{$} = _ACMFORMATTAGDETAILS{$};
{#END}

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

const
  ACM_FORMATTAGDETAILSF_INDEX       = $00000000;
  {$EXTERNALSYM ACM_FORMATTAGDETAILSF_INDEX}
  ACM_FORMATTAGDETAILSF_FORMATTAG   = $00000001;
  {$EXTERNALSYM ACM_FORMATTAGDETAILSF_FORMATTAG}
  ACM_FORMATTAGDETAILSF_LARGESTSIZE = $00000002;
  {$EXTERNALSYM ACM_FORMATTAGDETAILSF_LARGESTSIZE}
  ACM_FORMATTAGDETAILSF_QUERYMASK   = $0000000F;
  {$EXTERNALSYM ACM_FORMATTAGDETAILSF_QUERYMASK}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFormatTagEnum()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

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

{#BEGIN}
function acmFormatTagEnum{$}(had: HACMDRIVER; var paftd: TAcmFormatTagDetails{$};
  fnCallback: ACMFORMATTAGENUMCB{$}; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatTagEnum{$}}
{#END}

//--------------------------------------------------------------------------;
//
//  ACM Formats
//
//--------------------------------------------------------------------------;

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFormatDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

const
  ACMFORMATDETAILS_FORMAT_CHARS = 128;
  {$EXTERNALSYM ACMFORMATDETAILS_FORMAT_CHARS}

type
{#BEGIN}
  PAcmFormatDetails{$} = ^TAcmFormatDetails{$};
{#END}
{#BEGIN}
  _ACMFORMATDETAILS{$} = packed record
    cbStruct: DWORD;
    dwFormatIndex: DWORD;
    dwFormatTag: DWORD;
    fdwSupport: DWORD;
    pwfx: PWAVEFORMATEX;
    cbwfx: DWORD;
    szFormat: array [0..ACMFORMATDETAILS_FORMAT_CHARS - 1] of TCHAR;
  end;
  {$EXTERNALSYM _ACMFORMATDETAILS{$}}
{#END}
{#BEGIN}
  TAcmFormatDetails{$} = _ACMFORMATDETAILS{$};
{#END}

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

const
  ACM_FORMATDETAILSF_INDEX     = $00000000;
  {$EXTERNALSYM ACM_FORMATDETAILSF_INDEX}
  ACM_FORMATDETAILSF_FORMAT    = $00000001;
  {$EXTERNALSYM ACM_FORMATDETAILSF_FORMAT}
  ACM_FORMATDETAILSF_QUERYMASK = $0000000F;
  {$EXTERNALSYM ACM_FORMATDETAILSF_QUERYMASK}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFormatEnum()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

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

{#BEGIN}
function acmFormatEnum{$}(had: HACMDRIVER; var pafd: TAcmFormatDetails{$};
  fnCallback: ACMFORMATENUMCB{$}; dwInstance, fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatEnum{$}}
{#END}

const
  ACM_FORMATENUMF_WFORMATTAG     = $00010000;
  {$EXTERNALSYM ACM_FORMATENUMF_WFORMATTAG}
  ACM_FORMATENUMF_NCHANNELS      = $00020000;
  {$EXTERNALSYM ACM_FORMATENUMF_NCHANNELS}
  ACM_FORMATENUMF_NSAMPLESPERSEC = $00040000;
  {$EXTERNALSYM ACM_FORMATENUMF_NSAMPLESPERSEC}
  ACM_FORMATENUMF_WBITSPERSAMPLE = $00080000;
  {$EXTERNALSYM ACM_FORMATENUMF_WBITSPERSAMPLE}
  ACM_FORMATENUMF_CONVERT        = $00100000;
  {$EXTERNALSYM ACM_FORMATENUMF_CONVERT}
  ACM_FORMATENUMF_SUGGEST        = $00200000;
  {$EXTERNALSYM ACM_FORMATENUMF_SUGGEST}
  ACM_FORMATENUMF_HARDWARE       = $00400000;
  {$EXTERNALSYM ACM_FORMATENUMF_HARDWARE}
  ACM_FORMATENUMF_INPUT          = $00800000;
  {$EXTERNALSYM ACM_FORMATENUMF_INPUT}
  ACM_FORMATENUMF_OUTPUT         = $01000000;
  {$EXTERNALSYM ACM_FORMATENUMF_OUTPUT}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFormatSuggest()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

function acmFormatSuggest(had: HACMDRIVER; var pwfxSrc: TWAVEFORMATEX;
  var pwfxDst: TWAVEFORMATEX; cbwfxDst: DWORD; fdwSuggest: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatSuggest}

const
  ACM_FORMATSUGGESTF_WFORMATTAG     = $00010000;
  {$EXTERNALSYM ACM_FORMATSUGGESTF_WFORMATTAG}
  ACM_FORMATSUGGESTF_NCHANNELS      = $00020000;
  {$EXTERNALSYM ACM_FORMATSUGGESTF_NCHANNELS}
  ACM_FORMATSUGGESTF_NSAMPLESPERSEC = $00040000;
  {$EXTERNALSYM ACM_FORMATSUGGESTF_NSAMPLESPERSEC}
  ACM_FORMATSUGGESTF_WBITSPERSAMPLE = $00080000;
  {$EXTERNALSYM ACM_FORMATSUGGESTF_WBITSPERSAMPLE}

  ACM_FORMATSUGGESTF_TYPEMASK       = $00FF0000;
  {$EXTERNALSYM ACM_FORMATSUGGESTF_TYPEMASK}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFormatChoose()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

const
{#BEGIN}
  ACMHELPMSGSTRING{$}      = 'acmchoose_help';
  {$EXTERNALSYM ACMHELPMSGSTRING{$}}
{#END}
{#BEGIN}
  ACMHELPMSGCONTEXTMENU{$} = 'acmchoose_contextmenu';
  {$EXTERNALSYM ACMHELPMSGCONTEXTMENU{$}}
{#END}
{#BEGIN}
  ACMHELPMSGCONTEXTHELP{$} = 'acmchoose_contexthelp';
  {$EXTERNALSYM ACMHELPMSGCONTEXTHELP{$}}
{#END}

//
//  MM_ACM_FORMATCHOOSE is sent to hook callbacks by the Format Chooser
//  Dialog...
//

const
  MM_ACM_FORMATCHOOSE           = $8000;
  {$EXTERNALSYM MM_ACM_FORMATCHOOSE}

  FORMATCHOOSE_MESSAGE          = 0;
  {$EXTERNALSYM FORMATCHOOSE_MESSAGE}
  FORMATCHOOSE_FORMATTAG_VERIFY = FORMATCHOOSE_MESSAGE + 0;
  {$EXTERNALSYM FORMATCHOOSE_FORMATTAG_VERIFY}
  FORMATCHOOSE_FORMAT_VERIFY    = FORMATCHOOSE_MESSAGE + 1;
  {$EXTERNALSYM FORMATCHOOSE_FORMAT_VERIFY}
  FORMATCHOOSE_CUSTOM_VERIFY    = FORMATCHOOSE_MESSAGE + 2;
  {$EXTERNALSYM FORMATCHOOSE_CUSTOM_VERIFY}

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

{#BEGIN}
  PAcmFormatChoose{$} = ^TAcmFormatChoose{$};
{#END}
{#BEGIN}
  _ACMFORMATCHOOSE{$} = packed record
    cbStruct: DWORD;
    fdwStyle: DWORD;
    hwndOwner: HWND;
    pwfx: PWAVEFORMATEX;
    cbwfx: DWORD;
    pszTitle: LPCTSTR;
    szFormatTag: array [0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of TCHAR;
    szFormat: array [0..ACMFORMATDETAILS_FORMAT_CHARS-1] of TCHAR;
    pszName: LPTSTR;
    cchName: DWORD;
    fdwEnum: DWORD;
    pwfxEnum: PWAVEFORMATEX;
    hInstance: HINST;
    pszTemplateName: LPCTSTR;
    lCustData: LPARAM;
    pfnHook: ACMFORMATCHOOSEHOOKPROC{$};
  end;
  {$EXTERNALSYM _ACMFORMATCHOOSE{$}}
{#END}
{#BEGIN}
  TAcmFormatChoose{$} = _ACMFORMATCHOOSE{$};
{#END}

//
//  ACMFORMATCHOOSE.fdwStyle
//

const
  ACMFORMATCHOOSE_STYLEF_SHOWHELP             = $00000004;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_SHOWHELP}
  ACMFORMATCHOOSE_STYLEF_ENABLEHOOK           = $00000008;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_ENABLEHOOK}
  ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE       = $00000010;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE}
  ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = $00000020;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE}
  ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT      = $00000040;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT}
  ACMFORMATCHOOSE_STYLEF_CONTEXTHELP          = $00000080;
  {$EXTERNALSYM ACMFORMATCHOOSE_STYLEF_CONTEXTHELP}

{#BEGIN}
function acmFormatChoose{$}(var pafmtc: TAcmFormatChoose{$}): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatChoose{$}}
{#END}

//--------------------------------------------------------------------------;
//
//  ACM Filter Tags
//
//--------------------------------------------------------------------------;

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
//  acmFilterTagDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;

const
  ACMFILTERTAGDETAILS_FILTERTAG_CHARS = 48;
  {$EXTERNALSYM ACMFILTERTAGDETAILS_FILTERTAG_CHARS}