- added version messages
[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
10 #include "winbase.h"
11 #include "winerror.h"
12 #include "windef.h"
13 #include "winuser.h"
14 #include "debugtools.h"
15 #include "driver.h"
16 #include "heap.h"
17 #include "mmsystem.h"
18 #include "msacm.h"
19 #include "msacmdrv.h"
20 #include "wineacm.h"
21 #include "winreg.h"
22
23 DEFAULT_DEBUG_CHANNEL(msacm)
24         
25 /***********************************************************************
26  *           acmDriverAddA (MSACM32.2)
27  */
28 MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
29                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
30 {
31     if (!phadid)
32         return MMSYSERR_INVALPARAM;
33     
34     /* Check if any unknown flags */
35     if (fdwAdd & 
36         ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
37           ACM_DRIVERADDF_GLOBAL))
38         return MMSYSERR_INVALFLAG;
39     
40     /* Check if any incompatible flags */
41     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) && 
42         (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
43         return MMSYSERR_INVALFLAG;
44     
45     /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a 
46      * LoadDriver on it, to be sure we can call SendDriverMessage on the
47      * hDrvr handle.
48      */
49     *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, hinstModule);
50     
51     /* FIXME: lParam, dwPriority and fdwAdd ignored */
52     
53     return MMSYSERR_NOERROR;
54 }
55
56 /***********************************************************************
57  *           acmDriverAddW (MSACM32.3)
58  * FIXME
59  *   Not implemented
60  */
61 MMRESULT WINAPI acmDriverAddW(PHACMDRIVERID phadid, HINSTANCE hinstModule,
62                               LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
63 {
64     FIXME("(%p, 0x%08x, %ld, %ld, %ld): stub\n",
65           phadid, hinstModule, lParam, dwPriority, fdwAdd);
66     
67     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
68     return MMSYSERR_ERROR;
69 }
70
71 /***********************************************************************
72  *           acmDriverClose (MSACM32.4)
73  */
74 MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
75 {
76     PWINE_ACMDRIVER p;
77     
78     if (fdwClose)
79         return MMSYSERR_INVALFLAG;
80     
81     p = MSACM_GetDriver(had);
82     if (!p)
83         return MMSYSERR_INVALHANDLE;
84     
85     p->obj.pACMDriverID->pACMDriver = NULL;
86     
87     if (p->hDrvr)
88         CloseDriver(p->hDrvr, 0, 0);
89     
90     HeapFree(MSACM_hHeap, 0, p);
91     
92     return MMSYSERR_NOERROR;
93 }
94
95 /***********************************************************************
96  *           acmDriverDetailsA (MSACM32.5)
97  */
98 MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
99 {
100     MMRESULT mmr;
101     ACMDRIVERDETAILSW   addw;
102     
103     addw.cbStruct = sizeof(addw);
104     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
105     if (mmr == 0) {
106         padd->fccType = addw.fccType; 
107         padd->fccComp = addw.fccComp; 
108         padd->wMid = addw.wMid; 
109         padd->wPid = addw.wPid; 
110         padd->vdwACM = addw.vdwACM; 
111         padd->vdwDriver = addw.vdwDriver; 
112         padd->fdwSupport = addw.fdwSupport; 
113         padd->cFormatTags = addw.cFormatTags; 
114         padd->cFilterTags = addw.cFilterTags; 
115         padd->hicon = addw.hicon; 
116         lstrcpyWtoA(padd->szShortName, addw.szShortName);
117         lstrcpyWtoA(padd->szLongName, addw.szLongName);
118         lstrcpyWtoA(padd->szCopyright, addw.szCopyright);
119         lstrcpyWtoA(padd->szLicensing, addw.szLicensing);
120         lstrcpyWtoA(padd->szFeatures, addw.szFeatures);
121     }
122     return mmr;
123 }
124
125 /***********************************************************************
126  *           acmDriverDetailsW (MSACM32.6)
127  */
128 MMRESULT WINAPI acmDriverDetailsW(HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
129 {
130     PWINE_ACMDRIVERID p;
131     MMRESULT mmr;
132     BOOL bOpenTemporary;
133     
134     p = MSACM_GetDriverID(hadid);
135     if (!p)
136         return MMSYSERR_INVALHANDLE;
137     
138     if (fdwDetails)
139         return MMSYSERR_INVALFLAG;
140     
141     bOpenTemporary = !p->pACMDriver;
142     if (bOpenTemporary) {
143         bOpenTemporary = TRUE;
144         acmDriverOpen((PHACMDRIVER) &p->pACMDriver, hadid, 0);
145     }
146     
147     mmr = (MMRESULT) acmDriverMessage((HACMDRIVER) p->pACMDriver, ACMDM_DRIVER_DETAILS, 
148                                       (LPARAM) padd,  0);
149     
150     if (bOpenTemporary) {
151         acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
152         p->pACMDriver = NULL;
153     }
154     
155     return mmr;
156 }
157
158 /***********************************************************************
159  *           acmDriverEnum (MSACM32.7)
160  */
161 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
162 {
163     PWINE_ACMDRIVERID p;
164     
165     if (!fnCallback) {
166         return MMSYSERR_INVALPARAM;
167     }
168     
169     if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
170         return MMSYSERR_INVALFLAG;
171     }
172     
173     p = MSACM_pFirstACMDriverID;
174     while (p) {
175         (*fnCallback)((HACMDRIVERID) p, dwInstance, ACMDRIVERDETAILS_SUPPORTF_CODEC);
176         p = p->pNextACMDriverID;
177     }
178     
179     return MMSYSERR_NOERROR;
180 }
181
182 /***********************************************************************
183  *           acmDriverID (MSACM32.8)
184  */
185 MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
186 {
187     PWINE_ACMOBJ pao;
188     
189     pao = MSACM_GetObj(hao);
190     if (!pao)
191         return MMSYSERR_INVALHANDLE;
192     
193     if (!phadid)
194         return MMSYSERR_INVALPARAM;
195     
196     if (fdwDriverID)
197         return MMSYSERR_INVALFLAG;
198     
199     *phadid = (HACMDRIVERID) pao->pACMDriverID;
200     
201     return MMSYSERR_NOERROR;
202 }
203
204 /***********************************************************************
205  *           acmDriverMessage (MSACM32.9)
206  * FIXME
207  *   Not implemented
208  */
209 LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
210 {
211     PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
212     if (!pad)
213         return MMSYSERR_INVALPARAM;
214     
215     /* FIXME: Check if uMsg legal */
216     
217     if (!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
218         return MMSYSERR_NOTSUPPORTED;
219     
220     return MMSYSERR_NOERROR;
221 }
222
223
224 /***********************************************************************
225  *           acmDriverOpen (MSACM32.10)
226  */
227 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
228 {
229     PWINE_ACMDRIVERID padid;
230
231     TRACE("(%p, %x, %08lu\n", phad, hadid, fdwOpen);
232
233     if (!phad)
234         return MMSYSERR_INVALPARAM;
235     
236     padid = MSACM_GetDriverID(hadid); 
237     if (!padid)
238         return MMSYSERR_INVALHANDLE;
239     
240     if (fdwOpen)
241         return MMSYSERR_INVALFLAG;
242     
243     if (padid->pACMDriver) {
244         /* FIXME: Is it allowed? */
245         ERR("Can't open driver twice\n");
246         return MMSYSERR_ERROR;
247     }
248     
249     padid->pACMDriver = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
250     padid->pACMDriver->obj.pACMDriverID = padid;
251     
252     if (!padid->hInstModule)
253         padid->pACMDriver->hDrvr = OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
254     else
255         padid->pACMDriver->hDrvr = padid->hInstModule;
256     
257     if (!padid->pACMDriver->hDrvr) {
258         HeapFree(MSACM_hHeap, 0, padid->pACMDriver);
259         padid->pACMDriver = NULL;
260         return MMSYSERR_ERROR;
261     }
262     
263     padid->pACMDriver->pfnDriverProc = GetProcAddress(padid->pACMDriver->hDrvr, "DriverProc");
264     
265     /* FIXME: Create a WINE_ACMDRIVER32 */
266     *phad = (HACMDRIVER) padid->pACMDriver;
267     
268     return MMSYSERR_NOERROR;
269 }
270
271 /***********************************************************************
272  *           acmDriverPriority (MSACM32.11)
273  */
274 MMRESULT WINAPI acmDriverPriority(HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
275 {
276     PWINE_ACMDRIVERID padid;
277     CHAR szSubKey[17];
278     CHAR szBuffer[256];
279     LONG lBufferLength = sizeof(szBuffer);
280     LONG lError;
281     HKEY hPriorityKey;
282     DWORD dwPriorityCounter;
283     
284     padid = MSACM_GetDriverID(hadid);
285     if (!padid)
286         return MMSYSERR_INVALHANDLE;
287     
288     /* Check for unknown flags */
289     if (fdwPriority & 
290         ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
291           ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
292         return MMSYSERR_INVALFLAG;
293     
294     /* Check for incompatible flags */
295     if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
296         (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
297         return MMSYSERR_INVALFLAG;
298     
299     /* Check for incompatible flags */
300     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
301         (fdwPriority & ACM_DRIVERPRIORITYF_END))
302         return MMSYSERR_INVALFLAG;
303     
304     lError = RegOpenKeyA(HKEY_CURRENT_USER, 
305                          "Software\\Microsoft\\Multimedia\\"
306                          "Audio Compression Manager\\Priority v4.00",
307                          &hPriorityKey
308                          );
309     /* FIXME: Create key */
310     if (lError != ERROR_SUCCESS)
311         return MMSYSERR_ERROR;
312     
313     for (dwPriorityCounter = 1; ; dwPriorityCounter++)  {
314         wsnprintfA(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
315         lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
316         if (lError != ERROR_SUCCESS)
317             break;
318         
319         FIXME("(0x%08x, %ld, %ld): stub (partial)\n", 
320               hadid, dwPriority, fdwPriority);
321         break;
322     }
323     
324     RegCloseKey(hPriorityKey);
325     
326     return MMSYSERR_ERROR;
327 }
328
329 /***********************************************************************
330  *           acmDriverRemove (MSACM32.12)
331  */
332 MMRESULT WINAPI acmDriverRemove(HACMDRIVERID hadid, DWORD fdwRemove)
333 {
334     PWINE_ACMDRIVERID padid;
335     
336     padid = MSACM_GetDriverID(hadid);
337     if (!padid)
338         return MMSYSERR_INVALHANDLE;
339     
340     if (fdwRemove)
341         return MMSYSERR_INVALFLAG;
342     
343     MSACM_UnregisterDriver(padid);
344     
345     return MMSYSERR_NOERROR;
346 }
347