format.c

Go to the documentation of this file.

/*
 *      MSACM32 library
 *
 *      Copyright 1998  Patrik Stridvall
 *        2000  Eric Pouech
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winerror.h"
#include "wingdi.h"
#include "winuser.h"
#include "wine/debug.h"
#include "mmsystem.h"
#include "mmreg.h"
#include "msacm.h"
#include "msacmdrv.h"
#include "wineacm.h"
 
WINE_DEFAULT_DEBUG_CHANNEL(msacm);
 
struct MSACM_FillFormatData {
    HWND        hWnd;
#define WINE_ACMFF_TAG      0
#define WINE_ACMFF_FORMAT   1
#define WINE_ACMFF_WFX      2
    int         mode;
    WCHAR       szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
    PACMFORMATCHOOSEW   afc;
    DWORD       ret;
};
 
static BOOL CALLBACK MSACM_FillFormatTagsCB(HACMDRIVERID hadid,
                                            PACMFORMATTAGDETAILSW paftd,
                                            DWORD_PTR dwInstance,
                                            DWORD fdwSupport)
{
    struct MSACM_FillFormatData*    affd = (struct MSACM_FillFormatData*)dwInstance;
 
    switch (affd->mode) {
    case WINE_ACMFF_TAG:
        if (paftd->cStandardFormats > 0)
        {
            if (SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                                    CB_FINDSTRINGEXACT, -1,
                                    (LPARAM)paftd->szFormatTag) == CB_ERR)
            {
                int index = SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                                    CB_ADDSTRING, 0, (LPARAM)paftd->szFormatTag);
                if (((affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
             (paftd->dwFormatTag == affd->afc->pwfx->wFormatTag)) ||
            (!(affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
             (paftd->dwFormatTag == WAVE_FORMAT_PCM)))
                    SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                                        CB_SETCURSEL, index, 0);
            }
        }
    break;
    case WINE_ACMFF_FORMAT:
    if (lstrcmpW(affd->szFormatTag, paftd->szFormatTag) == 0) {
        HACMDRIVER      had;
 
        if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
        ACMFORMATDETAILSW   afd = {0};
                unsigned int            i, len;
        MMRESULT        mmr;
        WCHAR           buffer[ACMFORMATDETAILS_FORMAT_CHARS+16];
 
        afd.cbStruct = sizeof(afd);
        afd.dwFormatTag = paftd->dwFormatTag;
        afd.pwfx = HeapAlloc(MSACM_hHeap, 0, paftd->cbFormatSize);
        if (!afd.pwfx) return FALSE;
        afd.pwfx->wFormatTag = paftd->dwFormatTag;
        if (paftd->dwFormatTag != WAVE_FORMAT_PCM)
            afd.pwfx->cbSize = paftd->cbFormatSize - sizeof(WAVEFORMATEX);
        afd.cbwfx = paftd->cbFormatSize;
 
        for (i = 0; i < paftd->cStandardFormats; i++) {
                    static const WCHAR fmtW[] = {'%','d',' ','K','o','/','s','\0'};
                    int j, index;
 
            afd.dwFormatIndex = i;
            afd.fdwSupport = 0;
            mmr = acmFormatDetailsW(had, &afd, ACM_FORMATDETAILSF_INDEX);
            if (mmr == MMSYSERR_NOERROR) {
                       lstrcpynW(buffer, afd.szFormat, ACMFORMATTAGDETAILS_FORMATTAG_CHARS + 1);
                       len = lstrlenW(buffer);
                       for (j = len; j < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; j++)
                           buffer[j] = ' ';
                       wsprintfW(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS,
                                 fmtW, (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
                       index = SendDlgItemMessageW(affd->hWnd,
                                           IDD_ACMFORMATCHOOSE_CMB_FORMAT,
                                           CB_ADDSTRING, 0, (LPARAM)buffer);
                       if ((affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
                           affd->afc->cbwfx >= paftd->cbFormatSize &&
                           !memcmp(afd.pwfx, affd->afc->pwfx, paftd->cbFormatSize))
                           SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
                                               CB_SETCURSEL, index, 0);
            }
        }
        acmDriverClose(had, 0);
        HeapFree(MSACM_hHeap, 0, afd.pwfx);
        }
    }
    break;
    case WINE_ACMFF_WFX:
    if (lstrcmpW(affd->szFormatTag, paftd->szFormatTag) == 0) {
        HACMDRIVER      had;
 
        if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
        ACMFORMATDETAILSW   afd = {0};
 
        afd.cbStruct = sizeof(afd);
        afd.dwFormatTag = paftd->dwFormatTag;
        afd.pwfx = affd->afc->pwfx;
        afd.cbwfx = affd->afc->cbwfx;
 
        afd.dwFormatIndex = SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
                            CB_GETCURSEL, 0, 0);
        affd->ret = acmFormatDetailsW(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, PACMFORMATCHOOSEW afc)
{
    ACMFORMATTAGDETAILSW    aftd;
    struct MSACM_FillFormatData affd;
 
    memset(&aftd, 0, sizeof(aftd));
    aftd.cbStruct = sizeof(aftd);
 
    affd.hWnd = hWnd;
    affd.mode = WINE_ACMFF_TAG;
    affd.afc = afc;
 
    acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
    if (SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, CB_GETCURSEL, 0, 0) == CB_ERR)
        SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, CB_SETCURSEL, 0, 0);
    return TRUE;
}
 
static BOOL MSACM_FillFormat(HWND hWnd, PACMFORMATCHOOSEW afc)
{
    ACMFORMATTAGDETAILSW    aftd;
    struct MSACM_FillFormatData affd;
 
    SendDlgItemMessageW(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;
    affd.afc = afc;
    SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
            CB_GETLBTEXT,
            SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                        CB_GETCURSEL, 0, 0),
                        (LPARAM)affd.szFormatTag);
 
    acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
    if (SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_GETCURSEL, 0, 0) == CB_ERR)
        SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_SETCURSEL, 0, 0);
    return TRUE;
}
 
static MMRESULT MSACM_GetWFX(HWND hWnd, PACMFORMATCHOOSEW afc)
{
    ACMFORMATTAGDETAILSW    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;
    SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
            CB_GETLBTEXT,
            SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                        CB_GETCURSEL, 0, 0),
                        (LPARAM)affd.szFormatTag);
 
    acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
    return affd.ret;
}
 
static const WCHAR fmt_prop[] = {'a','c','m','p','r','o','p','\0'};
 
static INT_PTR CALLBACK FormatChooseDlgProc(HWND hWnd, UINT msg,
                                            WPARAM wParam, LPARAM lParam)
{
    PACMFORMATCHOOSEW   afc = (PACMFORMATCHOOSEW)GetPropW(hWnd, fmt_prop);
 
    TRACE("hwnd=%p msg=%i 0x%08lx 0x%08lx\n", hWnd, msg, wParam, lParam);
 
    switch (msg) {
    case WM_INITDIALOG:
    afc = (PACMFORMATCHOOSEW)lParam;
    SetPropW(hWnd, fmt_prop, (HANDLE)afc);
    MSACM_FillFormatTags(hWnd, afc);
    MSACM_FillFormat(hWnd, afc);
    if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
                   ACMFORMATCHOOSE_STYLEF_SHOWHELP|
                               ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT|
                               ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE|
                               ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE)) != 0)
            FIXME("Unsupported style %08x\n", afc->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, afc);
        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)
        SendMessageW(afc->hwndOwner,
                 RegisterWindowMessageW(ACMHELPMSGSTRINGW), 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)
        SendMessageW(afc->hwndOwner,
             RegisterWindowMessageW(ACMHELPMSGCONTEXTMENUW),
             wParam, lParam);
    break;
#if defined(WM_CONTEXTHELP)
    case WM_CONTEXTHELP:
    if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
        SendMessageW(afc->hwndOwner,
             RegisterWindowMessageW(ACMHELPMSGCONTEXTHELPW),
             wParam, lParam);
    break;
#endif
    default:
    TRACE("Dropped dlgMsg: hwnd=%p msg=%i 0x%08lx 0x%08lx\n",
          hWnd,  msg, wParam, lParam );
    break;
    }
    return FALSE;
}
 
/***********************************************************************
 *           acmFormatChooseA (MSACM32.@)
 */
