|
|
//==========================================================================;
//
// msacm.h
//
// Copyright (c) 1992-2002 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 __cplusplus
extern "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_NOTIFY 0x10000000L // ;Internal
#define ACM_DRIVERENUMF_REMOVED 0x20000000L // ;Internal
#define ACM_DRIVERENUMF_NOLOCAL 0x40000000L
#define ACM_DRIVERENUMF_DISABLED 0x80000000L
#define ACM_DRIVERENUMF_VALID 0xF0000000L // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverID()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmDriverID( HACMOBJ hao, LPHACMDRIVERID phadid, DWORD fdwDriverID);
#define ACM_DRIVERIDF_VALID (0L) /* ;Internal */
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverAdd()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32
MMRESULT 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
#else
MMRESULT ACMAPI acmDriverAdd( LPHACMDRIVERID phadid, HINSTANCE hinstModule, LPARAM lParam, DWORD dwPriority, DWORD fdwAdd);#endif
#define ACM_DRIVERADDF_NAME 0x00000001L
#define ACM_DRIVERADDF_NOTIFY 0x00000002L // ;Internal
#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
#define ACM_DRIVERADDF_32BIT 0x80000000L // ;Internal
#define ACM_DRIVERADDF_PNP 0x40000000L // ;Internal
#define ACM_DRIVERADDF_VALID (ACM_DRIVERADDF_TYPEMASK | /* ;Internal */ \
ACM_DRIVERADDF_GLOBAL) /* ;Internal */
//
// 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);
#define ACM_DRIVERREMOVEF_UNINSTALL 0x00000001L // ;Internal
#define ACM_DRIVERREMOVEF_VALID (1L) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverOpen()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmDriverOpen( LPHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen);
#define ACM_DRIVEROPENF_VALID (0L) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmDriverClose()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmDriverClose( HACMDRIVER had, DWORD fdwClose);
#define ACM_DRIVERCLOSEF_VALID (0L) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// 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
#define ACM_DRIVERPRIORITYF_VALID 0x00030003L // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// 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 _WIN32
typedef 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
#else
typedef 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_NOTIFY 0x10000000L // ;Internal
#define ACMDRIVERDETAILS_SUPPORTF_LOCAL 0x40000000L
#define ACMDRIVERDETAILS_SUPPORTF_DISABLED 0x80000000L
#ifdef _WIN32
MMRESULT 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
#else
MMRESULT ACMAPI acmDriverDetails( HACMDRIVERID hadid, LPACMDRIVERDETAILS padd, DWORD fdwDetails);#endif
#define ACM_DRIVERDETAILSF_VALID (0L) // ;Internal
//--------------------------------------------------------------------------;
//
// ACM Format Tags
//
//
//
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFormatTagDetails()
//
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define ACMFORMATTAGDETAILS_FORMATTAG_CHARS 48
#ifdef _WIN32
typedef 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
#else
typedef 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 _WIN32
MMRESULT 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
#else
MMRESULT 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
#define ACM_FORMATTAGDETAILSF_VALID (ACM_FORMATTAGDETAILSF_QUERYMASK) /* ;Internal */
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFormatTagEnum()
//
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32
typedef 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
#else
typedef 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
#define ACM_FORMATTAGENUMF_VALID (0L) // ;Internal
//--------------------------------------------------------------------------;
//
// ACM Formats
//
//
//
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFormatDetails()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define ACMFORMATDETAILS_FORMAT_CHARS 128
#ifdef _WIN32
typedef 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
#else
typedef 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 _WIN32
MMRESULT 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
#else
MMRESULT ACMAPI acmFormatDetails( HACMDRIVER had, LPACMFORMATDETAILS pafd, DWORD fdwDetails);#endif
#define ACM_FORMATDETAILSF_INDEX 0x00000000L
#define ACM_FORMATDETAILSF_FORMAT 0x00000001L
#define ACM_FORMATDETAILSF_QUERYMASK 0x0000000FL
#define ACM_FORMATDETAILSF_VALID (ACM_FORMATDETAILSF_QUERYMASK) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFormatEnum()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32
typedef 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
#else
typedef 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
#define ACM_FORMATENUMF_VALID (0x01FF0000L) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// 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
#define ACM_FORMATSUGGESTF_VALID (ACM_FORMATSUGGESTF_TYPEMASK) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// 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)
#define FORMATCHOOSE_FORMATTAG_ADD (FORMATCHOOSE_MESSAGE+3) // ;Internal
#define FORMATCHOOSE_FORMAT_ADD (FORMATCHOOSE_MESSAGE+4) // ;Internal
#ifdef _WIN32
typedef 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
#else
typedef UINT (CALLBACK *ACMFORMATCHOOSEHOOKPROC)( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);#endif
//
//
//
//
#ifdef _WIN32
typedef 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
#else
typedef 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
#define ACMFORMATCHOOSE_STYLEF_VALID (0x000000FCL) // ;Internal
#ifdef _WIN32
MMRESULT ACMAPI acmFormatChooseA( LPACMFORMATCHOOSEA pafmtc);
MMRESULT ACMAPI acmFormatChooseW( LPACMFORMATCHOOSEW pafmtc);
#ifdef _UNICODE
#define acmFormatChoose acmFormatChooseW
#else
#define acmFormatChoose acmFormatChooseA
#endif
#else
MMRESULT ACMAPI acmFormatChoose( LPACMFORMATCHOOSE pafmtc);#endif
//--------------------------------------------------------------------------;
//
// ACM Filter Tags
//
//
//
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFilterTagDetails()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define ACMFILTERTAGDETAILS_FILTERTAG_CHARS 48
#ifdef _WIN32
typedef 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
#else
typedef 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 _WIN32
MMRESULT 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
#else
MMRESULT 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
#define ACM_FILTERTAGDETAILSF_VALID (ACM_FILTERTAGDETAILSF_QUERYMASK) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFilterTagEnum()
//
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32
typedef 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
#else
typedef 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
#define ACM_FILTERTAGENUMF_VALID (0L) // ;Internal
//--------------------------------------------------------------------------;
//
// ACM Filters
//
//
//
//
//--------------------------------------------------------------------------;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFilterDetails()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#define ACMFILTERDETAILS_FILTER_CHARS 128
#ifdef _WIN32
typedef 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
#else
typedef 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 _WIN32
MMRESULT 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
#else
MMRESULT ACMAPI acmFilterDetails( HACMDRIVER had, LPACMFILTERDETAILS pafd, DWORD fdwDetails);#endif
#define ACM_FILTERDETAILSF_INDEX 0x00000000L
#define ACM_FILTERDETAILSF_FILTER 0x00000001L
#define ACM_FILTERDETAILSF_QUERYMASK 0x0000000FL
#define ACM_FILTERDETAILSF_VALID (ACM_FILTERDETAILSF_QUERYMASK) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmFilterEnum()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
#ifdef _WIN32
typedef 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
#else
typedef 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
#define ACM_FILTERENUMF_VALID 0x00010000L // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// 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)
#define FILTERCHOOSE_FILTERTAG_ADD (FILTERCHOOSE_MESSAGE+3) // ;Internal
#define FILTERCHOOSE_FILTER_ADD (FILTERCHOOSE_MESSAGE+4) // ;Internal
#ifdef _WIN32
typedef 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
#else
typedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROC)( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);#endif
//
// ACMFILTERCHOOSE
//
//
#ifdef _WIN32
typedef 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
#else
typedef 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
#define ACMFILTERCHOOSE_STYLEF_VALID (0x000000FCL) // ;Internal
#ifdef _WIN32
MMRESULT ACMAPI acmFilterChooseA( LPACMFILTERCHOOSEA pafltrc);
MMRESULT ACMAPI acmFilterChooseW( LPACMFILTERCHOOSEW pafltrc);
#ifdef _UNICODE
#define acmFilterChoose acmFilterChooseW
#else
#define acmFilterChoose acmFilterChooseA
#endif
#else
MMRESULT 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
#define ACMSTREAMHEADER_STATUSF_VALID 0x00130000L // ;Internal
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
#define ACM_STREAMOPENF_VALID (CALLBACK_TYPEMASK | 0x00000007L) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmStreamClose()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamClose( HACMSTREAM has, DWORD fdwClose);
#define ACM_STREAMCLOSEF_VALID (0L) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// 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
#define ACM_STREAMSIZEF_VALID (ACM_STREAMSIZEF_QUERYMASK) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmStreamReset()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamReset( HACMSTREAM has, DWORD fdwReset);
#define ACM_STREAMRESETF_VALID (0L) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// 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
#define ACM_STREAMCONVERTF_VALID (ACM_STREAMCONVERTF_BLOCKALIGN | /* ;Internal */ \
ACM_STREAMCONVERTF_END | /* ;Internal */ \ ACM_STREAMCONVERTF_START) /* ;Internal */
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmStreamPrepareHeader()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamPrepareHeader( HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwPrepare);
#define ACM_STREAMPREPAREF_VALID (0L) // ;Internal
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
//
// acmStreamUnprepareHeader()
//
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
MMRESULT ACMAPI acmStreamUnprepareHeader( HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwUnprepare); #define ACM_STREAMUNPREPAREF_VALID (0L) // ;Internal
#include "poppack.h" /* Revert to default packing */
#ifdef __cplusplus
} /* End of extern "C" { */#endif /* __cplusplus */
#endif /* _INC_ACM */
|
