summaryrefslogtreecommitdiff
path: root/tvapi/libtv/audio/audio_alsa.cpp (plain)
blob: 8e8bb786e97a2d6af6d0e5044bdd76921175f322
1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4#include <getopt.h>
5#include <pthread.h>
6#include <stdarg.h>
7#include <ctype.h>
8#include <math.h>
9#include <errno.h>
10#include <assert.h>
11#include <fcntl.h>
12#include <tinyalsa/asoundlib.h>
13#include "CFbcCommunication.h"
14#include <sys/poll.h>
15#include "tvsetting/audio_cfg.h"
16#include "audio_alsa.h"
17#include <cutils/properties.h>
18#define LOG_TAG "CAudioAlsa"
19#include "CTvLog.h"
20#include "audio_amaudio.h"
21
22static const int DEFAULT_MAIN_DIGIT_LUT[] = {
23 //
24 0, 40, 50, 60, 70, 87, 110, 120, 130, 140, // 0~9
25 150, 152, 155, 158, 161, 164, 167, 170, 173, 174, // 10~19
26 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, // 20~29
27 191, 191, 192, 193, 194, 195, 196, 196, 197, 197, // 30~39
28 198, 198, 198, 199, 199, 200, 200, 201, 201, 201, // 40~49
29 202, 202, 202, 203, 203, 203, 203, 204, 204, 204, // 50~59
30 205, 205, 205, 205, 206, 206, 206, 206, 206, 207, // 60~69
31 207, 207, 207, 207, 207, 207, 207, 208, 208, 208, // 70~79
32 208, 208, 208, 208, 208, 208, 208, 208, 208, 209, // 80~89
33 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, // 90~99
34 209, // 100
35};
36
37static const int DEFAULT_SUPPER_BASS_DIGIT_LUT_BUF[] = {
38 //
39 0, 122, 123, 124, 125, 126, 127, 128, 129, 130, // 0~9
40 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, // 10~19
41 141, 142, 143, 144, 145, 147, 147, 148, 148, 149, // 20~29
42 149, 150, 150, 151, 151, 152, 152, 153, 153, 154, // 30~39
43 154, 155, 155, 156, 156, 157, 157, 158, 158, 159, // 40~49
44 160, 160, 160, 160, 161, 161, 161, 161, 162, 162, // 50~59
45 162, 163, 163, 163, 163, 164, 164, 164, 165, 165, // 60~69
46 165, 165, 166, 166, 166, 167, 168, 169, 170, 171, // 70~79
47 173, 174, 175, 176, 177, 179, 180, 181, 182, 183, // 80~89
48 185, 186, 187, 188, 189, 191, 192, 193, 194, 195, // 90~99
49 197 // 100
50};
51
52CAudioAlsa::CAudioAlsa()
53{
54 int card_id;
55 card_id = get_aml_card();
56 LOGD("[%s:%d] card_id:%d\n", __FUNCTION__, __LINE__, card_id);
57 mpMixer = mixer_open(card_id);
58
59 card_id = get_USB_Audio_card();
60 LOGD("[%s:%d] card_id:%d\n", __FUNCTION__, __LINE__, card_id);
61 mpUsbMixer = mixer_open(card_id);
62 mMainVolumeGainVal = 0;
63 mSupperBassVolumeGainVal = 0;
64 ArrayCopy(mMainDigitLutBuf, DEFAULT_MAIN_DIGIT_LUT, CC_VOL_TRANS_LUT_BUF_SIZE);
65 ArrayCopy(mSupperBassDigitLutBuf, DEFAULT_SUPPER_BASS_DIGIT_LUT_BUF, CC_VOL_TRANS_LUT_BUF_SIZE);
66}
67
68CAudioAlsa::~CAudioAlsa()
69{
70 if (NULL != mpMixer) {
71 mixer_close(mpMixer);
72 }
73
74 if (NULL != mpUsbMixer) {
75 mixer_close(mpUsbMixer);
76 }
77}
78
79int CAudioAlsa::get_aml_card()
80{
81 int card = -1, err = 0;
82 int fd = -1;
83 char read_buf[512], *pd = NULL;
84 static const char *const SOUND_CARDS_PATH = "/proc/asound/cards";
85 fd = open(SOUND_CARDS_PATH, O_RDONLY);
86 if (fd < 0) {
87 LOGE("ERROR: failed to open config file %s error: %d\n", SOUND_CARDS_PATH, errno);
88 close(fd);
89 return -EINVAL;
90 }
91 memset(read_buf, 0x0, 512);
92 err = read(fd, read_buf, 512);
93 if (fd < 0) {
94 LOGE("ERROR: failed to read config file %s error: %d\n", SOUND_CARDS_PATH, errno);
95 close(fd);
96 return -EINVAL;
97 }
98 pd = strstr(read_buf, "AML");
99 card = *(pd - 3) - '0';
100 close(fd);
101 return card;
102}
103
104int CAudioAlsa::AudioControlSetValue(int val_count, int data_buf[], char *match_names)
105{
106 struct mixer_ctl *pctl;
107 unsigned int expected_val_count;
108 unsigned int value_index;
109
110 if (NULL == mpMixer) {
111 LOGE("[%s:%d] Failed to open mixer\n", __FUNCTION__, __LINE__);
112 goto err_exit;
113 }
114
115 pctl = mixer_get_ctl_by_name(mpMixer, match_names);
116 if (NULL == pctl) {
117 LOGE("[%s:%d] Failed to get mixer control for:%s\n", __FUNCTION__, __LINE__, match_names);
118 goto err_exit;
119 }
120 expected_val_count = mixer_ctl_get_num_values(pctl);
121 if (expected_val_count != (unsigned int)val_count) {
122 LOGE("[%s:%d] val_count != expected_val_count\n", __FUNCTION__, __LINE__);
123 goto err_exit;
124 }
125 for (value_index = 0; value_index < expected_val_count; value_index++) {
126 if (mixer_ctl_set_value(pctl, value_index, data_buf[value_index]) != 0) {
127 LOGE("[%s:%d] Failed to set value:%d\n", __FUNCTION__, __LINE__, value_index);
128 goto err_exit;
129 }
130 }
131 return 0;
132err_exit:
133 return -1;
134}
135
136int CAudioAlsa::AudioControlGetValue(int val_count, int ret_buf[], char *match_names)
137{
138 struct mixer_ctl *pctl;
139 unsigned int expected_val_count;
140 unsigned int value_index;
141
142 if (NULL == mpMixer) {
143 LOGE("[%s:%d] Failed to open mixer\n", __FUNCTION__, __LINE__);
144 goto err_exit;
145 }
146 pctl = mixer_get_ctl_by_name(mpMixer, match_names);
147 if (NULL == pctl) {
148 LOGE("[%s:%d] Failed to get mixer control for:%s\n", __FUNCTION__, __LINE__, match_names);
149 goto err_exit;
150 }
151 expected_val_count = mixer_ctl_get_num_values(pctl);
152 if (expected_val_count != (unsigned int)val_count) {
153 LOGE("[%s:%d] val_count != expected_val_count\n", __FUNCTION__, __LINE__);
154 goto err_exit;
155 }
156 for (value_index = 0; value_index < expected_val_count; value_index++) {
157 ret_buf[value_index] = mixer_ctl_get_value(pctl, value_index);
158 }
159 return 0;
160err_exit:
161 return -1;
162}
163
164int CAudioAlsa::get_USB_Audio_card()
165{
166 int card = -1, err = 0;
167 int fd = -1;
168 char read_buf[512], *pd = NULL;
169 static const char *const SOUND_CARDS_PATH = "/proc/asound/cards";
170 fd = open(SOUND_CARDS_PATH, O_RDONLY);
171 if (fd < 0) {
172 LOGE("ERROR: failed to open config file %s error: %d\n", SOUND_CARDS_PATH, errno);
173 close(fd);
174 return -EINVAL;
175 }
176 memset(read_buf, 0x0, 512);
177 err = read(fd, read_buf, 512);
178 if (fd < 0) {
179 LOGE("ERROR: failed to read config file %s error: %d\n", SOUND_CARDS_PATH, errno);
180 close(fd);
181 return -EINVAL;
182 }
183 pd = strstr(read_buf, "Receiver");
184 if (pd == NULL) {
185 LOGE("ERROR: failed to read config file %s error: %d\n", SOUND_CARDS_PATH, errno);
186 close(fd);
187 return -EINVAL;
188 }
189
190 card = *(pd - 3) - '0';
191 close(fd);
192 return card;
193}
194
195int CAudioAlsa::HandleUSBAudioControlValue(int val_count, int data_buf[], int match_count, char **match_names)
196{
197
198 struct mixer_ctl *pctl;
199 unsigned int expected_val_count;
200 unsigned int match_index;
201 unsigned int value_index;
202 char card_id_str[9] = {0};
203
204 if (NULL == mpUsbMixer) {
205 LOGE("[%s:%d] Failed to open mixer\n", __FUNCTION__, __LINE__);
206 goto err_exit;
207 }
208
209 for (match_index = 0; match_index < match_count; match_index++) {
210 pctl = mixer_get_ctl_by_name(mpUsbMixer, match_names[match_index]);
211 if (NULL == pctl) {
212 LOGE("[%s:%d] Failed to get mixer control for:%s\n", __FUNCTION__, __LINE__, match_names[match_index]);
213 goto err_exit;
214 }
215 expected_val_count = mixer_ctl_get_num_values(pctl);
216 if (expected_val_count != (unsigned int)val_count) {
217 LOGE("[%s:%d] val_count != expected_val_count\n", __FUNCTION__, __LINE__);
218 goto err_exit;
219 }
220 for (value_index = 0; value_index < expected_val_count; value_index++) {
221 if (mixer_ctl_set_value(pctl, value_index, data_buf[value_index]) != 0) {
222 LOGE("[%s:%d] Failed to set value:%d\n", __FUNCTION__, __LINE__, value_index);
223 goto err_exit;
224 }
225 }
226 }
227
228 return 0;
229err_exit:
230 return -1;
231}
232
233int CAudioAlsa::CheckVolume(int digit_vol, int digit_min, int digit_max, int hd_min,
234 int hd_max)
235{
236 int tmp_val = digit_vol;
237
238 if (digit_vol < hd_min) {
239 return hd_min;
240 } else if (digit_vol > hd_max) {
241 return hd_max;
242 }
243
244 return digit_vol;
245}
246
247int CAudioAlsa::GetTwoChannelVolume(int vol_buf[], int l_min_vol, int l_max_vol,
248 int r_min_vol, int r_max_vol, char *match_names, int hd_min,
249 int hd_max)
250{
251 vol_buf[0] = 0;
252 vol_buf[1] = 0;
253 return AudioControlGetValue(2, vol_buf, match_names);
254}
255
256int CAudioAlsa::GetLineInMaxVol()
257{
258
259 return 127;
260}
261
262int CAudioAlsa::GetLineOutMaxVol()
263{
264
265 return 255;
266}
267
268#define CC_GET_ALSA_CTL_AUDIO_IN_SOURCE_NAME (0)
269#define CC_GET_ALSA_CTL_INTERNAL_DAC_PGA_IN_GAIN (1)
270#define CC_GET_ALSA_CTL_INTERNAL_DAC_ADC_DIGITAL_CAPTURE_VOLUME_NAME (2)
271#define CC_GET_ALSA_CTL_INTERNAL_DAC_DAC_DIGITAL_PLAYBACK_VOLUME_NAME (3)
272#define CC_GET_ALSA_CTL_INTERNAL_DAC_LEFT_LINEIN_SEL_NAME (4)
273#define CC_GET_ALSA_CTL_INTERNAL_DAC_RIGHT_LINEIN_SEL_NAME (5)
274#define CC_GET_ALSA_CTL_INTERNAL_DAC_LINEIN_CAPTURE_VOLUME_NAME (6)
275#define CC_GET_ALSA_CTL_INTERNAL_DAC_LINEOUT_PLAYBACK_VOLUME_NAME (7)
276#define CC_GET_ALSA_CTL_I2S_MUTE_NAME (8)
277#define CC_GET_ALSA_CTL_SPDIF_MUTE_NAME (9)
278#define CC_GET_ALSA_CTL_HW_RESAMPLE_NAME (10)
279#define CC_GET_ALSA_CTL_EXTERNAL_DAC_MASTER_VOLUME_NAME (11)
280#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_VOLUME_NAME (12)
281#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_VOLUME_NAME (13)
282#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_VOLUME_NAME (14)
283#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_SWITCH_NAME (15)
284#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_SWITCH_NAME (16)
285#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_SWITCH_NAME (17)
286#define CC_GET_ALSA_CTL_EXTERNAL_DAC_EQ_MODE_NAME (18)
287#define CC_GET_ALSA_CTL_PCM_PLAYBACK_VOLUME (19)
288#define CC_GET_ALSA_CTL_PCM_PLAYBACK_SWITCH (20)
289#define CC_GET_ALSA_CTL_SETOUTPUT_SWAP (21)
290#define CC_GET_ALSA_CTL_AUDIO_IN_SWITCH (22)
291
292static char gG9AlsaNames[32][48] = {
293 {"Audio In Source"},//0
294 {"PGA IN Gain"},//1
295 {"ADC Digital Capture Volume"},//2
296 {"DAC Digital Playback Volume"},//3
297 {"Linein right switch"},//4
298 {"Linein left switch"},
299 {"ADC Digital Capture Volume"},
300 {"DAC Digital Playback Volume"},
301 {"Audio i2s mute"},//8
302 {"Audio spdif mute"},
303 {"Hardware resample enable"},//10
304 {"AMP Master Volume"},
305 {"AMP Ch1 Volume"},//12
306 {"AMP Ch2 Volume"},
307 {"AMP Ch3 Volume"},
308 {"AMP Ch1 Switch"},
309 {"AMP Ch2 Switch"},
310 {"AMP Ch3 Switch"},//17
311 {"AMP EQ Mode"},
312 {"PCM Playback Volume"},
313 {"PCM Playback Switch"},
314 {"Output Swap"},
315 {"AudioIn Switch"},//22
316};
317
318
319char *CAudioAlsa::GetAlsaControlName(int get_type)
320{
321 return gG9AlsaNames[get_type];
322}
323
324
325int CAudioAlsa::SetAudioInSource(int source_type)
326{
327 int set_val = 0;
328 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_AUDIO_IN_SOURCE_NAME);
329 set_val = source_type;
330 return AudioControlSetValue(1, &set_val, match_names);
331}
332
333int CAudioAlsa::GetAudioInSource(void)
334{
335 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_AUDIO_IN_SOURCE_NAME);
336 int source_type = 0;
337 AudioControlGetValue(1, &source_type, match_names);
338 return source_type;
339}
340
341int CAudioAlsa::SetAudioInternalDacPGAInGain(int gain_l_val, int gain_r_val)
342{
343 int GainBuf[2] = {0, 0};
344 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_PGA_IN_GAIN);
345
346 GainBuf[0] = gain_l_val;
347 GainBuf[1] = gain_r_val;
348 if (gain_l_val < 0 || gain_l_val > 31) {
349 GainBuf[0] = 16;
350 }
351 if (gain_r_val < 0 || gain_r_val > 31) {
352 GainBuf[1] = 16;
353 }
354
355 return AudioControlSetValue(2, GainBuf, match_names);
356}
357
358int CAudioAlsa::GetAudioInternalDacPGAInGain(int *gain_l_val, int *gain_r_val)
359{
360 int GainBuf[2] = {0, 0};
361 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_PGA_IN_GAIN);
362
363 AudioControlGetValue(2, GainBuf, match_names);
364
365 *gain_l_val = GainBuf[0];
366 *gain_r_val = GainBuf[1];
367
368 return 0;
369}
370
371int CAudioAlsa::SetAudioInternalDacADCDigitalCaptureVolume(int vol_l_val, int vol_r_val)
372{
373 int VolumeBuf[2] = {0, 0};
374 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_ADC_DIGITAL_CAPTURE_VOLUME_NAME);
375
376 VolumeBuf[0] = vol_l_val;
377 VolumeBuf[1] = vol_r_val;
378 if (vol_l_val < 0 || vol_l_val > 127) {
379 VolumeBuf[0] = 82;
380 }
381 if (vol_r_val < 0 || vol_r_val > 127) {
382 VolumeBuf[1] = 82;
383 }
384
385 return AudioControlSetValue(2, VolumeBuf, match_names);
386}
387
388int CAudioAlsa::GetAudioInternalDacADCDigitalCaptureVolume(int *vol_l_val, int *vol_r_val)
389{
390 int VolumeBuf[2] = {0, 0};
391 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_ADC_DIGITAL_CAPTURE_VOLUME_NAME);
392
393 AudioControlGetValue(2, VolumeBuf, match_names);
394
395 *vol_l_val = VolumeBuf[0];
396 *vol_r_val = VolumeBuf[1];
397
398 return 0;
399}
400
401int CAudioAlsa::SetAudioInternalDacDACDigitalPlayBackVolume(int vol_l_val, int vol_r_val)
402{
403 int VolumeBuf[2] = {0, 0};
404 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_DAC_DIGITAL_PLAYBACK_VOLUME_NAME);
405
406 VolumeBuf[0] = vol_l_val;
407 VolumeBuf[1] = vol_r_val;
408 if (vol_l_val < 0 || vol_l_val > 255) {
409 VolumeBuf[0] = 255;
410 }
411 if (vol_r_val < 0 || vol_r_val > 255) {
412 VolumeBuf[1] = 255;
413 }
414
415 return AudioControlSetValue(2, VolumeBuf, match_names);
416}
417
418int CAudioAlsa::GetAudioInternalDacDACDigitalPlayBackVolume(int *vol_l_val, int *vol_r_val)
419{
420 int VolumeBuf[2] = {0, 0};
421 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_DAC_DIGITAL_PLAYBACK_VOLUME_NAME);
422
423 AudioControlGetValue(2, VolumeBuf, match_names);
424
425 *vol_l_val = VolumeBuf[0];
426 *vol_r_val = VolumeBuf[1];
427
428 return 0;
429}
430
431int CAudioAlsa::SetInternalDacLineInSelectChannel(int line_in_number)
432{
433 int tmp_ret = 0;
434 char *match_names = NULL;
435
436 if (line_in_number < 0 || line_in_number > 7) {
437 return -1;
438 }
439
440 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LEFT_LINEIN_SEL_NAME);
441 tmp_ret |= AudioControlSetValue(1, &line_in_number, match_names);
442
443 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_RIGHT_LINEIN_SEL_NAME);
444 tmp_ret |= AudioControlSetValue(1, &line_in_number, match_names);
445
446 return tmp_ret;
447}
448
449int CAudioAlsa::SetInternalDacLineInCaptureVolume(int l_vol, int r_vol)
450{
451 int max_val = GetLineInMaxVol();
452 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LINEIN_CAPTURE_VOLUME_NAME);
453 int VolumeBuf[2];
454
455 VolumeBuf[0] = CheckVolume(l_vol, 0, max_val, 0, max_val);
456 VolumeBuf[1] = CheckVolume(r_vol, 0, max_val, 0, max_val);
457
458 return AudioControlSetValue(2, VolumeBuf, match_names);
459}
460
461int CAudioAlsa::GetInternalDacLineInCaptureVolume(int vol_buf[])
462{
463 int max_val = GetLineInMaxVol();
464 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LINEIN_CAPTURE_VOLUME_NAME);
465
466 return GetTwoChannelVolume(vol_buf, 0, max_val, 0, max_val, match_names, 0, max_val);
467}
468
469int CAudioAlsa::SetInternalDacLineOutPlayBackVolume(int l_vol, int r_vol)
470{
471 int max_val = GetLineOutMaxVol();
472 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LINEOUT_PLAYBACK_VOLUME_NAME);
473 int VolumeBuf[2];
474
475 VolumeBuf[0] = CheckVolume(l_vol, 0, max_val, 0, max_val);
476 VolumeBuf[1] = CheckVolume(r_vol, 0, max_val, 0, max_val);
477
478 return AudioControlSetValue(2, VolumeBuf, match_names);
479}
480
481int CAudioAlsa::GetInternalDacLineOutPlayBackVolume(int vol_buf[])
482{
483 int max_val = GetLineOutMaxVol();
484 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LINEOUT_PLAYBACK_VOLUME_NAME);
485
486 return GetTwoChannelVolume(vol_buf, 0, max_val, 0, max_val, match_names, 0, max_val);
487}
488
489int CAudioAlsa::SetAudioPcmPlaybackVolume(int vol)
490{
491 if (get_USB_Audio_card() == -EINVAL) return 0;
492 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_PCM_PLAYBACK_VOLUME);
493 return HandleUSBAudioControlValue(1, &vol, 1, &match_names);
494}
495
496int CAudioAlsa::SetAudioPcmPlaybackSwitch(int vol)
497{
498 if (get_USB_Audio_card() == -EINVAL) return 0;
499 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_PCM_PLAYBACK_SWITCH);
500 return HandleUSBAudioControlValue(1, &vol, 1, &match_names);
501}
502
503int CAudioAlsa::SetExternalDacChannelSwitch(int chan_ind, int switch_val)
504{
505 char *match_names = NULL;
506
507 if (chan_ind == 1) {
508 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_SWITCH_NAME);
509 } else if (chan_ind == 2) {
510 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_SWITCH_NAME);
511 } else if (chan_ind == 3) {
512 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_SWITCH_NAME);
513 } else {
514 return -1;
515 }
516
517 return AudioControlSetValue(1, &switch_val, match_names);
518}
519
520int CAudioAlsa::SetExternalDacChannelVolume(int chan_ind, int main_vol)
521{
522 int tmp_ret = 0;
523 char *match_names = NULL;
524
525 if (chan_ind == 0) {
526 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_MASTER_VOLUME_NAME);
527 } else if (chan_ind == 1) {
528 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_VOLUME_NAME);
529 } else if (chan_ind == 2) {
530 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_VOLUME_NAME);
531 } else if (chan_ind == 3) {
532 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_VOLUME_NAME);
533 } else {
534 return -1;
535 }
536
537 return AudioControlSetValue(1, &main_vol, match_names);
538}
539int CAudioAlsa::SetAudioSwitchIO(int value)
540{
541 char *match_names = gG9AlsaNames[CC_GET_ALSA_CTL_AUDIO_IN_SWITCH];
542
543 return AudioControlSetValue(1, &value, match_names);
544}
545int CAudioAlsa::SetOutput_Swap(int value)
546{
547 char *match_names = gG9AlsaNames[CC_GET_ALSA_CTL_SETOUTPUT_SWAP];
548
549 return AudioControlSetValue(1, &value, match_names);
550}
551
552int CAudioAlsa::SetExternalDacEQMode(int mode_val)
553{
554 char *match_names = NULL;
555
556 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_EQ_MODE_NAME);
557 return AudioControlSetValue(1, &mode_val, match_names);
558}
559
560int CAudioAlsa::SetI2SMute(int mute_status)
561{
562 char *match_names = NULL;
563
564 if (mute_status != CC_I2S_MUTE_ON && mute_status != CC_I2S_MUTE_OFF) {
565 LOGE("%s, I2S mute value (%d) error!\n", __FUNCTION__, mute_status);
566 return -1;
567 }
568
569 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_I2S_MUTE_NAME);
570 return AudioControlSetValue(1, &mute_status, match_names);
571}
572
573int CAudioAlsa::SetSPDIFMute(int mute_status)
574{
575 int set_val = 0;
576 char *match_names = NULL;
577
578 if (mute_status == CC_AUDIO_MUTE) {
579 set_val = CC_SPDIF_MUTE_ON;
580 } else if (mute_status == CC_AUDIO_UNMUTE) {
581 set_val = CC_SPDIF_MUTE_OFF;
582 } else {
583 return -1;
584 }
585 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_SPDIF_MUTE_NAME);
586 return AudioControlSetValue(1, &mute_status, match_names);
587}
588
589#define CC_SAMPLE_BUF_SIZE (32)
590
591enum CC_HW_RESAMPLE_TYPE {
592 CC_HW_RESAMPLE_DISABLE,
593 CC_HW_RESAMPLE_48K,
594 CC_HW_RESAMPLE_44K,
595 CC_HW_RESAMPLE_32K,
596};
597
598int CAudioAlsa::SetHardwareResample(int sr)
599{
600 int i = 0, set_val = 0, tmp_val = 0;
601 int diff_val = 0x7FFFFFFF, diff_ind = -1;
602 char *match_names = NULL;
603 int sample_buf[CC_SAMPLE_BUF_SIZE] = {48000, 44100, 32000, -1};
604
605 if (sr < 0) {
606 set_val = 0;
607 } else {
608 for (i = 0; i < CC_SAMPLE_BUF_SIZE; i++) {
609 if (sample_buf[i] < 0) {
610 break;
611 }
612
613 if (sample_buf[i] >= sr) {
614 tmp_val = sample_buf[i] - sr;
615 } else {
616 tmp_val = sr - sample_buf[i];
617 }
618
619 if (tmp_val <= diff_val) {
620 diff_val = tmp_val;
621 diff_ind = i;
622 }
623 }
624
625 if (diff_ind < 0) {
626 set_val = 0;
627 } else {
628 set_val = diff_ind + 1;
629 }
630 }
631
632 LOGD("%s, set_val = %d.\n", __FUNCTION__, set_val);
633 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_HW_RESAMPLE_NAME);
634 return AudioControlSetValue(1, &set_val, match_names);
635}
636
637int CAudioAlsa::SetMixerBypassSwitch(int switch_val)
638{
639 char match_names[48] = "Output Mixer Bypass Switch" ;
640 int ctl_buf[2];
641
642 if (switch_val != 0 && switch_val != 1) {
643 return -1;
644 }
645
646 ctl_buf[0] = switch_val;
647 ctl_buf[1] = switch_val;
648
649 return AudioControlSetValue(2, ctl_buf, match_names);
650}
651
652int CAudioAlsa::GetMixerBypassSwitch(void)
653{
654 char match_names[48] = "Output Mixer Bypass Switch" ;
655 int ctl_buf[2];
656
657 AudioControlSetValue(2, ctl_buf, match_names);
658
659 return ctl_buf[0];
660}
661
662int CAudioAlsa::SetMixerDacSwitch(int switch_val)
663{
664 char match_names[48] = "Output Mixer DAC Switch" ;
665 int ctl_buf[2];
666
667 if (switch_val != 0 && switch_val != 1) {
668 return -1;
669 }
670
671 ctl_buf[0] = switch_val;
672 ctl_buf[1] = switch_val;
673
674 return AudioControlSetValue(2, ctl_buf, match_names);
675}
676
677int CAudioAlsa::GetMixerDacSwitch(void)
678{
679 char *match_names = "Output Mixer DAC Switch" ;
680 int ctl_buf[2];
681
682 AudioControlGetValue(2, ctl_buf, match_names);
683
684 return ctl_buf[0];
685}
686
687int CAudioAlsa::TransVolumeBarVolToDigitalVol(int digit_lut_buf[], int digit_vol)
688{
689
690 return digit_lut_buf[digit_vol];
691}
692
693int CAudioAlsa::TransDigitalVolToVolumeBarVol(int digit_lut_buf[], int hd_vol, int hd_min,
694 int hd_max, int digit_min, int digit_max)
695{
696 int i;
697
698
699 for (i = 0; i < CC_VOL_TRANS_LUT_BUF_SIZE - 1; i++) {
700 if (digit_lut_buf[i] >= hd_vol && digit_lut_buf[i + 1] < hd_vol)
701 break;
702 }
703
704 if (i < CC_VOL_TRANS_LUT_BUF_SIZE - 1)
705 return i;
706
707 return digit_max;
708}
709
710void CAudioAlsa::SetMainVolDigitLutBuf(int digit_lut_buf[])
711{
712 memcpy((void *) mMainDigitLutBuf, digit_lut_buf,
713 CC_VOL_TRANS_LUT_BUF_SIZE * sizeof(int));
714}
715
716int *CAudioAlsa::GetMainVolDigitLutBuf()
717{
718 return mMainDigitLutBuf;
719}
720void CAudioAlsa::SetSupperBassVolDigitLutBuf(int digit_lut_buf[])
721{
722 memcpy((void *) mSupperBassDigitLutBuf, digit_lut_buf,
723 CC_VOL_TRANS_LUT_BUF_SIZE * sizeof(int));
724}
725
726
727int CAudioAlsa::SetMainVolumeGain(int gain_val)
728{
729 mMainVolumeGainVal = gain_val;
730 return mMainVolumeGainVal;
731}
732
733int CAudioAlsa::GetMainVolumeGain()
734{
735 return mMainVolumeGainVal;
736}
737
738int CAudioAlsa::SetSupperBassVolumeGain(int gain_val)
739{
740 int tmp_val = 0;
741 tmp_val = mSupperBassVolumeGainVal;
742 mSupperBassVolumeGainVal = gain_val;
743 return tmp_val;
744}
745
746int CAudioAlsa::GetSupperBassVolumeGain()
747{
748 int tmp_val = 0;
749 tmp_val = mSupperBassVolumeGainVal;
750 return tmp_val;
751}
752
753
754int CAudioAlsa::CalculateBalanceVol(int max_vol, int balance_val, int vol_buf[])
755{
756 int bal_mid_vol = 0, bal_cal_len = 0;
757 int tmp_val = 0;
758
759
760 vol_buf[0] = max_vol;
761 vol_buf[1] = max_vol;
762
763 bal_mid_vol = (CC_MIN_SOUND_BALANCE_VAL + CC_MAX_SOUND_BALANCE_VAL) / 2;
764 bal_cal_len = (CC_MAX_SOUND_BALANCE_VAL - CC_MIN_SOUND_BALANCE_VAL) / 2;
765
766 if (balance_val == bal_mid_vol) {
767 LOGD(
768 "%s, balance value = %d, bal_mid_vol = %d, vol_buf[0] = %d, vol_buf[1] = %d.\n",
769 __FUNCTION__, balance_val, bal_mid_vol, vol_buf[0], vol_buf[1]);
770 return 0;
771 } else if (balance_val < bal_mid_vol) {
772 vol_buf[1] = (bal_cal_len - (bal_mid_vol - balance_val)) * max_vol / bal_cal_len;
773 } else if (balance_val > bal_mid_vol) {
774 vol_buf[0] = (bal_cal_len - (balance_val - bal_mid_vol)) * max_vol / bal_cal_len;
775 }
776
777 if (GetAudioAmplifierBalanceExchangeCFG() != 0) {
778 tmp_val = vol_buf[0];
779 vol_buf[0] = vol_buf[1];
780 vol_buf[1] = tmp_val;
781 }
782
783 LOGD(
784 "%s, balance value = %d, bal_mid_vol = %d, vol_buf[0] = %d, vol_buf[1] = %d.\n",
785 __FUNCTION__, balance_val, bal_mid_vol, vol_buf[0], vol_buf[1]);
786 return 0;
787}
788
789
790int CAudioAlsa::SetInternalDacMute(int mute_state)
791{
792 int ret = 0;
793 if (mute_state == CC_AUDIO_MUTE)
794 ret = SetAudioInternalDacDACDigitalPlayBackVolume(0, 0);
795 else
796 ret = SetAudioInternalDacDACDigitalPlayBackVolume(255, 255);
797 return ret;
798}
799
800int CAudioAlsa::setAudioPcmPlaybackMute(int mute_state)
801{
802 char prop[256];
803 property_get("audio.output.double_output", prop, "null");
804 if ( Get2d4gHeadsetEnable() == 1 && (strcmp(prop, "0") == 0 || strcmp(prop, "null") == 0)) {
805 SetAudioPcmPlaybackSwitch(mute_state);
806 }
807 return 0;
808}
809
810
811int CAudioAlsa::SetInternalDacMainVolume(int main_vol)
812{
813 int tmp_ret = 0, digit_vol = 0;
814 digit_vol = TransVolumeBarVolToDigitalVol(mMainDigitLutBuf, main_vol);
815
816 return SetInternalDacLineOutPlayBackVolume(digit_vol, digit_vol);
817}
818
819
820static int gDigitalMuteStatus = CC_AUDIO_UNMUTE;
821static int gDigitalLeftVol = 0;
822static int gDigitalRightVol = 0;
823
824int CAudioAlsa::SetDigitalVolume(int l_val, int r_val)
825{
826 amAudioSetLeftGain(l_val);
827 amAudioSetRightGain(r_val);
828 LOGD("%s, l_val = %d, r_val = %d.\n", __FUNCTION__, l_val, r_val);
829 return 0;
830}
831
832int CAudioAlsa::SetDigitalMainVolume(int l_vol, int r_vol)
833{
834 int tmp_ret = 0, l_val = 0, r_val = 0;
835
836 //handle l&r channel volume for balance
837 l_val = TransVolumeBarVolToDigitalVol(mMainDigitLutBuf, l_vol);
838 r_val = TransVolumeBarVolToDigitalVol(mMainDigitLutBuf, r_vol);
839
840 gDigitalLeftVol = l_val;
841 gDigitalRightVol = r_val;
842 if (gDigitalMuteStatus == CC_AUDIO_UNMUTE) {
843 SetDigitalVolume(l_val, r_val);
844 }
845
846 return tmp_ret;
847}
848
849int CAudioAlsa::SetDigitalMute(int mute_status)
850{
851 gDigitalMuteStatus = mute_status;
852 if (mute_status == CC_AUDIO_MUTE) {
853 SetDigitalVolume(0, 0);
854 } else if (mute_status == CC_AUDIO_UNMUTE) {
855 SetDigitalVolume(gDigitalLeftVol, gDigitalRightVol);
856 }
857
858 return 0;
859}
860
861
generated by cgit at 2024-05-10 00:55:06 (GMT)