MMRESULT WINAPI acmFormatChooseA(PACMFORMATCHOOSEA pafmtc)
{
    ACMFORMATCHOOSEW    afcw;
    MMRESULT            ret;
    LPWSTR              title = NULL;
    LPWSTR              name = NULL;
    LPWSTR              templ = NULL;
    DWORD               sz;
 
    if (pafmtc->cbStruct < sizeof(ACMFORMATCHOOSEA))
        return MMSYSERR_INVALPARAM;
 
    afcw.cbStruct  = sizeof(afcw);
    afcw.fdwStyle  = pafmtc->fdwStyle;
    afcw.hwndOwner = pafmtc->hwndOwner;
    afcw.pwfx      = pafmtc->pwfx;
    afcw.cbwfx     = pafmtc->cbwfx;
    if (pafmtc->pszTitle)
    {
        sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTitle, -1, NULL, 0);
        if (!(title = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
        {
            ret = MMSYSERR_NOMEM;
            goto done;
        }
        MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTitle, -1, title, sz);
    }
    afcw.pszTitle  = title;
    if (pafmtc->pszName)
    {
        sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszName, -1, NULL, 0);
        if (!(name = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
        {
            ret = MMSYSERR_NOMEM;
            goto done;
        }
        MultiByteToWideChar(CP_ACP, 0, pafmtc->pszName, -1, name, sz);
    }
    afcw.pszName   = name;
    afcw.cchName   = pafmtc->cchName;
    afcw.fdwEnum   = pafmtc->fdwEnum;
    afcw.pwfxEnum  = pafmtc->pwfxEnum;
    afcw.hInstance = pafmtc->hInstance;
    if (pafmtc->pszTemplateName)
    {
        sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTemplateName, -1, NULL, 0);
        if (!(templ = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
        {
            ret = MMSYSERR_NOMEM;
            goto done;
        }
        MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTemplateName, -1, templ, sz);
    }
    afcw.pszTemplateName = templ;
    /* FIXME: hook procs not supported yet */
    if (pafmtc->pfnHook)
    {
        FIXME("Unsupported hook procs\n");
        ret = MMSYSERR_NOTSUPPORTED;
        goto done;
    }
    ret = acmFormatChooseW(&afcw);
    if (ret == MMSYSERR_NOERROR)
    {
        WideCharToMultiByte(CP_ACP, 0, afcw.szFormatTag, -1, pafmtc->szFormatTag, sizeof(pafmtc->szFormatTag),
                            NULL, NULL);
        WideCharToMultiByte(CP_ACP, 0, afcw.szFormat, -1, pafmtc->szFormat, sizeof(pafmtc->szFormat),
                            NULL, NULL);
        if (pafmtc->pszName)
            WideCharToMultiByte(CP_ACP, 0, afcw.pszName, -1, pafmtc->pszName, pafmtc->cchName, NULL, NULL);
    }
done:
    HeapFree(GetProcessHeap(), 0, title);
    HeapFree(GetProcessHeap(), 0, name);
    HeapFree(GetProcessHeap(), 0, templ);
    return ret;
}
 
/***********************************************************************
 *           acmFormatChooseW (MSACM32.@)
 */
MMRESULT WINAPI acmFormatChooseW(PACMFORMATCHOOSEW pafmtc)
{
    if (pafmtc->cbStruct < sizeof(ACMFORMATCHOOSEW))
        return MMSYSERR_INVALPARAM;
 
    if (!pafmtc->pwfx)
        return MMSYSERR_INVALPARAM;
 
    if (pafmtc->fdwStyle & ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE)
        return DialogBoxIndirectParamW(MSACM_hInstance32, (LPCDLGTEMPLATEW)pafmtc->hInstance,
                                       pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
 
    if (pafmtc->fdwStyle & ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE)
        return DialogBoxParamW(pafmtc->hInstance, pafmtc->pszTemplateName,
                               pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
 
    return DialogBoxParamW(MSACM_hInstance32, MAKEINTRESOURCEW(DLG_ACMFORMATCHOOSE_ID),
                           pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
}
 
/***********************************************************************
 *           acmFormatDetailsA (MSACM32.@)
 */
MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd,
                  DWORD fdwDetails)
{
    ACMFORMATDETAILSW   afdw;
    MMRESULT        mmr;
 
    if (!pafd)
        return MMSYSERR_INVALPARAM;
 
    memset(&afdw, 0, sizeof(afdw));
    afdw.cbStruct = sizeof(afdw);
    afdw.dwFormatIndex = pafd->dwFormatIndex;
    afdw.dwFormatTag = pafd->dwFormatTag;
    afdw.fdwSupport = pafd->fdwSupport;
    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;
        WideCharToMultiByte( CP_ACP, 0, afdw.szFormat, -1,
                             pafd->szFormat, sizeof(pafd->szFormat), NULL, NULL );
    }
    return mmr;
}
 
/***********************************************************************
 *           acmFormatDetailsW (MSACM32.@)
 */
MMRESULT WINAPI acmFormatDetailsW(HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
{
    MMRESULT            mmr;
    static const WCHAR      fmt1[] = {'%','d',' ','H','z',0};
    static const WCHAR      fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
    ACMFORMATTAGDETAILSW    aftd = {0};
 
    TRACE("(%p, %p, %d)\n", had, pafd, fdwDetails);
 
    if (!pafd)
        return MMSYSERR_INVALPARAM;
 
    if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 
    if (!pafd->pwfx)
        return MMSYSERR_INVALPARAM;
 
    if (pafd->cbwfx < sizeof(PCMWAVEFORMAT))
        return MMSYSERR_INVALPARAM;
 
    if (pafd->fdwSupport)
        return MMSYSERR_INVALPARAM;
 
    if (pafd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
        return MMSYSERR_INVALPARAM;
 
    switch (fdwDetails) {
    case ACM_FORMATDETAILSF_FORMAT:
    if (pafd->dwFormatTag != pafd->pwfx->wFormatTag) {
        mmr = MMSYSERR_INVALPARAM;
        break;
    }
    if (had == NULL) {
        PWINE_ACMDRIVERID       padid;
 
        mmr = ACMERR_NOTPOSSIBLE;
        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
            mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
            acmDriverClose(had, 0);
            if (mmr == MMSYSERR_NOERROR) break;
        }
        }
    } else {
        mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
    }
    break;
    case ACM_FORMATDETAILSF_INDEX:
        aftd.cbStruct = sizeof(aftd);
        aftd.dwFormatTag = pafd->dwFormatTag;
        mmr = acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_FORMATTAG);
        if (mmr != MMSYSERR_NOERROR)
            break;
        if (pafd->dwFormatIndex >= aftd.cStandardFormats)
        {
            mmr = MMSYSERR_INVALPARAM;
            break;
        }
    mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
    break;
    default:
    WARN("Unknown fdwDetails %08x\n", fdwDetails);
    mmr = MMSYSERR_INVALFLAG;
    break;
    }
 
    if (mmr == MMSYSERR_NOERROR && pafd->szFormat[0] == 0) {
    wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
    if (pafd->pwfx->wBitsPerSample) {
        wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2,
              pafd->pwfx->wBitsPerSample);
    }
        MultiByteToWideChar(CP_ACP, 0, (pafd->pwfx->nChannels == 1) ? "; Mono" : "; Stereo", -1,
                            pafd->szFormat + lstrlenW(pafd->szFormat),
                            ARRAY_SIZE(pafd->szFormat) - lstrlenW(pafd->szFormat));
    }
 
    TRACE("=> %d\n", mmr);
    return mmr;
}
 
