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