source: trunk/src/msacm32/driver.cpp@ 4145

Last change on this file since 4145 was 3925, checked in by bird, 25 years ago

Added the CVS keyword Id.
File size: 8.9 KB
Line 
1/* $Id: driver.cpp,v 1.3 2000-08-02 15:49:31 bird Exp $ */
2/*
3 * MSACM32 library
4 *
5 * Copyright 1998 Patrik Stridvall
6 * 1999 Eric Pouech
7 */
8
9#include <os2win.h>
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 "heapstring.h"
17#include "mmsystem.h"
18#include "msacm.h"
19#include "msacmdrv.h"
20#include "wineacm.h"
21#include "winreg.h"
22
23DEFAULT_DEBUG_CHANNEL(msacm)
24
25/***********************************************************************
26 * acmDriverAddA (MSACM32.2)
27 */
28MMRESULT 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 */
61MMRESULT WINAPI acmDriverAddW(PHACMDRIVERID phadid, HINSTANCE hinstModule,
62 LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
63{
64 dprintf(("(%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 */
74MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
75{
76 PWINE_ACMDRIVER p;
77 PWINE_ACMDRIVER* tp;
78
79 if (fdwClose)
80 return MMSYSERR_INVALFLAG;
81
82 p = MSACM_GetDriver(had);
83 if (!p)
84 return MMSYSERR_INVALHANDLE;
85
86 for (tp = &(p->obj.pACMDriverID->pACMDriverList); *tp; *tp = (*tp)->pNextACMDriver) {
87 if (*tp == p) {
88 *tp = (*tp)->pNextACMDriver;
89 break;
90 }
91 }
92
93 if (p->hDrvr && !p->obj.pACMDriverID->pACMDriverList)
94 CloseDriver(p->hDrvr, 0, 0);
95
96 HeapFree(MSACM_hHeap, 0, p);
97
98 return MMSYSERR_NOERROR;
99}
100
101/***********************************************************************
102 * acmDriverDetailsA (MSACM32.5)
103 */
104MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
105{
106 MMRESULT mmr;
107 ACMDRIVERDETAILSW addw;
108
109 addw.cbStruct = sizeof(addw);
110 mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
111 if (mmr == 0) {
112 padd->fccType = addw.fccType;
113 padd->fccComp = addw.fccComp;
114 padd->wMid = addw.wMid;
115 padd->wPid = addw.wPid;
116 padd->vdwACM = addw.vdwACM;
117 padd->vdwDriver = addw.vdwDriver;
118 padd->fdwSupport = addw.fdwSupport;
119 padd->cFormatTags = addw.cFormatTags;
120 padd->cFilterTags = addw.cFilterTags;
121 padd->hicon = addw.hicon;
122 lstrcpyWtoA(padd->szShortName, addw.szShortName);
123 lstrcpyWtoA(padd->szLongName, addw.szLongName);
124 lstrcpyWtoA(padd->szCopyright, addw.szCopyright);
125 lstrcpyWtoA(padd->szLicensing, addw.szLicensing);
126 lstrcpyWtoA(padd->szFeatures, addw.szFeatures);
127 }
128 return mmr;
129}
130
131/***********************************************************************
132 * acmDriverDetailsW (MSACM32.6)
133 */
134MMRESULT WINAPI acmDriverDetailsW(HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
135{
136 HACMDRIVER acmDrvr;
137 MMRESULT mmr;
138
139 if (fdwDetails)
140 return MMSYSERR_INVALFLAG;
141
142 mmr = acmDriverOpen(&acmDrvr, hadid, 0);
143 if (mmr == 0) {
144 mmr = (MMRESULT)acmDriverMessage(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM) padd, 0);
145
146 acmDriverClose(acmDrvr, 0);
147 }
148
149 return mmr;
150}
151
152/***********************************************************************
153 * acmDriverEnum (MSACM32.7)
154 */
155MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
156{
157 PWINE_ACMDRIVERID p;
158 DWORD fdwSupport;
159
160 if (!fnCallback) {
161 return MMSYSERR_INVALPARAM;
162 }
163
164 if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
165 return MMSYSERR_INVALFLAG;
166 }
167
168 for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
169 fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
170 if (!p->bEnabled) {
171 if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
172 fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
173 else
174 continue;
175 }
176 (*fnCallback)((HACMDRIVERID) p, dwInstance, fdwSupport);
177 }
178
179 return MMSYSERR_NOERROR;
180}
181
182/***********************************************************************
183 * acmDriverID (MSACM32.8)
184 */
185MMRESULT 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 */
209LRESULT 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 */
227MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
228{
229 PWINE_ACMDRIVERID padid;
230 PWINE_ACMDRIVER pad;
231
232 dprintf(("(%p, %x, %08lu)\n", phad, hadid, fdwOpen));
233
234 if (!phad)
235 return MMSYSERR_INVALPARAM;
236
237 padid = MSACM_GetDriverID(hadid);
238 if (!padid)
239 return MMSYSERR_INVALHANDLE;
240
241 if (fdwOpen)
242 return MMSYSERR_INVALFLAG;
243
244 pad = PWINE_ACMDRIVER(HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER)));
245 if (!pad) return MMSYSERR_NOMEM;
246
247 pad->obj.pACMDriverID = padid;
248
249 if (!padid->hInstModule)
250 pad->hDrvr = OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
251 else
252 pad->hDrvr = padid->hInstModule;
253
254 if (!pad->hDrvr) {
255 HeapFree(MSACM_hHeap, 0, pad);
256 return MMSYSERR_ERROR;
257 }
258
259// pad->pfnDriverProc = GetProcAddress(pad->hDrvr, "DriverProc");
260
261 /* insert new pad at beg of list */
262 pad->pNextACMDriver = padid->pACMDriverList;
263 padid->pACMDriverList = pad;
264
265 /* FIXME: Create a WINE_ACMDRIVER32 */
266 *phad = (HACMDRIVER)pad;
267
268// return MMSYSERR_NOERROR;
269 return MMSYSERR_ERROR;
270}
271
272/***********************************************************************
273 * acmDriverPriority (MSACM32.11)
274 */
275MMRESULT WINAPI acmDriverPriority(HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
276{
277 PWINE_ACMDRIVERID padid;
278 CHAR szSubKey[17];
279 CHAR szBuffer[256];
280 LONG lBufferLength = sizeof(szBuffer);
281 LONG lError;
282 HKEY hPriorityKey;
283 DWORD dwPriorityCounter;
284
285 padid = MSACM_GetDriverID(hadid);
286 if (!padid)
287 return MMSYSERR_INVALHANDLE;
288
289 /* Check for unknown flags */
290 if (fdwPriority &
291 ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
292 ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
293 return MMSYSERR_INVALFLAG;
294
295 /* Check for incompatible flags */
296 if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
297 (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
298 return MMSYSERR_INVALFLAG;
299
300 /* Check for incompatible flags */
301 if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
302 (fdwPriority & ACM_DRIVERPRIORITYF_END))
303 return MMSYSERR_INVALFLAG;
304
305 lError = RegOpenKeyA(HKEY_CURRENT_USER,
306 "Software\\Microsoft\\Multimedia\\"
307 "Audio Compression Manager\\Priority v4.00",
308 &hPriorityKey
309 );
310 /* FIXME: Create key */
311 if (lError != ERROR_SUCCESS)
312 return MMSYSERR_ERROR;
313
314 for (dwPriorityCounter = 1; ; dwPriorityCounter++) {
315 wsnprintfA(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
316 lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
317 if (lError != ERROR_SUCCESS)
318 break;
319
320 dprintf(("(0x%08x, %ld, %ld): stub (partial)\n",
321 hadid, dwPriority, fdwPriority));
322 break;
323 }
324
325 RegCloseKey(hPriorityKey);
326
327 return MMSYSERR_ERROR;
328}
329
330/***********************************************************************
331 * acmDriverRemove (MSACM32.12)
332 */
333MMRESULT WINAPI acmDriverRemove(HACMDRIVERID hadid, DWORD fdwRemove)
334{
335 PWINE_ACMDRIVERID padid;
336
337 padid = MSACM_GetDriverID(hadid);
338 if (!padid)
339 return MMSYSERR_INVALHANDLE;
340
341 if (fdwRemove)
342 return MMSYSERR_INVALFLAG;
343
344 MSACM_UnregisterDriver(padid);
345
346 return MMSYSERR_NOERROR;
347}
348
Note: See TracBrowser for help on using the repository browser.