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