wined3d: Store the texture in a local variable in sampler_texmatrix().
[wine] / dlls / msacm32 / driver.c
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4  *      MSACM32 library
5  *
6  *      Copyright 1998  Patrik Stridvall
7  *                1999  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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdarg.h>
28 #include <stdio.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winnls.h"
35 #include "mmsystem.h"
36 #include "mmreg.h"
37 #include "msacm.h"
38 #include "msacmdrv.h"
39 #include "wineacm.h"
40 #include "wine/debug.h"
41 #include "wine/unicode.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(msacm);
44
45 /***********************************************************************
46  *           acmDriverAddA (MSACM32.@)
47  */
48 MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
49                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
50 {
51     MMRESULT resultW;
52     WCHAR * driverW = NULL;
53     LPARAM lParamW = lParam;
54
55     TRACE("(%p, %p, %08lx, %08x, %08x)\n",
56           phadid, hinstModule, lParam, dwPriority, fdwAdd);
57
58     if (!phadid) {
59         WARN("invalid parameter\n");
60         return MMSYSERR_INVALPARAM;
61     }
62
63     /* Check if any unknown flags */
64     if (fdwAdd &
65         ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
66           ACM_DRIVERADDF_GLOBAL)) {
67         WARN("invalid flag\n");
68         return MMSYSERR_INVALFLAG;
69     }
70
71     /* Check if any incompatible flags */
72     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
73         (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND)) {
74         WARN("invalid flag\n");
75         return MMSYSERR_INVALFLAG;
76     }
77
78     /* A->W translation of name */
79     if ((fdwAdd & ACM_DRIVERADDF_TYPEMASK) == ACM_DRIVERADDF_NAME) {
80         unsigned long len;
81         
82         if (lParam == 0) return MMSYSERR_INVALPARAM;
83         len = MultiByteToWideChar(CP_ACP, 0, (LPSTR)lParam, -1, NULL, 0);
84         driverW = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
85         if (!driverW) return MMSYSERR_NOMEM;
86         MultiByteToWideChar(CP_ACP, 0, (LPSTR)lParam, -1, driverW, len);
87         lParamW = (LPARAM)driverW;
88     }
89
90     resultW = acmDriverAddW(phadid, hinstModule, lParamW, dwPriority, fdwAdd);
91     HeapFree(MSACM_hHeap, 0, driverW);
92     return resultW;
93 }
94
95 /***********************************************************************
96  *           acmDriverAddW (MSACM32.@)
97  *
98  */
99 MMRESULT WINAPI acmDriverAddW(PHACMDRIVERID phadid, HINSTANCE hinstModule,
100                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
101 {
102     PWINE_ACMLOCALDRIVER pLocalDrv = NULL;
103
104     TRACE("(%p, %p, %08lx, %08x, %08x)\n",
105           phadid, hinstModule, lParam, dwPriority, fdwAdd);
106
107     if (!phadid) {
108         WARN("invalid parameter\n");
109         return MMSYSERR_INVALPARAM;
110     }
111
112     /* Check if any unknown flags */
113     if (fdwAdd &
114         ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
115           ACM_DRIVERADDF_GLOBAL)) {
116         WARN("invalid flag\n");
117         return MMSYSERR_INVALFLAG;
118     }
119  
120     /* Check if any incompatible flags */
121     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
122         (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND)) {
123         WARN("invalid flag\n");
124         return MMSYSERR_INVALFLAG;
125     }
126
127     switch (fdwAdd & ACM_DRIVERADDF_TYPEMASK) {
128     case ACM_DRIVERADDF_NAME:
129         /*
130                 hInstModule     (unused)
131                 lParam          name of value in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Drivers32
132                 dwPriority      (unused, set to 0)
133          */
134         *phadid = (HACMDRIVERID) MSACM_RegisterDriverFromRegistry((LPCWSTR)lParam);        
135         if (!*phadid) {
136             ERR("Unable to register driver via ACM_DRIVERADDF_NAME\n");
137             return MMSYSERR_INVALPARAM;
138         }
139         break;
140     case ACM_DRIVERADDF_FUNCTION:
141         /*
142                 hInstModule     Handle of module which contains driver entry proc
143                 lParam          Driver function address
144                 dwPriority      (unused, set to 0)
145          */
146         fdwAdd &= ~ACM_DRIVERADDF_TYPEMASK;
147         /* FIXME: fdwAdd ignored */
148         /* Application-supplied acmDriverProc's are placed at the top of the priority unless
149            fdwAdd indicates ACM_DRIVERADDF_GLOBAL
150          */
151         pLocalDrv = MSACM_RegisterLocalDriver(hinstModule, (DRIVERPROC)lParam);
152         *phadid = pLocalDrv ? (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, pLocalDrv) : NULL;
153         if (!*phadid) {
154             ERR("Unable to register driver via ACM_DRIVERADDF_FUNCTION\n");
155             return MMSYSERR_INVALPARAM;
156         }
157         break;
158     case ACM_DRIVERADDF_NOTIFYHWND:
159         /*
160                 hInstModule     (unused)
161                 lParam          Handle of notification window
162                 dwPriority      Window message to send for notification broadcasts
163          */
164         *phadid = (HACMDRIVERID) MSACM_RegisterNotificationWindow((HWND)lParam, dwPriority);
165         if (!*phadid) {
166             ERR("Unable to register driver via ACM_DRIVERADDF_NOTIFYHWND\n");
167             return MMSYSERR_INVALPARAM;
168         }
169         break;
170     default:
171         ERR("invalid flag value 0x%08lx for fdwAdd\n", fdwAdd & ACM_DRIVERADDF_TYPEMASK);
172         return MMSYSERR_INVALFLAG;
173     }
174
175     MSACM_BroadcastNotification();
176     return MMSYSERR_NOERROR;
177 }
178
179 /***********************************************************************
180  *           acmDriverClose (MSACM32.@)
181  */
182 MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
183 {
184     PWINE_ACMDRIVER     pad;
185     PWINE_ACMDRIVERID   padid;
186     PWINE_ACMDRIVER*    tpad;
187
188     TRACE("(%p, %08x)\n", had, fdwClose);
189
190     if (fdwClose) {
191         WARN("invalid flag\n");
192         return MMSYSERR_INVALFLAG;
193     }
194
195     pad = MSACM_GetDriver(had);
196     if (!pad) {
197         WARN("invalid handle\n");
198         return MMSYSERR_INVALHANDLE;
199     }
200
201     padid = pad->obj.pACMDriverID;
202
203     /* remove driver from list */
204     for (tpad = &(padid->pACMDriverList); *tpad; tpad = &((*tpad)->pNextACMDriver)) {
205         if (*tpad == pad) {
206             *tpad = (*tpad)->pNextACMDriver;
207             break;
208         }
209     }
210
211     /* close driver if it has been opened */
212     if (pad->hDrvr && !pad->pLocalDrvrInst)
213         CloseDriver(pad->hDrvr, 0, 0);
214     else if (pad->pLocalDrvrInst)
215         MSACM_CloseLocalDriver(pad->pLocalDrvrInst);
216
217     HeapFree(MSACM_hHeap, 0, pad);
218
219     return MMSYSERR_NOERROR;
220 }
221
222 /***********************************************************************
223  *           acmDriverDetailsA (MSACM32.@)
224  */
225 MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
226 {
227     MMRESULT mmr;
228     ACMDRIVERDETAILSW   addw;
229
230     TRACE("(%p, %p, %08x)\n", hadid, padd, fdwDetails);
231
232     if (!padd) {
233         WARN("invalid parameter\n");
234         return MMSYSERR_INVALPARAM;
235     }
236
237     if (padd->cbStruct < 4) {
238         WARN("invalid parameter\n");
239         return MMSYSERR_INVALPARAM;
240     }
241
242     addw.cbStruct = sizeof(addw);
243     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
244     if (mmr == 0) {
245         ACMDRIVERDETAILSA padda;
246
247         padda.fccType = addw.fccType;
248         padda.fccComp = addw.fccComp;
249         padda.wMid = addw.wMid;
250         padda.wPid = addw.wPid;
251         padda.vdwACM = addw.vdwACM;
252         padda.vdwDriver = addw.vdwDriver;
253         padda.fdwSupport = addw.fdwSupport;
254         padda.cFormatTags = addw.cFormatTags;
255         padda.cFilterTags = addw.cFilterTags;
256         padda.hicon = addw.hicon;
257         WideCharToMultiByte( CP_ACP, 0, addw.szShortName, -1, padda.szShortName,
258                              sizeof(padda.szShortName), NULL, NULL );
259         WideCharToMultiByte( CP_ACP, 0, addw.szLongName, -1, padda.szLongName,
260                              sizeof(padda.szLongName), NULL, NULL );
261         WideCharToMultiByte( CP_ACP, 0, addw.szCopyright, -1, padda.szCopyright,
262                              sizeof(padda.szCopyright), NULL, NULL );
263         WideCharToMultiByte( CP_ACP, 0, addw.szLicensing, -1, padda.szLicensing,
264                              sizeof(padda.szLicensing), NULL, NULL );
265         WideCharToMultiByte( CP_ACP, 0, addw.szFeatures, -1, padda.szFeatures,
266                              sizeof(padda.szFeatures), NULL, NULL );
267         padda.cbStruct = min(padd->cbStruct, sizeof(*padd));
268         memcpy(padd, &padda, padda.cbStruct);
269     }
270     return mmr;
271 }
272
273 /***********************************************************************
274  *           acmDriverDetailsW (MSACM32.@)
275  */
276 MMRESULT WINAPI acmDriverDetailsW(HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
277 {
278     HACMDRIVER acmDrvr;
279     MMRESULT mmr;
280
281     TRACE("(%p, %p, %08x)\n", hadid, padd, fdwDetails);
282
283     if (!padd) {
284         WARN("invalid parameter\n");
285         return MMSYSERR_INVALPARAM;
286     }
287
288     if (padd->cbStruct < 4) {
289         WARN("invalid parameter\n");
290         return MMSYSERR_INVALPARAM;
291     }
292
293     if (fdwDetails) {
294         WARN("invalid flag\n");
295         return MMSYSERR_INVALFLAG;
296     }
297
298     mmr = acmDriverOpen(&acmDrvr, hadid, 0);
299     if (mmr == MMSYSERR_NOERROR) {
300         ACMDRIVERDETAILSW paddw;
301         paddw.cbStruct = sizeof(paddw);
302         mmr = MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)&paddw,  0);
303
304         acmDriverClose(acmDrvr, 0);
305         paddw.cbStruct = min(padd->cbStruct, sizeof(*padd));
306         memcpy(padd, &paddw, paddw.cbStruct);
307     }
308
309     return mmr;
310 }
311
312 /***********************************************************************
313  *           acmDriverEnum (MSACM32.@)
314  */
315 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
316 {
317     PWINE_ACMDRIVERID   padid;
318     DWORD               fdwSupport;
319
320     TRACE("(%p, %08x, %08x)\n", fnCallback, dwInstance, fdwEnum);
321
322     if (!fnCallback) {
323         WARN("invalid parameter\n");
324         return MMSYSERR_INVALPARAM;
325     }
326
327     if (fdwEnum & ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
328         WARN("invalid flag\n");
329         return MMSYSERR_INVALFLAG;
330     }
331
332     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
333         fdwSupport = padid->fdwSupport;
334
335         if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
336             if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
337                 fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
338             else
339                 continue;
340         }
341         if (!(*fnCallback)((HACMDRIVERID)padid, dwInstance, fdwSupport))
342             break;
343     }
344
345     return MMSYSERR_NOERROR;
346 }
347
348 /***********************************************************************
349  *           acmDriverID (MSACM32.@)
350  */
351 MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
352 {
353     PWINE_ACMOBJ pao;
354
355     TRACE("(%p, %p, %08x)\n", hao, phadid, fdwDriverID);
356
357     if (fdwDriverID) {
358         WARN("invalid flag\n");
359         return MMSYSERR_INVALFLAG;
360     }
361
362     pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
363     if (!pao) {
364         WARN("invalid handle\n");
365         return MMSYSERR_INVALHANDLE;
366     }
367
368     if (!phadid) {
369         WARN("invalid parameter\n");
370         return MMSYSERR_INVALPARAM;
371     }
372
373     *phadid = (HACMDRIVERID) pao->pACMDriverID;
374
375     return MMSYSERR_NOERROR;
376 }
377
378 /***********************************************************************
379  *           acmDriverMessage (MSACM32.@)
380  *
381  * Note: MSDN documentation (July 2001) is incomplete. This function
382  * accepts sending messages to an HACMDRIVERID in addition to the
383  * documented HACMDRIVER. In fact, for DRV_QUERYCONFIGURE and DRV_CONFIGURE, 
384  * this might actually be the required mode of operation.
385  *
386  * Note: For DRV_CONFIGURE, msacm supplies its own DRVCONFIGINFO structure
387  * when the application fails to supply one. Some native drivers depend on
388  * this and refuse to display unless a valid DRVCONFIGINFO structure is
389  * built and supplied.
390  */
391 LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
392 {
393     TRACE("(%p, %04x, %08lx, %08lx\n", had, uMsg, lParam1, lParam2);
394
395     if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
396         uMsg == ACMDM_DRIVER_ABOUT ||
397         uMsg == DRV_QUERYCONFIGURE ||
398         uMsg == DRV_CONFIGURE)
399     {
400         PWINE_ACMDRIVERID padid;
401         LRESULT lResult;
402         LPDRVCONFIGINFO pConfigInfo = NULL;
403         LPWSTR section_name = NULL;
404         LPWSTR alias_name = NULL;
405
406         /* Check whether handle is an HACMDRIVERID */
407         padid  = MSACM_GetDriverID((HACMDRIVERID)had);
408         
409         /* If the message is DRV_CONFIGURE, and the application provides no
410            DRVCONFIGINFO structure, msacm must supply its own.
411          */
412         if (uMsg == DRV_CONFIGURE && lParam2 == 0) {
413             LPWSTR pAlias;
414             
415             /* Get the alias from the HACMDRIVERID */
416             if (padid) {
417                 pAlias = padid->pszDriverAlias;
418                 if (pAlias == NULL) {
419                     WARN("DRV_CONFIGURE: no alias for this driver, cannot self-supply alias\n");
420                 }
421             } else {
422                 FIXME("DRV_CONFIGURE: reverse lookup HACMDRIVER -> HACMDRIVERID not implemented\n");
423                 pAlias = NULL;
424             }
425         
426             if (pAlias != NULL) {
427                 /* DRVCONFIGINFO is only 12 bytes long, but native msacm
428                  * reports a 16-byte structure to codecs, so allocate 16 bytes,
429                  * just to be on the safe side.
430                  */
431                 const unsigned int iStructSize = 16;
432                 pConfigInfo = HeapAlloc(MSACM_hHeap, 0, iStructSize);
433                 if (!pConfigInfo) {
434                     ERR("OOM while supplying DRVCONFIGINFO for DRV_CONFIGURE, using NULL\n");
435                 } else {
436                     static const WCHAR drivers32[] = {'D','r','i','v','e','r','s','3','2','\0'};
437
438                     pConfigInfo->dwDCISize = iStructSize;
439
440                     section_name = HeapAlloc(MSACM_hHeap, 0, (strlenW(drivers32) + 1) * sizeof(WCHAR));
441                     if (section_name) strcpyW(section_name, drivers32);
442                     pConfigInfo->lpszDCISectionName = section_name;
443                     alias_name = HeapAlloc(MSACM_hHeap, 0, (strlenW(pAlias) + 1) * sizeof(WCHAR));
444                     if (alias_name) strcpyW(alias_name, pAlias);
445                     pConfigInfo->lpszDCIAliasName = alias_name;
446
447                     if (pConfigInfo->lpszDCISectionName == NULL || pConfigInfo->lpszDCIAliasName == NULL) {
448                         HeapFree(MSACM_hHeap, 0, alias_name);
449                         HeapFree(MSACM_hHeap, 0, section_name);
450                         HeapFree(MSACM_hHeap, 0, pConfigInfo);
451                         pConfigInfo = NULL;
452                         ERR("OOM while supplying DRVCONFIGINFO for DRV_CONFIGURE, using NULL\n");
453                     }
454                 }
455             }
456             
457             lParam2 = (LPARAM)pConfigInfo;
458         }
459         
460         if (padid) {
461             /* Handle is really an HACMDRIVERID, must have an open session to get an HACMDRIVER */
462             if (padid->pACMDriverList != NULL) {
463                 lResult = MSACM_Message((HACMDRIVER)padid->pACMDriverList, uMsg, lParam1, lParam2);
464             } else {
465                 MMRESULT mmr = acmDriverOpen(&had, (HACMDRIVERID)padid, 0);
466                 if (mmr != MMSYSERR_NOERROR) {
467                     lResult = MMSYSERR_INVALPARAM;
468                 } else {
469                     lResult = acmDriverMessage(had, uMsg, lParam1, lParam2);
470                     acmDriverClose(had, 0);
471                 }
472             }
473         } else {
474             lResult = MSACM_Message(had, uMsg, lParam1, lParam2);
475         }
476         if (pConfigInfo) {
477             HeapFree(MSACM_hHeap, 0, alias_name);
478             HeapFree(MSACM_hHeap, 0, section_name);
479             HeapFree(MSACM_hHeap, 0, pConfigInfo);
480         }
481         return lResult;
482     }
483     WARN("invalid parameter\n");
484     return MMSYSERR_INVALPARAM;
485 }
486
487 /***********************************************************************
488  *           acmDriverOpen (MSACM32.@)
489  */
490 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
491 {
492     PWINE_ACMDRIVERID   padid;
493     PWINE_ACMDRIVER     pad = NULL;
494     MMRESULT            ret;
495
496     TRACE("(%p, %p, %08u)\n", phad, hadid, fdwOpen);
497
498     if (!phad) {
499         WARN("invalid parameter\n");
500         return MMSYSERR_INVALPARAM;
501     }
502
503     if (fdwOpen) {
504         WARN("invalid flag\n");
505         return MMSYSERR_INVALFLAG;
506     }
507
508     padid = MSACM_GetDriverID(hadid);
509     if (!padid) {
510         WARN("invalid handle\n");
511         return MMSYSERR_INVALHANDLE;
512     }
513
514     pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
515     if (!pad) {
516         WARN("no memory\n");
517         return MMSYSERR_NOMEM;
518     }
519
520     pad->obj.dwType = WINE_ACMOBJ_DRIVER;
521     pad->obj.pACMDriverID = padid;
522     pad->hDrvr = 0;
523     pad->pLocalDrvrInst = NULL;
524
525     if (padid->pLocalDriver == NULL)
526     {
527         ACMDRVOPENDESCW adod;
528         int             len;
529         LPWSTR          section_name;
530
531         /* this is not an externally added driver... need to actually load it */
532         if (!padid->pszDriverAlias)
533         {
534             ret = MMSYSERR_ERROR;
535             goto gotError;
536         }
537
538         adod.cbStruct = sizeof(adod);
539         adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
540         adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
541         adod.dwVersion = acmGetVersion();
542         adod.dwFlags = fdwOpen;
543         adod.dwError = 0;
544         len = strlen("Drivers32") + 1;
545         section_name = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
546         MultiByteToWideChar(CP_ACP, 0, "Drivers32", -1, section_name, len);
547         adod.pszSectionName = section_name;
548         adod.pszAliasName = padid->pszDriverAlias;
549         adod.dnDevNode = 0;
550
551         pad->hDrvr = OpenDriver(padid->pszDriverAlias, NULL, (DWORD)&adod);
552
553         HeapFree(MSACM_hHeap, 0, section_name);
554         if (!pad->hDrvr)
555         {
556             ret = adod.dwError;
557             goto gotError;
558         }
559     }
560     else
561     {
562         ACMDRVOPENDESCW adod;
563
564         pad->hDrvr = NULL;
565
566         adod.cbStruct = sizeof(adod);
567         adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
568         adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
569         adod.dwVersion = acmGetVersion();
570         adod.dwFlags = fdwOpen;
571         adod.dwError = 0;
572         adod.pszSectionName = NULL;
573         adod.pszAliasName = NULL;
574         adod.dnDevNode = 0;
575
576         pad->pLocalDrvrInst = MSACM_OpenLocalDriver(padid->pLocalDriver, (DWORD)&adod);
577         if (!pad->pLocalDrvrInst)
578         {
579             ret = adod.dwError;
580             goto gotError;
581         }
582     }
583
584     /* insert new pad at beg of list */
585     pad->pNextACMDriver = padid->pACMDriverList;
586     padid->pACMDriverList = pad;
587
588     /* FIXME: Create a WINE_ACMDRIVER32 */
589     *phad = (HACMDRIVER)pad;
590     TRACE("%s => %p\n", debugstr_w(padid->pszDriverAlias), pad);
591
592     return MMSYSERR_NOERROR;
593  gotError:
594     WARN("failed: ret = %08x\n", ret);
595     if (pad && !pad->hDrvr)
596         HeapFree(MSACM_hHeap, 0, pad);
597     return ret;
598 }
599
600 /***********************************************************************
601  *           acmDriverPriority (MSACM32.@)
602  */
603 MMRESULT WINAPI acmDriverPriority(HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
604 {
605
606     TRACE("(%p, %08x, %08x)\n", hadid, dwPriority, fdwPriority);
607
608     /* Check for unknown flags */
609     if (fdwPriority &
610         ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
611           ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
612         WARN("invalid flag\n");
613         return MMSYSERR_INVALFLAG;
614     }
615
616     /* Check for incompatible flags */
617     if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
618         (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE)) {
619         WARN("invalid flag\n");
620         return MMSYSERR_INVALFLAG;
621     }
622
623     /* Check for incompatible flags */
624     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
625         (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
626         WARN("invalid flag\n");
627         return MMSYSERR_INVALFLAG;
628     }
629     
630     /* According to MSDN, ACM_DRIVERPRIORITYF_BEGIN and ACM_DRIVERPRIORITYF_END 
631        may only appear by themselves, and in addition, hadid and dwPriority must
632        both be zero */
633     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) ||
634         (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
635         if (fdwPriority & ~(ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
636             WARN("ACM_DRIVERPRIORITYF_[BEGIN|END] cannot be used with any other flags\n");
637             return MMSYSERR_INVALPARAM;
638         }
639         if (dwPriority) {
640             WARN("priority invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
641             return MMSYSERR_INVALPARAM;
642         }
643         if (hadid) {
644             WARN("non-null hadid invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
645             return MMSYSERR_INVALPARAM;
646         }
647         /* FIXME: MSDN wording suggests that deferred notification should be 
648            implemented as a system-wide lock held by a calling task, and that 
649            re-enabling notifications should broadcast them across all processes.
650            This implementation uses a simple DWORD counter. One consequence of the
651            current implementation is that applications will never see 
652            MMSYSERR_ALLOCATED as a return error.
653          */
654         if (fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) {
655             MSACM_DisableNotifications();
656         } else if (fdwPriority & ACM_DRIVERPRIORITYF_END) {
657             MSACM_EnableNotifications();
658         }
659         return MMSYSERR_NOERROR;
660     } else {
661         PWINE_ACMDRIVERID padid;
662         PWINE_ACMNOTIFYWND panwnd;
663         BOOL bPerformBroadcast = FALSE;
664
665         /* Fetch driver ID */
666         padid = MSACM_GetDriverID(hadid);
667         panwnd = MSACM_GetNotifyWnd(hadid);
668         if (!padid && !panwnd) {
669             WARN("invalid handle\n");
670             return MMSYSERR_INVALHANDLE;
671         }
672         
673         if (padid) {
674             /* Check whether driver ID is appropriate for requested op */
675             if (dwPriority) {
676                 if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) {
677                     return MMSYSERR_NOTSUPPORTED;
678                 }
679                 if (dwPriority != 1 && dwPriority != (DWORD)-1) {
680                     FIXME("unexpected priority %d, using sign only\n", dwPriority);
681                     if ((signed)dwPriority < 0) dwPriority = (DWORD)-1;
682                     if (dwPriority > 0) dwPriority = 1;
683                 }
684                 
685                 if (dwPriority == 1 && (padid->pPrevACMDriverID == NULL || 
686                     (padid->pPrevACMDriverID->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL))) {
687                     /* do nothing - driver is first of list, or first after last
688                        local driver */
689                 } else if (dwPriority == (DWORD)-1 && padid->pNextACMDriverID == NULL) {
690                     /* do nothing - driver is last of list */
691                 } else {
692                     MSACM_RePositionDriver(padid, dwPriority);
693                     bPerformBroadcast = TRUE;
694                 }
695             }
696
697             /* Check whether driver ID should be enabled or disabled */
698             if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
699                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
700                     padid->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
701                     bPerformBroadcast = TRUE;
702                 }
703             } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
704                 if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
705                     padid->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
706                     bPerformBroadcast = TRUE;
707                 }
708             }
709         }
710         
711         if (panwnd) {
712             if (dwPriority) {
713                 return MMSYSERR_NOTSUPPORTED;
714             }
715         
716             /* Check whether notify window should be enabled or disabled */
717             if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
718                 if (!(panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
719                     panwnd->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
720                     bPerformBroadcast = TRUE;
721                 }
722             } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
723                 if (panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
724                     panwnd->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
725                     bPerformBroadcast = TRUE;
726                 }
727             }
728         }
729         
730         /* Perform broadcast of changes */
731         if (bPerformBroadcast) {
732             MSACM_WriteCurrentPriorities();
733             MSACM_BroadcastNotification();
734         }
735         return MMSYSERR_NOERROR;
736     }
737 }
738
739 /***********************************************************************
740  *           acmDriverRemove (MSACM32.@)
741  */
742 MMRESULT WINAPI acmDriverRemove(HACMDRIVERID hadid, DWORD fdwRemove)
743 {
744     PWINE_ACMDRIVERID padid;
745     PWINE_ACMNOTIFYWND panwnd;
746
747     TRACE("(%p, %08x)\n", hadid, fdwRemove);
748
749     padid = MSACM_GetDriverID(hadid);
750     panwnd = MSACM_GetNotifyWnd(hadid);
751     if (!padid && !panwnd) {
752         WARN("invalid handle\n");
753         return MMSYSERR_INVALHANDLE;
754     }
755
756     if (fdwRemove) {
757         WARN("invalid flag\n");
758         return MMSYSERR_INVALFLAG;
759     }
760
761     if (padid) MSACM_UnregisterDriver(padid);
762     if (panwnd) MSACM_UnRegisterNotificationWindow(panwnd);
763     MSACM_BroadcastNotification();
764
765     return MMSYSERR_NOERROR;
766 }