?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
quartz/tests: Make testpin_{AddRef,Release}() static.
[wine.git] / dlls / msacm32 / format.c
blobfcc0d9b1c62ae3437ea254c33b579777d3d983cd
1 /*
2 * MSACM32 library
3 *
4 * Copyright 1998 Patrik Stridvall
5 * 2000 Eric Pouech
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23 #include <string.h>
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winnls.h"
27 #include "winerror.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "wine/unicode.h"
31 #include "wine/debug.h"
32 #include "mmsystem.h"
33 #include "mmreg.h"
34 #include "msacm.h"
35 #include "msacmdrv.h"
36 #include "wineacm.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(msacm);
39
40 struct MSACM_FillFormatData {
41 HWND hWnd;
42 #define WINE_ACMFF_TAG 0
43 #define WINE_ACMFF_FORMAT 1
44 #define WINE_ACMFF_WFX 2
45 int mode;
46 WCHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
47 PACMFORMATCHOOSEW afc;
48 DWORD ret;
49 };
50
51 static BOOL CALLBACK MSACM_FillFormatTagsCB(HACMDRIVERID hadid,
52 PACMFORMATTAGDETAILSW paftd,
53 DWORD_PTR dwInstance,
54 DWORD fdwSupport)
55 {
56 struct MSACM_FillFormatData* affd = (struct MSACM_FillFormatData*)dwInstance;
57
58 switch (affd->mode) {
59 case WINE_ACMFF_TAG:
60 if (paftd->cStandardFormats > 0)
61 {
62 if (SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
63 CB_FINDSTRINGEXACT, -1,
64 (LPARAM)paftd->szFormatTag) == CB_ERR)
65 {
66 int index = SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
67 CB_ADDSTRING, 0, (LPARAM)paftd->szFormatTag);
68 if (((affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
69 (paftd->dwFormatTag == affd->afc->pwfx->wFormatTag)) ||
70 (!(affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
71 (paftd->dwFormatTag == WAVE_FORMAT_PCM)))
72 SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
73 CB_SETCURSEL, index, 0);
74 }
75 }
76 break;
77 case WINE_ACMFF_FORMAT:
78 if (strcmpW(affd->szFormatTag, paftd->szFormatTag) == 0) {
79 HACMDRIVER had;
80
81 if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
82 ACMFORMATDETAILSW afd = {0};
83 unsigned int i, len;
84 MMRESULT mmr;
85 WCHAR buffer[ACMFORMATDETAILS_FORMAT_CHARS+16];
86
87 afd.cbStruct = sizeof(afd);
88 afd.dwFormatTag = paftd->dwFormatTag;
89 afd.pwfx = HeapAlloc(MSACM_hHeap, 0, paftd->cbFormatSize);
90 if (!afd.pwfx) return FALSE;
91 afd.pwfx->wFormatTag = paftd->dwFormatTag;
92 if (paftd->dwFormatTag != WAVE_FORMAT_PCM)
93 afd.pwfx->cbSize = paftd->cbFormatSize - sizeof(WAVEFORMATEX);
94 afd.cbwfx = paftd->cbFormatSize;
95
96 for (i = 0; i < paftd->cStandardFormats; i++) {
97 static const WCHAR fmtW[] = {'%','d',' ','K','o','/','s','\0'};
98 int j, index;
99
100 afd.dwFormatIndex = i;
101 afd.fdwSupport = 0;
102 mmr = acmFormatDetailsW(had, &afd, ACM_FORMATDETAILSF_INDEX);
103 if (mmr == MMSYSERR_NOERROR) {
104 lstrcpynW(buffer, afd.szFormat, ACMFORMATTAGDETAILS_FORMATTAG_CHARS + 1);
105 len = strlenW(buffer);
106 for (j = len; j < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; j++)
107 buffer[j] = ' ';
108 wsprintfW(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS,
109 fmtW, (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
110 index = SendDlgItemMessageW(affd->hWnd,
111 IDD_ACMFORMATCHOOSE_CMB_FORMAT,
112 CB_ADDSTRING, 0, (LPARAM)buffer);
113 if ((affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
114 affd->afc->cbwfx >= paftd->cbFormatSize &&
115 !memcmp(afd.pwfx, affd->afc->pwfx, paftd->cbFormatSize))
116 SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
117 CB_SETCURSEL, index, 0);
118 }
119 }
120 acmDriverClose(had, 0);
121 HeapFree(MSACM_hHeap, 0, afd.pwfx);
122 }
123 }
124 break;
125 case WINE_ACMFF_WFX:
126 if (strcmpW(affd->szFormatTag, paftd->szFormatTag) == 0) {
127 HACMDRIVER had;
128
129 if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
130 ACMFORMATDETAILSW afd = {0};
131
132 afd.cbStruct = sizeof(afd);
133 afd.dwFormatTag = paftd->dwFormatTag;
134 afd.pwfx = affd->afc->pwfx;
135 afd.cbwfx = affd->afc->cbwfx;
136
137 afd.dwFormatIndex = SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
138 CB_GETCURSEL, 0, 0);
139 affd->ret = acmFormatDetailsW(had, &afd, ACM_FORMATDETAILSF_INDEX);
140 acmDriverClose(had, 0);
141 return TRUE;
142 }
143 }
144 break;
145 default:
146 FIXME("Unknown mode (%d)\n", affd->mode);
147 break;
148 }
149 return TRUE;
150 }
151
152 static BOOL MSACM_FillFormatTags(HWND hWnd, PACMFORMATCHOOSEW afc)
153 {
154 ACMFORMATTAGDETAILSW aftd;
155 struct MSACM_FillFormatData affd;
156
157 memset(&aftd, 0, sizeof(aftd));
158 aftd.cbStruct = sizeof(aftd);
159
160 affd.hWnd = hWnd;
161 affd.mode = WINE_ACMFF_TAG;
162 affd.afc = afc;
163
164 acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
165 if (SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, CB_GETCURSEL, 0, 0) == CB_ERR)
166 SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, CB_SETCURSEL, 0, 0);
167 return TRUE;
168 }
169
170 static BOOL MSACM_FillFormat(HWND hWnd, PACMFORMATCHOOSEW afc)
171 {
172 ACMFORMATTAGDETAILSW aftd;
173 struct MSACM_FillFormatData affd;
174
175 SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_RESETCONTENT, 0, 0);
176
177 memset(&aftd, 0, sizeof(aftd));
178 aftd.cbStruct = sizeof(aftd);
179
180 affd.hWnd = hWnd;
181 affd.mode = WINE_ACMFF_FORMAT;
182 affd.afc = afc;
183 SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
184 CB_GETLBTEXT,
185 SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
186 CB_GETCURSEL, 0, 0),
187 (LPARAM)affd.szFormatTag);
188
189 acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
190 if (SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_GETCURSEL, 0, 0) == CB_ERR)
191 SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_SETCURSEL, 0, 0);
192 return TRUE;
193 }
194
195 static MMRESULT MSACM_GetWFX(HWND hWnd, PACMFORMATCHOOSEW afc)
196 {
197 ACMFORMATTAGDETAILSW aftd;
198 struct MSACM_FillFormatData affd;
199
200 memset(&aftd, 0, sizeof(aftd));
201 aftd.cbStruct = sizeof(aftd);
202
203 affd.hWnd = hWnd;
204 affd.mode = WINE_ACMFF_WFX;
205 affd.afc = afc;
206 affd.ret = MMSYSERR_NOERROR;
207 SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
208 CB_GETLBTEXT,
209 SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
210 CB_GETCURSEL, 0, 0),
211 (LPARAM)affd.szFormatTag);
212
213 acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
214 return affd.ret;
215 }
216
217 static const WCHAR fmt_prop[] = {'a','c','m','p','r','o','p','\0'};
218
219 static INT_PTR CALLBACK FormatChooseDlgProc(HWND hWnd, UINT msg,
220 WPARAM wParam, LPARAM lParam)
221 {
222 PACMFORMATCHOOSEW afc = (PACMFORMATCHOOSEW)GetPropW(hWnd, fmt_prop);
223
224 TRACE("hwnd=%p msg=%i 0x%08lx 0x%08lx\n", hWnd, msg, wParam, lParam);
225
226 switch (msg) {
227 case WM_INITDIALOG:
228 afc = (PACMFORMATCHOOSEW)lParam;
229 SetPropW(hWnd, fmt_prop, (HANDLE)afc);
230 MSACM_FillFormatTags(hWnd, afc);
231 MSACM_FillFormat(hWnd, afc);
232 if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
233 ACMFORMATCHOOSE_STYLEF_SHOWHELP|
234 ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT|
235 ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE|
236 ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE)) != 0)
237 FIXME("Unsupported style %08x\n", afc->fdwStyle);
238 if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
239 ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
240 return TRUE;
241
242 case WM_COMMAND:
243 switch (LOWORD(wParam)) {
244 case IDOK:
245 EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
246 return TRUE;
247 case IDCANCEL:
248 EndDialog(hWnd, ACMERR_CANCELED);
249 return TRUE;
250 case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
251 switch (HIWORD(wParam)) {
252 case CBN_SELCHANGE:
253 MSACM_FillFormat(hWnd, afc);
254 break;
255 default:
256 TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n",
257 HIWORD(wParam), lParam);
258 break;
259 }
260 break;
261 case IDD_ACMFORMATCHOOSE_BTN_HELP:
262 if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
263 SendMessageW(afc->hwndOwner,
264 RegisterWindowMessageW(ACMHELPMSGSTRINGW), 0L, 0L);
265 break;
266
267 default:
268 TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n",
269 LOWORD(wParam), HIWORD(wParam), lParam);
270 break;
271 }
272 break;
273 case WM_CONTEXTMENU:
274 if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
275 SendMessageW(afc->hwndOwner,
276 RegisterWindowMessageW(ACMHELPMSGCONTEXTMENUW),
277 wParam, lParam);
278 break;
279 #if defined(WM_CONTEXTHELP)
280 case WM_CONTEXTHELP:
281 if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
282 SendMessageW(afc->hwndOwner,
283 RegisterWindowMessageW(ACMHELPMSGCONTEXTHELPW),
284 wParam, lParam);
285 break;
286 #endif
287 default:
288 TRACE("Dropped dlgMsg: hwnd=%p msg=%i 0x%08lx 0x%08lx\n",
289 hWnd, msg, wParam, lParam );
290 break;
291 }
292 return FALSE;
293 }
294
295 /***********************************************************************
296 * acmFormatChooseA (MSACM32.@)
297 */
298 MMRESULT WINAPI acmFormatChooseA(PACMFORMATCHOOSEA pafmtc)
299 {
300 ACMFORMATCHOOSEW afcw;
301 MMRESULT ret;
302 LPWSTR title = NULL;
303 LPWSTR name = NULL;
304 LPWSTR templ = NULL;
305 DWORD sz;
306
307 if (pafmtc->cbStruct < sizeof(ACMFORMATCHOOSEA))
308 return MMSYSERR_INVALPARAM;
309
310 afcw.cbStruct = sizeof(afcw);
311 afcw.fdwStyle = pafmtc->fdwStyle;
312 afcw.hwndOwner = pafmtc->hwndOwner;
313 afcw.pwfx = pafmtc->pwfx;
314 afcw.cbwfx = pafmtc->cbwfx;
315 if (pafmtc->pszTitle)
316 {
317 sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTitle, -1, NULL, 0);
318 if (!(title = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
319 {
320 ret = MMSYSERR_NOMEM;
321 goto done;
322 }
323 MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTitle, -1, title, sz);
324 }
325 afcw.pszTitle = title;
326 if (pafmtc->pszName)
327 {
328 sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszName, -1, NULL, 0);
329 if (!(name = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
330 {
331 ret = MMSYSERR_NOMEM;
332 goto done;
333 }
334 MultiByteToWideChar(CP_ACP, 0, pafmtc->pszName, -1, name, sz);
335 }
336 afcw.pszName = name;
337 afcw.cchName = pafmtc->cchName;
338 afcw.fdwEnum = pafmtc->fdwEnum;
339 afcw.pwfxEnum = pafmtc->pwfxEnum;
340 afcw.hInstance = pafmtc->hInstance;
341 if (pafmtc->pszTemplateName)
342 {
343 sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTemplateName, -1, NULL, 0);
344 if (!(templ = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
345 {
346 ret = MMSYSERR_NOMEM;
347 goto done;
348 }
349 MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTemplateName, -1, templ, sz);
350 }
351 afcw.pszTemplateName = templ;
352 /* FIXME: hook procs not supported yet */
353 if (pafmtc->pfnHook)
354 {
355 FIXME("Unsupported hook procs\n");
356 ret = MMSYSERR_NOTSUPPORTED;
357 goto done;
358 }
359 ret = acmFormatChooseW(&afcw);
360 if (ret == MMSYSERR_NOERROR)
361 {
362 WideCharToMultiByte(CP_ACP, 0, afcw.szFormatTag, -1, pafmtc->szFormatTag, sizeof(pafmtc->szFormatTag),
363 NULL, NULL);
364 WideCharToMultiByte(CP_ACP, 0, afcw.szFormat, -1, pafmtc->szFormat, sizeof(pafmtc->szFormat),
365 NULL, NULL);
366 if (pafmtc->pszName)
367 WideCharToMultiByte(CP_ACP, 0, afcw.pszName, -1, pafmtc->pszName, pafmtc->cchName, NULL, NULL);
368 }
369 done:
370 HeapFree(GetProcessHeap(), 0, title);
371 HeapFree(GetProcessHeap(), 0, name);
372 HeapFree(GetProcessHeap(), 0, templ);
373 return ret;
374 }
375
376 /***********************************************************************
377 * acmFormatChooseW (MSACM32.@)
378 */
379 MMRESULT WINAPI acmFormatChooseW(PACMFORMATCHOOSEW pafmtc)
380 {
381 if (pafmtc->cbStruct < sizeof(ACMFORMATCHOOSEW))
382 return MMSYSERR_INVALPARAM;
383
384 if (!pafmtc->pwfx)
385 return MMSYSERR_INVALPARAM;
386
387 if (pafmtc->fdwStyle & ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE)
388 return DialogBoxIndirectParamW(MSACM_hInstance32, (LPCDLGTEMPLATEW)pafmtc->hInstance,
389 pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
390
391 if (pafmtc->fdwStyle & ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE)
392 return DialogBoxParamW(pafmtc->hInstance, pafmtc->pszTemplateName,
393 pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
394
395 return DialogBoxParamW(MSACM_hInstance32, MAKEINTRESOURCEW(DLG_ACMFORMATCHOOSE_ID),
396 pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
397 }
398
399 /***********************************************************************
400 * acmFormatDetailsA (MSACM32.@)
401 */
402 MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd,
403 DWORD fdwDetails)
404 {
405 ACMFORMATDETAILSW afdw;
406 MMRESULT mmr;
407
408 if (!pafd)
409 return MMSYSERR_INVALPARAM;
410
411 memset(&afdw, 0, sizeof(afdw));
412 afdw.cbStruct = sizeof(afdw);
413 afdw.dwFormatIndex = pafd->dwFormatIndex;
414 afdw.dwFormatTag = pafd->dwFormatTag;
415 afdw.fdwSupport = pafd->fdwSupport;
416 afdw.pwfx = pafd->pwfx;
417 afdw.cbwfx = pafd->cbwfx;
418
419 mmr = acmFormatDetailsW(had, &afdw, fdwDetails);
420 if (mmr == MMSYSERR_NOERROR) {
421 pafd->dwFormatTag = afdw.dwFormatTag;
422 pafd->fdwSupport = afdw.fdwSupport;
423 WideCharToMultiByte( CP_ACP, 0, afdw.szFormat, -1,
424 pafd->szFormat, sizeof(pafd->szFormat), NULL, NULL );
425 }
426 return mmr;
427 }
428
429 /***********************************************************************
430 * acmFormatDetailsW (MSACM32.@)
431 */
432 MMRESULT WINAPI acmFormatDetailsW(HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
433 {
434 MMRESULT mmr;
435 static const WCHAR fmt1[] = {'%','d',' ','H','z',0};
436 static const WCHAR fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
437 ACMFORMATTAGDETAILSW aftd = {0};
438
439 TRACE("(%p, %p, %d)\n", had, pafd, fdwDetails);
440
441 if (!pafd)
442 return MMSYSERR_INVALPARAM;
443
444 if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
445
446 if (!pafd->pwfx)
447 return MMSYSERR_INVALPARAM;
448
449 if (pafd->cbwfx < sizeof(PCMWAVEFORMAT))
450 return MMSYSERR_INVALPARAM;
451
452 if (pafd->fdwSupport)
453 return MMSYSERR_INVALPARAM;
454
455 if (pafd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
456 return MMSYSERR_INVALPARAM;
457
458 switch (fdwDetails) {
459 case ACM_FORMATDETAILSF_FORMAT:
460 if (pafd->dwFormatTag != pafd->pwfx->wFormatTag) {
461 mmr = MMSYSERR_INVALPARAM;
462 break;
463 }
464 if (had == NULL) {
465 PWINE_ACMDRIVERID padid;
466
467 mmr = ACMERR_NOTPOSSIBLE;
468 for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
469 /* should check for codec only */
470 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
471 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
472 mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
473 acmDriverClose(had, 0);
474 if (mmr == MMSYSERR_NOERROR) break;
475 }
476 }
477 } else {
478 mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
479 }
480 break;
481 case ACM_FORMATDETAILSF_INDEX:
482 aftd.cbStruct = sizeof(aftd);
483 aftd.dwFormatTag = pafd->dwFormatTag;
484 mmr = acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_FORMATTAG);
485 if (mmr != MMSYSERR_NOERROR)
486 break;
487 if (pafd->dwFormatIndex >= aftd.cStandardFormats)
488 {
489 mmr = MMSYSERR_INVALPARAM;
490 break;
491 }
492 mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
493 break;
494 default:
495 WARN("Unknown fdwDetails %08x\n", fdwDetails);
496 mmr = MMSYSERR_INVALFLAG;
497 break;
498 }
499
500 if (mmr == MMSYSERR_NOERROR && pafd->szFormat[0] == 0) {
501 wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
502 if (pafd->pwfx->wBitsPerSample) {
503 wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2,
504 pafd->pwfx->wBitsPerSample);
505 }
506 MultiByteToWideChar(CP_ACP, 0, (pafd->pwfx->nChannels == 1) ? "; Mono" : "; Stereo", -1,
507 pafd->szFormat + strlenW(pafd->szFormat),
508 ARRAY_SIZE(pafd->szFormat) - strlenW(pafd->szFormat));
509 }
510
511 TRACE("=> %d\n", mmr);
512 return mmr;
513 }
514
515 struct MSACM_FormatEnumWtoA_Instance {
516 PACMFORMATDETAILSA pafda;
517 DWORD_PTR dwInstance;
518 ACMFORMATENUMCBA fnCallback;
519 };
520
521 static BOOL CALLBACK MSACM_FormatEnumCallbackWtoA(HACMDRIVERID hadid,
522 PACMFORMATDETAILSW pafdw,
523 DWORD_PTR dwInstance,
524 DWORD fdwSupport)
525 {
526 struct MSACM_FormatEnumWtoA_Instance* pafei;
527
528 pafei = (struct MSACM_FormatEnumWtoA_Instance*)dwInstance;
529
530 pafei->pafda->dwFormatIndex = pafdw->dwFormatIndex;
531 pafei->pafda->dwFormatTag = pafdw->dwFormatTag;
532 pafei->pafda->fdwSupport = pafdw->fdwSupport;
533 WideCharToMultiByte( CP_ACP, 0, pafdw->szFormat, -1,
534 pafei->pafda->szFormat, sizeof(pafei->pafda->szFormat), NULL, NULL );
535
536 return (pafei->fnCallback)(hadid, pafei->pafda,
537 pafei->dwInstance, fdwSupport);
538 }
539
540 /***********************************************************************
541 * acmFormatEnumA (MSACM32.@)
542 */
543 MMRESULT WINAPI acmFormatEnumA(HACMDRIVER had, PACMFORMATDETAILSA pafda,
544 ACMFORMATENUMCBA fnCallback,
545 DWORD_PTR dwInstance, DWORD fdwEnum)
546 {
547 ACMFORMATDETAILSW afdw;
548 struct MSACM_FormatEnumWtoA_Instance afei;
549
550 if (!pafda)
551 return MMSYSERR_INVALPARAM;
552
553 if (!fnCallback)
554 return MMSYSERR_INVALPARAM;
555
556 if (pafda->cbStruct < sizeof(*pafda))
557 return MMSYSERR_INVALPARAM;
558
559 memset(&afdw, 0, sizeof(afdw));
560 afdw.cbStruct = sizeof(afdw);
561 afdw.dwFormatIndex = pafda->dwFormatIndex;
562 afdw.dwFormatTag = pafda->dwFormatTag;
563 afdw.fdwSupport = pafda->fdwSupport;
564 afdw.pwfx = pafda->pwfx;
565 afdw.cbwfx = pafda->cbwfx;
566
567 afei.pafda = pafda;
568 afei.dwInstance = dwInstance;
569 afei.fnCallback = fnCallback;
570
571 return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA,
572 (DWORD_PTR)&afei, fdwEnum);
573 }
574
575 /***********************************************************************
576 * acmFormatEnumW (MSACM32.@)
577 */
578 static BOOL MSACM_FormatEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
579 PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef,
580 ACMFORMATENUMCBW fnCallback,
581 DWORD_PTR dwInstance, DWORD fdwEnum)
582 {
583 ACMFORMATTAGDETAILSW aftd;
584 unsigned int i, j;
585
586 if (fdwEnum & ACM_FORMATENUMF_SUGGEST) {
587 HDRVR hdrvr;
588 ACMDRVFORMATSUGGEST adfs;
589 pafd->dwFormatIndex = 0;
590 memset(&aftd, 0, sizeof(aftd));
591 aftd.cbStruct = sizeof(aftd);
592 memset(&adfs, 0, sizeof(adfs));
593 adfs.cbStruct = sizeof(adfs);
594
595 for (i = 0; i < padid->cFormatTags; i++) {
596 aftd.dwFormatTag = i;
597 pafd->dwFormatTag = aftd.dwFormatTag;
598 pafd->pwfx->wFormatTag = pafd->dwFormatTag;
599
600 if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
601 continue;
602
603 adfs.cbwfxSrc = aftd.cbFormatSize;
604 adfs.cbwfxDst = aftd.cbFormatSize;
605 adfs.pwfxSrc = pwfxRef;
606 adfs.pwfxDst = pafd->pwfx;
607 pafd->fdwSupport = padid->fdwSupport;
608
609 if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
610 aftd.dwFormatTag != pwfxRef->wFormatTag)
611 continue;
612
613 if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
614 !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
615 continue;
616
617 hdrvr = OpenDriver(padid->pszFileName,0,0);
618 SendDriverMessage(hdrvr,ACMDM_FORMAT_SUGGEST,(LPARAM)&adfs,(fdwEnum & 0x000000FFL));
619
620 if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_FORMAT) != MMSYSERR_NOERROR)
621 continue;
622
623 pafd->cbwfx = sizeof(*(pafd->pwfx));
624
625 if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, padid->fdwSupport))
626 return FALSE;
627 }
628 } else {
629 for (i = 0; i < padid->cFormatTags; i++) {
630 memset(&aftd, 0, sizeof(aftd));
631 aftd.cbStruct = sizeof(aftd);
632 aftd.dwFormatTagIndex = i;
633 if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
634 continue;
635
636 if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) && aftd.dwFormatTag != pwfxRef->wFormatTag)
637 continue;
638
639 for (j = 0; j < aftd.cStandardFormats; j++) {
640 pafd->dwFormatIndex = j;
641 pafd->dwFormatTag = aftd.dwFormatTag;
642 pafd->fdwSupport = 0;
643 if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_INDEX) != MMSYSERR_NOERROR)
644 continue;
645
646 if ((fdwEnum & ACM_FORMATENUMF_NCHANNELS) &&
647 pafd->pwfx->nChannels != pwfxRef->nChannels)
648 continue;
649 if ((fdwEnum & ACM_FORMATENUMF_NSAMPLESPERSEC) &&
650 pafd->pwfx->nSamplesPerSec != pwfxRef->nSamplesPerSec)
651 continue;
652 if ((fdwEnum & ACM_FORMATENUMF_WBITSPERSAMPLE) &&
653 pafd->pwfx->wBitsPerSample != pwfxRef->wBitsPerSample)
654 continue;
655 if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
656 !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
657 continue;
658
659 /* more checks to be done on fdwEnum */
660
661 if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, padid->fdwSupport))
662 return FALSE;
663 }
664 /* the "formats" used by the filters are also reported */
665 }
666 }
667 return TRUE;
668 }
669
670 /**********************************************************************/
671
672 MMRESULT WINAPI acmFormatEnumW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
673 ACMFORMATENUMCBW fnCallback,
674 DWORD_PTR dwInstance, DWORD fdwEnum)
675 {
676 PWINE_ACMDRIVERID padid;
677 WAVEFORMATEX wfxRef;
678 BOOL ret;
679 DWORD cbwfxMax;
680 MMRESULT mmr;
681
682 TRACE("(%p, %p, %p, %ld, %d)\n",
683 had, pafd, fnCallback, dwInstance, fdwEnum);
684
685 if (!pafd)
686 return MMSYSERR_INVALPARAM;
687
688 if (!fnCallback)
689 return MMSYSERR_INVALPARAM;
690
691 if (pafd->cbStruct < sizeof(*pafd))
692 return MMSYSERR_INVALPARAM;
693
694 if (pafd->fdwSupport)
695 return MMSYSERR_INVALPARAM;
696
697 if (!pafd->pwfx)
698 return MMSYSERR_INVALPARAM;
699
700 if (fdwEnum & (ACM_FORMATENUMF_WFORMATTAG|ACM_FORMATENUMF_NCHANNELS|
701 ACM_FORMATENUMF_NSAMPLESPERSEC|ACM_FORMATENUMF_WBITSPERSAMPLE|
702 ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST))
703 wfxRef = *pafd->pwfx;
704
705 if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
706 !(fdwEnum & (ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT)))
707 return MMSYSERR_INVALPARAM;
708
709 if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
710 (pafd->dwFormatTag != pafd->pwfx->wFormatTag))
711 return MMSYSERR_INVALPARAM;
712
713 if (fdwEnum & (ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT))
714 FIXME("Unsupported fdwEnum values %08x\n", fdwEnum);
715
716 mmr = acmMetrics((HACMOBJ)had, ACM_METRIC_MAX_SIZE_FORMAT, &cbwfxMax);
717 if (mmr != MMSYSERR_NOERROR)
718 return mmr;
719 if (pafd->cbwfx < cbwfxMax)
720 return MMSYSERR_INVALPARAM;
721
722 if (had) {
723 HACMDRIVERID hadid;
724
725 if (acmDriverID((HACMOBJ)had, &hadid, 0) != MMSYSERR_NOERROR)
726 return MMSYSERR_INVALHANDLE;
727 MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef,
728 fnCallback, dwInstance, fdwEnum);
729 return MMSYSERR_NOERROR;
730 }
731 for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
732 /* should check for codec only */
733 if ((padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
734 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
735 continue;
736 ret = MSACM_FormatEnumHelper(padid, had, pafd, &wfxRef,
737 fnCallback, dwInstance, fdwEnum);
738 acmDriverClose(had, 0);
739 if (!ret) break;
740 }
741 return MMSYSERR_NOERROR;
742 }
743
744 /***********************************************************************
745 * acmFormatSuggest (MSACM32.@)
746 */
747 MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
748 PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
749 {
750 ACMFORMATTAGDETAILSW aftd = {0};
751 ACMDRVFORMATSUGGEST adfg;
752 MMRESULT mmr;
753
754 TRACE("(%p, %p, %p, %d, %d)\n",
755 had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
756
757 if (!pwfxSrc || !pwfxDst)
758 return MMSYSERR_INVALPARAM;
759
760 if (fdwSuggest & ~(ACM_FORMATSUGGESTF_NCHANNELS|ACM_FORMATSUGGESTF_NSAMPLESPERSEC|
761 ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
762 return MMSYSERR_INVALFLAG;
763
764 /* if we were given PCM, try to convert to PCM */
765 if (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && !had &&
766 !(fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
767 {
768 ACMFORMATDETAILSW afd = {0};
769 afd.cbStruct = sizeof(afd);
770 afd.dwFormatTag = WAVE_FORMAT_PCM;
771 afd.pwfx = pwfxSrc;
772 afd.cbwfx = sizeof(PCMWAVEFORMAT);
773 if (!acmFormatDetailsW(had, &afd, ACM_FORMATDETAILSF_FORMAT))
774 {
775 memcpy(pwfxDst, pwfxSrc, sizeof(PCMWAVEFORMAT));
776 return MMSYSERR_NOERROR;
777 }
778 }
779
780 aftd.cbStruct = sizeof(aftd);
781 if (fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG)
782 aftd.dwFormatTag = pwfxDst->wFormatTag;
783 mmr = acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
784 if ((fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG) && mmr == ACMERR_NOTPOSSIBLE)
785 return ACMERR_NOTPOSSIBLE;
786
787 if (cbwfxDst < aftd.cbFormatSize)
788 return MMSYSERR_INVALPARAM;
789
790 adfg.cbStruct = sizeof(adfg);
791 adfg.fdwSuggest = fdwSuggest;
792 adfg.pwfxSrc = pwfxSrc;
793 adfg.cbwfxSrc = (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) ?
794 sizeof(WAVEFORMATEX) : (sizeof(WAVEFORMATEX) + pwfxSrc->cbSize);
795 adfg.pwfxDst = pwfxDst;
796 adfg.cbwfxDst = cbwfxDst;
797
798 if (had == NULL) {
799 PWINE_ACMDRIVERID padid;
800
801 /* MS doc says: ACM finds the best suggestion.
802 * Well, first found will be the "best"
803 */
804 mmr = ACMERR_NOTPOSSIBLE;
805 for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
806 /* should check for codec only */
807 if ((padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
808 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
809 continue;
810
811 if (MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L) == MMSYSERR_NOERROR) {
812 mmr = MMSYSERR_NOERROR;
813 break;
814 }
815 acmDriverClose(had, 0);
816 }
817 } else {
818 mmr = MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L);
819 }
820 return mmr;
821 }
822
823 /***********************************************************************
824 * acmFormatTagDetailsA (MSACM32.@)
825 */
826 MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
827 DWORD fdwDetails)
828 {
829 ACMFORMATTAGDETAILSW aftdw;
830 MMRESULT mmr;
831
832 memset(&aftdw, 0, sizeof(aftdw));
833 aftdw.cbStruct = sizeof(aftdw);
834 aftdw.dwFormatTagIndex = paftda->dwFormatTagIndex;
835 aftdw.dwFormatTag = paftda->dwFormatTag;
836
837 mmr = acmFormatTagDetailsW(had, &aftdw, fdwDetails);
838 if (mmr == MMSYSERR_NOERROR) {
839 paftda->dwFormatTag = aftdw.dwFormatTag;
840 paftda->dwFormatTagIndex = aftdw.dwFormatTagIndex;
841 paftda->cbFormatSize = aftdw.cbFormatSize;
842 paftda->fdwSupport = aftdw.fdwSupport;
843 paftda->cStandardFormats = aftdw.cStandardFormats;
844 WideCharToMultiByte( CP_ACP, 0, aftdw.szFormatTag, -1, paftda->szFormatTag,
845 sizeof(paftda->szFormatTag), NULL, NULL );
846 }
847 return mmr;
848 }
849
850 /***********************************************************************
851 * acmFormatTagDetailsW (MSACM32.@)
852 */
853 MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
854 DWORD fdwDetails)
855 {
856 PWINE_ACMDRIVERID padid;
857 MMRESULT mmr = ACMERR_NOTPOSSIBLE;
858
859 TRACE("(%p, %p, %d)\n", had, paftd, fdwDetails);
860
861 if (fdwDetails & ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_INDEX|
862 ACM_FORMATTAGDETAILSF_LARGESTSIZE))
863 return MMSYSERR_INVALFLAG;
864
865 switch (fdwDetails) {
866 case ACM_FORMATTAGDETAILSF_FORMATTAG:
867 if (had == NULL) {
868 for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
869 /* should check for codec only */
870 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
871 MSACM_FindFormatTagInCache(padid, paftd->dwFormatTag, NULL) &&
872 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
873 mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
874 acmDriverClose(had, 0);
875 if (mmr == MMSYSERR_NOERROR) break;
876 }
877 }
878 } else {
879 PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
880
881 if (pad && MSACM_FindFormatTagInCache(pad->obj.pACMDriverID, paftd->dwFormatTag, NULL))
882 mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
883 }
884 break;
885
886 case ACM_FORMATTAGDETAILSF_INDEX:
887 if (had != NULL) {
888 PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
889
890 if (pad && paftd->dwFormatTagIndex < pad->obj.pACMDriverID->cFormatTags)
891 mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
892 }
893 break;
894
895 case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
896 if (had == NULL) {
897 ACMFORMATTAGDETAILSW tmp;
898 DWORD ft = paftd->dwFormatTag;
899
900 for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
901 /* should check for codec only */
902 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
903 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
904
905 memset(&tmp, 0, sizeof(tmp));
906 tmp.cbStruct = sizeof(tmp);
907 tmp.dwFormatTag = ft;
908
909 if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
910 (LPARAM)&tmp, fdwDetails) == MMSYSERR_NOERROR) {
911 if (mmr == ACMERR_NOTPOSSIBLE ||
912 paftd->cbFormatSize < tmp.cbFormatSize) {
913 *paftd = tmp;
914 mmr = MMSYSERR_NOERROR;
915 }
916 }
917 acmDriverClose(had, 0);
918 }
919 }
920 } else {
921 mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
922 }
923 break;
924
925 default:
926 WARN("Unsupported fdwDetails=%08x\n", fdwDetails);
927 mmr = MMSYSERR_ERROR;
928 }
929
930 if (mmr == MMSYSERR_NOERROR &&
931 paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
932 MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
933 ARRAY_SIZE(paftd->szFormatTag));
934
935 return mmr;
936 }
937
938 struct MSACM_FormatTagEnumWtoA_Instance {
939 PACMFORMATTAGDETAILSA paftda;
940 DWORD_PTR dwInstance;
941 ACMFORMATTAGENUMCBA fnCallback;
942 };
943
944 static BOOL CALLBACK MSACM_FormatTagEnumCallbackWtoA(HACMDRIVERID hadid,
945 PACMFORMATTAGDETAILSW paftdw,
946 DWORD_PTR dwInstance,
947 DWORD fdwSupport)
948 {
949 struct MSACM_FormatTagEnumWtoA_Instance* paftei;
950
951 paftei = (struct MSACM_FormatTagEnumWtoA_Instance*)dwInstance;
952
953 paftei->paftda->dwFormatTagIndex = paftdw->dwFormatTagIndex;
954 paftei->paftda->dwFormatTag = paftdw->dwFormatTag;
955 paftei->paftda->cbFormatSize = paftdw->cbFormatSize;
956 paftei->paftda->fdwSupport = paftdw->fdwSupport;
957 paftei->paftda->cStandardFormats = paftdw->cStandardFormats;
958 WideCharToMultiByte( CP_ACP, 0, paftdw->szFormatTag, -1, paftei->paftda->szFormatTag,
959 sizeof(paftei->paftda->szFormatTag), NULL, NULL );
960
961 return (paftei->fnCallback)(hadid, paftei->paftda,
962 paftei->dwInstance, fdwSupport);
963 }
964
965 /***********************************************************************
966 * acmFormatTagEnumA (MSACM32.@)
967 */
968 MMRESULT WINAPI acmFormatTagEnumA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
969 ACMFORMATTAGENUMCBA fnCallback,
970 DWORD_PTR dwInstance, DWORD fdwEnum)
971 {
972 ACMFORMATTAGDETAILSW aftdw;
973 struct MSACM_FormatTagEnumWtoA_Instance aftei;
974
975 if (!paftda)
976 return MMSYSERR_INVALPARAM;
977
978 if (paftda->cbStruct < sizeof(*paftda))
979 return MMSYSERR_INVALPARAM;
980
981 if (fdwEnum != 0)
982 return MMSYSERR_INVALFLAG;
983
984 memset(&aftdw, 0, sizeof(aftdw));
985 aftdw.cbStruct = sizeof(aftdw);
986 aftdw.dwFormatTagIndex = paftda->dwFormatTagIndex;
987 aftdw.dwFormatTag = paftda->dwFormatTag;
988
989 aftei.paftda = paftda;
990 aftei.dwInstance = dwInstance;
991 aftei.fnCallback = fnCallback;
992
993 return acmFormatTagEnumW(had, &aftdw, MSACM_FormatTagEnumCallbackWtoA,
994 (DWORD_PTR)&aftei, fdwEnum);
995 }
996
997 /***********************************************************************
998 * acmFormatTagEnumW (MSACM32.@)
999 */
1000 MMRESULT WINAPI acmFormatTagEnumW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
1001 ACMFORMATTAGENUMCBW fnCallback,
1002 DWORD_PTR dwInstance, DWORD fdwEnum)
1003 {
1004 PWINE_ACMDRIVERID padid;
1005 unsigned int i;
1006 BOOL bPcmDone = FALSE;
1007
1008 TRACE("(%p, %p, %p, %ld, %d)\n",
1009 had, paftd, fnCallback, dwInstance, fdwEnum);
1010
1011 if (!paftd)
1012 return MMSYSERR_INVALPARAM;
1013
1014 if (paftd->cbStruct < sizeof(*paftd))
1015 return MMSYSERR_INVALPARAM;
1016
1017 if (fdwEnum != 0)
1018 return MMSYSERR_INVALFLAG;
1019
1020 /* (WS) MSDN info page says that if had != 0, then we should find
1021 * the specific driver to get its tags from. Therefore I'm removing
1022 * the FIXME call and adding a search block below. It also seems
1023 * that the lack of this functionality was the responsible for
1024 * codecs to be multiply and incorrectly listed.
1025 */
1026
1027 /* if (had) FIXME("had != NULL, not supported\n"); */
1028
1029 if (had) {
1030 if (acmDriverID((HACMOBJ)had, (HACMDRIVERID *)&padid, 0) != MMSYSERR_NOERROR)
1031 return MMSYSERR_INVALHANDLE;
1032
1033 for (i = 0; i < padid->cFormatTags; i++) {
1034 paftd->dwFormatTagIndex = i;
1035 if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
1036 (LPARAM)paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
1037 if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
1038 if (paftd->szFormatTag[0] == 0)
1039 MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
1040 ARRAY_SIZE(paftd->szFormatTag));
1041 /* (WS) I'm preserving this PCM hack since it seems to be
1042 * correct. Please notice this block was borrowed from
1043 * below.
1044 */
1045 if (bPcmDone) continue;
1046 bPcmDone = TRUE;
1047 }
1048 if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, padid->fdwSupport))
1049 return MMSYSERR_NOERROR;
1050 }
1051 }
1052 }
1053 /* if had==0 then search for the first suitable driver */
1054 else {
1055 for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
1056 /* should check for codec only */
1057 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
1058 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
1059 for (i = 0; i < padid->cFormatTags; i++) {
1060 paftd->dwFormatTagIndex = i;
1061 if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
1062 (LPARAM)paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
1063 if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
1064 if (paftd->szFormatTag[0] == 0)
1065 MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
1066 ARRAY_SIZE(paftd->szFormatTag));
1067 /* FIXME (EPP): I'm not sure this is the correct
1068 * algorithm (should make more sense to apply the same
1069 * for all already loaded formats, but this will do
1070 * for now
1071 */
1072 if (bPcmDone) continue;
1073 bPcmDone = TRUE;
1074 }
1075 if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, padid->fdwSupport)) {
1076 acmDriverClose(had, 0);
1077 return MMSYSERR_NOERROR;
1078 }
1079 }
1080 }
1081 acmDriverClose(had, 0);
1082 }
1083 }
1084 }
1085 return MMSYSERR_NOERROR;
1086 }
Windows API implementation