struct MSACM_FormatEnumWtoA_Instance {
    PACMFORMATDETAILSA pafda;
    DWORD_PTR          dwInstance;
    ACMFORMATENUMCBA   fnCallback;
};
 
static BOOL CALLBACK MSACM_FormatEnumCallbackWtoA(HACMDRIVERID hadid,
                          PACMFORMATDETAILSW pafdw,
                                                  DWORD_PTR 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;
    WideCharToMultiByte( CP_ACP, 0, pafdw->szFormat, -1,
                         pafei->pafda->szFormat, sizeof(pafei->pafda->szFormat), NULL, NULL );
 
    return (pafei->fnCallback)(hadid, pafei->pafda,
                   pafei->dwInstance, fdwSupport);
}
 
/***********************************************************************
 *           acmFormatEnumA (MSACM32.@)
 */
MMRESULT WINAPI acmFormatEnumA(HACMDRIVER had, PACMFORMATDETAILSA pafda,
                               ACMFORMATENUMCBA fnCallback,
                               DWORD_PTR dwInstance, DWORD fdwEnum)
{
    ACMFORMATDETAILSW       afdw;
    struct MSACM_FormatEnumWtoA_Instance afei;
 
    if (!pafda)
        return MMSYSERR_INVALPARAM;
 
    if (!fnCallback)
        return MMSYSERR_INVALPARAM;
 
    if (pafda->cbStruct < sizeof(*pafda))
        return MMSYSERR_INVALPARAM;
 
    memset(&afdw, 0, sizeof(afdw));
    afdw.cbStruct = sizeof(afdw);
    afdw.dwFormatIndex = pafda->dwFormatIndex;
    afdw.dwFormatTag = pafda->dwFormatTag;
    afdw.fdwSupport = pafda->fdwSupport;
    afdw.pwfx = pafda->pwfx;
    afdw.cbwfx = pafda->cbwfx;
 
    afei.pafda = pafda;
    afei.dwInstance = dwInstance;
    afei.fnCallback = fnCallback;
 
    return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA,
                          (DWORD_PTR)&afei, fdwEnum);
}
 
