summaryrefslogtreecommitdiff
path: root/tvapi/libtv/audio/audio_alsa.cpp (plain)
blob: 84ce046fe9d6ac0da43b0979b155934332d0a049
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 <dlfcn.h>
13#include <tinyalsa/asoundlib.h>
14#include "CFbcCommunication.h"
15#include <sys/poll.h>
16#include <android/log.h>
17#include "tvsetting/audio_cfg.h"
18#include "audio_alsa.h"
19#include <cutils/properties.h>
20#define LOG_TAG "CAudioAlsa"
21#include "CTvLog.h"
22#include "audio_amaudio.h"
23
24static const int MainDigitLutBuf[CC_VOL_TRANS_LUT_BUF_SIZE] = {
25 //
26 0, 40, 50, 60, 70, 87, 110, 120, 130, 140, // 0~9
27 150, 152, 155, 158, 161, 164, 167, 170, 173, 174, // 10~19
28 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, // 20~29
29 191, 191, 192, 193, 194, 195, 196, 196, 197, 197, // 30~39
30 198, 198, 198, 199, 199, 200, 200, 201, 201, 201, // 40~49
31 202, 202, 202, 203, 203, 203, 203, 204, 204, 204, // 50~59
32 205, 205, 205, 205, 206, 206, 206, 206, 206, 207, // 60~69
33 207, 207, 207, 207, 207, 207, 207, 208, 208, 208, // 70~79
34 208, 208, 208, 208, 208, 208, 208, 208, 208, 209, // 80~89
35 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, // 90~99
36 209, // 100
37};
38
39static const int SupperBassDigitLutBuf[CC_VOL_TRANS_LUT_BUF_SIZE] = {
40 //
41 0, 122, 123, 124, 125, 126, 127, 128, 129, 130, // 0~9
42 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, // 10~19
43 141, 142, 143, 144, 145, 147, 147, 148, 148, 149, // 20~29
44 149, 150, 150, 151, 151, 152, 152, 153, 153, 154, // 30~39
45 154, 155, 155, 156, 156, 157, 157, 158, 158, 159, // 40~49
46 160, 160, 160, 160, 161, 161, 161, 161, 162, 162, // 50~59
47 162, 163, 163, 163, 163, 164, 164, 164, 165, 165, // 60~69
48 165, 165, 166, 166, 166, 167, 168, 169, 170, 171, // 70~79
49 173, 174, 175, 176, 177, 179, 180, 181, 182, 183, // 80~89
50 185, 186, 187, 188, 189, 191, 192, 193, 194, 195, // 90~99
51 197 // 100
52};
53
54CAudioAlsa::CAudioAlsa()
55{
56 int card_id;
57 card_id = get_aml_card();
58 LOGD("[%s:%d] card_id:%d\n", __FUNCTION__, __LINE__, card_id);
59 mpMixer = mixer_open(card_id);
60
61 card_id = get_USB_Audio_card();
62 LOGD("[%s:%d] card_id:%d\n", __FUNCTION__, __LINE__, card_id);
63 mpUsbMixer = mixer_open(card_id);
64 mMainVolumeBalanceVal = 0;
65 mMainVolumeGainVal = 0;
66 mSupperBassVolumeGainVal = 0;
67 memcpy(mMainDigitLutBuf, MainDigitLutBuf, CC_VOL_TRANS_LUT_BUF_SIZE);
68 memcpy(mSupperBassDigitLutBuf, SupperBassDigitLutBuf, CC_VOL_TRANS_LUT_BUF_SIZE);
69}
70
71CAudioAlsa::~CAudioAlsa()
72{
73 if (NULL != mpMixer) {
74 mixer_close(mpMixer);
75 }
76
77 if (NULL != mpUsbMixer) {
78 mixer_close(mpUsbMixer);
79 }
80}
81
82int CAudioAlsa::get_aml_card()
83{
84 int card = -1, err = 0;
85 int fd = -1;
86 char read_buf[512], *pd = NULL;
87 static const char *const SOUND_CARDS_PATH = "/proc/asound/cards";
88 fd = open(SOUND_CARDS_PATH, O_RDONLY);
89 if (fd < 0) {
90 ALOGE("ERROR: failed to open config file %s error: %d\n", SOUND_CARDS_PATH, errno);
91 close(fd);
92 return -EINVAL;
93 }
94 memset(read_buf, 0x0, 512);
95 err = read(fd, read_buf, 512);
96 if (fd < 0) {
97 ALOGE("ERROR: failed to read config file %s error: %d\n", SOUND_CARDS_PATH, errno);
98 close(fd);
99 return -EINVAL;
100 }
101 pd = strstr(read_buf, "AML");
102 card = *(pd - 3) - '0';
103 close(fd);
104 return card;
105}
106
107int CAudioAlsa::AudioControlSetValue(int val_count, int data_buf[], char *match_names)
108{
109 struct mixer_ctl *pctl;
110 unsigned int expected_val_count;
111 unsigned int value_index;
112
113 if (NULL == mpMixer) {
114 LOGE("[%s:%d] Failed to open mixer\n", __FUNCTION__, __LINE__);
115 goto err_exit;
116 }
117
118 pctl = mixer_get_ctl_by_name(mpMixer, match_names);
119 if (NULL == pctl) {
120 LOGE("[%s:%d] Failed to get mixer control for:%s\n", __FUNCTION__, __LINE__, match_names);
121 goto err_exit;
122 }
123 expected_val_count = mixer_ctl_get_num_values(pctl);
124 if (expected_val_count != (unsigned int)val_count) {
125 LOGE("[%s:%d] val_count != expected_val_count\n", __FUNCTION__, __LINE__);
126 goto err_exit;
127 }
128 for (value_index = 0; value_index < expected_val_count; value_index++) {
129 if (mixer_ctl_set_value(pctl, value_index, data_buf[value_index]) != 0) {
130 LOGE("[%s:%d] Failed to set value:%d\n", __FUNCTION__, __LINE__, value_index);
131 goto err_exit;
132 }
133 }
134 return 0;
135err_exit:
136 return -1;
137}
138
139int CAudioAlsa::AudioControlGetValue(int val_count, int ret_buf[], char *match_names)
140{
141 struct mixer_ctl *pctl;
142 unsigned int expected_val_count;
143 unsigned int value_index;
144
145 if (NULL == mpMixer) {
146 LOGE("[%s:%d] Failed to open mixer\n", __FUNCTION__, __LINE__);
147 goto err_exit;
148 }
149 pctl = mixer_get_ctl_by_name(mpMixer, match_names);
150 if (NULL == pctl) {
151 LOGE("[%s:%d] Failed to get mixer control for:%s\n", __FUNCTION__, __LINE__, match_names);
152 goto err_exit;
153 }
154 expected_val_count = mixer_ctl_get_num_values(pctl);
155 if (expected_val_count != (unsigned int)val_count) {
156 LOGE("[%s:%d] val_count != expected_val_count\n", __FUNCTION__, __LINE__);
157 goto err_exit;
158 }
159 for (value_index = 0; value_index < expected_val_count; value_index++) {
160 ret_buf[value_index] = mixer_ctl_get_value(pctl, value_index);
161 }
162 return 0;
163err_exit:
164 return -1;
165}
166
167int CAudioAlsa::get_USB_Audio_card()
168{
169 int card = -1, err = 0;
170 int fd = -1;
171 char read_buf[512], *pd = NULL;
172 static const char *const SOUND_CARDS_PATH = "/proc/asound/cards";
173 fd = open(SOUND_CARDS_PATH, O_RDONLY);
174 if (fd < 0) {
175 ALOGE("ERROR: failed to open config file %s error: %d\n", SOUND_CARDS_PATH, errno);
176 close(fd);
177 return -EINVAL;
178 }
179 memset(read_buf, 0x0, 512);
180 err = read(fd, read_buf, 512);
181 if (fd < 0) {
182 ALOGE("ERROR: failed to read config file %s error: %d\n", SOUND_CARDS_PATH, errno);
183 close(fd);
184 return -EINVAL;
185 }
186 pd = strstr(read_buf, "Receiver");
187 if (pd == NULL) {
188 ALOGE("ERROR: failed to read config file %s error: %d\n", SOUND_CARDS_PATH, errno);
189 close(fd);
190 return -EINVAL;
191 }
192
193 card = *(pd - 3) - '0';
194 close(fd);
195 return card;
196}
197
198int CAudioAlsa::HandleUSBAudioControlValue(int val_count, int data_buf[], int match_count, char **match_names)
199{
200
201 struct mixer_ctl *pctl;
202 unsigned int expected_val_count;
203 unsigned int match_index;
204 unsigned int value_index;
205 char card_id_str[9] = {0};
206
207 if (NULL == mpUsbMixer) {
208 LOGE("[%s:%d] Failed to open mixer\n", __FUNCTION__, __LINE__);
209 goto err_exit;
210 }
211
212 for (match_index = 0; match_index < match_count; match_index++) {
213 pctl = mixer_get_ctl_by_name(mpUsbMixer, match_names[match_index]);
214 if (NULL == pctl) {
215 LOGE("[%s:%d] Failed to get mixer control for:%s\n", __FUNCTION__, __LINE__, match_names[match_index]);
216 goto err_exit;
217 }
218 expected_val_count = mixer_ctl_get_num_values(pctl);
219 if (expected_val_count != (unsigned int)val_count) {
220 LOGE("[%s:%d] val_count != expected_val_count\n", __FUNCTION__, __LINE__);
221 goto err_exit;
222 }
223 for (value_index = 0; value_index < expected_val_count; value_index++) {
224 if (mixer_ctl_set_value(pctl, value_index, data_buf[value_index]) != 0) {
225 LOGE("[%s:%d] Failed to set value:%d\n", __FUNCTION__, __LINE__, value_index);
226 goto err_exit;
227 }
228 }
229 }
230
231 return 0;
232err_exit:
233 return -1;
234}
235
236int CAudioAlsa::CheckVolume(int digit_vol, int digit_min, int digit_max, int hd_min,
237 int hd_max)
238{
239 int tmp_val = digit_vol;
240
241 if (digit_vol < hd_min) {
242 return hd_min;
243 } else if (digit_vol > hd_max) {
244 return hd_max;
245 }
246
247 return digit_vol;
248}
249
250int CAudioAlsa::GetTwoChannelVolume(int vol_buf[], int l_min_vol, int l_max_vol,
251 int r_min_vol, int r_max_vol, char *match_names, int hd_min,
252 int hd_max)
253{
254 vol_buf[0] = 0;
255 vol_buf[1] = 0;
256 return AudioControlGetValue(2, vol_buf, match_names);
257}
258
259int CAudioAlsa::GetLineInMaxVol()
260{
261 if (GetAudioArchitectureTypeCFG() == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
262 return 84;
263 }
264
265 return 127;
266}
267
268int CAudioAlsa::GetLineOutMaxVol()
269{
270 if (GetAudioArchitectureTypeCFG() == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
271 return 84;
272 }
273
274 return 255;
275}
276
277#define CC_GET_ALSA_CTL_AUDIO_IN_SOURCE_NAME (0)
278#define CC_GET_ALSA_CTL_INTERNAL_DAC_LEFT_LINEIN_SEL_NAME (1)
279#define CC_GET_ALSA_CTL_INTERNAL_DAC_RIGHT_LINEIN_SEL_NAME (2)
280#define CC_GET_ALSA_CTL_INTERNAL_DAC_LINEIN_CAPTURE_VOLUME_NAME (3)
281#define CC_GET_ALSA_CTL_INTERNAL_DAC_LINEOUT_PLAYBACK_VOLUME_NAME (4)
282#define CC_GET_ALSA_CTL_I2S_MUTE_NAME (5)
283#define CC_GET_ALSA_CTL_SPDIF_MUTE_NAME (6)
284#define CC_GET_ALSA_CTL_HW_RESAMPLE_NAME (7)
285#define CC_GET_ALSA_CTL_EXTERNAL_DAC_MASTER_VOLUME_NAME (8)
286#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_VOLUME_NAME (9)
287#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_VOLUME_NAME (10)
288#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_VOLUME_NAME (11)
289#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_SWITCH_NAME (12)
290#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_SWITCH_NAME (13)
291#define CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_SWITCH_NAME (14)
292#define CC_GET_ALSA_CTL_EXTERNAL_DAC_EQ_MODE_NAME (15)
293#define CC_GET_ALSA_CTL_PCM_PLAYBACK_VOLUME (16)
294#define CC_GET_ALSA_CTL_PCM_PLAYBACK_SWITCH (17)
295#define CC_GET_ALSA_CTL_SETOUTPUT_SWAP (18)
296#define CC_GET_ALSA_CTL_AUDIO_IN_SWITCH (19)
297
298static char gG9AlsaNames[32][48] = {
299 {"Audio In Source"},//0
300 {"Linein right switch"},//1
301 {"Linein left switch"},
302 {"ADC Digital Capture Volume"},
303 {"DAC Digital Playback Volume"},
304 {"Audio i2s mute"},//5
305 {"Audio spdif mute"},
306 {"Hardware resample enable"},//8
307 {"AMP Master Volume"},
308 {"AMP Ch1 Volume"},//10
309 {"AMP Ch2 Volume"},
310 {"AMP Ch3 Volume"},
311 {"AMP Ch1 Switch"},
312 {"AMP Ch2 Switch"},
313 {"AMP Ch3 Switch"},//15
314 {"AMP EQ Mode"},
315 {"PCM Playback Volume"},
316 {"PCM Playback Switch"},
317 {"Output Swap"},
318 {"AudioIn Switch"},//19
319};
320
321
322char *CAudioAlsa::GetAlsaControlName(int get_type)
323{
324 if (GetAudioArchitectureTypeCFG() == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
325 /*if(get_type == CC_GET_ALSA_CTL_AUDIO_IN_SOURCE_NAME) {
326 return gAudioInSourceNameBuf;
327 } else if(get_type == CC_GET_ALSA_CTL_INTERNAL_DAC_LEFT_LINEIN_SEL_NAME) {
328 strcpy(gInternalDacLeftLineInSelNameBuf, "Left LINEIN Select");
329 return gInternalDacLeftLineInSelNameBuf;
330 } else if(get_type == CC_GET_ALSA_CTL_INTERNAL_DAC_RIGHT_LINEIN_SEL_NAME) {
331 strcpy(gInternalDacRightLineInSelNameBuf, "Right LINEIN Select");
332 return gInternalDacRightLineInSelNameBuf;
333 } else if (get_type == CC_GET_ALSA_CTL_INTERNAL_DAC_LINEIN_CAPTURE_VOLUME_NAME) {
334 strcpy(gInternalDacLineInCaptureVolumeNameBuf, "LINEIN Capture Volume");
335 return gInternalDacLineInCaptureVolumeNameBuf;
336 } else if (get_type == CC_GET_ALSA_CTL_INTERNAL_DAC_LINEOUT_PLAYBACK_VOLUME_NAME) {
337 strcpy(gInternalDacLineOutCaptureVolumeNameBuf, "LINEOUT Playback Volume");
338 return gInternalDacLineOutCaptureVolumeNameBuf;
339 } else if(get_type == CC_GET_ALSA_CTL_I2S_MUTE_NAME) {
340 strcpy(gI2SMuteNameBuf, "Audio i2s mute");
341 return gI2SMuteNameBuf;
342 } else if(get_type == CC_GET_ALSA_CTL_SPDIF_MUTE_NAME) {
343 strcpy(gSpdifMuteNameBuf, "Audio spdif mute");
344 return gSpdifMuteNameBuf;
345 } else if(get_type == CC_GET_ALSA_CTL_HW_RESAMPLE_NAME) {
346 strcpy(gHWResampleNameBuf, "Hardware resample enable");
347 return gHWResampleNameBuf;
348 } else if(get_type == CC_GET_ALSA_CTL_EXTERNAL_DAC_MASTER_VOLUME_NAME) {
349 strcpy(gExternalDacMasterVolumeNameBuf, "AMP Master Volume");
350 return gExternalDacMasterVolumeNameBuf;
351 } else if(get_type == CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_VOLUME_NAME) {
352 strcpy(gExternalDacCh1VolumeNameBuf, "AMP Ch1 Volume");
353 return gExternalDacCh1VolumeNameBuf;
354 } else if(get_type == CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_VOLUME_NAME) {
355 strcpy(gExternalDacCh2VolumeNameBuf, "AMP Ch2 Volume");
356 return gExternalDacCh2VolumeNameBuf;
357 } else if(get_type == CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_VOLUME_NAME) {
358 strcpy(gExternalDacCh3VolumeNameBuf, "AMP Ch3 Volume");
359 return gExternalDacCh3VolumeNameBuf;
360 } else if(get_type == CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_SWITCH_NAME) {
361 strcpy(gExternalDacCh1SwitchNameBuf, "AMP Ch1 Switch");
362 return gExternalDacCh1SwitchNameBuf;
363 } else if(get_type == CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_SWITCH_NAME) {
364 strcpy(gExternalDacCh2SwitchNameBuf, "AMP Ch2 Switch");
365 return gExternalDacCh2SwitchNameBuf;
366 } else if(get_type == CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_SWITCH_NAME) {
367 strcpy(gExternalDacCh3SwitchNameBuf, "AMP Ch3 Switch");
368 return gExternalDacCh3SwitchNameBuf;
369 } else if(get_type == CC_GET_ALSA_CTL_EXTERNAL_DAC_EQ_MODE_NAME) {
370 strcpy(gExternalDacEQModeNameBuf, "AMP EQ Mode");
371 return gExternalDacEQModeNameBuf;
372 }*/
373 } else {
374 return gG9AlsaNames[get_type];
375 }
376
377 return NULL;
378}
379
380int gAudioInSource = -1;
381
382int CAudioAlsa::SetAudioInSource(int source_type)
383{
384 int set_val = 0;
385 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_AUDIO_IN_SOURCE_NAME);
386
387 if (GetAudioArchitectureTypeCFG() == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
388 if (source_type != 0 && source_type != 1) {
389 return -1;
390 }
391
392 if (source_type == CC_AUDIO_IN_SOURCE_LINEIN) {
393 set_val = 0;
394 } else if (source_type == CC_AUDIO_IN_SOURCE_HDMI) {
395 set_val = 1;
396 }
397 } else {
398 if (source_type != 0 && source_type != 1 && source_type != 2) {
399 return -1;
400 }
401
402 set_val = source_type;
403 }
404
405 gAudioInSource = set_val;
406
407 return AudioControlSetValue(1, &set_val, match_names);
408}
409
410int CAudioAlsa::GetAudioInSource(void)
411{
412 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_AUDIO_IN_SOURCE_NAME);
413 int source_type = 0;
414
415 source_type = gAudioInSource;
416 if (source_type == -1) {
417 AudioControlGetValue(1, &source_type, match_names);
418 }
419
420 return source_type;
421}
422
423int CAudioAlsa::SetInternalDacLineInSelectChannel(int line_in_number)
424{
425 int tmp_ret = 0;
426 char *match_names = NULL;
427
428 if (line_in_number < 0 || line_in_number > 7) {
429 return -1;
430 }
431
432 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LEFT_LINEIN_SEL_NAME);
433 tmp_ret |= AudioControlSetValue(1, &line_in_number, match_names);
434
435 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_RIGHT_LINEIN_SEL_NAME);
436 tmp_ret |= AudioControlSetValue(1, &line_in_number, match_names);
437
438 return tmp_ret;
439}
440
441int CAudioAlsa::SetInternalDacLineInCaptureVolume(int l_vol, int r_vol)
442{
443 int max_val = GetLineInMaxVol();
444 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LINEIN_CAPTURE_VOLUME_NAME);
445 int VolumeBuf[2];
446
447 VolumeBuf[0] = CheckVolume(l_vol, 0, max_val, 0, max_val);
448 VolumeBuf[1] = CheckVolume(r_vol, 0, max_val, 0, max_val);
449
450 return AudioControlSetValue(2, VolumeBuf, match_names);
451}
452
453int CAudioAlsa::GetInternalDacLineInCaptureVolume(int vol_buf[])
454{
455 int max_val = GetLineInMaxVol();
456 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LINEIN_CAPTURE_VOLUME_NAME);
457
458 return GetTwoChannelVolume(vol_buf, 0, max_val, 0, max_val, match_names, 0, max_val);
459}
460
461int CAudioAlsa::SetInternalDacLineOutPlayBackVolume(int l_vol, int r_vol)
462{
463 int max_val = GetLineOutMaxVol();
464 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LINEOUT_PLAYBACK_VOLUME_NAME);
465 int VolumeBuf[2];
466
467 VolumeBuf[0] = CheckVolume(l_vol, 0, max_val, 0, max_val);
468 VolumeBuf[1] = CheckVolume(r_vol, 0, max_val, 0, max_val);
469
470 return AudioControlSetValue(2, VolumeBuf, match_names);
471}
472
473int CAudioAlsa::GetInternalDacLineOutPlayBackVolume(int vol_buf[])
474{
475 int max_val = GetLineOutMaxVol();
476 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_INTERNAL_DAC_LINEOUT_PLAYBACK_VOLUME_NAME);
477
478 return GetTwoChannelVolume(vol_buf, 0, max_val, 0, max_val, match_names, 0, max_val);
479}
480
481int CAudioAlsa::SetAudioPcmPlaybackVolume(int vol)
482{
483 if(get_USB_Audio_card() == -EINVAL) return 0;
484 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_PCM_PLAYBACK_VOLUME);
485 return HandleUSBAudioControlValue(1, &vol, 1, &match_names);
486}
487
488int CAudioAlsa::SetAudioPcmPlaybackSwitch(int vol)
489{
490 if(get_USB_Audio_card() == -EINVAL) return 0;
491 char *match_names = GetAlsaControlName(CC_GET_ALSA_CTL_PCM_PLAYBACK_SWITCH);
492 return HandleUSBAudioControlValue(1, &vol, 1, &match_names);
493}
494
495int CAudioAlsa::SetExternalDacChannelSwitch(int chan_ind, int switch_val)
496{
497 char *match_names = NULL;
498
499 if (chan_ind == 1) {
500 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_SWITCH_NAME);
501 } else if (chan_ind == 2) {
502 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_SWITCH_NAME);
503 } else if (chan_ind == 3) {
504 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_SWITCH_NAME);
505 } else {
506 return -1;
507 }
508
509 return AudioControlSetValue(1, &switch_val, match_names);
510}
511
512int CAudioAlsa::SetExternalDacChannelVolume(int chan_ind, int main_vol)
513{
514 int tmp_ret = 0;
515 char *match_names = NULL;
516
517 if (chan_ind == 0) {
518 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_MASTER_VOLUME_NAME);
519 } else if (chan_ind == 1) {
520 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH1_VOLUME_NAME);
521 } else if (chan_ind == 2) {
522 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH2_VOLUME_NAME);
523 } else if (chan_ind == 3) {
524 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_CH3_VOLUME_NAME);
525 } else {
526 return -1;
527 }
528
529 return AudioControlSetValue(1, &main_vol, match_names);
530}
531int CAudioAlsa::SetAudioSwitchIO(int value)
532{
533 char *match_names = gG9AlsaNames[CC_GET_ALSA_CTL_AUDIO_IN_SWITCH];
534
535 return AudioControlSetValue(1, &value, match_names);
536}
537int CAudioAlsa::SetOutput_Swap(int value)
538{
539 char *match_names = gG9AlsaNames[CC_GET_ALSA_CTL_SETOUTPUT_SWAP];
540
541 return AudioControlSetValue(1, &value, match_names);
542}
543
544int CAudioAlsa::SetExternalDacEQMode(int mode_val)
545{
546 char *match_names = NULL;
547
548 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_EXTERNAL_DAC_EQ_MODE_NAME);
549 return AudioControlSetValue(1, &mode_val, match_names);
550}
551
552int CAudioAlsa::SetI2SMute(int mute_status)
553{
554 char *match_names = NULL;
555
556 if (mute_status != CC_I2S_MUTE_ON && mute_status != CC_I2S_MUTE_OFF) {
557 LOGE("%s, I2S mute value (%d) error!\n", __FUNCTION__, mute_status);
558 return -1;
559 }
560
561 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_I2S_MUTE_NAME);
562 return AudioControlSetValue(1, &mute_status, match_names);
563}
564
565int CAudioAlsa::SetSPDIFMute(int mute_status)
566{
567 char *match_names = NULL;
568
569 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_SPDIF_MUTE_NAME);
570 return AudioControlSetValue(1, &mute_status, match_names);
571}
572
573#define CC_SAMPLE_BUF_SIZE (32)
574
575enum CC_HW_RESAMPLE_TYPE {
576 CC_HW_RESAMPLE_DISABLE,
577 CC_HW_RESAMPLE_48K,
578 CC_HW_RESAMPLE_44K,
579 CC_HW_RESAMPLE_32K,
580};
581
582int CAudioAlsa::SetHardwareResample(int sr)
583{
584 int i = 0, set_val = 0, tmp_val = 0;
585 int diff_val = 0x7FFFFFFF, diff_ind = -1;
586 char *match_names = NULL;
587 int sample_buf[CC_SAMPLE_BUF_SIZE] = {48000, 44000, 32000, -1};
588
589 if (sr < 0) {
590 set_val = 0;
591 } else {
592 for (i = 0; i < CC_SAMPLE_BUF_SIZE; i++) {
593 if (sample_buf[i] < 0) {
594 break;
595 }
596
597 if (sample_buf[i] >= sr) {
598 tmp_val = sample_buf[i] - sr;
599 } else {
600 tmp_val = sr - sample_buf[i];
601 }
602
603 if (tmp_val <= diff_val) {
604 diff_val = tmp_val;
605 diff_ind = i;
606 }
607 }
608
609 if (diff_ind < 0) {
610 set_val = 0;
611 } else {
612 set_val = diff_ind + 1;
613 }
614 }
615
616 LOGD("%s, set_val = %d.\n", __FUNCTION__, set_val);
617 match_names = GetAlsaControlName(CC_GET_ALSA_CTL_HW_RESAMPLE_NAME);
618 return AudioControlSetValue(1, &set_val, match_names);
619}
620
621int CAudioAlsa::SetMixerBypassSwitch(int switch_val)
622{
623 char match_names[48] = "Output Mixer Bypass Switch" ;
624 int ctl_buf[2];
625
626 if (switch_val != 0 && switch_val != 1) {
627 return -1;
628 }
629
630 ctl_buf[0] = switch_val;
631 ctl_buf[1] = switch_val;
632
633 return AudioControlSetValue(2, ctl_buf, match_names);
634}
635
636int CAudioAlsa::GetMixerBypassSwitch(void)
637{
638 char match_names[48] = "Output Mixer Bypass Switch" ;
639 int ctl_buf[2];
640
641 AudioControlSetValue(2, ctl_buf, match_names);
642
643 return ctl_buf[0];
644}
645
646int CAudioAlsa::SetMixerDacSwitch(int switch_val)
647{
648 char match_names[48] = "Output Mixer DAC Switch" ;
649 int ctl_buf[2];
650
651 if (switch_val != 0 && switch_val != 1) {
652 return -1;
653 }
654
655 ctl_buf[0] = switch_val;
656 ctl_buf[1] = switch_val;
657
658 return AudioControlSetValue(2, ctl_buf, match_names);
659}
660
661int CAudioAlsa::GetMixerDacSwitch(void)
662{
663 char *match_names = "Output Mixer DAC Switch" ;
664 int ctl_buf[2];
665
666 AudioControlGetValue(2, ctl_buf, match_names);
667
668 return ctl_buf[0];
669}
670
671int CAudioAlsa::TransVolumeBarVolToDigitalVol(int digit_lut_buf[], int digit_vol,
672 int digit_min, int digit_max, int hd_min, int hd_max)
673{
674 if (digit_vol >= CC_VOL_TRANS_LUT_BUF_SIZE) {
675 return digit_lut_buf[CC_VOL_TRANS_LUT_BUF_SIZE - 1];
676 } else if (digit_vol < 0) {
677 return digit_lut_buf[CC_VOL_TRANS_LUT_BUF_SIZE - 1];
678 }
679
680 return digit_lut_buf[digit_vol];
681}
682
683int CAudioAlsa::TransDigitalVolToVolumeBarVol(int digit_lut_buf[], int hd_vol, int hd_min,
684 int hd_max, int digit_min, int digit_max)
685{
686 int i;
687
688 for (i = 0; i < CC_VOL_TRANS_LUT_BUF_SIZE; i++) {
689 if (digit_lut_buf[i] == hd_vol)
690 break;
691 }
692
693 if (i < CC_VOL_TRANS_LUT_BUF_SIZE)
694 return i;
695
696 for (i = 0; i < CC_VOL_TRANS_LUT_BUF_SIZE - 1; i++) {
697 if (digit_lut_buf[i] > hd_vol && digit_lut_buf[i + 1] < hd_vol)
698 break;
699 }
700
701 if (i < CC_VOL_TRANS_LUT_BUF_SIZE - 1)
702 return i;
703
704 return digit_max;
705}
706
707void CAudioAlsa::SetMainVolDigitLutBuf(int digit_lut_buf[])
708{
709 memcpy((void *) mMainDigitLutBuf, digit_lut_buf,
710 CC_VOL_TRANS_LUT_BUF_SIZE * sizeof(int));
711}
712
713void CAudioAlsa::SetSupperBassVolDigitLutBuf(int digit_lut_buf[])
714{
715 memcpy((void *) mSupperBassDigitLutBuf, digit_lut_buf,
716 CC_VOL_TRANS_LUT_BUF_SIZE * sizeof(int));
717}
718
719int CAudioAlsa::SetDacMute(int mute_state, int mute_type)
720{
721 int tmp_ret = 0;
722
723 if (mute_type & CC_DAC_MUTE_TYPE_INTERNAL) {
724 tmp_ret |= SetInternalDacMute(mute_state);
725 }
726
727 if (mute_type & CC_DAC_MUTE_TYPE_EXTERNAL) {
728 tmp_ret |= SetExternalDacMute(mute_state);
729 setAudioPcmPlaybackMute(mute_state);
730 }
731
732 return tmp_ret;
733}
734
735int CAudioAlsa::SetDacMainVolume(int main_vol)
736{
737 int tmp_ret = 0;
738 int aud_arch_type = GetAudioArchitectureTypeCFG();
739
740 if (aud_arch_type == CC_DAC_T866_INTERNAL_DAC) {
741 tmp_ret = SetInternalDacMainVolume(main_vol);
742 } else {
743 tmp_ret = SetExternalDacMainVolume(main_vol);
744 }
745
746 return tmp_ret;
747}
748
749int CAudioAlsa::SetDacSupperBassVolume(int tmp_vol)
750{
751 int aud_arch_type = GetAudioArchitectureTypeCFG();
752
753 if (aud_arch_type == CC_DAC_T866_INTERNAL_DAC) {
754 return 0;
755 }
756
757 return SetExternalDacSupperBassVolume(tmp_vol);
758}
759
760int CAudioAlsa::SetDacEQMode(int mode_val)
761{
762 int aud_arch_type = GetAudioArchitectureTypeCFG();
763
764 if (aud_arch_type == CC_DAC_T866_INTERNAL_DAC) {
765 return 0;
766 }
767
768 return SetExternalDacEQ(mode_val);
769}
770
771int CAudioAlsa::SetBalanceValue(int balance_val)
772{
773 int tmp_val = 0;
774 int aud_arch_type = GetAudioArchitectureTypeCFG();
775
776 tmp_val = mMainVolumeBalanceVal;
777 mMainVolumeBalanceVal = balance_val;
778
779 if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_FBC) {
780 SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_BALANCE, balance_val);
781 return 0;
782 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_CUSTOMER_LIB) {
783 SendCmdToOffBoardCustomerLibExternalDac(AUDIO_CMD_SET_BALANCE, balance_val);
784 return 0;
785 }
786
787 return -1;
788}
789
790int CAudioAlsa::GetBalanceValue()
791{
792 int tmp_val = 0;
793 tmp_val = mMainVolumeBalanceVal;
794 return tmp_val;
795}
796
797int CAudioAlsa::SetMainVolumeGain(int gain_val)
798{
799 int tmp_val = 0;
800 tmp_val = mMainVolumeGainVal;
801 mMainVolumeGainVal = gain_val;
802 return tmp_val;
803}
804
805int CAudioAlsa::GetMainVolumeGain()
806{
807 int tmp_val = 0;
808 tmp_val = mMainVolumeGainVal;
809 return tmp_val;
810}
811
812int CAudioAlsa::SetSupperBassVolumeGain(int gain_val)
813{
814 int tmp_val = 0;
815 tmp_val = mSupperBassVolumeGainVal;
816 mSupperBassVolumeGainVal = gain_val;
817 return tmp_val;
818}
819
820int CAudioAlsa::GetSupperBassVolumeGain()
821{
822 int tmp_val = 0;
823 tmp_val = mSupperBassVolumeGainVal;
824 return tmp_val;
825}
826
827int CAudioAlsa::SetDacAudioSourceType(int source_type)
828{
829 int aud_arch_type = GetAudioArchitectureTypeCFG();
830
831 if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_ON_BOARD || aud_arch_type == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
832 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_FBC) {
833 SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_SOURCE, source_type);
834 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_CUSTOMER_LIB) {
835 SendCmdToOffBoardCustomerLibExternalDac(AUDIO_CMD_SET_SOURCE, source_type);
836 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_DIGITAL) {
837 }
838
839 return 0;
840}
841
842int CAudioAlsa::CalculateBalanceVol(int max_vol, int balance_val, int vol_buf[])
843{
844 int bal_mid_vol = 0, bal_cal_len = 0;
845 int tmp_val = 0;
846
847 if (balance_val < CC_MIN_SOUND_BALANCE_VAL
848 || balance_val > CC_MAX_SOUND_BALANCE_VAL) {
849 return -1;
850 }
851
852 vol_buf[0] = max_vol;
853 vol_buf[1] = max_vol;
854
855 bal_mid_vol = (CC_MIN_SOUND_BALANCE_VAL + CC_MAX_SOUND_BALANCE_VAL) / 2;
856 bal_cal_len = (CC_MAX_SOUND_BALANCE_VAL - CC_MIN_SOUND_BALANCE_VAL) / 2;
857
858 if (balance_val == bal_mid_vol) {
859 LOGD(
860 "%s, balance value = %d, bal_mid_vol = %d, vol_buf[0] = %d, vol_buf[1] = %d.\n",
861 __FUNCTION__, balance_val, bal_mid_vol, vol_buf[0], vol_buf[1]);
862 return 0;
863 } else if (balance_val < bal_mid_vol) {
864 vol_buf[1] = (bal_cal_len - (bal_mid_vol - balance_val)) * max_vol / bal_cal_len;
865 } else if (balance_val > bal_mid_vol) {
866 vol_buf[0] = (bal_cal_len - (balance_val - bal_mid_vol)) * max_vol / bal_cal_len;
867 }
868
869 if (GetAudioAmplifierBalanceExchangeCFG() != 0) {
870 tmp_val = vol_buf[0];
871 vol_buf[0] = vol_buf[1];
872 vol_buf[1] = tmp_val;
873 }
874
875 LOGD(
876 "%s, balance value = %d, bal_mid_vol = %d, vol_buf[0] = %d, vol_buf[1] = %d.\n",
877 __FUNCTION__, balance_val, bal_mid_vol, vol_buf[0], vol_buf[1]);
878 return 0;
879}
880
881int CAudioAlsa::SetExternalDacMute(int mute_state)
882{
883 int tmp_ret = 0;
884 int aud_arch_type = GetAudioArchitectureTypeCFG();
885
886 if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_ON_BOARD || aud_arch_type == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
887 SetExternalDacChannelSwitch(1, mute_state);
888 SetExternalDacChannelSwitch(2, mute_state);
889
890 if (GetAudioSupperBassModuleDisableCFG() == 0) {
891 SetExternalDacChannelSwitch(3, mute_state);
892 }
893 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_FBC) {
894 SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_MUTE, mute_state);
895 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_CUSTOMER_LIB) {
896 SendCmdToOffBoardCustomerLibExternalDac(AUDIO_CMD_SET_MUTE, mute_state);
897 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_DIGITAL) {
898 SetDigitalMute(mute_state);
899 }
900
901 return tmp_ret;
902}
903
904int CAudioAlsa::SetInternalDacMute(int mute_state)
905{
906 return 0;
907}
908
909int CAudioAlsa::setAudioPcmPlaybackMute(int mute_state)
910{
911 const char *value;
912 char prop[256];
913 value = config_get_str ( "TV", "tvin.2d4G.headset.en", "null" );
914 property_get("audio.output.double_output", prop, "null");
915 if ( strcmp ( value, "enable" ) == 0 && (strcmp(prop, "0") == 0 || strcmp(prop, "null") == 0)) {
916 SetAudioPcmPlaybackSwitch(mute_state);
917 }
918 return 0;
919}
920
921int CAudioAlsa::SetExternalDacMainVolume(int main_vol)
922{
923 int tmp_ret = 0;
924 int aud_arch_type = GetAudioArchitectureTypeCFG();
925
926 if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_ON_BOARD || aud_arch_type == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
927 int digit_vol = 0;
928 int vol_gain_val = 0;
929 int balance_val = 0, vol_buf[2] = {0, 0};
930
931 //handle l&r channel volume for balance
932 balance_val = GetBalanceValue();
933 CalculateBalanceVol(255, balance_val, vol_buf);
934
935 tmp_ret |= SetExternalDacChannelVolume(1, vol_buf[0]);
936 tmp_ret |= SetExternalDacChannelVolume(2, vol_buf[1]);
937
938 //handle master channel volume
939 digit_vol = TransVolumeBarVolToDigitalVol(mMainDigitLutBuf, main_vol,
940 0, 100, CC_MIN_DAC_VOLUME, CC_MAX_DAC_VOLUME);
941
942 vol_gain_val = GetMainVolumeGain();
943 digit_vol += vol_gain_val;
944 if (digit_vol < CC_MIN_DAC_VOLUME) {
945 digit_vol = CC_MIN_DAC_VOLUME;
946 } else if (digit_vol > CC_MAX_DAC_VOLUME) {
947 digit_vol = CC_MAX_DAC_VOLUME;
948 }
949 tmp_ret |= SetExternalDacChannelVolume(0, digit_vol);
950 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_FBC) {
951 tmp_ret = SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_VOLUME_BAR, main_vol);
952 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_CUSTOMER_LIB) {
953 tmp_ret = SendCmdToOffBoardCustomerLibExternalDac(AUDIO_CMD_SET_VOLUME_BAR, main_vol);
954 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_DIGITAL) {
955 tmp_ret = SetDigitalMainVolume(main_vol);
956 }
957
958 return tmp_ret;
959}
960
961int CAudioAlsa::SetInternalDacMainVolume(int main_vol)
962{
963 int tmp_ret = 0, digit_vol = 0;
964 int aud_arch_type = GetAudioArchitectureTypeCFG();
965
966 if (aud_arch_type == CC_DAC_T866_INTERNAL_DAC) {
967 digit_vol = TransVolumeBarVolToDigitalVol(mMainDigitLutBuf, main_vol,
968 0, 100, CC_MIN_DAC_VOLUME, CC_MAX_DAC_VOLUME);
969
970 if (digit_vol < CC_MIN_DAC_VOLUME) {
971 digit_vol = CC_MIN_DAC_VOLUME;
972 } else if (digit_vol > CC_MAX_DAC_VOLUME) {
973 digit_vol = CC_MAX_DAC_VOLUME;
974 }
975
976 return SetInternalDacLineOutPlayBackVolume(digit_vol, digit_vol);
977 }
978
979 return 0;
980}
981
982int CAudioAlsa::SetExternalDacSupperBassVolume(int tmp_vol)
983{
984 int tmp_ret = 0;
985 int aud_arch_type = GetAudioArchitectureTypeCFG();
986
987 if (GetAudioSupperBassModuleDisableCFG() != 0) {
988 return 0;
989 }
990
991 if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_ON_BOARD || aud_arch_type == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
992 int digit_vol = 0;
993 int vol_gain_val = 0;
994
995 digit_vol = TransVolumeBarVolToDigitalVol(mMainDigitLutBuf, tmp_vol,
996 0, 100, CC_MIN_DAC_SUB_WOOFER_VOLUME,
997 CC_MAX_DAC_SUB_WOOFER_VOLUME);
998
999 vol_gain_val = GetSupperBassVolumeGain();
1000 digit_vol += vol_gain_val;
1001 if (digit_vol < CC_MIN_DAC_SUB_WOOFER_VOLUME) {
1002 digit_vol = CC_MIN_DAC_SUB_WOOFER_VOLUME;
1003 } else if (digit_vol > CC_MAX_DAC_SUB_WOOFER_VOLUME) {
1004 digit_vol = CC_MAX_DAC_SUB_WOOFER_VOLUME;
1005 }
1006
1007 tmp_ret = SetExternalDacChannelVolume(3, digit_vol);
1008 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_FBC) {
1009 tmp_ret = SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_SUBCHANNEL_VOLUME, tmp_vol);
1010 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_CUSTOMER_LIB) {
1011 tmp_ret = SendCmdToOffBoardCustomerLibExternalDac(AUDIO_CMD_SET_SUBCHANNEL_VOLUME, tmp_vol);
1012 }
1013
1014 return tmp_ret;
1015}
1016
1017int CAudioAlsa::SetExternalDacEQ(int mode_val)
1018{
1019 int tmp_ret = 0;
1020 int aud_arch_type = GetAudioArchitectureTypeCFG();
1021
1022 if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_ON_BOARD || aud_arch_type == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) {
1023 SetExternalDacEQMode(mode_val);
1024 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_FBC) {
1025 SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_EQ_MODE, mode_val);
1026 } else if (aud_arch_type == CC_DAC_T866_EXTERNAL_DAC_OFF_BOARD_CUSTOMER_LIB) {
1027 SendCmdToOffBoardCustomerLibExternalDac(AUDIO_CMD_SET_EQ_MODE, mode_val);
1028 }
1029
1030 return tmp_ret;
1031}
1032
1033int (*HandleDacMute)(int mute_state);
1034int (*HandleDacMainVolume)(int vol);
1035int (*HandleDacBalance)(int balance_val);
1036int (*HandleAudioSourceType)(int source_type);
1037
1038static void *gExternalDacLibHandler = NULL;
1039int CAudioAlsa::LoadExternalDacLib(void)
1040{
1041 char *error;
1042
1043 ALOGD("%s, entering...\n", __FUNCTION__);
1044
1045 if (gExternalDacLibHandler != NULL) {
1046 return 0;
1047 }
1048
1049 const char *config_value = config_get_str("TV", "audio.external.dac.libpath", "/system/lib/libdac.so");
1050 gExternalDacLibHandler = dlopen(config_value, RTLD_NOW);
1051 if (!gExternalDacLibHandler) {
1052 ALOGE("%s, failed to load external dac lib (%s)\n", __FUNCTION__, config_value);
1053 goto Error;
1054 }
1055
1056
1057 HandleDacMute = (int(*)(int))dlsym(gExternalDacLibHandler, "HandleDacMute");
1058 if (HandleDacMute == NULL) {
1059 ALOGE("%s, fail find fun HandleDacMute()\n", __FUNCTION__);
1060 goto Error;
1061 }
1062 HandleDacMainVolume = (int(*)(int))dlsym(gExternalDacLibHandler, "HandleDacMainVolume");
1063 if (HandleDacMainVolume == NULL) {
1064 ALOGE("%s, fail find fun HandleDacMainVolume()\n", __FUNCTION__);
1065 goto Error;
1066 }
1067 HandleDacBalance = (int(*)(int))dlsym(gExternalDacLibHandler, "HandleDacBalance");
1068 if (HandleDacBalance == NULL) {
1069 ALOGE("%s, fail find fun HandleDacBalance()\n", __FUNCTION__);
1070 goto Error;
1071 }
1072 HandleAudioSourceType = (int(*)(int))dlsym(gExternalDacLibHandler, "HandleAudioSourceType");
1073 if (HandleAudioSourceType == NULL) {
1074 ALOGE("%s, fail find fun HandleAudioSourceType()\n", __FUNCTION__);
1075 goto Error;
1076 }
1077
1078 return 0;
1079
1080Error: //
1081 HandleDacMute = NULL;
1082 HandleDacMainVolume = NULL;
1083 HandleDacBalance = NULL;
1084 HandleAudioSourceType = NULL;
1085
1086 if (gExternalDacLibHandler != NULL) {
1087 dlclose(gExternalDacLibHandler);
1088 gExternalDacLibHandler = NULL;
1089 }
1090 return -1;
1091}
1092
1093int CAudioAlsa::SendCmdToOffBoardCustomerLibExternalDac(int cmd, int para)
1094{
1095 LoadExternalDacLib();
1096 if (gExternalDacLibHandler != NULL) {
1097 if (cmd == AUDIO_CMD_SET_MUTE) {
1098 if (HandleDacMute != NULL) {
1099 LOGD("%s, call external dac lib HandleDacMute (para = %d).\n", __FUNCTION__, para);
1100 return (*HandleDacMute)(para);
1101 }
1102 } else if (cmd == AUDIO_CMD_SET_VOLUME_BAR) {
1103 if (HandleDacMainVolume != NULL) {
1104 LOGD("%s, call external dac lib HandleDacMainVolume (para = %d).\n", __FUNCTION__, para);
1105 return (*HandleDacMainVolume)(para);
1106 }
1107 } else if (cmd == AUDIO_CMD_SET_BALANCE) {
1108 if (HandleDacBalance != NULL) {
1109 LOGD("%s, call external dac lib HandleDacBalance (para = %d).\n", __FUNCTION__, para);
1110 return (*HandleDacBalance)(para);
1111 }
1112 } else if (cmd == AUDIO_CMD_SET_SOURCE) {
1113 if (HandleAudioSourceType != NULL) {
1114 LOGD("%s, call external dac lib HandleAudioSourceType (para = %d).\n", __FUNCTION__, para);
1115 return (*HandleAudioSourceType)(para);
1116 }
1117 }
1118 }
1119
1120 return 0;
1121}
1122
1123int CAudioAlsa::SendCmdToOffBoardFBCExternalDac(int cmd, int para)
1124{
1125 CFbcCommunication *pFBC = GetSingletonFBC();
1126 if (pFBC != NULL) {
1127 if (cmd == AUDIO_CMD_SET_MUTE) {
1128 int fbc_mute = 0;//0 is mute,1 is unmute
1129 if(para == CC_AUDIO_MUTE) {
1130 fbc_mute = 0;
1131 } else {
1132 fbc_mute = 1;
1133 }
1134 //int fbcIsBute;
1135 //pFBC->cfbc_Get_Mute(COMM_DEV_SERIAL, &fbcIsBute);
1136 //LOGD("fbc is mute = %d", fbcIsBute);
1137 return pFBC->cfbc_Set_Mute(COMM_DEV_SERIAL, fbc_mute);
1138 } else if (cmd == AUDIO_CMD_SET_VOLUME_BAR) {
1139 LOGD("%s, send AUDIO_CMD_SET_VOLUME_BAR (para = %d) to fbc.\n", __FUNCTION__, para);
1140 return pFBC->cfbc_Set_Volume_Bar(COMM_DEV_SERIAL, para);
1141 } else if (cmd == AUDIO_CMD_SET_BALANCE) {
1142 LOGD("%s, send AUDIO_CMD_SET_BALANCE (para = %d) to fbc.\n", __FUNCTION__, para);
1143 return pFBC->cfbc_Set_Balance(COMM_DEV_SERIAL, para);
1144 } else if (cmd == AUDIO_CMD_SET_SOURCE) {
1145 LOGD("%s, send AUDIO_CMD_SET_SOURCE (para = %d) to fbc.\n", __FUNCTION__, para);
1146 return pFBC->cfbc_Set_FBC_Audio_Source(COMM_DEV_SERIAL, para);
1147 }
1148 }
1149
1150 return 0;
1151}
1152
1153static int gDigitalMuteStatus = CC_AUDIO_UNMUTE;
1154static int gDigitalLeftVol = 0;
1155static int gDigitalRightVol = 0;
1156
1157int CAudioAlsa::HandleDigitalVolume(int l_val, int r_val)
1158{
1159 amAudioSetLeftGain(l_val);
1160 amAudioSetRightGain(r_val);
1161
1162 amAudioSetAndroidVolumeEnable(1);
1163 amAudioSetAndroidVolume(l_val, r_val);
1164
1165 LOGD("%s, l_val = %d, r_val = %d.\n", __FUNCTION__, l_val, r_val);
1166 return 0;
1167}
1168
1169int CAudioAlsa::HandleDigitalMute(int mute_status)
1170{
1171 if (mute_status == CC_AUDIO_MUTE) {
1172 HandleDigitalVolume(0, 0);
1173 } else if (mute_status == CC_AUDIO_UNMUTE) {
1174 HandleDigitalVolume(gDigitalLeftVol, gDigitalRightVol);
1175 }
1176
1177 return 0;
1178}
1179
1180int CAudioAlsa::SetDigitalMainVolume(int main_vol)
1181{
1182 int tmp_ret = 0, l_val = 0, r_val = 0;
1183 int balance_val = 0, vol_buf[2] = {0, 0};
1184
1185 //handle l&r channel volume for balance
1186 balance_val = GetBalanceValue();
1187 CalculateBalanceVol(main_vol, balance_val, vol_buf);
1188
1189 //handle master channel volume
1190 l_val = TransVolumeBarVolToDigitalVol(mMainDigitLutBuf, vol_buf[0],
1191 0, 100, CC_MIN_DAC_VOLUME, CC_MAX_DAC_VOLUME);
1192 r_val = TransVolumeBarVolToDigitalVol(mMainDigitLutBuf, vol_buf[1],
1193 0, 100, CC_MIN_DAC_VOLUME, CC_MAX_DAC_VOLUME);
1194
1195 gDigitalLeftVol = l_val;
1196 gDigitalRightVol = r_val;
1197 if (gDigitalMuteStatus == CC_AUDIO_UNMUTE) {
1198 HandleDigitalVolume(l_val, r_val);
1199 }
1200
1201 return tmp_ret;
1202}
1203
1204int CAudioAlsa::SetDigitalMute(int mute_status)
1205{
1206 if (mute_status == CC_AUDIO_MUTE || mute_status == CC_AUDIO_UNMUTE) {
1207 gDigitalMuteStatus = mute_status;
1208 return HandleDigitalMute(mute_status);
1209 }
1210
1211 return 0;
1212}
1213
1214
generated by cgit at 2024-05-11 10:01:40 (GMT)