Implemented most of '*Format*' API.
Improved internal object and messages handling.
Started some '*Filter*' functions.
Fixed standard headers for Winelib.
Fixed acmMetrics.
diff --git a/dlls/msacm/.cvsignore b/dlls/msacm/.cvsignore
index 52d50c0..4be7f8b 100644
--- a/dlls/msacm/.cvsignore
+++ b/dlls/msacm/.cvsignore
@@ -3,3 +3,4 @@
Makefile
libmsacm.so.1.0
libmsacm32.so.1.0
+msacm.s
diff --git a/dlls/msacm/Makefile.in b/dlls/msacm/Makefile.in
index 9a41981..812b2ef 100644
--- a/dlls/msacm/Makefile.in
+++ b/dlls/msacm/Makefile.in
@@ -16,6 +16,9 @@
msacm_main.c \
stream.c
+RC_SRCS = \
+ msacm.rc
+
@MAKE_DLL_RULES@
### Dependencies:
diff --git a/dlls/msacm/driver.c b/dlls/msacm/driver.c
index 9a185ba..574dbd6 100644
--- a/dlls/msacm/driver.c
+++ b/dlls/msacm/driver.c
@@ -142,8 +142,8 @@
return MMSYSERR_INVALFLAG;
mmr = acmDriverOpen(&acmDrvr, hadid, 0);
- if (mmr == 0) {
- mmr = (MMRESULT)acmDriverMessage(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM) padd, 0);
+ if (mmr == MMSYSERR_NOERROR) {
+ mmr = (MMRESULT)MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)padd, 0);
acmDriverClose(acmDrvr, 0);
}
@@ -157,25 +157,25 @@
MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
{
PWINE_ACMDRIVERID p;
- DWORD fdwSupport;
+ ACMDRIVERDETAILSW add;
- if (!fnCallback) {
- return MMSYSERR_INVALPARAM;
- }
+ if (!fnCallback) return MMSYSERR_INVALPARAM;
- if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
+ if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
return MMSYSERR_INVALFLAG;
- }
+ add.cbStruct = sizeof(add);
for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
- fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
+ if (acmDriverDetailsW((HACMDRIVERID)p, &add, 0) != MMSYSERR_NOERROR)
+ continue;
if (!p->bEnabled) {
if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
- fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
+ add.fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
else
continue;
}
- (*fnCallback)((HACMDRIVERID) p, dwInstance, fdwSupport);
+ if (!(*fnCallback)((HACMDRIVERID)p, dwInstance, add.fdwSupport))
+ break;
}
return MMSYSERR_NOERROR;
@@ -188,16 +188,16 @@
{
PWINE_ACMOBJ pao;
- pao = MSACM_GetObj(hao);
- if (!pao)
- return MMSYSERR_INVALHANDLE;
-
if (!phadid)
return MMSYSERR_INVALPARAM;
if (fdwDriverID)
return MMSYSERR_INVALFLAG;
+ pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
+ if (!pao)
+ return MMSYSERR_INVALHANDLE;
+
*phadid = (HACMDRIVERID) pao->pACMDriverID;
return MMSYSERR_NOERROR;
@@ -205,21 +205,16 @@
/***********************************************************************
* acmDriverMessage (MSACM32.9)
- * FIXME
- * Not implemented
+ *
*/
LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
{
- PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
- if (!pad)
- return MMSYSERR_INVALPARAM;
-
- /* FIXME: Check if uMsg legal */
-
- if (!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
- return MMSYSERR_NOTSUPPORTED;
-
- return MMSYSERR_NOERROR;
+ if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
+ uMsg == ACMDM_DRIVER_ABOUT ||
+ uMsg == DRV_QUERYCONFIGURE ||
+ uMsg == DRV_CONFIGURE)
+ return MSACM_Message(had, uMsg, lParam1, lParam2);
+ return MMSYSERR_INVALPARAM;
}
@@ -246,6 +241,7 @@
pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
if (!pad) return MMSYSERR_NOMEM;
+ pad->obj.dwType = WINE_ACMOBJ_DRIVER;
pad->obj.pACMDriverID = padid;
if (!padid->hInstModule)
diff --git a/dlls/msacm/filter.c b/dlls/msacm/filter.c
index e12e194..fc64de0 100644
--- a/dlls/msacm/filter.c
+++ b/dlls/msacm/filter.c
@@ -1,3 +1,5 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
/*
* MSACM32 library
*
@@ -9,148 +11,162 @@
#include "mmsystem.h"
#include "msacm.h"
#include "msacmdrv.h"
+#include "wineacm.h"
#include "debugtools.h"
-DEFAULT_DEBUG_CHANNEL(msacm)
+DEFAULT_DEBUG_CHANNEL(msacm);
/***********************************************************************
* acmFilterChooseA (MSACM32.13)
*/
-MMRESULT WINAPI acmFilterChooseA(
- PACMFILTERCHOOSEA pafltrc)
+MMRESULT WINAPI acmFilterChooseA(PACMFILTERCHOOSEA pafltrc)
{
- FIXME("(%p): stub\n", pafltrc);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ FIXME("(%p): stub\n", pafltrc);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return MMSYSERR_ERROR;
}
/***********************************************************************
* acmFilterChooseW (MSACM32.14)
*/
-MMRESULT WINAPI acmFilterChooseW(
- PACMFILTERCHOOSEW pafltrc)
+MMRESULT WINAPI acmFilterChooseW(PACMFILTERCHOOSEW pafltrc)
{
- FIXME("(%p): stub\n", pafltrc);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ FIXME("(%p): stub\n", pafltrc);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return MMSYSERR_ERROR;
}
/***********************************************************************
* acmFilterDetailsA (MSACM32.15)
*/
-MMRESULT WINAPI acmFilterDetailsA(
- HACMDRIVER had, PACMFILTERDETAILSA pafd, DWORD fdwDetails)
+MMRESULT WINAPI acmFilterDetailsA(HACMDRIVER had, PACMFILTERDETAILSA pafd,
+ DWORD fdwDetails)
{
- if(fdwDetails & ~(ACM_FILTERDETAILSF_FILTER))
- return MMSYSERR_INVALFLAG;
+ ACMFILTERDETAILSW afdw;
+ MMRESULT mmr;
- /* FIXME
- * How does the driver know if the ANSI or
- * the UNICODE variant of PACMFILTERDETAILS is used?
- * It might check cbStruct or does it only accept ANSI.
- */
- return (MMRESULT) acmDriverMessage(
- had, ACMDM_FILTER_DETAILS,
- (LPARAM) pafd, (LPARAM) fdwDetails
- );
+ memset(&afdw, 0, sizeof(afdw));
+ afdw.cbStruct = sizeof(afdw);
+ afdw.dwFilterIndex = pafd->dwFilterIndex;
+ afdw.dwFilterTag = pafd->dwFilterTag;
+ afdw.pwfltr = pafd->pwfltr;
+ afdw.cbwfltr = pafd->cbwfltr;
+
+ mmr = acmFilterDetailsW(had, &afdw, fdwDetails);
+ if (mmr == MMSYSERR_NOERROR) {
+ pafd->dwFilterTag = afdw.dwFilterTag;
+ pafd->fdwSupport = afdw.fdwSupport;
+ lstrcpyWtoA(pafd->szFilter, afdw.szFilter);
+ }
+ return mmr;
}
/***********************************************************************
* acmFilterDetailsW (MSACM32.16)
*/
-MMRESULT WINAPI acmFilterDetailsW(
- HACMDRIVER had, PACMFILTERDETAILSW pafd, DWORD fdwDetails)
+MMRESULT WINAPI acmFilterDetailsW(HACMDRIVER had, PACMFILTERDETAILSW pafd,
+ DWORD fdwDetails)
{
- FIXME("(0x%08x, %p, %ld): stub\n", had, pafd, fdwDetails);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ TRACE("(0x%08x, %p, %ld)\n", had, pafd, fdwDetails);
+
+ if (fdwDetails & ~(ACM_FILTERDETAILSF_FILTER))
+ return MMSYSERR_INVALFLAG;
+
+ return MSACM_Message(had, ACMDM_FILTER_DETAILS,
+ (LPARAM) pafd, (LPARAM) fdwDetails);
}
/***********************************************************************
* acmFilterEnumA (MSACM32.17)
*/
-MMRESULT WINAPI acmFilterEnumA(
- HACMDRIVER had, PACMFILTERDETAILSA pafd,
- ACMFILTERENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFilterEnumA(HACMDRIVER had, PACMFILTERDETAILSA pafd,
+ ACMFILTERENUMCBA fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, pafd, fnCallback, dwInstance, fdwEnum
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
+ had, pafd, fnCallback, dwInstance, fdwEnum);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return MMSYSERR_ERROR;
}
/***********************************************************************
* acmFilterEnumW (MSACM32.18)
*/
-MMRESULT WINAPI acmFilterEnumW(
- HACMDRIVER had, PACMFILTERDETAILSW pafd,
- ACMFILTERENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFilterEnumW(HACMDRIVER had, PACMFILTERDETAILSW pafd,
+ ACMFILTERENUMCBW fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, pafd, fnCallback, dwInstance, fdwEnum
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
+ had, pafd, fnCallback, dwInstance, fdwEnum);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return MMSYSERR_ERROR;
}
/***********************************************************************
* acmFilterTagDetailsA (MSACM32.19)
*/
-MMRESULT WINAPI acmFilterTagDetailsA(
- HACMDRIVER had, PACMFILTERTAGDETAILSA paftd, DWORD fdwDetails)
+MMRESULT WINAPI acmFilterTagDetailsA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda,
+ DWORD fdwDetails)
{
- if(fdwDetails &
- ~(ACM_FILTERTAGDETAILSF_FILTERTAG|
- ACM_FILTERTAGDETAILSF_LARGESTSIZE))
- return MMSYSERR_INVALFLAG;
+ ACMFILTERTAGDETAILSW aftdw;
+ MMRESULT mmr;
- /* FIXME
- * How does the driver know if the ANSI or
- * the UNICODE variant of PACMFILTERTAGDETAILS is used?
- * It might check cbStruct or does it only accept ANSI.
- */
- return (MMRESULT) acmDriverMessage(
- had, ACMDM_FILTERTAG_DETAILS,
- (LPARAM) paftd, (LPARAM) fdwDetails
- );
+ memset(&aftdw, 0, sizeof(aftdw));
+ aftdw.cbStruct = sizeof(aftdw);
+ aftdw.dwFilterTagIndex = paftda->dwFilterTagIndex;
+ aftdw.dwFilterTag = paftda->dwFilterTag;
+
+ mmr = acmFilterTagDetailsW(had, &aftdw, fdwDetails);
+ if (mmr == MMSYSERR_NOERROR) {
+ paftda->dwFilterTag = aftdw.dwFilterTag;
+ paftda->dwFilterTagIndex = aftdw.dwFilterTagIndex;
+ paftda->cbFilterSize = aftdw.cbFilterSize;
+ paftda->fdwSupport = aftdw.fdwSupport;
+ paftda->cStandardFilters = aftdw.cStandardFilters;
+ lstrcpyWtoA(paftda->szFilterTag, aftdw.szFilterTag);
+ }
+ return mmr;
}
/***********************************************************************
* acmFilterTagDetailsW (MSACM32.20)
*/
-MMRESULT WINAPI acmFilterTagDetailsW(
- HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, DWORD fdwDetails)
+MMRESULT WINAPI acmFilterTagDetailsW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
+ DWORD fdwDetails)
{
- FIXME("(0x%08x, %p, %ld): stub\n", had, paftd, fdwDetails);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ TRACE("(0x%08x, %p, %ld)\n", had, paftd, fdwDetails);
+
+ if (fdwDetails &
+ ~(ACM_FILTERTAGDETAILSF_FILTERTAG|
+ ACM_FILTERTAGDETAILSF_LARGESTSIZE))
+ return MMSYSERR_INVALFLAG;
+
+ return MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+ (LPARAM)paftd, (LPARAM)fdwDetails);
}
/***********************************************************************
* acmFilterTagEnumA (MSACM32.21)
*/
-MMRESULT WINAPI acmFilterTagEnumA(
- HACMDRIVER had, PACMFILTERTAGDETAILSA paftd,
- ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFilterTagEnumA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftd,
+ ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, paftd, fnCallback, dwInstance, fdwEnum
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
+ had, paftd, fnCallback, dwInstance, fdwEnum);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return MMSYSERR_ERROR;
}
/***********************************************************************
* acmFilterTagEnumW (MSACM32.22)
*/
-MMRESULT WINAPI acmFilterTagEnumW(
- HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
- ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFilterTagEnumW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
+ ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, paftd, fnCallback, dwInstance, fdwEnum
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
+ had, paftd, fnCallback, dwInstance, fdwEnum);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return MMSYSERR_ERROR;
}
diff --git a/dlls/msacm/format.c b/dlls/msacm/format.c
index 94b7973..76898dc 100644
--- a/dlls/msacm/format.c
+++ b/dlls/msacm/format.c
@@ -1,170 +1,765 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
/*
* MSACM32 library
*
* Copyright 1998 Patrik Stridvall
+ * 2000 Eric Pouech
*/
#include "winbase.h"
#include "winerror.h"
#include "windef.h"
+#include "wingdi.h"
+#include "winuser.h"
#include "debugtools.h"
#include "mmsystem.h"
#include "msacm.h"
#include "msacmdrv.h"
+#include "wineacm.h"
-DEFAULT_DEBUG_CHANNEL(msacm)
+DEFAULT_DEBUG_CHANNEL(msacm);
+
+static PACMFORMATCHOOSEA afc;
+
+struct MSACM_FillFormatData {
+ HWND hWnd;
+#define WINE_ACMFF_TAG 0
+#define WINE_ACMFF_FORMAT 1
+#define WINE_ACMFF_WFX 2
+ int mode;
+ char szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
+ PACMFORMATCHOOSEA afc;
+ DWORD ret;
+};
+
+static BOOL CALLBACK MSACM_FillFormatTagsCB(HACMDRIVERID hadid,
+ PACMFORMATTAGDETAILSA paftd,
+ DWORD dwInstance, DWORD fdwSupport)
+{
+ struct MSACM_FillFormatData* affd = (struct MSACM_FillFormatData*)dwInstance;
+
+ switch (affd->mode) {
+ case WINE_ACMFF_TAG:
+ if (SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
+ CB_FINDSTRINGEXACT,
+ (WPARAM)-1, (LPARAM)paftd->szFormatTag) == CB_ERR)
+ SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
+ CB_ADDSTRING, 0, (DWORD)paftd->szFormatTag);
+ break;
+ case WINE_ACMFF_FORMAT:
+ if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
+ HACMDRIVER had;
+
+ if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
+ ACMFORMATDETAILSA afd;
+ int i, idx;
+ MMRESULT mmr;
+ char buffer[64];
+
+ afd.cbStruct = sizeof(afd);
+ afd.dwFormatTag = paftd->dwFormatTag;
+ afd.pwfx = HeapAlloc(GetProcessHeap(), 0, paftd->cbFormatSize);
+ afd.pwfx->wFormatTag = paftd->dwFormatTag;
+ afd.pwfx->cbSize = paftd->cbFormatSize;
+ afd.cbwfx = paftd->cbFormatSize;
+
+ for (i = 0; i < paftd->cStandardFormats; i++) {
+ afd.dwFormatIndex = i;
+ mmr = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
+ if (mmr == MMSYSERR_NOERROR) {
+ strcpy(buffer, afd.szFormat);
+ for (idx = strlen(buffer);
+ idx < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; idx++)
+ buffer[idx] = ' ';
+ wsprintfA(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS,
+ "%d Ko/s",
+ (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
+ SendDlgItemMessageA(affd->hWnd,
+ IDD_ACMFORMATCHOOSE_CMB_FORMAT,
+ CB_ADDSTRING, 0, (DWORD)buffer);
+ }
+ }
+ acmDriverClose(had, 0);
+ SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
+ CB_SETCURSEL, 0, 0);
+ }
+ }
+ break;
+ case WINE_ACMFF_WFX:
+ if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
+ HACMDRIVER had;
+
+ if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
+ ACMFORMATDETAILSA afd;
+
+ afd.cbStruct = sizeof(afd);
+ afd.dwFormatTag = paftd->dwFormatTag;
+ afd.pwfx = affd->afc->pwfx;
+ afd.cbwfx = affd->afc->cbwfx;
+
+ afd.dwFormatIndex = SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_GETCURSEL, 0, 0);;
+ affd->ret = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
+ acmDriverClose(had, 0);
+ return TRUE;
+ }
+ }
+ break;
+ default:
+ FIXME("Unknown mode (%d)\n", affd->mode);
+ break;
+ }
+ return TRUE;
+}
+
+static BOOL MSACM_FillFormatTags(HWND hWnd)
+{
+ ACMFORMATTAGDETAILSA aftd;
+ struct MSACM_FillFormatData affd;
+
+ memset(&aftd, 0, sizeof(aftd));
+ aftd.cbStruct = sizeof(aftd);
+
+ affd.hWnd = hWnd;
+ affd.mode = WINE_ACMFF_TAG;
+
+ acmFormatTagEnumA((HACMDRIVER)0, &aftd, MSACM_FillFormatTagsCB, (DWORD)&affd, 0);
+ SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, CB_SETCURSEL, 0, 0);
+ return TRUE;
+}
+
+static BOOL MSACM_FillFormat(HWND hWnd)
+{
+ ACMFORMATTAGDETAILSA aftd;
+ struct MSACM_FillFormatData affd;
+
+ SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_RESETCONTENT, 0, 0);
+
+ memset(&aftd, 0, sizeof(aftd));
+ aftd.cbStruct = sizeof(aftd);
+
+ affd.hWnd = hWnd;
+ affd.mode = WINE_ACMFF_FORMAT;
+ SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
+ CB_GETLBTEXT,
+ SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
+ CB_GETCURSEL, 0, 0),
+ (DWORD)affd.szFormatTag);
+
+ acmFormatTagEnumA((HACMDRIVER)0, &aftd, MSACM_FillFormatTagsCB, (DWORD)&affd, 0);
+ SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_SETCURSEL, 0, 0);
+ return TRUE;
+}
+
+static MMRESULT MSACM_GetWFX(HWND hWnd, PACMFORMATCHOOSEA afc)
+{
+ ACMFORMATTAGDETAILSA aftd;
+ struct MSACM_FillFormatData affd;
+
+ memset(&aftd, 0, sizeof(aftd));
+ aftd.cbStruct = sizeof(aftd);
+
+ affd.hWnd = hWnd;
+ affd.mode = WINE_ACMFF_WFX;
+ affd.afc = afc;
+ affd.ret = MMSYSERR_NOERROR;
+
+ acmFormatTagEnumA((HACMDRIVER)0, &aftd, MSACM_FillFormatTagsCB, (DWORD)&affd, 0);
+ return affd.ret;
+}
+
+static BOOL WINAPI FormatChooseDlgProc(HWND hWnd, UINT msg,
+ WPARAM wParam, LPARAM lParam)
+{
+
+ TRACE("hwnd=%i msg=%i 0x%08x 0x%08lx\n", hWnd, msg, wParam, lParam );
+
+ switch (msg) {
+ case WM_INITDIALOG:
+ afc = (PACMFORMATCHOOSEA)lParam;
+ MSACM_FillFormatTags(hWnd);
+ MSACM_FillFormat(hWnd);
+ if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
+ ACMFORMATCHOOSE_STYLEF_SHOWHELP)) != 0)
+ FIXME("Unsupported style %08lx\n", ((PACMFORMATCHOOSEA)lParam)->fdwStyle);
+ if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
+ ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
+ return TRUE;
+
+ case WM_COMMAND:
+ switch (LOWORD(wParam)) {
+ case IDOK:
+ EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
+ return TRUE;
+ case IDCANCEL:
+ EndDialog(hWnd, ACMERR_CANCELED);
+ return TRUE;
+ case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
+ switch (HIWORD(wParam)) {
+ case CBN_SELCHANGE:
+ MSACM_FillFormat(hWnd);
+ break;
+ default:
+ TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n",
+ HIWORD(wParam), lParam);
+ break;
+ }
+ break;
+ case IDD_ACMFORMATCHOOSE_BTN_HELP:
+ if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
+ SendMessageA(afc->hwndOwner,
+ RegisterWindowMessageA(ACMHELPMSGSTRINGA), 0L, 0L);
+ break;
+
+ default:
+ TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n",
+ LOWORD(wParam), HIWORD(wParam), lParam);
+ break;
+ }
+ break;
+ case WM_CONTEXTMENU:
+ if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
+ SendMessageA(afc->hwndOwner,
+ RegisterWindowMessageA(ACMHELPMSGCONTEXTMENUA),
+ wParam, lParam);
+ break;
+#if defined(WM_CONTEXTHELP)
+ case WM_CONTEXTHELP:
+ if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
+ SendMessageA(afc->hwndOwner,
+ RegisterWindowMessageA(ACMHELPMSGCONTEXTHELPA),
+ wParam, lParam);
+ break;
+#endif
+ default:
+ TRACE("Dropped dlgMsg: hwnd=%i msg=%i 0x%08x 0x%08lx\n",
+ hWnd, msg, wParam, lParam );
+ break;
+ }
+ return FALSE;
+}
/***********************************************************************
* acmFormatChooseA (MSACM32.23)
*/
-MMRESULT WINAPI acmFormatChooseA(
- PACMFORMATCHOOSEA pafmtc)
+MMRESULT WINAPI acmFormatChooseA(PACMFORMATCHOOSEA pafmtc)
{
- FIXME("(%p): stub\n", pafmtc);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ return DialogBoxParamA(MSACM_hInstance32, MAKEINTRESOURCEA(DLG_ACMFORMATCHOOSE_ID),
+ pafmtc->hwndOwner, FormatChooseDlgProc, (INT)pafmtc);
}
/***********************************************************************
* acmFormatChooseW (MSACM32.24)
*/
-MMRESULT WINAPI acmFormatChooseW(
- PACMFORMATCHOOSEW pafmtc)
+MMRESULT WINAPI acmFormatChooseW(PACMFORMATCHOOSEW pafmtc)
{
- FIXME("(%p): stub\n", pafmtc);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ FIXME("(%p): stub\n", pafmtc);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return MMSYSERR_ERROR;
}
/***********************************************************************
* acmFormatDetailsA (MSACM32.25)
*/
-MMRESULT WINAPI acmFormatDetailsA(
- HACMDRIVER had, PACMFORMATDETAILSA pafd, DWORD fdwDetails)
+MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd,
+ DWORD fdwDetails)
{
- if(fdwDetails & ~(ACM_FORMATDETAILSF_FORMAT))
- return MMSYSERR_INVALFLAG;
+ ACMFORMATDETAILSW afdw;
+ MMRESULT mmr;
- /* FIXME
- * How does the driver know if the ANSI or
- * the UNICODE variant of PACMFORMATDETAILS is used?
- * It might check cbStruct or does it only accept ANSI.
- */
- return (MMRESULT) acmDriverMessage(
- had, ACMDM_FORMAT_DETAILS,
- (LPARAM) pafd, (LPARAM) fdwDetails
- );
+ memset(&afdw, 0, sizeof(afdw));
+ afdw.cbStruct = sizeof(afdw);
+ afdw.dwFormatIndex = pafd->dwFormatIndex;
+ afdw.dwFormatTag = pafd->dwFormatTag;
+ afdw.pwfx = pafd->pwfx;
+ afdw.cbwfx = pafd->cbwfx;
+
+ mmr = acmFormatDetailsW(had, &afdw, fdwDetails);
+ if (mmr == MMSYSERR_NOERROR) {
+ pafd->dwFormatTag = afdw.dwFormatTag;
+ pafd->fdwSupport = afdw.fdwSupport;
+ lstrcpyWtoA(pafd->szFormat, afdw.szFormat);
+ }
+ return mmr;
}
/***********************************************************************
* acmFormatDetailsW (MSACM32.26)
*/
-MMRESULT WINAPI acmFormatDetailsW(
- HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
+MMRESULT WINAPI acmFormatDetailsW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
+ DWORD fdwDetails)
{
- FIXME("(0x%08x, %p, %ld): stub\n", had, pafd, fdwDetails);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ MMRESULT mmr;
+ static WCHAR fmt1[] = {'%','d',' ','H','z',0};
+ static WCHAR fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
+ ACMFORMATTAGDETAILSA aftd;
+
+ TRACE("(0x%08x, %p, %ld)\n", had, pafd, fdwDetails);
+
+ memset(&aftd, 0, sizeof(aftd));
+ aftd.cbStruct = sizeof(aftd);
+
+ if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
+
+ switch (fdwDetails) {
+ case ACM_FORMATDETAILSF_FORMAT:
+ if (pafd->dwFormatTag != pafd->pwfx->wFormatTag)
+ mmr = MMSYSERR_INVALPARAM;
+ if (had == (HACMDRIVER)NULL) {
+ PWINE_ACMDRIVERID padid;
+
+ mmr = ACMERR_NOTPOSSIBLE;
+ for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+ /* should check for codec only */
+ if (padid->bEnabled &&
+ acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+ mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+ (LPARAM)pafd, (LPARAM)fdwDetails);
+ acmDriverClose(had, 0);
+ if (mmr == MMSYSERR_NOERROR) break;
+ }
+ }
+ } else {
+ mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+ (LPARAM)pafd, (LPARAM)fdwDetails);
+ }
+ break;
+ case ACM_FORMATDETAILSF_INDEX:
+ /* should check pafd->dwFormatIndex < aftd->cStandardFormats */
+ mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+ (LPARAM)pafd, (LPARAM)fdwDetails);
+ break;
+ default:
+ WARN("Unknown fdwDetails %08lx\n", fdwDetails);
+ mmr = MMSYSERR_INVALFLAG;
+ break;
+ }
+
+ if (mmr == MMSYSERR_NOERROR && pafd->szFormat[0] == (WCHAR)0) {
+ wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
+ if (pafd->pwfx->wBitsPerSample) {
+ wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2,
+ pafd->pwfx->wBitsPerSample);
+ }
+ lstrcpyAtoW(pafd->szFormat + lstrlenW(pafd->szFormat),
+ (pafd->pwfx->nChannels == 1) ? "; Mono" : "; Stereo");
+ }
+
+ TRACE("=> %d\n", mmr);
+ return mmr;
+}
+
+struct MSACM_FormatEnumWtoA_Instance {
+ PACMFORMATDETAILSA pafda;
+ DWORD dwInstance;
+ ACMFORMATENUMCBA fnCallback;
+};
+
+static BOOL CALLBACK MSACM_FormatEnumCallbackWtoA(HACMDRIVERID hadid,
+ PACMFORMATDETAILSW pafdw,
+ DWORD dwInstance,
+ DWORD fdwSupport)
+{
+ struct MSACM_FormatEnumWtoA_Instance* pafei;
+
+ pafei = (struct MSACM_FormatEnumWtoA_Instance*)dwInstance;
+
+ pafei->pafda->dwFormatIndex = pafdw->dwFormatIndex;
+ pafei->pafda->dwFormatTag = pafdw->dwFormatTag;
+ pafei->pafda->fdwSupport = pafdw->fdwSupport;
+ lstrcpyWtoA(pafei->pafda->szFormat, pafdw->szFormat);
+
+ return (pafei->fnCallback)(hadid, pafei->pafda,
+ pafei->dwInstance, fdwSupport);
}
/***********************************************************************
* acmFormatEnumA (MSACM32.27)
- */
-MMRESULT WINAPI acmFormatEnumA(
- HACMDRIVER had, PACMFORMATDETAILSA pafd,
- ACMFORMATENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
+s */
+MMRESULT WINAPI acmFormatEnumA(HACMDRIVER had, PACMFORMATDETAILSA pafda,
+ ACMFORMATENUMCBA fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, pafd, fnCallback, dwInstance, fdwEnum
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ ACMFORMATDETAILSW afdw;
+ struct MSACM_FormatEnumWtoA_Instance afei;
+
+ memset(&afdw, 0, sizeof(afdw));
+ afdw.cbStruct = sizeof(afdw);
+ afdw.dwFormatIndex = pafda->dwFormatIndex;
+ afdw.dwFormatTag = pafda->dwFormatTag;
+ afdw.pwfx = pafda->pwfx;
+ afdw.cbwfx = pafda->cbwfx;
+
+ afei.pafda = pafda;
+ afei.dwInstance = dwInstance;
+ afei.fnCallback = fnCallback;
+
+ return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA,
+ (DWORD)&afei, fdwEnum);
}
/***********************************************************************
* acmFormatEnumW (MSACM32.28)
*/
-MMRESULT WINAPI acmFormatEnumW(
- HACMDRIVER had, PACMFORMATDETAILSW pafd,
- ACMFORMATENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
+static BOOL MSACM_FormatEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
+ PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef,
+ ACMFORMATENUMCBW fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, pafd, fnCallback, dwInstance, fdwEnum
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ ACMDRIVERDETAILSW add;
+ ACMFORMATTAGDETAILSW aftd;
+ int i, j;
+
+ add.cbStruct = sizeof(add);
+
+ if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) != MMSYSERR_NOERROR) return FALSE;
+
+ for (i = 0; i < add.cFormatTags; i++) {
+ memset(&aftd, 0, sizeof(aftd));
+ aftd.cbStruct = sizeof(aftd);
+ aftd.dwFormatTagIndex = i;
+ if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
+ continue;
+
+ if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) && aftd.dwFormatTag != pwfxRef->wFormatTag)
+ continue;
+
+ for (j = 0; j < aftd.cStandardFormats; j++) {
+ pafd->dwFormatIndex = j;
+ pafd->dwFormatTag = aftd.dwFormatTag;
+ if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_INDEX) != MMSYSERR_NOERROR)
+ continue;
+
+ if ((fdwEnum & ACM_FORMATENUMF_NCHANNELS) &&
+ pafd->pwfx->nChannels != pwfxRef->nChannels)
+ continue;
+ if ((fdwEnum & ACM_FORMATENUMF_NSAMPLESPERSEC) &&
+ pafd->pwfx->nSamplesPerSec != pwfxRef->nSamplesPerSec)
+ continue;
+ if ((fdwEnum & ACM_FORMATENUMF_WBITSPERSAMPLE) &&
+ pafd->pwfx->wBitsPerSample != pwfxRef->wBitsPerSample)
+ continue;
+ if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
+ !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
+ continue;
+
+ /* more checks to be done on fdwEnum */
+
+ if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
+ return FALSE;
+ }
+ /* the "formats" used by the filters are also reported */
+ }
+ return TRUE;
+}
+
+MMRESULT WINAPI acmFormatEnumW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
+ ACMFORMATENUMCBW fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
+{
+ PWINE_ACMDRIVERID padid;
+ WAVEFORMATEX wfxRef;
+ BOOL ret;
+
+ TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
+ had, pafd, fnCallback, dwInstance, fdwEnum);
+
+ if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
+
+ if (fdwEnum & (ACM_FORMATENUMF_WFORMATTAG|ACM_FORMATENUMF_NCHANNELS|
+ ACM_FORMATENUMF_NSAMPLESPERSEC|ACM_FORMATENUMF_WBITSPERSAMPLE|
+ ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST))
+ wfxRef = *pafd->pwfx;
+
+ if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
+ !(fdwEnum & (ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT)))
+ return MMSYSERR_INVALPARAM;
+
+ if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
+ (pafd->dwFormatTag != pafd->pwfx->wFormatTag))
+ return MMSYSERR_INVALPARAM;
+
+ if (fdwEnum & (ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST|
+ ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT))
+ FIXME("Unsupported fdwEnum values\n");
+
+ if (had) {
+ HACMDRIVERID hadid;
+
+ if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
+ return MMSYSERR_INVALHANDLE;
+ return MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef,
+ fnCallback, dwInstance, fdwEnum);
+ }
+ for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+ /* should check for codec only */
+ if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
+ continue;
+ ret = MSACM_FormatEnumHelper(padid, had, pafd, &wfxRef,
+ fnCallback, dwInstance, fdwEnum);
+ acmDriverClose(had, 0);
+ if (!ret) break;
+ }
+ return MMSYSERR_NOERROR;
}
/***********************************************************************
* acmFormatSuggest (MSACM32.29)
*/
-MMRESULT WINAPI acmFormatSuggest(
- HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst,
- DWORD cbwfxDst, DWORD fdwSuggest)
+MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
+ PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ ACMDRVFORMATSUGGEST adfg;
+ MMRESULT mmr;
+
+ TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
+ had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
+
+ if (fdwSuggest & ~(ACM_FORMATSUGGESTF_NCHANNELS|ACM_FORMATSUGGESTF_NSAMPLESPERSEC|
+ ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
+ return MMSYSERR_INVALFLAG;
+
+ adfg.cbStruct = sizeof(adfg);
+ adfg.fdwSuggest = fdwSuggest;
+ adfg.pwfxSrc = pwfxSrc;
+ adfg.cbwfxSrc = (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) ?
+ sizeof(WAVEFORMATEX) : pwfxSrc->cbSize;
+ adfg.pwfxDst = pwfxDst;
+ adfg.cbwfxDst = cbwfxDst;
+
+ if (had == (HACMDRIVER)NULL) {
+ PWINE_ACMDRIVERID padid;
+
+ /* MS doc says: ACM finds the best suggestion.
+ * Well, first found will be the "best"
+ */
+ mmr = ACMERR_NOTPOSSIBLE;
+ for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+ /* should check for codec only */
+ if (!padid->bEnabled ||
+ acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
+ continue;
+
+ if (MSACM_Message(had, ACMDM_FORMAT_SUGGEST,
+ (LPARAM)&adfg, 0L) == MMSYSERR_NOERROR) {
+ mmr = MMSYSERR_NOERROR;
+ break;
+ }
+ acmDriverClose(had, 0);
+ }
+ } else {
+ mmr = MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L);
+ }
+ return mmr;
}
/***********************************************************************
* acmFormatTagDetailsA (MSACM32.30)
*/
-MMRESULT WINAPI acmFormatTagDetailsA(
- HACMDRIVER had, PACMFORMATTAGDETAILSA paftd, DWORD fdwDetails)
+MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
+ DWORD fdwDetails)
{
- if(fdwDetails &
- ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_LARGESTSIZE))
- return MMSYSERR_INVALFLAG;
+ ACMFORMATTAGDETAILSW aftdw;
+ MMRESULT mmr;
- /* FIXME
- * How does the driver know if the ANSI or
- * the UNICODE variant of PACMFORMATTAGDETAILS is used?
- * It might check cbStruct or does it only accept ANSI.
- */
- return (MMRESULT) acmDriverMessage(
- had, ACMDM_FORMATTAG_DETAILS,
- (LPARAM) paftd, (LPARAM) fdwDetails
- );
+ memset(&aftdw, 0, sizeof(aftdw));
+ aftdw.cbStruct = sizeof(aftdw);
+ aftdw.dwFormatTagIndex = paftda->dwFormatTagIndex;
+ aftdw.dwFormatTag = paftda->dwFormatTag;
+
+ mmr = acmFormatTagDetailsW(had, &aftdw, fdwDetails);
+ if (mmr == MMSYSERR_NOERROR) {
+ paftda->dwFormatTag = aftdw.dwFormatTag;
+ paftda->dwFormatTagIndex = aftdw.dwFormatTagIndex;
+ paftda->cbFormatSize = aftdw.cbFormatSize;
+ paftda->fdwSupport = aftdw.fdwSupport;
+ paftda->cStandardFormats = aftdw.cStandardFormats;
+ lstrcpyWtoA(paftda->szFormatTag, aftdw.szFormatTag);
+ }
+ return mmr;
}
/***********************************************************************
* acmFormatTagDetailsW (MSACM32.31)
*/
-MMRESULT WINAPI acmFormatTagDetailsW(
- HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, DWORD fdwDetails)
+MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
+ DWORD fdwDetails)
{
- FIXME("(0x%08x, %p, %ld): stub\n", had, paftd, fdwDetails);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ PWINE_ACMDRIVERID padid;
+ MMRESULT mmr;
+
+ TRACE("(0x%08x, %p, %ld)\n", had, paftd, fdwDetails);
+
+ if (fdwDetails & ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_INDEX|
+ ACM_FORMATTAGDETAILSF_LARGESTSIZE))
+ return MMSYSERR_INVALFLAG;
+
+ switch (fdwDetails) {
+ case ACM_FORMATTAGDETAILSF_FORMATTAG:
+ if (had == (HACMDRIVER)NULL) {
+ mmr = ACMERR_NOTPOSSIBLE;
+ for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+ /* should check for codec only */
+ if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+ mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+ (LPARAM)paftd, (LPARAM)fdwDetails);
+ acmDriverClose(had, 0);
+ if (mmr == MMSYSERR_NOERROR) break;
+ }
+ }
+ } else {
+ mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+ (LPARAM)paftd, (LPARAM)fdwDetails);
+ }
+ break;
+
+ case ACM_FORMATTAGDETAILSF_INDEX:
+ /* FIXME should check paftd->dwFormatTagIndex < add.cFormatTags */
+ mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+ (LPARAM)paftd, (LPARAM)fdwDetails);
+ break;
+
+ case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
+ if (had == (HACMDRIVER)NULL) {
+ ACMFORMATTAGDETAILSW tmp;
+ DWORD ft = paftd->dwFormatTag;
+
+ mmr = ACMERR_NOTPOSSIBLE;
+ for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+ /* should check for codec only */
+ if (padid->bEnabled &&
+ acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+
+ memset(&tmp, 0, sizeof(tmp));
+ tmp.cbStruct = sizeof(tmp);
+ tmp.dwFormatTag = ft;
+
+ if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+ (LPARAM)&tmp,
+ (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
+ if (mmr == ACMERR_NOTPOSSIBLE ||
+ paftd->cbFormatSize < tmp.cbFormatSize) {
+ *paftd = tmp;
+ mmr = MMSYSERR_NOERROR;
+ }
+ }
+ acmDriverClose(had, 0);
+ }
+ }
+ } else {
+ mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+ (LPARAM)paftd, (LPARAM)fdwDetails);
+ }
+ break;
+
+ default:
+ WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
+ mmr = MMSYSERR_ERROR;
+ }
+
+ if (mmr == MMSYSERR_NOERROR &&
+ paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
+ lstrcpyAtoW(paftd->szFormatTag, "PCM");
+
+ return mmr;
+}
+
+struct MSACM_FormatTagEnumWtoA_Instance {
+ PACMFORMATTAGDETAILSA paftda;
+ DWORD dwInstance;
+ ACMFORMATTAGENUMCBA fnCallback;
+};
+
+static BOOL CALLBACK MSACM_FormatTagEnumCallbackWtoA(HACMDRIVERID hadid,
+ PACMFORMATTAGDETAILSW paftdw,
+ DWORD dwInstance,
+ DWORD fdwSupport)
+{
+ struct MSACM_FormatTagEnumWtoA_Instance* paftei;
+
+ paftei = (struct MSACM_FormatTagEnumWtoA_Instance*)dwInstance;
+
+ paftei->paftda->dwFormatTagIndex = paftdw->dwFormatTagIndex;
+ paftei->paftda->dwFormatTag = paftdw->dwFormatTag;
+ paftei->paftda->cbFormatSize = paftdw->cbFormatSize;
+ paftei->paftda->fdwSupport = paftdw->fdwSupport;
+ paftei->paftda->cStandardFormats = paftdw->cStandardFormats;
+ lstrcpyWtoA(paftei->paftda->szFormatTag, paftdw->szFormatTag);
+
+ return (paftei->fnCallback)(hadid, paftei->paftda,
+ paftei->dwInstance, fdwSupport);
}
/***********************************************************************
* acmFormatTagEnumA (MSACM32.32)
*/
-MMRESULT WINAPI acmFormatTagEnumA(
- HACMDRIVER had, PACMFORMATTAGDETAILSA paftd,
- ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFormatTagEnumA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
+ ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, paftd, fnCallback, dwInstance, fdwEnum
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ ACMFORMATTAGDETAILSW aftdw;
+ struct MSACM_FormatTagEnumWtoA_Instance aftei;
+
+ memset(&aftdw, 0, sizeof(aftdw));
+ aftdw.cbStruct = sizeof(aftdw);
+ aftdw.dwFormatTagIndex = paftda->dwFormatTagIndex;
+ aftdw.dwFormatTag = paftda->dwFormatTag;
+
+ aftei.paftda = paftda;
+ aftei.dwInstance = dwInstance;
+ aftei.fnCallback = fnCallback;
+
+ return acmFormatTagEnumW(had, &aftdw, MSACM_FormatTagEnumCallbackWtoA,
+ (DWORD)&aftei, fdwEnum);
}
/***********************************************************************
* acmFormatTagEnumW (MSACM32.33)
*/
-MMRESULT WINAPI acmFormatTagEnumW(
- HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
- ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
+MMRESULT WINAPI acmFormatTagEnumW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
+ ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance,
+ DWORD fdwEnum)
{
- FIXME("(0x%08x, %p, %p, %ld, %ld): stub\n",
- had, paftd, fnCallback, dwInstance, fdwEnum
- );
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return MMSYSERR_ERROR;
+ PWINE_ACMDRIVERID padid;
+ ACMDRIVERDETAILSW add;
+ int i;
+ BOOL bPcmDone = FALSE;
+
+ TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
+ had, paftd, fnCallback, dwInstance, fdwEnum);
+
+ if (paftd->cbStruct < sizeof(*paftd)) return MMSYSERR_INVALPARAM;
+
+ if (had) FIXME("had != NULL, not supported\n");
+
+ for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+ /* should check for codec only */
+ if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
+ add.cbStruct = sizeof(add);
+
+ if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
+ for (i = 0; i < add.cFormatTags; i++) {
+ paftd->dwFormatTagIndex = i;
+ if (acmFormatTagDetailsW(had, paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
+ if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
+ /* FIXME (EPP): I'm not sure this is the correct
+ * algorithm (should make more sense to apply the same
+ * for all already loaded formats, but this will do
+ * for now
+ */
+ if (bPcmDone) continue;
+ bPcmDone = TRUE;
+ }
+ if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance,
+ add.fdwSupport)) {
+ padid = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ acmDriverClose(had, 0);
+ }
+ return MMSYSERR_NOERROR;
}
diff --git a/dlls/msacm/internal.c b/dlls/msacm/internal.c
index 9eb235d..8c8c51a 100644
--- a/dlls/msacm/internal.c
+++ b/dlls/msacm/internal.c
@@ -30,7 +30,7 @@
PWINE_ACMDRIVERID MSACM_pLastACMDriverID = NULL;
/***********************************************************************
- * MSACM_RegisterDriver32()
+ * MSACM_RegisterDriver()
*/
PWINE_ACMDRIVERID MSACM_RegisterDriver(LPSTR pszDriverAlias, LPSTR pszFileName,
HINSTANCE hinstModule)
@@ -40,6 +40,8 @@
TRACE("('%s', '%s', 0x%08x)\n", pszDriverAlias, pszFileName, hinstModule);
padid = (PWINE_ACMDRIVERID) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID));
+ padid->obj.dwType = WINE_ACMOBJ_DRIVERID;
+ padid->obj.pACMDriverID = padid;
padid->pszDriverAlias = HEAP_strdupA(MSACM_hHeap, 0, pszDriverAlias);
padid->pszFileName = HEAP_strdupA(MSACM_hHeap, 0, pszFileName);
padid->hInstModule = hinstModule;
@@ -57,7 +59,7 @@
}
/***********************************************************************
- * MSACM_RegisterAllDrivers32()
+ * MSACM_RegisterAllDrivers()
*/
void MSACM_RegisterAllDrivers(void)
{
@@ -95,7 +97,7 @@
}
/***********************************************************************
- * MSACM_UnregisterDriver32()
+ * MSACM_UnregisterDriver()
*/
PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p)
{
@@ -127,7 +129,7 @@
}
/***********************************************************************
- * MSACM_UnregisterAllDrivers32()
+ * MSACM_UnregisterAllDrivers()
* FIXME
* Where should this function be called?
*/
@@ -139,27 +141,40 @@
}
/***********************************************************************
- * MSACM_GetDriverID32()
+ * MSACM_GetObj()
+ */
+PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj, DWORD type)
+{
+ PWINE_ACMOBJ pao = (PWINE_ACMOBJ)hObj;
+
+ if (IsBadReadPtr(pao, sizeof(WINE_ACMOBJ)) ||
+ ((type != WINE_ACMOBJ_DONTCARE) && (type != pao->dwType)))
+ return NULL;
+ return pao;
+}
+
+/***********************************************************************
+ * MSACM_GetDriverID()
*/
PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
{
- return (PWINE_ACMDRIVERID)hDriverID;
+ return (PWINE_ACMDRIVERID)MSACM_GetObj((HACMOBJ)hDriverID, WINE_ACMOBJ_DRIVERID);
}
/***********************************************************************
- * MSACM_GetDriver32()
+ * MSACM_GetDriver()
*/
PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver)
{
- return (PWINE_ACMDRIVER)hDriver;
+ return (PWINE_ACMDRIVER)MSACM_GetObj((HACMOBJ)hDriver, WINE_ACMOBJ_DRIVER);
}
/***********************************************************************
- * MSACM_GetObj32()
+ * MSACM_Message()
*/
-PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj)
+MMRESULT MSACM_Message(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
{
- return (PWINE_ACMOBJ)hObj;
+ PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
+
+ return pad ? SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2) : MMSYSERR_INVALHANDLE;
}
-
-
diff --git a/dlls/msacm/msacm.rc b/dlls/msacm/msacm.rc
new file mode 100644
index 0000000..8288809
--- /dev/null
+++ b/dlls/msacm/msacm.rc
@@ -0,0 +1,45 @@
+/*
+ * Top level resource file for MS ACM
+ *
+ */
+
+#include "windef.h"
+#include "winuser.h"
+#include "wineacm.h"
+
+LANGUAGE 0,0
+
+DLG_ACMFORMATCHOOSE_ID DIALOG DISCARDABLE 10, 20, 225, 100
+STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Sound Selection"
+FONT 8, "MS Shell Dlg"
+BEGIN
+
+ LTEXT "&Name:", -1, 5, 5, 115, 8, NOT WS_GROUP
+
+ COMBOBOX IDD_ACMFORMATCHOOSE_CMB_CUSTOM, 5, 15, 115, 60,
+ CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+
+ PUSHBUTTON "&Save As...", IDD_ACMFORMATCHOOSE_BTN_SETNAME, 125, 14, 45, 14
+ PUSHBUTTON "&Remove", IDD_ACMFORMATCHOOSE_BTN_DELNAME, 175, 14, 45, 14
+
+ LTEXT "&Format:", -1, 5, 41, 44, 8, NOT WS_GROUP
+
+ COMBOBOX IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 50, 39, 170, 60,
+ CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+
+ LTEXT "&Attributes:", -1, 5, 59, 44, 8, NOT WS_GROUP
+
+#if 0
+ COMBOBOX IDD_ACMFORMATCHOOSE_CMB_FORMAT, 50, 57, 170, 60,
+ CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP |
+ CBS_OWNERDRAWFIXED | CBS_HASSTRINGS
+#else
+ COMBOBOX IDD_ACMFORMATCHOOSE_CMB_FORMAT, 50, 57, 170, 60,
+ CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
+#endif
+ DEFPUSHBUTTON "OK", IDOK, 48, 80, 40, 14
+ PUSHBUTTON "Cancel", IDCANCEL, 92, 80, 40, 14
+ PUSHBUTTON "&Help", IDD_ACMFORMATCHOOSE_BTN_HELP, 136, 80, 40, 14
+
+END
diff --git a/dlls/msacm/msacm32.spec b/dlls/msacm/msacm32.spec
index 9687de7..d8746ad 100644
--- a/dlls/msacm/msacm32.spec
+++ b/dlls/msacm/msacm32.spec
@@ -1,6 +1,7 @@
name msacm32
type win32
init MSACM32_LibMain
+rsrc msacm
import winmm.dll
import kernel32.dll
diff --git a/dlls/msacm/msacm32_main.c b/dlls/msacm/msacm32_main.c
index 6a9b834..274f9d5 100644
--- a/dlls/msacm/msacm32_main.c
+++ b/dlls/msacm/msacm32_main.c
@@ -20,6 +20,7 @@
/**********************************************************************/
static DWORD MSACM_dwProcessesAttached = 0;
+HINSTANCE MSACM_hInstance32 = 0;
/***********************************************************************
* MSACM_LibMain (MSACM32.init)
@@ -32,6 +33,7 @@
case DLL_PROCESS_ATTACH:
if (MSACM_dwProcessesAttached == 0) {
MSACM_hHeap = HeapCreate(0, 0x10000, 0);
+ MSACM_hInstance32 = hInstDLL;
MSACM_RegisterAllDrivers();
}
MSACM_dwProcessesAttached++;
@@ -42,6 +44,7 @@
MSACM_UnregisterAllDrivers();
HeapDestroy(MSACM_hHeap);
MSACM_hHeap = (HANDLE) NULL;
+ MSACM_hInstance32 = (HINSTANCE)NULL;
}
break;
case DLL_THREAD_ATTACH:
@@ -87,14 +90,15 @@
/***********************************************************************
* acmMetrics (MSACM32.36)
*/
-MMRESULT WINAPI acmMetrics(HACMOBJ hao, UINT uMetric, LPVOID pMetric)
+MMRESULT WINAPI acmMetrics(HACMOBJ hao, UINT uMetric, LPVOID pMetric)
{
- PWINE_ACMOBJ pao = MSACM_GetObj(hao);
+ PWINE_ACMOBJ pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
BOOL bLocal = TRUE;
PWINE_ACMDRIVERID padid;
DWORD val = 0;
+ MMRESULT mmr = MMSYSERR_NOERROR;
- FIXME("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric);
+ TRACE("(0x%08x, %d, %p);\n", hao, uMetric, pMetric);
switch (uMetric) {
case ACM_METRIC_COUNT_DRIVERS:
@@ -107,7 +111,7 @@
if (padid->bEnabled /* && (local(padid) || !bLocal) */)
val++;
*(LPDWORD)pMetric = val;
- return 0;
+ break;
case ACM_METRIC_COUNT_CODECS:
if (!pao)
@@ -120,7 +124,7 @@
if (padid->bEnabled /* && (local(padid) || !bLocal) */)
val++;
*(LPDWORD)pMetric = val;
- return 0;
+ break;
case ACM_METRIC_COUNT_CONVERTERS:
bLocal = FALSE;
@@ -131,7 +135,7 @@
if (padid->bEnabled /* && (local(padid) || !bLocal) */)
val++;
*(LPDWORD)pMetric = val;
- return 0;
+ break;
case ACM_METRIC_COUNT_FILTERS:
bLocal = FALSE;
@@ -142,7 +146,7 @@
if (padid->bEnabled /* && (local(padid) || !bLocal) */)
val++;
*(LPDWORD)pMetric = val;
- return 0;
+ break;
case ACM_METRIC_COUNT_DISABLED:
bLocal = FALSE;
@@ -154,14 +158,33 @@
if (!padid->bEnabled /* && (local(padid) || !bLocal) */)
val++;
*(LPDWORD)pMetric = val;
- return 0;
+ break;
case ACM_METRIC_MAX_SIZE_FORMAT:
- /* FIXME: According to MSDN, this should return the size of the largest WAVEFORMATEX
- structure in the system. How is this calculated? */
- *(LPDWORD)pMetric = sizeof (WAVEFORMATEX);
- return 0;
-
+ {
+ ACMFORMATTAGDETAILSW aftd;
+
+ aftd.cbStruct = sizeof(aftd);
+ aftd.dwFormatTag = WAVE_FORMAT_UNKNOWN;
+
+ if (hao == (HACMOBJ)NULL) {
+ mmr = acmFormatTagDetailsW((HACMDRIVER)NULL, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+ } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVER)) {
+ mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+ } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVERID)) {
+ HACMDRIVER had;
+
+ if (acmDriverOpen(&had, (HACMDRIVERID)hao, 0) == 0) {
+ mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+ acmDriverClose(had, 0);
+ }
+ } else {
+ mmr = MMSYSERR_INVALHANDLE;
+ }
+ if (mmr == MMSYSERR_NOERROR) *(LPDWORD)pMetric = aftd.cbFormatSize;
+ }
+ break;
+
case ACM_METRIC_COUNT_HARDWARE:
case ACM_METRIC_HARDWARE_WAVE_INPUT:
case ACM_METRIC_HARDWARE_WAVE_OUTPUT:
@@ -169,7 +192,8 @@
case ACM_METRIC_DRIVER_SUPPORT:
case ACM_METRIC_DRIVER_PRIORITY:
default:
- return MMSYSERR_NOTSUPPORTED;
+ FIXME("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric);
+ mmr = MMSYSERR_NOTSUPPORTED;
}
- return MMSYSERR_NOERROR;
+ return mmr;
}
diff --git a/dlls/msacm/stream.c b/dlls/msacm/stream.c
index 4918f87..0fe1417 100644
--- a/dlls/msacm/stream.c
+++ b/dlls/msacm/stream.c
@@ -165,6 +165,7 @@
goto errCleanUp;
}
+ was->obj.dwType = WINE_ACMOBJ_STREAM;
was->obj.pACMDriverID = wad->obj.pACMDriverID;
was->pDrv = wad;
was->hAcmDriver = 0; /* not to close it in acmStreamClose */
@@ -180,6 +181,7 @@
ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
if (ret == MMSYSERR_NOERROR) {
if ((wad = MSACM_GetDriver(had)) != 0) {
+ was->obj.dwType = WINE_ACMOBJ_STREAM;
was->obj.pACMDriverID = wad->obj.pACMDriverID;
was->pDrv = wad;
was->hAcmDriver = had;
diff --git a/dlls/msacm/wineacm.h b/dlls/msacm/wineacm.h
index b86641c..819dd59 100644
--- a/dlls/msacm/wineacm.h
+++ b/dlls/msacm/wineacm.h
@@ -6,9 +6,15 @@
typedef struct _WINE_ACMDRIVERID *PWINE_ACMDRIVERID;
typedef struct _WINE_ACMDRIVER *PWINE_ACMDRIVER;
+#define WINE_ACMOBJ_DONTCARE 0x5EED0000
+#define WINE_ACMOBJ_DRIVERID 0x5EED0001
+#define WINE_ACMOBJ_DRIVER 0x5EED0002
+#define WINE_ACMOBJ_STREAM 0x5EED0003
+
typedef struct _WINE_ACMOBJ
{
- PWINE_ACMDRIVERID pACMDriverID;
+ DWORD dwType;
+ PWINE_ACMDRIVERID pACMDriverID;
} WINE_ACMOBJ, *PWINE_ACMOBJ;
typedef struct _WINE_ACMDRIVER
@@ -29,6 +35,7 @@
typedef struct _WINE_ACMDRIVERID
{
+ WINE_ACMOBJ obj;
LPSTR pszDriverAlias;
LPSTR pszFileName;
HINSTANCE hInstModule; /* NULL if global */
@@ -43,13 +50,33 @@
extern HANDLE MSACM_hHeap;
extern PWINE_ACMDRIVERID MSACM_pFirstACMDriverID;
extern PWINE_ACMDRIVERID MSACM_pLastACMDriverID;
-PWINE_ACMDRIVERID MSACM_RegisterDriver(
- LPSTR pszDriverAlias, LPSTR pszFileName,
- HINSTANCE hinstModule);
-void MSACM_RegisterAllDrivers(void);
-PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p);
-void MSACM_UnregisterAllDrivers(void);
-PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID);
-PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver);
-PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj);
+extern PWINE_ACMDRIVERID MSACM_RegisterDriver(LPSTR pszDriverAlias, LPSTR pszFileName,
+ HINSTANCE hinstModule);
+extern void MSACM_RegisterAllDrivers(void);
+extern PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p);
+extern void MSACM_UnregisterAllDrivers(void);
+extern PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID);
+extern PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver);
+extern PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj, DWORD type);
+extern MMRESULT MSACM_Message(HACMDRIVER, UINT, LPARAM, LPARAM);
+
+/* From msacm32.c */
+extern HINSTANCE MSACM_hInstance32;
+
+/* Dialog box templates */
+#define DLG_ACMFORMATCHOOSE_ID 70
+#define IDD_ACMFORMATCHOOSE_BTN_HELP 9
+#define IDD_ACMFORMATCHOOSE_CMB_CUSTOM 100
+#define IDD_ACMFORMATCHOOSE_CMB_FORMATTAG 101
+#define IDD_ACMFORMATCHOOSE_CMB_FORMAT 102
+#define IDD_ACMFORMATCHOOSE_BTN_SETNAME 103
+#define IDD_ACMFORMATCHOOSE_BTN_DELNAME 104
+
+#define DLG_ACMFILTERCHOOSE_ID 71
+#define IDD_ACMFILTERCHOOSE_BTN_HELP 9
+#define IDD_ACMFILTERCHOOSE_CMB_CUSTOM 100
+#define IDD_ACMFILTERCHOOSE_CMB_FILTERTAG 101
+#define IDD_ACMFILTERCHOOSE_CMB_FILTER 102
+#define IDD_ACMFILTERCHOOSE_BTN_SETNAME 103
+#define IDD_ACMFILTERCHOOSE_BTN_DELNAME 104
