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

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

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