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