/***********************************************************************
 *           acmFormatEnumW (MSACM32.@)
 */
static BOOL MSACM_FormatEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
                   PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef,
                                   ACMFORMATENUMCBW fnCallback,
                                   DWORD_PTR dwInstance, DWORD fdwEnum)
{
    ACMFORMATTAGDETAILSW    aftd;
    unsigned int            i, j;
 
    if (fdwEnum & ACM_FORMATENUMF_SUGGEST) {
        HDRVR hdrvr;
        ACMDRVFORMATSUGGEST adfs;
        pafd->dwFormatIndex = 0;
        memset(&aftd, 0, sizeof(aftd));
        aftd.cbStruct = sizeof(aftd);
        memset(&adfs, 0, sizeof(adfs));
        adfs.cbStruct = sizeof(adfs);
 
        for (i = 0; i < padid->cFormatTags; i++) {
            aftd.dwFormatTag = i;
            pafd->dwFormatTag = aftd.dwFormatTag;
            pafd->pwfx->wFormatTag = pafd->dwFormatTag;
 
            if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
                continue;
 
            adfs.cbwfxSrc = aftd.cbFormatSize;
            adfs.cbwfxDst = aftd.cbFormatSize;
            adfs.pwfxSrc = pwfxRef;
            adfs.pwfxDst = pafd->pwfx;
            pafd->fdwSupport = padid->fdwSupport;
 
            if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
                aftd.dwFormatTag != pwfxRef->wFormatTag)
                continue;
 
            if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
                !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
                continue;
 
            hdrvr = OpenDriver(padid->pszFileName,0,0);
            SendDriverMessage(hdrvr,ACMDM_FORMAT_SUGGEST,(LPARAM)&adfs,(fdwEnum & 0x000000FFL));
 
            if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_FORMAT) != MMSYSERR_NOERROR)
                continue;
 
            pafd->cbwfx = sizeof(*(pafd->pwfx));
 
            if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, padid->fdwSupport))
                return FALSE;
        }
    } else {
        for (i = 0; i < padid->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;
                pafd->fdwSupport = 0;
                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, padid->fdwSupport))
                    return FALSE;
            }
        /* the "formats" used by the filters are also reported */
        }
    }
    return TRUE;
}
 
