source: trunk/src/msacm32/msacm32.cpp@ 1224

Last change on this file since 1224 was 1118, checked in by sandervl, 26 years ago

Lots of changes by several people (see changelog for 4 October
File size: 23.8 KB
Line 
1/* $Id: msacm32.cpp,v 1.3 1999-10-04 09:55:58 sandervl Exp $ */
2/*
3 * MSACM32 library
4 *
5 * Copyright 1998 Patrik Stridvall
6 * Copyright 1999 Jens Wiessner
7 */
8
9#include <os2win.h>
10#include <winerror.h>
11#include <windef.h>
12#include <winuser.h>
13#include <misc.h>
14#include <odinwrap.h>
15#include "msacm.h"
16#include "msacmdrv.h"
17#include "winversion.h"
18#include "winreg.h"
19#include "debugtools.h"
20#include <debugdefs.h>
21
22
23DEFAULT_DEBUG_CHANNEL(msacm)
24
25/**********************************************************************/
26
27static DWORD MSACM_dwProcessesAttached = 0;
28
29/***********************************************************************
30 * MSACM_LibMain32 (MSACM32.init)
31 */
32BOOL WINAPI MSACM32_LibMain(
33 HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
34{
35 switch(fdwReason)
36 {
37 case DLL_PROCESS_ATTACH:
38 if(MSACM_dwProcessesAttached == 0)
39 {
40 MSACM_hHeap = HeapCreate(0, 0x10000, 0);
41 MSACM_RegisterAllDrivers();
42 }
43 MSACM_dwProcessesAttached++;
44 break;
45 case DLL_PROCESS_DETACH:
46 MSACM_dwProcessesAttached--;
47 if(MSACM_dwProcessesAttached == 0)
48 {
49 MSACM_UnregisterAllDrivers();
50 HeapDestroy(MSACM_hHeap);
51 MSACM_hHeap = (HANDLE) NULL;
52 }
53 break;
54 case DLL_THREAD_ATTACH:
55 break;
56 case DLL_THREAD_DETACH:
57 break;
58 default:
59 break;
60 }
61 return TRUE;
62}
63
64/***********************************************************************
65 * XRegThunkEntry (MSACM32.1)
66 * FIXME
67 * No documentation found.
68 */
69
70/***********************************************************************
71 * acmDriverAddA (MSACM32.2)
72 */
73MMRESULT WINAPI acmDriverAddA(
74 PHACMDRIVERID phadid, HINSTANCE hinstModule,
75 LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
76{
77#ifdef DEBUG
78 dprintf(("MSACM32: acmDriverAddA\n"));
79#endif
80 PWINE_ACMLOCALDRIVER pld;
81 if(!phadid)
82 return MMSYSERR_INVALPARAM;
83
84 /* Check if any unknown flags */
85 if(fdwAdd &
86 ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
87 ACM_DRIVERADDF_GLOBAL))
88 return MMSYSERR_INVALFLAG;
89
90 /* Check if any incompatible flags */
91 if((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
92 (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
93 return MMSYSERR_INVALFLAG;
94
95 pld = (PWINE_ACMLOCALDRIVER) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
96 pld->pfnDriverProc = (DRIVERPROC)
97 GetProcAddress(hinstModule, "DriverProc");
98 *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, pld);
99
100 /* FIXME: lParam, dwPriority and fdwAdd ignored */
101
102 return MMSYSERR_NOERROR;
103}
104
105/***********************************************************************
106 * acmDriverAddW (MSACM32.3)
107 * FIXME
108 * Not implemented
109 */
110MMRESULT WINAPI acmDriverAddW(
111 PHACMDRIVERID phadid, HINSTANCE hinstModule,
112 LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
113{
114#ifdef DEBUG
115 dprintf(("MSACM32: acmDriverAddW not implemented\n"));
116#endif
117 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
118 return MMSYSERR_ERROR;
119}
120
121/***********************************************************************
122 * acmDriverClose (MSACM32.4)
123 */
124MMRESULT WINAPI acmDriverClose(
125 HACMDRIVER had, DWORD fdwClose)
126{
127#ifdef DEBUG
128 dprintf(("MSACM32: acmDriverClose\n"));
129#endif
130 PWINE_ACMDRIVER p;
131
132 if(fdwClose)
133 return MMSYSERR_INVALFLAG;
134
135 p = MSACM_GetDriver(had);
136 if(!p)
137 return MMSYSERR_INVALHANDLE;
138
139 p->obj.pACMDriverID->pACMDriver = NULL;
140
141 if(p->hDrvr)
142 CloseDriver(p->hDrvr, 0, 0);
143
144 HeapFree(MSACM_hHeap, 0, p);
145
146 return MMSYSERR_NOERROR;
147}
148
149/***********************************************************************
150 * acmDriverDetailsA (MSACM32.5)
151 */
152MMRESULT WINAPI acmDriverDetailsA(
153 HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
154{
155#ifdef DEBUG
156 dprintf(("MSACM32: acmDriverDetailsA\n"));
157#endif
158 PWINE_ACMDRIVERID p;
159 MMRESULT mmr;
160 BOOL bOpenTemporary;
161
162 p = MSACM_GetDriverID(hadid);
163 if(!p)
164 return MMSYSERR_INVALHANDLE;
165
166 if(fdwDetails)
167 return MMSYSERR_INVALFLAG;
168
169 bOpenTemporary = !p->pACMDriver;
170 if(bOpenTemporary) {
171 bOpenTemporary = TRUE;
172 acmDriverOpen((PHACMDRIVER) &p->pACMDriver, hadid, 0);
173 }
174
175 /* FIXME
176 * How does the driver know if the ANSI or
177 * the UNICODE variant of PACMDRIVERDETAILS is used?
178 * It might check cbStruct or does it only accept ANSI.
179 */
180 mmr = (MMRESULT) acmDriverMessage(
181 (HACMDRIVER) p->pACMDriver, ACMDM_DRIVER_DETAILS,
182 (LPARAM) padd, 0
183 );
184
185 if(bOpenTemporary) {
186 acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
187 p->pACMDriver = NULL;
188 }
189
190 return mmr;
191}
192
193/***********************************************************************
194 * acmDriverDetailsW (MSACM32.6)
195 * FIXME
196 * Not implemented
197 */
198MMRESULT WINAPI acmDriverDetailsW(
199 HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
200{
201#ifdef DEBUG
202 dprintf(("MSACM32: acmDriverDetailsW not implemented\n"));
203#endif
204 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
205 return MMSYSERR_ERROR;
206}
207
208/***********************************************************************
209 * acmDriverEnum (MSACM32.7)
210 */
211MMRESULT WINAPI acmDriverEnum(
212 ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
213{
214#ifdef DEBUG
215 dprintf(("MSACM32: acmDriverEnum\n"));
216#endif
217 PWINE_ACMDRIVERID p;
218
219 if(!fnCallback)
220 {
221 return MMSYSERR_INVALPARAM;
222 }
223
224 if(fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
225 {
226 return MMSYSERR_INVALFLAG;
227 }
228
229 p = MSACM_pFirstACMDriverID;
230 while(p)
231 {
232 (*fnCallback)((HACMDRIVERID) p, dwInstance, ACMDRIVERDETAILS_SUPPORTF_CODEC);
233 p = p->pNextACMDriverID;
234 }
235
236 return MMSYSERR_NOERROR;
237}
238
239/***********************************************************************
240 * acmDriverID (MSACM32.8)
241 */
242MMRESULT WINAPI acmDriverID(
243 HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
244{
245#ifdef DEBUG
246 dprintf(("MSACM32: acmDriverID\n"));
247#endif
248 PWINE_ACMOBJ pao;
249
250 pao = MSACM_GetObj(hao);
251 if(!pao)
252 return MMSYSERR_INVALHANDLE;
253
254 if(!phadid)
255 return MMSYSERR_INVALPARAM;
256
257 if(fdwDriverID)
258 return MMSYSERR_INVALFLAG;
259
260 *phadid = (HACMDRIVERID) pao->pACMDriverID;
261
262 return MMSYSERR_NOERROR;
263}
264
265/***********************************************************************
266 * acmDriverMessage (MSACM32.9)
267 * FIXME
268 * Not implemented
269 */
270LRESULT WINAPI acmDriverMessage(
271 HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
272{
273#ifdef DEBUG
274 dprintf(("MSACM32: acmDriverMessage not implemented\n"));
275#endif
276 PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
277 if(!pad)
278 return MMSYSERR_INVALPARAM;
279
280 /* FIXME: Check if uMsg legal */
281
282 if(!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
283 return MMSYSERR_NOTSUPPORTED;
284
285 return MMSYSERR_NOERROR;
286}
287
288
289/***********************************************************************
290 * acmDriverOpen (MSACM32.10)
291 */
292MMRESULT WINAPI acmDriverOpen(
293 PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
294{
295#ifdef DEBUG
296 dprintf(("MSACM32: acmDriverOpen\n"));
297#endif
298 PWINE_ACMDRIVERID padid;
299
300 if(!phad)
301 return MMSYSERR_INVALPARAM;
302
303 padid = MSACM_GetDriverID(hadid);
304 if(!padid)
305 return MMSYSERR_INVALHANDLE;
306
307 if(fdwOpen)
308 return MMSYSERR_INVALFLAG;
309
310 if(padid->pACMDriver)
311 {
312 /* FIXME: Is it allowed? */
313 return MMSYSERR_ERROR;
314 }
315
316 padid->pACMDriver = (PWINE_ACMDRIVER) HeapAlloc(
317 MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER)
318 );
319 padid->pACMDriver->obj.pACMDriverID = padid;
320
321 if(!padid->pACMLocalDriver)
322 padid->pACMDriver->hDrvr =
323 OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
324 else
325 {
326 padid->pACMDriver->hDrvr = MSACM_OpenDriverProc(
327 padid->pACMLocalDriver->pfnDriverProc
328 );
329 }
330
331 if(!padid->pACMDriver->hDrvr)
332 return MMSYSERR_ERROR;
333
334 /* FIXME: Create a WINE_ACMDRIVER32 */
335 *phad = (HACMDRIVER) NULL;
336
337 return MMSYSERR_ERROR;
338}
339
340/***********************************************************************
341 * acmDriverPriority (MSACM32.11)
342 */
343MMRESULT WINAPI acmDriverPriority(
344 HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
345{
346#ifdef DEBUG
347 dprintf(("MSACM32: acmDriverPriority\n"));
348#endif
349 PWINE_ACMDRIVERID padid;
350 CHAR szSubKey[17];
351 CHAR szBuffer[256];
352 LONG lBufferLength = sizeof(szBuffer);
353 LONG lError;
354 HKEY hPriorityKey;
355 DWORD dwPriorityCounter;
356
357 padid = MSACM_GetDriverID(hadid);
358 if(!padid)
359 return MMSYSERR_INVALHANDLE;
360
361 /* Check for unknown flags */
362 if(fdwPriority &
363 ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
364 ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
365 return MMSYSERR_INVALFLAG;
366
367 /* Check for incompatible flags */
368 if((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
369 (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
370 return MMSYSERR_INVALFLAG;
371
372 /* Check for incompatible flags */
373 if((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
374 (fdwPriority & ACM_DRIVERPRIORITYF_END))
375 return MMSYSERR_INVALFLAG;
376
377 lError = RegOpenKeyA(HKEY_CURRENT_USER,
378 "Software\\Microsoft\\Multimedia\\"
379 "Audio Compression Manager\\Priority v4.00",
380 &hPriorityKey
381 );
382 /* FIXME: Create key */
383 if(lError != ERROR_SUCCESS)
384 return MMSYSERR_ERROR;
385
386 for(dwPriorityCounter = 1; ; dwPriorityCounter++)
387 {
388//
389// FIXME ODIN wsnprintfA(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
390//
391 lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
392 if(lError != ERROR_SUCCESS)
393 break;
394
395 break;
396 }
397
398 RegCloseKey(hPriorityKey);
399
400 return MMSYSERR_ERROR;
401}
402
403/***********************************************************************
404 * acmDriverRemove (MSACM32.12)
405 */
406MMRESULT WINAPI acmDriverRemove(
407 HACMDRIVERID hadid, DWORD fdwRemove)
408{
409#ifdef DEBUG
410 dprintf(("MSACM32: acmDriverRemove\n"));
411#endif
412 PWINE_ACMDRIVERID padid;
413
414 padid = MSACM_GetDriverID(hadid);
415 if(!padid)
416 return MMSYSERR_INVALHANDLE;
417
418 if(fdwRemove)
419 return MMSYSERR_INVALFLAG;
420
421 MSACM_UnregisterDriver(padid);
422
423 return MMSYSERR_NOERROR;
424}
425
426/***********************************************************************
427 * acmFilterChooseA (MSACM32.13)
428 */
429MMRESULT WINAPI acmFilterChooseA(
430 PACMFILTERCHOOSEA pafltrc)
431{
432#ifdef DEBUG
433 dprintf(("MSACM32: acmDriverChooseA not implemented\n"));
434#endif
435 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
436 return MMSYSERR_ERROR;
437}
438
439/***********************************************************************
440 * acmFilterChooseW (MSACM32.14)
441 */
442MMRESULT WINAPI acmFilterChooseW(
443 PACMFILTERCHOOSEW pafltrc)
444{
445#ifdef DEBUG
446 dprintf(("MSACM32: acmDriverChooseW not implemented\n"));
447#endif
448 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
449 return MMSYSERR_ERROR;
450}
451
452/***********************************************************************
453 * acmFilterDetailsA (MSACM32.15)
454 */
455MMRESULT WINAPI acmFilterDetailsA(
456 HACMDRIVER had, PACMFILTERDETAILSA pafd, DWORD fdwDetails)
457{
458#ifdef DEBUG
459 dprintf(("MSACM32: acmFilterDetailsA\n"));
460#endif
461 if(fdwDetails & ~(ACM_FILTERDETAILSF_FILTER))
462 return MMSYSERR_INVALFLAG;
463
464 /* FIXME
465 * How does the driver know if the ANSI or
466 * the UNICODE variant of PACMFILTERDETAILS is used?
467 * It might check cbStruct or does it only accept ANSI.
468 */
469 return (MMRESULT) acmDriverMessage(
470 had, ACMDM_FILTER_DETAILS,
471 (LPARAM) pafd, (LPARAM) fdwDetails
472 );
473}
474
475/***********************************************************************
476 * acmFilterDetailsW (MSACM32.16)
477 */
478MMRESULT WINAPI acmFilterDetailsW(
479 HACMDRIVER had, PACMFILTERDETAILSW pafd, DWORD fdwDetails)
480{
481#ifdef DEBUG
482 dprintf(("MSACM32: acmFilterDetailsW not implemented\n"));
483#endif
484 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
485 return MMSYSERR_ERROR;
486}
487
488/***********************************************************************
489 * acmFilterEnumA (MSACM32.17)
490 */
491MMRESULT WINAPI acmFilterEnumA(
492 HACMDRIVER had, PACMFILTERDETAILSA pafd,
493 ACMFILTERENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
494{
495#ifdef DEBUG
496 dprintf(("MSACM32: acmFilterEnumA not implemented\n"));
497#endif
498 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
499 return MMSYSERR_ERROR;
500}
501
502/***********************************************************************
503 * acmFilterEnumW (MSACM32.18)
504 */
505MMRESULT WINAPI acmFilterEnumW(
506 HACMDRIVER had, PACMFILTERDETAILSW pafd,
507 ACMFILTERENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
508{
509#ifdef DEBUG
510 dprintf(("MSACM32: acmFilterEnumW not implemented\n"));
511#endif
512 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
513 return MMSYSERR_ERROR;
514}
515
516/***********************************************************************
517 * acmFilterTagDetailsA (MSACM32.19)
518 */
519MMRESULT WINAPI acmFilterTagDetailsA(
520 HACMDRIVER had, PACMFILTERTAGDETAILSA paftd, DWORD fdwDetails)
521{
522#ifdef DEBUG
523 dprintf(("MSACM32: acmFilterTagDetailsA\n"));
524#endif
525 if(fdwDetails &
526 ~(ACM_FILTERTAGDETAILSF_FILTERTAG|
527 ACM_FILTERTAGDETAILSF_LARGESTSIZE))
528 return MMSYSERR_INVALFLAG;
529
530 /* FIXME
531 * How does the driver know if the ANSI or
532 * the UNICODE variant of PACMFILTERTAGDETAILS is used?
533 * It might check cbStruct or does it only accept ANSI.
534 */
535 return (MMRESULT) acmDriverMessage(
536 had, ACMDM_FILTERTAG_DETAILS,
537 (LPARAM) paftd, (LPARAM) fdwDetails
538 );
539}
540
541/***********************************************************************
542 * acmFilterTagDetailsW (MSACM32.20)
543 */
544MMRESULT WINAPI acmFilterTagDetailsW(
545 HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, DWORD fdwDetails)
546{
547#ifdef DEBUG
548 dprintf(("MSACM32: acmFilterTagDetailsW not implemented\n"));
549#endif
550 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
551 return MMSYSERR_ERROR;
552}
553
554/***********************************************************************
555 * acmFilterTagEnumA (MSACM32.21)
556 */
557MMRESULT WINAPI acmFilterTagEnumA(
558 HACMDRIVER had, PACMFILTERTAGDETAILSA paftd,
559 ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
560{
561#ifdef DEBUG
562 dprintf(("MSACM32: acmFilterTagEnumA not implemented\n"));
563#endif
564 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
565 return MMSYSERR_ERROR;
566}
567
568/***********************************************************************
569 * acmFilterTagEnumW (MSACM32.22)
570 */
571MMRESULT WINAPI acmFilterTagEnumW(
572 HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
573 ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
574{
575#ifdef DEBUG
576 dprintf(("MSACM32: acmFilterTagEnumW not implemented\n"));
577#endif
578 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
579 return MMSYSERR_ERROR;
580}
581
582/***********************************************************************
583 * acmFormatChooseA (MSACM32.23)
584 */
585MMRESULT WINAPI acmFormatChooseA(
586 PACMFORMATCHOOSEA pafmtc)
587{
588#ifdef DEBUG
589 dprintf(("MSACM32: acmFormatChooseA not implemented\n"));
590#endif
591 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
592 return MMSYSERR_ERROR;
593}
594
595/***********************************************************************
596 * acmFormatChooseW (MSACM32.24)
597 */
598MMRESULT WINAPI acmFormatChooseW(
599 PACMFORMATCHOOSEW pafmtc)
600{
601#ifdef DEBUG
602 dprintf(("MSACM32: acmFormatChooseW not implemented\n"));
603#endif
604 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
605 return MMSYSERR_ERROR;
606}
607
608/***********************************************************************
609 * acmFormatDetailsA (MSACM32.25)
610 */
611MMRESULT WINAPI acmFormatDetailsA(
612 HACMDRIVER had, PACMFORMATDETAILSA pafd, DWORD fdwDetails)
613{
614#ifdef DEBUG
615 dprintf(("MSACM32: acmFormatDetailsA\n"));
616#endif
617 if(fdwDetails & ~(ACM_FORMATDETAILSF_FORMAT))
618 return MMSYSERR_INVALFLAG;
619
620 /* FIXME
621 * How does the driver know if the ANSI or
622 * the UNICODE variant of PACMFORMATDETAILS is used?
623 * It might check cbStruct or does it only accept ANSI.
624 */
625 return (MMRESULT) acmDriverMessage(
626 had, ACMDM_FORMAT_DETAILS,
627 (LPARAM) pafd, (LPARAM) fdwDetails
628 );
629}
630
631/***********************************************************************
632 * acmFormatDetailsW (MSACM32.26)
633 */
634MMRESULT WINAPI acmFormatDetailsW(
635 HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
636{
637#ifdef DEBUG
638 dprintf(("MSACM32: acmFormatDetailsW not implemented\n"));
639#endif
640 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
641 return MMSYSERR_ERROR;
642}
643
644/***********************************************************************
645 * acmFormatEnumA (MSACM32.27)
646 */
647MMRESULT WINAPI acmFormatEnumA(
648 HACMDRIVER had, PACMFORMATDETAILSA pafd,
649 ACMFORMATENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
650{
651#ifdef DEBUG
652 dprintf(("MSACM32: acmFormatEnumA not implemented\n"));
653#endif
654 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
655 return MMSYSERR_ERROR;
656}
657
658/***********************************************************************
659 * acmFormatEnumW (MSACM32.28)
660 */
661MMRESULT WINAPI acmFormatEnumW(
662 HACMDRIVER had, PACMFORMATDETAILSW pafd,
663 ACMFORMATENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
664{
665#ifdef DEBUG
666 dprintf(("MSACM32: acmFormatEnumW not implemented\n"));
667#endif
668 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
669 return MMSYSERR_ERROR;
670}
671
672/***********************************************************************
673 * acmFormatSuggest (MSACM32.29)
674 */
675MMRESULT WINAPI acmFormatSuggest(
676 HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst,
677 DWORD cbwfxDst, DWORD fdwSuggest)
678{
679#ifdef DEBUG
680 dprintf(("MSACM32: acmFormatSuggest not implemented\n"));
681#endif
682 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
683 return MMSYSERR_ERROR;
684}
685
686/***********************************************************************
687 * acmFormatTagDetailsA (MSACM32.30)
688 */
689MMRESULT WINAPI acmFormatTagDetailsA(
690 HACMDRIVER had, PACMFORMATTAGDETAILSA paftd, DWORD fdwDetails)
691{
692#ifdef DEBUG
693 dprintf(("MSACM32: acmFormatTagDetailsA\n"));
694#endif
695 if(fdwDetails &
696 ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_LARGESTSIZE))
697 return MMSYSERR_INVALFLAG;
698
699 /* FIXME
700 * How does the driver know if the ANSI or
701 * the UNICODE variant of PACMFORMATTAGDETAILS is used?
702 * It might check cbStruct or does it only accept ANSI.
703 */
704 return (MMRESULT) acmDriverMessage(
705 had, ACMDM_FORMATTAG_DETAILS,
706 (LPARAM) paftd, (LPARAM) fdwDetails
707 );
708}
709
710/***********************************************************************
711 * acmFormatTagDetailsW (MSACM32.31)
712 */
713MMRESULT WINAPI acmFormatTagDetailsW(
714 HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, DWORD fdwDetails)
715{
716#ifdef DEBUG
717 dprintf(("MSACM32: acmFormatTagDetailsW not implemented\n"));
718#endif
719 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
720 return MMSYSERR_ERROR;
721}
722
723/***********************************************************************
724 * acmFormatTagEnumA (MSACM32.32)
725 */
726MMRESULT WINAPI acmFormatTagEnumA(
727 HACMDRIVER had, PACMFORMATTAGDETAILSA paftd,
728 ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
729{
730#ifdef DEBUG
731 dprintf(("MSACM32: acmFormatTagEnumA not implemented\n"));
732#endif
733 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
734 return MMSYSERR_ERROR;
735}
736
737/***********************************************************************
738 * acmFormatTagEnumW (MSACM32.33)
739 */
740MMRESULT WINAPI acmFormatTagEnumW(
741 HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
742 ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
743{
744#ifdef DEBUG
745 dprintf(("MSACM32: acmFormatTagEnumW not implemented\n"));
746#endif
747 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
748 return MMSYSERR_ERROR;
749}
750
751/***********************************************************************
752 * acmGetVersion (MSACM32.34)
753 */
754DWORD WINAPI acmGetVersion()
755{
756#ifdef DEBUG
757 dprintf(("MSACM32: acmGetVersion\n"));
758#endif
759 switch(GetVersion())
760 {
761 default:
762//
763 case WIN95:
764 return 0x04000000; /* 4.0.0 */
765 case NT40:
766 return 0x04000565; /* 4.0.1381 */
767 }
768}
769
770/***********************************************************************
771 * acmMessage (MSACM32.35)
772 * FIXME
773 * No documentation found.
774 */
775
776/***********************************************************************
777 * acmMetrics (MSACM32.36)
778 */
779MMRESULT WINAPI acmMetrics(
780 HACMOBJ hao, UINT uMetric, LPVOID pMetric)
781{
782#ifdef DEBUG
783 dprintf(("MSACM32: acmMetrics\n"));
784#endif
785 PWINE_ACMOBJ pao = MSACM_GetObj(hao);
786 BOOL bLocal = TRUE;
787
788 switch(uMetric)
789 {
790 case ACM_METRIC_COUNT_DRIVERS:
791 bLocal = FALSE;
792 case ACM_METRIC_COUNT_LOCAL_DRIVERS:
793 if(!pao)
794 return MMSYSERR_INVALHANDLE;
795 return MMSYSERR_NOTSUPPORTED;
796 case ACM_METRIC_COUNT_CODECS:
797 bLocal = FALSE;
798 case ACM_METRIC_COUNT_LOCAL_CODECS:
799 return MMSYSERR_NOTSUPPORTED;
800 case ACM_METRIC_COUNT_CONVERTERS:
801 bLocal = FALSE;
802 case ACM_METRIC_COUNT_LOCAL_CONVERTERS:
803 return MMSYSERR_NOTSUPPORTED;
804 case ACM_METRIC_COUNT_FILTERS:
805 bLocal = FALSE;
806 case ACM_METRIC_COUNT_LOCAL_FILTERS:
807 return MMSYSERR_NOTSUPPORTED;
808 case ACM_METRIC_COUNT_DISABLED:
809 bLocal = FALSE;
810 case ACM_METRIC_COUNT_LOCAL_DISABLED:
811 if(!pao)
812 return MMSYSERR_INVALHANDLE;
813 return MMSYSERR_NOTSUPPORTED;
814 case ACM_METRIC_COUNT_HARDWARE:
815 case ACM_METRIC_HARDWARE_WAVE_INPUT:
816 case ACM_METRIC_HARDWARE_WAVE_OUTPUT:
817 case ACM_METRIC_MAX_SIZE_FORMAT:
818 case ACM_METRIC_MAX_SIZE_FILTER:
819 case ACM_METRIC_DRIVER_SUPPORT:
820 case ACM_METRIC_DRIVER_PRIORITY:
821 default:
822 return MMSYSERR_NOTSUPPORTED;
823 }
824 return MMSYSERR_NOERROR;
825}
826
827/***********************************************************************
828 * acmStreamClose (MSACM32.37)
829 */
830MMRESULT WINAPI acmStreamClose(
831 HACMSTREAM has, DWORD fdwClose)
832{
833#ifdef DEBUG
834 dprintf(("MSACM32: acmStreamClose not implemented\n"));
835#endif
836 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
837 return MMSYSERR_ERROR;
838}
839
840/***********************************************************************
841 * acmStreamConvert (MSACM32.38)
842 */
843MMRESULT WINAPI acmStreamConvert(
844 HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwConvert)
845{
846#ifdef DEBUG
847 dprintf(("MSACM32: acmStreamConvert not implemented\n"));
848#endif
849 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
850 return MMSYSERR_ERROR;
851}
852
853/***********************************************************************
854 * acmStreamMessage (MSACM32.39)
855 */
856MMRESULT WINAPI acmStreamMessage(
857 HACMSTREAM has, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
858{
859#ifdef DEBUG
860 dprintf(("MSACM32: acmStreamMessage not implemented\n"));
861#endif
862 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
863 return MMSYSERR_ERROR;
864}
865
866/***********************************************************************
867 * acmStreamOpen (MSACM32.40)
868 */
869MMRESULT WINAPI acmStreamOpen(
870 PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
871 PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
872 DWORD dwInstance, DWORD fdwOpen)
873{
874#ifdef DEBUG
875 dprintf(("MSACM32: acmStreamOpen not implemented\n"));
876#endif
877 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
878 return MMSYSERR_ERROR;
879}
880
881
882/***********************************************************************
883 * acmStreamPrepareHeader (MSACM32.41)
884 */
885MMRESULT WINAPI acmStreamPrepareHeader(
886 HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwPrepare)
887{
888#ifdef DEBUG
889 dprintf(("MSACM32: acmStreamPrepareHeader not implemented\n"));
890#endif
891 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
892 return MMSYSERR_ERROR;
893}
894
895/***********************************************************************
896 * acmStreamReset (MSACM32.42)
897 */
898MMRESULT WINAPI acmStreamReset(
899 HACMSTREAM has, DWORD fdwReset)
900{
901#ifdef DEBUG
902 dprintf(("MSACM32: acmStreamReset not implemented\n"));
903#endif
904 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
905 return MMSYSERR_ERROR;
906}
907
908/***********************************************************************
909 * acmStreamSize (MSACM32.43)
910 */
911MMRESULT WINAPI acmStreamSize(
912 HACMSTREAM has, DWORD cbInput,
913 LPDWORD pdwOutputBytes, DWORD fdwSize)
914{
915#ifdef DEBUG
916 dprintf(("MSACM32: acmStreamSize not implemented\n"));
917#endif
918 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
919 return MMSYSERR_ERROR;
920}
921
922/***********************************************************************
923 * acmStreamUnprepareHeader (MSACM32.44)
924 */
925MMRESULT WINAPI acmStreamUnprepareHeader(
926 HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwUnprepare)
927{
928#ifdef DEBUG
929 dprintf(("MSACM32: acmStreamUnprepareHeader not implemented\n"));
930#endif
931 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
932 return MMSYSERR_ERROR;
933}
Note: See TracBrowser for help on using the repository browser.