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

Last change on this file since 919 was 779, checked in by sandervl, 26 years ago

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