/**********************************************************************/
 
MMRESULT WINAPI acmFormatEnumW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
                               ACMFORMATENUMCBW fnCallback,
                               DWORD_PTR dwInstance, DWORD fdwEnum)
{
    PWINE_ACMDRIVERID       padid;
    WAVEFORMATEX        wfxRef;
    BOOL            ret;
    DWORD           cbwfxMax;
    MMRESULT            mmr;
 
    TRACE("(%p, %p, %p, %ld, %d)\n",
      had, pafd, fnCallback, dwInstance, fdwEnum);
 
    if (!pafd)
        return MMSYSERR_INVALPARAM;
 
    if (!fnCallback)
        return MMSYSERR_INVALPARAM;
 
    if (pafd->cbStruct < sizeof(*pafd))
        return MMSYSERR_INVALPARAM;
 
    if (pafd->fdwSupport)
        return MMSYSERR_INVALPARAM;
 
    if (!pafd->pwfx)
        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_INPUT|ACM_FORMATENUMF_OUTPUT))
    FIXME("Unsupported fdwEnum values %08x\n", fdwEnum);
 
    mmr = acmMetrics((HACMOBJ)had, ACM_METRIC_MAX_SIZE_FORMAT, &cbwfxMax);
    if (mmr != MMSYSERR_NOERROR)
        return mmr;
    if (pafd->cbwfx < cbwfxMax)
        return MMSYSERR_INVALPARAM;
 
    if (had) {
    HACMDRIVERID    hadid;
 
    if (acmDriverID((HACMOBJ)had, &hadid, 0) != MMSYSERR_NOERROR)
        return MMSYSERR_INVALHANDLE;
    MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef,
                   fnCallback, dwInstance, fdwEnum);
    return MMSYSERR_NOERROR;
    }
    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if ((padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
        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.@)
 */
MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
                 PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
{
    ACMFORMATTAGDETAILSW aftd = {0};
    ACMDRVFORMATSUGGEST adfg;
    MMRESULT        mmr;
 
    TRACE("(%p, %p, %p, %d, %d)\n",
      had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
 
    if (!pwfxSrc || !pwfxDst)
        return MMSYSERR_INVALPARAM;
 
    if (fdwSuggest & ~(ACM_FORMATSUGGESTF_NCHANNELS|ACM_FORMATSUGGESTF_NSAMPLESPERSEC|
               ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
    return MMSYSERR_INVALFLAG;
 
    /* if we were given PCM, try to convert to PCM */
    if (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && !had &&
        !(fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
    {
        ACMFORMATDETAILSW afd = {0};
        afd.cbStruct = sizeof(afd);
        afd.dwFormatTag = WAVE_FORMAT_PCM;
        afd.pwfx = pwfxSrc;
        afd.cbwfx = sizeof(PCMWAVEFORMAT);
        if (!acmFormatDetailsW(had, &afd, ACM_FORMATDETAILSF_FORMAT))
        {
            memcpy(pwfxDst, pwfxSrc, sizeof(PCMWAVEFORMAT));
            return MMSYSERR_NOERROR;
        }
    }
 
    aftd.cbStruct = sizeof(aftd);
    if (fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG)
        aftd.dwFormatTag = pwfxDst->wFormatTag;
    mmr = acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
    if ((fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG) && mmr == ACMERR_NOTPOSSIBLE)
        return ACMERR_NOTPOSSIBLE;
 
    if (cbwfxDst < aftd.cbFormatSize)
        return MMSYSERR_INVALPARAM;
 
    adfg.cbStruct = sizeof(adfg);
    adfg.fdwSuggest = fdwSuggest;
    adfg.pwfxSrc = pwfxSrc;
    adfg.cbwfxSrc = (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) ?
    sizeof(WAVEFORMATEX) : (sizeof(WAVEFORMATEX) + pwfxSrc->cbSize);
    adfg.pwfxDst = pwfxDst;
    adfg.cbwfxDst = cbwfxDst;
 
    if (had == 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->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
        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.@)
 */
MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
                     DWORD fdwDetails)
{
    ACMFORMATTAGDETAILSW    aftdw;
    MMRESULT            mmr;
 
    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;
        WideCharToMultiByte( CP_ACP, 0, aftdw.szFormatTag, -1, paftda->szFormatTag,
                             sizeof(paftda->szFormatTag), NULL, NULL );
    }
    return mmr;
}
 
/***********************************************************************
 *           acmFormatTagDetailsW (MSACM32.@)
 */
MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
                     DWORD fdwDetails)
{
    PWINE_ACMDRIVERID   padid;
    MMRESULT        mmr = ACMERR_NOTPOSSIBLE;
 
    TRACE("(%p, %p, %d)\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 == NULL) {
        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
            MSACM_FindFormatTagInCache(padid, paftd->dwFormatTag, NULL) &&
            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
            mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
            acmDriverClose(had, 0);
            if (mmr == MMSYSERR_NOERROR) break;
        }
        }
    } else {
        PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
 
        if (pad && MSACM_FindFormatTagInCache(pad->obj.pACMDriverID, paftd->dwFormatTag, NULL))
        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
    }
    break;
 
    case ACM_FORMATTAGDETAILSF_INDEX:
    if (had != NULL) {
        PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
 
        if (pad && paftd->dwFormatTagIndex < pad->obj.pACMDriverID->cFormatTags)
        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
    }
    break;
 
    case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
    if (had == NULL) {
        ACMFORMATTAGDETAILSW    tmp;
        DWORD           ft = paftd->dwFormatTag;
 
        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
            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, 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, fdwDetails);
    }
    break;
 
    default:
    WARN("Unsupported fdwDetails=%08x\n", fdwDetails);
    mmr = MMSYSERR_ERROR;
    }
 
    if (mmr == MMSYSERR_NOERROR &&
    paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
        MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
                            ARRAY_SIZE(paftd->szFormatTag));
 
    return mmr;
}
 
