source: trunk/src/winmm/mixeros2.cpp@ 8506

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

Implemented mixerSetControlDetails + mixer updates/fixes
File size: 18.9 KB
Line 
1/* $Id: mixeros2.cpp,v 1.6 2002-05-28 13:35:02 sandervl Exp $ */
2
3/*
4 * OS/2 Mixer multimedia
5 *
6 * Copyright 2002 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12
13#define INCL_BASE
14#define INCL_DOSERRORS
15#define INCL_DOSDEVIOCTL
16#define INCL_DOSFILEMGR
17#define INCL_OS2MM
18#include <os2wrap.h>
19#include <os2mewrap.h>
20#include <stdlib.h>
21#include <string.h>
22#include <dbglog.h>
23#include <ioctl90.h>
24
25#include "initwinmm.h"
26#include "mixeros2.h"
27
28static BOOL GetAudioPDDName (char *pszPDDName);
29static HFILE DevOpen (char *ddName);
30static BOOL mixerapiIOCTL90 (HFILE hPdd, ULONG ulFunc, PVOID pData, ULONG cbDataSize);
31
32static HFILE hPDDMix = 0;
33static char mixerApiMap[256] = {0};
34static int szVolumeLevels[MIX_CTRL_MAX][2] = {0};
35
36/******************************************************************************/
37/******************************************************************************/
38BOOL OSLibMixerOpen()
39{
40 char szPDDName[128] = "\\DEV\\";
41
42 if(GetAudioPDDName(&szPDDName[5]) == FALSE) {
43 return FALSE;
44 }
45
46 dprintf(("OSLibMixerOpen: PDD name %s", szPDDName));
47
48 hPDDMix = DevOpen(szPDDName);
49 if(hPDDMix == 0) {
50 dprintf(("Unable to open PDD %s", szPDDName));
51 return FALSE;
52 }
53 if(mixerapiIOCTL90(hPDDMix, GETAPIMAP, mixerApiMap, sizeof(mixerApiMap)) == FALSE) {
54 dprintf(("GETAPIMAP failed!!"));
55 DosClose(hPDDMix);
56 return FALSE;
57 }
58
59 memset(szVolumeLevels, -1, sizeof(szVolumeLevels));
60 return TRUE;
61}
62/******************************************************************************/
63/******************************************************************************/
64void OSLibMixerClose()
65{
66 if(hPDDMix) {
67 DosClose(hPDDMix);
68 }
69}
70/******************************************************************************/
71/******************************************************************************/
72static DWORD OSLibMixGetIndex(DWORD dwControl)
73{
74 DWORD idx;
75
76 switch(dwControl) {
77 case MIX_CTRL_VOL_IN_L_MONO:
78 case MIX_CTRL_MUTE_IN_L_MONO:
79 idx = MONOINSET;
80 break;
81 case MIX_CTRL_VOL_IN_L_PHONE:
82 case MIX_CTRL_MUTE_IN_L_PHONE:
83 idx = PHONESET;
84 break;
85 case MIX_CTRL_VOL_IN_L_MIC:
86 case MIX_CTRL_MUTE_IN_L_MIC:
87 idx = MICSET;
88 break;
89 case MIX_CTRL_VOL_IN_L_LINE:
90 case MIX_CTRL_MUTE_IN_L_LINE:
91 idx = LINESET;
92 break;
93 case MIX_CTRL_VOL_IN_L_CD:
94 case MIX_CTRL_MUTE_IN_L_CD:
95 idx = CDSET;
96 break;
97 case MIX_CTRL_VOL_IN_L_VIDEO:
98 case MIX_CTRL_MUTE_IN_L_VIDEO:
99 idx = VIDEOSET;
100 break;
101 case MIX_CTRL_VOL_IN_L_AUX:
102 case MIX_CTRL_MUTE_IN_L_AUX:
103 idx = AUXSET;
104 break;
105 case MIX_CTRL_OUT_L_BASS:
106 case MIX_CTRL_OUT_L_TREBLE:
107 idx = BASSTREBLESET;
108 break;
109 case MIX_CTRL_OUT_L_3DCENTER:
110 case MIX_CTRL_OUT_L_3DDEPTH:
111 idx = THREEDSET;
112 break;
113 case MIX_CTRL_VOL_IN_L_PCM:
114 case MIX_CTRL_MUTE_IN_L_PCM:
115 idx = STREAMVOLSET;
116 break;
117 case MIX_CTRL_MUX_IN_W_SRC:
118 idx = RECORDSRCSET;
119 break;
120 case MIX_CTRL_VOL_IN_W_MONO:
121 case MIX_CTRL_VOL_IN_W_PHONE:
122 case MIX_CTRL_VOL_IN_W_MIC:
123 case MIX_CTRL_VOL_IN_W_LINE:
124 case MIX_CTRL_VOL_IN_W_CD:
125 case MIX_CTRL_VOL_IN_W_VIDEO:
126 case MIX_CTRL_VOL_IN_W_AUX:
127 case MIX_CTRL_VOL_IN_W_PCM:
128 idx = RECORDGAINSET;
129 break;
130 default:
131 return -1;
132 }
133 return idx & 0xF;
134}
135/******************************************************************************/
136/******************************************************************************/
137BOOL OSLibMixIsControlPresent(DWORD dwControl)
138{
139 DWORD idx;
140
141 idx = OSLibMixGetIndex(dwControl);
142 if(idx == -1) {
143 return FALSE;
144 }
145 idx += MONOINSET;
146 return mixerApiMap[idx] != 0;
147}
148/******************************************************************************/
149/******************************************************************************/
150BOOL OSLibMixSetVolume(DWORD dwControl, DWORD dwVolLeft, DWORD dwVolRight)
151{
152 DWORD dwFunc, dwIOCT90VolLeft, dwIOCT90VolRight;
153 MIXSTRUCT mixstruct;
154
155 //TODO: implement master volume with MMPM2
156 if(dwControl == MIX_CTRL_VOL_OUT_LINE) {
157 return TRUE;
158 }
159
160 //wave in recording levels are virtual controls as there is only
161 //one control for recording gain
162 switch(dwControl) {
163 case MIX_CTRL_VOL_IN_W_MONO:
164 case MIX_CTRL_VOL_IN_W_PHONE:
165 case MIX_CTRL_VOL_IN_W_MIC:
166 case MIX_CTRL_VOL_IN_W_LINE:
167 case MIX_CTRL_VOL_IN_W_CD:
168 case MIX_CTRL_VOL_IN_W_VIDEO:
169 case MIX_CTRL_VOL_IN_W_AUX:
170 case MIX_CTRL_VOL_IN_W_PCM:
171 szVolumeLevels[dwControl][0] = dwVolLeft;
172 szVolumeLevels[dwControl][1] = dwVolRight;
173 break;
174 }
175 dwFunc = OSLibMixGetIndex(dwControl);
176 if(dwFunc == -1) {
177 return FALSE;
178 }
179 dwFunc += MONOINSET;
180
181 //first get current mute value
182 if(mixerapiIOCTL90(hPDDMix, dwFunc-MONOINSET+MONOINQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
183 return FALSE;
184 }
185
186 if(dwVolLeft > MIXER_WIN32_MAX_VOLUME || dwVolRight > MIXER_WIN32_MAX_VOLUME) {
187 dprintf(("OSLibMixSetVolume: Volume (%d,%d) out of RANGE!!", dwVolLeft, dwVolRight));
188 return FALSE;
189 }
190 if(dwControl == MIX_CTRL_OUT_L_TREBLE) {
191 //get bass value (right = treble, left = bass)
192 OSLibMixGetVolume(MIX_CTRL_OUT_L_BASS, &dwVolLeft, NULL);
193 }
194 else
195 if(dwControl == MIX_CTRL_OUT_L_BASS) {
196 //get treble value (right = treble, left = bass)
197 OSLibMixGetVolume(MIX_CTRL_OUT_L_TREBLE, &dwVolRight, NULL);
198 }
199
200 dwIOCT90VolLeft = WIN32_TO_IOCTL90_VOLUME(dwVolLeft);
201 dwIOCT90VolRight = WIN32_TO_IOCTL90_VOLUME(dwVolRight);
202
203 if(mixstruct.VolumeL == dwIOCT90VolLeft &&
204 mixstruct.VolumeR == dwIOCT90VolRight)
205 {
206 return TRUE; //nothing to do
207 }
208 //change volume levels
209 mixstruct.VolumeL = dwIOCT90VolLeft;
210 mixstruct.VolumeR = dwIOCT90VolRight;
211
212 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == TRUE) {
213 return TRUE;
214 }
215 dprintf(("OSLibMixSetVolume: mixerapiIOCTL90 %d failed!!", dwFunc));
216 return FALSE;
217}
218/******************************************************************************/
219/******************************************************************************/
220BOOL OSLibMixSetMute(DWORD dwControl, BOOL fMute)
221{
222 DWORD dwFunc;
223 MIXSTRUCT mixstruct;
224
225 //TODO: implement master volume with MMPM2
226 if(dwControl == MIX_CTRL_MUTE_OUT_LINE) {
227 return TRUE;
228 }
229
230 dwFunc = OSLibMixGetIndex(dwControl);
231 if(dwFunc == -1) {
232 return FALSE;
233 }
234 dwFunc += MONOINSET;
235
236 //first get current volume levels
237 if(mixerapiIOCTL90(hPDDMix, dwFunc-MONOINSET+MONOINQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
238 return FALSE;
239 }
240
241 if(mixstruct.Mute == fMute) {
242 return TRUE; //nothing to do
243 }
244
245 //change mute
246 mixstruct.Mute = fMute;
247
248 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == TRUE) {
249 return TRUE;
250 }
251 dprintf(("OSLibMixSetVolume: mixerapiIOCTL90 %d failed!!", dwFunc));
252 return FALSE;
253}
254/******************************************************************************/
255/******************************************************************************/
256BOOL OSLibMixGetVolume(DWORD dwControl, DWORD *pdwVolLeft, DWORD *pdwVolRight)
257{
258 DWORD dwFunc;
259 MIXSTRUCT mixstruct;
260
261 //TODO: implement master volume with MMPM2
262 if(dwControl == MIX_CTRL_VOL_OUT_LINE) {
263 if(pdwVolLeft) *pdwVolLeft = 50000;
264 if(pdwVolRight) *pdwVolRight = 50000;
265 return TRUE;
266 }
267
268 //wave in recording levels are virtual controls as there is only
269 //one control for recording gain
270 switch(dwControl) {
271 case MIX_CTRL_VOL_IN_W_MONO:
272 case MIX_CTRL_VOL_IN_W_PHONE:
273 case MIX_CTRL_VOL_IN_W_MIC:
274 case MIX_CTRL_VOL_IN_W_LINE:
275 case MIX_CTRL_VOL_IN_W_CD:
276 case MIX_CTRL_VOL_IN_W_VIDEO:
277 case MIX_CTRL_VOL_IN_W_AUX:
278 case MIX_CTRL_VOL_IN_W_PCM:
279 if(szVolumeLevels[dwControl][0] != -1) {
280 if(pdwVolLeft) *pdwVolLeft = szVolumeLevels[dwControl][0];
281 if(pdwVolRight) *pdwVolRight = szVolumeLevels[dwControl][1];
282 return TRUE;
283 }
284 break;
285 }
286
287 dwFunc = OSLibMixGetIndex(dwControl);
288 if(dwFunc == -1) {
289 return FALSE;
290 }
291 dwFunc += MONOINQUERY;
292
293 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == FALSE) {
294 return FALSE;
295 }
296 if(mixstruct.VolumeL > MIXER_IOCTL90_MAX_VOLUME || mixstruct.VolumeR > MIXER_IOCTL90_MAX_VOLUME) {
297 dprintf(("OSLibMixGetVolume: Volume (%d,%d) out of RANGE!!", mixstruct.VolumeL, mixstruct.VolumeR));
298 }
299 mixstruct.VolumeL = min(MIXER_IOCTL90_MAX_VOLUME, mixstruct.VolumeL);
300 mixstruct.VolumeR = min(MIXER_IOCTL90_MAX_VOLUME, mixstruct.VolumeR);
301
302 if(dwControl == MIX_CTRL_OUT_L_TREBLE) {
303 mixstruct.VolumeL = mixstruct.VolumeR; //right = treble, left = bass
304 }
305 else
306 if(dwControl == MIX_CTRL_OUT_L_BASS) {
307 mixstruct.VolumeR = mixstruct.VolumeL; //right = treble, left = bass
308 }
309
310 //save volume levels
311 szVolumeLevels[dwControl][0] = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeL);
312 szVolumeLevels[dwControl][1] = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeR);
313
314 if(pdwVolLeft) *pdwVolLeft = szVolumeLevels[dwControl][0];
315 if(pdwVolRight) *pdwVolRight = szVolumeLevels[dwControl][1];
316
317 return TRUE;
318}
319/******************************************************************************/
320/******************************************************************************/
321BOOL OSLibMixGetMute(DWORD dwControl, BOOL *pfMute)
322{
323 DWORD dwFunc;
324 MIXSTRUCT mixstruct;
325
326 //TODO: implement master volume with MMPM2
327 if(dwControl == MIX_CTRL_MUTE_OUT_LINE) {
328 if(pfMute) *pfMute = 0;
329 return TRUE;
330 }
331 dwFunc = OSLibMixGetIndex(dwControl);
332 if(dwFunc == -1) {
333 return FALSE;
334 }
335 dwFunc += MONOINQUERY;
336
337 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == FALSE) {
338 return FALSE;
339 }
340 if(pfMute) *pfMute = mixstruct.Mute;
341 return TRUE;
342}
343/******************************************************************************/
344/******************************************************************************/
345BOOL OSLibMixGetCtrlCaps(DWORD dwControl, LONG *plMinimum, LONG *plMaximum, DWORD *pcSteps)
346{
347 switch(dwControl) {
348 case MIX_CTRL_VOL_OUT_LINE:
349 *plMinimum = MIXER_WIN32_MIN_VOLUME;
350 *plMaximum = MIXER_WIN32_MAX_VOLUME;
351 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
352 break;
353
354 case MIX_CTRL_VOL_IN_L_MONO:
355 case MIX_CTRL_VOL_IN_L_PHONE:
356 case MIX_CTRL_VOL_IN_L_MIC:
357 case MIX_CTRL_VOL_IN_L_LINE:
358 case MIX_CTRL_VOL_IN_L_CD:
359 case MIX_CTRL_VOL_IN_L_VIDEO:
360 case MIX_CTRL_VOL_IN_L_AUX:
361 case MIX_CTRL_VOL_IN_L_PCM:
362 *plMinimum = MIXER_WIN32_MIN_VOLUME;
363 *plMaximum = MIXER_WIN32_MAX_VOLUME;
364 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
365 break;
366
367 case MIX_CTRL_VOL_IN_W_MONO:
368 case MIX_CTRL_VOL_IN_W_PHONE:
369 case MIX_CTRL_VOL_IN_W_MIC:
370 case MIX_CTRL_VOL_IN_W_LINE:
371 case MIX_CTRL_VOL_IN_W_CD:
372 case MIX_CTRL_VOL_IN_W_VIDEO:
373 case MIX_CTRL_VOL_IN_W_AUX:
374 case MIX_CTRL_VOL_IN_W_PCM:
375 *plMinimum = MIXER_WIN32_MIN_VOLUME;
376 *plMaximum = MIXER_WIN32_MAX_VOLUME;
377 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
378 break;
379
380 case MIX_CTRL_OUT_L_BASS:
381 case MIX_CTRL_OUT_L_TREBLE:
382 *plMinimum = MIXER_WIN32_MIN_VOLUME;
383 *plMaximum = MIXER_WIN32_MAX_VOLUME;
384 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
385 break;
386
387 case MIX_CTRL_OUT_L_3DCENTER:
388 case MIX_CTRL_OUT_L_3DDEPTH:
389 *plMinimum = MIXER_WIN32_MIN_VOLUME;
390 *plMaximum = MIXER_WIN32_MAX_VOLUME;
391 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
392 break;
393 default:
394 DebugInt3();
395 return FALSE;
396 }
397 return TRUE;
398}
399/******************************************************************************/
400/******************************************************************************/
401BOOL OSLibMixIsRecSourcePresent(DWORD dwRecSrc)
402{
403 if(OSLibMixSetRecSource(dwRecSrc) == FALSE) {
404 return FALSE;
405 }
406 return TRUE;
407}
408/******************************************************************************/
409/******************************************************************************/
410BOOL OSLibMixSetRecSource(DWORD dwRecSrc)
411{
412 DWORD idx, volidx;
413 MIXSTRUCT mixstruct;
414 DWORD dwVolL, dwVolR;
415
416 switch(dwRecSrc) {
417 case MIXER_SRC_IN_W_MIC:
418 idx = I90SRC_MIC;
419 volidx = MIX_CTRL_VOL_IN_W_MIC;
420 break;
421 case MIXER_SRC_IN_W_CD:
422 idx = I90SRC_CD;
423 volidx = MIX_CTRL_VOL_IN_W_CD;
424 break;
425 case MIXER_SRC_IN_W_VIDEO:
426 idx = I90SRC_VIDEO;
427 volidx = MIX_CTRL_VOL_IN_W_VIDEO;
428 break;
429 case MIXER_SRC_IN_W_AUX:
430 idx = I90SRC_AUX;
431 volidx = MIX_CTRL_VOL_IN_W_AUX;
432 break;
433 case MIXER_SRC_IN_W_LINE:
434 idx = I90SRC_LINE;
435 volidx = MIX_CTRL_VOL_IN_W_LINE;
436 break;
437 case MIXER_SRC_IN_W_PHONE:
438 idx = I90SRC_PHONE;
439 volidx = MIX_CTRL_VOL_IN_W_PHONE;
440 break;
441 default:
442 return FALSE;
443 }
444 mixstruct.Mute = 0;
445 mixstruct.VolumeL = idx;
446
447 //select recording source
448 if(mixerapiIOCTL90(hPDDMix, RECORDSRCSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
449 dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCSET failed!!"));
450 return FALSE;
451 }
452
453 dwVolL = szVolumeLevels[volidx][0];
454 dwVolR = szVolumeLevels[volidx][1];
455 mixstruct.VolumeL = WIN32_TO_IOCTL90_VOLUME(dwVolL);
456 mixstruct.VolumeR = WIN32_TO_IOCTL90_VOLUME(dwVolR);
457 mixstruct.Mute = 0;
458
459 //set recording gain to that of the selected source
460 if(mixerapiIOCTL90(hPDDMix, RECORDGAINSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
461 dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDGAINSET failed!!"));
462 return FALSE;
463 }
464 return TRUE;
465}
466/******************************************************************************/
467/******************************************************************************/
468BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc)
469{
470 DWORD idx;
471 MIXSTRUCT mixstruct;
472
473 if(mixerapiIOCTL90(hPDDMix, RECORDSRCQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
474 dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCGET failed!!"));
475 return FALSE;
476 }
477 switch(mixstruct.VolumeL) {
478 case I90SRC_MIC:
479 idx = MIXER_SRC_IN_W_MIC;
480 break;
481 case I90SRC_CD:
482 idx = MIXER_SRC_IN_W_CD;
483 break;
484 case I90SRC_VIDEO:
485 idx = MIXER_SRC_IN_W_VIDEO;
486 break;
487 case I90SRC_AUX:
488 idx = MIXER_SRC_IN_W_AUX;
489 break;
490 case I90SRC_LINE:
491 idx = MIXER_SRC_IN_W_LINE;
492 break;
493 case I90SRC_PHONE:
494 idx = MIXER_SRC_IN_W_PHONE;
495 break;
496 default:
497 DebugInt3();
498 return FALSE;
499 }
500 if(pdwRecSrc) {
501 *pdwRecSrc = idx;
502 }
503 return TRUE;
504}
505/******************************************************************************/
506// OS/2 32-bit program to query the Physical Device Driver name
507// for the default MMPM/2 WaveAudio device. Joe Nord 10-Mar-1999
508/******************************************************************************/
509static HFILE DevOpen (char *ddName)
510{
511 ULONG ulRC;
512 ULONG OpenFlags;
513 ULONG OpenMode;
514 ULONG ulFileSize = 0;
515 ULONG ulFileAttribute = 0;
516 ULONG ulActionTaken = 0;
517 HFILE hPdd = NULL;
518
519 OpenFlags = OPEN_ACTION_OPEN_IF_EXISTS; // Do not create file
520
521 OpenMode = OPEN_ACCESS_READWRITE + // Read/Write file
522 OPEN_SHARE_DENYNONE + // Non-exclusive access
523 OPEN_FLAGS_FAIL_ON_ERROR; // No system popups on errors
524
525 ulRC = DosOpen (ddName, // in
526 &hPdd, // out (handle)
527 &ulActionTaken, // out
528 ulFileSize, // in
529 ulFileAttribute, // in
530 OpenFlags, // in
531 OpenMode, // in
532 NULL); // in
533
534 if (ulRC != 0)
535 hPdd = NULL;
536
537 return (hPdd);
538}
539/******************************************************************************/
540/******************************************************************************/
541static BOOL mixerapiIOCTL90 (HFILE hPdd, ULONG ulFunc, PVOID pData, ULONG cbDataSize)
542{
543 ULONG ulRC;
544
545 ulRC = DosDevIOCtl
546 (hPdd, // Device Handle
547 0x90, // Category (user defined >= 0x80)
548 ulFunc, // Function Use defines in .H file
549 NULL, // in Address of parm data (not used)
550 0, // in Max size of parm data structure
551 NULL, // in out Actual size of parm data structure
552 pData, // in Address of command data
553 cbDataSize, // in Maximum size of command data
554 &cbDataSize); // in out Size of command data
555
556 return ulRC == NO_ERROR;
557}
558/******************************************************************************/
559// OS/2 32-bit program to query the Physical Device Driver name
560// for the default MMPM/2 WaveAudio device. Joe Nord 10-Mar-1999
561/******************************************************************************/
562static BOOL GetAudioPDDName (char *pszPDDName)
563{
564 ULONG ulRC;
565 char szAmpMix[9] = "AMPMIX01";
566
567 MCI_SYSINFO_PARMS SysInfo;
568 MCI_SYSINFO_LOGDEVICE SysInfoParm;
569 MCI_SYSINFO_QUERY_NAME QueryNameParm;
570
571 memset (&SysInfo, '\0', sizeof(SysInfo));
572 memset (&SysInfoParm, '\0', sizeof(SysInfoParm));
573 memset (&QueryNameParm, '\0', sizeof(QueryNameParm));
574
575 SysInfo.ulItem = MCI_SYSINFO_QUERY_NAMES;
576 SysInfo.usDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
577 SysInfo.pSysInfoParm = &QueryNameParm;
578
579 strcpy (QueryNameParm.szLogicalName, szAmpMix);
580
581 ulRC = mymciSendCommand (0,
582 MCI_SYSINFO,
583 MCI_SYSINFO_ITEM | MCI_WAIT,
584 (PVOID) &SysInfo,
585 0);
586 if (ulRC != 0) return FALSE;
587
588 // Get PDD associated with our AmpMixer
589 // Device name is in pSysInfoParm->szPDDName
590
591 SysInfo.ulItem = MCI_SYSINFO_QUERY_DRIVER;
592 SysInfo.usDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
593 SysInfo.pSysInfoParm = &SysInfoParm;
594
595 strcpy (SysInfoParm.szInstallName, QueryNameParm.szInstallName);
596
597 ulRC = mymciSendCommand (0,
598 MCI_SYSINFO,
599 MCI_SYSINFO_ITEM | MCI_WAIT,
600 (PVOID) &SysInfo,
601 0);
602 if (ulRC != 0) return FALSE;
603
604 strcpy (pszPDDName, SysInfoParm.szPDDName);
605
606 return TRUE;
607}
608/******************************************************************************/
609/******************************************************************************/
610
Note: See TracBrowser for help on using the repository browser.