|
|
//==========================================================================;//// msacm.h//// Copyright (c) 1992-1999 Microsoft Corporation. All Rights Reserved.//// Description:// Audio Compression Manager Public Header File//// History:////==========================================================================;
#ifndef _INC_ACM#define _INC_ACM /* #defined if msacm.h has been included */
#if _MSC_VER > 1000#pragma once#endif
#if !defined(_INC_MMREG) || (_INC_MMREG < 142)#ifndef RC_INVOKED#error MMREG.H version 142 or greater to be included first#endif#endif
#if defined(WIN32) && !defined(_WIN32)#ifndef RC_INVOKED#pragma message("MSACM.H: defining _WIN32 because application defined WIN32")#endif#define _WIN32#endif
#if defined(UNICODE) && !defined(_UNICODE)#ifndef RC_INVOKED#pragma message("MSACM.H: defining _UNICODE because application defined UNICODE")#endif#define _UNICODE#endif
#include "pshpack1.h" /* Assume byte packing throughout */
#ifdef __cplusplusextern "C" { /* Assume C declarations for C++ */#endif /* __cplusplus */
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//////////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifndef DRV_MAPPER_PREFERRED_INPUT_GET#define DRV_MAPPER_PREFERRED_INPUT_GET (DRV_USER + 0)#endif
#ifndef DRV_MAPPER_PREFERRED_OUTPUT_GET#define DRV_MAPPER_PREFERRED_OUTPUT_GET (DRV_USER + 2)#endif
#ifndef DRVM_MAPPER_STATUS#define DRVM_MAPPER 0x2000#define DRVM_MAPPER_STATUS (DRVM_MAPPER+0)#endif
#ifndef WIDM_MAPPER_STATUS#define WIDM_MAPPER_STATUS (DRVM_MAPPER_STATUS + 0)#define WAVEIN_MAPPER_STATUS_DEVICE 0#define WAVEIN_MAPPER_STATUS_MAPPED 1#define WAVEIN_MAPPER_STATUS_FORMAT 2#endif
#ifndef WODM_MAPPER_STATUS#define WODM_MAPPER_STATUS (DRVM_MAPPER_STATUS + 0)#define WAVEOUT_MAPPER_STATUS_DEVICE 0#define WAVEOUT_MAPPER_STATUS_MAPPED 1#define WAVEOUT_MAPPER_STATUS_FORMAT 2#endif
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;////////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32 #define ACMAPI WINAPI#else#ifdef _WINDLL #define ACMAPI _far _pascal _loadds#else #define ACMAPI _far _pascal#endif#endif
//--------------------------------------------------------------------------;//// 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.//DECLARE_HANDLE(HACMDRIVERID);typedef HACMDRIVERID *PHACMDRIVERID;typedef HACMDRIVERID FAR *LPHACMDRIVERID;
DECLARE_HANDLE(HACMDRIVER);typedef HACMDRIVER *PHACMDRIVER;typedef HACMDRIVER FAR *LPHACMDRIVER;
DECLARE_HANDLE(HACMSTREAM);typedef HACMSTREAM *PHACMSTREAM;typedef HACMSTREAM FAR *LPHACMSTREAM;
DECLARE_HANDLE(HACMOBJ);typedef HACMOBJ *PHACMOBJ;typedef HACMOBJ FAR *LPHACMOBJ;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// ACM Error Codes//// Note that these error codes are specific errors that apply to the ACM// directly--general errors are defined as MMSYSERR_*.////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifndef _MMRESULT_#define _MMRESULT_typedef UINT MMRESULT;#endif
#define ACMERR_BASE (512)#define ACMERR_NOTPOSSIBLE (ACMERR_BASE + 0)#define ACMERR_BUSY (ACMERR_BASE + 1)#define ACMERR_UNPREPARED (ACMERR_BASE + 2)#define ACMERR_CANCELED (ACMERR_BASE + 3)
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// 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.////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define MM_ACM_OPEN (MM_STREAM_OPEN) // conversion callback messages#define MM_ACM_CLOSE (MM_STREAM_CLOSE)#define MM_ACM_DONE (MM_STREAM_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)////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
DWORD ACMAPI acmGetVersion( void);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmMetrics()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmMetrics( HACMOBJ hao, UINT uMetric, LPVOID pMetric);
#define ACM_METRIC_COUNT_DRIVERS 1#define ACM_METRIC_COUNT_CODECS 2#define ACM_METRIC_COUNT_CONVERTERS 3#define ACM_METRIC_COUNT_FILTERS 4#define ACM_METRIC_COUNT_DISABLED 5#define ACM_METRIC_COUNT_HARDWARE 6#define ACM_METRIC_COUNT_LOCAL_DRIVERS 20#define ACM_METRIC_COUNT_LOCAL_CODECS 21#define ACM_METRIC_COUNT_LOCAL_CONVERTERS 22#define ACM_METRIC_COUNT_LOCAL_FILTERS 23#define ACM_METRIC_COUNT_LOCAL_DISABLED 24#define ACM_METRIC_HARDWARE_WAVE_INPUT 30#define ACM_METRIC_HARDWARE_WAVE_OUTPUT 31#define ACM_METRIC_MAX_SIZE_FORMAT 50#define ACM_METRIC_MAX_SIZE_FILTER 51#define ACM_METRIC_DRIVER_SUPPORT 100#define ACM_METRIC_DRIVER_PRIORITY 101
//--------------------------------------------------------------------------;//// ACM Drivers//////////--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverEnum()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
typedef BOOL (CALLBACK *ACMDRIVERENUMCB)( HACMDRIVERID hadid, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmDriverEnum( ACMDRIVERENUMCB fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);
#define ACM_DRIVERENUMF_NOLOCAL 0x40000000L#define ACM_DRIVERENUMF_DISABLED 0x80000000L
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverID()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmDriverID( HACMOBJ hao, LPHACMDRIVERID phadid, DWORD fdwDriverID);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverAdd()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32MMRESULT ACMAPI acmDriverAddA( LPHACMDRIVERID phadid, HINSTANCE hinstModule, LPARAM lParam, DWORD dwPriority, DWORD fdwAdd);
MMRESULT ACMAPI acmDriverAddW( LPHACMDRIVERID phadid, HINSTANCE hinstModule, LPARAM lParam, DWORD dwPriority, DWORD fdwAdd);
#ifdef _UNICODE#define acmDriverAdd acmDriverAddW#else#define acmDriverAdd acmDriverAddA#endif#elseMMRESULT ACMAPI acmDriverAdd( LPHACMDRIVERID phadid, HINSTANCE hinstModule, LPARAM lParam, DWORD dwPriority, DWORD fdwAdd);#endif
#define ACM_DRIVERADDF_NAME 0x00000001L#define ACM_DRIVERADDF_FUNCTION 0x00000003L // lParam is a procedure#define ACM_DRIVERADDF_NOTIFYHWND 0x00000004L // lParam is notify hwnd#define ACM_DRIVERADDF_TYPEMASK 0x00000007L // driver type mask#define ACM_DRIVERADDF_LOCAL 0x00000000L // is local to current task#define ACM_DRIVERADDF_GLOBAL 0x00000008L // is global
//// prototype for ACM driver procedures that are installed as _functions_// or _notifations_ instead of as a standalone installable driver.//typedef LRESULT (CALLBACK *ACMDRIVERPROC)(DWORD_PTR, HACMDRIVERID, UINT, LPARAM, LPARAM);typedef ACMDRIVERPROC FAR *LPACMDRIVERPROC;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverRemove()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmDriverRemove( HACMDRIVERID hadid, DWORD fdwRemove);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverOpen()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmDriverOpen( LPHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverClose()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmDriverClose( HACMDRIVER had, DWORD fdwClose);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverMessage()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
LRESULT ACMAPI acmDriverMessage( HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2);
////////#define ACMDM_USER (DRV_USER + 0x0000)#define ACMDM_RESERVED_LOW (DRV_USER + 0x2000)#define ACMDM_RESERVED_HIGH (DRV_USER + 0x2FFF)
#define ACMDM_BASE ACMDM_RESERVED_LOW
#define ACMDM_DRIVER_ABOUT (ACMDM_BASE + 11)
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverPriority//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmDriverPriority( HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority);
#define ACM_DRIVERPRIORITYF_ENABLE 0x00000001L#define ACM_DRIVERPRIORITYF_DISABLE 0x00000002L#define ACM_DRIVERPRIORITYF_ABLEMASK 0x00000003L#define ACM_DRIVERPRIORITYF_BEGIN 0x00010000L#define ACM_DRIVERPRIORITYF_END 0x00020000L#define ACM_DRIVERPRIORITYF_DEFERMASK 0x00030000L
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmDriverDetails()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//// ACMDRIVERDETAILS//// the ACMDRIVERDETAILS structure is used to get various capabilities from// an ACM driver (codec, converter, filter).//#define ACMDRIVERDETAILS_SHORTNAME_CHARS 32#define ACMDRIVERDETAILS_LONGNAME_CHARS 128#define ACMDRIVERDETAILS_COPYRIGHT_CHARS 80#define ACMDRIVERDETAILS_LICENSING_CHARS 128#define ACMDRIVERDETAILS_FEATURES_CHARS 512
#ifdef _WIN32typedef struct tACMDRIVERDETAILSA{ DWORD cbStruct; // number of valid bytes in structure
FOURCC fccType; // compressor type 'audc' FOURCC fccComp; // sub-type (not used; reserved)
WORD wMid; // manufacturer id WORD wPid; // product id
DWORD vdwACM; // version of the ACM *compiled* for DWORD vdwDriver; // version of the driver
DWORD fdwSupport; // misc. support flags DWORD cFormatTags; // total unique format tags supported DWORD cFilterTags; // total unique filter tags supported
HICON hicon; // handle to custom icon
char szShortName[ACMDRIVERDETAILS_SHORTNAME_CHARS]; char szLongName[ACMDRIVERDETAILS_LONGNAME_CHARS]; char szCopyright[ACMDRIVERDETAILS_COPYRIGHT_CHARS]; char szLicensing[ACMDRIVERDETAILS_LICENSING_CHARS]; char szFeatures[ACMDRIVERDETAILS_FEATURES_CHARS];
} ACMDRIVERDETAILSA, *PACMDRIVERDETAILSA, FAR *LPACMDRIVERDETAILSA;
typedef struct tACMDRIVERDETAILSW{ DWORD cbStruct; // number of valid bytes in structure
FOURCC fccType; // compressor type 'audc' FOURCC fccComp; // sub-type (not used; reserved)
WORD wMid; // manufacturer id WORD wPid; // product id
DWORD vdwACM; // version of the ACM *compiled* for DWORD vdwDriver; // version of the driver
DWORD fdwSupport; // misc. support flags DWORD cFormatTags; // total unique format tags supported DWORD cFilterTags; // total unique filter tags supported
HICON hicon; // handle to custom icon
WCHAR szShortName[ACMDRIVERDETAILS_SHORTNAME_CHARS]; WCHAR szLongName[ACMDRIVERDETAILS_LONGNAME_CHARS]; WCHAR szCopyright[ACMDRIVERDETAILS_COPYRIGHT_CHARS]; WCHAR szLicensing[ACMDRIVERDETAILS_LICENSING_CHARS]; WCHAR szFeatures[ACMDRIVERDETAILS_FEATURES_CHARS];
} ACMDRIVERDETAILSW, *PACMDRIVERDETAILSW, FAR *LPACMDRIVERDETAILSW;
#ifdef _UNICODE#define ACMDRIVERDETAILS ACMDRIVERDETAILSW#define PACMDRIVERDETAILS PACMDRIVERDETAILSW#define LPACMDRIVERDETAILS LPACMDRIVERDETAILSW#else#define ACMDRIVERDETAILS ACMDRIVERDETAILSA#define PACMDRIVERDETAILS PACMDRIVERDETAILSA#define LPACMDRIVERDETAILS LPACMDRIVERDETAILSA#endif#elsetypedef struct tACMDRIVERDETAILS{ DWORD cbStruct; // number of valid bytes in structure
FOURCC fccType; // compressor type 'audc' FOURCC fccComp; // sub-type (not used; reserved)
WORD wMid; // manufacturer id WORD wPid; // product id
DWORD vdwACM; // version of the ACM *compiled* for DWORD vdwDriver; // version of the driver
DWORD fdwSupport; // misc. support flags DWORD cFormatTags; // total unique format tags supported DWORD cFilterTags; // total unique filter tags supported
HICON hicon; // handle to custom icon
char szShortName[ACMDRIVERDETAILS_SHORTNAME_CHARS]; char szLongName[ACMDRIVERDETAILS_LONGNAME_CHARS]; char szCopyright[ACMDRIVERDETAILS_COPYRIGHT_CHARS]; char szLicensing[ACMDRIVERDETAILS_LICENSING_CHARS]; char szFeatures[ACMDRIVERDETAILS_FEATURES_CHARS];
} ACMDRIVERDETAILS, *PACMDRIVERDETAILS, FAR *LPACMDRIVERDETAILS;#endif
//// 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.//#define ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC mmioFOURCC('a', 'u', 'd', 'c')#define ACMDRIVERDETAILS_FCCCOMP_UNDEFINED mmioFOURCC('\0', '\0', '\0', '\0')
//// 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.//#define ACMDRIVERDETAILS_SUPPORTF_CODEC 0x00000001L#define ACMDRIVERDETAILS_SUPPORTF_CONVERTER 0x00000002L#define ACMDRIVERDETAILS_SUPPORTF_FILTER 0x00000004L#define ACMDRIVERDETAILS_SUPPORTF_HARDWARE 0x00000008L#define ACMDRIVERDETAILS_SUPPORTF_ASYNC 0x00000010L#define ACMDRIVERDETAILS_SUPPORTF_LOCAL 0x40000000L#define ACMDRIVERDETAILS_SUPPORTF_DISABLED 0x80000000L
#ifdef _WIN32MMRESULT ACMAPI acmDriverDetailsA( HACMDRIVERID hadid, LPACMDRIVERDETAILSA padd, DWORD fdwDetails);
MMRESULT ACMAPI acmDriverDetailsW( HACMDRIVERID hadid, LPACMDRIVERDETAILSW padd, DWORD fdwDetails);
#ifdef _UNICODE#define acmDriverDetails acmDriverDetailsW#else#define acmDriverDetails acmDriverDetailsA#endif#elseMMRESULT ACMAPI acmDriverDetails( HACMDRIVERID hadid, LPACMDRIVERDETAILS padd, DWORD fdwDetails);#endif
//--------------------------------------------------------------------------;//// ACM Format Tags//////////--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFormatTagDetails()////////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define ACMFORMATTAGDETAILS_FORMATTAG_CHARS 48
#ifdef _WIN32typedef struct tACMFORMATTAGDETAILSA{ DWORD cbStruct; DWORD dwFormatTagIndex; DWORD dwFormatTag; DWORD cbFormatSize; DWORD fdwSupport; DWORD cStandardFormats; char szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
} ACMFORMATTAGDETAILSA, *PACMFORMATTAGDETAILSA, FAR *LPACMFORMATTAGDETAILSA;
typedef struct tACMFORMATTAGDETAILSW{ DWORD cbStruct; DWORD dwFormatTagIndex; DWORD dwFormatTag; DWORD cbFormatSize; DWORD fdwSupport; DWORD cStandardFormats; WCHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
} ACMFORMATTAGDETAILSW, *PACMFORMATTAGDETAILSW, FAR *LPACMFORMATTAGDETAILSW;
#ifdef _UNICODE#define ACMFORMATTAGDETAILS ACMFORMATTAGDETAILSW#define PACMFORMATTAGDETAILS PACMFORMATTAGDETAILSW#define LPACMFORMATTAGDETAILS LPACMFORMATTAGDETAILSW#else#define ACMFORMATTAGDETAILS ACMFORMATTAGDETAILSA#define PACMFORMATTAGDETAILS PACMFORMATTAGDETAILSA#define LPACMFORMATTAGDETAILS LPACMFORMATTAGDETAILSA#endif#elsetypedef struct tACMFORMATTAGDETAILS{ DWORD cbStruct; DWORD dwFormatTagIndex; DWORD dwFormatTag; DWORD cbFormatSize; DWORD fdwSupport; DWORD cStandardFormats; char szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
} ACMFORMATTAGDETAILS, *PACMFORMATTAGDETAILS, FAR *LPACMFORMATTAGDETAILS;#endif
#ifdef _WIN32MMRESULT ACMAPI acmFormatTagDetailsA( HACMDRIVER had, LPACMFORMATTAGDETAILSA paftd, DWORD fdwDetails);
MMRESULT ACMAPI acmFormatTagDetailsW( HACMDRIVER had, LPACMFORMATTAGDETAILSW paftd, DWORD fdwDetails);
#ifdef _UNICODE#define acmFormatTagDetails acmFormatTagDetailsW#else#define acmFormatTagDetails acmFormatTagDetailsA#endif#elseMMRESULT ACMAPI acmFormatTagDetails( HACMDRIVER had, LPACMFORMATTAGDETAILS paftd, DWORD fdwDetails);#endif
#define ACM_FORMATTAGDETAILSF_INDEX 0x00000000L#define ACM_FORMATTAGDETAILSF_FORMATTAG 0x00000001L#define ACM_FORMATTAGDETAILSF_LARGESTSIZE 0x00000002L#define ACM_FORMATTAGDETAILSF_QUERYMASK 0x0000000FL
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFormatTagEnum()////////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32typedef BOOL (CALLBACK *ACMFORMATTAGENUMCBA)( HACMDRIVERID hadid, LPACMFORMATTAGDETAILSA paftd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFormatTagEnumA( HACMDRIVER had, LPACMFORMATTAGDETAILSA paftd, ACMFORMATTAGENUMCBA fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);typedef BOOL (CALLBACK *ACMFORMATTAGENUMCBW)( HACMDRIVERID hadid, LPACMFORMATTAGDETAILSW paftd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFormatTagEnumW( HACMDRIVER had, LPACMFORMATTAGDETAILSW paftd, ACMFORMATTAGENUMCBW fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);
#ifdef _UNICODE#define ACMFORMATTAGENUMCB ACMFORMATTAGENUMCBW#define acmFormatTagEnum acmFormatTagEnumW#else#define ACMFORMATTAGENUMCB ACMFORMATTAGENUMCBA#define acmFormatTagEnum acmFormatTagEnumA#endif#elsetypedef BOOL (CALLBACK *ACMFORMATTAGENUMCB)( HACMDRIVERID hadid, LPACMFORMATTAGDETAILS paftd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFormatTagEnum( HACMDRIVER had, LPACMFORMATTAGDETAILS paftd, ACMFORMATTAGENUMCB fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);#endif
//--------------------------------------------------------------------------;//// ACM Formats//////////--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFormatDetails()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define ACMFORMATDETAILS_FORMAT_CHARS 128
#ifdef _WIN32typedef struct tACMFORMATDETAILSA{ DWORD cbStruct; DWORD dwFormatIndex; DWORD dwFormatTag; DWORD fdwSupport; LPWAVEFORMATEX pwfx; DWORD cbwfx; char szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
} ACMFORMATDETAILSA, *PACMFORMATDETAILSA, FAR *LPACMFORMATDETAILSA;
typedef struct tACMFORMATDETAILSW{ DWORD cbStruct; DWORD dwFormatIndex; DWORD dwFormatTag; DWORD fdwSupport; LPWAVEFORMATEX pwfx; DWORD cbwfx; WCHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
} ACMFORMATDETAILSW, *PACMFORMATDETAILSW, FAR *LPACMFORMATDETAILSW;
#ifdef _UNICODE#define ACMFORMATDETAILS ACMFORMATDETAILSW#define PACMFORMATDETAILS PACMFORMATDETAILSW#define LPACMFORMATDETAILS LPACMFORMATDETAILSW#else#define ACMFORMATDETAILS ACMFORMATDETAILSA#define PACMFORMATDETAILS PACMFORMATDETAILSA#define LPACMFORMATDETAILS LPACMFORMATDETAILSA#endif#elsetypedef struct tACMFORMATDETAILS{ DWORD cbStruct; DWORD dwFormatIndex; DWORD dwFormatTag; DWORD fdwSupport; LPWAVEFORMATEX pwfx; DWORD cbwfx; char szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
} ACMFORMATDETAILS, *PACMFORMATDETAILS, FAR *LPACMFORMATDETAILS;#endif
#ifdef _WIN32MMRESULT ACMAPI acmFormatDetailsA( HACMDRIVER had, LPACMFORMATDETAILSA pafd, DWORD fdwDetails);
MMRESULT ACMAPI acmFormatDetailsW( HACMDRIVER had, LPACMFORMATDETAILSW pafd, DWORD fdwDetails);
#ifdef _UNICODE#define acmFormatDetails acmFormatDetailsW#else#define acmFormatDetails acmFormatDetailsA#endif#elseMMRESULT ACMAPI acmFormatDetails( HACMDRIVER had, LPACMFORMATDETAILS pafd, DWORD fdwDetails);#endif
#define ACM_FORMATDETAILSF_INDEX 0x00000000L#define ACM_FORMATDETAILSF_FORMAT 0x00000001L#define ACM_FORMATDETAILSF_QUERYMASK 0x0000000FL
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFormatEnum()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32typedef BOOL (CALLBACK *ACMFORMATENUMCBA)( HACMDRIVERID hadid, LPACMFORMATDETAILSA pafd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFormatEnumA( HACMDRIVER had, LPACMFORMATDETAILSA pafd, ACMFORMATENUMCBA fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);
typedef BOOL (CALLBACK *ACMFORMATENUMCBW)( HACMDRIVERID hadid, LPACMFORMATDETAILSW pafd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFormatEnumW( HACMDRIVER had, LPACMFORMATDETAILSW pafd, ACMFORMATENUMCBW fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);
#ifdef _UNICODE#define ACMFORMATENUMCB ACMFORMATENUMCBW#define acmFormatEnum acmFormatEnumW#else#define ACMFORMATENUMCB ACMFORMATENUMCBA#define acmFormatEnum acmFormatEnumA#endif#elsetypedef BOOL (CALLBACK *ACMFORMATENUMCB)( HACMDRIVERID hadid, LPACMFORMATDETAILS pafd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFormatEnum( HACMDRIVER had, LPACMFORMATDETAILS pafd, ACMFORMATENUMCB fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);#endif
#define ACM_FORMATENUMF_WFORMATTAG 0x00010000L#define ACM_FORMATENUMF_NCHANNELS 0x00020000L#define ACM_FORMATENUMF_NSAMPLESPERSEC 0x00040000L#define ACM_FORMATENUMF_WBITSPERSAMPLE 0x00080000L#define ACM_FORMATENUMF_CONVERT 0x00100000L#define ACM_FORMATENUMF_SUGGEST 0x00200000L#define ACM_FORMATENUMF_HARDWARE 0x00400000L#define ACM_FORMATENUMF_INPUT 0x00800000L#define ACM_FORMATENUMF_OUTPUT 0x01000000L
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFormatSuggest()////////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmFormatSuggest( HACMDRIVER had, LPWAVEFORMATEX pwfxSrc, LPWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest);
#define ACM_FORMATSUGGESTF_WFORMATTAG 0x00010000L#define ACM_FORMATSUGGESTF_NCHANNELS 0x00020000L#define ACM_FORMATSUGGESTF_NSAMPLESPERSEC 0x00040000L#define ACM_FORMATSUGGESTF_WBITSPERSAMPLE 0x00080000L
#define ACM_FORMATSUGGESTF_TYPEMASK 0x00FF0000L
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFormatChoose()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32#define ACMHELPMSGSTRINGA "acmchoose_help"#define ACMHELPMSGSTRINGW L"acmchoose_help"#define ACMHELPMSGCONTEXTMENUA "acmchoose_contextmenu"#define ACMHELPMSGCONTEXTMENUW L"acmchoose_contextmenu"#define ACMHELPMSGCONTEXTHELPA "acmchoose_contexthelp"#define ACMHELPMSGCONTEXTHELPW L"acmchoose_contexthelp"#ifdef _UNICODE#define ACMHELPMSGSTRING ACMHELPMSGSTRINGW#define ACMHELPMSGCONTEXTMENU ACMHELPMSGCONTEXTMENUW#define ACMHELPMSGCONTEXTHELP ACMHELPMSGCONTEXTHELPW#else#define ACMHELPMSGSTRING ACMHELPMSGSTRINGA#define ACMHELPMSGCONTEXTMENU ACMHELPMSGCONTEXTMENUA#define ACMHELPMSGCONTEXTHELP ACMHELPMSGCONTEXTHELPA#endif#else#define ACMHELPMSGSTRING "acmchoose_help"#define ACMHELPMSGCONTEXTMENU "acmchoose_contextmenu"#define ACMHELPMSGCONTEXTHELP "acmchoose_contexthelp"#endif
//// MM_ACM_FORMATCHOOSE is sent to hook callbacks by the Format Chooser// Dialog...//#define MM_ACM_FORMATCHOOSE (0x8000)
#define FORMATCHOOSE_MESSAGE 0#define FORMATCHOOSE_FORMATTAG_VERIFY (FORMATCHOOSE_MESSAGE+0)#define FORMATCHOOSE_FORMAT_VERIFY (FORMATCHOOSE_MESSAGE+1)#define FORMATCHOOSE_CUSTOM_VERIFY (FORMATCHOOSE_MESSAGE+2)
#ifdef _WIN32typedef UINT (CALLBACK *ACMFORMATCHOOSEHOOKPROCA)( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef UINT (CALLBACK *ACMFORMATCHOOSEHOOKPROCW)( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
#ifdef _UNICODE#define ACMFORMATCHOOSEHOOKPROC ACMFORMATCHOOSEHOOKPROCW#else#define ACMFORMATCHOOSEHOOKPROC ACMFORMATCHOOSEHOOKPROCA#endif#elsetypedef UINT (CALLBACK *ACMFORMATCHOOSEHOOKPROC)( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);#endif
////////#ifdef _WIN32typedef struct tACMFORMATCHOOSEA{ DWORD cbStruct; // sizeof(ACMFORMATCHOOSE) DWORD fdwStyle; // chooser style flags
HWND hwndOwner; // caller's window handle
LPWAVEFORMATEX pwfx; // ptr to wfx buf to receive choice DWORD cbwfx; // size of mem buf for pwfx LPCSTR pszTitle; // dialog box title bar
char szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; char szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
LPSTR pszName; // custom name selection DWORD cchName; // size in chars of mem buf for pszName
DWORD fdwEnum; // format enumeration restrictions LPWAVEFORMATEX pwfxEnum; // format describing restrictions
HINSTANCE hInstance; // app instance containing dlg template LPCSTR pszTemplateName; // custom template name LPARAM lCustData; // data passed to hook fn. ACMFORMATCHOOSEHOOKPROCA pfnHook; // ptr to hook function
} ACMFORMATCHOOSEA, *PACMFORMATCHOOSEA, FAR *LPACMFORMATCHOOSEA;
typedef struct tACMFORMATCHOOSEW{ DWORD cbStruct; // sizeof(ACMFORMATCHOOSE) DWORD fdwStyle; // chooser style flags
HWND hwndOwner; // caller's window handle
LPWAVEFORMATEX pwfx; // ptr to wfx buf to receive choice DWORD cbwfx; // size of mem buf for pwfx LPCWSTR pszTitle; // dialog box title bar
WCHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; WCHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
LPWSTR pszName; // custom name selection DWORD cchName; // size in chars of mem buf for pszName
DWORD fdwEnum; // format enumeration restrictions LPWAVEFORMATEX pwfxEnum; // format describing restrictions
HINSTANCE hInstance; // app instance containing dlg template LPCWSTR pszTemplateName; // custom template name LPARAM lCustData; // data passed to hook fn. ACMFORMATCHOOSEHOOKPROCW pfnHook; // ptr to hook function
} ACMFORMATCHOOSEW, *PACMFORMATCHOOSEW, FAR *LPACMFORMATCHOOSEW;
#ifdef _UNICODE#define ACMFORMATCHOOSE ACMFORMATCHOOSEW#define PACMFORMATCHOOSE PACMFORMATCHOOSEW#define LPACMFORMATCHOOSE LPACMFORMATCHOOSEW#else#define ACMFORMATCHOOSE ACMFORMATCHOOSEA#define PACMFORMATCHOOSE PACMFORMATCHOOSEA#define LPACMFORMATCHOOSE LPACMFORMATCHOOSEA#endif#elsetypedef struct tACMFORMATCHOOSE{ DWORD cbStruct; // sizeof(ACMFORMATCHOOSE) DWORD fdwStyle; // chooser style flags
HWND hwndOwner; // caller's window handle
LPWAVEFORMATEX pwfx; // ptr to wfx buf to receive choice DWORD cbwfx; // size of mem buf for pwfx LPCSTR pszTitle; // dialog box title bar
char szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; char szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
LPSTR pszName; // custom name selection DWORD cchName; // size in chars of mem buf for pszName
DWORD fdwEnum; // format enumeration restrictions LPWAVEFORMATEX pwfxEnum; // format describing restrictions
HINSTANCE hInstance; // app instance containing dlg template LPCSTR pszTemplateName; // custom template name LPARAM lCustData; // data passed to hook fn. ACMFORMATCHOOSEHOOKPROC pfnHook; // ptr to hook function
} ACMFORMATCHOOSE, *PACMFORMATCHOOSE, FAR *LPACMFORMATCHOOSE;#endif
//// ACMFORMATCHOOSE.fdwStyle//////#define ACMFORMATCHOOSE_STYLEF_SHOWHELP 0x00000004L#define ACMFORMATCHOOSE_STYLEF_ENABLEHOOK 0x00000008L#define ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE 0x00000010L#define ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE 0x00000020L#define ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT 0x00000040L#define ACMFORMATCHOOSE_STYLEF_CONTEXTHELP 0x00000080L
#ifdef _WIN32MMRESULT ACMAPI acmFormatChooseA( LPACMFORMATCHOOSEA pafmtc);
MMRESULT ACMAPI acmFormatChooseW( LPACMFORMATCHOOSEW pafmtc);
#ifdef _UNICODE#define acmFormatChoose acmFormatChooseW#else#define acmFormatChoose acmFormatChooseA#endif#elseMMRESULT ACMAPI acmFormatChoose( LPACMFORMATCHOOSE pafmtc);#endif
//--------------------------------------------------------------------------;//// ACM Filter Tags//////////--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFilterTagDetails()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define ACMFILTERTAGDETAILS_FILTERTAG_CHARS 48
#ifdef _WIN32typedef struct tACMFILTERTAGDETAILSA{ DWORD cbStruct; DWORD dwFilterTagIndex; DWORD dwFilterTag; DWORD cbFilterSize; DWORD fdwSupport; DWORD cStandardFilters; char szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS];
} ACMFILTERTAGDETAILSA, *PACMFILTERTAGDETAILSA, FAR *LPACMFILTERTAGDETAILSA;
typedef struct tACMFILTERTAGDETAILSW{ DWORD cbStruct; DWORD dwFilterTagIndex; DWORD dwFilterTag; DWORD cbFilterSize; DWORD fdwSupport; DWORD cStandardFilters; WCHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS];
} ACMFILTERTAGDETAILSW, *PACMFILTERTAGDETAILSW, FAR *LPACMFILTERTAGDETAILSW;
#ifdef _UNICODE#define ACMFILTERTAGDETAILS ACMFILTERTAGDETAILSW#define PACMFILTERTAGDETAILS PACMFILTERTAGDETAILSW#define LPACMFILTERTAGDETAILS LPACMFILTERTAGDETAILSW#else#define ACMFILTERTAGDETAILS ACMFILTERTAGDETAILSA#define PACMFILTERTAGDETAILS PACMFILTERTAGDETAILSA#define LPACMFILTERTAGDETAILS LPACMFILTERTAGDETAILSA#endif#elsetypedef struct tACMFILTERTAGDETAILS{ DWORD cbStruct; DWORD dwFilterTagIndex; DWORD dwFilterTag; DWORD cbFilterSize; DWORD fdwSupport; DWORD cStandardFilters; char szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS];
} ACMFILTERTAGDETAILS, *PACMFILTERTAGDETAILS, FAR *LPACMFILTERTAGDETAILS;#endif
#ifdef _WIN32MMRESULT ACMAPI acmFilterTagDetailsA( HACMDRIVER had, LPACMFILTERTAGDETAILSA paftd, DWORD fdwDetails);
MMRESULT ACMAPI acmFilterTagDetailsW( HACMDRIVER had, LPACMFILTERTAGDETAILSW paftd, DWORD fdwDetails);
#ifdef _UNICODE#define acmFilterTagDetails acmFilterTagDetailsW#else#define acmFilterTagDetails acmFilterTagDetailsA#endif#elseMMRESULT ACMAPI acmFilterTagDetails( HACMDRIVER had, LPACMFILTERTAGDETAILS paftd, DWORD fdwDetails);#endif
#define ACM_FILTERTAGDETAILSF_INDEX 0x00000000L#define ACM_FILTERTAGDETAILSF_FILTERTAG 0x00000001L#define ACM_FILTERTAGDETAILSF_LARGESTSIZE 0x00000002L#define ACM_FILTERTAGDETAILSF_QUERYMASK 0x0000000FL
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFilterTagEnum()////////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32typedef BOOL (CALLBACK *ACMFILTERTAGENUMCBA)( HACMDRIVERID hadid, LPACMFILTERTAGDETAILSA paftd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFilterTagEnumA( HACMDRIVER had, LPACMFILTERTAGDETAILSA paftd, ACMFILTERTAGENUMCBA fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);
typedef BOOL (CALLBACK *ACMFILTERTAGENUMCBW)( HACMDRIVERID hadid, LPACMFILTERTAGDETAILSW paftd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFilterTagEnumW( HACMDRIVER had, LPACMFILTERTAGDETAILSW paftd, ACMFILTERTAGENUMCBW fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);
#ifdef _UNICODE#define ACMFILTERTAGENUMCB ACMFILTERTAGENUMCBW#define acmFilterTagEnum acmFilterTagEnumW#else#define ACMFILTERTAGENUMCB ACMFILTERTAGENUMCBA#define acmFilterTagEnum acmFilterTagEnumA#endif#elsetypedef BOOL (CALLBACK *ACMFILTERTAGENUMCB)( HACMDRIVERID hadid, LPACMFILTERTAGDETAILS paftd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFilterTagEnum( HACMDRIVER had, LPACMFILTERTAGDETAILS paftd, ACMFILTERTAGENUMCB fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);#endif
//--------------------------------------------------------------------------;//// ACM Filters//////////--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFilterDetails()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define ACMFILTERDETAILS_FILTER_CHARS 128
#ifdef _WIN32typedef struct tACMFILTERDETAILSA{ DWORD cbStruct; DWORD dwFilterIndex; DWORD dwFilterTag; DWORD fdwSupport; LPWAVEFILTER pwfltr; DWORD cbwfltr; char szFilter[ACMFILTERDETAILS_FILTER_CHARS];
} ACMFILTERDETAILSA, *PACMFILTERDETAILSA, FAR *LPACMFILTERDETAILSA;
typedef struct tACMFILTERDETAILSW{ DWORD cbStruct; DWORD dwFilterIndex; DWORD dwFilterTag; DWORD fdwSupport; LPWAVEFILTER pwfltr; DWORD cbwfltr; WCHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS];
} ACMFILTERDETAILSW, *PACMFILTERDETAILSW, FAR *LPACMFILTERDETAILSW;
#ifdef _UNICODE#define ACMFILTERDETAILS ACMFILTERDETAILSW#define PACMFILTERDETAILS PACMFILTERDETAILSW#define LPACMFILTERDETAILS LPACMFILTERDETAILSW#else#define ACMFILTERDETAILS ACMFILTERDETAILSA#define PACMFILTERDETAILS PACMFILTERDETAILSA#define LPACMFILTERDETAILS LPACMFILTERDETAILSA#endif#elsetypedef struct tACMFILTERDETAILS{ DWORD cbStruct; DWORD dwFilterIndex; DWORD dwFilterTag; DWORD fdwSupport; LPWAVEFILTER pwfltr; DWORD cbwfltr; char szFilter[ACMFILTERDETAILS_FILTER_CHARS];
} ACMFILTERDETAILS, *PACMFILTERDETAILS, FAR *LPACMFILTERDETAILS;#endif
#ifdef _WIN32MMRESULT ACMAPI acmFilterDetailsA( HACMDRIVER had, LPACMFILTERDETAILSA pafd, DWORD fdwDetails);
MMRESULT ACMAPI acmFilterDetailsW( HACMDRIVER had, LPACMFILTERDETAILSW pafd, DWORD fdwDetails);#ifdef _UNICODE#define acmFilterDetails acmFilterDetailsW#else#define acmFilterDetails acmFilterDetailsA#endif#elseMMRESULT ACMAPI acmFilterDetails( HACMDRIVER had, LPACMFILTERDETAILS pafd, DWORD fdwDetails);#endif
#define ACM_FILTERDETAILSF_INDEX 0x00000000L#define ACM_FILTERDETAILSF_FILTER 0x00000001L#define ACM_FILTERDETAILSF_QUERYMASK 0x0000000FL
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFilterEnum()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32typedef BOOL (CALLBACK *ACMFILTERENUMCBA)( HACMDRIVERID hadid, LPACMFILTERDETAILSA pafd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFilterEnumA( HACMDRIVER had, LPACMFILTERDETAILSA pafd, ACMFILTERENUMCBA fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);
typedef BOOL (CALLBACK *ACMFILTERENUMCBW)( HACMDRIVERID hadid, LPACMFILTERDETAILSW pafd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFilterEnumW( HACMDRIVER had, LPACMFILTERDETAILSW pafd, ACMFILTERENUMCBW fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);
#ifdef _UNICODE#define ACMFILTERENUMCB ACMFILTERENUMCBW#define acmFilterEnum acmFilterEnumW#else#define ACMFILTERENUMCB ACMFILTERENUMCBA#define acmFilterEnum acmFilterEnumA#endif#elsetypedef BOOL (CALLBACK *ACMFILTERENUMCB)( HACMDRIVERID hadid, LPACMFILTERDETAILS pafd, DWORD_PTR dwInstance, DWORD fdwSupport);
MMRESULT ACMAPI acmFilterEnum( HACMDRIVER had, LPACMFILTERDETAILS pafd, ACMFILTERENUMCB fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum);#endif
#define ACM_FILTERENUMF_DWFILTERTAG 0x00010000L
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmFilterChoose()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//// MM_ACM_FILTERCHOOSE is sent to hook callbacks by the Filter Chooser// Dialog...//#define MM_ACM_FILTERCHOOSE (0x8000)
#define FILTERCHOOSE_MESSAGE 0#define FILTERCHOOSE_FILTERTAG_VERIFY (FILTERCHOOSE_MESSAGE+0)#define FILTERCHOOSE_FILTER_VERIFY (FILTERCHOOSE_MESSAGE+1)#define FILTERCHOOSE_CUSTOM_VERIFY (FILTERCHOOSE_MESSAGE+2)
#ifdef _WIN32typedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROCA)( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROCW)( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
#ifdef _UNICODE#define ACMFILTERCHOOSEHOOKPROC ACMFILTERCHOOSEHOOKPROCW#else#define ACMFILTERCHOOSEHOOKPROC ACMFILTERCHOOSEHOOKPROCA#endif#elsetypedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROC)( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);#endif
//// ACMFILTERCHOOSE////#ifdef _WIN32typedef struct tACMFILTERCHOOSEA{ DWORD cbStruct; // sizeof(ACMFILTERCHOOSE) DWORD fdwStyle; // chooser style flags
HWND hwndOwner; // caller's window handle
LPWAVEFILTER pwfltr; // ptr to wfltr buf to receive choice DWORD cbwfltr; // size of mem buf for pwfltr
LPCSTR pszTitle;
char szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; char szFilter[ACMFILTERDETAILS_FILTER_CHARS]; LPSTR pszName; // custom name selection DWORD cchName; // size in chars of mem buf for pszName
DWORD fdwEnum; // filter enumeration restrictions LPWAVEFILTER pwfltrEnum; // filter describing restrictions
HINSTANCE hInstance; // app instance containing dlg template LPCSTR pszTemplateName; // custom template name LPARAM lCustData; // data passed to hook fn. ACMFILTERCHOOSEHOOKPROCA pfnHook; // ptr to hook function
} ACMFILTERCHOOSEA, *PACMFILTERCHOOSEA, FAR *LPACMFILTERCHOOSEA;
typedef struct tACMFILTERCHOOSEW{ DWORD cbStruct; // sizeof(ACMFILTERCHOOSE) DWORD fdwStyle; // chooser style flags
HWND hwndOwner; // caller's window handle
LPWAVEFILTER pwfltr; // ptr to wfltr buf to receive choice DWORD cbwfltr; // size of mem buf for pwfltr
LPCWSTR pszTitle;
WCHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; WCHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS]; LPWSTR pszName; // custom name selection DWORD cchName; // size in chars of mem buf for pszName
DWORD fdwEnum; // filter enumeration restrictions LPWAVEFILTER pwfltrEnum; // filter describing restrictions
HINSTANCE hInstance; // app instance containing dlg template LPCWSTR pszTemplateName; // custom template name LPARAM lCustData; // data passed to hook fn. ACMFILTERCHOOSEHOOKPROCW pfnHook; // ptr to hook function
} ACMFILTERCHOOSEW, *PACMFILTERCHOOSEW, FAR *LPACMFILTERCHOOSEW;
#ifdef _UNICODE#define ACMFILTERCHOOSE ACMFILTERCHOOSEW#define PACMFILTERCHOOSE PACMFILTERCHOOSEW#define LPACMFILTERCHOOSE LPACMFILTERCHOOSEW#else#define ACMFILTERCHOOSE ACMFILTERCHOOSEA#define PACMFILTERCHOOSE PACMFILTERCHOOSEA#define LPACMFILTERCHOOSE LPACMFILTERCHOOSEA#endif#elsetypedef struct tACMFILTERCHOOSE{ DWORD cbStruct; // sizeof(ACMFILTERCHOOSE) DWORD fdwStyle; // chooser style flags
HWND hwndOwner; // caller's window handle
LPWAVEFILTER pwfltr; // ptr to wfltr buf to receive choice DWORD cbwfltr; // size of mem buf for pwfltr
LPCSTR pszTitle;
char szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; char szFilter[ACMFILTERDETAILS_FILTER_CHARS]; LPSTR pszName; // custom name selection DWORD cchName; // size in chars of mem buf for pszName
DWORD fdwEnum; // filter enumeration restrictions LPWAVEFILTER pwfltrEnum; // filter describing restrictions
HINSTANCE hInstance; // app instance containing dlg template LPCSTR pszTemplateName; // custom template name LPARAM lCustData; // data passed to hook fn. ACMFILTERCHOOSEHOOKPROC pfnHook; // ptr to hook function
} ACMFILTERCHOOSE, *PACMFILTERCHOOSE, FAR *LPACMFILTERCHOOSE;#endif
//// ACMFILTERCHOOSE.fdwStyle////#define ACMFILTERCHOOSE_STYLEF_SHOWHELP 0x00000004L#define ACMFILTERCHOOSE_STYLEF_ENABLEHOOK 0x00000008L#define ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE 0x00000010L#define ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE 0x00000020L#define ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT 0x00000040L#define ACMFILTERCHOOSE_STYLEF_CONTEXTHELP 0x00000080L
#ifdef _WIN32MMRESULT ACMAPI acmFilterChooseA( LPACMFILTERCHOOSEA pafltrc);
MMRESULT ACMAPI acmFilterChooseW( LPACMFILTERCHOOSEW pafltrc);
#ifdef _UNICODE#define acmFilterChoose acmFilterChooseW#else#define acmFilterChoose acmFilterChooseA#endif#elseMMRESULT ACMAPI acmFilterChoose( LPACMFILTERCHOOSE pafltrc);#endif
//--------------------------------------------------------------------------;//// ACM Stream API's////////--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmStreamOpen()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;#ifdef _WIN64#define _DRVRESERVED 15#else#define _DRVRESERVED 10#endif // _WIN64
typedef struct tACMSTREAMHEADER{ DWORD cbStruct; // sizeof(ACMSTREAMHEADER) DWORD fdwStatus; // ACMSTREAMHEADER_STATUSF_* DWORD_PTR dwUser; // user instance data for hdr LPBYTE pbSrc; DWORD cbSrcLength; DWORD cbSrcLengthUsed; DWORD_PTR dwSrcUser; // user instance data for src LPBYTE pbDst; DWORD cbDstLength; DWORD cbDstLengthUsed; DWORD_PTR dwDstUser; // user instance data for dst DWORD dwReservedDriver[_DRVRESERVED]; // driver reserved work space
} ACMSTREAMHEADER, *PACMSTREAMHEADER, FAR *LPACMSTREAMHEADER;
//// ACMSTREAMHEADER.fdwStatus//// ACMSTREAMHEADER_STATUSF_DONE: done bit for async conversions.//#define ACMSTREAMHEADER_STATUSF_DONE 0x00010000L#define ACMSTREAMHEADER_STATUSF_PREPARED 0x00020000L#define ACMSTREAMHEADER_STATUSF_INQUEUE 0x00100000L
MMRESULT ACMAPI acmStreamOpen( LPHACMSTREAM phas, // pointer to stream handle HACMDRIVER had, // optional driver handle LPWAVEFORMATEX pwfxSrc, // source format to convert LPWAVEFORMATEX pwfxDst, // required destination format LPWAVEFILTER pwfltr, // optional filter DWORD_PTR dwCallback, // callback DWORD_PTR dwInstance, // callback instance data DWORD fdwOpen // ACM_STREAMOPENF_* and CALLBACK_*);
#define ACM_STREAMOPENF_QUERY 0x00000001#define ACM_STREAMOPENF_ASYNC 0x00000002#define ACM_STREAMOPENF_NONREALTIME 0x00000004
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmStreamClose()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamClose( HACMSTREAM has, DWORD fdwClose);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmStreamSize()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamSize( HACMSTREAM has, DWORD cbInput, LPDWORD pdwOutputBytes, DWORD fdwSize);
#define ACM_STREAMSIZEF_SOURCE 0x00000000L#define ACM_STREAMSIZEF_DESTINATION 0x00000001L#define ACM_STREAMSIZEF_QUERYMASK 0x0000000FL
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmStreamReset()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamReset( HACMSTREAM has, DWORD fdwReset);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmStreamMessage()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamMessage( HACMSTREAM has, UINT uMsg, LPARAM lParam1, LPARAM lParam2);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmStreamConvert()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamConvert( HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwConvert);
#define ACM_STREAMCONVERTF_BLOCKALIGN 0x00000004#define ACM_STREAMCONVERTF_START 0x00000010#define ACM_STREAMCONVERTF_END 0x00000020
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmStreamPrepareHeader()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamPrepareHeader( HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwPrepare);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;//// acmStreamUnprepareHeader()//////- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamUnprepareHeader( HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwUnprepare);
#include "poppack.h" /* Revert to default packing */
#ifdef __cplusplus} /* End of extern "C" { */#endif /* __cplusplus */
#endif /* _INC_ACM */
|
