ReactOS 0.4.15-dev-7681-g776c3a3
internal.c
Go to the documentation of this file.
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 <stdarg.h>
25#include <string.h>
26#ifdef __REACTOS__
27#include <wchar.h>
28#endif
29
30#include "windef.h"
31#include "winbase.h"
32#include "wingdi.h"
33#include "winuser.h"
34#include "winerror.h"
35#include "winreg.h"
36#include "mmsystem.h"
37#include "mmreg.h"
38#include "msacm.h"
39#include "msacmdrv.h"
40#include "wineacm.h"
41#include "wine/debug.h"
42
44
45/**********************************************************************/
46
50
55
56static void MSACM_ReorderDriversByPriority(void);
57
58/***********************************************************************
59 * MSACM_RegisterDriverFromRegistry()
60 */
62{
63 static const WCHAR msacmW[] = {'M','S','A','C','M','.'};
64 static const WCHAR drvkey[] = {'S','o','f','t','w','a','r','e','\\',
65 'M','i','c','r','o','s','o','f','t','\\',
66 'W','i','n','d','o','w','s',' ','N','T','\\',
67 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
68 'D','r','i','v','e','r','s','3','2','\0'};
69 WCHAR buf[2048];
70 DWORD bufLen, lRet;
71 HKEY hKey;
72 PWINE_ACMDRIVERID padid = NULL;
73
74 /* The requested registry entry must have the format msacm.XXXXX in order to
75 be recognized in any future sessions of msacm
76 */
77 if (0 == _wcsnicmp(pszRegEntry, msacmW, ARRAY_SIZE(msacmW))) {
79 if (lRet != ERROR_SUCCESS) {
80 WARN("unable to open registry key - 0x%08x\n", lRet);
81 } else {
82 bufLen = sizeof(buf);
83 lRet = RegQueryValueExW(hKey, pszRegEntry, NULL, NULL, (LPBYTE)buf, &bufLen);
84 if (lRet != ERROR_SUCCESS) {
85 WARN("unable to query requested subkey %s - 0x%08x\n", debugstr_w(pszRegEntry), lRet);
86 } else {
87 MSACM_RegisterDriver(pszRegEntry, buf, 0);
88 }
90 }
91 }
92 return padid;
93}
94
95#if 0
96/***********************************************************************
97 * MSACM_DumpCache
98 */
99static void MSACM_DumpCache(PWINE_ACMDRIVERID padid)
100{
101 unsigned i;
102
103 TRACE("cFilterTags=%lu cFormatTags=%lu fdwSupport=%08lx\n",
104 padid->cFilterTags, padid->cFormatTags, padid->fdwSupport);
105 for (i = 0; i < padid->cache->cFormatTags; i++) {
106 TRACE("\tdwFormatTag=%lu cbwfx=%lu\n",
107 padid->aFormatTag[i].dwFormatTag, padid->aFormatTag[i].cbwfx);
108 }
109}
110#endif
111
112/***********************************************************************
113 * MSACM_FindFormatTagInCache [internal]
114 *
115 * Returns TRUE is the format tag fmtTag is present in the cache.
116 * If so, idx is set to its index.
117 */
119{
120 unsigned i;
121
122 for (i = 0; i < padid->cFormatTags; i++) {
123 if (padid->aFormatTag[i].dwFormatTag == fmtTag) {
124 if (idx) *idx = i;
125 return TRUE;
126 }
127 }
128 return FALSE;
129}
130
131/***********************************************************************
132 * MSACM_FillCache
133 */
135{
136 HACMDRIVER had = 0;
137 unsigned int ntag;
140
141 if (acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != 0)
142 return FALSE;
143
144 padid->aFormatTag = NULL;
145 add.cbStruct = sizeof(add);
146 if (MSACM_Message(had, ACMDM_DRIVER_DETAILS, (LPARAM)&add, 0))
147 goto errCleanUp;
148
149 if (add.cFormatTags > 0) {
151 add.cFormatTags * sizeof(padid->aFormatTag[0]));
152 if (!padid->aFormatTag) goto errCleanUp;
153 }
154
155 padid->cFormatTags = add.cFormatTags;
156 padid->cFilterTags = add.cFilterTags;
157 padid->fdwSupport = add.fdwSupport;
158
159 aftd.cbStruct = sizeof(aftd);
160
161 for (ntag = 0; ntag < add.cFormatTags; ntag++) {
162 aftd.dwFormatTagIndex = ntag;
164 TRACE("IIOs (%s)\n", debugstr_w(padid->pszDriverAlias));
165 goto errCleanUp;
166 }
167 padid->aFormatTag[ntag].dwFormatTag = aftd.dwFormatTag;
168 padid->aFormatTag[ntag].cbwfx = aftd.cbFormatSize;
169 }
170
171 acmDriverClose(had, 0);
172
173 return TRUE;
174
175errCleanUp:
176 if (had) acmDriverClose(had, 0);
177 HeapFree(MSACM_hHeap, 0, padid->aFormatTag);
178 padid->aFormatTag = NULL;
179 return FALSE;
180}
181
182/***********************************************************************
183 * MSACM_GetRegistryKey
184 */
186{
187 static const WCHAR baseKey[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
188 'A','u','d','i','o','C','o','m','p','r','e','s','s','i','o','n','M','a','n','a','g','e','r','\\',
189 'D','r','i','v','e','r','C','a','c','h','e','\\','\0'};
190 LPWSTR ret;
191 int len;
192
193 if (!padid->pszDriverAlias) {
194 ERR("No alias needed for registry entry\n");
195 return NULL;
196 }
197 len = lstrlenW(baseKey);
198 ret = HeapAlloc(MSACM_hHeap, 0, (len + lstrlenW(padid->pszDriverAlias) + 1) * sizeof(WCHAR));
199 if (!ret) return NULL;
200
201 lstrcpyW(ret, baseKey);
202 lstrcpyW(ret + len, padid->pszDriverAlias);
203 CharLowerW(ret + len);
204 return ret;
205}
206
207/***********************************************************************
208 * MSACM_ReadCache
209 */
211{
213 HKEY hKey;
214 DWORD type, size;
215
216 if (!key) return FALSE;
217
218 padid->aFormatTag = NULL;
219
221 goto errCleanUp;
222
223 size = sizeof(padid->cFormatTags);
224 if (RegQueryValueExA(hKey, "cFormatTags", 0, &type, (void*)&padid->cFormatTags, &size))
225 goto errCleanUp;
226 size = sizeof(padid->cFilterTags);
227 if (RegQueryValueExA(hKey, "cFilterTags", 0, &type, (void*)&padid->cFilterTags, &size))
228 goto errCleanUp;
229 size = sizeof(padid->fdwSupport);
230 if (RegQueryValueExA(hKey, "fdwSupport", 0, &type, (void*)&padid->fdwSupport, &size))
231 goto errCleanUp;
232
233 if (padid->cFormatTags > 0) {
234 size = padid->cFormatTags * sizeof(padid->aFormatTag[0]);
236 if (!padid->aFormatTag) goto errCleanUp;
237 if (RegQueryValueExA(hKey, "aFormatTagCache", 0, &type, (void*)padid->aFormatTag, &size))
238 goto errCleanUp;
239 }
241 return TRUE;
242
243 errCleanUp:
245 HeapFree(MSACM_hHeap, 0, padid->aFormatTag);
246 padid->aFormatTag = NULL;
248 return FALSE;
249}
250
251/***********************************************************************
252 * MSACM_WriteCache
253 */
255{
257 HKEY hKey;
258
259 if (!key) return FALSE;
260
262 goto errCleanUp;
263
264 if (RegSetValueExA(hKey, "cFormatTags", 0, REG_DWORD, (const void*)&padid->cFormatTags, sizeof(DWORD)))
265 goto errCleanUp;
266 if (RegSetValueExA(hKey, "cFilterTags", 0, REG_DWORD, (const void*)&padid->cFilterTags, sizeof(DWORD)))
267 goto errCleanUp;
268 if (RegSetValueExA(hKey, "fdwSupport", 0, REG_DWORD, (const void*)&padid->fdwSupport, sizeof(DWORD)))
269 goto errCleanUp;
270 if (RegSetValueExA(hKey, "aFormatTagCache", 0, REG_BINARY,
271 (void*)padid->aFormatTag,
272 padid->cFormatTags * sizeof(padid->aFormatTag[0])))
273 goto errCleanUp;
275 return TRUE;
276
277 errCleanUp:
279 return FALSE;
280}
281
282/***********************************************************************
283 * MSACM_RegisterDriver()
284 */
286 PWINE_ACMLOCALDRIVER pLocalDriver)
287{
288 PWINE_ACMDRIVERID padid;
289
290 TRACE("(%s, %s, %p)\n",
291 debugstr_w(pszDriverAlias), debugstr_w(pszFileName), pLocalDriver);
292
293 padid = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID));
294 if (!padid)
295 return NULL;
297 padid->obj.pACMDriverID = padid;
298 padid->pszDriverAlias = NULL;
299 if (pszDriverAlias)
300 {
301 padid->pszDriverAlias = HeapAlloc( MSACM_hHeap, 0, (lstrlenW(pszDriverAlias)+1) * sizeof(WCHAR) );
302 if (!padid->pszDriverAlias) {
303 HeapFree(MSACM_hHeap, 0, padid);
304 return NULL;
305 }
306 lstrcpyW( padid->pszDriverAlias, pszDriverAlias );
307 }
308 padid->pszFileName = NULL;
309 if (pszFileName)
310 {
311 padid->pszFileName = HeapAlloc( MSACM_hHeap, 0, (lstrlenW(pszFileName)+1) * sizeof(WCHAR) );
312 if (!padid->pszFileName) {
314 HeapFree(MSACM_hHeap, 0, padid);
315 return NULL;
316 }
318 }
319 padid->pLocalDriver = pLocalDriver;
320
321 padid->pACMDriverList = NULL;
322
323 if (pLocalDriver) {
324 padid->pPrevACMDriverID = NULL;
331 } else {
332 padid->pNextACMDriverID = NULL;
339 }
340 /* disable the driver if we cannot load the cache */
341 if ((!padid->pszDriverAlias || !MSACM_ReadCache(padid)) && !MSACM_FillCache(padid)) {
342 WARN("Couldn't load cache for ACM driver (%s)\n", debugstr_w(pszFileName));
344 return NULL;
345 }
346
347 if (pLocalDriver) padid->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_LOCAL;
348 return padid;
349}
350
351/***********************************************************************
352 * MSACM_RegisterAllDrivers()
353 */
355{
356 static const WCHAR msacm32[] = {'m','s','a','c','m','3','2','.','d','l','l','\0'};
357 static const WCHAR msacmW[] = {'M','S','A','C','M','.'};
358 static const WCHAR drv32[] = {'d','r','i','v','e','r','s','3','2','\0'};
359 static const WCHAR sys[] = {'s','y','s','t','e','m','.','i','n','i','\0'};
360 static const WCHAR drvkey[] = {'S','o','f','t','w','a','r','e','\\',
361 'M','i','c','r','o','s','o','f','t','\\',
362 'W','i','n','d','o','w','s',' ','N','T','\\',
363 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
364 'D','r','i','v','e','r','s','3','2','\0'};
365 DWORD i, cnt, bufLen, lRet, type;
366 WCHAR buf[2048], valname[64], *name, *s;
367 FILETIME lastWrite;
368 HKEY hKey;
369
370 /* FIXME: What if the user edits system.ini while the program is running?
371 * Does Windows handle that? */
372 if (MSACM_pFirstACMDriverID) return;
373
375 if (lRet == ERROR_SUCCESS) {
376 RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
377 for (i = 0; i < cnt; i++) {
378 bufLen = ARRAY_SIZE(buf);
379 lRet = RegEnumKeyExW(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite);
380 if (lRet != ERROR_SUCCESS) continue;
381 if (_wcsnicmp(buf, msacmW, ARRAY_SIZE(msacmW))) continue;
382 if (!(name = wcschr(buf, '='))) continue;
383 *name = 0;
385 }
386 i = 0;
387 cnt = ARRAY_SIZE(valname);
388 bufLen = sizeof(buf);
389 while(RegEnumValueW(hKey, i, valname, &cnt, 0,
390 &type, (BYTE*)buf, &bufLen) == ERROR_SUCCESS){
391 if (!_wcsnicmp(valname, msacmW, ARRAY_SIZE(msacmW)))
392 MSACM_RegisterDriver(valname, buf, 0);
393 ++i;
394 }
395 RegCloseKey( hKey );
396 }
397
398 if (GetPrivateProfileSectionW(drv32, buf, ARRAY_SIZE(buf), sys))
399 {
400 for(s = buf; *s; s += lstrlenW(s) + 1)
401 {
402 if (_wcsnicmp(s, msacmW, ARRAY_SIZE(msacmW))) continue;
403 if (!(name = wcschr(s, '='))) continue;
404 *name = 0;
405 MSACM_RegisterDriver(s, name + 1, 0);
406 *name = '=';
407 }
408 }
410 MSACM_RegisterDriver(msacm32, msacm32, 0);
411}
412
413/***********************************************************************
414 * MSACM_RegisterNotificationWindow()
415 */
417{
418 PWINE_ACMNOTIFYWND panwnd;
419
420 TRACE("(%p,0x%08x)\n", hNotifyWnd, dwNotifyMsg);
421
422 panwnd = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMNOTIFYWND));
424 panwnd->obj.pACMDriverID = 0;
425 panwnd->hNotifyWnd = hNotifyWnd;
426 panwnd->dwNotifyMsg = dwNotifyMsg;
427 panwnd->fdwSupport = 0;
428
429 panwnd->pNextACMNotifyWnd = NULL;
436
437 return panwnd;
438}
439
440/***********************************************************************
441 * MSACM_BroadcastNotification()
442 */
444{
446 PWINE_ACMNOTIFYWND panwnd;
447
448 for (panwnd = MSACM_pFirstACMNotifyWnd; panwnd; panwnd = panwnd->pNextACMNotifyWnd)
450 SendMessageW(panwnd->hNotifyWnd, panwnd->dwNotifyMsg, 0, 0);
451 } else {
453 }
454}
455
456/***********************************************************************
457 * MSACM_DisableNotifications()
458 */
460{
462}
463
464/***********************************************************************
465 * MSACM_EnableNotifications()
466 */
468{
474 }
475 }
476}
477
478/***********************************************************************
479 * MSACM_UnRegisterNotificationWindow()
480 */
482{
484
485 for (p = MSACM_pFirstACMNotifyWnd; p; p = p->pNextACMNotifyWnd) {
486 if (p == panwnd) {
488
489 if (p->pPrevACMNotifyWnd) p->pPrevACMNotifyWnd->pNextACMNotifyWnd = p->pNextACMNotifyWnd;
490 if (p->pNextACMNotifyWnd) p->pNextACMNotifyWnd->pPrevACMNotifyWnd = p->pPrevACMNotifyWnd;
494
495 return pNext;
496 }
497 }
498 return NULL;
499}
500
501/***********************************************************************
502 * MSACM_RePositionDriver()
503 */
505{
506 PWINE_ACMDRIVERID pTargetPosition = NULL;
507
508 /* Remove selected driver from linked list */
509 if (MSACM_pFirstACMDriverID == padid) {
511 }
512 if (MSACM_pLastACMDriverID == padid) {
514 }
515 if (padid->pPrevACMDriverID != NULL) {
517 }
518 if (padid->pNextACMDriverID != NULL) {
520 }
521
522 /* Look up position where selected driver should be */
523 if (dwPriority == 1) {
524 pTargetPosition = padid->pPrevACMDriverID;
525 while (pTargetPosition->pPrevACMDriverID != NULL &&
527 pTargetPosition = pTargetPosition->pPrevACMDriverID;
528 }
529 } else if (dwPriority == -1) {
530 pTargetPosition = padid->pNextACMDriverID;
531 while (pTargetPosition->pNextACMDriverID != NULL) {
532 pTargetPosition = pTargetPosition->pNextACMDriverID;
533 }
534 }
535
536 /* Place selected driver in selected position */
537 padid->pPrevACMDriverID = pTargetPosition->pPrevACMDriverID;
538 padid->pNextACMDriverID = pTargetPosition;
539 if (padid->pPrevACMDriverID != NULL) {
540 padid->pPrevACMDriverID->pNextACMDriverID = padid;
541 } else {
543 }
544 if (padid->pNextACMDriverID != NULL) {
545 padid->pNextACMDriverID->pPrevACMDriverID = padid;
546 } else {
548 }
549}
550
551/***********************************************************************
552 * MSACM_ReorderDriversByPriority()
553 * Reorders all drivers based on the priority list indicated by the registry key:
554 * HKCU\\Software\\Microsoft\\Multimedia\\Audio Compression Manager\\Priority v4.00
555 */
557{
558 PWINE_ACMDRIVERID padid;
559 unsigned int iNumDrivers;
560 PWINE_ACMDRIVERID * driverList = NULL;
561 HKEY hPriorityKey = NULL;
562
563 TRACE("\n");
564
565 /* Count drivers && alloc corresponding memory for list */
566 iNumDrivers = 0;
567 for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) iNumDrivers++;
568 if (iNumDrivers > 1)
569 {
570 LONG lError;
571 static const WCHAR basePriorityKey[] = {
572 'S','o','f','t','w','a','r','e','\\',
573 'M','i','c','r','o','s','o','f','t','\\',
574 'M','u','l','t','i','m','e','d','i','a','\\',
575 'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
576 'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
577 };
578 unsigned int i;
579 LONG lBufferLength;
580 WCHAR szBuffer[256];
581
582 driverList = HeapAlloc(MSACM_hHeap, 0, iNumDrivers * sizeof(PWINE_ACMDRIVERID));
583 if (!driverList)
584 {
585 ERR("out of memory\n");
586 goto errCleanUp;
587 }
588
589 lError = RegOpenKeyW(HKEY_CURRENT_USER, basePriorityKey, &hPriorityKey);
590 if (lError != ERROR_SUCCESS) {
591 TRACE("RegOpenKeyW failed, possibly key does not exist yet\n");
592 hPriorityKey = NULL;
593 goto errCleanUp;
594 }
595
596 /* Copy drivers into list to simplify linked list modification */
597 for (i = 0, padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID, i++)
598 {
599 driverList[i] = padid;
600 }
601
602 /* Query each of the priorities in turn. Alias key is in lowercase.
603 The general form of the priority record is the following:
604 "PriorityN" --> "1, msacm.driveralias"
605 where N is an integer, and the value is a string of the driver
606 alias, prefixed by "1, " for an enabled driver, or "0, " for a
607 disabled driver.
608 */
609 for (i = 0; i < iNumDrivers; i++)
610 {
611 static const WCHAR priorityTmpl[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
612 WCHAR szSubKey[17];
613 unsigned int iTargetPosition;
614 unsigned int iCurrentPosition;
615 WCHAR * pAlias;
616 static const WCHAR sPrefix[] = {'m','s','a','c','m','.','\0'};
617
618 /* Build expected entry name */
619 swprintf(szSubKey, priorityTmpl, i + 1);
620 lBufferLength = sizeof(szBuffer);
621 lError = RegQueryValueExW(hPriorityKey, szSubKey, NULL, NULL, (LPBYTE)szBuffer, (LPDWORD)&lBufferLength);
622 if (lError != ERROR_SUCCESS) continue;
623
624 /* Recovered driver alias should be at this position */
625 iTargetPosition = i;
626
627 /* Locate driver alias in driver list */
628 pAlias = wcsstr(szBuffer, sPrefix);
629 if (pAlias == NULL) continue;
630
631 for (iCurrentPosition = 0; iCurrentPosition < iNumDrivers; iCurrentPosition++) {
632 if (wcsicmp(driverList[iCurrentPosition]->pszDriverAlias, pAlias) == 0)
633 break;
634 }
635 if (iCurrentPosition < iNumDrivers && iTargetPosition != iCurrentPosition) {
636 padid = driverList[iTargetPosition];
637 driverList[iTargetPosition] = driverList[iCurrentPosition];
638 driverList[iCurrentPosition] = padid;
639
640 /* Locate enabled status */
641 if (szBuffer[0] == '1') {
642 driverList[iTargetPosition]->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
643 } else if (szBuffer[0] == '0') {
644 driverList[iTargetPosition]->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
645 }
646 }
647 }
648
649 /* Re-assign pointers so that linked list traverses the ordered array */
650 for (i = 0; i < iNumDrivers; i++) {
651 driverList[i]->pPrevACMDriverID = (i > 0) ? driverList[i - 1] : NULL;
652 driverList[i]->pNextACMDriverID = (i < iNumDrivers - 1) ? driverList[i + 1] : NULL;
653 }
654 MSACM_pFirstACMDriverID = driverList[0];
655 MSACM_pLastACMDriverID = driverList[iNumDrivers - 1];
656 }
657
658errCleanUp:
659 if (hPriorityKey != NULL) RegCloseKey(hPriorityKey);
660 HeapFree(MSACM_hHeap, 0, driverList);
661}
662
663/***********************************************************************
664 * MSACM_WriteCurrentPriorities()
665 * Writes out current order of driver priorities to registry key:
666 * HKCU\\Software\\Microsoft\\Multimedia\\Audio Compression Manager\\Priority v4.00
667 */
669{
670 LONG lError;
671 HKEY hPriorityKey;
672 static const WCHAR basePriorityKey[] = {
673 'S','o','f','t','w','a','r','e','\\',
674 'M','i','c','r','o','s','o','f','t','\\',
675 'M','u','l','t','i','m','e','d','i','a','\\',
676 'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
677 'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
678 };
679 PWINE_ACMDRIVERID padid;
680 DWORD dwPriorityCounter;
681 static const WCHAR priorityTmpl[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
682 static const WCHAR valueTmpl[] = {'%','c',',',' ','%','s','\0'};
683 static const WCHAR converterAlias[] = {'I','n','t','e','r','n','a','l',' ','P','C','M',' ','C','o','n','v','e','r','t','e','r','\0'};
684 WCHAR szSubKey[17];
685 WCHAR szBuffer[256];
686
687 /* Delete ACM priority key and create it anew */
688 lError = RegDeleteKeyW(HKEY_CURRENT_USER, basePriorityKey);
689 if (lError != ERROR_SUCCESS && lError != ERROR_FILE_NOT_FOUND) {
690 ERR("unable to remove current key %s (0x%08x) - priority changes won't persist past application end.\n",
691 debugstr_w(basePriorityKey), lError);
692 return;
693 }
694 lError = RegCreateKeyW(HKEY_CURRENT_USER, basePriorityKey, &hPriorityKey);
695 if (lError != ERROR_SUCCESS) {
696 ERR("unable to create key %s (0x%08x) - priority changes won't persist past application end.\n",
697 debugstr_w(basePriorityKey), lError);
698 return;
699 }
700
701 /* Write current list of priorities */
702 for (dwPriorityCounter = 0, padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
703 if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) continue;
704 if (padid->pszDriverAlias == NULL) continue; /* internal PCM converter is last */
705
706 /* Build required value name */
707 dwPriorityCounter++;
708 swprintf(szSubKey, priorityTmpl, dwPriorityCounter);
709
710 /* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
711 swprintf(szBuffer, valueTmpl, (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ? '0' : '1', padid->pszDriverAlias);
712 _wcslwr(szBuffer);
713
714 lError = RegSetValueExW(hPriorityKey, szSubKey, 0, REG_SZ, (BYTE *)szBuffer, (lstrlenW(szBuffer) + 1) * sizeof(WCHAR));
715 if (lError != ERROR_SUCCESS) {
716 ERR("unable to write value for %s under key %s (0x%08x)\n",
717 debugstr_w(padid->pszDriverAlias), debugstr_w(basePriorityKey), lError);
718 }
719 }
720
721 /* Build required value name */
722 dwPriorityCounter++;
723 swprintf(szSubKey, priorityTmpl, dwPriorityCounter);
724
725 /* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
726 swprintf(szBuffer, valueTmpl, '1', converterAlias);
727
728 lError = RegSetValueExW(hPriorityKey, szSubKey, 0, REG_SZ, (BYTE *)szBuffer, (lstrlenW(szBuffer) + 1) * sizeof(WCHAR));
729 if (lError != ERROR_SUCCESS) {
730 ERR("unable to write value for %s under key %s (0x%08x)\n",
731 debugstr_w(converterAlias), debugstr_w(basePriorityKey), lError);
732 }
733 RegCloseKey(hPriorityKey);
734}
735
738
740{
741 PWINE_ACMLOCALDRIVER pNextACMLocalDriver;
742 LONG ref;
743
744 if (paldrv->pACMInstList) {
745 ERR("local driver instances still present after closing all drivers - memory leak\n");
746 return NULL;
747 }
748
749 ref = InterlockedDecrement(&paldrv->ref);
750 if (ref)
751 return paldrv;
752
753 if (paldrv == MSACM_pFirstACMLocalDriver)
755 if (paldrv == MSACM_pLastACMLocalDriver)
757
758 if (paldrv->pPrevACMLocalDrv)
760 if (paldrv->pNextACMLocalDrv)
762
763 pNextACMLocalDriver = paldrv->pNextACMLocalDrv;
764
765 HeapFree(MSACM_hHeap, 0, paldrv);
766
767 return pNextACMLocalDriver;
768}
769
770/***********************************************************************
771 * MSACM_UnregisterDriver()
772 */
774{
775 PWINE_ACMDRIVERID pNextACMDriverID;
776
777 while (p->pACMDriverList)
778 acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
779
780 HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
781 HeapFree(MSACM_hHeap, 0, p->pszFileName);
782 HeapFree(MSACM_hHeap, 0, p->aFormatTag);
783
788
789 if (p->pPrevACMDriverID)
791 if (p->pNextACMDriverID)
793
794 pNextACMDriverID = p->pNextACMDriverID;
795
796 if (p->pLocalDriver) MSACM_UnregisterLocalDriver(p->pLocalDriver);
798
799 return pNextACMDriverID;
800}
801
802/***********************************************************************
803 * MSACM_UnregisterAllDrivers()
804 */
806{
809
810 while (p) {
813 }
814
815 while (panwnd) {
816 panwnd = MSACM_UnRegisterNotificationWindow(panwnd);
817 }
818}
819
820/***********************************************************************
821 * MSACM_GetObj()
822 */
824{
825 PWINE_ACMOBJ pao = (PWINE_ACMOBJ)hObj;
826
827 if (pao == NULL || IsBadReadPtr(pao, sizeof(WINE_ACMOBJ)) ||
828 ((type != WINE_ACMOBJ_DONTCARE) && (type != pao->dwType)))
829 return NULL;
830 return pao;
831}
832
833/***********************************************************************
834 * MSACM_GetDriverID()
835 */
837{
838 return (PWINE_ACMDRIVERID)MSACM_GetObj((HACMOBJ)hDriverID, WINE_ACMOBJ_DRIVERID);
839}
840
841/***********************************************************************
842 * MSACM_GetDriver()
843 */
845{
847}
848
849/***********************************************************************
850 * MSACM_GetNotifyWnd()
851 */
853{
855}
856
857/***********************************************************************
858 * MSACM_GetLocalDriver()
859 */
860/*
861PWINE_ACMLOCALDRIVER MSACM_GetLocalDriver(HACMDRIVER hDriver)
862{
863 return (PWINE_ACMLOCALDRIVER)MSACM_GetObj((HACMOBJ)hDriver, WINE_ACMOBJ_LOCALDRIVER);
864}
865*/
866#define MSACM_DRIVER_SendMessage(PDRVRINST, msg, lParam1, lParam2) \
867 (PDRVRINST)->pLocalDriver->lpDrvProc((PDRVRINST)->dwDriverID, (HDRVR)(PDRVRINST), msg, lParam1, lParam2)
868
869/***********************************************************************
870 * MSACM_Message()
871 */
872MMRESULT MSACM_Message(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
873{
875
876 if (!pad) return MMSYSERR_INVALHANDLE;
877 if (pad->hDrvr) return SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2);
878 if (pad->pLocalDrvrInst) return MSACM_DRIVER_SendMessage(pad->pLocalDrvrInst, uMsg, lParam1, lParam2);
879
881}
882
884{
886
887 TRACE("(%p, %p)\n", hModule, lpDriverProc);
888 if (!hModule || !lpDriverProc) return NULL;
889
890 /* look up previous instance of local driver module */
891 for (paldrv = MSACM_pFirstACMLocalDriver; paldrv; paldrv = paldrv->pNextACMLocalDrv)
892 {
893 if (paldrv->hModule == hModule && paldrv->lpDrvProc == lpDriverProc)
894 {
895 InterlockedIncrement(&paldrv->ref);
896 return paldrv;
897 }
898 }
899
900 paldrv = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
902 paldrv->obj.pACMDriverID = 0;
903 paldrv->hModule = hModule;
904 paldrv->lpDrvProc = lpDriverProc;
905 paldrv->pACMInstList = NULL;
906 paldrv->ref = 1;
907
908 paldrv->pNextACMLocalDrv = NULL;
915
916 return paldrv;
917}
918
919/**************************************************************************
920 * MSACM_GetNumberOfModuleRefs [internal]
921 *
922 * Returns the number of open drivers which share the same module.
923 * Inspired from implementation in dlls/winmm/driver.c
924 */
926{
928 unsigned count = 0;
929
930 if (found) *found = NULL;
931 for (lpDrv = MSACM_pFirstACMLocalDriver; lpDrv; lpDrv = lpDrv->pNextACMLocalDrv)
932 {
933 if (lpDrv->hModule == hModule && lpDrv->lpDrvProc == lpDrvProc)
934 {
936
937 while (pInst) {
938 if (found && !*found) *found = pInst;
939 count++;
940 pInst = pInst->pNextACMInst;
941 }
942 }
943 }
944 return count;
945}
946
947/**************************************************************************
948 * MSACM_RemoveFromList [internal]
949 *
950 * Generates all the logic to handle driver closure / deletion
951 * Removes a driver struct to the list of open drivers.
952 */
954{
955 PWINE_ACMLOCALDRIVER pDriverBase = lpDrv->pLocalDriver;
956 PWINE_ACMLOCALDRIVERINST pPrevInst;
957
958 /* last of this driver in list ? */
959 if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, NULL) == 1) {
962 }
963
964 pPrevInst = NULL;
965 if (pDriverBase->pACMInstList != lpDrv) {
966 pPrevInst = pDriverBase->pACMInstList;
967 while (pPrevInst && pPrevInst->pNextACMInst != lpDrv)
968 pPrevInst = pPrevInst->pNextACMInst;
969 if (!pPrevInst) {
970 ERR("requested to remove invalid instance %p\n", pPrevInst);
971 return FALSE;
972 }
973 }
974 if (!pPrevInst) {
975 /* first driver instance on list */
976 pDriverBase->pACMInstList = lpDrv->pNextACMInst;
977 } else {
978 pPrevInst->pNextACMInst = lpDrv->pNextACMInst;
979 }
980 return TRUE;
981}
982
983/**************************************************************************
984 * MSACM_AddToList [internal]
985 *
986 * Adds a driver struct to the list of open drivers.
987 * Generates all the logic to handle driver creation / open.
988 */
990{
991 PWINE_ACMLOCALDRIVER pDriverBase = lpNewDrv->pLocalDriver;
992
993 /* first of this driver in list ? */
994 if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, NULL) == 0) {
995 if (MSACM_DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
996 FIXME("DRV_LOAD failed on driver %p\n", lpNewDrv);
997 return FALSE;
998 }
999 /* returned value is not checked */
1000 MSACM_DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
1001 }
1002
1003 lpNewDrv->pNextACMInst = NULL;
1004 if (pDriverBase->pACMInstList == NULL) {
1005 pDriverBase->pACMInstList = lpNewDrv;
1006 } else {
1007 PWINE_ACMLOCALDRIVERINST lpDrvInst = pDriverBase->pACMInstList;
1008
1009 while (lpDrvInst->pNextACMInst != NULL)
1010 lpDrvInst = lpDrvInst->pNextACMInst;
1011
1012 lpDrvInst->pNextACMInst = lpNewDrv;
1013 }
1014
1015 /* Now just open a new instance of a driver on this module */
1016 lpNewDrv->dwDriverID = MSACM_DRIVER_SendMessage(lpNewDrv, DRV_OPEN, 0, lParam2);
1017
1018 if (lpNewDrv->dwDriverID == 0) {
1019 FIXME("DRV_OPEN failed on driver %p\n", lpNewDrv);
1020 MSACM_RemoveFromList(lpNewDrv);
1021 return FALSE;
1022 }
1023 return TRUE;
1024}
1025
1027{
1028 PWINE_ACMLOCALDRIVERINST pDrvInst;
1029
1030 pDrvInst = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVERINST));
1031 if (!pDrvInst)
1032 return NULL;
1033
1034 pDrvInst->pLocalDriver = paldrv;
1035 pDrvInst->dwDriverID = 0;
1036 pDrvInst->pNextACMInst = NULL;
1037 pDrvInst->bSession = FALSE;
1038
1039 /* Win32 installable drivers must support a two phase opening scheme:
1040 * + first open with NULL as lParam2 (session instance),
1041 * + then do a second open with the real non null lParam2)
1042 */
1043 if (MSACM_GetNumberOfModuleRefs(paldrv->hModule, paldrv->lpDrvProc, NULL) == 0 && lParam2)
1044 {
1046
1047 if (!MSACM_AddToList(pDrvInst, 0L))
1048 {
1049 ERR("load0 failed\n");
1050 goto exit;
1051 }
1052 ret = MSACM_OpenLocalDriver(paldrv, lParam2);
1053 if (!ret)
1054 {
1055 ERR("load1 failed\n");
1056 /* If MSACM_CloseLocalDriver returns TRUE,
1057 * then pDrvInst has been freed
1058 */
1059 if (!MSACM_CloseLocalDriver(pDrvInst))
1060 goto exit;
1061
1062 return NULL;
1063 }
1064 pDrvInst->bSession = TRUE;
1065 return ret;
1066 }
1067
1068 if (!MSACM_AddToList(pDrvInst, lParam2))
1069 {
1070 ERR("load failed\n");
1071 goto exit;
1072 }
1073
1074 TRACE("=> %p\n", pDrvInst);
1075 return pDrvInst;
1076exit:
1077 HeapFree(MSACM_hHeap, 0, pDrvInst);
1078 return NULL;
1079}
1080
1082{
1083 if (MSACM_RemoveFromList(paldrv)) {
1085 PWINE_ACMLOCALDRIVER pDriverBase = paldrv->pLocalDriver;
1086
1087 MSACM_DRIVER_SendMessage(paldrv, DRV_CLOSE, 0, 0);
1088 paldrv->dwDriverID = 0;
1089
1090 if (paldrv->bSession)
1091 ERR("should not directly close session instance (%p)\n", paldrv);
1092
1093 /* if driver has an opened session instance, we have to close it too */
1094 if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, &lpDrv0) == 1 &&
1095 lpDrv0->bSession)
1096 {
1098 lpDrv0->dwDriverID = 0;
1099 MSACM_RemoveFromList(lpDrv0);
1100 HeapFree(MSACM_hHeap, 0, lpDrv0);
1101 }
1102
1103 HeapFree(MSACM_hHeap, 0, paldrv);
1104 return TRUE;
1105 }
1106 ERR("unable to close driver instance\n");
1107 return FALSE;
1108}
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define ARRAY_SIZE(A)
Definition: main.h:33
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
#define RegCloseKey(hKey)
Definition: registry.h:49
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
unsigned int idx
Definition: utils.c:41
LONG WINAPI RegSetValueExA(HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE *lpData, DWORD cbData)
Definition: reg.c:4828
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3362
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2533
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3297
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4911
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1239
LONG WINAPI RegEnumValueW(_In_ HKEY hKey, _In_ DWORD index, _Out_ LPWSTR value, _Inout_ PDWORD val_count, _Reserved_ PDWORD reserved, _Out_opt_ PDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ PDWORD count)
Definition: reg.c:2859
LONG WINAPI RegQueryInfoKeyW(HKEY hKey, LPWSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime)
Definition: reg.c:3691
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4038
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4132
LONG WINAPI RegCreateKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:1201
HMODULE hModule
Definition: animate.c:44
#define wcschr
Definition: compat.h:17
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define lstrcpyW
Definition: compat.h:749
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define wcsicmp
Definition: compat.h:15
#define lstrlenW
Definition: compat.h:750
BOOL WINAPI IsBadReadPtr(IN LPCVOID lp, IN UINT_PTR ucb)
Definition: except.c:805
INT WINAPI GetPrivateProfileSectionW(LPCWSTR section, LPWSTR buffer, DWORD len, LPCWSTR filename)
Definition: profile.c:1351
MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
Definition: driver.c:491
MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
Definition: driver.c:179
static LPWSTR MSACM_GetRegistryKey(const WINE_ACMDRIVERID *padid)
Definition: internal.c:185
PWINE_ACMNOTIFYWND MSACM_RegisterNotificationWindow(HWND hNotifyWnd, DWORD dwNotifyMsg)
Definition: internal.c:416
PWINE_ACMNOTIFYWND MSACM_UnRegisterNotificationWindow(const WINE_ACMNOTIFYWND *panwnd)
Definition: internal.c:481
static BOOL MSACM_ReadCache(PWINE_ACMDRIVERID padid)
Definition: internal.c:210
void MSACM_WriteCurrentPriorities(void)
Definition: internal.c:668
PWINE_ACMNOTIFYWND MSACM_GetNotifyWnd(HACMDRIVERID hDriver)
Definition: internal.c:852
PWINE_ACMDRIVERID MSACM_RegisterDriverFromRegistry(LPCWSTR pszRegEntry)
Definition: internal.c:61
static BOOL MSACM_RemoveFromList(PWINE_ACMLOCALDRIVERINST lpDrv)
Definition: internal.c:953
static PWINE_ACMLOCALDRIVER MSACM_UnregisterLocalDriver(PWINE_ACMLOCALDRIVER paldrv)
Definition: internal.c:739
HANDLE MSACM_hHeap
Definition: internal.c:47
BOOL MSACM_FindFormatTagInCache(const WINE_ACMDRIVERID *padid, DWORD fmtTag, LPDWORD idx)
Definition: internal.c:118
static DWORD MSACM_suspendBroadcastCount
Definition: internal.c:51
static BOOL MSACM_FillCache(PWINE_ACMDRIVERID padid)
Definition: internal.c:134
static PWINE_ACMNOTIFYWND MSACM_pLastACMNotifyWnd
Definition: internal.c:54
static BOOL MSACM_WriteCache(const WINE_ACMDRIVERID *padid)
Definition: internal.c:254
void MSACM_UnregisterAllDrivers(void)
Definition: internal.c:805
static PWINE_ACMNOTIFYWND MSACM_pFirstACMNotifyWnd
Definition: internal.c:53
MMRESULT MSACM_Message(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
Definition: internal.c:872
void MSACM_EnableNotifications(void)
Definition: internal.c:467
void MSACM_BroadcastNotification(void)
Definition: internal.c:443
void MSACM_RePositionDriver(PWINE_ACMDRIVERID padid, DWORD dwPriority)
Definition: internal.c:504
static PWINE_ACMDRIVERID MSACM_pLastACMDriverID
Definition: internal.c:49
#define MSACM_DRIVER_SendMessage(PDRVRINST, msg, lParam1, lParam2)
Definition: internal.c:866
PWINE_ACMLOCALDRIVERINST MSACM_OpenLocalDriver(PWINE_ACMLOCALDRIVER paldrv, LPARAM lParam2)
Definition: internal.c:1026
PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p)
Definition: internal.c:773
static void MSACM_ReorderDriversByPriority(void)
Definition: internal.c:556
static PWINE_ACMLOCALDRIVER MSACM_pFirstACMLocalDriver
Definition: internal.c:736
void MSACM_RegisterAllDrivers(void)
Definition: internal.c:354
static PWINE_ACMLOCALDRIVER MSACM_pLastACMLocalDriver
Definition: internal.c:737
PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver)
Definition: internal.c:844
static unsigned MSACM_GetNumberOfModuleRefs(HMODULE hModule, DRIVERPROC lpDrvProc, WINE_ACMLOCALDRIVERINST **found)
Definition: internal.c:925
PWINE_ACMDRIVERID MSACM_pFirstACMDriverID
Definition: internal.c:48
static BOOL MSACM_pendingBroadcast
Definition: internal.c:52
void MSACM_DisableNotifications(void)
Definition: internal.c:459
PWINE_ACMDRIVERID MSACM_RegisterDriver(LPCWSTR pszDriverAlias, LPCWSTR pszFileName, PWINE_ACMLOCALDRIVER pLocalDriver)
Definition: internal.c:285
PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj, DWORD type)
Definition: internal.c:823
static BOOL MSACM_AddToList(PWINE_ACMLOCALDRIVERINST lpNewDrv, LPARAM lParam2)
Definition: internal.c:989
PWINE_ACMLOCALDRIVER MSACM_RegisterLocalDriver(HMODULE hModule, DRIVERPROC lpDriverProc)
Definition: internal.c:883
PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
Definition: internal.c:836
LRESULT MSACM_CloseLocalDriver(PWINE_ACMLOCALDRIVERINST paldrv)
Definition: internal.c:1081
#define swprintf
Definition: precomp.h:40
LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1, LPARAM lParam2)
Definition: driver.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FxAutoRegKey hKey
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLdouble s
Definition: gl.h:2039
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define DRV_LOAD(x)
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
#define debugstr_w
Definition: kernel32.h:32
#define REG_SZ
Definition: layer.c:22
#define DRV_CLOSE
Definition: mmsystem.h:122
#define DRV_SUCCESS
Definition: mmsystem.h:18
UINT MMRESULT
Definition: mmsystem.h:962
#define DRV_ENABLE
Definition: mmsystem.h:120
LRESULT(CALLBACK * DRIVERPROC)(DWORD_PTR, HDRVR, UINT, LPARAM, LPARAM)
Definition: mmsystem.h:1001
#define DRV_OPEN
Definition: mmsystem.h:121
#define MMSYSERR_INVALHANDLE
Definition: mmsystem.h:101
#define DRV_FREE
Definition: mmsystem.h:124
#define DRV_DISABLE
Definition: mmsystem.h:123
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
#define ACMDRIVERDETAILS_SUPPORTF_DISABLED
Definition: msacm.h:67
#define ACM_FORMATTAGDETAILSF_INDEX
Definition: msacm.h:182
#define ACMDRIVERDETAILS_SUPPORTF_LOCAL
Definition: msacm.h:66
#define ACMDM_FORMATTAG_DETAILS
Definition: msacmdrv.h:51
#define ACMDM_DRIVER_DETAILS
Definition: msacmdrv.h:46
unsigned int UINT
Definition: ndis.h:50
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
#define REG_DWORD
Definition: sdbapi.c:596
_CRTIMP wchar_t *__cdecl _wcslwr(_Inout_z_ wchar_t *_String)
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
#define exit(n)
Definition: config.h:202
#define TRACE(s)
Definition: solgame.cpp:4
DWORD cFilterTags
Definition: msacm.h:311
DWORD cbStruct
Definition: msacm.h:298
DWORD cFormatTags
Definition: msacm.h:310
DWORD fdwSupport
Definition: msacm.h:309
DWORD dwFormatTagIndex
Definition: msacm.h:530
PWINE_ACMLOCALDRIVER pLocalDriver
Definition: wineacm.h:91
LPWSTR pszDriverAlias
Definition: wineacm.h:89
PWINE_ACMDRIVER pACMDriverList
Definition: wineacm.h:92
DWORD fdwSupport
Definition: wineacm.h:98
PWINE_ACMDRIVERID pNextACMDriverID
Definition: wineacm.h:93
PWINE_ACMDRIVERID pPrevACMDriverID
Definition: wineacm.h:94
DWORD cFilterTags
Definition: wineacm.h:96
DWORD cFormatTags
Definition: wineacm.h:97
LPWSTR pszFileName
Definition: wineacm.h:90
struct _WINE_ACMDRIVERID::@484 * aFormatTag
WINE_ACMOBJ obj
Definition: wineacm.h:88
PWINE_ACMLOCALDRIVERINST pLocalDrvrInst
Definition: wineacm.h:73
HDRVR hDrvr
Definition: wineacm.h:72
PWINE_ACMLOCALDRIVERINST pNextACMInst
Definition: wineacm.h:66
PWINE_ACMLOCALDRIVER pLocalDriver
Definition: wineacm.h:63
DRIVERPROC lpDrvProc
Definition: wineacm.h:54
PWINE_ACMLOCALDRIVER pPrevACMLocalDrv
Definition: wineacm.h:57
PWINE_ACMLOCALDRIVERINST pACMInstList
Definition: wineacm.h:55
PWINE_ACMLOCALDRIVER pNextACMLocalDrv
Definition: wineacm.h:56
WINE_ACMOBJ obj
Definition: wineacm.h:52
WINE_ACMOBJ obj
Definition: wineacm.h:108
PWINE_ACMNOTIFYWND pNextACMNotifyWnd
Definition: wineacm.h:112
PWINE_ACMNOTIFYWND pPrevACMNotifyWnd
Definition: wineacm.h:113
PWINE_ACMDRIVERID pACMDriverID
Definition: wineacm.h:45
DWORD dwType
Definition: wineacm.h:44
Definition: copy.c:22
Definition: name.c:39
Definition: send.c:48
unsigned char * LPBYTE
Definition: typedefs.h:53
uint32_t * LPDWORD
Definition: typedefs.h:59
WORD WORD PSZ PSZ pszFileName
Definition: vdmdbg.h:44
int ret
_In_ LPWSTR _In_ ULONG _In_ ULONG _In_ ULONG _Out_ DEVINFO _In_ HDEV _In_ LPWSTR _In_ HANDLE hDriver
Definition: winddi.h:3557
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
struct _WINE_ACMOBJ * PWINE_ACMOBJ
#define WINE_ACMOBJ_NOTIFYWND
Definition: wineacm.h:39
#define WINE_ACMOBJ_DRIVERID
Definition: wineacm.h:36
#define WINE_ACMOBJ_LOCALDRIVER
Definition: wineacm.h:40
#define WINE_ACMOBJ_DONTCARE
Definition: wineacm.h:35
#define WINE_ACMOBJ_DRIVER
Definition: wineacm.h:37
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CURRENT_USER
Definition: winreg.h:11
LPWSTR WINAPI CharLowerW(_Inout_ LPWSTR)
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193