From e9bb9dac5d74dba4c359fa95895607ae1986225f Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Mon, 14 Aug 2000 11:01:51 +0000 Subject: [PATCH] Missing WINE header files. Original commit message from CVS: Missing WINE header files. --- include/wine/ldt.h | 98 +++++ include/wine/mmreg.h | 104 +++++ include/wine/msacm.h | 942 ++++++++++++++++++++++++++++++++++++++++ include/wine/msacmdrv.h | 203 +++++++++ 4 files changed, 1347 insertions(+) create mode 100644 include/wine/ldt.h create mode 100644 include/wine/mmreg.h create mode 100644 include/wine/msacm.h create mode 100644 include/wine/msacmdrv.h diff --git a/include/wine/ldt.h b/include/wine/ldt.h new file mode 100644 index 0000000000..f87ecc14e2 --- /dev/null +++ b/include/wine/ldt.h @@ -0,0 +1,98 @@ +/* + * LDT copy + * + * Copyright 1995 Alexandre Julliard + */ + +#ifndef __WINE_LDT_H +#define __WINE_LDT_H + +#include "windef.h" +enum seg_type +{ + SEGMENT_DATA = 0, + SEGMENT_STACK = 1, + SEGMENT_CODE = 2 +}; + + /* This structure represents a real LDT entry. */ + /* It is used by get_ldt_entry() and set_ldt_entry(). */ +typedef struct +{ + unsigned long base; /* base address */ + unsigned long limit; /* segment limit (in pages or bytes) */ + int seg_32bit; /* is segment 32-bit? */ + int read_only; /* is segment read-only? */ + int limit_in_pages; /* is the limit in pages or bytes? */ + enum seg_type type; /* segment type */ +} ldt_entry; +#ifdef __cplusplus +extern "C" +{ +#endif +extern void LDT_BytesToEntry( const unsigned long *buffer, ldt_entry *content); +extern void LDT_EntryToBytes( unsigned long *buffer, const ldt_entry *content); +extern int LDT_GetEntry( int entry, ldt_entry *content ); +extern int LDT_SetEntry( int entry, const ldt_entry *content ); +extern void LDT_Print( int start, int length ); + + + /* This structure is used to build the local copy of the LDT. */ +typedef struct +{ + unsigned long base; /* base address or 0 if entry is free */ + unsigned long limit; /* limit in bytes or 0 if entry is free */ +} ldt_copy_entry; + +#define LDT_SIZE 8192 + +extern ldt_copy_entry ldt_copy[LDT_SIZE]; + +#define __AHSHIFT 3 /* don't change! */ +#define __AHINCR (1 << __AHSHIFT) + +#define SELECTOR_TO_ENTRY(sel) (((int)(sel) & 0xffff) >> __AHSHIFT) +#define ENTRY_TO_SELECTOR(i) ((i) ? (((int)(i) << __AHSHIFT) | 7) : 0) +#define IS_LDT_ENTRY_FREE(i) (!(ldt_flags_copy[(i)] & LDT_FLAGS_ALLOCATED)) +#define IS_SELECTOR_FREE(sel) (IS_LDT_ENTRY_FREE(SELECTOR_TO_ENTRY(sel))) +#define GET_SEL_BASE(sel) (ldt_copy[SELECTOR_TO_ENTRY(sel)].base) +#define GET_SEL_LIMIT(sel) (ldt_copy[SELECTOR_TO_ENTRY(sel)].limit) + +/* Convert a segmented ptr (16:16) to a linear (32) pointer */ + +#define PTR_SEG_OFF_TO_LIN(seg,off) \ + ((void*)(GET_SEL_BASE(seg) + (unsigned int)(off))) +#define PTR_SEG_TO_LIN(ptr) \ + PTR_SEG_OFF_TO_LIN(SELECTOROF(ptr),OFFSETOF(ptr)) +#define PTR_SEG_OFF_TO_SEGPTR(seg,off) \ + ((SEGPTR)MAKELONG(off,seg)) +#define PTR_SEG_OFF_TO_HUGEPTR(seg,off) \ + PTR_SEG_OFF_TO_SEGPTR( (seg) + (HIWORD(off) << __AHSHIFT), LOWORD(off) ) + +#define W32S_APPLICATION() (PROCESS_Current()->flags & PDB32_WIN32S_PROC) +#define W32S_OFFSET 0x10000 +#define W32S_APP2WINE(addr, offset) ((addr)? (DWORD)(addr) + (DWORD)(offset) : 0) +#define W32S_WINE2APP(addr, offset) ((addr)? (DWORD)(addr) - (DWORD)(offset) : 0) + +extern unsigned char ldt_flags_copy[LDT_SIZE]; + +#define LDT_FLAGS_TYPE 0x03 /* Mask for segment type */ +#define LDT_FLAGS_READONLY 0x04 /* Segment is read-only (data) */ +#define LDT_FLAGS_EXECONLY 0x04 /* Segment is execute-only (code) */ +#define LDT_FLAGS_32BIT 0x08 /* Segment is 32-bit (code or stack) */ +#define LDT_FLAGS_BIG 0x10 /* Segment is big (limit is in pages) */ +#define LDT_FLAGS_ALLOCATED 0x80 /* Segment is allocated (no longer free) */ + +#define GET_SEL_FLAGS(sel) (ldt_flags_copy[SELECTOR_TO_ENTRY(sel)]) + +#define FIRST_LDT_ENTRY_TO_ALLOC 17 + +/* Determine if sel is a system selector (i.e. not managed by Wine) */ +#define IS_SELECTOR_SYSTEM(sel) \ + (!((sel) & 4) || (SELECTOR_TO_ENTRY(sel) < FIRST_LDT_ENTRY_TO_ALLOC)) +#define IS_SELECTOR_32BIT(sel) \ + (IS_SELECTOR_SYSTEM(sel) || (GET_SEL_FLAGS(sel) & LDT_FLAGS_32BIT)) +#ifdef __cplusplus +} +#endif +#endif /* __WINE_LDT_H */ diff --git a/include/wine/mmreg.h b/include/wine/mmreg.h new file mode 100644 index 0000000000..74e26250d0 --- /dev/null +++ b/include/wine/mmreg.h @@ -0,0 +1,104 @@ +/* + * mmreg.h - Declarations for ??? + */ + +#ifndef __WINE_MMREG_H +#define __WINE_MMREG_H + +/*********************************************************************** + * Defines/Enums + */ + +#ifndef _ACM_WAVEFILTER +#define _ACM_WAVEFILTER + +#include "windef.h" + +#define WAVE_FILTER_UNKNOWN 0x0000 +#define WAVE_FILTER_DEVELOPMENT 0xFFFF + +typedef struct _WAVEFILTER { + DWORD cbStruct; + DWORD dwFilterTag; + DWORD fdwFilter; + DWORD dwReserved[5]; +} WAVEFILTER, *PWAVEFILTER, *NPWAVEFILTER, *LPWAVEFILTER; +#endif /* _ACM_WAVEFILTER */ + +#ifndef WAVE_FILTER_VOLUME +#define WAVE_FILTER_VOLUME 0x0001 + +typedef struct _WAVEFILTER_VOLUME { + WAVEFILTER wfltr; + DWORD dwVolume; +} VOLUMEWAVEFILTER, *PVOLUMEWAVEFILTER, *NPVOLUMEWAVEFILTER, *LPVOLUMEWAVEFILTER; +#endif /* WAVE_FILTER_VOLUME */ + +#ifndef WAVE_FILTER_ECHO +#define WAVE_FILTER_ECHO 0x0002 + +typedef struct WAVEFILTER_ECHO { + WAVEFILTER wfltr; + DWORD dwVolume; + DWORD dwDelay; +} ECHOWAVEFILTER, *PECHOWAVEFILTER, *NPECHOWAVEFILTER, *LPECHOWAVEFILTER; +#endif /* WAVEFILTER_ECHO */ + +#ifndef _WAVEFORMATEX_ +#define _WAVEFORMATEX_ +typedef struct _WAVEFORMATEX { + WORD wFormatTag; + WORD nChannels; + DWORD nSamplesPerSec; + DWORD nAvgBytesPerSec; + WORD nBlockAlign; + WORD wBitsPerSample; + WORD cbSize; +} WAVEFORMATEX, *PWAVEFORMATEX, *NPWAVEFORMATEX, *LPWAVEFORMATEX; +#endif /* _WAVEFORMATEX_ */ + +/* WAVE form wFormatTag IDs */ +#define WAVE_FORMAT_UNKNOWN 0x0000 /* Microsoft Corporation */ +#define WAVE_FORMAT_ADPCM 0x0002 /* Microsoft Corporation */ +#define WAVE_FORMAT_IBM_CVSD 0x0005 /* IBM Corporation */ +#define WAVE_FORMAT_ALAW 0x0006 /* Microsoft Corporation */ +#define WAVE_FORMAT_MULAW 0x0007 /* Microsoft Corporation */ +#define WAVE_FORMAT_OKI_ADPCM 0x0010 /* OKI */ +#define WAVE_FORMAT_DVI_ADPCM 0x0011 /* Intel Corporation */ +#define WAVE_FORMAT_IMA_ADPCM (WAVE_FORMAT_DVI_ADPCM) /* Intel Corporation */ +#define WAVE_FORMAT_MEDIASPACE_ADPCM 0x0012 /* Videologic */ +#define WAVE_FORMAT_SIERRA_ADPCM 0x0013 /* Sierra Semiconductor Corp */ +#define WAVE_FORMAT_G723_ADPCM 0x0014 /* Antex Electronics Corporation */ +#define WAVE_FORMAT_DIGISTD 0x0015 /* DSP Solutions, Inc. */ +#define WAVE_FORMAT_DIGIFIX 0x0016 /* DSP Solutions, Inc. */ +#define WAVE_FORMAT_DIALOGIC_OKI_ADPCM 0x0017 /* Dialogic Corporation */ +#define WAVE_FORMAT_YAMAHA_ADPCM 0x0020 /* Yamaha Corporation of America */ +#define WAVE_FORMAT_SONARC 0x0021 /* Speech Compression */ +#define WAVE_FORMAT_DSPGROUP_TRUESPEECH 0x0022 /* DSP Group, Inc */ +#define WAVE_FORMAT_ECHOSC1 0x0023 /* Echo Speech Corporation */ +#define WAVE_FORMAT_AUDIOFILE_AF36 0x0024 /* */ +#define WAVE_FORMAT_APTX 0x0025 /* Audio Processing Technology */ +#define WAVE_FORMAT_AUDIOFILE_AF10 0x0026 /* */ +#define WAVE_FORMAT_DOLBY_AC2 0x0030 /* Dolby Laboratories */ +#define WAVE_FORMAT_GSM610 0x0031 /* Microsoft Corporation */ +#define WAVE_FORMAT_ANTEX_ADPCME 0x0033 /* Antex Electronics Corporation */ +#define WAVE_FORMAT_CONTROL_RES_VQLPC 0x0034 /* Control Resources Limited */ +#define WAVE_FORMAT_DIGIREAL 0x0035 /* DSP Solutions, Inc. */ +#define WAVE_FORMAT_DIGIADPCM 0x0036 /* DSP Solutions, Inc. */ +#define WAVE_FORMAT_CONTROL_RES_CR10 0x0037 /* Control Resources Limited */ +#define WAVE_FORMAT_NMS_VBXADPCM 0x0038 /* Natural MicroSystems */ +#define WAVE_FORMAT_G721_ADPCM 0x0040 /* Antex Electronics Corporation */ +#define WAVE_FORMAT_MPEG 0x0050 /* Microsoft Corporation */ +#define WAVE_FORMAT_CREATIVE_ADPCM 0x0200 /* Creative Labs, Inc */ +#define WAVE_FORMAT_CREATIVE_FASTSPEECH8 0x0202 /* Creative Labs, Inc */ +#define WAVE_FORMAT_CREATIVE_FASTSPEECH10 0x0203 /* Creative Labs, Inc */ +#define WAVE_FORMAT_FM_TOWNS_SND 0x0300 /* Fujitsu Corp. */ +#define WAVE_FORMAT_OLIGSM 0x1000 /* Ing C. Olivetti & C., S.p.A. */ +#define WAVE_FORMAT_OLIADPCM 0x1001 /* Ing C. Olivetti & C., S.p.A. */ +#define WAVE_FORMAT_OLICELP 0x1002 /* Ing C. Olivetti & C., S.p.A. */ +#define WAVE_FORMAT_OLISBC 0x1003 /* Ing C. Olivetti & C., S.p.A. */ +#define WAVE_FORMAT_OLIOPR 0x1004 /* Ing C. Olivetti & C., S.p.A. */ + +#define WAVE_FORMAT_DEVELOPMENT (0xFFFF) + +#endif /* __WINE_MMREG_H */ diff --git a/include/wine/msacm.h b/include/wine/msacm.h new file mode 100644 index 0000000000..18f1d855c7 --- /dev/null +++ b/include/wine/msacm.h @@ -0,0 +1,942 @@ +/* + * msacm.h - Declarations for MSACM + */ + +#ifndef __WINE_MSACM_H +#define __WINE_MSACM_H + +#include "windef.h" +#include "driver.h" +#include "mmreg.h" + +#ifdef __cplusplus +extern "C" { +#endif /* defined(__cplusplus) */ + +typedef WORD VERSION; /* major (high byte), minor (low byte) */ + +typedef UINT16 MMVERSION16; +typedef UINT MMVERSION; +typedef UINT16 MCIDEVICEID16; +typedef UINT MCIDEVICEID; +typedef UINT16 MMRESULT16; +typedef UINT MMRESULT; +typedef DWORD FOURCC; /* a four character code */ + + + +#define WAVE_FORMAT_PCM 1 + +/*********************************************************************** + * Defines/Enums + */ + +#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) + +#define MM_ACM_OPEN MM_STREAM_OPEN +#define MM_ACM_CLOSE MM_STREAM_CLOSE +#define MM_ACM_DONE MM_STREAM_DONE + +#define ACM_DRIVERADDF_FUNCTION 0x00000003L +#define ACM_DRIVERADDF_NOTIFYHWND 0x00000004L +#define ACM_DRIVERADDF_TYPEMASK 0x00000007L +#define ACM_DRIVERADDF_LOCAL 0x00000000L +#define ACM_DRIVERADDF_GLOBAL 0x00000008L + +#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 + +#define ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC mmioFOURCC('a', 'u', 'd', 'c') +#define ACMDRIVERDETAILS_FCCCOMP_UNDEFINED mmioFOURCC('\0', '\0', '\0', '\0') + +#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 + +#define ACM_DRIVERENUMF_NOLOCAL 0x40000000L +#define ACM_DRIVERENUMF_DISABLED 0x80000000L + +#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 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 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 ACMFILTERDETAILS_FILTER_CHARS 128 + +#define ACM_FILTERDETAILSF_INDEX 0x00000000L +#define ACM_FILTERDETAILSF_FILTER 0x00000001L +#define ACM_FILTERDETAILSF_QUERYMASK 0x0000000FL + +#define ACMFILTERTAGDETAILS_FILTERTAG_CHARS 48 + +#define ACM_FILTERTAGDETAILSF_INDEX 0x00000000L +#define ACM_FILTERTAGDETAILSF_FILTERTAG 0x00000001L +#define ACM_FILTERTAGDETAILSF_LARGESTSIZE 0x00000002L +#define ACM_FILTERTAGDETAILSF_QUERYMASK 0x0000000FL + +#define ACM_FILTERENUMF_DWFILTERTAG 0x00010000L + +#define ACMHELPMSGSTRINGA "acmchoose_help" +#define ACMHELPMSGSTRINGW L"acmchoose_help" +#define ACMHELPMSGSTRING16 "acmchoose_help" + +#define ACMHELPMSGCONTEXTMENUA "acmchoose_contextmenu" +#define ACMHELPMSGCONTEXTMENUW L"acmchoose_contextmenu" +#define ACMHELPMSGCONTEXTMENU16 "acmchoose_contextmenu" + +#define ACMHELPMSGCONTEXTHELPA "acmchoose_contexthelp" +#define ACMHELPMSGCONTEXTHELPW L"acmchoose_contexthelp" +#define ACMHELPMSGCONTEXTHELP16 "acmchoose_contexthelp" + +#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 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 ACMFORMATDETAILS_FORMAT_CHARS 128 + +#define ACM_FORMATDETAILSF_INDEX 0x00000000L +#define ACM_FORMATDETAILSF_FORMAT 0x00000001L +#define ACM_FORMATDETAILSF_QUERYMASK 0x0000000FL + +#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_FORMATSUGGESTF_WFORMATTAG 0x00010000L +#define ACM_FORMATSUGGESTF_NCHANNELS 0x00020000L +#define ACM_FORMATSUGGESTF_NSAMPLESPERSEC 0x00040000L +#define ACM_FORMATSUGGESTF_WBITSPERSAMPLE 0x00080000L +#define ACM_FORMATSUGGESTF_TYPEMASK 0x00FF0000L + +#define ACMFORMATTAGDETAILS_FORMATTAG_CHARS 48 + +#define ACM_FORMATTAGDETAILSF_INDEX 0x00000000L +#define ACM_FORMATTAGDETAILSF_FORMATTAG 0x00000001L +#define ACM_FORMATTAGDETAILSF_LARGESTSIZE 0x00000002L +#define ACM_FORMATTAGDETAILSF_QUERYMASK 0x0000000FL + +#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 + +#define ACM_STREAMCONVERTF_BLOCKALIGN 0x00000004 +#define ACM_STREAMCONVERTF_START 0x00000010 +#define ACM_STREAMCONVERTF_END 0x00000020 + +#define ACMSTREAMHEADER_STATUSF_DONE 0x00010000L +#define ACMSTREAMHEADER_STATUSF_PREPARED 0x00020000L +#define ACMSTREAMHEADER_STATUSF_INQUEUE 0x00100000L + +#define ACM_STREAMOPENF_QUERY 0x00000001 +#define ACM_STREAMOPENF_ASYNC 0x00000002 +#define ACM_STREAMOPENF_NONREALTIME 0x00000004 + +#define ACM_STREAMSIZEF_SOURCE 0x00000000L +#define ACM_STREAMSIZEF_DESTINATION 0x00000001L +#define ACM_STREAMSIZEF_QUERYMASK 0x0000000FL + +#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) + +/*********************************************************************** + * Callbacks + */ + +typedef WIN_BOOL CALLBACK ( *ACMDRIVERENUMCB)( + HACMDRIVERID hadid, DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL16 CALLBACK ( *ACMDRIVERENUMCB16)( + HACMDRIVERID16 hadid, DWORD dwInstance, DWORD fdwSupport +); + +typedef UINT CALLBACK ( *ACMFILTERCHOOSEHOOKPROCA)( + HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam +); + +typedef UINT CALLBACK ( *ACMFILTERCHOOSEHOOKPROCW)( + HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam +); + +typedef UINT CALLBACK ( *ACMFILTERCHOOSEHOOKPROC16)( + HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam +); + +typedef UINT CALLBACK ( *ACMFORMATCHOOSEHOOKPROCA)( + HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam +); + +typedef UINT CALLBACK ( *ACMFORMATCHOOSEHOOKPROCW)( + HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam +); + +typedef UINT16 CALLBACK ( *ACMFORMATCHOOSEHOOKPROC16)( + HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam +); + +/*********************************************************************** + * Structures + */ + +typedef struct _ACMDRIVERDETAILSA +{ + DWORD cbStruct; + + FOURCC fccType; + FOURCC fccComp; + + WORD wMid; + WORD wPid; + + DWORD vdwACM; + DWORD vdwDriver; + + DWORD fdwSupport; + DWORD cFormatTags; + DWORD cFilterTags; + + HICON hicon; + + 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; + +typedef struct _ACMDRIVERDETAILSW +{ + DWORD cbStruct; + + FOURCC fccType; + FOURCC fccComp; + + WORD wMid; + WORD wPid; + + DWORD vdwACM; + DWORD vdwDriver; + + DWORD fdwSupport; + DWORD cFormatTags; + DWORD cFilterTags; + + HICON hicon; + + 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; + +typedef struct _ACMDRIVERDETAILS16 +{ + DWORD cbStruct; + + FOURCC fccType; + FOURCC fccComp; + + WORD wMid; + WORD wPid; + + DWORD vdwACM; + DWORD vdwDriver; + + DWORD fdwSupport; + DWORD cFormatTags; + DWORD cFilterTags; + + HICON16 hicon; + + 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]; +} ACMDRIVERDETAILS16, *NPACMDRIVERDETAILS16, *LPACMDRIVERDETAILS16; + +typedef struct _ACMFILTERCHOOSEA +{ + DWORD cbStruct; + DWORD fdwStyle; + + HWND hwndOwner; + + PWAVEFILTER pwfltr; + DWORD cbwfltr; + + LPCSTR pszTitle; + + CHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; + CHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS]; + LPSTR pszName; + DWORD cchName; + + DWORD fdwEnum; + PWAVEFILTER pwfltrEnum; + + HINSTANCE hInstance; + LPCSTR pszTemplateName; + LPARAM lCustData; + ACMFILTERCHOOSEHOOKPROCA pfnHook; +} ACMFILTERCHOOSEA, *PACMFILTERCHOOSEA; + +typedef struct _ACMFILTERCHOOSEW +{ + DWORD cbStruct; + DWORD fdwStyle; + + HWND hwndOwner; + + PWAVEFILTER pwfltr; + DWORD cbwfltr; + + LPCWSTR pszTitle; + + WCHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; + WCHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS]; + LPWSTR pszName; + DWORD cchName; + + DWORD fdwEnum; + PWAVEFILTER pwfltrEnum; + + HINSTANCE hInstance; + LPCWSTR pszTemplateName; + LPARAM lCustData; + ACMFILTERCHOOSEHOOKPROCW pfnHook; +} ACMFILTERCHOOSEW, *PACMFILTERCHOOSEW; + +typedef struct _ACMFILTERCHOOSE16 +{ + DWORD cbStruct; + DWORD fdwStyle; + + HWND16 hwndOwner; + + LPWAVEFILTER pwfltr; + DWORD cbwfltr; + + LPCSTR pszTitle; + + char szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; + char szFilter[ACMFILTERDETAILS_FILTER_CHARS]; + LPSTR pszName; + DWORD cchName; + + DWORD fdwEnum; + LPWAVEFILTER pwfltrEnum; + + HINSTANCE16 hInstance; + LPCSTR pszTemplateName; + LPARAM lCustData; + ACMFILTERCHOOSEHOOKPROC16 pfnHook; +} ACMFILTERCHOOSE16, *NPACMFILTERCHOOSE16, *LPACMFILTERCHOOSE16; + +typedef struct _ACMFILTERDETAILSA +{ + DWORD cbStruct; + DWORD dwFilterIndex; + DWORD dwFilterTag; + DWORD fdwSupport; + PWAVEFILTER pwfltr; + DWORD cbwfltr; + CHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS]; +} ACMFILTERDETAILSA, *PACMFILTERDETAILSA; + +typedef struct _ACMFILTERDETAILSW +{ + DWORD cbStruct; + DWORD dwFilterIndex; + DWORD dwFilterTag; + DWORD fdwSupport; + PWAVEFILTER pwfltr; + DWORD cbwfltr; + WCHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS]; +} ACMFILTERDETAILSW, *PACMFILTERDETAILSW; + +typedef struct _ACMFILTERDETAILS16 +{ + DWORD cbStruct; + DWORD dwFilterIndex; + DWORD dwFilterTag; + DWORD fdwSupport; + LPWAVEFILTER pwfltr; + DWORD cbwfltr; + CHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS]; +} ACMFILTERDETAILS16, *NPACMFILTERDETAILS16, *LPACMFILTERDETAILS16; + +typedef struct _ACMFILTERTAGDETAILSA +{ + DWORD cbStruct; + DWORD dwFilterTagIndex; + DWORD dwFilterTag; + DWORD cbFilterSize; + DWORD fdwSupport; + DWORD cStandardFilters; + CHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; +} ACMFILTERTAGDETAILSA, *PACMFILTERTAGDETAILSA; + +typedef struct _ACMFILTERTAGDETAILSW +{ + DWORD cbStruct; + DWORD dwFilterTagIndex; + DWORD dwFilterTag; + DWORD cbFilterSize; + DWORD fdwSupport; + DWORD cStandardFilters; + WCHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; +} ACMFILTERTAGDETAILSW, *PACMFILTERTAGDETAILSW; + +typedef struct _ACMFILTERTAGDETAILS16 +{ + DWORD cbStruct; + DWORD dwFilterTagIndex; + DWORD dwFilterTag; + DWORD cbFilterSize; + DWORD fdwSupport; + DWORD cStandardFilters; + CHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS]; +} ACMFILTERTAGDETAILS16, *NPACMFILTERTAGDETAILS16, *LPACMFILTERTAGDETAILS16; + +typedef struct _ACMFORMATCHOOSEA +{ + DWORD cbStruct; + DWORD fdwStyle; + + HWND hwndOwner; + + PWAVEFORMATEX pwfx; + DWORD cbwfx; + LPCSTR pszTitle; + + CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; + CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]; + + LPSTR pszName; + DWORD cchName; + + DWORD fdwEnum; + PWAVEFORMATEX pwfxEnum; + + HINSTANCE hInstance; + LPCSTR pszTemplateName; + LPARAM lCustData; + ACMFORMATCHOOSEHOOKPROCA pfnHook; +} ACMFORMATCHOOSEA, *PACMFORMATCHOOSEA; + +typedef struct _ACMFORMATCHOOSEW +{ + DWORD cbStruct; + DWORD fdwStyle; + + HWND hwndOwner; + + PWAVEFORMATEX pwfx; + DWORD cbwfx; + LPCWSTR pszTitle; + + WCHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; + WCHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]; + + LPWSTR pszName; + DWORD cchName; + + DWORD fdwEnum; + LPWAVEFORMATEX pwfxEnum; + + HINSTANCE hInstance; + LPCWSTR pszTemplateName; + LPARAM lCustData; + ACMFORMATCHOOSEHOOKPROCW pfnHook; +} ACMFORMATCHOOSEW, *PACMFORMATCHOOSEW; + +typedef struct _ACMFORMATCHOOSE16 +{ + DWORD cbStruct; + DWORD fdwStyle; + + HWND16 hwndOwner; + + LPWAVEFORMATEX pwfx; + DWORD cbwfx; + LPCSTR pszTitle; + + CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; + CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]; + + LPSTR pszName; + DWORD cchName; + + DWORD fdwEnum; + LPWAVEFORMATEX pwfxEnum; + + HINSTANCE16 hInstance; + LPCSTR pszTemplateName; + LPARAM lCustData; + ACMFORMATCHOOSEHOOKPROC16 pfnHook; +} ACMFORMATCHOOSE16, *NPACMFORMATCHOOSE16, *LPACMFORMATCHOOSE16; + +typedef struct _ACMFORMATDETAILSA +{ + DWORD cbStruct; + DWORD dwFormatIndex; + DWORD dwFormatTag; + DWORD fdwSupport; + PWAVEFORMATEX pwfx; + DWORD cbwfx; + CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]; +} ACMFORMATDETAILSA, *PACMFORMATDETAILSA; + +typedef struct _ACMFORMATDETAILSW +{ + DWORD cbStruct; + DWORD dwFormatIndex; + DWORD dwFormatTag; + DWORD fdwSupport; + PWAVEFORMATEX pwfx; + DWORD cbwfx; + WCHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]; +} ACMFORMATDETAILSW, *PACMFORMATDETAILSW; + +typedef struct _ACMFORMATDETAILS16 +{ + DWORD cbStruct; + DWORD dwFormatIndex; + DWORD dwFormatTag; + DWORD fdwSupport; + LPWAVEFORMATEX pwfx; + DWORD cbwfx; + CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]; +} ACMFORMATDETAILS16, *NPACMFORMATDETAILS16, *LPACMFORMATDETAILS16; + +typedef struct _ACMFORMATTAGDETAILSA +{ + DWORD cbStruct; + DWORD dwFormatTagIndex; + DWORD dwFormatTag; + DWORD cbFormatSize; + DWORD fdwSupport; + DWORD cStandardFormats; + CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; +} ACMFORMATTAGDETAILSA, *PACMFORMATTAGDETAILSA; + +typedef struct _ACMFORMATTAGDETAILSW +{ + DWORD cbStruct; + DWORD dwFormatTagIndex; + DWORD dwFormatTag; + DWORD cbFormatSize; + DWORD fdwSupport; + DWORD cStandardFormats; + WCHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; +} ACMFORMATTAGDETAILSW, *PACMFORMATTAGDETAILSW; + +typedef struct _ACMFORMATTAGDETAILS16 +{ + DWORD cbStruct; + DWORD dwFormatTagIndex; + DWORD dwFormatTag; + DWORD cbFormatSize; + DWORD fdwSupport; + DWORD cStandardFormats; + CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]; +} ACMFORMATTAGDETAILS16, *NPACMFORMATTAGDETAILS16, *LPACMFORMATTAGDETAILS16; + +typedef struct _ACMSTREAMHEADER +{ + DWORD cbStruct; + DWORD fdwStatus; + DWORD dwUser; + LPBYTE pbSrc; + DWORD cbSrcLength; + DWORD cbSrcLengthUsed; + DWORD dwSrcUser; + LPBYTE pbDst; + DWORD cbDstLength; + DWORD cbDstLengthUsed; + DWORD dwDstUser; + DWORD dwReservedDriver[10]; +} ACMSTREAMHEADER16, *NPACMSTREAMHEADER16, *LPACMSTREAMHEADER16, + ACMSTREAMHEADER, *PACMSTREAMHEADER; + +/*********************************************************************** + * Callbacks 2 + */ + +typedef WIN_BOOL CALLBACK ( *ACMFILTERENUMCBA)( + HACMDRIVERID hadid, PACMFILTERDETAILSA pafd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL CALLBACK ( *ACMFILTERENUMCBW)( + HACMDRIVERID hadid, PACMFILTERDETAILSW pafd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL16 CALLBACK ( *ACMFILTERENUMCB16)( + HACMDRIVERID16 hadid, LPACMFILTERDETAILS16 pafd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL CALLBACK ( *ACMFILTERTAGENUMCBA)( + HACMDRIVERID hadid, PACMFILTERTAGDETAILSA paftd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL CALLBACK ( *ACMFILTERTAGENUMCBW)( + HACMDRIVERID hadid, PACMFILTERTAGDETAILSW paftd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL16 CALLBACK ( *ACMFILTERTAGENUMCB16)( + HACMDRIVERID16 hadid, LPACMFILTERTAGDETAILS16 paftd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL CALLBACK ( *ACMFORMATENUMCBA)( + HACMDRIVERID hadid, PACMFORMATDETAILSA pafd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL CALLBACK ( *ACMFORMATENUMCBW)( + HACMDRIVERID hadid, PACMFORMATDETAILSW pafd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL16 CALLBACK ( *ACMFORMATENUMCB16)( + HACMDRIVERID16 hadid, LPACMFORMATDETAILS16 pafd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL CALLBACK ( *ACMFORMATTAGENUMCBA)( + HACMDRIVERID hadid, PACMFORMATTAGDETAILSA paftd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL CALLBACK ( *ACMFORMATTAGENUMCBW)( + HACMDRIVERID hadid, PACMFORMATTAGDETAILSW paftd, + DWORD dwInstance, DWORD fdwSupport +); + +typedef WIN_BOOL16 CALLBACK ( *ACMFORMATTAGENUMCB16)( + HACMDRIVERID16 hadid, LPACMFORMATTAGDETAILS16 paftd, + DWORD dwInstance, DWORD fdwSupport +); + +/*********************************************************************** + * Functions - Win16 + */ + +DWORD WINAPI acmGetVersion16( +); +MMRESULT16 WINAPI acmMetrics16( + HACMOBJ16 hao, UINT16 uMetric, LPVOID pMetric +); +MMRESULT16 WINAPI acmDriverEnum16( + ACMDRIVERENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT16 WINAPI acmDriverDetails16( + HACMDRIVERID16 hadid, LPACMDRIVERDETAILS16 padd, DWORD fdwDetails +); +MMRESULT16 WINAPI acmDriverAdd16( + LPHACMDRIVERID16 phadid, HINSTANCE16 hinstModule, + LPARAM lParam, DWORD dwPriority, DWORD fdwAdd +); +MMRESULT16 WINAPI acmDriverRemove16( + HACMDRIVERID16 hadid, DWORD fdwRemove +); +MMRESULT16 WINAPI acmDriverOpen16( + LPHACMDRIVER16 phad, HACMDRIVERID16 hadid, DWORD fdwOpen +); +MMRESULT16 WINAPI acmDriverClose16( + HACMDRIVER16 had, DWORD fdwClose +); +LRESULT WINAPI acmDriverMessage16( + HACMDRIVER16 had, UINT16 uMsg, LPARAM lParam1, LPARAM lParam2 +); +MMRESULT16 WINAPI acmDriverID16( + HACMOBJ16 hao, LPHACMDRIVERID16 phadid, DWORD fdwDriverID +); +MMRESULT16 WINAPI acmDriverPriority16( + HACMDRIVERID16 hadid, DWORD dwPriority, DWORD fdwPriority +); +MMRESULT16 WINAPI acmFormatTagDetails16( + HACMDRIVER16 had, LPACMFORMATTAGDETAILS16 paftd, DWORD fdwDetails +); +MMRESULT16 WINAPI acmFormatTagEnum16( + HACMDRIVER16 had, LPACMFORMATTAGDETAILS16 paftd, + ACMFORMATTAGENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT16 WINAPI acmFormatChoose16( + LPACMFORMATCHOOSE16 pafmtc +); +MMRESULT16 WINAPI acmFormatDetails16( + HACMDRIVER16 had, LPACMFORMATDETAILS16 pafd, DWORD fdwDetails +); +MMRESULT16 WINAPI acmFormatEnum16( + HACMDRIVER16 had, LPACMFORMATDETAILS16 pafd, + ACMFORMATENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT16 WINAPI acmFormatSuggest16( + HACMDRIVER16 had, LPWAVEFORMATEX pwfxSrc, + LPWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest +); +MMRESULT16 WINAPI acmFilterTagDetails16( + HACMDRIVER16 had, LPACMFILTERTAGDETAILS16 paftd, DWORD fdwDetails +); +MMRESULT16 WINAPI acmFilterTagEnum16( + HACMDRIVER16 had, LPACMFILTERTAGDETAILS16 paftd, + ACMFILTERTAGENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT16 WINAPI acmFilterChoose16( + LPACMFILTERCHOOSE16 pafltrc +); +MMRESULT16 WINAPI acmFilterDetails16( + HACMDRIVER16 had, LPACMFILTERDETAILS16 pafd, DWORD fdwDetails +); +MMRESULT16 WINAPI acmFilterEnum16( + HACMDRIVER16 had, LPACMFILTERDETAILS16 pafd, + ACMFILTERENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT16 WINAPI acmStreamOpen16( + LPHACMSTREAM16 phas, HACMDRIVER16 had, + LPWAVEFORMATEX pwfxSrc, LPWAVEFORMATEX pwfxDst, + LPWAVEFILTER pwfltr, DWORD dwCallback, + DWORD dwInstance, DWORD fdwOpen +); +MMRESULT16 WINAPI acmStreamClose16( + HACMSTREAM16 has, DWORD fdwClose +); +MMRESULT16 WINAPI acmStreamSize16( + HACMSTREAM16 has, DWORD cbInput, + LPDWORD pdwOutputBytes, DWORD fdwSize +); +MMRESULT16 WINAPI acmStreamConvert16( + HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwConvert +); +MMRESULT16 WINAPI acmStreamReset16( + HACMSTREAM16 has, DWORD fdwReset +); +MMRESULT16 WINAPI acmStreamPrepareHeader16( + HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwPrepare +); +MMRESULT16 WINAPI acmStreamUnprepareHeader16( + HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwUnprepare +); + +/*********************************************************************** + * Functions - Win32 + */ + +MMRESULT WINAPI acmDriverAddA( + PHACMDRIVERID phadid, HINSTANCE hinstModule, + LPARAM lParam, DWORD dwPriority, DWORD fdwAdd +); +MMRESULT WINAPI acmDriverAddW( + PHACMDRIVERID phadid, HINSTANCE hinstModule, + LPARAM lParam, DWORD dwPriority, DWORD fdwAdd +); +MMRESULT WINAPI acmDriverClose( + HACMDRIVER had, DWORD fdwClose +); +MMRESULT WINAPI acmDriverDetailsA( + HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails +); +MMRESULT WINAPI acmDriverDetailsW( + HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails +); +MMRESULT WINAPI acmDriverEnum( + ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT WINAPI acmDriverID( + HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID +); +LRESULT WINAPI acmDriverMessage( + HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2 +); +MMRESULT WINAPI acmDriverOpen( + PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen +); +MMRESULT WINAPI acmDriverPriority( + HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority +); +MMRESULT WINAPI acmDriverRemove( + HACMDRIVERID hadid, DWORD fdwRemove +); +MMRESULT WINAPI acmFilterChooseA( + PACMFILTERCHOOSEA pafltrc +); +MMRESULT WINAPI acmFilterChooseW( + PACMFILTERCHOOSEW pafltrc +); +MMRESULT WINAPI acmFilterDetailsA( + HACMDRIVER had, PACMFILTERDETAILSA pafd, DWORD fdwDetails +); +MMRESULT WINAPI acmFilterDetailsW( + HACMDRIVER had, PACMFILTERDETAILSW pafd, DWORD fdwDetails +); +MMRESULT WINAPI acmFilterEnumA( + HACMDRIVER had, PACMFILTERDETAILSA pafd, + ACMFILTERENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT WINAPI acmFilterEnumW( + HACMDRIVER had, PACMFILTERDETAILSW pafd, + ACMFILTERENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT WINAPI acmFilterTagDetailsA( + HACMDRIVER had, PACMFILTERTAGDETAILSA paftd, DWORD fdwDetails +); +MMRESULT WINAPI acmFilterTagDetailsW( + HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, DWORD fdwDetails +); +MMRESULT WINAPI acmFilterTagEnumA( + HACMDRIVER had, PACMFILTERTAGDETAILSA paftd, + ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT WINAPI acmFilterTagEnumW( + HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, + ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT WINAPI acmFormatChooseA( + PACMFORMATCHOOSEA pafmtc +); +MMRESULT WINAPI acmFormatChooseW( + PACMFORMATCHOOSEW pafmtc +); +MMRESULT WINAPI acmFormatDetailsA( + HACMDRIVER had, PACMFORMATDETAILSA pafd, DWORD fdwDetails +); +MMRESULT WINAPI acmFormatDetailsW( + HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails +); +MMRESULT WINAPI acmFormatEnumA( + HACMDRIVER had, PACMFORMATDETAILSA pafd, + ACMFORMATENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT WINAPI acmFormatEnumW( + HACMDRIVER had, PACMFORMATDETAILSW pafd, + ACMFORMATENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT WINAPI acmFormatSuggest( + HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst, + DWORD cbwfxDst, DWORD fdwSuggest +); +MMRESULT WINAPI acmFormatTagDetailsA( + HACMDRIVER had, PACMFORMATTAGDETAILSA paftd, DWORD fdwDetails +); +MMRESULT WINAPI acmFormatTagDetailsW( + HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, DWORD fdwDetails +); +MMRESULT WINAPI acmFormatTagEnumA( + HACMDRIVER had, PACMFORMATTAGDETAILSA paftd, + ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum +); +MMRESULT WINAPI acmFormatTagEnumW( + HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, + ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum +); +DWORD WINAPI acmGetVersion( +); +MMRESULT WINAPI acmMetrics( + HACMOBJ hao, UINT uMetric, LPVOID pMetric +); +MMRESULT WINAPI acmStreamClose( + HACMSTREAM has, DWORD fdwClose +); +MMRESULT WINAPI acmStreamConvert( + HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwConvert +); +MMRESULT WINAPI acmStreamMessage( + HACMSTREAM has, UINT uMsg, LPARAM lParam1, LPARAM lParam2 +); +MMRESULT WINAPI acmStreamOpen( + PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc, + PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback, + DWORD dwInstance, DWORD fdwOpen +); +MMRESULT WINAPI acmStreamPrepareHeader( + HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwPrepare +); +MMRESULT WINAPI acmStreamReset( + HACMSTREAM has, DWORD fdwReset +); +MMRESULT WINAPI acmStreamSize( + HACMSTREAM has, DWORD cbInput, + LPDWORD pdwOutputBytes, DWORD fdwSize +); +MMRESULT WINAPI acmStreamUnprepareHeader( + HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwUnprepare +); +void MSACM_RegisterAllDrivers(void); + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* defined(__cplusplus) */ + +#endif /* __WINE_MSACM_H */ + + diff --git a/include/wine/msacmdrv.h b/include/wine/msacmdrv.h new file mode 100644 index 0000000000..2e23a17d79 --- /dev/null +++ b/include/wine/msacmdrv.h @@ -0,0 +1,203 @@ +/* + * msacmdrv.h - Declarations for MSACM driver + */ + +#ifndef __WINE_MSACMDRV_H +#define __WINE_MSACMDRV_H + +#include "windef.h" +#include "msacm.h" + +/*********************************************************************** + * Types + */ + +/*********************************************************************** + * Defines/Enums + */ + +#define MAKE_ACM_VERSION(mjr, mnr, bld) \ + (((long)(mjr)<<24) | ((long)(mnr)<<16) | ((long)bld)) + +#define ACMDRVOPENDESC_SECTIONNAME_CHARS + +#define ACMDM_DRIVER_NOTIFY (ACMDM_BASE + 1) +#define ACMDM_DRIVER_DETAILS (ACMDM_BASE + 10) + +#define ACMDM_HARDWARE_WAVE_CAPS_INPUT (ACMDM_BASE + 20) +#define ACMDM_HARDWARE_WAVE_CAPS_OUTPUT (ACMDM_BASE + 21) + +#define ACMDM_FORMATTAG_DETAILS (ACMDM_BASE + 25) +#define ACMDM_FORMAT_DETAILS (ACMDM_BASE + 26) +#define ACMDM_FORMAT_SUGGEST (ACMDM_BASE + 27) + +#define ACMDM_FILTERTAG_DETAILS (ACMDM_BASE + 50) +#define ACMDM_FILTER_DETAILS (ACMDM_BASE + 51) + +#define ACMDM_STREAM_OPEN (ACMDM_BASE + 76) +#define ACMDM_STREAM_CLOSE (ACMDM_BASE + 77) +#define ACMDM_STREAM_SIZE (ACMDM_BASE + 78) +#define ACMDM_STREAM_CONVERT (ACMDM_BASE + 79) +#define ACMDM_STREAM_RESET (ACMDM_BASE + 80) +#define ACMDM_STREAM_PREPARE (ACMDM_BASE + 81) +#define ACMDM_STREAM_UNPREPARE (ACMDM_BASE + 82) +#define ACMDM_STREAM_UPDATE (ACMDM_BASE + 83) + +/*********************************************************************** + * Structures + */ + +typedef struct _ACMDRVOPENDESCA +{ + DWORD cbStruct; + FOURCC fccType; + FOURCC fccComp; + DWORD dwVersion; + DWORD dwFlags; + DWORD dwError; + LPCSTR pszSectionName; + LPCSTR pszAliasName; + DWORD dnDevNode; +} ACMDRVOPENDESCA, *PACMDRVOPENDESCA; + +typedef struct _ACMDRVOPENDESCW +{ + DWORD cbStruct; + FOURCC fccType; + FOURCC fccComp; + DWORD dwVersion; + DWORD dwFlags; + DWORD dwError; + LPCWSTR pszSectionName; + LPCWSTR pszAliasName; + DWORD dnDevNode; +} ACMDRVOPENDESCW, *PACMDRVOPENDESCW; + +typedef struct _ACMDRVOPENDESC16 +{ + DWORD cbStruct; + FOURCC fccType; + FOURCC fccComp; + DWORD dwVersion; + DWORD dwFlags; + DWORD dwError; + LPCSTR pszSectionName; + LPCSTR pszAliasName; + DWORD dnDevNode; +} ACMDRVOPENDESC16, *NPACMDRVOPENDESC16, *LPACMDRVOPENDESC16; + +typedef struct _ACMDRVSTREAMINSTANCE16 +{ + DWORD cbStruct; + LPWAVEFORMATEX pwfxSrc; + LPWAVEFORMATEX pwfxDst; + LPWAVEFILTER pwfltr; + DWORD dwCallback; + DWORD dwInstance; + DWORD fdwOpen; + DWORD fdwDriver; + DWORD dwDriver; + HACMSTREAM16 has; +} ACMDRVSTREAMINSTANCE16, *NPACMDRVSTREAMINSTANCE16, *LPACMDRVSTREAMINSTANCE16; + +typedef struct _ACMDRVSTREAMINSTANCE +{ + DWORD cbStruct; + PWAVEFORMATEX pwfxSrc; + PWAVEFORMATEX pwfxDst; + PWAVEFILTER pwfltr; + DWORD dwCallback; + DWORD dwInstance; + DWORD fdwOpen; + DWORD fdwDriver; + DWORD dwDriver; + HACMSTREAM has; +} ACMDRVSTREAMINSTANCE, *PACMDRVSTREAMINSTANCE; + + +typedef struct _ACMDRVSTREAMHEADER16 *LPACMDRVSTREAMHEADER16; +typedef struct _ACMDRVSTREAMHEADER16 { + DWORD cbStruct; + DWORD fdwStatus; + DWORD dwUser; + LPBYTE pbSrc; + DWORD cbSrcLength; + DWORD cbSrcLengthUsed; + DWORD dwSrcUser; + LPBYTE pbDst; + DWORD cbDstLength; + DWORD cbDstLengthUsed; + DWORD dwDstUser; + + DWORD fdwConvert; + LPACMDRVSTREAMHEADER16 *padshNext; + DWORD fdwDriver; + DWORD dwDriver; + + /* Internal fields for ACM */ + DWORD fdwPrepared; + DWORD dwPrepared; + LPBYTE pbPreparedSrc; + DWORD cbPreparedSrcLength; + LPBYTE pbPreparedDst; + DWORD cbPreparedDstLength; +} ACMDRVSTREAMHEADER16, *NPACMDRVSTREAMHEADER16; + +typedef struct _ACMDRVSTREAMHEADER *PACMDRVSTREAMHEADER; +typedef struct _ACMDRVSTREAMHEADER { + DWORD cbStruct; + DWORD fdwStatus; + DWORD dwUser; + LPBYTE pbSrc; + DWORD cbSrcLength; + DWORD cbSrcLengthUsed; + DWORD dwSrcUser; + LPBYTE pbDst; + DWORD cbDstLength; + DWORD cbDstLengthUsed; + DWORD dwDstUser; + + DWORD fdwConvert; + PACMDRVSTREAMHEADER *padshNext; + DWORD fdwDriver; + DWORD dwDriver; + + /* Internal fields for ACM */ + DWORD fdwPrepared; + DWORD dwPrepared; + LPBYTE pbPreparedSrc; + DWORD cbPreparedSrcLength; + LPBYTE pbPreparedDst; + DWORD cbPreparedDstLength; +} ACMDRVSTREAMHEADER; + +typedef struct _ACMDRVSTREAMSIZE +{ + DWORD cbStruct; + DWORD fdwSize; + DWORD cbSrcLength; + DWORD cbDstLength; +} ACMDRVSTREAMSIZE16, *NPACMDRVSTREAMSIZE16, *LPACMDRVSTREAMSIZE16, + ACMDRVSTREAMSIZE, *PACMDRVSTREAMSIZE; + +typedef struct _ACMDRVFORMATSUGGEST16 +{ + DWORD cbStruct; + DWORD fdwSuggest; + LPWAVEFORMATEX pwfxSrc; + DWORD cbwfxSrc; + LPWAVEFORMATEX pwfxDst; + DWORD cbwfxDst; +} ACMDRVFORMATSUGGEST16, *NPACMDRVFORMATSUGGEST, *LPACMDRVFORMATSUGGEST; + +typedef struct _ACMDRVFORMATSUGGEST +{ + DWORD cbStruct; + DWORD fdwSuggest; + PWAVEFORMATEX pwfxSrc; + DWORD cbwfxSrc; + PWAVEFORMATEX pwfxDst; + DWORD cbwfxDst; +} ACMDRVFORMATSUGGEST, *PACMDRVFORMATSUGGEST; + +#endif /* __WINE_MSACMDRV_H */