source: trunk/src/winmm/mixer.cpp@ 8470

Last change on this file since 8470 was 8470, checked in by sandervl, 23 years ago

added debug wrappers (.def)
File size: 17.9 KB
Line 
1/* $Id: mixer.cpp,v 1.11 2002-05-22 15:50:25 sandervl Exp $ */
2
3/*
4 * Mixer stubs
5 *
6 * Copyright 1998 Joel Troster
7 *
8 * TODO: This is just a hack to fool apps into thinking a mixer exists
9 * Must be redesigned
10 *
11 * Based on Wine code (dlls\winmm\wineoss\mixer.c)
12 * Copyright 1997 Marcus Meissner
13 * 1999 Eric Pouech
14 *
15 *
16 * Project Odin Software License can be found in LICENSE.TXT
17 *
18 */
19
20/****************************************************************************
21 * Includes *
22 ****************************************************************************/
23
24#define NONAMELESSUNION
25#define NONAMELESSSTRUCT
26
27#include <os2win.h>
28#include <string.h>
29#include <mmsystem.h>
30#include <odinwrap.h>
31#include <misc.h>
32
33#include "waveoutdart.h"
34#include "winmm.h"
35
36#define DBG_LOCALLOG DBG_mixer
37#include "dbglocal.h"
38
39
40#define WINMM_MIXERSTRING_A "OS/2 WINMM Mixer"
41#define WINMM_MIXERSTRING_W (LPWSTR)L"OS/2 WINMM Mixer"
42
43#define WINMM_SHORTNAME_WAVEOUT_A "Wave Out"
44#define WINMM_SHORTNAME_WAVEOUT_W (LPWSTR)L"Wave Out"
45#define WINMM_SHORTNAME_LINEOUT_A "Line Out"
46#define WINMM_SHORTNAME_LINEOUT_W (LPWSTR)L"Line Out"
47
48#define SOUND_MIXER_LINEOUT 0
49#define SOUND_MIXER_WAVEOUT 1
50#define SOUND_MIXER_MAXID 2
51
52DWORD MIX_Volume[SOUND_MIXER_MAXID] = { 0x80008000, 0x80008000};
53DWORD MIX_Mute[SOUND_MIXER_MAXID] = { 0, 0};
54
55//
56// All Stubs
57//
58
59/**************************************************************************
60 * MIX_SplitControlID [internal]
61 */
62static BOOL MIX_SplitControlID(DWORD controlID, LPDWORD lineID, LPDWORD controlType)
63{
64 *lineID = controlID / 2;
65 *controlType = (controlID & 1) ?
66 MIXERCONTROL_CONTROLTYPE_MUTE : MIXERCONTROL_CONTROLTYPE_VOLUME;
67
68 return *lineID < SOUND_MIXER_MAXID;
69}
70/**************************************************************************
71 * MIX_MakeControlID [internal]
72 */
73static DWORD MIX_MakeControlID(DWORD lineID, DWORD controlType)
74{
75 switch (controlType) {
76 case MIXERCONTROL_CONTROLTYPE_VOLUME:
77 return 2 * lineID + 0;
78 case MIXERCONTROL_CONTROLTYPE_MUTE:
79 return 2 * lineID + 1;
80 }
81 dprintf(("MIX_MakeControlID: Internal error"));
82 return 0x00FADE00;
83}
84/**************************************************************************
85 * MIX_DoGetLineControls [internal]
86 */
87static void MIX_DoGetLineControls(LPMIXERCONTROLA mc, DWORD lineID, DWORD dwType)
88{
89 mc->cbStruct = sizeof(MIXERCONTROLA);
90
91 switch (dwType) {
92 case MIXERCONTROL_CONTROLTYPE_VOLUME:
93 mc->dwControlID = MIX_MakeControlID(lineID, dwType);
94 mc->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
95 mc->fdwControl = 0;
96 mc->cMultipleItems = 0;
97 lstrcpynA(mc->szShortName, "Vol", MIXER_SHORT_NAME_CHARS);
98 lstrcpynA(mc->szName, "Volume", MIXER_LONG_NAME_CHARS);
99 memset(&mc->Bounds, 0, sizeof(mc->Bounds));
100 mc->Bounds.s1.dwMinimum = 0;
101 mc->Bounds.s1.dwMaximum = 65535;
102 memset(&mc->Metrics, 0, sizeof(mc->Metrics));
103 break;
104 case MIXERCONTROL_CONTROLTYPE_MUTE:
105 mc->dwControlID = MIX_MakeControlID(lineID, dwType);
106 mc->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
107 mc->fdwControl = 0;
108 mc->cMultipleItems = 0;
109 lstrcpynA(mc->szShortName, "Mute", MIXER_SHORT_NAME_CHARS);
110 lstrcpynA(mc->szName, "Mute", MIXER_LONG_NAME_CHARS);
111 memset(&mc->Bounds, 0, sizeof(mc->Bounds));
112 memset(&mc->Metrics, 0, sizeof(mc->Metrics));
113 break;
114 default:
115 dprintf(("MIX_DoGetLineControls: Internal error: unknown type: %08lx\n", dwType));
116 }
117}
118/******************************************************************************/
119/******************************************************************************/
120MMRESULT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
121{
122 DWORD ret = MMSYSERR_NOTSUPPORTED;
123 DWORD lineID, controlType;
124
125 if (lpmcd == NULL) return MMSYSERR_INVALPARAM;
126
127 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
128 case MIXER_GETCONTROLDETAILSF_VALUE:
129 if(MIX_SplitControlID(lpmcd->dwControlID, &lineID, &controlType)) {
130 switch (controlType)
131 {
132 case MIXERCONTROL_CONTROLTYPE_VOLUME:
133 {
134 LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
135 int val;
136
137 /* return value is 00RL (4 bytes)... */
138 val = MIX_Volume[lineID];
139
140 switch (lpmcd->cChannels) {
141 case 1:
142 /* mono... so R = L */
143 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
144 mcdu->dwValue = LOWORD(val);
145 break;
146 case 2:
147 /* stereo, left is paDetails[0] */
148 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 0 * lpmcd->cbDetails);
149 mcdu->dwValue = LOWORD(val);
150 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 1 * lpmcd->cbDetails);
151 mcdu->dwValue = HIWORD(val);
152 break;
153 default:
154 dprintf(("Unknown cChannels (%ld)\n", lpmcd->cChannels));
155 return MMSYSERR_INVALPARAM;
156 }
157 }
158 break;
159 case MIXERCONTROL_CONTROLTYPE_MUTE:
160 {
161 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
162
163 /* we mute both channels at the same time */
164 mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
165 mcdb->fValue = MIX_Mute[lineID];
166 }
167 break;
168 }
169 ret = MMSYSERR_NOERROR;
170 } else {
171 ret = MMSYSERR_INVALPARAM;
172 }
173 break;
174 case MIXER_GETCONTROLDETAILSF_LISTTEXT:
175 dprintf(("mixerGetControlDetailsA: NIY\n"));
176 break;
177 default:
178 dprintf(("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK));
179 }
180 return ret;
181}
182/******************************************************************************/
183/******************************************************************************/
184MMRESULT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails)
185{
186 dprintf(("WINMM:mixerGetControlDetailsW - stub\n" ));
187 return MIXERR_INVALCONTROL;
188}
189/******************************************************************************/
190/******************************************************************************/
191MMRESULT WINAPI mixerSetControlDetails(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
192{
193 DWORD ret = MMSYSERR_NOTSUPPORTED;
194 DWORD lineID, controlType;
195 int val;
196
197 if (lpmcd == NULL) return MMSYSERR_INVALPARAM;
198
199 switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
200 case MIXER_GETCONTROLDETAILSF_VALUE:
201 if (MIX_SplitControlID(lpmcd->dwControlID, &lineID, &controlType)) {
202 switch (controlType) {
203 case MIXERCONTROL_CONTROLTYPE_VOLUME:
204 {
205 LPMIXERCONTROLDETAILS_UNSIGNED mcdu;
206
207 /* val should contain 00RL */
208 switch (lpmcd->cChannels) {
209 case 1:
210 /* mono... so R = L */
211 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
212 val = mcdu->dwValue;
213 break;
214 case 2:
215 /* stereo, left is paDetails[0] */
216 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 0 * lpmcd->cbDetails);
217 val = mcdu->dwValue;
218 mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 1 * lpmcd->cbDetails);
219 val += (mcdu->dwValue) << 16;
220 break;
221 default:
222 dprintf(("Unknown cChannels (%ld)\n", lpmcd->cChannels));
223 return MMSYSERR_INVALPARAM;
224 }
225
226 MIX_Volume[lineID] = val;
227 }
228 ret = MMSYSERR_NOERROR;
229 break;
230 case MIXERCONTROL_CONTROLTYPE_MUTE:
231 {
232 LPMIXERCONTROLDETAILS_BOOLEAN mcdb;
233
234 mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
235 MIX_Mute[lineID] = mcdb->fValue;
236 }
237 ret = MMSYSERR_NOERROR;
238 break;
239 }
240 }
241 break;
242 case MIXER_GETCONTROLDETAILSF_LISTTEXT:
243 dprintf(("mixerSetControlDetails: NIY\n"));
244 break;
245 default:
246 dprintf(("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK));
247 }
248 return MMSYSERR_NOTSUPPORTED;
249}
250/******************************************************************************/
251/******************************************************************************/
252MMRESULT WINAPI mixerGetLineControlsA(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA lpMlc, DWORD fdwControls)
253{
254 DWORD dwRet = MMSYSERR_NOERROR;
255 DWORD lineID, controlType;
256
257 if (lpMlc == NULL) return MMSYSERR_INVALPARAM;
258 if (lpMlc->cbStruct < sizeof(*lpMlc) ||
259 lpMlc->cbmxctrl < sizeof(MIXERCONTROLA))
260 return MMSYSERR_INVALPARAM;
261
262 switch(fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)
263 {
264 case MIXER_GETLINECONTROLSF_ALL:
265 if (lpMlc->cControls != 2) {
266 dwRet = MMSYSERR_INVALPARAM;
267 }
268 else {
269 MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
270 MIX_DoGetLineControls(&lpMlc->pamxctrl[1], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
271 }
272 break;
273 case MIXER_GETLINECONTROLSF_ONEBYID:
274 if (MIX_SplitControlID(lpMlc->u.dwControlID, &lineID, &controlType))
275 MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lineID, controlType);
276 else
277 dwRet = MMSYSERR_INVALPARAM;
278 break;
279 case MIXER_GETLINECONTROLSF_ONEBYTYPE:
280 switch (lpMlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK) {
281 case MIXERCONTROL_CT_CLASS_FADER:
282 MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
283 break;
284 case MIXERCONTROL_CT_CLASS_SWITCH:
285 MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
286 break;
287 default:
288 dwRet = MMSYSERR_INVALPARAM;
289 }
290 break;
291 default:
292 dprintf(("Unknown flag %08lx\n", fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK));
293 dwRet = MMSYSERR_INVALPARAM;
294 }
295
296 return dwRet;
297}
298/******************************************************************************/
299/******************************************************************************/
300MMRESULT WINAPI mixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls)
301{
302 dprintf(("WINMM:mixerGetGetLineControlsW - stub\n" ));
303 return MIXERR_INVALLINE;
304}
305/******************************************************************************/
306/******************************************************************************/
307MMRESULT WINAPI mixerGetDevCapsA(UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
308{
309 if(DartWaveOut::getNumDevices() == 0) {
310 memset(pmxcaps, 0, sizeof(*pmxcaps));
311 return MMSYSERR_NODRIVER;
312 }
313
314 // we have to fill in this thing
315 pmxcaps->wMid = 0; /* manufacturer ID */
316 pmxcaps->wPid = 0; /* product ID */
317 pmxcaps->vDriverVersion = 0x0001; /* version of the driver */
318 strcpy( pmxcaps->szPname, WINMM_MIXERSTRING_A); /* product name */
319
320 pmxcaps->fdwSupport = 0;
321 pmxcaps->cDestinations = 1;
322
323 return MMSYSERR_NOERROR;
324}
325/******************************************************************************/
326/******************************************************************************/
327MMRESULT WINAPI mixerGetDevCapsW(UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
328{
329 if(DartWaveOut::getNumDevices() == 0) {
330 memset(pmxcaps, 0, sizeof(*pmxcaps));
331 return MMSYSERR_NODRIVER;
332 }
333
334 // we have to fill in this thing
335 pmxcaps->wMid = 0; /* manufacturer ID */
336 pmxcaps->wPid = 0; /* product ID */
337 pmxcaps->vDriverVersion = 0x0001; /* version of the driver */
338 lstrcpyW( pmxcaps->szPname, WINMM_MIXERSTRING_W ); /* product name */
339
340 pmxcaps->fdwSupport = 0;
341 pmxcaps->cDestinations = 1;
342
343 return MMSYSERR_NOERROR;
344}
345/******************************************************************************/
346/******************************************************************************/
347MMRESULT WINAPI mixerGetID(HMIXEROBJ hmxobj, UINT * puMxId, DWORD fdwId)
348{
349 DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
350
351 if(pMixInfo && puMxId) {
352 *puMxId = pMixInfo->uDeviceID;
353 }
354 else *puMxId = 0;
355 return MMSYSERR_NOERROR;
356}
357/******************************************************************************/
358/******************************************************************************/
359MMRESULT WINAPI mixerGetLineInfoA(HMIXEROBJ hmxobj, LPMIXERLINEA lpMl, DWORD fdwInfo)
360{
361 if (lpMl == NULL || lpMl->cbStruct != sizeof(*lpMl))
362 return MMSYSERR_INVALPARAM;
363
364 /* FIXME: set all the variables correctly... the lines below
365 * are very wrong...
366 */
367 lpMl->fdwLine = MIXERLINE_LINEF_ACTIVE;
368 lpMl->cChannels = 1;
369 lpMl->dwUser = 0;
370 lpMl->cControls = 2;
371
372 switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
373 {
374 case MIXER_GETLINEINFOF_DESTINATION:
375 /* FIXME: Linux doesn't seem to support multiple outputs?
376 * So we have only one output type: Speaker.
377 */
378 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
379 lpMl->dwSource = 0xFFFFFFFF;
380 lpMl->dwLineID = SOUND_MIXER_LINEOUT;
381 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_LINEOUT_A, MIXER_SHORT_NAME_CHARS);
382 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_LINEOUT_A, MIXER_LONG_NAME_CHARS);
383
384 /* we have all connections found in the MIX_DevMask */
385 lpMl->cConnections = 1; //waveout
386 lpMl->cControls = 1;
387 lpMl->cChannels = 2;
388 break;
389
390 case MIXER_GETLINEINFOF_LINEID:
391 if(lpMl->dwLineID >= SOUND_MIXER_MAXID)
392 return MIXERR_INVALLINE;
393
394 lpMl->cChannels = 2;
395 lpMl->dwDestination = 0; /* index for speakers */
396 if(lpMl->dwLineID == SOUND_MIXER_WAVEOUT) {
397 lpMl->dwLineID = SOUND_MIXER_WAVEOUT;
398 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_SHORT_NAME_CHARS);
399 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_LONG_NAME_CHARS);
400 lpMl->cConnections = 0;
401 lpMl->cControls = 1;
402 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
403 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
404 }
405 else {
406 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
407 lpMl->dwSource = 0xFFFFFFFF;
408 lpMl->dwLineID = SOUND_MIXER_LINEOUT;
409 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_LINEOUT_A, MIXER_SHORT_NAME_CHARS);
410 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_LINEOUT_A, MIXER_LONG_NAME_CHARS);
411 lpMl->cConnections = 1;
412 lpMl->cControls = 1;
413 }
414 break;
415
416 case MIXER_GETLINEINFOF_SOURCE:
417 if(lpMl->dwSource != SOUND_MIXER_WAVEOUT)
418 return MIXERR_INVALLINE;
419
420 lpMl->dwLineID = SOUND_MIXER_WAVEOUT;
421 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_SHORT_NAME_CHARS);
422 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_LONG_NAME_CHARS);
423 lpMl->cConnections = 0;
424 lpMl->cControls = 1;
425 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
426 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
427 lpMl->cChannels = 2;
428 lpMl->dwLineID = SOUND_MIXER_WAVEOUT;
429 lpMl->dwDestination = 0; /* index for speakers */
430 break;
431
432 case MIXER_GETLINEINFOF_COMPONENTTYPE:
433 switch (lpMl->dwComponentType)
434 {
435 case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
436 lpMl->dwDestination = 0;
437 lpMl->dwSource = 0xFFFFFFFF;
438 lpMl->dwLineID = SOUND_MIXER_LINEOUT;
439 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_LINEOUT_A, MIXER_SHORT_NAME_CHARS);
440 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_LINEOUT_A, MIXER_LONG_NAME_CHARS);
441 break;
442 case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT:
443 lpMl->dwLineID = SOUND_MIXER_WAVEOUT;
444 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
445 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_SHORT_NAME_CHARS);
446 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_LONG_NAME_CHARS);
447 break;
448 default:
449 dprintf(("Unhandled component type (%08lx)\n", lpMl->dwComponentType));
450 return MMSYSERR_INVALPARAM;
451 }
452 lpMl->cConnections = 0;
453 lpMl->cControls = 1;
454 lpMl->cChannels = 2;
455 break;
456
457 case MIXER_GETLINEINFOF_TARGETTYPE:
458 dprintf(("_TARGETTYPE not implemented yet.\n"));
459 break;
460 default:
461 dprintf(("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK));
462 break;
463 }
464
465 lpMl->Target.dwType = MIXERLINE_TARGETTYPE_AUX;
466 lpMl->Target.dwDeviceID = 0xFFFFFFFF;
467 lpMl->Target.wMid = 0;
468 lpMl->Target.wPid = 0;
469 lpMl->Target.vDriverVersion = 1;
470 lstrcpyA(lpMl->Target.szPname, WINMM_MIXERSTRING_A);
471
472 return MMSYSERR_NOERROR;
473}
474
475/******************************************************************************/
476MMRESULT WINAPI mixerGetLineInfoW(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo)
477{
478 dprintf(("WINMM:mixerGetLineInfoW - stub\n" ));
479 return MIXERR_INVALLINE;
480}
481/******************************************************************************/
482/******************************************************************************/
483MMRESULT WINAPI mixerMessage(HMIXER hmx, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
484{
485 dprintf(("WINMM:mixerMessage - stub\n" ));
486 return 0;
487}
488/******************************************************************************/
489/******************************************************************************/
490UINT WINAPI mixerGetNumDevs()
491{
492 if(DartWaveOut::getNumDevices() == 0) {
493 return 0;
494 }
495 return 1;
496}
497/******************************************************************************/
498/******************************************************************************/
499MMRESULT WINAPI mixerOpen(LPHMIXER phmx, UINT uMxId, DWORD dwCallback, DWORD dwInstance,
500 DWORD fdwOpen)
501{
502 DEVICE_STRUCT *pMixInfo;
503
504 if(DartWaveOut::getNumDevices() == 0) {
505 if(phmx) *phmx = 0;
506 return MMSYSERR_NODRIVER;
507 }
508 pMixInfo = (DEVICE_STRUCT *)malloc(sizeof(DEVICE_STRUCT));
509 if(pMixInfo == NULL) {
510 return MMSYSERR_NODRIVER;
511 }
512 pMixInfo->dwCallback = dwCallback;
513 pMixInfo->dwDriverInstance = dwInstance;
514 pMixInfo->dwFlags = fdwOpen;
515 pMixInfo->uDeviceID = uMxId;
516 pMixInfo->type = WINMM_MIXER;
517 if(phmx)
518 *phmx = (HMIXER)pMixInfo;
519 return MMSYSERR_NOERROR;
520}
521/******************************************************************************/
522/******************************************************************************/
523MMRESULT WINAPI mixerClose(HMIXER hmx)
524{
525 if(hmx) {
526 free((void *)hmx);
527 }
528 return MMSYSERR_NOERROR;
529}
530/******************************************************************************/
531/******************************************************************************/
532
533
Note: See TracBrowser for help on using the repository browser.