ReactOS  0.4.14-dev-390-g34947ad
lolvldrv.c
Go to the documentation of this file.
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 
3 /*
4  * MMSYSTEM low level drivers handling functions
5  *
6  * Copyright 1999 Eric Pouech
7  * Modified for use with ReactOS by Andrew Greenwood, 2007
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 "winemm.h"
25 
27 
28 /* each known type of driver has an instance of this structure */
29 typedef struct tagWINE_LLTYPE {
30  /* those attributes depend on the specification of the type */
31  LPCSTR typestr; /* name (for debugging) */
32  BOOL bSupportMapper; /* if type is allowed to support mapper */
33  /* those attributes reflect the loaded/current situation for the type */
34  UINT wMaxId; /* number of loaded devices (sum across all loaded drivers) */
35  LPWINE_MLD lpMlds; /* "static" mlds to access the part though device IDs */
36  int nMapper; /* index to mapper */
37 } WINE_LLTYPE;
38 
39 static int MMDrvsHi /* = 0 */;
41 static LPWINE_MLD MM_MLDrvs[40];
42 #define MAX_MM_MLDRVS (sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]))
43 
44 #define A(_x,_y) {#_y, _x, 0, NULL, -1}
45 /* Note: the indices of this array must match the definitions
46  * of the MMDRV_???? manifest constants
47  */
49  A(TRUE, Aux),
50  A(FALSE, Mixer),
51  A(TRUE, MidiIn),
52  A(TRUE, MidiOut),
53  A(TRUE, WaveIn),
54  A(TRUE, WaveOut),
55 };
56 #undef A
57 
58 /**************************************************************************
59  * MMDRV_GetNum [internal]
60  */
62 {
63  TRACE("(%04x)\n", type);
65  return llTypes[type].wMaxId;
66 }
67 
68 /**************************************************************************
69  * MMDRV_Message [internal]
70  */
72  DWORD_PTR dwParam2)
73 {
74  LPWINE_MM_DRIVER lpDrv;
75  DWORD ret;
76  WINE_MM_DRIVER_PART* part;
77  WINE_LLTYPE* llType = &llTypes[mld->type];
78  int devID;
79 
80  TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx)\n",
81  llTypes[mld->type].typestr, mld->uDeviceID, wMsg,
82  mld->dwDriverInstance, dwParam1, dwParam2);
83 
84  if (mld->uDeviceID == (UINT16)-1) {
85  if (!llType->bSupportMapper) {
86  WARN("uDev=-1 requested on non-mappable ll type %s\n",
87  llTypes[mld->type].typestr);
88  return MMSYSERR_BADDEVICEID;
89  }
90  devID = -1;
91  } else {
92  if (mld->uDeviceID >= llType->wMaxId) {
93  WARN("uDev(%u) requested >= max (%d)\n", mld->uDeviceID, llType->wMaxId);
94  return MMSYSERR_BADDEVICEID;
95  }
96  devID = mld->uDeviceID;
97  }
98 
99  lpDrv = &MMDrvs[mld->mmdIndex];
100  part = &lpDrv->parts[mld->type];
101 
102 #if 0
103  /* some sanity checks */
104  if (!(part->nIDMin <= devID))
105  ERR("!(part->nIDMin(%d) <= devID(%d))\n", part->nIDMin, devID);
106  if (!(devID < part->nIDMax))
107  ERR("!(devID(%d) < part->nIDMax(%d))\n", devID, part->nIDMax);
108 #endif
109 
110  assert(part->fnMessage32);
111 
112  TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
113  mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
114  ret = part->fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
115  TRACE("=> %s\n", WINMM_ErrorToString(ret));
116 
117  return ret;
118 }
119 
120 /**************************************************************************
121  * MMDRV_Alloc [internal]
122  */
124  DWORD_PTR* dwCallback, DWORD_PTR* dwInstance)
125 {
126  LPWINE_MLD mld;
127  UINT_PTR i;
128  TRACE("(%d, %04x, %p, %p, %p, %p)\n",
129  size, type, hndl, dwFlags, dwCallback, dwInstance);
130 
132  if (!mld) return NULL;
133 
134  /* find an empty slot in MM_MLDrvs table */
135  for (i = 0; i < MAX_MM_MLDRVS; i++) if (!MM_MLDrvs[i]) break;
136 
137  if (i == MAX_MM_MLDRVS) {
138  /* the MM_MLDrvs table could be made growable in the future if needed */
139  ERR("Too many open drivers\n");
140  HeapFree(GetProcessHeap(), 0, mld);
141  return NULL;
142  }
143  MM_MLDrvs[i] = mld;
144  *hndl = (HANDLE)(i | 0x8000);
145 
146  mld->type = type;
147  if ((UINT_PTR)*hndl < MMDRV_GetNum(type) || ((UINT_PTR)*hndl >> 16)) {
148  /* FIXME: those conditions must be fulfilled so that:
149  * - we can distinguish between device IDs and handles
150  * - we can use handles as 16 or 32 bit entities
151  */
152  ERR("Shouldn't happen. Bad allocation scheme\n");
153  }
154 
155  mld->dwFlags = HIWORD(*dwFlags);
156  mld->dwCallback = *dwCallback;
157  mld->dwClientInstance = *dwInstance;
158 
159  return mld;
160 }
161 
162 /**************************************************************************
163  * MMDRV_Free [internal]
164  */
165 void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld)
166 {
167  TRACE("(%p, %p)\n", hndl, mld);
168 
169  if ((UINT_PTR)hndl & 0x8000) {
170  UINT_PTR idx = (UINT_PTR)hndl & ~0x8000;
171  if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) {
172  MM_MLDrvs[idx] = NULL;
173  HeapFree(GetProcessHeap(), 0, mld);
174  return;
175  }
176  }
177  ERR("Bad Handle %p at %p (not freed)\n", hndl, mld);
178 }
179 
180 /**************************************************************************
181  * MMDRV_Open [internal]
182  */
184 {
185  DWORD dwRet = MMSYSERR_BADDEVICEID;
186  DWORD_PTR dwInstance;
187  WINE_LLTYPE* llType = &llTypes[mld->type];
188  TRACE("(%p, %04x, 0x%08lx, 0x%08x)\n", mld, wMsg, dwParam1, dwFlags);
189 
190  mld->dwDriverInstance = (DWORD_PTR)&dwInstance;
191 
192  if (mld->uDeviceID == (UINT)-1 || mld->uDeviceID == (UINT16)-1) {
193  TRACE("MAPPER mode requested !\n");
194  /* check if mapper is supported by type */
195  if (llType->bSupportMapper) {
196  if (llType->nMapper == -1) {
197  /* no driver for mapper has been loaded, try a dumb implementation */
198  TRACE("No mapper loaded, doing it by hand\n");
199  for (mld->uDeviceID = 0; mld->uDeviceID < llType->wMaxId; mld->uDeviceID++) {
200  if ((dwRet = MMDRV_Open(mld, wMsg, dwParam1, dwFlags)) == MMSYSERR_NOERROR) {
201  /* to share this function epilog */
202  dwInstance = mld->dwDriverInstance;
203  break;
204  }
205  }
206  } else {
207  mld->uDeviceID = (UINT16)-1;
208  mld->mmdIndex = llType->lpMlds[-1].mmdIndex;
209  TRACE("Setting mmdIndex to %u\n", mld->mmdIndex);
210  dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags);
211  }
212  }
213  } else {
214  if (mld->uDeviceID < llType->wMaxId) {
215  mld->mmdIndex = llType->lpMlds[mld->uDeviceID].mmdIndex;
216  TRACE("Setting mmdIndex to %u\n", mld->mmdIndex);
217  dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags);
218  }
219  }
220  if (dwRet == MMSYSERR_NOERROR)
221  mld->dwDriverInstance = dwInstance;
222  return dwRet;
223 }
224 
225 /**************************************************************************
226  * MMDRV_Close [internal]
227  */
229 {
230  TRACE("(%p, %04x)\n", mld, wMsg);
231  return MMDRV_Message(mld, wMsg, 0L, 0L);
232 }
233 
234 /**************************************************************************
235  * MMDRV_GetByID [internal]
236  */
238 {
239  TRACE("(%04x, %04x)\n", uDevID, type);
240  if (uDevID < llTypes[type].wMaxId)
241  return &llTypes[type].lpMlds[uDevID];
242  if ((uDevID == (UINT16)-1 || uDevID == (UINT)-1) && llTypes[type].nMapper != -1)
243  return &llTypes[type].lpMlds[-1];
244  return NULL;
245 }
246 
247 /**************************************************************************
248  * MMDRV_Get [internal]
249  */
251 {
252  LPWINE_MLD mld = NULL;
253  UINT_PTR hndl = (UINT_PTR)_hndl;
254  TRACE("(%p, %04x, %c)\n", _hndl, type, bCanBeID ? 'Y' : 'N');
255 
256  assert(type < MMDRV_MAX);
257 
258  if (hndl >= llTypes[type].wMaxId &&
259  hndl != (UINT16)-1 && hndl != (UINT)-1) {
260  if (hndl & 0x8000) {
261  UINT idx = hndl & ~0x8000;
262  if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) {
263  __TRY
264  {
265  mld = MM_MLDrvs[idx];
266  if (mld && mld->type != type) mld = NULL;
267  }
269  {
270  mld = NULL;
271  }
272  __ENDTRY;
273  }
274  }
275  }
276  if (mld == NULL && bCanBeID) {
277  mld = MMDRV_GetByID(hndl, type);
278  }
279  return mld;
280 }
281 
282 /**************************************************************************
283  * MMDRV_GetRelated [internal]
284  */
286  BOOL bSrcCanBeID, UINT dstType)
287 {
288  LPWINE_MLD mld;
289  TRACE("(%p, %04x, %c, %04x)\n",
290  hndl, srcType, bSrcCanBeID ? 'Y' : 'N', dstType);
291 
292  if ((mld = MMDRV_Get(hndl, srcType, bSrcCanBeID)) != NULL) {
293  WINE_MM_DRIVER_PART* part = &MMDrvs[mld->mmdIndex].parts[dstType];
294  if (part->nIDMin < part->nIDMax)
295  return MMDRV_GetByID(part->nIDMin, dstType);
296  }
297  return NULL;
298 }
299 
300 /**************************************************************************
301  * MMDRV_PhysicalFeatures [internal]
302  */
304  DWORD_PTR dwParam1, DWORD_PTR dwParam2)
305 {
306  WINE_MM_DRIVER* lpDrv = &MMDrvs[mld->mmdIndex];
307 
308  TRACE("(%p, %04x, %08lx, %08lx)\n", mld, uMsg, dwParam1, dwParam2);
309 
310  /* all those function calls are undocumented */
311  switch (uMsg) {
312  case DRV_QUERYDRVENTRY:
313  lstrcpynA((LPSTR)dwParam1, lpDrv->drvname, LOWORD(dwParam2));
314  break;
315  case DRV_QUERYDEVNODE:
316  *(LPDWORD)dwParam1 = 0L; /* should be DevNode */
317  break;
318  case DRV_QUERYNAME:
319  WARN("NIY QueryName\n");
320  break;
321  case DRV_QUERYDRIVERIDS:
322  WARN("NIY call VxD\n");
323  /* should call VxD MMDEVLDR with (DevNode, dwParam1 and dwParam2) as pmts
324  * dwParam1 is buffer and dwParam2 is sizeof(buffer)
325  * I don't know where the result is stored though
326  */
327  break;
328  case DRV_QUERYMAPPABLE:
329  return (lpDrv->bIsMapper) ? 2 : 0;
330 
332  /* FIXME: get from registry someday */
333  *((LPDWORD)dwParam1) = -1; /* No preferred device */
334  *((LPDWORD)dwParam2) = 0;
335  break;
336 
339  return MMDRV_Message(mld, uMsg, dwParam1, dwParam2);
340 
341  case DRV_QUERYDSOUNDIFACE: /* Wine-specific: Retrieve DirectSound interface */
342  case DRV_QUERYDSOUNDDESC: /* Wine-specific: Retrieve DirectSound driver description*/
343  return MMDRV_Message(mld, uMsg, dwParam1, dwParam2);
344 
345  default:
346  WARN("Unknown call %04x\n", uMsg);
347  return MMSYSERR_INVALPARAM;
348  }
349  return 0L;
350 }
351 
352 /**************************************************************************
353  * MMDRV_InitPerType [internal]
354  */
356 {
357  WINE_MM_DRIVER_PART* part = &lpDrv->parts[type];
358  DWORD ret;
359  UINT count = 0;
360  int i, k;
361  TRACE("(%p, %04x, %04x)\n", lpDrv, type, wMsg);
362 
363  part->nIDMin = part->nIDMax = 0;
364 
365  /* for DRVM_INIT and DRVM_ENABLE, dwParam2 should be PnP node */
366  /* the DRVM_ENABLE is only required when the PnP node is non zero */
367  if (part->fnMessage32) {
368  ret = part->fnMessage32(0, DRVM_INIT, 0L, 0L, 0L);
369  TRACE("DRVM_INIT => %s\n", WINMM_ErrorToString(ret));
370 #if 0
371  ret = part->fnMessage32(0, DRVM_ENABLE, 0L, 0L, 0L);
372  TRACE("DRVM_ENABLE => %08lx\n", ret);
373 #endif
374  count = part->fnMessage32(0, wMsg, 0L, 0L, 0L);
375  }
376  else return FALSE;
377 
378  TRACE("Got %u dev for (%s:%s)\n", count, lpDrv->drvname, llTypes[type].typestr);
379 
380  if (HIWORD(count))
381  return FALSE;
382 
383  /* got some drivers */
384  if (lpDrv->bIsMapper) {
385  /* it seems native mappers return 0 devices :-( */
386  if (llTypes[type].nMapper != -1)
387  ERR("Two mappers for type %s (%d, %s)\n",
388  llTypes[type].typestr, llTypes[type].nMapper, lpDrv->drvname);
389  if (count > 1)
390  ERR("Strange: mapper with %d > 1 devices\n", count);
392  } else {
393  if (count == 0)
394  return FALSE;
395  part->nIDMin = llTypes[type].wMaxId;
396  llTypes[type].wMaxId += count;
397  part->nIDMax = llTypes[type].wMaxId;
398  }
399  TRACE("Setting min=%d max=%d (ttop=%d) for (%s:%s)\n",
400  part->nIDMin, part->nIDMax, llTypes[type].wMaxId,
401  lpDrv->drvname, llTypes[type].typestr);
402  /* realloc translation table */
403  if (llTypes[type].lpMlds)
406  sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1;
407  else
410  sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1;
411 
412  /* re-build the translation table */
413  if (llTypes[type].nMapper != -1) {
414  TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, -1, MMDrvs[llTypes[type].nMapper].drvname);
415  llTypes[type].lpMlds[-1].uDeviceID = (UINT16)-1;
416  llTypes[type].lpMlds[-1].type = type;
419  }
420  for (i = k = 0; i <= MMDrvsHi; i++) {
421  while (MMDrvs[i].parts[type].nIDMin <= k && k < MMDrvs[i].parts[type].nIDMax) {
422  TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, k, MMDrvs[i].drvname);
427  k++;
428  }
429  }
430  return TRUE;
431 }
432 
433 /**************************************************************************
434  * MMDRV_Install [internal]
435  */
436 BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper)
437 {
438  int i, count = 0;
439  LPWINE_MM_DRIVER lpDrv = &MMDrvs[MMDrvsHi];
442 
443  TRACE("('%s', '%s', mapper=%c);\n", drvRegName, drvFileName, bIsMapper ? 'Y' : 'N');
444 
445  for (i = 0; i < MMDrvsHi; i++) {
446  if (!strcmp(drvRegName, MMDrvs[i].drvname)) return FALSE;
447  }
448 
449  /* Be sure that size of MMDrvs matches the max number of loadable
450  * drivers !!
451  * If not just increase size of MMDrvs
452  */
453  assert(MMDrvsHi <= sizeof(MMDrvs)/sizeof(MMDrvs[0]));
454 
455  memset(lpDrv, 0, sizeof(*lpDrv));
456 
457  if (!(lpDrv->hDriver = OpenDriverA(drvFileName, 0, 0))) {
458  WARN("Couldn't open driver '%s'\n", drvFileName);
459  return FALSE;
460  }
461 
462  d = DRIVER_FindFromHDrvr(lpDrv->hDriver);
463 
464  if (!(d = DRIVER_FindFromHDrvr(lpDrv->hDriver))) {
465  CloseDriver(lpDrv->hDriver, 0, 0);
466  WARN("Couldn't get the WINE internal structure for driver '%s'\n", drvFileName);
467  return FALSE;
468  }
469 
470  /* Then look for xxxMessage functions */
471 #define AA(_h,_w,_x,_y,_z) \
472  func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \
473  if (func != NULL) \
474  { lpDrv->parts[_w].fnMessage##_y = func; count++; \
475  TRACE("Got %d bit func '%s'\n", _y, #_x); }
476 
477  if (d->hModule) {
478 #define A(_x,_y) AA(d->hModule,_x,_y,32,GetProcAddress)
485 #undef A
486  }
487 #undef AA
488 
489  if (!count) {
490  CloseDriver(lpDrv->hDriver, 0, 0);
491  WARN("No message functions found\n");
492  return FALSE;
493  }
494 
495  /* FIXME: being a mapper or not should be known by another way */
496  /* it's known for NE drvs (the description is of the form '*mapper: *'
497  * I don't have any clue for PE drvs
498  */
499  lpDrv->bIsMapper = bIsMapper;
500  lpDrv->drvname = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(drvRegName) + 1), drvRegName);
501 
502  /* Finish init and get the count of the devices */
503  i = 0;
504  if (MMDRV_InitPerType(lpDrv, MMDRV_AUX, AUXDM_GETNUMDEVS)) i = 1;
510  /* if all those func calls return FALSE, then the driver must be unloaded */
511  if (!i) {
512  CloseDriver(lpDrv->hDriver, 0, 0);
513  HeapFree(GetProcessHeap(), 0, lpDrv->drvname);
514  WARN("Driver initialization failed\n");
515  return FALSE;
516  }
517 
518  MMDrvsHi++;
519 
520  return TRUE;
521 }
522 
523 /**************************************************************************
524  * MMDRV_Init
525  */
527 {
528 /* Redundant code, keeping this for reference only (for now) */
529 #if 0
530  HKEY hKey;
531  char driver_buffer[256];
532  char mapper_buffer[256];
533  char midi_buffer[256];
534  char* p;
535  DWORD type, size;
536  BOOL ret = FALSE;
537  TRACE("()\n");
538 
539  strcpy(driver_buffer, WINE_DEFAULT_WINMM_DRIVER);
540  strcpy(mapper_buffer, WINE_DEFAULT_WINMM_MAPPER);
541  strcpy(midi_buffer, WINE_DEFAULT_WINMM_MIDI);
542 
543  /* @@ Wine registry key: HKCU\Software\Wine\Drivers */
544  if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Drivers", &hKey))
545  {
546  size = sizeof(driver_buffer);
547  if (RegQueryValueExA(hKey, "Audio", 0, &type, (LPVOID)driver_buffer, &size))
548  strcpy(driver_buffer, WINE_DEFAULT_WINMM_DRIVER);
549  }
550 
551  p = driver_buffer;
552  while (p)
553  {
554  char filename[sizeof(driver_buffer)+10];
555  char *next = strchr(p, ',');
556  if (next) *next++ = 0;
557  sprintf( filename, "wine%s.drv", p );
558  if ((ret = MMDRV_Install( filename, filename, FALSE ))) break;
559  p = next;
560  }
561 
562  ret |= MMDRV_Install("beepmidi.dll", "beepmidi.dll", FALSE);
563 
564  ret |= MMDRV_Install("wavemapper", WINE_DEFAULT_WINMM_MAPPER, TRUE);
565  ret |= MMDRV_Install("midimapper", WINE_DEFAULT_WINMM_MIDI, TRUE);
566  return ret;
567 #else
568  INT driver_count = 0;
569 
572 
573  /* Explorer doesn't like us failing */
574  return TRUE;
575 // return ( driver_count > 0 );
576 #endif
577 }
578 
579 /******************************************************************
580  * ExitPerType
581  *
582  *
583  */
585 {
586  WINE_MM_DRIVER_PART* part = &lpDrv->parts[type];
587  DWORD ret;
588  TRACE("(%p, %04x)\n", lpDrv, type);
589 
590  if (part->fnMessage32) {
591 #if 0
592  ret = part->fnMessage32(0, DRVM_DISABLE, 0L, 0L, 0L);
593  TRACE("DRVM_DISABLE => %08lx\n", ret);
594 #endif
595  ret = part->fnMessage32(0, DRVM_EXIT, 0L, 0L, 0L);
596  TRACE("DRVM_EXIT => %s\n", WINMM_ErrorToString(ret));
597  }
598 
599  return TRUE;
600 }
601 
602 /******************************************************************
603  * Exit
604  *
605  *
606  */
607 void MMDRV_Exit(void)
608 {
609  unsigned int i;
610  TRACE("()\n");
611 
612  for (i = 0; i < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]); i++)
613  {
614  if (MM_MLDrvs[i] != NULL)
615  {
616  FIXME("Closing while ll-driver open\n");
617 #if 0
618  /* FIXME: should generate a message depending on type */
619  MMDRV_Free((HANDLE)(i | 0x8000), MM_MLDrvs[i]);
620 #endif
621  }
622  }
623 
624  /* unload driver, in reverse order of loading */
625  i = MMDrvsHi;
626  while (i-- > 0)
627  {
634  CloseDriver(MMDrvs[i].hDriver, 0, 0);
635  }
636  if (llTypes[MMDRV_AUX].lpMlds)
637  HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_AUX].lpMlds - 1);
638  if (llTypes[MMDRV_MIXER].lpMlds)
639  HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIXER].lpMlds - 1);
640  if (llTypes[MMDRV_MIDIIN].lpMlds)
641  HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIDIIN].lpMlds - 1);
642  if (llTypes[MMDRV_MIDIOUT].lpMlds)
643  HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIDIOUT].lpMlds - 1);
644  if (llTypes[MMDRV_WAVEIN].lpMlds)
645  HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_WAVEIN].lpMlds - 1);
646  if (llTypes[MMDRV_WAVEOUT].lpMlds)
647  HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_WAVEOUT].lpMlds - 1);
648 }
GLenum func
Definition: glext.h:6028
unsigned __int3264 UINT_PTR
Definition: activex.cpp:275
LONG WINAPI RegOpenKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3257
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:4023
LPWINE_MLD MMDRV_Get(HANDLE _hndl, UINT type, BOOL bCanBeID)
Definition: lolvldrv.c:250
#define MMDRV_MIXER
Definition: winemm.h:77
#define DRV_QUERYDRIVERIDS
Definition: mmddk.h:92
#define TRUE
Definition: types.h:120
BOOL bSupportMapper
Definition: lolvldrv.c:32
struct tagWINE_MLD WINE_MLD
#define DWORD_PTR
Definition: treelist.c:76
#define MMDRV_MIDIIN
Definition: winemm.h:78
#define DRVM_MAPPER_PREFERRED_GET
Definition: mmsys.h:37
#define DRV_QUERYDRVENTRY
Definition: mmddk.h:89
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static const D3D_BLOB_PART parts[]
Definition: blob.c:76
HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
Definition: driver.c:365
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define HKEY_CURRENT_USER
Definition: winreg.h:11
unsigned bIsMapper
Definition: winemm.h:88
LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD *dwFlags, DWORD_PTR *dwCallback, DWORD_PTR *dwInstance)
Definition: lolvldrv.c:123
#define WARN(fmt,...)
Definition: debug.h:111
LPWINE_MLD lpMlds
Definition: lolvldrv.c:35
LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
Definition: driver.c:462
#define WIDM_GETNUMDEVS
Definition: mmddk.h:136
DWORD APIENTRY mxdMessage(UINT DeviceId, UINT Message, DWORD_PTR PrivateHandle, DWORD_PTR Parameter1, DWORD_PTR Parameter2)
Definition: mxdMessage.c:69
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
_In_ LPWSTR _In_ ULONG _In_ ULONG _In_ ULONG _Out_ DEVINFO _In_ HDEV _In_ LPWSTR _In_ HANDLE hDriver
Definition: winddi.h:3553
#define assert(x)
Definition: debug.h:53
#define DRV_QUERYDEVICEINTERFACESIZE
Definition: mmddk.h:97
static LPWINE_MLD MMDRV_GetByID(UINT uDevID, UINT type)
Definition: lolvldrv.c:237
#define DRVM_EXIT
Definition: mmddk.h:57
#define WINE_DEFAULT_WINMM_MAPPER
Definition: winemm.h:47
#define MMDRV_WAVEOUT
Definition: winemm.h:81
char * LPSTR
Definition: xmlstorage.h:182
DWORD_PTR dwClientInstance
Definition: winemm.h:101
const char * filename
Definition: ioapi.h:135
#define MIDM_GETNUMDEVS
Definition: mmddk.h:169
#define DRVM_ENABLE
Definition: mmddk.h:59
DWORD APIENTRY wodMessage(UINT device_id, UINT message, DWORD_PTR private_handle, DWORD_PTR parameter1, DWORD_PTR parameter2)
Definition: mme.c:48
int32_t INT
Definition: typedefs.h:56
LPSTR drvname
Definition: winemm.h:87
#define AUXDM_GETNUMDEVS
Definition: mmddk.h:182
LPCSTR typestr
Definition: lolvldrv.c:31
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static LPWINE_MLD MM_MLDrvs[40]
Definition: lolvldrv.c:41
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
MMRESULT FAR PASCAL modMessage(UINT device_id, UINT message, DWORD_PTR private_data, DWORD_PTR parameter1, DWORD_PTR parameter2)
Definition: beepmidi.c:771
#define MMDRV_AUX
Definition: winemm.h:76
LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstType)
Definition: lolvldrv.c:285
DWORD APIENTRY widMessage(UINT DeviceId, UINT Message, DWORD_PTR PrivateHandle, DWORD_PTR Parameter1, DWORD_PTR Parameter2)
Definition: widMessage.c:20
unsigned int BOOL
Definition: ntddk_ex.h:94
#define MMDRV_WAVEIN
Definition: winemm.h:80
#define FIXME(fmt,...)
Definition: debug.h:110
#define MMDRV_MAX
Definition: winemm.h:82
unsigned int idx
Definition: utils.c:41
smooth NULL
Definition: ftsmooth.c:416
struct tagWINE_MLD * LPWINE_MLD
WINE_DEFAULT_DEBUG_CHANNEL(winmm)
#define DRVM_DISABLE
Definition: mmddk.h:58
DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD dwFlags)
Definition: lolvldrv.c:183
static BOOL MMDRV_InitPerType(LPWINE_MM_DRIVER lpDrv, UINT type, UINT wMsg)
Definition: lolvldrv.c:355
UINT type
Definition: winemm.h:95
const char * LPCSTR
Definition: xmlstorage.h:183
#define __TRY
Definition: compat.h:70
#define MODM_GETNUMDEVS
Definition: mmddk.h:154
#define A(_x, _y)
Definition: lolvldrv.c:44
#define WINE_DEFAULT_WINMM_MIDI
Definition: winemm.h:48
#define TRACE(s)
Definition: solgame.cpp:4
#define MMDRV_MIDIOUT
Definition: winemm.h:79
static BOOL MMDRV_ExitPerType(LPWINE_MM_DRIVER lpDrv, UINT type)
Definition: lolvldrv.c:584
GLsizeiptr size
Definition: glext.h:5919
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define d
Definition: ke_i.h:81
struct tagWINE_LLTYPE WINE_LLTYPE
#define NT_MME_DRIVERS32_KEY
Definition: winemm.h:200
HDRVR hDriver
Definition: winemm.h:86
void MMDRV_Exit(void)
Definition: lolvldrv.c:607
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
Definition: lolvldrv.c:71
PVOID HANDLE
Definition: typedefs.h:71
unsigned long DWORD
Definition: ntddk_ex.h:95
static unsigned driver_count
Definition: ds3d.c:1254
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
BOOL LoadRegistryMMEDrivers(char *key)
Definition: registry.c:23
BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper)
Definition: lolvldrv.c:436
static int MMDrvsHi
Definition: lolvldrv.c:39
#define DRVM_INIT
Definition: mmddk.h:56
#define __ENDTRY
Definition: compat.h:72
int ret
DWORD(CALLBACK * WINEMM_msgFunc32)(UINT, UINT, DWORD_PTR, DWORD_PTR, DWORD_PTR)
Definition: winemm.h:65
#define LPDWORD
Definition: nt_native.h:46
static const WCHAR L[]
Definition: oid.c:1250
#define DRV_QUERYDEVNODE
Definition: mmddk.h:90
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define MMSYSERR_BADDEVICEID
Definition: mmsystem.h:98
WINEMM_msgFunc32 fnMessage32
Definition: winemm.h:73
#define DRV_QUERYMAPPABLE
Definition: mmddk.h:93
UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
Definition: lolvldrv.c:303
uint32_t DWORD_PTR
Definition: typedefs.h:63
const char * WINMM_ErrorToString(MMRESULT error)
Definition: winmm.c:113
#define NT_MME_DRIVERS_KEY
Definition: winemm.h:203
#define ERR(fmt,...)
Definition: debug.h:109
#define WINE_DEFAULT_WINMM_DRIVER
Definition: winemm.h:46
DWORD_PTR dwCallback
Definition: winemm.h:100
#define DRV_QUERYNAME
Definition: mmddk.h:91
DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg)
Definition: lolvldrv.c:228
static unsigned __int64 next
Definition: rand_nt.c:6
UINT uDeviceID
Definition: winemm.h:94
void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld)
Definition: lolvldrv.c:165
#define MMSYSERR_INVALPARAM
Definition: mmsystem.h:107
#define MXDM_GETNUMDEVS
Definition: mmddk.h:191
#define HeapReAlloc
Definition: compat.h:401
unsigned short UINT16
unsigned int UINT
Definition: ndis.h:50
#define lstrcpynA
Definition: compat.h:416
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
static WINE_MM_DRIVER MMDrvs[8]
Definition: lolvldrv.c:40
char * strchr(const char *String, int ch)
Definition: utclib.c:501
BOOL MMDRV_Init(void)
Definition: lolvldrv.c:526
WINE_MM_DRIVER_PART parts[MMDRV_MAX]
Definition: winemm.h:89
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define HIWORD(l)
Definition: typedefs.h:246
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
UINT mmdIndex
Definition: winemm.h:96
APIENTRY DWORD midMessage(DWORD dwId, DWORD dwMessage, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
Definition: midi.c:251
GLfloat GLfloat p
Definition: glext.h:8902
static WINE_LLTYPE llTypes[MMDRV_MAX]
Definition: lolvldrv.c:48
#define memset(x, y, z)
Definition: compat.h:39
#define DRV_QUERYDEVICEINTERFACE
Definition: mmddk.h:96
int k
Definition: mpi.c:3369
#define LOWORD(l)
Definition: pedump.c:82
WORD dwFlags
Definition: winemm.h:99
UINT MMDRV_GetNum(UINT type)
Definition: lolvldrv.c:61
#define HeapFree(x, y, z)
Definition: compat.h:402
APIENTRY DWORD auxMessage(UINT dwId, UINT uMessage, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
Definition: auxil.c:20
#define __EXCEPT_PAGE_FAULT
Definition: compat.h:71
#define MAX_MM_MLDRVS
Definition: lolvldrv.c:42
DWORD_PTR dwDriverInstance
Definition: winemm.h:97
LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr)
Definition: driver.c:89
#define WODM_GETNUMDEVS
Definition: mmddk.h:108