📄 msacm.pas
字号:
{******************************************************************}
{ }
{ 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/MPL/MPL-1.1.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;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -