1 /*
2 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #define USE_ERROR
27 //#define USE_TRACE
28
29 #include "Ports.h"
30 #include "PLATFORM_API_BsdOS_ALSA_CommonUtils.h"
31 #include <alsa/asoundlib.h>
32
33 #if USE_PORTS == TRUE
34
35 #define MAX_ELEMS (300)
36 #define MAX_CONTROLS (MAX_ELEMS * 4)
37
38 #define CHANNELS_MONO (SND_MIXER_SCHN_LAST + 1)
39 #define CHANNELS_STEREO (SND_MIXER_SCHN_LAST + 2)
40
41 typedef struct {
42 snd_mixer_elem_t* elem;
43 INT32 portType; /* one of PORT_XXX_xx */
44 char* controlType; /* one of CONTROL_TYPE_xx */
45 /* Values: either SND_MIXER_SCHN_FRONT_xx, CHANNELS_MONO or CHANNELS_STEREO.
46 For SND_MIXER_SCHN_FRONT_xx, exactly this channel is set/retrieved directly.
47 For CHANNELS_MONO, ALSA channel SND_MIXER_SCHN_MONO is set/retrieved directly.
48 For CHANNELS_STEREO, ALSA channels SND_MIXER_SCHN_FRONT_LEFT and SND_MIXER_SCHN_FRONT_RIGHT
49 are set after a calculation that takes balance into account. Retrieved? Average of both
50 channels? (Using a cached value is not a good idea since the value in the HW may have been
51 altered.) */
52 INT32 channel;
53 } PortControl;
54
55
56 typedef struct tag_PortMixer {
57 snd_mixer_t* mixer_handle;
58 /* Number of array elements used in elems and types. */
59 int numElems;
60 snd_mixer_elem_t** elems;
61 /* Array of port types (PORT_SRC_UNKNOWN etc.). Indices are the same as in elems. */
62 INT32* types;
63 /* Number of array elements used in controls. */
64 int numControls;
65 PortControl* controls;
66 } PortMixer;
67
68
69 ///// implemented functions of Ports.h
70
71 INT32 PORT_GetPortMixerCount() {
72 INT32 mixerCount;
73 int card;
74 char devname[16];
75 int err;
76 snd_ctl_t *handle;
77 snd_ctl_card_info_t* info;
78
79 TRACE0("> PORT_GetPortMixerCount\n");
80
81 initAlsaSupport();
82
83 snd_ctl_card_info_malloc(&info);
84 card = -1;
85 mixerCount = 0;
86 if (snd_card_next(&card) >= 0) {
87 while (card >= 0) {
88 sprintf(devname, ALSA_HARDWARE_CARD, card);
89 TRACE1("PORT_GetPortMixerCount: Opening alsa device \"%s\"...\n", devname);
90 err = snd_ctl_open(&handle, devname, 0);
91 if (err < 0) {
92 ERROR2("ERROR: snd_ctl_open, card=%d: %s\n", card, snd_strerror(err));
93 } else {
94 mixerCount++;
95 snd_ctl_close(handle);
96 }
97 if (snd_card_next(&card) < 0) {
98 break;
99 }
100 }
101 }
102 snd_ctl_card_info_free(info);
103 TRACE0("< PORT_GetPortMixerCount\n");
104 return mixerCount;
105 }
106
107
108 INT32 PORT_GetPortMixerDescription(INT32 mixerIndex, PortMixerDescription* description) {
109 snd_ctl_t* handle;
110 snd_ctl_card_info_t* card_info;
111 char devname[16];
112 int err;
113 char buffer[100];
114
115 TRACE0("> PORT_GetPortMixerDescription\n");
116 snd_ctl_card_info_malloc(&card_info);
117
118 sprintf(devname, ALSA_HARDWARE_CARD, (int) mixerIndex);
119 TRACE1("Opening alsa device \"%s\"...\n", devname);
120 err = snd_ctl_open(&handle, devname, 0);
121 if (err < 0) {
122 ERROR2("ERROR: snd_ctl_open, card=%d: %s\n", (int) mixerIndex, snd_strerror(err));
123 return FALSE;
124 }
125 err = snd_ctl_card_info(handle, card_info);
126 if (err < 0) {
127 ERROR2("ERROR: snd_ctl_card_info, card=%d: %s\n", (int) mixerIndex, snd_strerror(err));
128 }
129 strncpy(description->name, snd_ctl_card_info_get_id(card_info), PORT_STRING_LENGTH - 1);
130 sprintf(buffer, " [%s]", devname);
131 strncat(description->name, buffer, PORT_STRING_LENGTH - 1 - strlen(description->name));
132 strncpy(description->vendor, "ALSA (http://www.alsa-project.org)", PORT_STRING_LENGTH - 1);
133 strncpy(description->description, snd_ctl_card_info_get_name(card_info), PORT_STRING_LENGTH - 1);
134 strncat(description->description, ", ", PORT_STRING_LENGTH - 1 - strlen(description->description));
135 strncat(description->description, snd_ctl_card_info_get_mixername(card_info), PORT_STRING_LENGTH - 1 - strlen(description->description));
136 getALSAVersion(description->version, PORT_STRING_LENGTH - 1);
137
138 snd_ctl_close(handle);
139 snd_ctl_card_info_free(card_info);
140 TRACE0("< PORT_GetPortMixerDescription\n");
141 return TRUE;
142 }
143
144
145 void* PORT_Open(INT32 mixerIndex) {
146 char devname[16];
147 snd_mixer_t* mixer_handle;
148 int err;
149 PortMixer* handle;
150
151 TRACE0("> PORT_Open\n");
152 sprintf(devname, ALSA_HARDWARE_CARD, (int) mixerIndex);
153 if ((err = snd_mixer_open(&mixer_handle, 0)) < 0) {
154 ERROR2("Mixer %s open error: %s", devname, snd_strerror(err));
155 return NULL;
156 }
157 if ((err = snd_mixer_attach(mixer_handle, devname)) < 0) {
158 ERROR2("Mixer attach %s error: %s", devname, snd_strerror(err));
159 snd_mixer_close(mixer_handle);
160 return NULL;
161 }
162 if ((err = snd_mixer_selem_register(mixer_handle, NULL, NULL)) < 0) {
163 ERROR1("Mixer register error: %s", snd_strerror(err));
164 snd_mixer_close(mixer_handle);
165 return NULL;
166 }
167 err = snd_mixer_load(mixer_handle);
168 if (err < 0) {
169 ERROR2("Mixer %s load error: %s", devname, snd_strerror(err));
170 snd_mixer_close(mixer_handle);
171 return NULL;
172 }
173 handle = (PortMixer*) calloc(1, sizeof(PortMixer));
174 if (handle == NULL) {
175 ERROR0("malloc() failed.");
176 snd_mixer_close(mixer_handle);
177 return NULL;
178 }
179 handle->numElems = 0;
180 handle->elems = (snd_mixer_elem_t**) calloc(MAX_ELEMS, sizeof(snd_mixer_elem_t*));
181 if (handle->elems == NULL) {
182 ERROR0("malloc() failed.");
183 snd_mixer_close(mixer_handle);
184 free(handle);
185 return NULL;
186 }
187 handle->types = (INT32*) calloc(MAX_ELEMS, sizeof(INT32));
188 if (handle->types == NULL) {
189 ERROR0("malloc() failed.");
190 snd_mixer_close(mixer_handle);
191 free(handle->elems);
192 free(handle);
193 return NULL;
194 }
195 handle->controls = (PortControl*) calloc(MAX_CONTROLS, sizeof(PortControl));
196 if (handle->controls == NULL) {
197 ERROR0("malloc() failed.");
198 snd_mixer_close(mixer_handle);
199 free(handle->elems);
200 free(handle->types);
201 free(handle);
202 return NULL;
203 }
204 handle->mixer_handle = mixer_handle;
205 // necessary to initialize data structures
206 PORT_GetPortCount(handle);
207 TRACE0("< PORT_Open\n");
208 return handle;
209 }
210
211
212 void PORT_Close(void* id) {
213 TRACE0("> PORT_Close\n");
214 if (id != NULL) {
215 PortMixer* handle = (PortMixer*) id;
216 if (handle->mixer_handle != NULL) {
217 snd_mixer_close(handle->mixer_handle);
218 }
219 if (handle->elems != NULL) {
220 free(handle->elems);
221 }
222 if (handle->types != NULL) {
223 free(handle->types);
224 }
225 if (handle->controls != NULL) {
226 free(handle->controls);
227 }
228 free(handle);
229 }
230 TRACE0("< PORT_Close\n");
231 }
232
233
234
235 INT32 PORT_GetPortCount(void* id) {
236 PortMixer* portMixer;
237 snd_mixer_elem_t *elem;
238
239 TRACE0("> PORT_GetPortCount\n");
240 if (id == NULL) {
241 // $$mp: Should become a descriptive error code (invalid handle).
242 return -1;
243 }
244 portMixer = (PortMixer*) id;
245 if (portMixer->numElems == 0) {
246 for (elem = snd_mixer_first_elem(portMixer->mixer_handle); elem; elem = snd_mixer_elem_next(elem)) {
247 if (!snd_mixer_selem_is_active(elem))
248 continue;
249 TRACE2("Simple mixer control '%s',%i\n",
250 snd_mixer_selem_get_name(elem),
251 snd_mixer_selem_get_index(elem));
252 if (snd_mixer_selem_has_playback_volume(elem)) {
253 portMixer->elems[portMixer->numElems] = elem;
254 portMixer->types[portMixer->numElems] = PORT_DST_UNKNOWN;
255 portMixer->numElems++;
256 }
257 // to prevent buffer overflow
258 if (portMixer->numElems >= MAX_ELEMS) {
259 break;
260 }
261 /* If an element has both playback an capture volume, it is put into the arrays
262 twice. */
263 if (snd_mixer_selem_has_capture_volume(elem)) {
264 portMixer->elems[portMixer->numElems] = elem;
265 portMixer->types[portMixer->numElems] = PORT_SRC_UNKNOWN;
266 portMixer->numElems++;
267 }
268 // to prevent buffer overflow
269 if (portMixer->numElems >= MAX_ELEMS) {
270 break;
271 }
272 }
273 }
274 TRACE0("< PORT_GetPortCount\n");
275 return portMixer->numElems;
276 }
277
278
279 INT32 PORT_GetPortType(void* id, INT32 portIndex) {
280 PortMixer* portMixer;
281 INT32 type;
282 TRACE0("> PORT_GetPortType\n");
283 if (id == NULL) {
284 // $$mp: Should become a descriptive error code (invalid handle).
285 return -1;
286 }
287 portMixer = (PortMixer*) id;
288 if (portIndex < 0 || portIndex >= portMixer->numElems) {
289 // $$mp: Should become a descriptive error code (index out of bounds).
290 return -1;
291 }
292 type = portMixer->types[portIndex];
293 TRACE0("< PORT_GetPortType\n");
294 return type;
295 }
296
297
298 INT32 PORT_GetPortName(void* id, INT32 portIndex, char* name, INT32 len) {
299 PortMixer* portMixer;
300 const char* nam;
301
302 TRACE0("> PORT_GetPortName\n");
303 if (id == NULL) {
304 // $$mp: Should become a descriptive error code (invalid handle).
305 return -1;
306 }
307 portMixer = (PortMixer*) id;
308 if (portIndex < 0 || portIndex >= portMixer->numElems) {
309 // $$mp: Should become a descriptive error code (index out of bounds).
310 return -1;
311 }
312 nam = snd_mixer_selem_get_name(portMixer->elems[portIndex]);
313 strncpy(name, nam, len - 1);
314 name[len - 1] = 0;
315 TRACE0("< PORT_GetPortName\n");
316 return TRUE;
317 }
318
319
320 static int isPlaybackFunction(INT32 portType) {
321 return (portType & PORT_DST_MASK);
322 }
323
324
325 /* Sets portControl to a pointer to the next free array element in the PortControl (pointer)
326 array of the passed portMixer. Returns TRUE if successful. May return FALSE if there is no
327 free slot. In this case, portControl is not altered */
328 static int getControlSlot(PortMixer* portMixer, PortControl** portControl) {
329 if (portMixer->numControls >= MAX_CONTROLS) {
330 return FALSE;
331 } else {
332 *portControl = &(portMixer->controls[portMixer->numControls]);
333 portMixer->numControls++;
334 return TRUE;
335 }
336 }
337
338
339 /* Protect against illegal min-max values, preventing divisions by zero.
340 */
341 inline static long getRange(long min, long max) {
342 if (max > min) {
343 return max - min;
344 } else {
345 return 1;
346 }
347 }
348
349
350 /* Idea: we may specify that if unit is an empty string, the values are linear and if unit is "dB",
351 the values are logarithmic.
352 */
353 static void* createVolumeControl(PortControlCreator* creator,
354 PortControl* portControl,
355 snd_mixer_elem_t* elem, int isPlayback) {
356 void* control;
357 float precision;
358 long min, max;
359
360 if (isPlayback) {
361 snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
362 } else {
363 snd_mixer_selem_get_capture_volume_range(elem, &min, &max);
364 }
365 /* $$mp: The volume values retrieved with the ALSA API are strongly supposed to be logarithmic.
366 So the following calculation is wrong. However, there is no correct calculation, since
367 for equal-distant logarithmic steps, the precision expressed in linear varies over the
368 scale. */
369 precision = 1.0F / getRange(min, max);
370 control = (creator->newFloatControl)(creator, portControl, CONTROL_TYPE_VOLUME, 0.0F, +1.0F, precision, "");
371 return control;
372 }
373
374
375 void PORT_GetControls(void* id, INT32 portIndex, PortControlCreator* creator) {
376 PortMixer* portMixer;
377 snd_mixer_elem_t* elem;
378 void* control;
379 PortControl* portControl;
380 void* controls[10];
381 int numControls;
382 char* portName;
383 int isPlayback = 0;
384 int isMono;
385 int isStereo;
386 char* type;
387 snd_mixer_selem_channel_id_t channel;
388 memset(controls, 0, sizeof(controls));
389
390 TRACE0("> PORT_GetControls\n");
391 if (id == NULL) {
392 ERROR0("Invalid handle!");
393 // $$mp: an error code should be returned.
394 return;
395 }
396 portMixer = (PortMixer*) id;
397 if (portIndex < 0 || portIndex >= portMixer->numElems) {
398 ERROR0("Port index out of range!");
399 // $$mp: an error code should be returned.
400 return;
401 }
402 numControls = 0;
403 elem = portMixer->elems[portIndex];
404 if (snd_mixer_selem_has_playback_volume(elem) || snd_mixer_selem_has_capture_volume(elem)) {
405 /* Since we've split/duplicated elements with both playback and capture on the recovery
406 of elements, we now can assume that we handle only to deal with either playback or
407 capture. */
408 isPlayback = isPlaybackFunction(portMixer->types[portIndex]);
409 isMono = (isPlayback && snd_mixer_selem_is_playback_mono(elem)) ||
410 (!isPlayback && snd_mixer_selem_is_capture_mono(elem));
411 isStereo = (isPlayback &&
412 snd_mixer_selem_has_playback_channel(elem, SND_MIXER_SCHN_FRONT_LEFT) &&
413 snd_mixer_selem_has_playback_channel(elem, SND_MIXER_SCHN_FRONT_RIGHT)) ||
414 (!isPlayback &&
415 snd_mixer_selem_has_capture_channel(elem, SND_MIXER_SCHN_FRONT_LEFT) &&
416 snd_mixer_selem_has_capture_channel(elem, SND_MIXER_SCHN_FRONT_RIGHT));
417 // single volume control
418 if (isMono || isStereo) {
419 if (getControlSlot(portMixer, &portControl)) {
420 portControl->elem = elem;
421 portControl->portType = portMixer->types[portIndex];
422 portControl->controlType = CONTROL_TYPE_VOLUME;
423 if (isMono) {
424 portControl->channel = CHANNELS_MONO;
425 } else {
426 portControl->channel = CHANNELS_STEREO;
427 }
428 control = createVolumeControl(creator, portControl, elem, isPlayback);
429 if (control != NULL) {
430 controls[numControls++] = control;
431 }
432 }
433 } else { // more than two channels, each channels has its own control.
434 for (channel = SND_MIXER_SCHN_FRONT_LEFT; channel <= SND_MIXER_SCHN_LAST; channel++) {
435 if (isPlayback && snd_mixer_selem_has_playback_channel(elem, channel) ||
436 !isPlayback && snd_mixer_selem_has_capture_channel(elem, channel)) {
437 if (getControlSlot(portMixer, &portControl)) {
438 portControl->elem = elem;
439 portControl->portType = portMixer->types[portIndex];
440 portControl->controlType = CONTROL_TYPE_VOLUME;
441 portControl->channel = channel;
442 control = createVolumeControl(creator, portControl, elem, isPlayback);
443 // We wrap in a compound control to provide the channel name.
444 if (control != NULL) {
445 /* $$mp 2003-09-14: The following cast shouln't be necessary. Instead, the
446 declaration of PORT_NewCompoundControlPtr in Ports.h should be changed
447 to take a const char* parameter. */
448 control = (creator->newCompoundControl)(creator, (char*) snd_mixer_selem_channel_name(channel), &control, 1);
449 }
450 if (control != NULL) {
451 controls[numControls++] = control;
452 }
453 }
454 }
455 }
456 }
457 // BALANCE control
458 if (isStereo) {
459 if (getControlSlot(portMixer, &portControl)) {
460 portControl->elem = elem;
461 portControl->portType = portMixer->types[portIndex];
462 portControl->controlType = CONTROL_TYPE_BALANCE;
463 portControl->channel = CHANNELS_STEREO;
464 /* $$mp: The value for precision is chosen more or less arbitrarily. */
465 control = (creator->newFloatControl)(creator, portControl, CONTROL_TYPE_BALANCE, -1.0F, 1.0F, 0.01F, "");
466 if (control != NULL) {
467 controls[numControls++] = control;
468 }
469 }
470 }
471 }
472 if (snd_mixer_selem_has_playback_switch(elem) || snd_mixer_selem_has_capture_switch(elem)) {
473 if (getControlSlot(portMixer, &portControl)) {
474 type = isPlayback ? CONTROL_TYPE_MUTE : CONTROL_TYPE_SELECT;
475 portControl->elem = elem;
476 portControl->portType = portMixer->types[portIndex];
477 portControl->controlType = type;
478 control = (creator->newBooleanControl)(creator, portControl, type);
479 if (control != NULL) {
480 controls[numControls++] = control;
481 }
482 }
483 }
484 /* $$mp 2003-09-14: The following cast shouln't be necessary. Instead, the
485 declaration of PORT_NewCompoundControlPtr in Ports.h should be changed
486 to take a const char* parameter. */
487 portName = (char*) snd_mixer_selem_get_name(elem);
488 control = (creator->newCompoundControl)(creator, portName, controls, numControls);
489 if (control != NULL) {
490 (creator->addControl)(creator, control);
491 }
492 TRACE0("< PORT_GetControls\n");
493 }
494
495
496 INT32 PORT_GetIntValue(void* controlIDV) {
497 PortControl* portControl = (PortControl*) controlIDV;
498 int value = 0;
499 snd_mixer_selem_channel_id_t channel;
500
501 if (portControl != NULL) {
502 switch (portControl->channel) {
503 case CHANNELS_MONO:
504 channel = SND_MIXER_SCHN_MONO;
505 break;
506
507 case CHANNELS_STEREO:
508 channel = SND_MIXER_SCHN_FRONT_LEFT;
509 break;
510
511 default:
512 channel = portControl->channel;
513 }
514 if (portControl->controlType == CONTROL_TYPE_MUTE ||
515 portControl->controlType == CONTROL_TYPE_SELECT) {
516 if (isPlaybackFunction(portControl->portType)) {
517 snd_mixer_selem_get_playback_switch(portControl->elem, channel, &value);
518 } else {
519 snd_mixer_selem_get_capture_switch(portControl->elem, channel, &value);
520 }
521 if (portControl->controlType == CONTROL_TYPE_MUTE) {
522 value = ! value;
523 }
524 } else {
525 ERROR1("PORT_GetIntValue(): inappropriate control type: %s\n",
526 portControl->controlType);
527 }
528 }
529 return (INT32) value;
530 }
531
532
533 void PORT_SetIntValue(void* controlIDV, INT32 value) {
534 PortControl* portControl = (PortControl*) controlIDV;
535 snd_mixer_selem_channel_id_t channel;
536
537 if (portControl != NULL) {
538 if (portControl->controlType == CONTROL_TYPE_MUTE) {
539 value = ! value;
540 }
541 if (portControl->controlType == CONTROL_TYPE_MUTE ||
542 portControl->controlType == CONTROL_TYPE_SELECT) {
543 if (isPlaybackFunction(portControl->portType)) {
544 snd_mixer_selem_set_playback_switch_all(portControl->elem, value);
545 } else {
546 snd_mixer_selem_set_capture_switch_all(portControl->elem, value);
547 }
548 } else {
549 ERROR1("PORT_SetIntValue(): inappropriate control type: %s\n",
550 portControl->controlType);
551 }
552 }
553 }
554
555
556 static float scaleVolumeValueToNormalized(long value, long min, long max) {
557 return (float) (value - min) / getRange(min, max);
558 }
559
560
561 static long scaleVolumeValueToHardware(float value, long min, long max) {
562 return (long)(value * getRange(min, max) + min);
563 }
564
565
566 float getRealVolume(PortControl* portControl,
567 snd_mixer_selem_channel_id_t channel) {
568 float fValue;
569 long lValue = 0;
570 long min = 0;
571 long max = 0;
572
573 if (isPlaybackFunction(portControl->portType)) {
574 snd_mixer_selem_get_playback_volume_range(portControl->elem,
575 &min, &max);
576 snd_mixer_selem_get_playback_volume(portControl->elem,
577 channel, &lValue);
578 } else {
579 snd_mixer_selem_get_capture_volume_range(portControl->elem,
580 &min, &max);
581 snd_mixer_selem_get_capture_volume(portControl->elem,
582 channel, &lValue);
583 }
584 fValue = scaleVolumeValueToNormalized(lValue, min, max);
585 return fValue;
586 }
587
588
589 void setRealVolume(PortControl* portControl,
590 snd_mixer_selem_channel_id_t channel, float value) {
591 long lValue = 0;
592 long min = 0;
593 long max = 0;
594
595 if (isPlaybackFunction(portControl->portType)) {
596 snd_mixer_selem_get_playback_volume_range(portControl->elem,
597 &min, &max);
598 lValue = scaleVolumeValueToHardware(value, min, max);
599 snd_mixer_selem_set_playback_volume(portControl->elem,
600 channel, lValue);
601 } else {
602 snd_mixer_selem_get_capture_volume_range(portControl->elem,
603 &min, &max);
604 lValue = scaleVolumeValueToHardware(value, min, max);
605 snd_mixer_selem_set_capture_volume(portControl->elem,
606 channel, lValue);
607 }
608 }
609
610
611 static float getFakeBalance(PortControl* portControl) {
612 float volL, volR;
613
614 // pan is the ratio of left and right
615 volL = getRealVolume(portControl, SND_MIXER_SCHN_FRONT_LEFT);
616 volR = getRealVolume(portControl, SND_MIXER_SCHN_FRONT_RIGHT);
617 if (volL > volR) {
618 return -1.0f + (volR / volL);
619 }
620 else if (volR > volL) {
621 return 1.0f - (volL / volR);
622 }
623 return 0.0f;
624 }
625
626
627 static float getFakeVolume(PortControl* portControl) {
628 float valueL;
629 float valueR;
630 float value;
631
632 valueL = getRealVolume(portControl, SND_MIXER_SCHN_FRONT_LEFT);
633 valueR = getRealVolume(portControl, SND_MIXER_SCHN_FRONT_RIGHT);
634 // volume is the greater value of both
635 value = valueL > valueR ? valueL : valueR ;
636 return value;
637 }
638
639
640 /*
641 * sets the unsigned values for left and right volume according to
642 * the given volume (0...1) and balance (-1..0..+1)
643 */
644 static void setFakeVolume(PortControl* portControl, float vol, float bal) {
645 float volumeLeft;
646 float volumeRight;
647
648 if (bal < 0.0f) {
649 volumeLeft = vol;
650 volumeRight = vol * (bal + 1.0f);
651 } else {
652 volumeLeft = vol * (1.0f - bal);
653 volumeRight = vol;
654 }
655 setRealVolume(portControl, SND_MIXER_SCHN_FRONT_LEFT, volumeLeft);
656 setRealVolume(portControl, SND_MIXER_SCHN_FRONT_RIGHT, volumeRight);
657 }
658
659
660 float PORT_GetFloatValue(void* controlIDV) {
661 PortControl* portControl = (PortControl*) controlIDV;
662 float value = 0.0F;
663
664 if (portControl != NULL) {
665 if (portControl->controlType == CONTROL_TYPE_VOLUME) {
666 switch (portControl->channel) {
667 case CHANNELS_MONO:
668 value = getRealVolume(portControl, SND_MIXER_SCHN_MONO);
669 break;
670
671 case CHANNELS_STEREO:
672 value = getFakeVolume(portControl);
673 break;
674
675 default:
676 value = getRealVolume(portControl, portControl->channel);
677 }
678 } else if (portControl->controlType == CONTROL_TYPE_BALANCE) {
679 if (portControl->channel == CHANNELS_STEREO) {
680 value = getFakeBalance(portControl);
681 } else {
682 ERROR0("PORT_GetFloatValue(): Balance only allowed for stereo channels!\n");
683 }
684 } else {
685 ERROR1("PORT_GetFloatValue(): inappropriate control type: %s!\n",
686 portControl->controlType);
687 }
688 }
689 return value;
690 }
691
692
693 void PORT_SetFloatValue(void* controlIDV, float value) {
694 PortControl* portControl = (PortControl*) controlIDV;
695
696 if (portControl != NULL) {
697 if (portControl->controlType == CONTROL_TYPE_VOLUME) {
698 switch (portControl->channel) {
699 case CHANNELS_MONO:
700 setRealVolume(portControl, SND_MIXER_SCHN_MONO, value);
701 break;
702
703 case CHANNELS_STEREO:
704 setFakeVolume(portControl, value, getFakeBalance(portControl));
705 break;
706
707 default:
708 setRealVolume(portControl, portControl->channel, value);
709 }
710 } else if (portControl->controlType == CONTROL_TYPE_BALANCE) {
711 if (portControl->channel == CHANNELS_STEREO) {
712 setFakeVolume(portControl, getFakeVolume(portControl), value);
713 } else {
714 ERROR0("PORT_SetFloatValue(): Balance only allowed for stereo channels!\n");
715 }
716 } else {
717 ERROR1("PORT_SetFloatValue(): inappropriate control type: %s!\n",
718 portControl->controlType);
719 }
720 }
721 }
722
723
724 #endif // USE_PORTS