struct MSACM_FormatTagEnumWtoA_Instance {
    PACMFORMATTAGDETAILSA paftda;
    DWORD_PTR             dwInstance;
    ACMFORMATTAGENUMCBA   fnCallback;
};
 
static BOOL CALLBACK MSACM_FormatTagEnumCallbackWtoA(HACMDRIVERID hadid,
                             PACMFORMATTAGDETAILSW paftdw,
                                                     DWORD_PTR 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;
    WideCharToMultiByte( CP_ACP, 0, paftdw->szFormatTag, -1, paftei->paftda->szFormatTag,
                         sizeof(paftei->paftda->szFormatTag), NULL, NULL );
 
    return (paftei->fnCallback)(hadid, paftei->paftda,
                paftei->dwInstance, fdwSupport);
}
 
/***********************************************************************
 *           acmFormatTagEnumA (MSACM32.@)
 */
MMRESULT WINAPI acmFormatTagEnumA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
                                  ACMFORMATTAGENUMCBA fnCallback,
                                  DWORD_PTR dwInstance, DWORD fdwEnum)
{
    ACMFORMATTAGDETAILSW    aftdw;
    struct MSACM_FormatTagEnumWtoA_Instance aftei;
 
    if (!paftda)
        return MMSYSERR_INVALPARAM;
 
    if (paftda->cbStruct < sizeof(*paftda))
        return MMSYSERR_INVALPARAM;
 
    if (fdwEnum != 0)
        return MMSYSERR_INVALFLAG;
 
    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_PTR)&aftei, fdwEnum);
}
 
