blob: 551e3c6e94fe402eccfff0e3750de54bd3d2c3fb
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 | |
24 | static 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 | |
39 | static 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 | |
54 | CAudioAlsa::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 | |
71 | CAudioAlsa::~CAudioAlsa() |
72 | { |
73 | if (NULL != mpMixer) { |
74 | mixer_close(mpMixer); |
75 | } |
76 | |
77 | if (NULL != mpUsbMixer) { |
78 | mixer_close(mpUsbMixer); |
79 | } |
80 | } |
81 | |
82 | int 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 | |
107 | int 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; |
135 | err_exit: |
136 | return -1; |
137 | } |
138 | |
139 | int 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; |
163 | err_exit: |
164 | return -1; |
165 | } |
166 | |
167 | int 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 | |
198 | int 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; |
232 | err_exit: |
233 | return -1; |
234 | } |
235 | |
236 | int 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 | |
250 | int 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 | |
259 | int CAudioAlsa::GetLineInMaxVol() |
260 | { |
261 | if (GetAudioArchitectureTypeCFG() == CC_DAC_M6C_EXTERNAL_DAC_ON_BOARD) { |
262 | return 84; |
263 | } |
264 | |
265 | return 127; |
266 | } |
267 | |
268 | int 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 | |
298 | static 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 | |
322 | char *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 | |
380 | int gAudioInSource = -1; |
381 | |
382 | int 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 | |
410 | int 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 | |
423 | int 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 | |
441 | int 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 | |
453 | int 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 | |
461 | int 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 | |
473 | int 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 | |
481 | int 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 | |
488 | int 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 | |
495 | int 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 | |
512 | int 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 | } |
531 | int 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 | } |
537 | int 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 | |
544 | int 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 | |
552 | int 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 | |
565 | int 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 | |
575 | enum 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 | |
582 | int 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 | |
621 | int 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 | |
636 | int 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 | |
646 | int 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 | |
661 | int 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 | |
671 | int 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 | |
683 | int 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 | |
707 | void 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 | |
713 | void 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 | |
719 | int 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 | |
735 | int 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 | |
749 | int 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 | |
760 | int 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 | |
771 | int 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 | |
790 | int CAudioAlsa::GetBalanceValue() |
791 | { |
792 | int tmp_val = 0; |
793 | tmp_val = mMainVolumeBalanceVal; |
794 | return tmp_val; |
795 | } |
796 | |
797 | int 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 | |
805 | int CAudioAlsa::GetMainVolumeGain() |
806 | { |
807 | int tmp_val = 0; |
808 | tmp_val = mMainVolumeGainVal; |
809 | return tmp_val; |
810 | } |
811 | |
812 | int 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 | |
820 | int CAudioAlsa::GetSupperBassVolumeGain() |
821 | { |
822 | int tmp_val = 0; |
823 | tmp_val = mSupperBassVolumeGainVal; |
824 | return tmp_val; |
825 | } |
826 | |
827 | int 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 | |
842 | int 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 | |
881 | int 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 | |
904 | int CAudioAlsa::SetInternalDacMute(int mute_state) |
905 | { |
906 | return 0; |
907 | } |
908 | |
909 | int 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 | |
921 | int 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 | |
961 | int 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 | |
982 | int 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 | |
1017 | int 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 | |
1033 | int (*HandleDacMute)(int mute_state); |
1034 | int (*HandleDacMainVolume)(int vol); |
1035 | int (*HandleDacBalance)(int balance_val); |
1036 | int (*HandleAudioSourceType)(int source_type); |
1037 | |
1038 | static void *gExternalDacLibHandler = NULL; |
1039 | int 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 | |
1080 | Error: // |
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 | |
1093 | int 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 | |
1123 | int 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 | |
1153 | static int gDigitalMuteStatus = CC_AUDIO_UNMUTE; |
1154 | static int gDigitalLeftVol = 0; |
1155 | static int gDigitalRightVol = 0; |
1156 | |
1157 | int 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 | |
1169 | int 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 | |
1180 | int 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 | |
1204 | int 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 |