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

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

some cleanup
File size: 23.4 KB
Line 
1/* $Id: mixeros2.cpp,v 1.9 2002-07-12 08:12:30 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(OSLibGetAudioPDDName(&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 dprintf(("OSLibMixSetMute (%d,%d) %d", mixstruct.VolumeL, mixstruct.VolumeR, mixstruct.Mute));
320 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == TRUE) {
321 return TRUE;
322 }
323 dprintf(("OSLibMixSetMute: mixerapiIOCTL90 %d failed!!", dwFunc));
324 return FALSE;
325}
326/******************************************************************************/
327/******************************************************************************/
328BOOL OSLibMixGetVolume(DWORD dwControl, DWORD *pdwVolLeft, DWORD *pdwVolRight)
329{
330 DWORD dwFunc;
331 MIXSTRUCT mixstruct;
332
333 //Master volume/mute can't be controlled with ioctl90
334 if(dwControl == MIX_CTRL_VOL_OUT_LINE)
335 {
336 if(pdwVolLeft) *pdwVolLeft = szVolumeLevels[MIX_CTRL_VOL_OUT_LINE][0];
337 if(pdwVolRight) *pdwVolRight = szVolumeLevels[MIX_CTRL_VOL_OUT_LINE][1];
338
339 return TRUE;
340 }
341
342 //wave in recording levels are virtual controls as there is only
343 //one control for recording gain
344 switch(dwControl) {
345 case MIX_CTRL_VOL_IN_W_MONO:
346 case MIX_CTRL_VOL_IN_W_PHONE:
347 case MIX_CTRL_VOL_IN_W_MIC:
348 case MIX_CTRL_VOL_IN_W_LINE:
349 case MIX_CTRL_VOL_IN_W_CD:
350 case MIX_CTRL_VOL_IN_W_VIDEO:
351 case MIX_CTRL_VOL_IN_W_AUX:
352 case MIX_CTRL_VOL_IN_W_PCM:
353 if(szVolumeLevels[dwControl][0] != -1) {
354 if(pdwVolLeft) *pdwVolLeft = szVolumeLevels[dwControl][0];
355 if(pdwVolRight) *pdwVolRight = szVolumeLevels[dwControl][1];
356 return TRUE;
357 }
358 break;
359 }
360
361 dwFunc = OSLibMixGetIndex(dwControl);
362 if(dwFunc == -1) {
363 return FALSE;
364 }
365 dwFunc += MONOINQUERY;
366
367 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == FALSE) {
368 return FALSE;
369 }
370 if(mixstruct.VolumeL > MIXER_IOCTL90_MAX_VOLUME || mixstruct.VolumeR > MIXER_IOCTL90_MAX_VOLUME) {
371 dprintf(("OSLibMixGetVolume: Volume (%d,%d) out of RANGE!!", mixstruct.VolumeL, mixstruct.VolumeR));
372 }
373 mixstruct.VolumeL = min(MIXER_IOCTL90_MAX_VOLUME, mixstruct.VolumeL);
374 if(dwFunc == RECORDGAINSET) {
375 mixstruct.VolumeR = mixstruct.VolumeL; //only left is valid
376 }
377 else mixstruct.VolumeR = min(MIXER_IOCTL90_MAX_VOLUME, mixstruct.VolumeR);
378
379 if(dwControl == MIX_CTRL_OUT_L_TREBLE) {
380 mixstruct.VolumeL = mixstruct.VolumeR; //right = treble, left = bass
381 }
382 else
383 if(dwControl == MIX_CTRL_OUT_L_BASS) {
384 mixstruct.VolumeR = mixstruct.VolumeL; //right = treble, left = bass
385 }
386
387 //save volume levels
388 szVolumeLevels[dwControl][0] = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeL);
389 szVolumeLevels[dwControl][1] = IOCTL90_TO_WIN32_VOLUME(mixstruct.VolumeR);
390
391 if(pdwVolLeft) *pdwVolLeft = szVolumeLevels[dwControl][0];
392 if(pdwVolRight) *pdwVolRight = szVolumeLevels[dwControl][1];
393
394 return TRUE;
395}
396/******************************************************************************/
397/******************************************************************************/
398BOOL OSLibMixGetMute(DWORD dwControl, BOOL *pfMute)
399{
400 DWORD dwFunc;
401 MIXSTRUCT mixstruct;
402
403 //Master volume/mute can't be controlled with ioctl90
404 if(dwControl == MIX_CTRL_MUTE_OUT_LINE)
405 {
406 if(pfMute) *pfMute = szVolumeLevels[MIX_CTRL_MUTE_OUT_LINE][0];
407
408 return TRUE;
409 }
410
411 dwFunc = OSLibMixGetIndex(dwControl);
412 if(dwFunc == -1) {
413 return FALSE;
414 }
415 dwFunc += MONOINQUERY;
416
417 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == FALSE) {
418 return FALSE;
419 }
420 if(pfMute) *pfMute = mixstruct.Mute;
421 return TRUE;
422}
423/******************************************************************************/
424/******************************************************************************/
425BOOL OSLibMixGetLineCaps(DWORD dwLine, DWORD *pcChannels)
426{
427 switch(dwLine) {
428 case MIXER_SRC_IN_L_MONOIN:
429 case MIXER_SRC_IN_W_MONOIN:
430 case MIXER_SRC_IN_L_PHONE:
431 case MIXER_SRC_IN_W_PHONE:
432 case MIXER_SRC_IN_L_MIC:
433 case MIXER_SRC_IN_W_MIC:
434 *pcChannels = 1;
435 break;
436
437 case MIXER_SRC_IN_W_LINE:
438 case MIXER_SRC_IN_W_CD:
439 case MIXER_SRC_IN_W_SPDIF:
440 case MIXER_SRC_IN_W_VIDEO:
441 case MIXER_SRC_IN_W_AUX:
442 case MIXER_SRC_IN_W_PCM:
443 case MIXER_SRC_IN_W_WAVETABLE:
444 case MIXER_SRC_IN_W_MIDI:
445 *pcChannels = 2;
446 break;
447
448 case MIXER_SRC_IN_L_LINE:
449 case MIXER_SRC_IN_L_CD:
450 case MIXER_SRC_IN_L_SPDIF:
451 case MIXER_SRC_IN_L_VIDEO:
452 case MIXER_SRC_IN_L_AUX:
453 case MIXER_SRC_IN_L_PCM:
454 case MIXER_SRC_IN_L_WAVETABLE:
455 case MIXER_SRC_IN_L_MIDI:
456 *pcChannels = 2;
457 break;
458 default:
459 DebugInt3();
460 return FALSE;
461 }
462
463 return TRUE;
464}
465/******************************************************************************/
466/******************************************************************************/
467BOOL OSLibMixGetCtrlCaps(DWORD dwControl, LONG *plMinimum, LONG *plMaximum, DWORD *pcSteps)
468{
469 switch(dwControl) {
470 case MIX_CTRL_VOL_OUT_LINE:
471 *plMinimum = MIXER_WIN32_MIN_VOLUME;
472 *plMaximum = MIXER_WIN32_MAX_VOLUME;
473 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
474 break;
475
476 case MIX_CTRL_VOL_IN_L_MONO:
477 case MIX_CTRL_VOL_IN_L_PHONE:
478 case MIX_CTRL_VOL_IN_L_MIC:
479 case MIX_CTRL_VOL_IN_L_LINE:
480 case MIX_CTRL_VOL_IN_L_CD:
481 case MIX_CTRL_VOL_IN_L_VIDEO:
482 case MIX_CTRL_VOL_IN_L_AUX:
483 case MIX_CTRL_VOL_IN_L_PCM:
484 *plMinimum = MIXER_WIN32_MIN_VOLUME;
485 *plMaximum = MIXER_WIN32_MAX_VOLUME;
486 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
487 break;
488
489 case MIX_CTRL_VOL_IN_W_MONO:
490 case MIX_CTRL_VOL_IN_W_PHONE:
491 case MIX_CTRL_VOL_IN_W_MIC:
492 case MIX_CTRL_VOL_IN_W_LINE:
493 case MIX_CTRL_VOL_IN_W_CD:
494 case MIX_CTRL_VOL_IN_W_VIDEO:
495 case MIX_CTRL_VOL_IN_W_AUX:
496 case MIX_CTRL_VOL_IN_W_PCM:
497 *plMinimum = MIXER_WIN32_MIN_VOLUME;
498 *plMaximum = MIXER_WIN32_MAX_VOLUME;
499 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
500 break;
501
502 case MIX_CTRL_OUT_L_BASS:
503 case MIX_CTRL_OUT_L_TREBLE:
504 *plMinimum = MIXER_WIN32_MIN_VOLUME;
505 *plMaximum = MIXER_WIN32_MAX_VOLUME;
506 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
507 break;
508
509 case MIX_CTRL_OUT_L_3DCENTER:
510 case MIX_CTRL_OUT_L_3DDEPTH:
511 *plMinimum = MIXER_WIN32_MIN_VOLUME;
512 *plMaximum = MIXER_WIN32_MAX_VOLUME;
513 *pcSteps = MIXER_WIN32_CSTEP_VOLUME;
514 break;
515 default:
516 DebugInt3();
517 return FALSE;
518 }
519 return TRUE;
520}
521/******************************************************************************/
522/******************************************************************************/
523BOOL OSLibMixIsRecSourcePresent(DWORD dwRecSrc)
524{
525 DWORD oldRecSrc;
526 BOOL ret = TRUE;
527
528 OSLibMixGetRecSource(&oldRecSrc);
529
530 if(OSLibMixSetRecSource(dwRecSrc) == FALSE) {
531 ret = FALSE;
532 }
533 OSLibMixSetRecSource(oldRecSrc);
534 return ret;
535}
536/******************************************************************************/
537/******************************************************************************/
538BOOL OSLibMixSetRecSource(DWORD dwRecSrc)
539{
540 DWORD idx, volidx;
541 MIXSTRUCT mixstruct;
542 DWORD dwVolL, dwVolR;
543
544 switch(dwRecSrc) {
545 case MIXER_SRC_IN_W_MIC:
546 idx = I90SRC_MIC;
547 volidx = MIX_CTRL_VOL_IN_W_MIC;
548 break;
549 case MIXER_SRC_IN_W_CD:
550 idx = I90SRC_CD;
551 volidx = MIX_CTRL_VOL_IN_W_CD;
552 break;
553 case MIXER_SRC_IN_W_VIDEO:
554 idx = I90SRC_VIDEO;
555 volidx = MIX_CTRL_VOL_IN_W_VIDEO;
556 break;
557 case MIXER_SRC_IN_W_AUX:
558 idx = I90SRC_AUX;
559 volidx = MIX_CTRL_VOL_IN_W_AUX;
560 break;
561 case MIXER_SRC_IN_W_LINE:
562 idx = I90SRC_LINE;
563 volidx = MIX_CTRL_VOL_IN_W_LINE;
564 break;
565 case MIXER_SRC_IN_W_PHONE:
566 idx = I90SRC_PHONE;
567 volidx = MIX_CTRL_VOL_IN_W_PHONE;
568 break;
569 default:
570 return FALSE;
571 }
572 mixstruct.Mute = 0;
573 mixstruct.VolumeL = idx;
574
575 //select recording source
576 if(mixerapiIOCTL90(hPDDMix, RECORDSRCSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
577 dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCSET failed!!"));
578 return FALSE;
579 }
580
581 if(szVolumeLevels[volidx][0] != -1)
582 {//if changed, override recording gain
583 dwVolL = szVolumeLevels[volidx][0];
584 dwVolR = szVolumeLevels[volidx][1];
585 mixstruct.VolumeL = WIN32_TO_IOCTL90_VOLUME(dwVolL);
586 mixstruct.VolumeR = WIN32_TO_IOCTL90_VOLUME(dwVolR);
587 mixstruct.Mute = 0;
588
589 //set recording gain to that of the selected source
590 dprintf(("set recording gain to (%d,%d)", mixstruct.VolumeL, mixstruct.VolumeR));
591 if(mixerapiIOCTL90(hPDDMix, RECORDGAINSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
592 dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDGAINSET failed!!"));
593 return FALSE;
594 }
595 }
596 return TRUE;
597}
598/******************************************************************************/
599/******************************************************************************/
600BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc)
601{
602 DWORD idx;
603 MIXSTRUCT mixstruct;
604
605 if(mixerapiIOCTL90(hPDDMix, RECORDSRCQUERY, &mixstruct, sizeof(mixstruct)) == FALSE) {
606 dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCGET failed!!"));
607 return FALSE;
608 }
609 switch(mixstruct.VolumeL) {
610 case I90SRC_MIC:
611 idx = MIXER_SRC_IN_W_MIC;
612 break;
613 case I90SRC_CD:
614 idx = MIXER_SRC_IN_W_CD;
615 break;
616 case I90SRC_VIDEO:
617 idx = MIXER_SRC_IN_W_VIDEO;
618 break;
619 case I90SRC_AUX:
620 idx = MIXER_SRC_IN_W_AUX;
621 break;
622 case I90SRC_LINE:
623 idx = MIXER_SRC_IN_W_LINE;
624 break;
625 case I90SRC_PHONE:
626 idx = MIXER_SRC_IN_W_PHONE;
627 break;
628 default:
629 DebugInt3();
630 return FALSE;
631 }
632 if(pdwRecSrc) {
633 *pdwRecSrc = idx;
634 }
635 return TRUE;
636}
637/******************************************************************************/
638// OS/2 32-bit program to query the Physical Device Driver name
639// for the default MMPM/2 WaveAudio device. Joe Nord 10-Mar-1999
640/******************************************************************************/
641static HFILE DevOpen (char *ddName)
642{
643 ULONG ulRC;
644 ULONG OpenFlags;
645 ULONG OpenMode;
646 ULONG ulFileSize = 0;
647 ULONG ulFileAttribute = 0;
648 ULONG ulActionTaken = 0;
649 HFILE hPdd = NULL;
650
651 OpenFlags = OPEN_ACTION_OPEN_IF_EXISTS; // Do not create file
652
653 OpenMode = OPEN_ACCESS_READWRITE + // Read/Write file
654 OPEN_SHARE_DENYNONE + // Non-exclusive access
655 OPEN_FLAGS_FAIL_ON_ERROR; // No system popups on errors
656
657 ulRC = DosOpen (ddName, // in
658 &hPdd, // out (handle)
659 &ulActionTaken, // out
660 ulFileSize, // in
661 ulFileAttribute, // in
662 OpenFlags, // in
663 OpenMode, // in
664 NULL); // in
665
666 if (ulRC != 0)
667 hPdd = NULL;
668
669 return (hPdd);
670}
671/******************************************************************************/
672/******************************************************************************/
673static BOOL mixerapiIOCTL90 (HFILE hPdd, ULONG ulFunc, PVOID pData, ULONG cbDataSize)
674{
675 ULONG ulRC;
676
677 ulRC = DosDevIOCtl
678 (hPdd, // Device Handle
679 0x90, // Category (user defined >= 0x80)
680 ulFunc, // Function Use defines in .H file
681 NULL, // in Address of parm data (not used)
682 0, // in Max size of parm data structure
683 NULL, // in out Actual size of parm data structure
684 pData, // in Address of command data
685 cbDataSize, // in Maximum size of command data
686 &cbDataSize); // in out Size of command data
687
688 return ulRC == NO_ERROR;
689}
690/******************************************************************************/
691// OS/2 32-bit program to query the Physical Device Driver name
692// for the default MMPM/2 WaveAudio device. Joe Nord 10-Mar-1999
693/******************************************************************************/
694BOOL OSLibGetAudioPDDName (char *pszPDDName)
695{
696 ULONG ulRC;
697 char szAmpMix[9] = "AMPMIX01";
698
699 MCI_SYSINFO_PARMS SysInfo;
700 MCI_SYSINFO_LOGDEVICE SysInfoParm;
701 MCI_SYSINFO_QUERY_NAME QueryNameParm;
702
703 memset (&SysInfo, '\0', sizeof(SysInfo));
704 memset (&SysInfoParm, '\0', sizeof(SysInfoParm));
705 memset (&QueryNameParm, '\0', sizeof(QueryNameParm));
706
707 SysInfo.ulItem = MCI_SYSINFO_QUERY_NAMES;
708 SysInfo.usDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
709 SysInfo.pSysInfoParm = &QueryNameParm;
710
711 strcpy (QueryNameParm.szLogicalName, szAmpMix);
712
713 ulRC = mymciSendCommand (0,
714 MCI_SYSINFO,
715 MCI_SYSINFO_ITEM | MCI_WAIT,
716 (PVOID) &SysInfo,
717 0);
718 if (ulRC != 0) return FALSE;
719
720 // Get PDD associated with our AmpMixer
721 // Device name is in pSysInfoParm->szPDDName
722
723 SysInfo.ulItem = MCI_SYSINFO_QUERY_DRIVER;
724 SysInfo.usDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
725 SysInfo.pSysInfoParm = &SysInfoParm;
726
727 strcpy (SysInfoParm.szInstallName, QueryNameParm.szInstallName);
728
729 ulRC = mymciSendCommand (0,
730 MCI_SYSINFO,
731 MCI_SYSINFO_ITEM | MCI_WAIT,
732 (PVOID) &SysInfo,
733 0);
734 if (ulRC != 0) return FALSE;
735
736 strcpy (pszPDDName, SysInfoParm.szPDDName);
737
738 return TRUE;
739}
740/******************************************************************************/
741/******************************************************************************/
742
Note: See TracBrowser for help on using the repository browser.