source: trunk/src/winmm/mixeros2.cpp

Last change on this file was 21916, checked in by dmik, 14 years ago

Merge branch gcc-kmk to trunk.
File size: 23.5 KB
RevLine 
[8858]1/* $Id: mixeros2.cpp,v 1.10 2002-07-12 09:21:27 sandervl Exp $ */
[8472]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
[21916]25#include "initterm.h"
[8472]26#include "mixeros2.h"
27
[8510]28#ifndef LOWORD
29#define LOWORD(a) (a & 0xffff)
30#endif
31
[8472]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};
[8506]38static int szVolumeLevels[MIX_CTRL_MAX][2] = {0};
[8472]39
40/******************************************************************************/
41/******************************************************************************/
42BOOL OSLibMixerOpen()
43{
44 char szPDDName[128] = "\\DEV\\";
45
[8855]46 if(OSLibGetAudioPDDName(&szPDDName[5]) == FALSE) {
[8472]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 }
[8858]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;
[8472]60 if(mixerapiIOCTL90(hPDDMix, GETAPIMAP, mixerApiMap, sizeof(mixerApiMap)) == FALSE) {
61 dprintf(("GETAPIMAP failed!!"));
62 DosClose(hPDDMix);
63 return FALSE;
64 }
65
[8506]66 memset(szVolumeLevels, -1, sizeof(szVolumeLevels));
[8510]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 }
[8530]86
[8472]87 return TRUE;
88}
89/******************************************************************************/
90/******************************************************************************/
91void OSLibMixerClose()
92{
93 if(hPDDMix) {
[8530]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
[8472]123 DosClose(hPDDMix);
124 }
125}
126/******************************************************************************/
127/******************************************************************************/
128static DWORD OSLibMixGetIndex(DWORD dwControl)
129{
130 DWORD idx;
131
132 switch(dwControl) {
[8477]133 case MIX_CTRL_VOL_IN_L_MONO:
134 case MIX_CTRL_MUTE_IN_L_MONO:
[8472]135 idx = MONOINSET;
136 break;
[8477]137 case MIX_CTRL_VOL_IN_L_PHONE:
138 case MIX_CTRL_MUTE_IN_L_PHONE:
[8472]139 idx = PHONESET;
140 break;
[8477]141 case MIX_CTRL_VOL_IN_L_MIC:
142 case MIX_CTRL_MUTE_IN_L_MIC:
[8472]143 idx = MICSET;
144 break;
[8477]145 case MIX_CTRL_VOL_IN_L_LINE:
146 case MIX_CTRL_MUTE_IN_L_LINE:
[8472]147 idx = LINESET;
148 break;
[8477]149 case MIX_CTRL_VOL_IN_L_CD:
150 case MIX_CTRL_MUTE_IN_L_CD:
[8472]151 idx = CDSET;
152 break;
[8477]153 case MIX_CTRL_VOL_IN_L_VIDEO:
154 case MIX_CTRL_MUTE_IN_L_VIDEO:
[8472]155 idx = VIDEOSET;
156 break;
[8477]157 case MIX_CTRL_VOL_IN_L_AUX:
158 case MIX_CTRL_MUTE_IN_L_AUX:
[8472]159 idx = AUXSET;
160 break;
[8477]161 case MIX_CTRL_OUT_L_BASS:
162 case MIX_CTRL_OUT_L_TREBLE:
[8472]163 idx = BASSTREBLESET;
164 break;
[8477]165 case MIX_CTRL_OUT_L_3DCENTER:
166 case MIX_CTRL_OUT_L_3DDEPTH:
[8472]167 idx = THREEDSET;
168 break;
[8477]169 case MIX_CTRL_VOL_IN_L_PCM:
170 case MIX_CTRL_MUTE_IN_L_PCM:
[8472]171 idx = STREAMVOLSET;
172 break;
[8477]173 case MIX_CTRL_MUX_IN_W_SRC:
[8472]174 idx = RECORDSRCSET;
175 break;
[8492]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;
[8472]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);
[8510]198 if(idx == -1) {
[8472]199 return FALSE;
200 }
201 idx += MONOINSET;
202 return mixerApiMap[idx] != 0;
203}
204/******************************************************************************/
205/******************************************************************************/
[8506]206BOOL OSLibMixSetVolume(DWORD dwControl, DWORD dwVolLeft, DWORD dwVolRight)
[8472]207{
[8506]208 DWORD dwFunc, dwIOCT90VolLeft, dwIOCT90VolRight;
[8472]209 MIXSTRUCT mixstruct;
210
[8510]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
[8492]237 return TRUE;
238 }
239
[8472]240 dwFunc = OSLibMixGetIndex(dwControl);
241 if(dwFunc == -1) {
242 return FALSE;
243 }
244 dwFunc += MONOINSET;
245
[8506]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 }
[8472]260
[8530]261 dwIOCT90VolLeft = WIN32_TO_IOCTL90_VOLUME(dwVolLeft);
[8506]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
[8472]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/******************************************************************************/
[8506]281BOOL OSLibMixSetMute(DWORD dwControl, BOOL fMute)
[8472]282{
283 DWORD dwFunc;
284 MIXSTRUCT mixstruct;
285
[8510]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
[8506]293 if(dwControl == MIX_CTRL_MUTE_OUT_LINE) {
[8510]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
[8506]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
[8855]322 dprintf(("OSLibMixSetMute (%d,%d) %d", mixstruct.VolumeL, mixstruct.VolumeR, mixstruct.Mute));
[8506]323 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == TRUE) {
324 return TRUE;
325 }
[8855]326 dprintf(("OSLibMixSetMute: mixerapiIOCTL90 %d failed!!", dwFunc));
[8506]327 return FALSE;
328}
329/******************************************************************************/
330/******************************************************************************/
331BOOL OSLibMixGetVolume(DWORD dwControl, DWORD *pdwVolLeft, DWORD *pdwVolRight)
332{
333 DWORD dwFunc;
334 MIXSTRUCT mixstruct;
335
[8510]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
[8492]342 return TRUE;
343 }
344
[8506]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
[8472]364 dwFunc = OSLibMixGetIndex(dwControl);
365 if(dwFunc == -1) {
366 return FALSE;
367 }
368 dwFunc += MONOINQUERY;
369
[8485]370 if(mixerapiIOCTL90(hPDDMix, dwFunc, &mixstruct, sizeof(mixstruct)) == FALSE) {
371 return FALSE;
[8472]372 }
[8492]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);
[8530]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);
[8492]381
[8506]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 }
[8472]389
[8506]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
[8492]397 return TRUE;
398}
399/******************************************************************************/
400/******************************************************************************/
[8506]401BOOL OSLibMixGetMute(DWORD dwControl, BOOL *pfMute)
402{
403 DWORD dwFunc;
404 MIXSTRUCT mixstruct;
405
[8510]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
[8506]411 return TRUE;
412 }
[8510]413
[8506]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/******************************************************************************/
[8855]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/******************************************************************************/
[8492]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();
[8472]520 return FALSE;
521 }
[8485]522 return TRUE;
[8472]523}
524/******************************************************************************/
525/******************************************************************************/
[8477]526BOOL OSLibMixIsRecSourcePresent(DWORD dwRecSrc)
[8472]527{
[8530]528 DWORD oldRecSrc;
529 BOOL ret = TRUE;
530
531 OSLibMixGetRecSource(&oldRecSrc);
532
[8506]533 if(OSLibMixSetRecSource(dwRecSrc) == FALSE) {
[8530]534 ret = FALSE;
[8477]535 }
[8530]536 OSLibMixSetRecSource(oldRecSrc);
537 return ret;
[8477]538}
539/******************************************************************************/
540/******************************************************************************/
[8506]541BOOL OSLibMixSetRecSource(DWORD dwRecSrc)
[8477]542{
[8506]543 DWORD idx, volidx;
[8472]544 MIXSTRUCT mixstruct;
[8506]545 DWORD dwVolL, dwVolR;
[8472]546
547 switch(dwRecSrc) {
[8493]548 case MIXER_SRC_IN_W_MIC:
[8472]549 idx = I90SRC_MIC;
[8506]550 volidx = MIX_CTRL_VOL_IN_W_MIC;
[8472]551 break;
[8493]552 case MIXER_SRC_IN_W_CD:
[8472]553 idx = I90SRC_CD;
[8506]554 volidx = MIX_CTRL_VOL_IN_W_CD;
[8472]555 break;
[8493]556 case MIXER_SRC_IN_W_VIDEO:
[8472]557 idx = I90SRC_VIDEO;
[8506]558 volidx = MIX_CTRL_VOL_IN_W_VIDEO;
[8472]559 break;
[8493]560 case MIXER_SRC_IN_W_AUX:
[8472]561 idx = I90SRC_AUX;
[8506]562 volidx = MIX_CTRL_VOL_IN_W_AUX;
[8472]563 break;
[8493]564 case MIXER_SRC_IN_W_LINE:
[8472]565 idx = I90SRC_LINE;
[8506]566 volidx = MIX_CTRL_VOL_IN_W_LINE;
[8472]567 break;
[8493]568 case MIXER_SRC_IN_W_PHONE:
[8472]569 idx = I90SRC_PHONE;
[8506]570 volidx = MIX_CTRL_VOL_IN_W_PHONE;
[8472]571 break;
572 default:
573 return FALSE;
574 }
575 mixstruct.Mute = 0;
576 mixstruct.VolumeL = idx;
577
[8506]578 //select recording source
[8477]579 if(mixerapiIOCTL90(hPDDMix, RECORDSRCSET, &mixstruct, sizeof(mixstruct)) == FALSE) {
580 dprintf(("OSLibMixSetRecSource: mixerapiIOCTL90 RECORDSRCSET failed!!"));
581 return FALSE;
[8472]582 }
[8477]583
[8530]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;
[8506]591
[8530]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 }
[8477]598 }
599 return TRUE;
[8472]600}
601/******************************************************************************/
602/******************************************************************************/
[8506]603BOOL OSLibMixGetRecSource(DWORD *pdwRecSrc)
[8472]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:
[8493]614 idx = MIXER_SRC_IN_W_MIC;
[8472]615 break;
616 case I90SRC_CD:
[8493]617 idx = MIXER_SRC_IN_W_CD;
[8472]618 break;
619 case I90SRC_VIDEO:
[8493]620 idx = MIXER_SRC_IN_W_VIDEO;
[8472]621 break;
622 case I90SRC_AUX:
[8493]623 idx = MIXER_SRC_IN_W_AUX;
[8472]624 break;
625 case I90SRC_LINE:
[8493]626 idx = MIXER_SRC_IN_W_LINE;
[8472]627 break;
628 case I90SRC_PHONE:
[8493]629 idx = MIXER_SRC_IN_W_PHONE;
[8472]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/******************************************************************************/
[8855]697BOOL OSLibGetAudioPDDName (char *pszPDDName)
[8472]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.