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

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

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