source: trunk/src/msacm32/driver.c@ 7549

Last change on this file since 7549 was 6712, checked in by sandervl, 24 years ago

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