pascal/lazarus-ccr
1
0
Fork 0
Code Issues Releases Activity
Files
a4971e7930eaff6e274b718c57fcd30c0732bfe5
lazarus-ccr/components/acs/Src/fileformats/windows/msacm.pas

1412 lines
51 KiB
ObjectPascal
Raw Normal View History

git-svn-id: https://svn.code.sf.net/p/lazarus-ccr/svn@67 8e941d3f-bd1b-0410-a28a-d453659cc2b4
2007-02-20 18:16:46 +00:00
{******************************************************************}
{ }
{ borland delphi runtime library }
{ microsoft audio compression manager interface unit }
{ }
{ portions created by microsoft are }
{ copyright (c) 1995-1999 microsoft corporation. }
{ all rights reserved. }
{ }
{ the original file is: msacm.h, released 9 march 1999. }
{ the original pascal code is: msacm.pas, released 21 july 1999. }
{ the initial developer of the pascal code is francois piette }
{ francois.piette@swing.be, http://www.rtfm.be/fpiette/indexuk.htm }
{ rue de grady 24, 4053 embourg, belgium }
{ }
{ portions created by francois piette are }
{ copyright (c) 1999 francois piette. }
{ }
{ contributor(s): marcel van brakel (brakelm@bart.nl) }
{ }
{ obtained through: }
{ joint endeavour of delphi innovators (project jedi) }
{ }
{ you may retrieve the latest version of this file at the project }
{ jedi home page, located at http://delphi-jedi.org }
{ }
{ the contents of this file are used with permission, subject to }
{ the mozilla public license version 1.1 (the "license"); you may }
{ not use this file except in compliance with the license. you may }
{ obtain a copy of the license at }
{ http://www.mozilla.org/npl/npl-1_1final.html }
{ }
{ software distributed under the license is distributed on an }
{ "as is" basis, without warranty of any kind, either express or }
{ implied. see the license for the specific language governing }
{ rights and limitations under the license. }
{ }
{******************************************************************}
unit msacm;
{$WEAKPACKAGEUNIT}
interface
{$HPPEMIT ''}
{$HPPEMIT '#include "MSAcm.h"'}
{$HPPEMIT ''}
uses
Windows, MMSystem;
type
PWaveFilter = ^TWaveFilter;
// Defined in mmreg.h
WAVEFILTER = packed record
cbStruct: DWORD; // Size of the filter in bytes
dwFilterTag: DWORD; // filter type
fdwFilter: DWORD; // Flags for the filter (Universal Dfns)
dwReserved: array [0..4] of DWORD; // Reserved for system use
end;
TWaveFilter = WAVEFILTER;
const
DRV_MAPPER_PREFERRED_INPUT_GET = DRV_USER + 0;
{$EXTERNALSYM DRV_MAPPER_PREFERRED_INPUT_GET}
DRV_MAPPER_PREFERRED_OUTPUT_GET = DRV_USER + 2;
{$EXTERNALSYM DRV_MAPPER_PREFERRED_OUTPUT_GET}
DRVM_MAPPER_STATUS = $2000;
{$EXTERNALSYM DRVM_MAPPER_STATUS}
WIDM_MAPPER_STATUS = DRVM_MAPPER_STATUS + 0;
{$EXTERNALSYM WIDM_MAPPER_STATUS}
WAVEIN_MAPPER_STATUS_DEVICE = 0;
{$EXTERNALSYM WAVEIN_MAPPER_STATUS_DEVICE}
WAVEIN_MAPPER_STATUS_MAPPED = 1;
{$EXTERNALSYM WAVEIN_MAPPER_STATUS_MAPPED}
WAVEIN_MAPPER_STATUS_FORMAT = 2;
{$EXTERNALSYM WAVEIN_MAPPER_STATUS_FORMAT}
WODM_MAPPER_STATUS = DRVM_MAPPER_STATUS + 0;
{$EXTERNALSYM WODM_MAPPER_STATUS}
WAVEOUT_MAPPER_STATUS_DEVICE = 0;
{$EXTERNALSYM WAVEOUT_MAPPER_STATUS_DEVICE}
WAVEOUT_MAPPER_STATUS_MAPPED = 1;
{$EXTERNALSYM WAVEOUT_MAPPER_STATUS_MAPPED}
WAVEOUT_MAPPER_STATUS_FORMAT = 2;
{$EXTERNALSYM WAVEOUT_MAPPER_STATUS_FORMAT}
//--------------------------------------------------------------------------
//
// ACM General API's and Defines
//
//--------------------------------------------------------------------------
// 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.
//
// 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.
//
// 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.
//
//
// 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.
type
HACMDRIVERID__ = record
Unused: Integer;
end;
{$EXTERNALSYM HACMDRIVERID__}
HACMDRIVERID = ^HACMDRIVERID__;
{$EXTERNALSYM HACMDRIVERID}
PHACMDRIVERID = ^HACMDRIVERID;
{$EXTERNALSYM PHACMDRIVERID}
LPHACMDRIVERID = ^HACMDRIVERID;
{$EXTERNALSYM LPHACMDRIVERID}
HACMDRIVER__ = record
Unused: Integer;
end;
{$EXTERNALSYM HACMDRIVER__}
HACMDRIVER = ^HACMDRIVER__;
{$EXTERNALSYM HACMDRIVER}
PHACMDRIVER = ^HACMDRIVER;
{$EXTERNALSYM PHACMDRIVER}
LPHACMDRIVER = ^HACMDRIVER;
{$EXTERNALSYM LPHACMDRIVER}
HACMSTREAM__ = record
Unused: Integer;
end;
{$EXTERNALSYM HACMSTREAM__}
HACMSTREAM = ^HACMSTREAM__;
{$EXTERNALSYM HACMSTREAM}
PHACMSTREAM = ^HACMSTREAM;
{$EXTERNALSYM PHACMSTREAM}
LPHACMSTREAM = ^HACMSTREAM;
{$EXTERNALSYM LPHACMSTREAM}
HACMOBJ__ = record
Unused: Integer;
end;
{$EXTERNALSYM HACMOBJ__}
HACMOBJ = ^HACMOBJ__;
{$EXTERNALSYM HACMOBJ}
PHACMOBJ = ^HACMOBJ;
{$EXTERNALSYM PHACMOBJ}
LPHACMOBJ = ^HACMOBJ;
{$EXTERNALSYM LPHACMOBJ}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// ACM Error Codes
//
// Note that these error codes are specific errors that apply to the ACM
// directly--general errors are defined as MMSYSERR_*.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
type
MMRESULT = UINT;
{$EXTERNALSYM MMRESULT}
const
ACMERR_BASE = 512;
{$EXTERNALSYM ACMERR_BASE}
ACMERR_NOTPOSSIBLE = (ACMERR_BASE + 0);
{$EXTERNALSYM ACMERR_NOTPOSSIBLE}
ACMERR_BUSY = (ACMERR_BASE + 1);
{$EXTERNALSYM ACMERR_BUSY}
ACMERR_UNPREPARED = (ACMERR_BASE + 2);
{$EXTERNALSYM ACMERR_UNPREPARED}
ACMERR_CANCELED = (ACMERR_BASE + 3);
{$EXTERNALSYM ACMERR_CANCELED}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// 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.
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const
MM_ACM_OPEN = MM_STREAM_OPEN; // conversion callback messages
{$EXTERNALSYM MM_ACM_OPEN}
MM_ACM_CLOSE = MM_STREAM_CLOSE;
{$EXTERNALSYM MM_ACM_CLOSE}
MM_ACM_DONE = MM_STREAM_DONE;
{$EXTERNALSYM MM_ACM_DONE}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// acmGetVersion()
//
// 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 acmGetVersion: DWORD; stdcall;
{$EXTERNALSYM acmGetVersion}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmMetrics()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
function acmMetrics(hao: HACMOBJ; uMetric: UINT; var pMetric): MMRESULT; stdcall;
{$EXTERNALSYM acmMetrics}
const
ACM_METRIC_COUNT_DRIVERS = 1;
{$EXTERNALSYM ACM_METRIC_COUNT_DRIVERS}
ACM_METRIC_COUNT_CODECS = 2;
{$EXTERNALSYM ACM_METRIC_COUNT_CODECS}
ACM_METRIC_COUNT_CONVERTERS = 3;
{$EXTERNALSYM ACM_METRIC_COUNT_CONVERTERS}
ACM_METRIC_COUNT_FILTERS = 4;
{$EXTERNALSYM ACM_METRIC_COUNT_FILTERS}
ACM_METRIC_COUNT_DISABLED = 5;
{$EXTERNALSYM ACM_METRIC_COUNT_DISABLED}
ACM_METRIC_COUNT_HARDWARE = 6;
{$EXTERNALSYM ACM_METRIC_COUNT_HARDWARE}
ACM_METRIC_COUNT_LOCAL_DRIVERS = 20;
{$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_DRIVERS}
ACM_METRIC_COUNT_LOCAL_CODECS = 21;
{$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_CODECS}
ACM_METRIC_COUNT_LOCAL_CONVERTERS = 22;
{$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_CONVERTERS}
ACM_METRIC_COUNT_LOCAL_FILTERS = 23;
{$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_FILTERS}
ACM_METRIC_COUNT_LOCAL_DISABLED = 24;
{$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_DISABLED}
ACM_METRIC_HARDWARE_WAVE_INPUT = 30;
{$EXTERNALSYM ACM_METRIC_HARDWARE_WAVE_INPUT}
ACM_METRIC_HARDWARE_WAVE_OUTPUT = 31;
{$EXTERNALSYM ACM_METRIC_HARDWARE_WAVE_OUTPUT}
ACM_METRIC_MAX_SIZE_FORMAT = 50;
{$EXTERNALSYM ACM_METRIC_MAX_SIZE_FORMAT}
ACM_METRIC_MAX_SIZE_FILTER = 51;
{$EXTERNALSYM ACM_METRIC_MAX_SIZE_FILTER}
ACM_METRIC_DRIVER_SUPPORT = 100;
{$EXTERNALSYM ACM_METRIC_DRIVER_SUPPORT}
ACM_METRIC_DRIVER_PRIORITY = 101;
{$EXTERNALSYM ACM_METRIC_DRIVER_PRIORITY}
//--------------------------------------------------------------------------;
//
// ACM Drivers
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverEnum()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
type
ACMDRIVERENUMCB = function (hadif: HACMDRIVERID; dwInstance, fdwSupport: DWORD): BOOL; stdcall;
{$EXTERNALSYM ACMDRIVERENUMCB}
function acmDriverEnum(fnCallback: ACMDRIVERENUMCB; dwInstance: DWORD;
fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverEnum}
const
ACM_DRIVERENUMF_NOLOCAL = $40000000;
{$EXTERNALSYM ACM_DRIVERENUMF_NOLOCAL}
ACM_DRIVERENUMF_DISABLED = $80000000;
{$EXTERNALSYM ACM_DRIVERENUMF_DISABLED}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverID()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
function acmDriverID(hao: HACMOBJ; var phadid: HACMDRIVERID; fdwDriverID: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverID}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverAdd()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
function acmDriverAddA(var phadid: HACMDRIVERID; hinstModule: HINST; Param: LPARAM;
dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverAddA}
function acmDriverAddW(var phadid: HACMDRIVERID; hinstModule: HINST; Param: LPARAM;
dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverAddW}
function acmDriverAdd(var phadid: HACMDRIVERID; hinstModule: HINST; Param: LPARAM;
dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverAdd}
const
ACM_DRIVERADDF_FUNCTION = $00000003; // lParam is a procedure
{$EXTERNALSYM ACM_DRIVERADDF_FUNCTION}
ACM_DRIVERADDF_NOTIFYHWND = $00000004; // lParam is notify hwnd
{$EXTERNALSYM ACM_DRIVERADDF_NOTIFYHWND}
ACM_DRIVERADDF_TYPEMASK = $00000007; // driver type mask
{$EXTERNALSYM ACM_DRIVERADDF_TYPEMASK}
ACM_DRIVERADDF_LOCAL = $00000000; // is local to current task
{$EXTERNALSYM ACM_DRIVERADDF_LOCAL}
ACM_DRIVERADDF_GLOBAL = $00000008; // is global
{$EXTERNALSYM ACM_DRIVERADDF_GLOBAL}
//
// prototype for ACM driver procedures that are installed as _functions_
// or _notifations_ instead of as a standalone installable driver.
//
type
ACMDRIVERPROC = function (dwID: DWORD; hdrvr: HACMDRIVERID; uMsg: UINT;
lParam1: LPARAM; lParam2: LPARAM) : LRESULT; stdcall;
{$EXTERNALSYM ACMDRIVERPROC}
LPACMDRIVERPROC = ^ACMDRIVERPROC;
{$EXTERNALSYM LPACMDRIVERPROC}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverRemove()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
function acmDriverRemove(hadid: HACMDRIVERID; fdwRemove: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverRemove}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverOpen()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
function acmDriverOpen(var phad: HACMDRIVER; hadid: HACMDRIVERID; fdwOpen: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverOpen}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverClose()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
function acmDriverClose(had: HACMDRIVER; fdwClose: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverClose}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverMessage()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
function acmDriverMessage(had: HACMDRIVER; uMsg: UINT; Param1, Param2: LPARAM): LRESULT; stdcall;
{$EXTERNALSYM acmDriverMessage}
const
ACMDM_USER = DRV_USER + $0000;
{$EXTERNALSYM ACMDM_USER}
ACMDM_RESERVED_LOW = DRV_USER + $2000;
{$EXTERNALSYM ACMDM_RESERVED_LOW}
ACMDM_RESERVED_HIGH = DRV_USER + $2FFF;
{$EXTERNALSYM ACMDM_RESERVED_HIGH}
ACMDM_BASE = ACMDM_RESERVED_LOW;
{$EXTERNALSYM ACMDM_BASE}
ACMDM_DRIVER_ABOUT = ACMDM_BASE + 11;
{$EXTERNALSYM ACMDM_DRIVER_ABOUT}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverPriority
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
function acmDriverPriority(hadid: HACMDRIVERID; dwPriority, fdwPriority: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverPriority}
const
ACM_DRIVERPRIORITYF_ENABLE = $00000001;
{$EXTERNALSYM ACM_DRIVERPRIORITYF_ENABLE}
ACM_DRIVERPRIORITYF_DISABLE = $00000002;
{$EXTERNALSYM ACM_DRIVERPRIORITYF_DISABLE}
ACM_DRIVERPRIORITYF_ABLEMASK = $00000003;
{$EXTERNALSYM ACM_DRIVERPRIORITYF_ABLEMASK}
ACM_DRIVERPRIORITYF_BEGIN = $00010000;
{$EXTERNALSYM ACM_DRIVERPRIORITYF_BEGIN}
ACM_DRIVERPRIORITYF_END = $00020000;
{$EXTERNALSYM ACM_DRIVERPRIORITYF_END}
ACM_DRIVERPRIORITYF_DEFERMASK = $00030000;
{$EXTERNALSYM ACM_DRIVERPRIORITYF_DEFERMASK}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// 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
PAcmDriverDetailsA = ^TAcmDriverDetailsA;
PAcmDriverDetailsW = ^TAcmDriverDetailsW;
PAcmDriverDetails = PAcmDriverDetailsA;
_ACMDRIVERDETAILSA = 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 AnsiChar;
szLongName: array [0..ACMDRIVERDETAILS_LONGNAME_CHARS - 1] of AnsiChar;
szCopyright: array [0..ACMDRIVERDETAILS_COPYRIGHT_CHARS - 1] of AnsiChar;
szLicensing: array [0..ACMDRIVERDETAILS_LICENSING_CHARS - 1] of AnsiChar;
szFeatures: array [0..ACMDRIVERDETAILS_FEATURES_CHARS - 1] of AnsiChar;
end;
{$EXTERNALSYM _ACMDRIVERDETAILSA}
_ACMDRIVERDETAILSW = 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 WideChar;
szLongName: array [0..ACMDRIVERDETAILS_LONGNAME_CHARS - 1] of WideChar;
szCopyright: array [0..ACMDRIVERDETAILS_COPYRIGHT_CHARS - 1] of WideChar;
szLicensing: array [0..ACMDRIVERDETAILS_LICENSING_CHARS - 1] of WideChar;
szFeatures: array [0..ACMDRIVERDETAILS_FEATURES_CHARS - 1] of WideChar;
end;
{$EXTERNALSYM _ACMDRIVERDETAILSW}
_ACMDRIVERDETAILS = _ACMDRIVERDETAILSA;
TAcmDriverDetailsA = _ACMDRIVERDETAILSA;
TAcmDriverDetailsW = _ACMDRIVERDETAILSW;
TAcmDriverDetails = TAcmDriverDetailsA;
//
// 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}
function acmDriverDetailsA(hadid: HACMDRIVERID; var padd: TAcmDriverDetailsA;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverDetailsA}
function acmDriverDetailsW(hadid: HACMDRIVERID; var padd: TAcmDriverDetailsW;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverDetailsW}
function acmDriverDetails(hadid: HACMDRIVERID; var padd: TAcmDriverDetails;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmDriverDetails}
//--------------------------------------------------------------------------;
//
// ACM Format Tags
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFormatTagDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
const
ACMFORMATTAGDETAILS_FORMATTAG_CHARS = 48;
{$EXTERNALSYM ACMFORMATTAGDETAILS_FORMATTAG_CHARS}
type
PAcmFormatTagDetailsA = ^TAcmFormatTagDetailsA;
PAcmFormatTagDetailsW = ^TAcmFormatTagDetailsW;
PAcmFormatTagDetails = PAcmFormatTagDetailsA;
_ACMFORMATTAGDETAILSA = packed record
cbStruct: DWORD;
dwFormatTagIndex: DWORD;
dwFormatTag: DWORD;
cbFormatSize: DWORD;
fdwSupport: DWORD;
cStandardFormats: DWORD;
szFormatTag: array [0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS - 1] of AnsiChar;
end;
{$EXTERNALSYM _ACMFORMATTAGDETAILSA}
_ACMFORMATTAGDETAILSW = packed record
cbStruct: DWORD;
dwFormatTagIndex: DWORD;
dwFormatTag: DWORD;
cbFormatSize: DWORD;
fdwSupport: DWORD;
cStandardFormats: DWORD;
szFormatTag: array [0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS - 1] of WideChar;
end;
{$EXTERNALSYM _ACMFORMATTAGDETAILSW}
_ACMFORMATTAGDETAILS = _ACMFORMATTAGDETAILSA;
TAcmFormatTagDetailsA = _ACMFORMATTAGDETAILSA;
TAcmFormatTagDetailsW = _ACMFORMATTAGDETAILSW;
TAcmFormatTagDetails = TAcmFormatTagDetailsA;
function acmFormatTagDetailsA(had: HACMDRIVER; var paftd: TAcmFormatTagDetailsA;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatTagDetailsA}
function acmFormatTagDetailsW(had: HACMDRIVER; var paftd: TAcmFormatTagDetailsW;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatTagDetailsW}
function acmFormatTagDetails(had: HACMDRIVER; var paftd: TAcmFormatTagDetails;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatTagDetails}
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
ACMFORMATTAGENUMCBA = function (hadid: HACMDRIVERID; paftd: PAcmFormatTagDetailsA;
dwInstance: DWORD; fdwSupport: DWORD): BOOL; stdcall;
{$EXTERNALSYM ACMFORMATTAGENUMCBA}
ACMFORMATTAGENUMCBW = function (hadid: HACMDRIVERID; paftd: PAcmFormatTagDetailsW;
dwInstance: DWORD; fdwSupport: DWORD): BOOL; stdcall;
{$EXTERNALSYM ACMFORMATTAGENUMCBW}
ACMFORMATTAGENUMCB = ACMFORMATTAGENUMCBA;
function acmFormatTagEnumA(had: HACMDRIVER; var paftd: TAcmFormatTagDetailsA;
fnCallback: ACMFORMATTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatTagEnumA}
function acmFormatTagEnumW(had: HACMDRIVER; var paftd: TAcmFormatTagDetailsW;
fnCallback: ACMFORMATTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatTagEnumW}
function acmFormatTagEnum(had: HACMDRIVER; var paftd: TAcmFormatTagDetails;
fnCallback: ACMFORMATTAGENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatTagEnum}
//--------------------------------------------------------------------------;
//
// ACM Formats
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFormatDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
const
ACMFORMATDETAILS_FORMAT_CHARS = 128;
{$EXTERNALSYM ACMFORMATDETAILS_FORMAT_CHARS}
type
PAcmFormatDetailsA = ^TAcmFormatDetailsA;
PAcmFormatDetailsW = ^TAcmFormatDetailsW;
PAcmFormatDetails = PAcmFormatDetailsA;
_ACMFORMATDETAILSA = packed record
cbStruct: DWORD;
dwFormatIndex: DWORD;
dwFormatTag: DWORD;
fdwSupport: DWORD;
pwfx: PWAVEFORMATEX;
cbwfx: DWORD;
szFormat: array [0..ACMFORMATDETAILS_FORMAT_CHARS - 1] of AnsiChar;
end;
{$EXTERNALSYM _ACMFORMATDETAILSA}
_ACMFORMATDETAILSW = packed record
cbStruct: DWORD;
dwFormatIndex: DWORD;
dwFormatTag: DWORD;
fdwSupport: DWORD;
pwfx: PWAVEFORMATEX;
cbwfx: DWORD;
szFormat: array [0..ACMFORMATDETAILS_FORMAT_CHARS - 1] of WideChar;
end;
{$EXTERNALSYM _ACMFORMATDETAILSW}
_ACMFORMATDETAILS = _ACMFORMATDETAILSA;
TAcmFormatDetailsA = _ACMFORMATDETAILSA;
TAcmFormatDetailsW = _ACMFORMATDETAILSW;
TAcmFormatDetails = TAcmFormatDetailsA;
function acmFormatDetailsA(had: HACMDRIVER; var pafd: TAcmFormatDetailsA;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatDetailsA}
function acmFormatDetailsW(had: HACMDRIVER; var pafd: TAcmFormatDetailsW;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatDetailsW}
function acmFormatDetails(had: HACMDRIVER; var pafd: TAcmFormatDetails;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatDetails}
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
ACMFORMATENUMCBA = function (hadid:HACMDRIVERID; pafd: PAcmFormatDetailsA;
dwInstance: DWORD; fdwSupport: DWORD): BOOL; stdcall;
{$EXTERNALSYM ACMFORMATENUMCBA}
ACMFORMATENUMCBW = function (hadid:HACMDRIVERID; pafd: PAcmFormatDetailsW;
dwInstance: DWORD; fdwSupport: DWORD): BOOL; stdcall;
{$EXTERNALSYM ACMFORMATENUMCBW}
ACMFORMATENUMCB = ACMFORMATENUMCBA;
function acmFormatEnumA(had: HACMDRIVER; var pafd: TAcmFormatDetailsA;
fnCallback: ACMFORMATENUMCBA; dwInstance, fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatEnumA}
function acmFormatEnumW(had: HACMDRIVER; var pafd: TAcmFormatDetailsW;
fnCallback: ACMFORMATENUMCBW; dwInstance, fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatEnumW}
function acmFormatEnum(had: HACMDRIVER; var pafd: TAcmFormatDetails;
fnCallback: ACMFORMATENUMCB; dwInstance, fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatEnum}
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
ACMHELPMSGSTRINGA = 'acmchoose_help';
{$EXTERNALSYM ACMHELPMSGSTRINGA}
ACMHELPMSGSTRINGW = 'acmchoose_help';
{$EXTERNALSYM ACMHELPMSGSTRINGW}
ACMHELPMSGSTRING = ACMHELPMSGSTRINGA;
ACMHELPMSGCONTEXTMENUA = 'acmchoose_contextmenu';
{$EXTERNALSYM ACMHELPMSGCONTEXTMENUA}
ACMHELPMSGCONTEXTMENUW = 'acmchoose_contextmenu';
{$EXTERNALSYM ACMHELPMSGCONTEXTMENUW}
ACMHELPMSGCONTEXTMENU = ACMHELPMSGCONTEXTMENUA;
ACMHELPMSGCONTEXTHELPA = 'acmchoose_contexthelp';
{$EXTERNALSYM ACMHELPMSGCONTEXTHELPA}
ACMHELPMSGCONTEXTHELPW = 'acmchoose_contexthelp';
{$EXTERNALSYM ACMHELPMSGCONTEXTHELPW}
ACMHELPMSGCONTEXTHELP = ACMHELPMSGCONTEXTHELPA;
//
// 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
ACMFORMATCHOOSEHOOKPROCA = function (hwnd: HWND; uMsg: UINT; wParam: WPARAM;
lParam: LPARAM): UINT; stdcall;
{$EXTERNALSYM ACMFORMATCHOOSEHOOKPROCA}
ACMFORMATCHOOSEHOOKPROCW = function (hwnd: HWND; uMsg: UINT; wParam: WPARAM;
lParam: LPARAM): UINT; stdcall;
{$EXTERNALSYM ACMFORMATCHOOSEHOOKPROCW}
ACMFORMATCHOOSEHOOKPROC = ACMFORMATCHOOSEHOOKPROCA;
PAcmFormatChooseA = ^TAcmFormatChooseA;
PAcmFormatChooseW = ^TAcmFormatChooseW;
PAcmFormatChoose = PAcmFormatChooseA;
_ACMFORMATCHOOSEA = packed record
cbStruct: DWORD;
fdwStyle: DWORD;
hwndOwner: HWND;
pwfx: PWAVEFORMATEX;
cbwfx: DWORD;
pszTitle: PAnsiChar;
szFormatTag: array [0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of AnsiChar;
szFormat: array [0..ACMFORMATDETAILS_FORMAT_CHARS-1] of AnsiChar;
pszName: PAnsiChar;
cchName: DWORD;
fdwEnum: DWORD;
pwfxEnum: PWAVEFORMATEX;
hInstance: HINST;
pszTemplateName: PAnsiChar;
lCustData: LPARAM;
pfnHook: ACMFORMATCHOOSEHOOKPROCA;
end;
{$EXTERNALSYM _ACMFORMATCHOOSEA}
_ACMFORMATCHOOSEW = packed record
cbStruct: DWORD;
fdwStyle: DWORD;
hwndOwner: HWND;
pwfx: PWAVEFORMATEX;
cbwfx: DWORD;
pszTitle: PWideChar;
szFormatTag: array [0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of WideChar;
szFormat: array [0..ACMFORMATDETAILS_FORMAT_CHARS-1] of WideChar;
pszName: PWideChar;
cchName: DWORD;
fdwEnum: DWORD;
pwfxEnum: PWAVEFORMATEX;
hInstance: HINST;
pszTemplateName: PWideChar;
lCustData: LPARAM;
pfnHook: ACMFORMATCHOOSEHOOKPROCW;
end;
{$EXTERNALSYM _ACMFORMATCHOOSEW}
_ACMFORMATCHOOSE = _ACMFORMATCHOOSEA;
TAcmFormatChooseA = _ACMFORMATCHOOSEA;
TAcmFormatChooseW = _ACMFORMATCHOOSEW;
TAcmFormatChoose = TAcmFormatChooseA;
//
// 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}
function acmFormatChooseA(var pafmtc: TAcmFormatChooseA): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatChooseA}
function acmFormatChooseW(var pafmtc: TAcmFormatChooseW): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatChooseW}
function acmFormatChoose(var pafmtc: TAcmFormatChoose): MMRESULT; stdcall;
{$EXTERNALSYM acmFormatChoose}
//--------------------------------------------------------------------------;
//
// ACM Filter Tags
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFilterTagDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
const
ACMFILTERTAGDETAILS_FILTERTAG_CHARS = 48;
{$EXTERNALSYM ACMFILTERTAGDETAILS_FILTERTAG_CHARS}
type
PAcmFilterTagDetailsA = ^TAcmFilterTagDetailsA;
PAcmFilterTagDetailsW = ^TAcmFilterTagDetailsW;
PAcmFilterTagDetails = PAcmFilterTagDetailsA;
_ACMFILTERTAGDETAILSA = packed record
cbStruct: DWORD;
dwFilterTagIndex: DWORD;
dwFilterTag: DWORD;
cbFilterSize: DWORD;
fdwSupport: DWORD;
cStandardFilters: DWORD;
szFilterTag: array [0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS-1] of AnsiChar;
end;
{$EXTERNALSYM _ACMFILTERTAGDETAILSA}
_ACMFILTERTAGDETAILSW = packed record
cbStruct: DWORD;
dwFilterTagIndex: DWORD;
dwFilterTag: DWORD;
cbFilterSize: DWORD;
fdwSupport: DWORD;
cStandardFilters: DWORD;
szFilterTag: array [0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS-1] of WideChar;
end;
{$EXTERNALSYM _ACMFILTERTAGDETAILSW}
_ACMFILTERTAGDETAILS = _ACMFILTERTAGDETAILSA;
TAcmFilterTagDetailsA = _ACMFILTERTAGDETAILSA;
TAcmFilterTagDetailsW = _ACMFILTERTAGDETAILSW;
TAcmFilterTagDetails = TAcmFilterTagDetailsA;
function acmFilterTagDetailsA(had: HACMDRIVER; var paftd: TAcmFilterTagDetailsA;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterTagDetailsA}
function acmFilterTagDetailsW(had: HACMDRIVER; var paftd: TAcmFilterTagDetailsW;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterTagDetailsW}
function acmFilterTagDetails(had: HACMDRIVER; var paftd: TAcmFilterTagDetails;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterTagDetails}
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
ACMFILTERTAGENUMCBA = function (hadid: HACMDRIVERID; paftd: PAcmFilterTagDetailsA;
dwInstance: DWORD; fdwSupport: DWORD) : BOOL; stdcall;
{$EXTERNALSYM ACMFILTERTAGENUMCBA}
ACMFILTERTAGENUMCBW = function (hadid: HACMDRIVERID; paftd: PAcmFilterTagDetailsW;
dwInstance: DWORD; fdwSupport: DWORD) : BOOL; stdcall;
{$EXTERNALSYM ACMFILTERTAGENUMCBW}
ACMFILTERTAGENUMCB = ACMFILTERTAGENUMCBA;
function acmFilterTagEnumA(had: HACMDRIVER; var paftd: TAcmFilterTagDetailsA;
fnCallback: ACMFILTERTAGENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterTagEnumA}
function acmFilterTagEnumW(had: HACMDRIVER; var paftd: TAcmFilterTagDetailsW;
fnCallback: ACMFILTERTAGENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterTagEnumW}
function acmFilterTagEnum(had: HACMDRIVER; var paftd: TAcmFilterTagDetails;
fnCallback: ACMFILTERTAGENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterTagEnum}
//--------------------------------------------------------------------------;
//
// ACM Filters
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFilterDetails()
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
const
ACMFILTERDETAILS_FILTER_CHARS = 128;
{$EXTERNALSYM ACMFILTERDETAILS_FILTER_CHARS}
type
PAcmFilterDetailsA = ^TAcmFilterDetailsA;
PAcmFilterDetailsW = ^TAcmFilterDetailsW;
PAcmFilterDetails = PAcmFilterDetailsA;
_ACMFILTERDETAILSA = packed record
cbStruct: DWORD;
dwFilterIndex: DWORD;
dwFilterTag: DWORD;
fdwSupport: DWORD;
pwfltr: PWAVEFILTER;
cbwfltr: DWORD;
szFilter: array [0..ACMFILTERDETAILS_FILTER_CHARS - 1] of AnsiChar;
end;
{$EXTERNALSYM _ACMFILTERDETAILSA}
_ACMFILTERDETAILSW = packed record
cbStruct: DWORD;
dwFilterIndex: DWORD;
dwFilterTag: DWORD;
fdwSupport: DWORD;
pwfltr: PWAVEFILTER;
cbwfltr: DWORD;
szFilter: array [0..ACMFILTERDETAILS_FILTER_CHARS - 1] of WideChar;
end;
{$EXTERNALSYM _ACMFILTERDETAILSW}
_ACMFILTERDETAILS = _ACMFILTERDETAILSA;
TAcmFilterDetailsA = _ACMFILTERDETAILSA;
TAcmFilterDetailsW = _ACMFILTERDETAILSW;
TAcmFilterDetails = TAcmFilterDetailsA;
function acmFilterDetailsA(had: HACMDRIVER; var pafd: TAcmFilterDetailsA;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterDetailsA}
function acmFilterDetailsW(had: HACMDRIVER; var pafd: TAcmFilterDetailsW;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterDetailsW}
function acmFilterDetails(had: HACMDRIVER; var pafd: TAcmFilterDetails;
fdwDetails: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterDetails}
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
ACMFILTERENUMCBA = function (hadid: HACMDRIVERID; pafd: PAcmFilterDetailsA;
dwInstance: DWORD; fdwSupport: DWORD) : BOOL; stdcall;
ACMFILTERENUMCBW = function (hadid: HACMDRIVERID; pafd: PAcmFilterDetailsW;
dwInstance: DWORD; fdwSupport: DWORD) : BOOL; stdcall;
ACMFILTERENUMCB = ACMFILTERENUMCBA;
function acmFilterEnumA(had: HACMDRIVER; var pafd: TAcmFilterDetailsA;
fnCallback: ACMFILTERENUMCBA; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterEnumA}
function acmFilterEnumW(had: HACMDRIVER; var pafd: TAcmFilterDetailsW;
fnCallback: ACMFILTERENUMCBW; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterEnumW}
function acmFilterEnum(had: HACMDRIVER; var pafd: TAcmFilterDetails;
fnCallback: ACMFILTERENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterEnum}
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
ACMFILTERCHOOSEHOOKPROCA = function (hwd: HWND; uMsg: UINT; wParam: WPARAM;
lParam: LPARAM): UINT; stdcall;
{$EXTERNALSYM ACMFILTERCHOOSEHOOKPROCA}
ACMFILTERCHOOSEHOOKPROCW = function (hwd: HWND; uMsg: UINT; wParam: WPARAM;
lParam: LPARAM): UINT; stdcall;
{$EXTERNALSYM ACMFILTERCHOOSEHOOKPROCW}
ACMFILTERCHOOSEHOOKPROC = ACMFILTERCHOOSEHOOKPROCA;
//
// ACMFILTERCHOOSE
//
//
type
PAcmFilterChooseA = ^TAcmFilterChooseA;
PAcmFilterChooseW = ^TAcmFilterChooseW;
PAcmFilterChoose = PAcmFilterChooseA;
_ACMFILTERCHOOSEA = packed record
cbStruct: DWORD;
fdwStyle: DWORD;
hwndOwner: HWND;
pwfltr: PWAVEFILTER;
cbwfltr: DWORD;
pszTitle: PAnsiChar;
szFilterTag: array [0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS - 1] of AnsiChar;
szFilter: array [0..ACMFILTERDETAILS_FILTER_CHARS - 1] of AnsiChar;
pszName: PAnsiChar;
cchName: DWORD;
fdwEnum: DWORD;
pwfltrEnum: PWAVEFILTER;
hInstance: HINST;
pszTemplateName: PAnsiChar;
lCustData: LPARAM;
pfnHook: ACMFILTERCHOOSEHOOKPROCA;
end;
{$EXTERNALSYM _ACMFILTERCHOOSEA}
_ACMFILTERCHOOSEW = packed record
cbStruct: DWORD;
fdwStyle: DWORD;
hwndOwner: HWND;
pwfltr: PWAVEFILTER;
cbwfltr: DWORD;
pszTitle: PWideChar;
szFilterTag: array [0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS - 1] of WideChar;
szFilter: array [0..ACMFILTERDETAILS_FILTER_CHARS - 1] of WideChar;
pszName: PWideChar;
cchName: DWORD;
fdwEnum: DWORD;
pwfltrEnum: PWAVEFILTER;
hInstance: HINST;
pszTemplateName: PWideChar;
lCustData: LPARAM;
pfnHook: ACMFILTERCHOOSEHOOKPROCW;
end;
{$EXTERNALSYM _ACMFILTERCHOOSEW}
_ACMFILTERCHOOSE = _ACMFILTERCHOOSEA;
TAcmFilterChooseA = _ACMFILTERCHOOSEA;
TAcmFilterChooseW = _ACMFILTERCHOOSEW;
TAcmFilterChoose = TAcmFilterChooseA;
//
// 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}
function acmFilterChooseA(var pafltrc: TAcmFilterChooseA): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterChooseA}
function acmFilterChooseW(var pafltrc: TAcmFilterChooseW): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterChooseW}
function acmFilterChoose(var pafltrc: TAcmFilterChoose): MMRESULT; stdcall;
{$EXTERNALSYM acmFilterChoose}
//--------------------------------------------------------------------------;
//
// 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';
function acmDriverAddA; external msacm32 name 'acmDriverAddA';
function acmDriverAddW; external msacm32 name 'acmDriverAddW';
function acmDriverAdd; external msacm32 name 'acmDriverAddA';
function acmDriverRemove; external msacm32 name 'acmDriverRemove';
function acmDriverOpen; external msacm32 name 'acmDriverOpen';
function acmDriverClose; external msacm32 name 'acmDriverClose';
function acmDriverMessage; external msacm32 name 'acmDriverMessage';
function acmDriverPriority; external msacm32 name 'acmDriverPriority';
function acmDriverDetailsA; external msacm32 name 'acmDriverDetailsA';
function acmDriverDetailsW; external msacm32 name 'acmDriverDetailsW';
function acmDriverDetails; external msacm32 name 'acmDriverDetailsA';
function acmFormatTagDetailsA; external msacm32 name 'acmFormatTagDetailsA';
function acmFormatTagDetailsW; external msacm32 name 'acmFormatTagDetailsW';
function acmFormatTagDetails; external msacm32 name 'acmFormatTagDetailsA';
function acmFormatDetailsA; external msacm32 name 'acmFormatDetailsA';
function acmFormatDetailsW; external msacm32 name 'acmFormatDetailsW';
function acmFormatDetails; external msacm32 name 'acmFormatDetailsA';
function acmFormatChooseA; external msacm32 name 'acmFormatChooseA';
function acmFormatChooseW; external msacm32 name 'acmFormatChooseW';
function acmFormatChoose; external msacm32 name 'acmFormatChooseA';
function acmFormatEnumA; external msacm32 name 'acmFormatEnumA';
function acmFormatEnumW; external msacm32 name 'acmFormatEnumW';
function acmFormatEnum; external msacm32 name 'acmFormatEnumA';
function acmFormatTagEnumA; external msacm32 name 'acmFormatTagEnumA';
function acmFormatTagEnumW; external msacm32 name 'acmFormatTagEnumW';
function acmFormatTagEnum; external msacm32 name 'acmFormatTagEnumA';
function acmFormatSuggest; external msacm32 name 'acmFormatSuggest';
function acmFilterTagDetailsA; external msacm32 name 'acmFilterTagDetailsA';
function acmFilterTagDetailsW; external msacm32 name 'acmFilterTagDetailsW';
function acmFilterTagDetails; external msacm32 name 'acmFilterTagDetailsA';
function acmFilterTagEnumA; external msacm32 name 'acmFilterTagEnumA';
function acmFilterTagEnumW; external msacm32 name 'acmFilterTagEnumW';
function acmFilterTagEnum; external msacm32 name 'acmFilterTagEnumA';
function acmFilterDetailsA; external msacm32 name 'acmFilterDetailsA';
function acmFilterDetailsW; external msacm32 name 'acmFilterDetailsW';
function acmFilterDetails; external msacm32 name 'acmFilterDetailsA';
function acmFilterEnumA; external msacm32 name 'acmFilterEnumA';
function acmFilterEnumW; external msacm32 name 'acmFilterEnumW';
function acmFilterEnum; external msacm32 name 'acmFilterEnumA';
function acmFilterChooseA; external msacm32 name 'acmFilterChooseA';
function acmFilterChooseW; external msacm32 name 'acmFilterChooseW';
function acmFilterChoose; external msacm32 name 'acmFilterChooseA';
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.
Reference in New Issue Copy Permalink