dbghelp: Allow loading PE module with 64bit addresses.
[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         INT 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     pad->obj.dwType = 0;
218     HeapFree(MSACM_hHeap, 0, pad);
219
220     return MMSYSERR_NOERROR;
221 }
222
223 /***********************************************************************
224  *           acmDriverDetailsA (MSACM32.@)
225  */
226 MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
227 {
228     MMRESULT mmr;
229     ACMDRIVERDETAILSW   addw;
230
231     TRACE("(%p, %p, %08x)\n", hadid, padd, fdwDetails);
232
233     if (!padd) {
234         WARN("invalid parameter\n");
235         return MMSYSERR_INVALPARAM;
236     }
237
238     if (padd->cbStruct < 4) {
239         WARN("invalid parameter\n");
240         return MMSYSERR_INVALPARAM;
241     }
242
243     addw.cbStruct = sizeof(addw);
244     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
245     if (mmr == 0) {
246         ACMDRIVERDETAILSA padda;
247
248         padda.fccType = addw.fccType;
249         padda.fccComp = addw.fccComp;
250         padda.wMid = addw.wMid;
251         padda.wPid = addw.wPid;
252         padda.vdwACM = addw.vdwACM;
253         padda.vdwDriver = addw.vdwDriver;
254         padda.fdwSupport = addw.fdwSupport;
255         padda.cFormatTags = addw.cFormatTags;
256         padda.cFilterTags = addw.cFilterTags;
257         padda.hicon = addw.hicon;
258         WideCharToMultiByte( CP_ACP, 0, addw.szShortName, -1, padda.szShortName,
259                              sizeof(padda.szShortName), NULL, NULL );
260         WideCharToMultiByte( CP_ACP, 0, addw.szLongName, -1, padda.szLongName,
261                              sizeof(padda.szLongName), NULL, NULL );
262         WideCharToMultiByte( CP_ACP, 0, addw.szCopyright, -1, padda.szCopyright,
263                              sizeof(padda.szCopyright), NULL, NULL );
264         WideCharToMultiByte( CP_ACP, 0, addw.szLicensing, -1, padda.szLicensing,
265                              sizeof(padda.szLicensing), NULL, NULL );
266         WideCharToMultiByte( CP_ACP, 0, addw.szFeatures, -1, padda.szFeatures,
267                              sizeof(padda.szFeatures), NULL, NULL );
268         padda.cbStruct = min(padd->cbStruct, sizeof(*padd));
269         memcpy(padd, &padda, padda.cbStruct);
270     }
271     return mmr;
272 }
273
274 /***********************************************************************
275  *           acmDriverDetailsW (MSACM32.@)
276  */
277 MMRESULT WINAPI acmDriverDetailsW(HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
278 {
279     HACMDRIVER acmDrvr;
280     MMRESULT mmr;
281
282     TRACE("(%p, %p, %08x)\n", hadid, padd, fdwDetails);
283
284     if (!padd) {
285         WARN("invalid parameter\n");
286         return MMSYSERR_INVALPARAM;
287     }
288
289     if (padd->cbStruct < 4) {
290         WARN("invalid parameter\n");
291         return MMSYSERR_INVALPARAM;
292     }
293
294     if (fdwDetails) {
295         WARN("invalid flag\n");
296         return MMSYSERR_INVALFLAG;
297     }
298
299     mmr = acmDriverOpen(&acmDrvr, hadid, 0);
300     if (mmr == MMSYSERR_NOERROR) {
301         ACMDRIVERDETAILSW paddw;
302         paddw.cbStruct = sizeof(paddw);
303         mmr = MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)&paddw,  0);
304
305         acmDriverClose(acmDrvr, 0);
306         paddw.cbStruct = min(padd->cbStruct, sizeof(*padd));
307         memcpy(padd, &paddw, paddw.cbStruct);
308     }
309     else if (mmr == MMSYSERR_NODRIVER)
310         return MMSYSERR_NOTSUPPORTED;
311
312     return mmr;
313 }
314
315 /***********************************************************************
316  *           acmDriverEnum (MSACM32.@)
317  */
318 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD_PTR dwInstance,
319                               DWORD fdwEnum)
320 {
321     PWINE_ACMDRIVERID   padid;
322     DWORD               fdwSupport;
323
324     TRACE("(%p, %08lx, %08x)\n", fnCallback, dwInstance, fdwEnum);
325
326     if (!fnCallback) {
327         WARN("invalid parameter\n");
328         return MMSYSERR_INVALPARAM;
329     }
330
331     if (fdwEnum & ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
332         WARN("invalid flag\n");
333         return MMSYSERR_INVALFLAG;
334     }
335
336     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
337         fdwSupport = padid->fdwSupport;
338
339         if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
340             if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
341                 fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
342             else
343                 continue;
344         }
345         if (!(*fnCallback)((HACMDRIVERID)padid, dwInstance, fdwSupport))
346             break;
347     }
348
349     return MMSYSERR_NOERROR;
350 }
351
352 /***********************************************************************
353  *           acmDriverID (MSACM32.@)
354  */
355 MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
356 {
357     PWINE_ACMOBJ pao;
358
359     TRACE("(%p, %p, %08x)\n", hao, phadid, fdwDriverID);
360
361     if (fdwDriverID) {
362         WARN("invalid flag\n");
363         return MMSYSERR_INVALFLAG;
364     }
365
366     pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
367     if (!pao) {
368         WARN("invalid handle\n");
369         return MMSYSERR_INVALHANDLE;
370     }
371
372     if (!phadid) {
373         WARN("invalid parameter\n");
374         return MMSYSERR_INVALPARAM;
375     }
376
377     *phadid = (HACMDRIVERID) pao->pACMDriverID;
378
379     return MMSYSERR_NOERROR;
380 }
381
382 /***********************************************************************
383  *           acmDriverMessage (MSACM32.@)
384  *
385  * Note: MSDN documentation (July 2001) is incomplete. This function
386  * accepts sending messages to an HACMDRIVERID in addition to the
387  * documented HACMDRIVER. In fact, for DRV_QUERYCONFIGURE and DRV_CONFIGURE, 
388  * this might actually be the required mode of operation.
389  *
390  * Note: For DRV_CONFIGURE, msacm supplies its own DRVCONFIGINFO structure
391  * when the application fails to supply one. Some native drivers depend on
392  * this and refuse to display unless a valid DRVCONFIGINFO structure is
393  * built and supplied.
394  */
395 LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
396 {
397     TRACE("(%p, %04x, %08lx, %08lx\n", had, uMsg, lParam1, lParam2);
398
399     if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
400         uMsg == ACMDM_DRIVER_ABOUT ||
401         uMsg == DRV_QUERYCONFIGURE ||
402         uMsg == DRV_CONFIGURE)
403     {
404         PWINE_ACMDRIVERID padid;
405         LRESULT lResult;
406         LPDRVCONFIGINFO pConfigInfo = NULL;
407         LPWSTR section_name = NULL;
408         LPWSTR alias_name = NULL;
409
410         /* Check whether handle is an HACMDRIVERID */
411         padid  = MSACM_GetDriverID((HACMDRIVERID)had);
412         
413         /* If the message is DRV_CONFIGURE, and the application provides no
414            DRVCONFIGINFO structure, msacm must supply its own.
415          */
416         if (uMsg == DRV_CONFIGURE && lParam2 == 0) {
417             LPWSTR pAlias;
418             
419             /* Get the alias from the HACMDRIVERID */
420             if (padid) {
421                 pAlias = padid->pszDriverAlias;
422                 if (pAlias == NULL) {
423                     WARN("DRV_CONFIGURE: no alias for this driver, cannot self-supply alias\n");
424                 }
425             } else {
426                 FIXME("DRV_CONFIGURE: reverse lookup HACMDRIVER -> HACMDRIVERID not implemented\n");
427                 pAlias = NULL;
428             }
429         
430             if (pAlias != NULL) {
431                 /* DRVCONFIGINFO is only 12 bytes long, but native msacm
432                  * reports a 16-byte structure to codecs, so allocate 16 bytes,
433                  * just to be on the safe side.
434                  */
435                 const unsigned int iStructSize = 16;
436                 pConfigInfo = HeapAlloc(MSACM_hHeap, 0, iStructSize);
437                 if (!pConfigInfo) {
438                     ERR("OOM while supplying DRVCONFIGINFO for DRV_CONFIGURE, using NULL\n");
439                 } else {
440                     static const WCHAR drivers32[] = {'D','r','i','v','e','r','s','3','2','\0'};
441
442                     pConfigInfo->dwDCISize = iStructSize;
443
444                     section_name = HeapAlloc(MSACM_hHeap, 0, (strlenW(drivers32) + 1) * sizeof(WCHAR));
445                     if (section_name) strcpyW(section_name, drivers32);
446                     pConfigInfo->lpszDCISectionName = section_name;
447                     alias_name = HeapAlloc(MSACM_hHeap, 0, (strlenW(pAlias) + 1) * sizeof(WCHAR));
448                     if (alias_name) strcpyW(alias_name, pAlias);
449                     pConfigInfo->lpszDCIAliasName = alias_name;
450
451                     if (pConfigInfo->lpszDCISectionName == NULL || pConfigInfo->lpszDCIAliasName == NULL) {
452                         HeapFree(MSACM_hHeap, 0, alias_name);
453                         HeapFree(MSACM_hHeap, 0, section_name);
454                         HeapFree(MSACM_hHeap, 0, pConfigInfo);
455                         pConfigInfo = NULL;
456                         ERR("OOM while supplying DRVCONFIGINFO for DRV_CONFIGURE, using NULL\n");
457                     }
458                 }
459             }
460             
461             lParam2 = (LPARAM)pConfigInfo;
462         }
463         
464         if (padid) {
465             /* Handle is really an HACMDRIVERID, must have an open session to get an HACMDRIVER */
466             if (padid->pACMDriverList != NULL) {
467                 lResult = MSACM_Message((HACMDRIVER)padid->pACMDriverList, uMsg, lParam1, lParam2);
468             } else {
469                 MMRESULT mmr = acmDriverOpen(&had, (HACMDRIVERID)padid, 0);
470                 if (mmr != MMSYSERR_NOERROR) {
471                     lResult = MMSYSERR_INVALPARAM;
472                 } else {
473                     lResult = acmDriverMessage(had, uMsg, lParam1, lParam2);
474                     acmDriverClose(had, 0);
475                 }
476             }
477         } else {
478             lResult = MSACM_Message(had, uMsg, lParam1, lParam2);
479         }
480         if (pConfigInfo) {
481             HeapFree(MSACM_hHeap, 0, alias_name);
482             HeapFree(MSACM_hHeap, 0, section_name);
483             HeapFree(MSACM_hHeap, 0, pConfigInfo);
484         }
485         return lResult;
486     }
487     WARN("invalid parameter\n");
488     return MMSYSERR_INVALPARAM;
489 }
490
491 /***********************************************************************
492  *           acmDriverOpen (MSACM32.@)
493  */
494 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
495 {
496     PWINE_ACMDRIVERID   padid;
497     PWINE_ACMDRIVER     pad = NULL;
498     MMRESULT            ret;
499
500     TRACE("(%p, %p, %08u)\n", phad, hadid, fdwOpen);
501
502     if (!phad) {
503         WARN("invalid parameter\n");
504         return MMSYSERR_INVALPARAM;
505     }
506
507     if (fdwOpen) {
508         WARN("invalid flag\n");
509         return MMSYSERR_INVALFLAG;
510     }
511
512     padid = MSACM_GetDriverID(hadid);
513     if (!padid) {
514         WARN("invalid handle\n");
515         return MMSYSERR_INVALHANDLE;
516     }
517
518     pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
519     if (!pad) {
520         WARN("no memory\n");
521         return MMSYSERR_NOMEM;
522     }
523
524     pad->obj.dwType = WINE_ACMOBJ_DRIVER;
525     pad->obj.pACMDriverID = padid;
526     pad->hDrvr = 0;
527     pad->pLocalDrvrInst = NULL;
528
529     if (padid->pLocalDriver == NULL)
530     {
531         ACMDRVOPENDESCW adod;
532         int             len;
533         LPWSTR          section_name;
534
535         /* this is not an externally added driver... need to actually load it */
536         if (!padid->pszDriverAlias)
537         {
538             ret = MMSYSERR_ERROR;
539             goto gotError;
540         }
541
542         adod.cbStruct = sizeof(adod);
543         adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
544         adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
545         adod.dwVersion = acmGetVersion();
546         adod.dwFlags = fdwOpen;
547         adod.dwError = 0;
548         len = strlen("Drivers32") + 1;
549         section_name = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
550         MultiByteToWideChar(CP_ACP, 0, "Drivers32", -1, section_name, len);
551         adod.pszSectionName = section_name;
552         adod.pszAliasName = padid->pszDriverAlias;
553         adod.dnDevNode = 0;
554
555         pad->hDrvr = OpenDriver(padid->pszDriverAlias, NULL, (DWORD_PTR)&adod);
556
557         HeapFree(MSACM_hHeap, 0, section_name);
558         if (!pad->hDrvr)
559         {
560             ret = adod.dwError;
561             if (ret == MMSYSERR_NOERROR)
562                 ret = MMSYSERR_NODRIVER;
563             goto gotError;
564         }
565     }
566     else
567     {
568         ACMDRVOPENDESCW adod;
569
570         pad->hDrvr = NULL;
571
572         adod.cbStruct = sizeof(adod);
573         adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
574         adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
575         adod.dwVersion = acmGetVersion();
576         adod.dwFlags = fdwOpen;
577         adod.dwError = 0;
578         adod.pszSectionName = NULL;
579         adod.pszAliasName = NULL;
580         adod.dnDevNode = 0;
581
582         pad->pLocalDrvrInst = MSACM_OpenLocalDriver(padid->pLocalDriver, (DWORD_PTR)&adod);
583         if (!pad->pLocalDrvrInst)
584         {
585             ret = adod.dwError;
586             if (ret == MMSYSERR_NOERROR)
587                 ret = MMSYSERR_NODRIVER;
588             goto gotError;
589         }
590     }
591
592     /* insert new pad at beg of list */
593     pad->pNextACMDriver = padid->pACMDriverList;
594     padid->pACMDriverList = pad;
595
596     /* FIXME: Create a WINE_ACMDRIVER32 */
597     *phad = (HACMDRIVER)pad;
598     TRACE("%s => %p\n", debugstr_w(padid->pszDriverAlias), pad);
599
600     return MMSYSERR_NOERROR;
601  gotError:
602     WARN("failed: ret = %08x\n", ret);
603     if (pad && !pad->hDrvr)
604         HeapFree(MSACM_hHeap, 0, pad);
605     return ret;
606 }
607
608 /***********************************************************************
609  *           acmDriverPriority (MSACM32.@)
610  */
611 MMRESULT WINAPI acmDriverPriority(HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
612 {
613
614     TRACE("(%p, %08x, %08x)\n", hadid, dwPriority, fdwPriority);
615
616     /* Check for unknown flags */
617     if (fdwPriority &
618         ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
619           ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
620         WARN("invalid flag\n");
621         return MMSYSERR_INVALFLAG;
622     }
623
624     /* Check for incompatible flags */
625     if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
626         (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE)) {
627         WARN("invalid flag\n");
628         return MMSYSERR_INVALFLAG;
629     }
630
631     /* Check for incompatible flags */
632     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
633         (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
634         WARN("invalid flag\n");
635         return MMSYSERR_INVALFLAG;
636     }
637     
638     /* According to MSDN, ACM_DRIVERPRIORITYF_BEGIN and ACM_DRIVERPRIORITYF_END 
639        may only appear by themselves, and in addition, hadid and dwPriority must
640        both be zero */
641     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) ||
642         (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
643         if (fdwPriority & ~(ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
644             WARN("ACM_DRIVERPRIORITYF_[BEGIN|END] cannot be used with any other flags\n");
645             return MMSYSERR_INVALPARAM;
646         }
647         if (dwPriority) {
648             WARN("priority invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
649             return MMSYSERR_INVALPARAM;
650         }
651         if (hadid) {
652             WARN("non-null hadid invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
653             return MMSYSERR_INVALPARAM;
654         }
655         /* FIXME: MSDN wording suggests that deferred notification should be 
656            implemented as a system-wide lock held by a calling task, and that 
657            re-enabling notifications should broadcast them across all processes.
658            This implementation uses a simple DWORD counter. One consequence of the
659            current implementation is that applications will never see 
660            MMSYSERR_ALLOCATED as a return error.
661          */
662         if (fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) {
663             MSACM_DisableNotifications();
664         } else if (fdwPriority & ACM_DRIVERPRIORITYF_END) {
665             MSACM_EnableNotifications();
666         }
667         return MMSYSERR_NOERROR;
668     } else {
669         PWINE_ACMDRIVERID padid;
670         PWINE_ACMNOTIFYWND panwnd;
671         BOOL bPerformBroadcast = FALSE;
672
673         /* Fetch driver ID */
674         padid = MSACM_GetDriverID(hadid);
675         panwnd = MSACM_GetNotifyWnd(hadid);
676         if (!padid && !panwnd) {
677             WARN("invalid handle\n");
678             return MMSYSERR_INVALHANDLE;
679         }
680         
681         if (padid) {
682             /* Check whether driver ID is appropriate for requested op */
683             if (dwPriority) {
684                 if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) {
685                     return MMSYSERR_NOTSUPPORTED;
686                 }
687                 if (dwPriority != 1 && dwPriority != (DWORD)-1) {
688                     FIXME("unexpected priority %d, using sign only\n", dwPriority);
689                     if ((signed)dwPriority < 0) dwPriority = (DWORD)-1;
690                     if (dwPriority > 0) dwPriority = 1;
691                 }
692                 
693                 if (dwPriority == 1 && (padid->pPrevACMDriverID == NULL || 
694                     (padid->pPrevACMDriverID->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL))) {
695                     /* do nothing - driver is first of list, or first after last
696                        local driver */
697                 } else if (dwPriority == (DWORD)-1 && padid->pNextACMDriverID == NULL) {
698                     /* do nothing - driver is last of list */
699                 } else {
700                     MSACM_RePositionDriver(padid, dwPriority);
701                     bPerformBroadcast = TRUE;
702                 }
703             }
704
705             /* Check whether driver ID should be enabled or disabled */
706             if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
707                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
708                     padid->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
709                     bPerformBroadcast = TRUE;
710                 }
711             } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
712                 if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
713                     padid->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
714                     bPerformBroadcast = TRUE;
715                 }
716             }
717         }
718         
719         if (panwnd) {
720             if (dwPriority) {
721                 return MMSYSERR_NOTSUPPORTED;
722             }
723         
724             /* Check whether notify window should be enabled or disabled */
725             if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
726                 if (!(panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
727                     panwnd->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
728                     bPerformBroadcast = TRUE;
729                 }
730             } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
731                 if (panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
732                     panwnd->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
733                     bPerformBroadcast = TRUE;
734                 }
735             }
736         }
737         
738         /* Perform broadcast of changes */
739         if (bPerformBroadcast) {
740             MSACM_WriteCurrentPriorities();
741             MSACM_BroadcastNotification();
742         }
743         return MMSYSERR_NOERROR;
744     }
745 }
746
747 /***********************************************************************
748  *           acmDriverRemove (MSACM32.@)
749  */
750 MMRESULT WINAPI acmDriverRemove(HACMDRIVERID hadid, DWORD fdwRemove)
751 {
752     PWINE_ACMDRIVERID padid;
753     PWINE_ACMNOTIFYWND panwnd;
754
755     TRACE("(%p, %08x)\n", hadid, fdwRemove);
756
757     padid = MSACM_GetDriverID(hadid);
758     panwnd = MSACM_GetNotifyWnd(hadid);
759     if (!padid && !panwnd) {
760         WARN("invalid handle\n");
761         return MMSYSERR_INVALHANDLE;
762     }
763
764     if (fdwRemove) {
765         WARN("invalid flag\n");
766         return MMSYSERR_INVALFLAG;
767     }
768
769     if (padid) MSACM_UnregisterDriver(padid);
770     if (panwnd) MSACM_UnRegisterNotificationWindow(panwnd);
771     MSACM_BroadcastNotification();
772
773     return MMSYSERR_NOERROR;
774 }