/***********************************************************************
 *           acmFormatTagEnumW (MSACM32.@)
 */
MMRESULT WINAPI acmFormatTagEnumW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
                                  ACMFORMATTAGENUMCBW fnCallback,
                                  DWORD_PTR dwInstance, DWORD fdwEnum)
{
    PWINE_ACMDRIVERID   padid;
    unsigned int        i;
    BOOL                bPcmDone = FALSE;
 
    TRACE("(%p, %p, %p, %ld, %d)\n",
          had, paftd, fnCallback, dwInstance, fdwEnum);
 
    if (!paftd)
        return MMSYSERR_INVALPARAM;
 
    if (paftd->cbStruct < sizeof(*paftd))
        return MMSYSERR_INVALPARAM;
 
    if (fdwEnum != 0)
        return MMSYSERR_INVALFLAG;
 
    /* (WS) MSDN info page says that if had != 0, then we should find
     * the specific driver to get its tags from. Therefore I'm removing
     * the FIXME call and adding a search block below. It also seems
     * that the lack of this functionality was the responsible for 
     * codecs to be multiply and incorrectly listed. 
     */
 
    /* if (had) FIXME("had != NULL, not supported\n"); */
 
    if (had) {
        if (acmDriverID((HACMOBJ)had, (HACMDRIVERID *)&padid, 0) != MMSYSERR_NOERROR)
        return MMSYSERR_INVALHANDLE;
 
        for (i = 0; i < padid->cFormatTags; i++) {
            paftd->dwFormatTagIndex = i;
            if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
                (LPARAM)paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
                if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
                    if (paftd->szFormatTag[0] == 0)
                        MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
                                            ARRAY_SIZE(paftd->szFormatTag));
                    /* (WS) I'm preserving this PCM hack since it seems to be
                     * correct. Please notice this block was borrowed from
                     * below.
                     */
                    if (bPcmDone) continue;
                    bPcmDone = TRUE;
                }
                if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, padid->fdwSupport))
                    return MMSYSERR_NOERROR;
            }
        }
    }
    /* if had==0 then search for the first suitable driver */
    else {
        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
            /* should check for codec only */
            if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
                acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
                for (i = 0; i < padid->cFormatTags; i++) {
                    paftd->dwFormatTagIndex = i;
                    if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
                        (LPARAM)paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
                        if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
                            if (paftd->szFormatTag[0] == 0)
                                MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
                                                    ARRAY_SIZE(paftd->szFormatTag));
                            /* 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, padid->fdwSupport)) {
                            acmDriverClose(had, 0);
                            return MMSYSERR_NOERROR;
                        }
                    }
                }
                acmDriverClose(had, 0);
            }
        }
    }
    return MMSYSERR_NOERROR;
}