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

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

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