git.oblomov.eu Git - wine/blob - dlls/msacm/format.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  *      MSACM32 library
   5  *
   6  *      Copyright 1998  Patrik Stridvall
   7  *                2000  Eric Pouech
   8  */
   9
  10 #include <string.h>
  11 #include "winbase.h"
  12 #include "winnls.h"
  13 #include "winerror.h"
  14 #include "windef.h"
  15 #include "wingdi.h"
  16 #include "winuser.h"
  17 #include "wine/unicode.h"
  18 #include "debugtools.h"
  19 #include "mmsystem.h"
  20 #include "msacm.h"
  21 #include "msacmdrv.h"
  22 #include "wineacm.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(msacm);
  25
  26 static  PACMFORMATCHOOSEA       afc;
  27
  28 struct MSACM_FillFormatData {
  29     HWND                hWnd;
  30 #define WINE_ACMFF_TAG          0
  31 #define WINE_ACMFF_FORMAT       1
  32 #define WINE_ACMFF_WFX          2
  33     int                 mode;
  34     char                szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
  35     PACMFORMATCHOOSEA   afc;
  36     DWORD               ret;
  37 };
  38
  39 static BOOL CALLBACK MSACM_FillFormatTagsCB(HACMDRIVERID hadid,
  40                                             PACMFORMATTAGDETAILSA paftd,
  41                                             DWORD dwInstance, DWORD fdwSupport)
  42 {
  43     struct MSACM_FillFormatData*        affd = (struct MSACM_FillFormatData*)dwInstance;
  44
  45     switch (affd->mode) {
  46     case WINE_ACMFF_TAG:
  47         if (SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
  48                                 CB_FINDSTRINGEXACT,
  49                                 (WPARAM)-1, (LPARAM)paftd->szFormatTag) == CB_ERR)
  50             SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
  51                                 CB_ADDSTRING, 0, (DWORD)paftd->szFormatTag);
  52         break;
  53     case WINE_ACMFF_FORMAT:
  54         if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
  55             HACMDRIVER          had;
  56
  57             if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
  58                 ACMFORMATDETAILSA       afd;
  59                 int                     i, idx;
  60                 MMRESULT                mmr;
  61                 char                    buffer[ACMFORMATDETAILS_FORMAT_CHARS+16];
  62
  63                 afd.cbStruct = sizeof(afd);
  64                 afd.dwFormatTag = paftd->dwFormatTag;
  65                 afd.pwfx = HeapAlloc(MSACM_hHeap, 0, paftd->cbFormatSize);
  66                 if (!afd.pwfx) return FALSE;
  67                 afd.pwfx->wFormatTag = paftd->dwFormatTag;
  68                 afd.pwfx->cbSize = paftd->cbFormatSize;
  69                 afd.cbwfx = paftd->cbFormatSize;
  70
  71                 for (i = 0; i < paftd->cStandardFormats; i++) {
  72                     afd.dwFormatIndex = i;
  73                     mmr = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
  74                     if (mmr == MMSYSERR_NOERROR) {
  75                         strncpy(buffer, afd.szFormat, ACMFORMATTAGDETAILS_FORMATTAG_CHARS);
  76                         for (idx = strlen(buffer);
  77                              idx < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; idx++)
  78                             buffer[idx] = ' ';
  79                         wsprintfA(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS,
  80                                   "%d Ko/s",
  81                                   (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
  82                         SendDlgItemMessageA(affd->hWnd,
  83                                             IDD_ACMFORMATCHOOSE_CMB_FORMAT,
  84                                             CB_ADDSTRING, 0, (DWORD)buffer);
  85                     }
  86                 }
  87                 acmDriverClose(had, 0);
  88                 SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
  89                                     CB_SETCURSEL, 0, 0);
  90                 HeapFree(MSACM_hHeap, 0, afd.pwfx);
  91             }
  92         }
  93         break;
  94     case WINE_ACMFF_WFX:
  95         if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
  96             HACMDRIVER          had;
  97
  98             if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
  99                 ACMFORMATDETAILSA       afd;
 100
 101                 afd.cbStruct = sizeof(afd);
 102                 afd.dwFormatTag = paftd->dwFormatTag;
 103                 afd.pwfx = affd->afc->pwfx;
 104                 afd.cbwfx = affd->afc->cbwfx;
 105
 106                 afd.dwFormatIndex = SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
 107                                                         CB_GETCURSEL, 0, 0);;
 108                 affd->ret = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
 109                 acmDriverClose(had, 0);
 110                 return TRUE;
 111             }
 112         }
 113         break;
 114     default:
 115         FIXME("Unknown mode (%d)\n", affd->mode);
 116         break;
 117     }
 118     return TRUE;
 119 }
 120
 121 static BOOL MSACM_FillFormatTags(HWND hWnd)
 122 {
 123     ACMFORMATTAGDETAILSA        aftd;
 124     struct MSACM_FillFormatData affd;
 125
 126     memset(&aftd, 0, sizeof(aftd));
 127     aftd.cbStruct = sizeof(aftd);
 128
 129     affd.hWnd = hWnd;
 130     affd.mode = WINE_ACMFF_TAG;
 131
 132     acmFormatTagEnumA((HACMDRIVER)0, &aftd, MSACM_FillFormatTagsCB, (DWORD)&affd, 0);
 133     SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, CB_SETCURSEL, 0, 0);
 134     return TRUE;
 135 }
 136
 137 static BOOL MSACM_FillFormat(HWND hWnd)
 138 {
 139     ACMFORMATTAGDETAILSA        aftd;
 140     struct MSACM_FillFormatData affd;
 141
 142     SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_RESETCONTENT, 0, 0);
 143
 144     memset(&aftd, 0, sizeof(aftd));
 145     aftd.cbStruct = sizeof(aftd);
 146
 147     affd.hWnd = hWnd;
 148     affd.mode = WINE_ACMFF_FORMAT;
 149     SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
 150                         CB_GETLBTEXT,
 151                         SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
 152                                             CB_GETCURSEL, 0, 0),
 153                         (DWORD)affd.szFormatTag);
 154
 155     acmFormatTagEnumA((HACMDRIVER)0, &aftd, MSACM_FillFormatTagsCB, (DWORD)&affd, 0);
 156     SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_SETCURSEL, 0, 0);
 157     return TRUE;
 158 }
 159
 160 static MMRESULT MSACM_GetWFX(HWND hWnd, PACMFORMATCHOOSEA afc)
 161 {
 162     ACMFORMATTAGDETAILSA        aftd;
 163     struct MSACM_FillFormatData affd;
 164
 165     memset(&aftd, 0, sizeof(aftd));
 166     aftd.cbStruct = sizeof(aftd);
 167
 168     affd.hWnd = hWnd;
 169     affd.mode = WINE_ACMFF_WFX;
 170     affd.afc = afc;
 171     affd.ret = MMSYSERR_NOERROR;
 172
 173     acmFormatTagEnumA((HACMDRIVER)0, &aftd, MSACM_FillFormatTagsCB, (DWORD)&affd, 0);
 174     return affd.ret;
 175 }
 176
 177 static BOOL WINAPI FormatChooseDlgProc(HWND hWnd, UINT msg,
 178                                        WPARAM wParam, LPARAM lParam)
 179 {
 180
 181     TRACE("hwnd=%i msg=%i 0x%08x 0x%08lx\n", hWnd,  msg, wParam, lParam );
 182
 183     switch (msg) {
 184     case WM_INITDIALOG:
 185         afc = (PACMFORMATCHOOSEA)lParam;
 186         MSACM_FillFormatTags(hWnd);
 187         MSACM_FillFormat(hWnd);
 188         if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
 189                                ACMFORMATCHOOSE_STYLEF_SHOWHELP)) != 0)
 190             FIXME("Unsupported style %08lx\n", ((PACMFORMATCHOOSEA)lParam)->fdwStyle);
 191         if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
 192             ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
 193         return TRUE;
 194
 195     case WM_COMMAND:
 196         switch (LOWORD(wParam)) {
 197         case IDOK:
 198             EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
 199             return TRUE;
 200         case IDCANCEL:
 201             EndDialog(hWnd, ACMERR_CANCELED);
 202             return TRUE;
 203         case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
 204             switch (HIWORD(wParam)) {
 205             case CBN_SELCHANGE:
 206                 MSACM_FillFormat(hWnd);
 207                 break;
 208             default:
 209                 TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n",
 210                       HIWORD(wParam), lParam);
 211                 break;
 212             }
 213             break;
 214         case IDD_ACMFORMATCHOOSE_BTN_HELP:
 215             if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
 216                 SendMessageA(afc->hwndOwner,
 217                              RegisterWindowMessageA(ACMHELPMSGSTRINGA), 0L, 0L);
 218             break;
 219
 220         default:
 221             TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n",
 222                   LOWORD(wParam), HIWORD(wParam), lParam);
 223             break;
 224         }
 225         break;
 226     case WM_CONTEXTMENU:
 227         if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
 228             SendMessageA(afc->hwndOwner,
 229                          RegisterWindowMessageA(ACMHELPMSGCONTEXTMENUA),
 230                          wParam, lParam);
 231         break;
 232 #if defined(WM_CONTEXTHELP)
 233     case WM_CONTEXTHELP:
 234         if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
 235             SendMessageA(afc->hwndOwner,
 236                          RegisterWindowMessageA(ACMHELPMSGCONTEXTHELPA),
 237                          wParam, lParam);
 238         break;
 239 #endif
 240     default:
 241         TRACE("Dropped dlgMsg: hwnd=%i msg=%i 0x%08x 0x%08lx\n",
 242               hWnd,  msg, wParam, lParam );
 243         break;
 244     }
 245     return FALSE;
 246 }
 247
 248 /***********************************************************************
 249  *           acmFormatChooseA (MSACM32.@)
 250  */
 251 MMRESULT WINAPI acmFormatChooseA(PACMFORMATCHOOSEA pafmtc)
 252 {
 253     return DialogBoxParamA(MSACM_hInstance32, MAKEINTRESOURCEA(DLG_ACMFORMATCHOOSE_ID),
 254                            pafmtc->hwndOwner, FormatChooseDlgProc, (INT)pafmtc);
 255 }
 256
 257 /***********************************************************************
 258  *           acmFormatChooseW (MSACM32.@)
 259  */
 260 MMRESULT WINAPI acmFormatChooseW(PACMFORMATCHOOSEW pafmtc)
 261 {
 262     FIXME("(%p): stub\n", pafmtc);
 263     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 264     return MMSYSERR_ERROR;
 265 }
 266
 267 /***********************************************************************
 268  *           acmFormatDetailsA (MSACM32.@)
 269  */
 270 MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd,
 271                                   DWORD fdwDetails)
 272 {
 273     ACMFORMATDETAILSW   afdw;
 274     MMRESULT            mmr;
 275
 276     memset(&afdw, 0, sizeof(afdw));
 277     afdw.cbStruct = sizeof(afdw);
 278     afdw.dwFormatIndex = pafd->dwFormatIndex;
 279     afdw.dwFormatTag = pafd->dwFormatTag;
 280     afdw.pwfx = pafd->pwfx;
 281     afdw.cbwfx = pafd->cbwfx;
 282
 283     mmr = acmFormatDetailsW(had, &afdw, fdwDetails);
 284     if (mmr == MMSYSERR_NOERROR) {
 285         pafd->dwFormatTag = afdw.dwFormatTag;
 286         pafd->fdwSupport = afdw.fdwSupport;
 287         WideCharToMultiByte( CP_ACP, 0, afdw.szFormat, -1,
 288                              pafd->szFormat, sizeof(pafd->szFormat), NULL, NULL );
 289     }
 290     return mmr;
 291 }
 292
 293 /***********************************************************************
 294  *           acmFormatDetailsW (MSACM32.@)
 295  */
 296 MMRESULT WINAPI acmFormatDetailsW(HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
 297 {
 298     MMRESULT                    mmr;
 299     static WCHAR                fmt1[] = {'%','d',' ','H','z',0};
 300     static WCHAR                fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
 301     ACMFORMATTAGDETAILSA        aftd;
 302
 303     TRACE("(0x%08x, %p, %ld)\n", had, pafd, fdwDetails);
 304
 305     memset(&aftd, 0, sizeof(aftd));
 306     aftd.cbStruct = sizeof(aftd);
 307
 308     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 309
 310     switch (fdwDetails) {
 311     case ACM_FORMATDETAILSF_FORMAT:
 312         if (pafd->dwFormatTag != pafd->pwfx->wFormatTag) {
 313             mmr = MMSYSERR_INVALPARAM;
 314             break;
 315         }
 316         if (had == (HACMDRIVER)NULL) {
 317             PWINE_ACMDRIVERID           padid;
 318
 319             mmr = ACMERR_NOTPOSSIBLE;
 320             for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 321                 /* should check for codec only */
 322                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
 323                     acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
 324                     mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
 325                     acmDriverClose(had, 0);
 326                     if (mmr == MMSYSERR_NOERROR) break;
 327                 }
 328             }
 329         } else {
 330             mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
 331         }
 332         break;
 333     case ACM_FORMATDETAILSF_INDEX:
 334         /* should check pafd->dwFormatIndex < aftd->cStandardFormats */
 335         mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
 336         break;
 337     default:
 338         WARN("Unknown fdwDetails %08lx\n", fdwDetails);
 339         mmr = MMSYSERR_INVALFLAG;
 340         break;
 341     }
 342
 343     if (mmr == MMSYSERR_NOERROR && pafd->szFormat[0] == (WCHAR)0) {
 344         wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
 345         if (pafd->pwfx->wBitsPerSample) {
 346             wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2,
 347                       pafd->pwfx->wBitsPerSample);
 348         }
 349         MultiByteToWideChar( CP_ACP, 0, (pafd->pwfx->nChannels == 1) ? "; Mono" : "; Stereo", -1,
 350                              pafd->szFormat + strlenW(pafd->szFormat),
 351                              sizeof(pafd->szFormat)/sizeof(WCHAR) - strlenW(pafd->szFormat) );
 352     }
 353
 354     TRACE("=> %d\n", mmr);
 355     return mmr;
 356 }
 357
 358 struct MSACM_FormatEnumWtoA_Instance {
 359     PACMFORMATDETAILSA  pafda;
 360     DWORD               dwInstance;
 361     ACMFORMATENUMCBA    fnCallback;
 362 };
 363
 364 static BOOL CALLBACK MSACM_FormatEnumCallbackWtoA(HACMDRIVERID hadid,
 365                                                   PACMFORMATDETAILSW pafdw,
 366                                                   DWORD dwInstance,
 367                                                   DWORD fdwSupport)
 368 {
 369     struct MSACM_FormatEnumWtoA_Instance* pafei;
 370
 371     pafei = (struct MSACM_FormatEnumWtoA_Instance*)dwInstance;
 372
 373     pafei->pafda->dwFormatIndex = pafdw->dwFormatIndex;
 374     pafei->pafda->dwFormatTag = pafdw->dwFormatTag;
 375     pafei->pafda->fdwSupport = pafdw->fdwSupport;
 376     WideCharToMultiByte( CP_ACP, 0, pafdw->szFormat, -1,
 377                          pafei->pafda->szFormat, sizeof(pafei->pafda->szFormat), NULL, NULL );
 378
 379     return (pafei->fnCallback)(hadid, pafei->pafda,
 380                                pafei->dwInstance, fdwSupport);
 381 }
 382
 383 /***********************************************************************
 384  *           acmFormatEnumA (MSACM32.@)
 385  */
 386 MMRESULT WINAPI acmFormatEnumA(HACMDRIVER had, PACMFORMATDETAILSA pafda,
 387                                ACMFORMATENUMCBA fnCallback, DWORD dwInstance,
 388                                DWORD fdwEnum)
 389 {
 390     ACMFORMATDETAILSW           afdw;
 391     struct MSACM_FormatEnumWtoA_Instance afei;
 392
 393     memset(&afdw, 0, sizeof(afdw));
 394     afdw.cbStruct = sizeof(afdw);
 395     afdw.dwFormatIndex = pafda->dwFormatIndex;
 396     afdw.dwFormatTag = pafda->dwFormatTag;
 397     afdw.pwfx = pafda->pwfx;
 398     afdw.cbwfx = pafda->cbwfx;
 399
 400     afei.pafda = pafda;
 401     afei.dwInstance = dwInstance;
 402     afei.fnCallback = fnCallback;
 403
 404     return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA,
 405                           (DWORD)&afei, fdwEnum);
 406 }
 407
 408 /***********************************************************************
 409  *           acmFormatEnumW (MSACM32.@)
 410  */
 411 static BOOL MSACM_FormatEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
 412                                    PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef,
 413                                    ACMFORMATENUMCBW fnCallback, DWORD dwInstance,
 414                                    DWORD fdwEnum)
 415 {
 416     ACMFORMATTAGDETAILSW        aftd;
 417     int                         i, j;
 418
 419     for (i = 0; i < padid->cFormatTags; i++) {
 420         memset(&aftd, 0, sizeof(aftd));
 421         aftd.cbStruct = sizeof(aftd);
 422         aftd.dwFormatTagIndex = i;
 423         if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
 424             continue;
 425
 426         if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) && aftd.dwFormatTag != pwfxRef->wFormatTag)
 427             continue;
 428
 429         for (j = 0; j < aftd.cStandardFormats; j++) {
 430             pafd->dwFormatIndex = j;
 431             pafd->dwFormatTag = aftd.dwFormatTag;
 432             if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_INDEX) != MMSYSERR_NOERROR)
 433                 continue;
 434
 435             if ((fdwEnum & ACM_FORMATENUMF_NCHANNELS) &&
 436                 pafd->pwfx->nChannels != pwfxRef->nChannels)
 437                 continue;
 438             if ((fdwEnum & ACM_FORMATENUMF_NSAMPLESPERSEC) &&
 439                 pafd->pwfx->nSamplesPerSec != pwfxRef->nSamplesPerSec)
 440                 continue;
 441             if ((fdwEnum & ACM_FORMATENUMF_WBITSPERSAMPLE) &&
 442                 pafd->pwfx->wBitsPerSample != pwfxRef->wBitsPerSample)
 443                 continue;
 444             if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
 445                 !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
 446                 continue;
 447
 448             /* more checks to be done on fdwEnum */
 449
 450             if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, padid->fdwSupport))
 451                 return FALSE;
 452         }
 453         /* the "formats" used by the filters are also reported */
 454     }
 455     return TRUE;
 456 }
 457
 458 /**********************************************************************/
 459
 460 MMRESULT WINAPI acmFormatEnumW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
 461                                ACMFORMATENUMCBW fnCallback, DWORD dwInstance,
 462                                DWORD fdwEnum)
 463 {
 464     PWINE_ACMDRIVERID           padid;
 465     WAVEFORMATEX                wfxRef;
 466     BOOL                        ret;
 467
 468     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
 469           had, pafd, fnCallback, dwInstance, fdwEnum);
 470
 471     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 472
 473     if (fdwEnum & (ACM_FORMATENUMF_WFORMATTAG|ACM_FORMATENUMF_NCHANNELS|
 474                    ACM_FORMATENUMF_NSAMPLESPERSEC|ACM_FORMATENUMF_WBITSPERSAMPLE|
 475                    ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST))
 476         wfxRef = *pafd->pwfx;
 477
 478     if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
 479         !(fdwEnum & (ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT)))
 480         return MMSYSERR_INVALPARAM;
 481
 482     if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
 483         (pafd->dwFormatTag != pafd->pwfx->wFormatTag))
 484         return MMSYSERR_INVALPARAM;
 485
 486     if (fdwEnum & (ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST|
 487                    ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT))
 488         FIXME("Unsupported fdwEnum values %08lx\n", fdwEnum);
 489
 490     if (had) {
 491         HACMDRIVERID    hadid;
 492
 493         if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
 494             return MMSYSERR_INVALHANDLE;
 495         MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef,
 496                                fnCallback, dwInstance, fdwEnum);
 497         return MMSYSERR_NOERROR;
 498     }
 499     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 500             /* should check for codec only */
 501             if ((padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
 502                 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
 503                 continue;
 504             ret = MSACM_FormatEnumHelper(padid, had, pafd, &wfxRef,
 505                                          fnCallback, dwInstance, fdwEnum);
 506             acmDriverClose(had, 0);
 507             if (!ret) break;
 508     }
 509     return MMSYSERR_NOERROR;
 510 }
 511
 512 /***********************************************************************
 513  *           acmFormatSuggest (MSACM32.@)
 514  */
 515 MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
 516                                  PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
 517 {
 518     ACMDRVFORMATSUGGEST adfg;
 519     MMRESULT            mmr;
 520
 521     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
 522           had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
 523
 524     if (fdwSuggest & ~(ACM_FORMATSUGGESTF_NCHANNELS|ACM_FORMATSUGGESTF_NSAMPLESPERSEC|
 525                        ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
 526         return MMSYSERR_INVALFLAG;
 527
 528     adfg.cbStruct = sizeof(adfg);
 529     adfg.fdwSuggest = fdwSuggest;
 530     adfg.pwfxSrc = pwfxSrc;
 531     adfg.cbwfxSrc = (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) ?
 532         sizeof(WAVEFORMATEX) : pwfxSrc->cbSize;
 533     adfg.pwfxDst = pwfxDst;
 534     adfg.cbwfxDst = cbwfxDst;
 535
 536     if (had == (HACMDRIVER)NULL) {
 537         PWINE_ACMDRIVERID       padid;
 538
 539         /* MS doc says: ACM finds the best suggestion.
 540          * Well, first found will be the "best"
 541          */
 542         mmr = ACMERR_NOTPOSSIBLE;
 543         for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 544             /* should check for codec only */
 545             if ((padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
 546                 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
 547                 continue;
 548
 549             if (MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L) == MMSYSERR_NOERROR) {
 550                 mmr = MMSYSERR_NOERROR;
 551                 break;
 552             }
 553             acmDriverClose(had, 0);
 554         }
 555     } else {
 556         mmr = MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L);
 557     }
 558     return mmr;
 559 }
 560
 561 /***********************************************************************
 562  *           acmFormatTagDetailsA (MSACM32.@)
 563  */
 564 MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
 565                                      DWORD fdwDetails)
 566 {
 567     ACMFORMATTAGDETAILSW        aftdw;
 568     MMRESULT                    mmr;
 569
 570     memset(&aftdw, 0, sizeof(aftdw));
 571     aftdw.cbStruct = sizeof(aftdw);
 572     aftdw.dwFormatTagIndex = paftda->dwFormatTagIndex;
 573     aftdw.dwFormatTag = paftda->dwFormatTag;
 574
 575     mmr = acmFormatTagDetailsW(had, &aftdw, fdwDetails);
 576     if (mmr == MMSYSERR_NOERROR) {
 577         paftda->dwFormatTag = aftdw.dwFormatTag;
 578         paftda->dwFormatTagIndex = aftdw.dwFormatTagIndex;
 579         paftda->cbFormatSize = aftdw.cbFormatSize;
 580         paftda->fdwSupport = aftdw.fdwSupport;
 581         paftda->cStandardFormats = aftdw.cStandardFormats;
 582         WideCharToMultiByte( CP_ACP, 0, aftdw.szFormatTag, -1, paftda->szFormatTag,
 583                              sizeof(paftda->szFormatTag), NULL, NULL );
 584     }
 585     return mmr;
 586 }
 587
 588 /***********************************************************************
 589  *           acmFormatTagDetailsW (MSACM32.@)
 590  */
 591 MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
 592                                      DWORD fdwDetails)
 593 {
 594     PWINE_ACMDRIVERID   padid;
 595     MMRESULT            mmr = ACMERR_NOTPOSSIBLE;
 596
 597     TRACE("(0x%08x, %p, %ld)\n", had, paftd, fdwDetails);
 598
 599     if (fdwDetails & ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_INDEX|
 600                        ACM_FORMATTAGDETAILSF_LARGESTSIZE))
 601         return MMSYSERR_INVALFLAG;
 602
 603     switch (fdwDetails) {
 604     case ACM_FORMATTAGDETAILSF_FORMATTAG:
 605         if (had == (HACMDRIVER)NULL) {
 606             for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 607                 /* should check for codec only */
 608                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
 609                     MSACM_FindFormatTagInCache(padid, paftd->dwFormatTag, NULL) &&
 610                     acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
 611                     mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
 612                     acmDriverClose(had, 0);
 613                     if (mmr == MMSYSERR_NOERROR) break;
 614                 }
 615             }
 616         } else {
 617             PWINE_ACMDRIVER     pad = MSACM_GetDriver(had);
 618
 619             if (pad && MSACM_FindFormatTagInCache(pad->obj.pACMDriverID, paftd->dwFormatTag, NULL))
 620                 mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
 621         }
 622         break;
 623
 624     case ACM_FORMATTAGDETAILSF_INDEX:
 625         if (had != (HACMDRIVER)NULL) {
 626             PWINE_ACMDRIVER     pad = MSACM_GetDriver(had);
 627
 628             if (pad && paftd->dwFormatTagIndex < pad->obj.pACMDriverID->cFormatTags)
 629                 mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
 630         }
 631         break;
 632
 633     case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
 634         if (had == (HACMDRIVER)NULL) {
 635             ACMFORMATTAGDETAILSW        tmp;
 636             DWORD                       ft = paftd->dwFormatTag;
 637
 638             for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 639                 /* should check for codec only */
 640                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
 641                     acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
 642
 643                     memset(&tmp, 0, sizeof(tmp));
 644                     tmp.cbStruct = sizeof(tmp);
 645                     tmp.dwFormatTag = ft;
 646
 647                     if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
 648                                       (LPARAM)&tmp, fdwDetails) == MMSYSERR_NOERROR) {
 649                         if (mmr == ACMERR_NOTPOSSIBLE ||
 650                             paftd->cbFormatSize < tmp.cbFormatSize) {
 651                             *paftd = tmp;
 652                             mmr = MMSYSERR_NOERROR;
 653                         }
 654                     }
 655                     acmDriverClose(had, 0);
 656                 }
 657             }
 658         } else {
 659             mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
 660         }
 661         break;
 662
 663     default:
 664         WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
 665         mmr = MMSYSERR_ERROR;
 666     }
 667
 668     if (mmr == MMSYSERR_NOERROR &&
 669         paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
 670         MultiByteToWideChar( CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
 671                              sizeof(paftd->szFormatTag)/sizeof(WCHAR) );
 672
 673     return mmr;
 674 }
 675
 676 struct MSACM_FormatTagEnumWtoA_Instance {
 677     PACMFORMATTAGDETAILSA       paftda;
 678     DWORD                       dwInstance;
 679     ACMFORMATTAGENUMCBA         fnCallback;
 680 };
 681
 682 static BOOL CALLBACK MSACM_FormatTagEnumCallbackWtoA(HACMDRIVERID hadid,
 683                                                      PACMFORMATTAGDETAILSW paftdw,
 684                                                      DWORD dwInstance,
 685                                                      DWORD fdwSupport)
 686 {
 687     struct MSACM_FormatTagEnumWtoA_Instance* paftei;
 688
 689     paftei = (struct MSACM_FormatTagEnumWtoA_Instance*)dwInstance;
 690
 691     paftei->paftda->dwFormatTagIndex = paftdw->dwFormatTagIndex;
 692     paftei->paftda->dwFormatTag = paftdw->dwFormatTag;
 693     paftei->paftda->cbFormatSize = paftdw->cbFormatSize;
 694     paftei->paftda->fdwSupport = paftdw->fdwSupport;
 695     paftei->paftda->cStandardFormats = paftdw->cStandardFormats;
 696     WideCharToMultiByte( CP_ACP, 0, paftdw->szFormatTag, -1, paftei->paftda->szFormatTag,
 697                          sizeof(paftei->paftda->szFormatTag), NULL, NULL );
 698
 699     return (paftei->fnCallback)(hadid, paftei->paftda,
 700                                 paftei->dwInstance, fdwSupport);
 701 }
 702
 703 /***********************************************************************
 704  *           acmFormatTagEnumA (MSACM32.@)
 705  */
 706 MMRESULT WINAPI acmFormatTagEnumA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
 707                                   ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance,
 708                                   DWORD fdwEnum)
 709 {
 710     ACMFORMATTAGDETAILSW        aftdw;
 711     struct MSACM_FormatTagEnumWtoA_Instance aftei;
 712
 713     memset(&aftdw, 0, sizeof(aftdw));
 714     aftdw.cbStruct = sizeof(aftdw);
 715     aftdw.dwFormatTagIndex = paftda->dwFormatTagIndex;
 716     aftdw.dwFormatTag = paftda->dwFormatTag;
 717
 718     aftei.paftda = paftda;
 719     aftei.dwInstance = dwInstance;
 720     aftei.fnCallback = fnCallback;
 721
 722     return acmFormatTagEnumW(had, &aftdw, MSACM_FormatTagEnumCallbackWtoA,
 723                              (DWORD)&aftei, fdwEnum);
 724 }
 725
 726 /***********************************************************************
 727  *           acmFormatTagEnumW (MSACM32.@)
 728  */
 729 MMRESULT WINAPI acmFormatTagEnumW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
 730                                   ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance,
 731                                   DWORD fdwEnum)
 732 {
 733     PWINE_ACMDRIVERID           padid;
 734     int                         i;
 735     BOOL                        bPcmDone = FALSE;
 736
 737     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
 738           had, paftd, fnCallback, dwInstance, fdwEnum);
 739
 740     if (paftd->cbStruct < sizeof(*paftd)) return MMSYSERR_INVALPARAM;
 741
 742     if (had) FIXME("had != NULL, not supported\n");
 743
 744     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 745         /* should check for codec only */
 746         if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
 747             acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
 748             for (i = 0; i < padid->cFormatTags; i++) {
 749                 paftd->dwFormatTagIndex = i;
 750                 if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
 751                                   (LPARAM)paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
 752                     if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
 753                         if (paftd->szFormatTag[0] == 0)
 754                             MultiByteToWideChar( CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
 755                                                  sizeof(paftd->szFormatTag)/sizeof(WCHAR) );
 756                         /* FIXME (EPP): I'm not sure this is the correct
 757                          * algorithm (should make more sense to apply the same
 758                          * for all already loaded formats, but this will do
 759                          * for now
 760                          */
 761                         if (bPcmDone) continue;
 762                         bPcmDone = TRUE;
 763                     }
 764                     if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, padid->fdwSupport)) {
 765                         padid = NULL; /* to exist the two nested for loops */
 766                         break;
 767                     }
 768                 }
 769             }
 770         }
 771         acmDriverClose(had, 0);
 772     }
 773     return MMSYSERR_NOERROR;
 774 }