1 /*
2 * Copyright (C) 2013-2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "audio_hw_primary"
18 /*#define LOG_NDEBUG 0*/
19 /*#define VERY_VERY_VERBOSE_LOGGING*/
20 #ifdef VERY_VERY_VERBOSE_LOGGING
21 #define ALOGVV ALOGV
22 #else
23 #define ALOGVV(a...) do { } while(0)
24 #endif
25
26 #include <errno.h>
27 #include <pthread.h>
28 #include <stdint.h>
29 #include <sys/time.h>
30 #include <stdlib.h>
31 #include <math.h>
32 #include <dlfcn.h>
33 #include <sys/resource.h>
34 #include <sys/prctl.h>
35
36 #include <cutils/log.h>
37 #include <cutils/str_parms.h>
38 #include <cutils/properties.h>
39 #include <cutils/atomic.h>
40 #include <cutils/sched_policy.h>
41
42 #include <hardware/audio_effect.h>
43 #include <hardware/audio_alsaops.h>
44 #include <system/thread_defs.h>
45 #include <audio_effects/effect_aec.h>
46 #include <audio_effects/effect_ns.h>
47 #include "audio_hw.h"
48 #include "audio_extn.h"
49 #include "platform_api.h"
50 #include <platform.h>
51 #include "voice_extn.h"
52
53 #include "sound/compress_params.h"
54
55 /* COMPRESS_OFFLOAD_FRAGMENT_SIZE must be more than 8KB and a multiple of 32KB if more than 32KB.
56 * COMPRESS_OFFLOAD_FRAGMENT_SIZE * COMPRESS_OFFLOAD_NUM_FRAGMENTS must be less than 8MB. */
57 #define COMPRESS_OFFLOAD_FRAGMENT_SIZE (256 * 1024)
58 // 2 buffers causes problems with high bitrate files
59 #define COMPRESS_OFFLOAD_NUM_FRAGMENTS 3
60 /* ToDo: Check and update a proper value in msec */
61 #define COMPRESS_OFFLOAD_PLAYBACK_LATENCY 96
62 #define COMPRESS_PLAYBACK_VOLUME_MAX 0x2000
63
64 #define PROXY_OPEN_RETRY_COUNT 100
65 #define PROXY_OPEN_WAIT_TIME 20
66
67 #define MIN_CHANNEL_COUNT 1
68 #define DEFAULT_CHANNEL_COUNT 2
69
70 #ifndef MAX_TARGET_SPECIFIC_CHANNEL_CNT
71 #define MAX_CHANNEL_COUNT 1
72 #else
73 #define MAX_CHANNEL_COUNT atoi(XSTR(MAX_TARGET_SPECIFIC_CHANNEL_CNT))
74 #define XSTR(x) STR(x)
75 #define STR(x) #x
76 #endif
77
78 static unsigned int configured_low_latency_capture_period_size =
79 LOW_LATENCY_CAPTURE_PERIOD_SIZE;
80
81 /* This constant enables extended precision handling.
82 * TODO The flag is off until more testing is done.
83 */
84 static const bool k_enable_extended_precision = false;
85
86 struct pcm_config pcm_config_deep_buffer = {
87 .channels = DEFAULT_CHANNEL_COUNT,
88 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
89 .period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE,
90 .period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT,
91 .format = PCM_FORMAT_S16_LE,
92 .start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
93 .stop_threshold = INT_MAX,
94 .avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
95 };
96
97 struct pcm_config pcm_config_low_latency = {
98 .channels = DEFAULT_CHANNEL_COUNT,
99 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
100 .period_size = LOW_LATENCY_OUTPUT_PERIOD_SIZE,
101 .period_count = LOW_LATENCY_OUTPUT_PERIOD_COUNT,
102 .format = PCM_FORMAT_S16_LE,
103 .start_threshold = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
104 .stop_threshold = INT_MAX,
105 .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
106 };
107
108 struct pcm_config pcm_config_hdmi_multi = {
109 .channels = HDMI_MULTI_DEFAULT_CHANNEL_COUNT, /* changed when the stream is opened */
110 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, /* changed when the stream is opened */
111 .period_size = HDMI_MULTI_PERIOD_SIZE,
112 .period_count = HDMI_MULTI_PERIOD_COUNT,
113 .format = PCM_FORMAT_S16_LE,
114 .start_threshold = 0,
115 .stop_threshold = INT_MAX,
116 .avail_min = 0,
117 };
118
119 struct pcm_config pcm_config_audio_capture = {
120 .channels = DEFAULT_CHANNEL_COUNT,
121 .period_count = AUDIO_CAPTURE_PERIOD_COUNT,
122 .format = PCM_FORMAT_S16_LE,
123 .stop_threshold = INT_MAX,
124 .avail_min = 0,
125 };
126
127 #define AFE_PROXY_CHANNEL_COUNT 2
128 #define AFE_PROXY_SAMPLING_RATE 48000
129
130 #define AFE_PROXY_PLAYBACK_PERIOD_SIZE 768
131 #define AFE_PROXY_PLAYBACK_PERIOD_COUNT 4
132
133 struct pcm_config pcm_config_afe_proxy_playback = {
134 .channels = AFE_PROXY_CHANNEL_COUNT,
135 .rate = AFE_PROXY_SAMPLING_RATE,
136 .period_size = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
137 .period_count = AFE_PROXY_PLAYBACK_PERIOD_COUNT,
138 .format = PCM_FORMAT_S16_LE,
139 .start_threshold = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
140 .stop_threshold = INT_MAX,
141 .avail_min = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
142 };
143
144 #define AFE_PROXY_RECORD_PERIOD_SIZE 768
145 #define AFE_PROXY_RECORD_PERIOD_COUNT 4
146
147 struct pcm_config pcm_config_afe_proxy_record = {
148 .channels = AFE_PROXY_CHANNEL_COUNT,
149 .rate = AFE_PROXY_SAMPLING_RATE,
150 .period_size = AFE_PROXY_RECORD_PERIOD_SIZE,
151 .period_count = AFE_PROXY_RECORD_PERIOD_COUNT,
152 .format = PCM_FORMAT_S16_LE,
153 .start_threshold = AFE_PROXY_RECORD_PERIOD_SIZE,
154 .stop_threshold = INT_MAX,
155 .avail_min = AFE_PROXY_RECORD_PERIOD_SIZE,
156 };
157
158 const char * const use_case_table[AUDIO_USECASE_MAX] = {
159 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = "deep-buffer-playback",
160 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = "low-latency-playback",
161 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = "multi-channel-playback",
162 [USECASE_AUDIO_PLAYBACK_OFFLOAD] = "compress-offload-playback",
163 [USECASE_AUDIO_PLAYBACK_TTS] = "audio-tts-playback",
164 [USECASE_AUDIO_PLAYBACK_ULL] = "audio-ull-playback",
165
166 [USECASE_AUDIO_RECORD] = "audio-record",
167 [USECASE_AUDIO_RECORD_LOW_LATENCY] = "low-latency-record",
168
169 [USECASE_AUDIO_HFP_SCO] = "hfp-sco",
170 [USECASE_AUDIO_HFP_SCO_WB] = "hfp-sco-wb",
171
172 [USECASE_VOICE_CALL] = "voice-call",
173 [USECASE_VOICE2_CALL] = "voice2-call",
174 [USECASE_VOLTE_CALL] = "volte-call",
175 [USECASE_QCHAT_CALL] = "qchat-call",
176 [USECASE_VOWLAN_CALL] = "vowlan-call",
177 [USECASE_VOICEMMODE1_CALL] = "voicemmode1-call",
178 [USECASE_VOICEMMODE2_CALL] = "voicemmode2-call",
179
180 [USECASE_AUDIO_SPKR_CALIB_RX] = "spkr-rx-calib",
181 [USECASE_AUDIO_SPKR_CALIB_TX] = "spkr-vi-record",
182
183 [USECASE_AUDIO_PLAYBACK_AFE_PROXY] = "afe-proxy-playback",
184 [USECASE_AUDIO_RECORD_AFE_PROXY] = "afe-proxy-record",
185 };
186
187
188 #define STRING_TO_ENUM(string) { #string, string }
189
190 struct string_to_enum {
191 const char *name;
192 uint32_t value;
193 };
194
195 static const struct string_to_enum out_channels_name_to_enum_table[] = {
196 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO),
197 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
198 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
199 };
200
201 static int set_voice_volume_l(struct audio_device *adev, float volume);
202 static struct audio_device *adev = NULL;
203 static pthread_mutex_t adev_init_lock;
204 static unsigned int audio_device_ref_count;
205
206 __attribute__ ((visibility ("default")))
audio_hw_send_gain_dep_calibration(int level)207 bool audio_hw_send_gain_dep_calibration(int level) {
208 bool ret_val = false;
209 ALOGV("%s: enter ... ", __func__);
210
211 pthread_mutex_lock(&adev_init_lock);
212
213 if (adev != NULL && adev->platform != NULL) {
214 pthread_mutex_lock(&adev->lock);
215 ret_val = platform_send_gain_dep_cal(adev->platform, level);
216 pthread_mutex_unlock(&adev->lock);
217 } else {
218 ALOGE("%s: %s is NULL", __func__, adev == NULL ? "adev" : "adev->platform");
219 }
220
221 pthread_mutex_unlock(&adev_init_lock);
222
223 ALOGV("%s: exit with ret_val %d ", __func__, ret_val);
224 return ret_val;
225 }
226
is_supported_format(audio_format_t format)227 static bool is_supported_format(audio_format_t format)
228 {
229 switch (format) {
230 case AUDIO_FORMAT_MP3:
231 case AUDIO_FORMAT_AAC_LC:
232 case AUDIO_FORMAT_AAC_HE_V1:
233 case AUDIO_FORMAT_AAC_HE_V2:
234 return true;
235 default:
236 break;
237 }
238 return false;
239 }
240
get_snd_codec_id(audio_format_t format)241 static int get_snd_codec_id(audio_format_t format)
242 {
243 int id = 0;
244
245 switch (format & AUDIO_FORMAT_MAIN_MASK) {
246 case AUDIO_FORMAT_MP3:
247 id = SND_AUDIOCODEC_MP3;
248 break;
249 case AUDIO_FORMAT_AAC:
250 id = SND_AUDIOCODEC_AAC;
251 break;
252 default:
253 ALOGE("%s: Unsupported audio format", __func__);
254 }
255
256 return id;
257 }
258
enable_audio_route(struct audio_device * adev,struct audio_usecase * usecase)259 int enable_audio_route(struct audio_device *adev,
260 struct audio_usecase *usecase)
261 {
262 snd_device_t snd_device;
263 char mixer_path[50];
264
265 if (usecase == NULL)
266 return -EINVAL;
267
268 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
269
270 if (usecase->type == PCM_CAPTURE)
271 snd_device = usecase->in_snd_device;
272 else
273 snd_device = usecase->out_snd_device;
274
275 strcpy(mixer_path, use_case_table[usecase->id]);
276 platform_add_backend_name(adev->platform, mixer_path, snd_device);
277 ALOGV("%s: apply and update mixer path: %s", __func__, mixer_path);
278 audio_route_apply_and_update_path(adev->audio_route, mixer_path);
279
280 ALOGV("%s: exit", __func__);
281 return 0;
282 }
283
disable_audio_route(struct audio_device * adev,struct audio_usecase * usecase)284 int disable_audio_route(struct audio_device *adev,
285 struct audio_usecase *usecase)
286 {
287 snd_device_t snd_device;
288 char mixer_path[50];
289
290 if (usecase == NULL)
291 return -EINVAL;
292
293 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
294 if (usecase->type == PCM_CAPTURE)
295 snd_device = usecase->in_snd_device;
296 else
297 snd_device = usecase->out_snd_device;
298 strcpy(mixer_path, use_case_table[usecase->id]);
299 platform_add_backend_name(adev->platform, mixer_path, snd_device);
300 ALOGV("%s: reset and update mixer path: %s", __func__, mixer_path);
301 audio_route_reset_and_update_path(adev->audio_route, mixer_path);
302
303 ALOGV("%s: exit", __func__);
304 return 0;
305 }
306
enable_snd_device(struct audio_device * adev,snd_device_t snd_device)307 int enable_snd_device(struct audio_device *adev,
308 snd_device_t snd_device)
309 {
310 int i, num_devices = 0;
311 snd_device_t new_snd_devices[2];
312 int ret_val = -EINVAL;
313 if (snd_device < SND_DEVICE_MIN ||
314 snd_device >= SND_DEVICE_MAX) {
315 ALOGE("%s: Invalid sound device %d", __func__, snd_device);
316 goto on_error;
317 }
318
319 platform_send_audio_calibration(adev->platform, snd_device);
320
321 if (adev->snd_dev_ref_cnt[snd_device] >= 1) {
322 ALOGV("%s: snd_device(%d: %s) is already active",
323 __func__, snd_device, platform_get_snd_device_name(snd_device));
324 goto on_success;
325 }
326
327 /* due to the possibility of calibration overwrite between listen
328 and audio, notify sound trigger hal before audio calibration is sent */
329 audio_extn_sound_trigger_update_device_status(snd_device,
330 ST_EVENT_SND_DEVICE_BUSY);
331
332 if (audio_extn_spkr_prot_is_enabled())
333 audio_extn_spkr_prot_calib_cancel(adev);
334
335 audio_extn_dsm_feedback_enable(adev, snd_device, true);
336
337 if ((snd_device == SND_DEVICE_OUT_SPEAKER ||
338 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER) &&
339 audio_extn_spkr_prot_is_enabled()) {
340 if (audio_extn_spkr_prot_get_acdb_id(snd_device) < 0) {
341 goto on_error;
342 }
343 if (audio_extn_spkr_prot_start_processing(snd_device)) {
344 ALOGE("%s: spkr_start_processing failed", __func__);
345 goto on_error;
346 }
347 } else if (platform_can_split_snd_device(snd_device, &num_devices, new_snd_devices)) {
348 for (i = 0; i < num_devices; i++) {
349 enable_snd_device(adev, new_snd_devices[i]);
350 }
351 platform_set_speaker_gain_in_combo(adev, snd_device, true);
352 } else {
353 char device_name[DEVICE_NAME_MAX_SIZE] = {0};
354 if (platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0 ) {
355 ALOGE(" %s: Invalid sound device returned", __func__);
356 goto on_error;
357 }
358
359 ALOGV("%s: snd_device(%d: %s)", __func__, snd_device, device_name);
360 audio_route_apply_and_update_path(adev->audio_route, device_name);
361 }
362 on_success:
363 adev->snd_dev_ref_cnt[snd_device]++;
364 ret_val = 0;
365 on_error:
366 return ret_val;
367 }
368
disable_snd_device(struct audio_device * adev,snd_device_t snd_device)369 int disable_snd_device(struct audio_device *adev,
370 snd_device_t snd_device)
371 {
372 int i, num_devices = 0;
373 snd_device_t new_snd_devices[2];
374
375 if (snd_device < SND_DEVICE_MIN ||
376 snd_device >= SND_DEVICE_MAX) {
377 ALOGE("%s: Invalid sound device %d", __func__, snd_device);
378 return -EINVAL;
379 }
380 if (adev->snd_dev_ref_cnt[snd_device] <= 0) {
381 ALOGE("%s: device ref cnt is already 0", __func__);
382 return -EINVAL;
383 }
384 adev->snd_dev_ref_cnt[snd_device]--;
385 if (adev->snd_dev_ref_cnt[snd_device] == 0) {
386 audio_extn_dsm_feedback_enable(adev, snd_device, false);
387 if ((snd_device == SND_DEVICE_OUT_SPEAKER ||
388 snd_device == SND_DEVICE_OUT_VOICE_SPEAKER) &&
389 audio_extn_spkr_prot_is_enabled()) {
390 audio_extn_spkr_prot_stop_processing(snd_device);
391 } else if (platform_can_split_snd_device(snd_device, &num_devices, new_snd_devices)) {
392 for (i = 0; i < num_devices; i++) {
393 disable_snd_device(adev, new_snd_devices[i]);
394 }
395 platform_set_speaker_gain_in_combo(adev, snd_device, false);
396 } else {
397 char device_name[DEVICE_NAME_MAX_SIZE] = {0};
398 if (platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0 ) {
399 ALOGE(" %s: Invalid sound device returned", __func__);
400 return -EINVAL;
401 }
402
403 ALOGV("%s: snd_device(%d: %s)", __func__, snd_device, device_name);
404 audio_route_reset_and_update_path(adev->audio_route, device_name);
405 }
406 audio_extn_sound_trigger_update_device_status(snd_device,
407 ST_EVENT_SND_DEVICE_FREE);
408 }
409
410 return 0;
411 }
412
check_and_route_playback_usecases(struct audio_device * adev,struct audio_usecase * uc_info,snd_device_t snd_device)413 static void check_and_route_playback_usecases(struct audio_device *adev,
414 struct audio_usecase *uc_info,
415 snd_device_t snd_device)
416 {
417 struct listnode *node;
418 struct audio_usecase *usecase;
419 bool switch_device[AUDIO_USECASE_MAX];
420 int i, num_uc_to_switch = 0;
421
422 /*
423 * This function is to make sure that all the usecases that are active on
424 * the hardware codec backend are always routed to any one device that is
425 * handled by the hardware codec.
426 * For example, if low-latency and deep-buffer usecases are currently active
427 * on speaker and out_set_parameters(headset) is received on low-latency
428 * output, then we have to make sure deep-buffer is also switched to headset,
429 * because of the limitation that both the devices cannot be enabled
430 * at the same time as they share the same backend.
431 */
432 /* Disable all the usecases on the shared backend other than the
433 specified usecase */
434 for (i = 0; i < AUDIO_USECASE_MAX; i++)
435 switch_device[i] = false;
436
437 list_for_each(node, &adev->usecase_list) {
438 usecase = node_to_item(node, struct audio_usecase, list);
439 if (usecase->type != PCM_CAPTURE &&
440 usecase != uc_info &&
441 usecase->out_snd_device != snd_device &&
442 usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND &&
443 platform_check_backends_match(snd_device, usecase->out_snd_device)) {
444 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
445 __func__, use_case_table[usecase->id],
446 platform_get_snd_device_name(usecase->out_snd_device));
447 disable_audio_route(adev, usecase);
448 switch_device[usecase->id] = true;
449 num_uc_to_switch++;
450 }
451 }
452
453 if (num_uc_to_switch) {
454 list_for_each(node, &adev->usecase_list) {
455 usecase = node_to_item(node, struct audio_usecase, list);
456 if (switch_device[usecase->id]) {
457 disable_snd_device(adev, usecase->out_snd_device);
458 }
459 }
460
461 list_for_each(node, &adev->usecase_list) {
462 usecase = node_to_item(node, struct audio_usecase, list);
463 if (switch_device[usecase->id]) {
464 enable_snd_device(adev, snd_device);
465 }
466 }
467
468 /* Re-route all the usecases on the shared backend other than the
469 specified usecase to new snd devices */
470 list_for_each(node, &adev->usecase_list) {
471 usecase = node_to_item(node, struct audio_usecase, list);
472 /* Update the out_snd_device only before enabling the audio route */
473 if (switch_device[usecase->id] ) {
474 usecase->out_snd_device = snd_device;
475 enable_audio_route(adev, usecase);
476 }
477 }
478 }
479 }
480
check_and_route_capture_usecases(struct audio_device * adev,struct audio_usecase * uc_info,snd_device_t snd_device)481 static void check_and_route_capture_usecases(struct audio_device *adev,
482 struct audio_usecase *uc_info,
483 snd_device_t snd_device)
484 {
485 struct listnode *node;
486 struct audio_usecase *usecase;
487 bool switch_device[AUDIO_USECASE_MAX];
488 int i, num_uc_to_switch = 0;
489
490 platform_check_and_set_capture_backend_cfg(adev, uc_info, snd_device);
491
492 /*
493 * This function is to make sure that all the active capture usecases
494 * are always routed to the same input sound device.
495 * For example, if audio-record and voice-call usecases are currently
496 * active on speaker(rx) and speaker-mic (tx) and out_set_parameters(earpiece)
497 * is received for voice call then we have to make sure that audio-record
498 * usecase is also switched to earpiece i.e. voice-dmic-ef,
499 * because of the limitation that two devices cannot be enabled
500 * at the same time if they share the same backend.
501 */
502 for (i = 0; i < AUDIO_USECASE_MAX; i++)
503 switch_device[i] = false;
504
505 list_for_each(node, &adev->usecase_list) {
506 usecase = node_to_item(node, struct audio_usecase, list);
507 if (usecase->type != PCM_PLAYBACK &&
508 usecase != uc_info &&
509 usecase->in_snd_device != snd_device &&
510 (usecase->id != USECASE_AUDIO_SPKR_CALIB_TX)) {
511 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
512 __func__, use_case_table[usecase->id],
513 platform_get_snd_device_name(usecase->in_snd_device));
514 disable_audio_route(adev, usecase);
515 switch_device[usecase->id] = true;
516 num_uc_to_switch++;
517 }
518 }
519
520 if (num_uc_to_switch) {
521 list_for_each(node, &adev->usecase_list) {
522 usecase = node_to_item(node, struct audio_usecase, list);
523 if (switch_device[usecase->id]) {
524 disable_snd_device(adev, usecase->in_snd_device);
525 }
526 }
527
528 list_for_each(node, &adev->usecase_list) {
529 usecase = node_to_item(node, struct audio_usecase, list);
530 if (switch_device[usecase->id]) {
531 enable_snd_device(adev, snd_device);
532 }
533 }
534
535 /* Re-route all the usecases on the shared backend other than the
536 specified usecase to new snd devices */
537 list_for_each(node, &adev->usecase_list) {
538 usecase = node_to_item(node, struct audio_usecase, list);
539 /* Update the in_snd_device only before enabling the audio route */
540 if (switch_device[usecase->id] ) {
541 usecase->in_snd_device = snd_device;
542 enable_audio_route(adev, usecase);
543 }
544 }
545 }
546 }
547
548 /* must be called with hw device mutex locked */
read_hdmi_channel_masks(struct stream_out * out)549 static int read_hdmi_channel_masks(struct stream_out *out)
550 {
551 int ret = 0;
552 int channels = platform_edid_get_max_channels(out->dev->platform);
553
554 switch (channels) {
555 /*
556 * Do not handle stereo output in Multi-channel cases
557 * Stereo case is handled in normal playback path
558 */
559 case 6:
560 ALOGV("%s: HDMI supports 5.1", __func__);
561 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
562 break;
563 case 8:
564 ALOGV("%s: HDMI supports 5.1 and 7.1 channels", __func__);
565 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
566 out->supported_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1;
567 break;
568 default:
569 ALOGE("HDMI does not support multi channel playback");
570 ret = -ENOSYS;
571 break;
572 }
573 return ret;
574 }
575
get_voice_usecase_id_from_list(struct audio_device * adev)576 static audio_usecase_t get_voice_usecase_id_from_list(struct audio_device *adev)
577 {
578 struct audio_usecase *usecase;
579 struct listnode *node;
580
581 list_for_each(node, &adev->usecase_list) {
582 usecase = node_to_item(node, struct audio_usecase, list);
583 if (usecase->type == VOICE_CALL) {
584 ALOGV("%s: usecase id %d", __func__, usecase->id);
585 return usecase->id;
586 }
587 }
588 return USECASE_INVALID;
589 }
590
get_usecase_from_list(struct audio_device * adev,audio_usecase_t uc_id)591 struct audio_usecase *get_usecase_from_list(struct audio_device *adev,
592 audio_usecase_t uc_id)
593 {
594 struct audio_usecase *usecase;
595 struct listnode *node;
596
597 list_for_each(node, &adev->usecase_list) {
598 usecase = node_to_item(node, struct audio_usecase, list);
599 if (usecase->id == uc_id)
600 return usecase;
601 }
602 return NULL;
603 }
604
select_devices(struct audio_device * adev,audio_usecase_t uc_id)605 int select_devices(struct audio_device *adev,
606 audio_usecase_t uc_id)
607 {
608 snd_device_t out_snd_device = SND_DEVICE_NONE;
609 snd_device_t in_snd_device = SND_DEVICE_NONE;
610 struct audio_usecase *usecase = NULL;
611 struct audio_usecase *vc_usecase = NULL;
612 struct audio_usecase *hfp_usecase = NULL;
613 audio_usecase_t hfp_ucid;
614 struct listnode *node;
615 int status = 0;
616
617 usecase = get_usecase_from_list(adev, uc_id);
618 if (usecase == NULL) {
619 ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id);
620 return -EINVAL;
621 }
622
623 if ((usecase->type == VOICE_CALL) ||
624 (usecase->type == PCM_HFP_CALL)) {
625 out_snd_device = platform_get_output_snd_device(adev->platform,
626 usecase->stream.out->devices);
627 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
628 usecase->devices = usecase->stream.out->devices;
629 } else {
630 /*
631 * If the voice call is active, use the sound devices of voice call usecase
632 * so that it would not result any device switch. All the usecases will
633 * be switched to new device when select_devices() is called for voice call
634 * usecase. This is to avoid switching devices for voice call when
635 * check_and_route_playback_usecases() is called below.
636 */
637 if (voice_is_in_call(adev)) {
638 vc_usecase = get_usecase_from_list(adev,
639 get_voice_usecase_id_from_list(adev));
640 if ((vc_usecase != NULL) &&
641 ((vc_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
642 (usecase->devices == AUDIO_DEVICE_IN_VOICE_CALL))) {
643 in_snd_device = vc_usecase->in_snd_device;
644 out_snd_device = vc_usecase->out_snd_device;
645 }
646 } else if (audio_extn_hfp_is_active(adev)) {
647 hfp_ucid = audio_extn_hfp_get_usecase();
648 hfp_usecase = get_usecase_from_list(adev, hfp_ucid);
649 if (hfp_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) {
650 in_snd_device = hfp_usecase->in_snd_device;
651 out_snd_device = hfp_usecase->out_snd_device;
652 }
653 }
654 if (usecase->type == PCM_PLAYBACK) {
655 usecase->devices = usecase->stream.out->devices;
656 in_snd_device = SND_DEVICE_NONE;
657 if (out_snd_device == SND_DEVICE_NONE) {
658 out_snd_device = platform_get_output_snd_device(adev->platform,
659 usecase->stream.out->devices);
660 if (usecase->stream.out == adev->primary_output &&
661 adev->active_input &&
662 (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
663 adev->mode == AUDIO_MODE_IN_COMMUNICATION) &&
664 out_snd_device != usecase->out_snd_device) {
665 select_devices(adev, adev->active_input->usecase);
666 }
667 }
668 } else if (usecase->type == PCM_CAPTURE) {
669 usecase->devices = usecase->stream.in->device;
670 out_snd_device = SND_DEVICE_NONE;
671 if (in_snd_device == SND_DEVICE_NONE) {
672 audio_devices_t out_device = AUDIO_DEVICE_NONE;
673 if (adev->active_input &&
674 (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
675 adev->mode == AUDIO_MODE_IN_COMMUNICATION)) {
676 platform_set_echo_reference(adev, false, AUDIO_DEVICE_NONE);
677 if (usecase->id == USECASE_AUDIO_RECORD_AFE_PROXY) {
678 out_device = AUDIO_DEVICE_OUT_TELEPHONY_TX;
679 } else if (adev->primary_output) {
680 out_device = adev->primary_output->devices;
681 }
682 }
683 in_snd_device = platform_get_input_snd_device(adev->platform, out_device);
684 }
685 }
686 }
687
688 if (out_snd_device == usecase->out_snd_device &&
689 in_snd_device == usecase->in_snd_device) {
690 return 0;
691 }
692
693 if (out_snd_device != SND_DEVICE_NONE &&
694 out_snd_device != adev->last_logged_snd_device[uc_id][0]) {
695 ALOGD("%s: changing use case %s output device from(%d: %s, acdb %d) to (%d: %s, acdb %d)",
696 __func__,
697 use_case_table[uc_id],
698 adev->last_logged_snd_device[uc_id][0],
699 platform_get_snd_device_name(adev->last_logged_snd_device[uc_id][0]),
700 adev->last_logged_snd_device[uc_id][0] != SND_DEVICE_NONE ?
701 platform_get_snd_device_acdb_id(adev->last_logged_snd_device[uc_id][0]) :
702 -1,
703 out_snd_device,
704 platform_get_snd_device_name(out_snd_device),
705 platform_get_snd_device_acdb_id(out_snd_device));
706 adev->last_logged_snd_device[uc_id][0] = out_snd_device;
707 }
708 if (in_snd_device != SND_DEVICE_NONE &&
709 in_snd_device != adev->last_logged_snd_device[uc_id][1]) {
710 ALOGD("%s: changing use case %s input device from(%d: %s, acdb %d) to (%d: %s, acdb %d)",
711 __func__,
712 use_case_table[uc_id],
713 adev->last_logged_snd_device[uc_id][1],
714 platform_get_snd_device_name(adev->last_logged_snd_device[uc_id][1]),
715 adev->last_logged_snd_device[uc_id][1] != SND_DEVICE_NONE ?
716 platform_get_snd_device_acdb_id(adev->last_logged_snd_device[uc_id][1]) :
717 -1,
718 in_snd_device,
719 platform_get_snd_device_name(in_snd_device),
720 platform_get_snd_device_acdb_id(in_snd_device));
721 adev->last_logged_snd_device[uc_id][1] = in_snd_device;
722 }
723
724 /*
725 * Limitation: While in call, to do a device switch we need to disable
726 * and enable both RX and TX devices though one of them is same as current
727 * device.
728 */
729 if ((usecase->type == VOICE_CALL) &&
730 (usecase->in_snd_device != SND_DEVICE_NONE) &&
731 (usecase->out_snd_device != SND_DEVICE_NONE)) {
732 status = platform_switch_voice_call_device_pre(adev->platform);
733 /* Disable sidetone only if voice call already exists */
734 if (voice_is_call_state_active(adev))
735 voice_set_sidetone(adev, usecase->out_snd_device, false);
736 }
737
738 /* Disable current sound devices */
739 if (usecase->out_snd_device != SND_DEVICE_NONE) {
740 disable_audio_route(adev, usecase);
741 disable_snd_device(adev, usecase->out_snd_device);
742 }
743
744 if (usecase->in_snd_device != SND_DEVICE_NONE) {
745 disable_audio_route(adev, usecase);
746 disable_snd_device(adev, usecase->in_snd_device);
747 }
748
749 /* Applicable only on the targets that has external modem.
750 * New device information should be sent to modem before enabling
751 * the devices to reduce in-call device switch time.
752 */
753 if ((usecase->type == VOICE_CALL) &&
754 (usecase->in_snd_device != SND_DEVICE_NONE) &&
755 (usecase->out_snd_device != SND_DEVICE_NONE)) {
756 status = platform_switch_voice_call_enable_device_config(adev->platform,
757 out_snd_device,
758 in_snd_device);
759 }
760
761 /* Enable new sound devices */
762 if (out_snd_device != SND_DEVICE_NONE) {
763 if (usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND)
764 check_and_route_playback_usecases(adev, usecase, out_snd_device);
765 enable_snd_device(adev, out_snd_device);
766 }
767
768 if (in_snd_device != SND_DEVICE_NONE) {
769 check_and_route_capture_usecases(adev, usecase, in_snd_device);
770 enable_snd_device(adev, in_snd_device);
771 }
772
773 if (usecase->type == VOICE_CALL)
774 status = platform_switch_voice_call_device_post(adev->platform,
775 out_snd_device,
776 in_snd_device);
777
778 usecase->in_snd_device = in_snd_device;
779 usecase->out_snd_device = out_snd_device;
780
781 enable_audio_route(adev, usecase);
782
783 /* Applicable only on the targets that has external modem.
784 * Enable device command should be sent to modem only after
785 * enabling voice call mixer controls
786 */
787 if (usecase->type == VOICE_CALL) {
788 status = platform_switch_voice_call_usecase_route_post(adev->platform,
789 out_snd_device,
790 in_snd_device);
791 /* Enable sidetone only if voice call already exists */
792 if (voice_is_call_state_active(adev))
793 voice_set_sidetone(adev, out_snd_device, true);
794 }
795
796 return status;
797 }
798
stop_input_stream(struct stream_in * in)799 static int stop_input_stream(struct stream_in *in)
800 {
801 int i, ret = 0;
802 struct audio_usecase *uc_info;
803 struct audio_device *adev = in->dev;
804
805 adev->active_input = NULL;
806
807 ALOGV("%s: enter: usecase(%d: %s)", __func__,
808 in->usecase, use_case_table[in->usecase]);
809 uc_info = get_usecase_from_list(adev, in->usecase);
810 if (uc_info == NULL) {
811 ALOGE("%s: Could not find the usecase (%d) in the list",
812 __func__, in->usecase);
813 return -EINVAL;
814 }
815
816 /* 1. Disable stream specific mixer controls */
817 disable_audio_route(adev, uc_info);
818
819 /* 2. Disable the tx device */
820 disable_snd_device(adev, uc_info->in_snd_device);
821
822 list_remove(&uc_info->list);
823 free(uc_info);
824
825 ALOGV("%s: exit: status(%d)", __func__, ret);
826 return ret;
827 }
828
start_input_stream(struct stream_in * in)829 int start_input_stream(struct stream_in *in)
830 {
831 /* 1. Enable output device and stream routing controls */
832 int ret = 0;
833 struct audio_usecase *uc_info;
834 struct audio_device *adev = in->dev;
835
836 ALOGV("%s: enter: usecase(%d)", __func__, in->usecase);
837 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
838 if (in->pcm_device_id < 0) {
839 ALOGE("%s: Could not find PCM device id for the usecase(%d)",
840 __func__, in->usecase);
841 ret = -EINVAL;
842 goto error_config;
843 }
844
845 adev->active_input = in;
846 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
847 uc_info->id = in->usecase;
848 uc_info->type = PCM_CAPTURE;
849 uc_info->stream.in = in;
850 uc_info->devices = in->device;
851 uc_info->in_snd_device = SND_DEVICE_NONE;
852 uc_info->out_snd_device = SND_DEVICE_NONE;
853
854 list_add_tail(&adev->usecase_list, &uc_info->list);
855
856 audio_extn_perf_lock_acquire();
857
858 select_devices(adev, in->usecase);
859
860 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
861 __func__, adev->snd_card, in->pcm_device_id, in->config.channels);
862
863 unsigned int flags = PCM_IN | PCM_MONOTONIC;
864 unsigned int pcm_open_retry_count = 0;
865
866 if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY) {
867 flags |= PCM_MMAP | PCM_NOIRQ;
868 pcm_open_retry_count = PROXY_OPEN_RETRY_COUNT;
869 }
870
871 while (1) {
872 in->pcm = pcm_open(adev->snd_card, in->pcm_device_id,
873 flags, &in->config);
874 if (in->pcm == NULL || !pcm_is_ready(in->pcm)) {
875 ALOGE("%s: %s", __func__, pcm_get_error(in->pcm));
876 if (in->pcm != NULL) {
877 pcm_close(in->pcm);
878 in->pcm = NULL;
879 }
880 if (pcm_open_retry_count-- == 0) {
881 ret = -EIO;
882 goto error_open;
883 }
884 usleep(PROXY_OPEN_WAIT_TIME * 1000);
885 continue;
886 }
887 break;
888 }
889
890 ALOGV("%s: pcm_prepare", __func__);
891 ret = pcm_prepare(in->pcm);
892 if (ret < 0) {
893 ALOGE("%s: pcm_prepare returned %d", __func__, ret);
894 pcm_close(in->pcm);
895 in->pcm = NULL;
896 goto error_open;
897 }
898
899 audio_extn_perf_lock_release();
900
901 ALOGV("%s: exit", __func__);
902
903 return ret;
904
905 error_open:
906 stop_input_stream(in);
907 audio_extn_perf_lock_release();
908
909 error_config:
910 adev->active_input = NULL;
911 ALOGW("%s: exit: status(%d)", __func__, ret);
912
913 return ret;
914 }
915
lock_input_stream(struct stream_in * in)916 void lock_input_stream(struct stream_in *in)
917 {
918 pthread_mutex_lock(&in->pre_lock);
919 pthread_mutex_lock(&in->lock);
920 pthread_mutex_unlock(&in->pre_lock);
921 }
922
lock_output_stream(struct stream_out * out)923 void lock_output_stream(struct stream_out *out)
924 {
925 pthread_mutex_lock(&out->pre_lock);
926 pthread_mutex_lock(&out->lock);
927 pthread_mutex_unlock(&out->pre_lock);
928 }
929
930 /* must be called with out->lock locked */
send_offload_cmd_l(struct stream_out * out,int command)931 static int send_offload_cmd_l(struct stream_out* out, int command)
932 {
933 struct offload_cmd *cmd = (struct offload_cmd *)calloc(1, sizeof(struct offload_cmd));
934
935 ALOGVV("%s %d", __func__, command);
936
937 cmd->cmd = command;
938 list_add_tail(&out->offload_cmd_list, &cmd->node);
939 pthread_cond_signal(&out->offload_cond);
940 return 0;
941 }
942
943 /* must be called iwth out->lock locked */
stop_compressed_output_l(struct stream_out * out)944 static void stop_compressed_output_l(struct stream_out *out)
945 {
946 out->offload_state = OFFLOAD_STATE_IDLE;
947 out->playback_started = 0;
948 out->send_new_metadata = 1;
949 if (out->compr != NULL) {
950 compress_stop(out->compr);
951 while (out->offload_thread_blocked) {
952 pthread_cond_wait(&out->cond, &out->lock);
953 }
954 }
955 }
956
offload_thread_loop(void * context)957 static void *offload_thread_loop(void *context)
958 {
959 struct stream_out *out = (struct stream_out *) context;
960 struct listnode *item;
961
962 out->offload_state = OFFLOAD_STATE_IDLE;
963 out->playback_started = 0;
964
965 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
966 set_sched_policy(0, SP_FOREGROUND);
967 prctl(PR_SET_NAME, (unsigned long)"Offload Callback", 0, 0, 0);
968
969 ALOGV("%s", __func__);
970 lock_output_stream(out);
971 for (;;) {
972 struct offload_cmd *cmd = NULL;
973 stream_callback_event_t event;
974 bool send_callback = false;
975
976 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
977 __func__, list_empty(&out->offload_cmd_list),
978 out->offload_state);
979 if (list_empty(&out->offload_cmd_list)) {
980 ALOGV("%s SLEEPING", __func__);
981 pthread_cond_wait(&out->offload_cond, &out->lock);
982 ALOGV("%s RUNNING", __func__);
983 continue;
984 }
985
986 item = list_head(&out->offload_cmd_list);
987 cmd = node_to_item(item, struct offload_cmd, node);
988 list_remove(item);
989
990 ALOGVV("%s STATE %d CMD %d out->compr %p",
991 __func__, out->offload_state, cmd->cmd, out->compr);
992
993 if (cmd->cmd == OFFLOAD_CMD_EXIT) {
994 free(cmd);
995 break;
996 }
997
998 if (out->compr == NULL) {
999 ALOGE("%s: Compress handle is NULL", __func__);
1000 free(cmd);
1001 pthread_cond_signal(&out->cond);
1002 continue;
1003 }
1004 out->offload_thread_blocked = true;
1005 pthread_mutex_unlock(&out->lock);
1006 send_callback = false;
1007 switch(cmd->cmd) {
1008 case OFFLOAD_CMD_WAIT_FOR_BUFFER:
1009 compress_wait(out->compr, -1);
1010 send_callback = true;
1011 event = STREAM_CBK_EVENT_WRITE_READY;
1012 break;
1013 case OFFLOAD_CMD_PARTIAL_DRAIN:
1014 compress_next_track(out->compr);
1015 compress_partial_drain(out->compr);
1016 send_callback = true;
1017 event = STREAM_CBK_EVENT_DRAIN_READY;
1018 /* Resend the metadata for next iteration */
1019 out->send_new_metadata = 1;
1020 break;
1021 case OFFLOAD_CMD_DRAIN:
1022 compress_drain(out->compr);
1023 send_callback = true;
1024 event = STREAM_CBK_EVENT_DRAIN_READY;
1025 break;
1026 default:
1027 ALOGE("%s unknown command received: %d", __func__, cmd->cmd);
1028 break;
1029 }
1030 lock_output_stream(out);
1031 out->offload_thread_blocked = false;
1032 pthread_cond_signal(&out->cond);
1033 if (send_callback) {
1034 ALOGVV("%s: sending offload_callback event %d", __func__, event);
1035 out->offload_callback(event, NULL, out->offload_cookie);
1036 }
1037 free(cmd);
1038 }
1039
1040 pthread_cond_signal(&out->cond);
1041 while (!list_empty(&out->offload_cmd_list)) {
1042 item = list_head(&out->offload_cmd_list);
1043 list_remove(item);
1044 free(node_to_item(item, struct offload_cmd, node));
1045 }
1046 pthread_mutex_unlock(&out->lock);
1047
1048 return NULL;
1049 }
1050
create_offload_callback_thread(struct stream_out * out)1051 static int create_offload_callback_thread(struct stream_out *out)
1052 {
1053 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
1054 list_init(&out->offload_cmd_list);
1055 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
1056 offload_thread_loop, out);
1057 return 0;
1058 }
1059
destroy_offload_callback_thread(struct stream_out * out)1060 static int destroy_offload_callback_thread(struct stream_out *out)
1061 {
1062 lock_output_stream(out);
1063 stop_compressed_output_l(out);
1064 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
1065
1066 pthread_mutex_unlock(&out->lock);
1067 pthread_join(out->offload_thread, (void **) NULL);
1068 pthread_cond_destroy(&out->offload_cond);
1069
1070 return 0;
1071 }
1072
allow_hdmi_channel_config(struct audio_device * adev)1073 static bool allow_hdmi_channel_config(struct audio_device *adev)
1074 {
1075 struct listnode *node;
1076 struct audio_usecase *usecase;
1077 bool ret = true;
1078
1079 list_for_each(node, &adev->usecase_list) {
1080 usecase = node_to_item(node, struct audio_usecase, list);
1081 if (usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1082 /*
1083 * If voice call is already existing, do not proceed further to avoid
1084 * disabling/enabling both RX and TX devices, CSD calls, etc.
1085 * Once the voice call done, the HDMI channels can be configured to
1086 * max channels of remaining use cases.
1087 */
1088 if (usecase->id == USECASE_VOICE_CALL) {
1089 ALOGV("%s: voice call is active, no change in HDMI channels",
1090 __func__);
1091 ret = false;
1092 break;
1093 } else if (usecase->id == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
1094 ALOGV("%s: multi channel playback is active, "
1095 "no change in HDMI channels", __func__);
1096 ret = false;
1097 break;
1098 }
1099 }
1100 }
1101 return ret;
1102 }
1103
check_and_set_hdmi_channels(struct audio_device * adev,unsigned int channels)1104 static int check_and_set_hdmi_channels(struct audio_device *adev,
1105 unsigned int channels)
1106 {
1107 struct listnode *node;
1108 struct audio_usecase *usecase;
1109
1110 /* Check if change in HDMI channel config is allowed */
1111 if (!allow_hdmi_channel_config(adev))
1112 return 0;
1113
1114 if (channels == adev->cur_hdmi_channels) {
1115 ALOGV("%s: Requested channels are same as current", __func__);
1116 return 0;
1117 }
1118
1119 platform_set_hdmi_channels(adev->platform, channels);
1120 adev->cur_hdmi_channels = channels;
1121
1122 /*
1123 * Deroute all the playback streams routed to HDMI so that
1124 * the back end is deactivated. Note that backend will not
1125 * be deactivated if any one stream is connected to it.
1126 */
1127 list_for_each(node, &adev->usecase_list) {
1128 usecase = node_to_item(node, struct audio_usecase, list);
1129 if (usecase->type == PCM_PLAYBACK &&
1130 usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1131 disable_audio_route(adev, usecase);
1132 }
1133 }
1134
1135 /*
1136 * Enable all the streams disabled above. Now the HDMI backend
1137 * will be activated with new channel configuration
1138 */
1139 list_for_each(node, &adev->usecase_list) {
1140 usecase = node_to_item(node, struct audio_usecase, list);
1141 if (usecase->type == PCM_PLAYBACK &&
1142 usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1143 enable_audio_route(adev, usecase);
1144 }
1145 }
1146
1147 return 0;
1148 }
1149
stop_output_stream(struct stream_out * out)1150 static int stop_output_stream(struct stream_out *out)
1151 {
1152 int i, ret = 0;
1153 struct audio_usecase *uc_info;
1154 struct audio_device *adev = out->dev;
1155
1156 ALOGV("%s: enter: usecase(%d: %s)", __func__,
1157 out->usecase, use_case_table[out->usecase]);
1158 uc_info = get_usecase_from_list(adev, out->usecase);
1159 if (uc_info == NULL) {
1160 ALOGE("%s: Could not find the usecase (%d) in the list",
1161 __func__, out->usecase);
1162 return -EINVAL;
1163 }
1164
1165 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1166 if (adev->visualizer_stop_output != NULL)
1167 adev->visualizer_stop_output(out->handle, out->pcm_device_id);
1168 if (adev->offload_effects_stop_output != NULL)
1169 adev->offload_effects_stop_output(out->handle, out->pcm_device_id);
1170 }
1171
1172 /* 1. Get and set stream specific mixer controls */
1173 disable_audio_route(adev, uc_info);
1174
1175 /* 2. Disable the rx device */
1176 disable_snd_device(adev, uc_info->out_snd_device);
1177
1178 list_remove(&uc_info->list);
1179 free(uc_info);
1180
1181 audio_extn_extspk_update(adev->extspk);
1182
1183 /* Must be called after removing the usecase from list */
1184 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1185 check_and_set_hdmi_channels(adev, DEFAULT_HDMI_OUT_CHANNELS);
1186
1187 ALOGV("%s: exit: status(%d)", __func__, ret);
1188 return ret;
1189 }
1190
start_output_stream(struct stream_out * out)1191 int start_output_stream(struct stream_out *out)
1192 {
1193 int ret = 0;
1194 struct audio_usecase *uc_info;
1195 struct audio_device *adev = out->dev;
1196
1197 ALOGV("%s: enter: usecase(%d: %s) devices(%#x)",
1198 __func__, out->usecase, use_case_table[out->usecase], out->devices);
1199 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
1200 if (out->pcm_device_id < 0) {
1201 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
1202 __func__, out->pcm_device_id, out->usecase);
1203 ret = -EINVAL;
1204 goto error_config;
1205 }
1206
1207 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
1208 uc_info->id = out->usecase;
1209 uc_info->type = PCM_PLAYBACK;
1210 uc_info->stream.out = out;
1211 uc_info->devices = out->devices;
1212 uc_info->in_snd_device = SND_DEVICE_NONE;
1213 uc_info->out_snd_device = SND_DEVICE_NONE;
1214
1215 /* This must be called before adding this usecase to the list */
1216 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
1217 check_and_set_hdmi_channels(adev, out->config.channels);
1218
1219 list_add_tail(&adev->usecase_list, &uc_info->list);
1220
1221 audio_extn_perf_lock_acquire();
1222
1223 select_devices(adev, out->usecase);
1224
1225 audio_extn_extspk_update(adev->extspk);
1226
1227 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d) format(%#x)",
1228 __func__, adev->snd_card, out->pcm_device_id, out->config.format);
1229 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1230 unsigned int flags = PCM_OUT;
1231 unsigned int pcm_open_retry_count = 0;
1232 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
1233 flags |= PCM_MMAP | PCM_NOIRQ;
1234 pcm_open_retry_count = PROXY_OPEN_RETRY_COUNT;
1235 } else
1236 flags |= PCM_MONOTONIC;
1237
1238 while (1) {
1239 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
1240 flags, &out->config);
1241 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
1242 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
1243 if (out->pcm != NULL) {
1244 pcm_close(out->pcm);
1245 out->pcm = NULL;
1246 }
1247 if (pcm_open_retry_count-- == 0) {
1248 ret = -EIO;
1249 goto error_open;
1250 }
1251 usleep(PROXY_OPEN_WAIT_TIME * 1000);
1252 continue;
1253 }
1254 break;
1255 }
1256 ALOGV("%s: pcm_prepare", __func__);
1257 if (pcm_is_ready(out->pcm)) {
1258 ret = pcm_prepare(out->pcm);
1259 if (ret < 0) {
1260 ALOGE("%s: pcm_prepare returned %d", __func__, ret);
1261 pcm_close(out->pcm);
1262 out->pcm = NULL;
1263 goto error_open;
1264 }
1265 }
1266 } else {
1267 out->pcm = NULL;
1268 out->compr = compress_open(adev->snd_card, out->pcm_device_id,
1269 COMPRESS_IN, &out->compr_config);
1270 if (out->compr && !is_compress_ready(out->compr)) {
1271 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
1272 compress_close(out->compr);
1273 out->compr = NULL;
1274 ret = -EIO;
1275 goto error_open;
1276 }
1277 if (out->offload_callback)
1278 compress_nonblock(out->compr, out->non_blocking);
1279
1280 if (adev->visualizer_start_output != NULL)
1281 adev->visualizer_start_output(out->handle, out->pcm_device_id);
1282 if (adev->offload_effects_start_output != NULL)
1283 adev->offload_effects_start_output(out->handle, out->pcm_device_id);
1284 }
1285 audio_extn_perf_lock_release();
1286 ALOGV("%s: exit", __func__);
1287 return 0;
1288 error_open:
1289 audio_extn_perf_lock_release();
1290 stop_output_stream(out);
1291 error_config:
1292 return ret;
1293 }
1294
check_input_parameters(uint32_t sample_rate,audio_format_t format,int channel_count)1295 static int check_input_parameters(uint32_t sample_rate,
1296 audio_format_t format,
1297 int channel_count)
1298 {
1299 if ((format != AUDIO_FORMAT_PCM_16_BIT) && (format != AUDIO_FORMAT_PCM_8_24_BIT)) {
1300 ALOGE("%s: unsupported AUDIO FORMAT (%d) ", __func__, format);
1301 return -EINVAL;
1302 }
1303
1304 if ((channel_count < MIN_CHANNEL_COUNT) || (channel_count > MAX_CHANNEL_COUNT)) {
1305 ALOGE("%s: unsupported channel count (%d) passed Min / Max (%d / %d)", __func__,
1306 channel_count, MIN_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1307 return -EINVAL;
1308 }
1309
1310 switch (sample_rate) {
1311 case 8000:
1312 case 11025:
1313 case 12000:
1314 case 16000:
1315 case 22050:
1316 case 24000:
1317 case 32000:
1318 case 44100:
1319 case 48000:
1320 break;
1321 default:
1322 ALOGE("%s: unsupported (%d) samplerate passed ", __func__, sample_rate);
1323 return -EINVAL;
1324 }
1325
1326 return 0;
1327 }
1328
get_input_buffer_size(uint32_t sample_rate,audio_format_t format,int channel_count,bool is_low_latency)1329 static size_t get_input_buffer_size(uint32_t sample_rate,
1330 audio_format_t format,
1331 int channel_count,
1332 bool is_low_latency)
1333 {
1334 size_t size = 0;
1335
1336 if (check_input_parameters(sample_rate, format, channel_count) != 0)
1337 return 0;
1338
1339 size = (sample_rate * AUDIO_CAPTURE_PERIOD_DURATION_MSEC) / 1000;
1340 if (is_low_latency)
1341 size = configured_low_latency_capture_period_size;
1342
1343 size *= channel_count * audio_bytes_per_sample(format);
1344
1345 /* make sure the size is multiple of 32 bytes
1346 * At 48 kHz mono 16-bit PCM:
1347 * 5.000 ms = 240 frames = 15*16*1*2 = 480, a whole multiple of 32 (15)
1348 * 3.333 ms = 160 frames = 10*16*1*2 = 320, a whole multiple of 32 (10)
1349 */
1350 size += 0x1f;
1351 size &= ~0x1f;
1352
1353 return size;
1354 }
1355
out_get_sample_rate(const struct audio_stream * stream)1356 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
1357 {
1358 struct stream_out *out = (struct stream_out *)stream;
1359
1360 return out->sample_rate;
1361 }
1362
out_set_sample_rate(struct audio_stream * stream __unused,uint32_t rate __unused)1363 static int out_set_sample_rate(struct audio_stream *stream __unused, uint32_t rate __unused)
1364 {
1365 return -ENOSYS;
1366 }
1367
out_get_buffer_size(const struct audio_stream * stream)1368 static size_t out_get_buffer_size(const struct audio_stream *stream)
1369 {
1370 struct stream_out *out = (struct stream_out *)stream;
1371
1372 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1373 return out->compr_config.fragment_size;
1374 }
1375 return out->config.period_size *
1376 audio_stream_out_frame_size((const struct audio_stream_out *)stream);
1377 }
1378
out_get_channels(const struct audio_stream * stream)1379 static uint32_t out_get_channels(const struct audio_stream *stream)
1380 {
1381 struct stream_out *out = (struct stream_out *)stream;
1382
1383 return out->channel_mask;
1384 }
1385
out_get_format(const struct audio_stream * stream)1386 static audio_format_t out_get_format(const struct audio_stream *stream)
1387 {
1388 struct stream_out *out = (struct stream_out *)stream;
1389
1390 return out->format;
1391 }
1392
out_set_format(struct audio_stream * stream __unused,audio_format_t format __unused)1393 static int out_set_format(struct audio_stream *stream __unused, audio_format_t format __unused)
1394 {
1395 return -ENOSYS;
1396 }
1397
out_standby(struct audio_stream * stream)1398 static int out_standby(struct audio_stream *stream)
1399 {
1400 struct stream_out *out = (struct stream_out *)stream;
1401 struct audio_device *adev = out->dev;
1402
1403 ALOGV("%s: enter: usecase(%d: %s)", __func__,
1404 out->usecase, use_case_table[out->usecase]);
1405
1406 lock_output_stream(out);
1407 if (!out->standby) {
1408 if (adev->adm_deregister_stream)
1409 adev->adm_deregister_stream(adev->adm_data, out->handle);
1410
1411 pthread_mutex_lock(&adev->lock);
1412 out->standby = true;
1413 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1414 if (out->pcm) {
1415 pcm_close(out->pcm);
1416 out->pcm = NULL;
1417 }
1418 } else {
1419 stop_compressed_output_l(out);
1420 out->gapless_mdata.encoder_delay = 0;
1421 out->gapless_mdata.encoder_padding = 0;
1422 if (out->compr != NULL) {
1423 compress_close(out->compr);
1424 out->compr = NULL;
1425 }
1426 }
1427 stop_output_stream(out);
1428 pthread_mutex_unlock(&adev->lock);
1429 }
1430 pthread_mutex_unlock(&out->lock);
1431 ALOGV("%s: exit", __func__);
1432 return 0;
1433 }
1434
out_dump(const struct audio_stream * stream __unused,int fd __unused)1435 static int out_dump(const struct audio_stream *stream __unused, int fd __unused)
1436 {
1437 return 0;
1438 }
1439
parse_compress_metadata(struct stream_out * out,struct str_parms * parms)1440 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
1441 {
1442 int ret = 0;
1443 char value[32];
1444 struct compr_gapless_mdata tmp_mdata;
1445
1446 if (!out || !parms) {
1447 return -EINVAL;
1448 }
1449
1450 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES, value, sizeof(value));
1451 if (ret >= 0) {
1452 tmp_mdata.encoder_delay = atoi(value); //whats a good limit check?
1453 } else {
1454 return -EINVAL;
1455 }
1456
1457 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES, value, sizeof(value));
1458 if (ret >= 0) {
1459 tmp_mdata.encoder_padding = atoi(value);
1460 } else {
1461 return -EINVAL;
1462 }
1463
1464 out->gapless_mdata = tmp_mdata;
1465 out->send_new_metadata = 1;
1466 ALOGV("%s new encoder delay %u and padding %u", __func__,
1467 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
1468
1469 return 0;
1470 }
1471
output_drives_call(struct audio_device * adev,struct stream_out * out)1472 static bool output_drives_call(struct audio_device *adev, struct stream_out *out)
1473 {
1474 return out == adev->primary_output || out == adev->voice_tx_output;
1475 }
1476
out_set_parameters(struct audio_stream * stream,const char * kvpairs)1477 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
1478 {
1479 struct stream_out *out = (struct stream_out *)stream;
1480 struct audio_device *adev = out->dev;
1481 struct audio_usecase *usecase;
1482 struct listnode *node;
1483 struct str_parms *parms;
1484 char value[32];
1485 int ret, val = 0;
1486 bool select_new_device = false;
1487 int status = 0;
1488
1489 ALOGV("%s: enter: usecase(%d: %s) kvpairs: %s",
1490 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
1491 parms = str_parms_create_str(kvpairs);
1492 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
1493 if (ret >= 0) {
1494 val = atoi(value);
1495 lock_output_stream(out);
1496 pthread_mutex_lock(&adev->lock);
1497
1498 /*
1499 * When HDMI cable is unplugged the music playback is paused and
1500 * the policy manager sends routing=0. But the audioflinger
1501 * continues to write data until standby time (3sec).
1502 * As the HDMI core is turned off, the write gets blocked.
1503 * Avoid this by routing audio to speaker until standby.
1504 */
1505 if (out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL &&
1506 val == AUDIO_DEVICE_NONE) {
1507 val = AUDIO_DEVICE_OUT_SPEAKER;
1508 }
1509
1510 /*
1511 * select_devices() call below switches all the usecases on the same
1512 * backend to the new device. Refer to check_and_route_playback_usecases() in
1513 * the select_devices(). But how do we undo this?
1514 *
1515 * For example, music playback is active on headset (deep-buffer usecase)
1516 * and if we go to ringtones and select a ringtone, low-latency usecase
1517 * will be started on headset+speaker. As we can't enable headset+speaker
1518 * and headset devices at the same time, select_devices() switches the music
1519 * playback to headset+speaker while starting low-lateny usecase for ringtone.
1520 * So when the ringtone playback is completed, how do we undo the same?
1521 *
1522 * We are relying on the out_set_parameters() call on deep-buffer output,
1523 * once the ringtone playback is ended.
1524 * NOTE: We should not check if the current devices are same as new devices.
1525 * Because select_devices() must be called to switch back the music
1526 * playback to headset.
1527 */
1528 if (val != 0) {
1529 out->devices = val;
1530
1531 if (!out->standby)
1532 select_devices(adev, out->usecase);
1533
1534 if (output_drives_call(adev, out)) {
1535 if (!voice_is_in_call(adev)) {
1536 if (adev->mode == AUDIO_MODE_IN_CALL) {
1537 adev->current_call_output = out;
1538 ret = voice_start_call(adev);
1539 }
1540 } else {
1541 adev->current_call_output = out;
1542 voice_update_devices_for_all_voice_usecases(adev);
1543 }
1544 }
1545 }
1546
1547 pthread_mutex_unlock(&adev->lock);
1548 pthread_mutex_unlock(&out->lock);
1549
1550 /*handles device and call state changes*/
1551 audio_extn_extspk_update(adev->extspk);
1552 }
1553
1554 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1555 parse_compress_metadata(out, parms);
1556 }
1557
1558 str_parms_destroy(parms);
1559 ALOGV("%s: exit: code(%d)", __func__, status);
1560 return status;
1561 }
1562
out_get_parameters(const struct audio_stream * stream,const char * keys)1563 static char* out_get_parameters(const struct audio_stream *stream, const char *keys)
1564 {
1565 struct stream_out *out = (struct stream_out *)stream;
1566 struct str_parms *query = str_parms_create_str(keys);
1567 char *str;
1568 char value[256];
1569 struct str_parms *reply = str_parms_create();
1570 size_t i, j;
1571 int ret;
1572 bool first = true;
1573 ALOGV("%s: enter: keys - %s", __func__, keys);
1574 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
1575 if (ret >= 0) {
1576 value[0] = '\0';
1577 i = 0;
1578 while (out->supported_channel_masks[i] != 0) {
1579 for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) {
1580 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
1581 if (!first) {
1582 strcat(value, "|");
1583 }
1584 strcat(value, out_channels_name_to_enum_table[j].name);
1585 first = false;
1586 break;
1587 }
1588 }
1589 i++;
1590 }
1591 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
1592 str = str_parms_to_str(reply);
1593 } else {
1594 str = strdup(keys);
1595 }
1596 str_parms_destroy(query);
1597 str_parms_destroy(reply);
1598 ALOGV("%s: exit: returns - %s", __func__, str);
1599 return str;
1600 }
1601
out_get_latency(const struct audio_stream_out * stream)1602 static uint32_t out_get_latency(const struct audio_stream_out *stream)
1603 {
1604 struct stream_out *out = (struct stream_out *)stream;
1605
1606 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
1607 return COMPRESS_OFFLOAD_PLAYBACK_LATENCY;
1608
1609 return (out->config.period_count * out->config.period_size * 1000) /
1610 (out->config.rate);
1611 }
1612
out_set_volume(struct audio_stream_out * stream,float left,float right)1613 static int out_set_volume(struct audio_stream_out *stream, float left,
1614 float right)
1615 {
1616 struct stream_out *out = (struct stream_out *)stream;
1617 int volume[2];
1618
1619 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
1620 /* only take left channel into account: the API is for stereo anyway */
1621 out->muted = (left == 0.0f);
1622 return 0;
1623 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1624 const char *mixer_ctl_name = "Compress Playback Volume";
1625 struct audio_device *adev = out->dev;
1626 struct mixer_ctl *ctl;
1627 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1628 if (!ctl) {
1629 /* try with the control based on device id */
1630 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
1631 PCM_PLAYBACK);
1632 char ctl_name[128] = {0};
1633 snprintf(ctl_name, sizeof(ctl_name),
1634 "Compress Playback %d Volume", pcm_device_id);
1635 ctl = mixer_get_ctl_by_name(adev->mixer, ctl_name);
1636 if (!ctl) {
1637 ALOGE("%s: Could not get volume ctl mixer cmd", __func__);
1638 return -EINVAL;
1639 }
1640 }
1641 volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX);
1642 volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX);
1643 mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
1644 return 0;
1645 }
1646
1647 return -ENOSYS;
1648 }
1649
1650 #ifdef NO_AUDIO_OUT
out_write_for_no_output(struct audio_stream_out * stream,const void * buffer,size_t bytes)1651 static ssize_t out_write_for_no_output(struct audio_stream_out *stream,
1652 const void *buffer, size_t bytes)
1653 {
1654 struct stream_out *out = (struct stream_out *)stream;
1655
1656 /* No Output device supported other than BT for playback.
1657 * Sleep for the amount of buffer duration
1658 */
1659 lock_output_stream(out);
1660 usleep(bytes * 1000000 / audio_stream_out_frame_size(&out->stream.common) /
1661 out_get_sample_rate(&out->stream.common));
1662 pthread_mutex_unlock(&out->lock);
1663 return bytes;
1664 }
1665 #endif
1666
out_write(struct audio_stream_out * stream,const void * buffer,size_t bytes)1667 static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
1668 size_t bytes)
1669 {
1670 struct stream_out *out = (struct stream_out *)stream;
1671 struct audio_device *adev = out->dev;
1672 ssize_t ret = 0;
1673
1674 lock_output_stream(out);
1675 if (out->standby) {
1676 out->standby = false;
1677 pthread_mutex_lock(&adev->lock);
1678 ret = start_output_stream(out);
1679 pthread_mutex_unlock(&adev->lock);
1680 /* ToDo: If use case is compress offload should return 0 */
1681 if (ret != 0) {
1682 out->standby = true;
1683 goto exit;
1684 }
1685 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD && adev->adm_register_output_stream)
1686 adev->adm_register_output_stream(adev->adm_data, out->handle, out->flags);
1687 }
1688
1689 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1690 ALOGVV("%s: writing buffer (%d bytes) to compress device", __func__, bytes);
1691 if (out->send_new_metadata) {
1692 ALOGVV("send new gapless metadata");
1693 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
1694 out->send_new_metadata = 0;
1695 }
1696 unsigned int avail;
1697 struct timespec tstamp;
1698 ret = compress_get_hpointer(out->compr, &avail, &tstamp);
1699 /* Do not limit write size if the available frames count is unknown */
1700 if (ret != 0) {
1701 avail = bytes;
1702 }
1703 if (avail == 0) {
1704 ret = 0;
1705 } else {
1706 if (avail > bytes) {
1707 avail = bytes;
1708 }
1709 ret = compress_write(out->compr, buffer, avail);
1710 ALOGVV("%s: writing buffer (%d bytes) to compress device returned %zd",
1711 __func__, avail, ret);
1712 }
1713
1714 if (ret >= 0 && ret < (ssize_t)bytes) {
1715 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
1716 }
1717 if (ret > 0 && !out->playback_started) {
1718 compress_start(out->compr);
1719 out->playback_started = 1;
1720 out->offload_state = OFFLOAD_STATE_PLAYING;
1721 }
1722 pthread_mutex_unlock(&out->lock);
1723 return ret;
1724 } else {
1725 if (out->pcm) {
1726 if (out->muted)
1727 memset((void *)buffer, 0, bytes);
1728
1729 ALOGVV("%s: writing buffer (%d bytes) to pcm device", __func__, bytes);
1730 if (adev->adm_request_focus)
1731 adev->adm_request_focus(adev->adm_data, out->handle);
1732
1733 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
1734 ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes);
1735 }
1736 else
1737 ret = pcm_write(out->pcm, (void *)buffer, bytes);
1738
1739 if (ret == 0)
1740 out->written += bytes / (out->config.channels * sizeof(short));
1741
1742 if (adev->adm_abandon_focus)
1743 adev->adm_abandon_focus(adev->adm_data, out->handle);
1744 }
1745 }
1746
1747 exit:
1748 pthread_mutex_unlock(&out->lock);
1749
1750 if (ret != 0) {
1751 if (out->pcm)
1752 ALOGE("%s: error %zu - %s", __func__, ret, pcm_get_error(out->pcm));
1753 out_standby(&out->stream.common);
1754 usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) /
1755 out_get_sample_rate(&out->stream.common));
1756 }
1757 return bytes;
1758 }
1759
out_get_render_position(const struct audio_stream_out * stream,uint32_t * dsp_frames)1760 static int out_get_render_position(const struct audio_stream_out *stream,
1761 uint32_t *dsp_frames)
1762 {
1763 struct stream_out *out = (struct stream_out *)stream;
1764 *dsp_frames = 0;
1765 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
1766 lock_output_stream(out);
1767 if (out->compr != NULL) {
1768 unsigned long frames = 0;
1769 // TODO: check return value
1770 compress_get_tstamp(out->compr, &frames, &out->sample_rate);
1771 *dsp_frames = (uint32_t)frames;
1772 ALOGVV("%s rendered frames %d sample_rate %d",
1773 __func__, *dsp_frames, out->sample_rate);
1774 }
1775 pthread_mutex_unlock(&out->lock);
1776 return 0;
1777 } else
1778 return -EINVAL;
1779 }
1780
out_add_audio_effect(const struct audio_stream * stream __unused,effect_handle_t effect __unused)1781 static int out_add_audio_effect(const struct audio_stream *stream __unused,
1782 effect_handle_t effect __unused)
1783 {
1784 return 0;
1785 }
1786
out_remove_audio_effect(const struct audio_stream * stream __unused,effect_handle_t effect __unused)1787 static int out_remove_audio_effect(const struct audio_stream *stream __unused,
1788 effect_handle_t effect __unused)
1789 {
1790 return 0;
1791 }
1792
out_get_next_write_timestamp(const struct audio_stream_out * stream __unused,int64_t * timestamp __unused)1793 static int out_get_next_write_timestamp(const struct audio_stream_out *stream __unused,
1794 int64_t *timestamp __unused)
1795 {
1796 return -EINVAL;
1797 }
1798
out_get_presentation_position(const struct audio_stream_out * stream,uint64_t * frames,struct timespec * timestamp)1799 static int out_get_presentation_position(const struct audio_stream_out *stream,
1800 uint64_t *frames, struct timespec *timestamp)
1801 {
1802 struct stream_out *out = (struct stream_out *)stream;
1803 int ret = -EINVAL;
1804 unsigned long dsp_frames;
1805
1806 lock_output_stream(out);
1807
1808 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1809 if (out->compr != NULL) {
1810 // TODO: check return value
1811 compress_get_tstamp(out->compr, &dsp_frames,
1812 &out->sample_rate);
1813 ALOGVV("%s rendered frames %ld sample_rate %d",
1814 __func__, dsp_frames, out->sample_rate);
1815 *frames = dsp_frames;
1816 ret = 0;
1817 /* this is the best we can do */
1818 clock_gettime(CLOCK_MONOTONIC, timestamp);
1819 }
1820 } else {
1821 if (out->pcm) {
1822 unsigned int avail;
1823 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
1824 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
1825 int64_t signed_frames = out->written - kernel_buffer_size + avail;
1826 // This adjustment accounts for buffering after app processor.
1827 // It is based on estimated DSP latency per use case, rather than exact.
1828 signed_frames -=
1829 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
1830
1831 // It would be unusual for this value to be negative, but check just in case ...
1832 if (signed_frames >= 0) {
1833 *frames = signed_frames;
1834 ret = 0;
1835 }
1836 }
1837 }
1838 }
1839
1840 pthread_mutex_unlock(&out->lock);
1841
1842 return ret;
1843 }
1844
out_set_callback(struct audio_stream_out * stream,stream_callback_t callback,void * cookie)1845 static int out_set_callback(struct audio_stream_out *stream,
1846 stream_callback_t callback, void *cookie)
1847 {
1848 struct stream_out *out = (struct stream_out *)stream;
1849
1850 ALOGV("%s", __func__);
1851 lock_output_stream(out);
1852 out->offload_callback = callback;
1853 out->offload_cookie = cookie;
1854 pthread_mutex_unlock(&out->lock);
1855 return 0;
1856 }
1857
out_pause(struct audio_stream_out * stream)1858 static int out_pause(struct audio_stream_out* stream)
1859 {
1860 struct stream_out *out = (struct stream_out *)stream;
1861 int status = -ENOSYS;
1862 ALOGV("%s", __func__);
1863 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1864 lock_output_stream(out);
1865 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
1866 status = compress_pause(out->compr);
1867 out->offload_state = OFFLOAD_STATE_PAUSED;
1868 }
1869 pthread_mutex_unlock(&out->lock);
1870 }
1871 return status;
1872 }
1873
out_resume(struct audio_stream_out * stream)1874 static int out_resume(struct audio_stream_out* stream)
1875 {
1876 struct stream_out *out = (struct stream_out *)stream;
1877 int status = -ENOSYS;
1878 ALOGV("%s", __func__);
1879 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1880 status = 0;
1881 lock_output_stream(out);
1882 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
1883 status = compress_resume(out->compr);
1884 out->offload_state = OFFLOAD_STATE_PLAYING;
1885 }
1886 pthread_mutex_unlock(&out->lock);
1887 }
1888 return status;
1889 }
1890
out_drain(struct audio_stream_out * stream,audio_drain_type_t type)1891 static int out_drain(struct audio_stream_out* stream, audio_drain_type_t type )
1892 {
1893 struct stream_out *out = (struct stream_out *)stream;
1894 int status = -ENOSYS;
1895 ALOGV("%s", __func__);
1896 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1897 lock_output_stream(out);
1898 if (type == AUDIO_DRAIN_EARLY_NOTIFY)
1899 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
1900 else
1901 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
1902 pthread_mutex_unlock(&out->lock);
1903 }
1904 return status;
1905 }
1906
out_flush(struct audio_stream_out * stream)1907 static int out_flush(struct audio_stream_out* stream)
1908 {
1909 struct stream_out *out = (struct stream_out *)stream;
1910 ALOGV("%s", __func__);
1911 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1912 lock_output_stream(out);
1913 stop_compressed_output_l(out);
1914 pthread_mutex_unlock(&out->lock);
1915 return 0;
1916 }
1917 return -ENOSYS;
1918 }
1919
1920 /** audio_stream_in implementation **/
in_get_sample_rate(const struct audio_stream * stream)1921 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
1922 {
1923 struct stream_in *in = (struct stream_in *)stream;
1924
1925 return in->config.rate;
1926 }
1927
in_set_sample_rate(struct audio_stream * stream __unused,uint32_t rate __unused)1928 static int in_set_sample_rate(struct audio_stream *stream __unused, uint32_t rate __unused)
1929 {
1930 return -ENOSYS;
1931 }
1932
in_get_buffer_size(const struct audio_stream * stream)1933 static size_t in_get_buffer_size(const struct audio_stream *stream)
1934 {
1935 struct stream_in *in = (struct stream_in *)stream;
1936
1937 return in->config.period_size *
1938 audio_stream_in_frame_size((const struct audio_stream_in *)stream);
1939 }
1940
in_get_channels(const struct audio_stream * stream)1941 static uint32_t in_get_channels(const struct audio_stream *stream)
1942 {
1943 struct stream_in *in = (struct stream_in *)stream;
1944
1945 return in->channel_mask;
1946 }
1947
in_get_format(const struct audio_stream * stream)1948 static audio_format_t in_get_format(const struct audio_stream *stream)
1949 {
1950 struct stream_in *in = (struct stream_in *)stream;
1951 return in->format;
1952 }
1953
in_set_format(struct audio_stream * stream __unused,audio_format_t format __unused)1954 static int in_set_format(struct audio_stream *stream __unused, audio_format_t format __unused)
1955 {
1956 return -ENOSYS;
1957 }
1958
in_standby(struct audio_stream * stream)1959 static int in_standby(struct audio_stream *stream)
1960 {
1961 struct stream_in *in = (struct stream_in *)stream;
1962 struct audio_device *adev = in->dev;
1963 int status = 0;
1964 ALOGV("%s: enter", __func__);
1965
1966 lock_input_stream(in);
1967
1968 if (!in->standby && in->is_st_session) {
1969 ALOGV("%s: sound trigger pcm stop lab", __func__);
1970 audio_extn_sound_trigger_stop_lab(in);
1971 in->standby = true;
1972 }
1973
1974 if (!in->standby) {
1975 if (adev->adm_deregister_stream)
1976 adev->adm_deregister_stream(adev->adm_data, in->capture_handle);
1977
1978 pthread_mutex_lock(&adev->lock);
1979 in->standby = true;
1980 if (in->pcm) {
1981 pcm_close(in->pcm);
1982 in->pcm = NULL;
1983 }
1984 adev->enable_voicerx = false;
1985 platform_set_echo_reference(adev, false, AUDIO_DEVICE_NONE );
1986 status = stop_input_stream(in);
1987 pthread_mutex_unlock(&adev->lock);
1988 }
1989 pthread_mutex_unlock(&in->lock);
1990 ALOGV("%s: exit: status(%d)", __func__, status);
1991 return status;
1992 }
1993
in_dump(const struct audio_stream * stream __unused,int fd __unused)1994 static int in_dump(const struct audio_stream *stream __unused, int fd __unused)
1995 {
1996 return 0;
1997 }
1998
in_set_parameters(struct audio_stream * stream,const char * kvpairs)1999 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
2000 {
2001 struct stream_in *in = (struct stream_in *)stream;
2002 struct audio_device *adev = in->dev;
2003 struct str_parms *parms;
2004 char *str;
2005 char value[32];
2006 int ret, val = 0;
2007 int status = 0;
2008
2009 ALOGV("%s: enter: kvpairs=%s", __func__, kvpairs);
2010 parms = str_parms_create_str(kvpairs);
2011
2012 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
2013
2014 lock_input_stream(in);
2015
2016 pthread_mutex_lock(&adev->lock);
2017 if (ret >= 0) {
2018 val = atoi(value);
2019 /* no audio source uses val == 0 */
2020 if ((in->source != val) && (val != 0)) {
2021 in->source = val;
2022 }
2023 }
2024
2025 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
2026
2027 if (ret >= 0) {
2028 val = atoi(value);
2029 if (((int)in->device != val) && (val != 0)) {
2030 in->device = val;
2031 /* If recording is in progress, change the tx device to new device */
2032 if (!in->standby)
2033 status = select_devices(adev, in->usecase);
2034 }
2035 }
2036
2037 pthread_mutex_unlock(&adev->lock);
2038 pthread_mutex_unlock(&in->lock);
2039
2040 str_parms_destroy(parms);
2041 ALOGV("%s: exit: status(%d)", __func__, status);
2042 return status;
2043 }
2044
in_get_parameters(const struct audio_stream * stream __unused,const char * keys __unused)2045 static char* in_get_parameters(const struct audio_stream *stream __unused,
2046 const char *keys __unused)
2047 {
2048 return strdup("");
2049 }
2050
in_set_gain(struct audio_stream_in * stream __unused,float gain __unused)2051 static int in_set_gain(struct audio_stream_in *stream __unused, float gain __unused)
2052 {
2053 return 0;
2054 }
2055
in_read(struct audio_stream_in * stream,void * buffer,size_t bytes)2056 static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
2057 size_t bytes)
2058 {
2059 struct stream_in *in = (struct stream_in *)stream;
2060 struct audio_device *adev = in->dev;
2061 int i, ret = -1;
2062 int *int_buf_stream = NULL;
2063
2064 lock_input_stream(in);
2065
2066 if (in->is_st_session) {
2067 ALOGVV(" %s: reading on st session bytes=%d", __func__, bytes);
2068 /* Read from sound trigger HAL */
2069 audio_extn_sound_trigger_read(in, buffer, bytes);
2070 pthread_mutex_unlock(&in->lock);
2071 return bytes;
2072 }
2073
2074 if (in->standby) {
2075 pthread_mutex_lock(&adev->lock);
2076 ret = start_input_stream(in);
2077 pthread_mutex_unlock(&adev->lock);
2078 if (ret != 0) {
2079 goto exit;
2080 }
2081 in->standby = 0;
2082 if (adev->adm_register_input_stream)
2083 adev->adm_register_input_stream(adev->adm_data, in->capture_handle, in->flags);
2084 }
2085
2086 if (adev->adm_request_focus)
2087 adev->adm_request_focus(adev->adm_data, in->capture_handle);
2088
2089 if (in->pcm) {
2090 if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY) {
2091 ret = pcm_mmap_read(in->pcm, buffer, bytes);
2092 } else {
2093 ret = pcm_read(in->pcm, buffer, bytes);
2094 if (!ret && bytes > 0 && (in->format == AUDIO_FORMAT_PCM_8_24_BIT)) {
2095 if (bytes % 4 == 0) {
2096 /* data from DSP comes in 24_8 format, convert it to 8_24 */
2097 int_buf_stream = buffer;
2098 for (size_t itt=0; itt < bytes/4 ; itt++) {
2099 int_buf_stream[itt] >>= 8;
2100 }
2101 } else {
2102 ALOGE("%s: !!! something wrong !!! ... data not 32 bit aligned ", __func__);
2103 ret = -EINVAL;
2104 goto exit;
2105 }
2106 }
2107 }
2108 }
2109
2110 if (adev->adm_abandon_focus)
2111 adev->adm_abandon_focus(adev->adm_data, in->capture_handle);
2112
2113 /*
2114 * Instead of writing zeroes here, we could trust the hardware
2115 * to always provide zeroes when muted.
2116 * No need to acquire adev->lock to read mic_muted here as we don't change its state.
2117 */
2118 if (ret == 0 && adev->mic_muted && in->usecase != USECASE_AUDIO_RECORD_AFE_PROXY)
2119 memset(buffer, 0, bytes);
2120
2121 exit:
2122 pthread_mutex_unlock(&in->lock);
2123
2124 if (ret != 0) {
2125 in_standby(&in->stream.common);
2126 ALOGV("%s: read failed - sleeping for buffer duration", __func__);
2127 usleep(bytes * 1000000 / audio_stream_in_frame_size(stream) /
2128 in_get_sample_rate(&in->stream.common));
2129 memset(buffer, 0, bytes); // clear return data
2130 }
2131 if (bytes > 0) {
2132 in->frames_read += bytes / audio_stream_in_frame_size(stream);
2133 }
2134 return bytes;
2135 }
2136
in_get_input_frames_lost(struct audio_stream_in * stream __unused)2137 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream __unused)
2138 {
2139 return 0;
2140 }
2141
in_get_capture_position(const struct audio_stream_in * stream,int64_t * frames,int64_t * time)2142 static int in_get_capture_position(const struct audio_stream_in *stream,
2143 int64_t *frames, int64_t *time)
2144 {
2145 if (stream == NULL || frames == NULL || time == NULL) {
2146 return -EINVAL;
2147 }
2148 struct stream_in *in = (struct stream_in *)stream;
2149 int ret = -ENOSYS;
2150
2151 lock_input_stream(in);
2152 if (in->pcm) {
2153 struct timespec timestamp;
2154 unsigned int avail;
2155 if (pcm_get_htimestamp(in->pcm, &avail, ×tamp) == 0) {
2156 *frames = in->frames_read + avail;
2157 *time = timestamp.tv_sec * 1000000000LL + timestamp.tv_nsec;
2158 ret = 0;
2159 }
2160 }
2161 pthread_mutex_unlock(&in->lock);
2162 return ret;
2163 }
2164
add_remove_audio_effect(const struct audio_stream * stream,effect_handle_t effect,bool enable)2165 static int add_remove_audio_effect(const struct audio_stream *stream,
2166 effect_handle_t effect,
2167 bool enable)
2168 {
2169 struct stream_in *in = (struct stream_in *)stream;
2170 struct audio_device *adev = in->dev;
2171 int status = 0;
2172 effect_descriptor_t desc;
2173
2174 status = (*effect)->get_descriptor(effect, &desc);
2175 if (status != 0)
2176 return status;
2177
2178 lock_input_stream(in);
2179 pthread_mutex_lock(&in->dev->lock);
2180 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
2181 in->source == AUDIO_SOURCE_VOICE_RECOGNITION ||
2182 adev->mode == AUDIO_MODE_IN_COMMUNICATION) &&
2183 in->enable_aec != enable &&
2184 (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) {
2185 in->enable_aec = enable;
2186 if (!enable)
2187 platform_set_echo_reference(in->dev, enable, AUDIO_DEVICE_NONE);
2188 if (in->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
2189 adev->mode == AUDIO_MODE_IN_COMMUNICATION) {
2190 adev->enable_voicerx = enable;
2191 struct audio_usecase *usecase;
2192 struct listnode *node;
2193 list_for_each(node, &adev->usecase_list) {
2194 usecase = node_to_item(node, struct audio_usecase, list);
2195 if (usecase->type == PCM_PLAYBACK) {
2196 select_devices(adev, usecase->id);
2197 break;
2198 }
2199 }
2200 }
2201 if (!in->standby)
2202 select_devices(in->dev, in->usecase);
2203 }
2204 if (in->enable_ns != enable &&
2205 (memcmp(&desc.type, FX_IID_NS, sizeof(effect_uuid_t)) == 0)) {
2206 in->enable_ns = enable;
2207 if (!in->standby)
2208 select_devices(in->dev, in->usecase);
2209 }
2210 pthread_mutex_unlock(&in->dev->lock);
2211 pthread_mutex_unlock(&in->lock);
2212
2213 return 0;
2214 }
2215
in_add_audio_effect(const struct audio_stream * stream,effect_handle_t effect)2216 static int in_add_audio_effect(const struct audio_stream *stream,
2217 effect_handle_t effect)
2218 {
2219 ALOGV("%s: effect %p", __func__, effect);
2220 return add_remove_audio_effect(stream, effect, true);
2221 }
2222
in_remove_audio_effect(const struct audio_stream * stream,effect_handle_t effect)2223 static int in_remove_audio_effect(const struct audio_stream *stream,
2224 effect_handle_t effect)
2225 {
2226 ALOGV("%s: effect %p", __func__, effect);
2227 return add_remove_audio_effect(stream, effect, false);
2228 }
2229
adev_open_output_stream(struct audio_hw_device * dev,audio_io_handle_t handle,audio_devices_t devices,audio_output_flags_t flags,struct audio_config * config,struct audio_stream_out ** stream_out,const char * address __unused)2230 static int adev_open_output_stream(struct audio_hw_device *dev,
2231 audio_io_handle_t handle,
2232 audio_devices_t devices,
2233 audio_output_flags_t flags,
2234 struct audio_config *config,
2235 struct audio_stream_out **stream_out,
2236 const char *address __unused)
2237 {
2238 struct audio_device *adev = (struct audio_device *)dev;
2239 struct stream_out *out;
2240 int i, ret;
2241
2242 ALOGV("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)",
2243 __func__, config->sample_rate, config->channel_mask, devices, flags);
2244 *stream_out = NULL;
2245 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
2246
2247 if (devices == AUDIO_DEVICE_NONE)
2248 devices = AUDIO_DEVICE_OUT_SPEAKER;
2249
2250 out->flags = flags;
2251 out->devices = devices;
2252 out->dev = adev;
2253 out->format = config->format;
2254 out->sample_rate = config->sample_rate;
2255 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2256 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
2257 out->handle = handle;
2258
2259 /* Init use case and pcm_config */
2260 if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
2261 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
2262 out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
2263 pthread_mutex_lock(&adev->lock);
2264 ret = read_hdmi_channel_masks(out);
2265 pthread_mutex_unlock(&adev->lock);
2266 if (ret != 0)
2267 goto error_open;
2268
2269 if (config->sample_rate == 0)
2270 config->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
2271 if (config->channel_mask == 0)
2272 config->channel_mask = AUDIO_CHANNEL_OUT_5POINT1;
2273 if (config->format == AUDIO_FORMAT_DEFAULT)
2274 config->format = AUDIO_FORMAT_PCM_16_BIT;
2275
2276 out->channel_mask = config->channel_mask;
2277 out->sample_rate = config->sample_rate;
2278 out->format = config->format;
2279 out->usecase = USECASE_AUDIO_PLAYBACK_MULTI_CH;
2280 out->config = pcm_config_hdmi_multi;
2281 out->config.rate = config->sample_rate;
2282 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
2283 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels * 2);
2284 } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
2285 if (config->offload_info.version != AUDIO_INFO_INITIALIZER.version ||
2286 config->offload_info.size != AUDIO_INFO_INITIALIZER.size) {
2287 ALOGE("%s: Unsupported Offload information", __func__);
2288 ret = -EINVAL;
2289 goto error_open;
2290 }
2291 if (!is_supported_format(config->offload_info.format)) {
2292 ALOGE("%s: Unsupported audio format", __func__);
2293 ret = -EINVAL;
2294 goto error_open;
2295 }
2296
2297 out->compr_config.codec = (struct snd_codec *)
2298 calloc(1, sizeof(struct snd_codec));
2299
2300 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
2301 if (config->offload_info.channel_mask)
2302 out->channel_mask = config->offload_info.channel_mask;
2303 else if (config->channel_mask)
2304 out->channel_mask = config->channel_mask;
2305 out->format = config->offload_info.format;
2306 out->sample_rate = config->offload_info.sample_rate;
2307
2308 out->stream.set_callback = out_set_callback;
2309 out->stream.pause = out_pause;
2310 out->stream.resume = out_resume;
2311 out->stream.drain = out_drain;
2312 out->stream.flush = out_flush;
2313
2314 out->compr_config.codec->id =
2315 get_snd_codec_id(config->offload_info.format);
2316 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
2317 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
2318 out->compr_config.codec->sample_rate = config->offload_info.sample_rate;
2319 out->compr_config.codec->bit_rate =
2320 config->offload_info.bit_rate;
2321 out->compr_config.codec->ch_in =
2322 audio_channel_count_from_out_mask(config->channel_mask);
2323 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
2324
2325 if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING)
2326 out->non_blocking = 1;
2327
2328 out->send_new_metadata = 1;
2329 create_offload_callback_thread(out);
2330 ALOGV("%s: offloaded output offload_info version %04x bit rate %d",
2331 __func__, config->offload_info.version,
2332 config->offload_info.bit_rate);
2333 } else if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) {
2334 if (config->sample_rate == 0)
2335 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
2336 if (config->sample_rate != 48000 && config->sample_rate != 16000 &&
2337 config->sample_rate != 8000) {
2338 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
2339 ret = -EINVAL;
2340 goto error_open;
2341 }
2342 out->sample_rate = config->sample_rate;
2343 out->config.rate = config->sample_rate;
2344 if (config->format == AUDIO_FORMAT_DEFAULT)
2345 config->format = AUDIO_FORMAT_PCM_16_BIT;
2346 if (config->format != AUDIO_FORMAT_PCM_16_BIT) {
2347 config->format = AUDIO_FORMAT_PCM_16_BIT;
2348 ret = -EINVAL;
2349 goto error_open;
2350 }
2351 out->format = config->format;
2352 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
2353 out->config = pcm_config_afe_proxy_playback;
2354 adev->voice_tx_output = out;
2355 } else {
2356 if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
2357 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
2358 out->config = pcm_config_deep_buffer;
2359 } else if (out->flags & AUDIO_OUTPUT_FLAG_TTS) {
2360 out->usecase = USECASE_AUDIO_PLAYBACK_TTS;
2361 out->config = pcm_config_deep_buffer;
2362 } else if (out->flags & AUDIO_OUTPUT_FLAG_RAW) {
2363 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
2364 out->config = pcm_config_low_latency;
2365 } else {
2366 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
2367 out->config = pcm_config_low_latency;
2368 }
2369 if (config->format != audio_format_from_pcm_format(out->config.format)) {
2370 if (k_enable_extended_precision
2371 && pcm_params_format_test(adev->use_case_table[out->usecase],
2372 pcm_format_from_audio_format(config->format))) {
2373 out->config.format = pcm_format_from_audio_format(config->format);
2374 /* out->format already set to config->format */
2375 } else {
2376 /* deny the externally proposed config format
2377 * and use the one specified in audio_hw layer configuration.
2378 * Note: out->format is returned by out->stream.common.get_format()
2379 * and is used to set config->format in the code several lines below.
2380 */
2381 out->format = audio_format_from_pcm_format(out->config.format);
2382 }
2383 }
2384 out->sample_rate = out->config.rate;
2385 }
2386 ALOGV("%s: Usecase(%s) config->format %#x out->config.format %#x\n",
2387 __func__, use_case_table[out->usecase], config->format, out->config.format);
2388
2389 if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) {
2390 if (adev->primary_output == NULL)
2391 adev->primary_output = out;
2392 else {
2393 ALOGE("%s: Primary output is already opened", __func__);
2394 ret = -EEXIST;
2395 goto error_open;
2396 }
2397 }
2398
2399 /* Check if this usecase is already existing */
2400 pthread_mutex_lock(&adev->lock);
2401 if (get_usecase_from_list(adev, out->usecase) != NULL) {
2402 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
2403 pthread_mutex_unlock(&adev->lock);
2404 ret = -EEXIST;
2405 goto error_open;
2406 }
2407 pthread_mutex_unlock(&adev->lock);
2408
2409 out->stream.common.get_sample_rate = out_get_sample_rate;
2410 out->stream.common.set_sample_rate = out_set_sample_rate;
2411 out->stream.common.get_buffer_size = out_get_buffer_size;
2412 out->stream.common.get_channels = out_get_channels;
2413 out->stream.common.get_format = out_get_format;
2414 out->stream.common.set_format = out_set_format;
2415 out->stream.common.standby = out_standby;
2416 out->stream.common.dump = out_dump;
2417 out->stream.common.set_parameters = out_set_parameters;
2418 out->stream.common.get_parameters = out_get_parameters;
2419 out->stream.common.add_audio_effect = out_add_audio_effect;
2420 out->stream.common.remove_audio_effect = out_remove_audio_effect;
2421 out->stream.get_latency = out_get_latency;
2422 out->stream.set_volume = out_set_volume;
2423 #ifdef NO_AUDIO_OUT
2424 out->stream.write = out_write_for_no_output;
2425 #else
2426 out->stream.write = out_write;
2427 #endif
2428 out->stream.get_render_position = out_get_render_position;
2429 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
2430 out->stream.get_presentation_position = out_get_presentation_position;
2431
2432 out->standby = 1;
2433 /* out->muted = false; by calloc() */
2434 /* out->written = 0; by calloc() */
2435
2436 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
2437 pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL);
2438 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
2439
2440 config->format = out->stream.common.get_format(&out->stream.common);
2441 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
2442 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
2443
2444 *stream_out = &out->stream;
2445 ALOGV("%s: exit", __func__);
2446 return 0;
2447
2448 error_open:
2449 free(out);
2450 *stream_out = NULL;
2451 ALOGW("%s: exit: ret %d", __func__, ret);
2452 return ret;
2453 }
2454
adev_close_output_stream(struct audio_hw_device * dev __unused,struct audio_stream_out * stream)2455 static void adev_close_output_stream(struct audio_hw_device *dev __unused,
2456 struct audio_stream_out *stream)
2457 {
2458 struct stream_out *out = (struct stream_out *)stream;
2459 struct audio_device *adev = out->dev;
2460
2461 ALOGV("%s: enter", __func__);
2462 out_standby(&stream->common);
2463 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2464 destroy_offload_callback_thread(out);
2465
2466 if (out->compr_config.codec != NULL)
2467 free(out->compr_config.codec);
2468 }
2469
2470 if (adev->voice_tx_output == out)
2471 adev->voice_tx_output = NULL;
2472
2473 pthread_cond_destroy(&out->cond);
2474 pthread_mutex_destroy(&out->lock);
2475 free(stream);
2476 ALOGV("%s: exit", __func__);
2477 }
2478
adev_set_parameters(struct audio_hw_device * dev,const char * kvpairs)2479 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
2480 {
2481 struct audio_device *adev = (struct audio_device *)dev;
2482 struct str_parms *parms;
2483 char *str;
2484 char value[32];
2485 int val;
2486 int ret;
2487 int status = 0;
2488
2489 ALOGV("%s: enter: %s", __func__, kvpairs);
2490
2491 pthread_mutex_lock(&adev->lock);
2492
2493 parms = str_parms_create_str(kvpairs);
2494 status = voice_set_parameters(adev, parms);
2495 if (status != 0) {
2496 goto done;
2497 }
2498
2499 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
2500 if (ret >= 0) {
2501 /* When set to false, HAL should disable EC and NS */
2502 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
2503 adev->bluetooth_nrec = true;
2504 else
2505 adev->bluetooth_nrec = false;
2506 }
2507
2508 ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
2509 if (ret >= 0) {
2510 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
2511 adev->screen_off = false;
2512 else
2513 adev->screen_off = true;
2514 }
2515
2516 ret = str_parms_get_int(parms, "rotation", &val);
2517 if (ret >= 0) {
2518 bool reverse_speakers = false;
2519 switch(val) {
2520 // FIXME: note that the code below assumes that the speakers are in the correct placement
2521 // relative to the user when the device is rotated 90deg from its default rotation. This
2522 // assumption is device-specific, not platform-specific like this code.
2523 case 270:
2524 reverse_speakers = true;
2525 break;
2526 case 0:
2527 case 90:
2528 case 180:
2529 break;
2530 default:
2531 ALOGE("%s: unexpected rotation of %d", __func__, val);
2532 status = -EINVAL;
2533 }
2534 if (status == 0) {
2535 platform_swap_lr_channels(adev, reverse_speakers);
2536 }
2537 }
2538
2539 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_SCO_WB, value, sizeof(value));
2540 if (ret >= 0) {
2541 adev->bt_wb_speech_enabled = !strcmp(value, AUDIO_PARAMETER_VALUE_ON);
2542 }
2543
2544 audio_extn_hfp_set_parameters(adev, parms);
2545 done:
2546 str_parms_destroy(parms);
2547 pthread_mutex_unlock(&adev->lock);
2548 ALOGV("%s: exit with code(%d)", __func__, status);
2549 return status;
2550 }
2551
adev_get_parameters(const struct audio_hw_device * dev,const char * keys)2552 static char* adev_get_parameters(const struct audio_hw_device *dev,
2553 const char *keys)
2554 {
2555 struct audio_device *adev = (struct audio_device *)dev;
2556 struct str_parms *reply = str_parms_create();
2557 struct str_parms *query = str_parms_create_str(keys);
2558 char *str;
2559
2560 pthread_mutex_lock(&adev->lock);
2561
2562 voice_get_parameters(adev, query, reply);
2563 str = str_parms_to_str(reply);
2564 str_parms_destroy(query);
2565 str_parms_destroy(reply);
2566
2567 pthread_mutex_unlock(&adev->lock);
2568 ALOGV("%s: exit: returns - %s", __func__, str);
2569 return str;
2570 }
2571
adev_init_check(const struct audio_hw_device * dev __unused)2572 static int adev_init_check(const struct audio_hw_device *dev __unused)
2573 {
2574 return 0;
2575 }
2576
adev_set_voice_volume(struct audio_hw_device * dev,float volume)2577 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
2578 {
2579 int ret;
2580 struct audio_device *adev = (struct audio_device *)dev;
2581
2582 audio_extn_extspk_set_voice_vol(adev->extspk, volume);
2583
2584 pthread_mutex_lock(&adev->lock);
2585 ret = voice_set_volume(adev, volume);
2586 pthread_mutex_unlock(&adev->lock);
2587
2588 return ret;
2589 }
2590
adev_set_master_volume(struct audio_hw_device * dev __unused,float volume __unused)2591 static int adev_set_master_volume(struct audio_hw_device *dev __unused, float volume __unused)
2592 {
2593 return -ENOSYS;
2594 }
2595
adev_get_master_volume(struct audio_hw_device * dev __unused,float * volume __unused)2596 static int adev_get_master_volume(struct audio_hw_device *dev __unused,
2597 float *volume __unused)
2598 {
2599 return -ENOSYS;
2600 }
2601
adev_set_master_mute(struct audio_hw_device * dev __unused,bool muted __unused)2602 static int adev_set_master_mute(struct audio_hw_device *dev __unused, bool muted __unused)
2603 {
2604 return -ENOSYS;
2605 }
2606
adev_get_master_mute(struct audio_hw_device * dev __unused,bool * muted __unused)2607 static int adev_get_master_mute(struct audio_hw_device *dev __unused, bool *muted __unused)
2608 {
2609 return -ENOSYS;
2610 }
2611
adev_set_mode(struct audio_hw_device * dev,audio_mode_t mode)2612 static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
2613 {
2614 struct audio_device *adev = (struct audio_device *)dev;
2615
2616 pthread_mutex_lock(&adev->lock);
2617 if (adev->mode != mode) {
2618 ALOGD("%s: mode %d", __func__, (int)mode);
2619 adev->mode = mode;
2620 if ((mode == AUDIO_MODE_NORMAL || mode == AUDIO_MODE_IN_COMMUNICATION) &&
2621 voice_is_in_call(adev)) {
2622 voice_stop_call(adev);
2623 adev->current_call_output = NULL;
2624 }
2625 }
2626 pthread_mutex_unlock(&adev->lock);
2627
2628 audio_extn_extspk_set_mode(adev->extspk, mode);
2629
2630 return 0;
2631 }
2632
adev_set_mic_mute(struct audio_hw_device * dev,bool state)2633 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
2634 {
2635 int ret;
2636 struct audio_device *adev = (struct audio_device *)dev;
2637
2638 ALOGD("%s: state %d", __func__, (int)state);
2639 pthread_mutex_lock(&adev->lock);
2640 ret = voice_set_mic_mute(adev, state);
2641 adev->mic_muted = state;
2642 pthread_mutex_unlock(&adev->lock);
2643
2644 return ret;
2645 }
2646
adev_get_mic_mute(const struct audio_hw_device * dev,bool * state)2647 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
2648 {
2649 *state = voice_get_mic_mute((struct audio_device *)dev);
2650 return 0;
2651 }
2652
adev_get_input_buffer_size(const struct audio_hw_device * dev __unused,const struct audio_config * config)2653 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev __unused,
2654 const struct audio_config *config)
2655 {
2656 int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
2657
2658 return get_input_buffer_size(config->sample_rate, config->format, channel_count,
2659 false /* is_low_latency: since we don't know, be conservative */);
2660 }
2661
adev_open_input_stream(struct audio_hw_device * dev,audio_io_handle_t handle,audio_devices_t devices,struct audio_config * config,struct audio_stream_in ** stream_in,audio_input_flags_t flags,const char * address __unused,audio_source_t source)2662 static int adev_open_input_stream(struct audio_hw_device *dev,
2663 audio_io_handle_t handle,
2664 audio_devices_t devices,
2665 struct audio_config *config,
2666 struct audio_stream_in **stream_in,
2667 audio_input_flags_t flags,
2668 const char *address __unused,
2669 audio_source_t source )
2670 {
2671 struct audio_device *adev = (struct audio_device *)dev;
2672 struct stream_in *in;
2673 int ret = 0, buffer_size, frame_size;
2674 int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
2675 bool is_low_latency = false;
2676
2677 ALOGV("%s: enter", __func__);
2678 *stream_in = NULL;
2679 if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0)
2680 return -EINVAL;
2681
2682 in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
2683
2684 pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL);
2685 pthread_mutex_init(&in->pre_lock, (const pthread_mutexattr_t *) NULL);
2686
2687 in->stream.common.get_sample_rate = in_get_sample_rate;
2688 in->stream.common.set_sample_rate = in_set_sample_rate;
2689 in->stream.common.get_buffer_size = in_get_buffer_size;
2690 in->stream.common.get_channels = in_get_channels;
2691 in->stream.common.get_format = in_get_format;
2692 in->stream.common.set_format = in_set_format;
2693 in->stream.common.standby = in_standby;
2694 in->stream.common.dump = in_dump;
2695 in->stream.common.set_parameters = in_set_parameters;
2696 in->stream.common.get_parameters = in_get_parameters;
2697 in->stream.common.add_audio_effect = in_add_audio_effect;
2698 in->stream.common.remove_audio_effect = in_remove_audio_effect;
2699 in->stream.set_gain = in_set_gain;
2700 in->stream.read = in_read;
2701 in->stream.get_input_frames_lost = in_get_input_frames_lost;
2702 in->stream.get_capture_position = in_get_capture_position;
2703
2704 in->device = devices;
2705 in->source = source;
2706 in->dev = adev;
2707 in->standby = 1;
2708 in->channel_mask = config->channel_mask;
2709 in->capture_handle = handle;
2710 in->flags = flags;
2711
2712 // restrict 24 bit capture for unprocessed source only
2713 // for other sources if 24 bit requested reject 24 and set 16 bit capture only
2714 if (config->format == AUDIO_FORMAT_DEFAULT) {
2715 config->format = AUDIO_FORMAT_PCM_16_BIT;
2716 } else if (config->format == AUDIO_FORMAT_PCM_FLOAT ||
2717 config->format == AUDIO_FORMAT_PCM_24_BIT_PACKED ||
2718 config->format == AUDIO_FORMAT_PCM_8_24_BIT) {
2719 bool ret_error = false;
2720 /* 24 bit is restricted to UNPROCESSED source only,also format supported
2721 from HAL is 8_24
2722 *> In case of UNPROCESSED source, for 24 bit, if format requested is other than
2723 8_24 return error indicating supported format is 8_24
2724 *> In case of any other source requesting 24 bit or float return error
2725 indicating format supported is 16 bit only.
2726
2727 on error flinger will retry with supported format passed
2728 */
2729 if (source != AUDIO_SOURCE_UNPROCESSED) {
2730 config->format = AUDIO_FORMAT_PCM_16_BIT;
2731 ret_error = true;
2732 } else if (config->format != AUDIO_FORMAT_PCM_8_24_BIT) {
2733 config->format = AUDIO_FORMAT_PCM_8_24_BIT;
2734 ret_error = true;
2735 }
2736
2737 if (ret_error) {
2738 ret = -EINVAL;
2739 goto err_open;
2740 }
2741 }
2742
2743 in->format = config->format;
2744
2745 /* Update config params with the requested sample rate and channels */
2746 if (in->device == AUDIO_DEVICE_IN_TELEPHONY_RX) {
2747 if (config->sample_rate == 0)
2748 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
2749 if (config->sample_rate != 48000 && config->sample_rate != 16000 &&
2750 config->sample_rate != 8000) {
2751 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
2752 ret = -EINVAL;
2753 goto err_open;
2754 }
2755
2756 if (config->format != AUDIO_FORMAT_PCM_16_BIT) {
2757 config->format = AUDIO_FORMAT_PCM_16_BIT;
2758 ret = -EINVAL;
2759 goto err_open;
2760 }
2761
2762 in->usecase = USECASE_AUDIO_RECORD_AFE_PROXY;
2763 in->config = pcm_config_afe_proxy_record;
2764 } else {
2765 in->usecase = USECASE_AUDIO_RECORD;
2766 if (config->sample_rate == LOW_LATENCY_CAPTURE_SAMPLE_RATE &&
2767 (flags & AUDIO_INPUT_FLAG_FAST) != 0) {
2768 is_low_latency = true;
2769 #if LOW_LATENCY_CAPTURE_USE_CASE
2770 in->usecase = USECASE_AUDIO_RECORD_LOW_LATENCY;
2771 #endif
2772 }
2773 in->config = pcm_config_audio_capture;
2774
2775 if (config->format == AUDIO_FORMAT_PCM_8_24_BIT)
2776 in->config.format = PCM_FORMAT_S24_LE;
2777
2778 frame_size = audio_stream_in_frame_size(&in->stream);
2779 buffer_size = get_input_buffer_size(config->sample_rate,
2780 config->format,
2781 channel_count,
2782 is_low_latency);
2783 in->config.period_size = buffer_size / frame_size;
2784 }
2785 in->config.channels = channel_count;
2786 in->config.rate = config->sample_rate;
2787
2788 /* This stream could be for sound trigger lab,
2789 get sound trigger pcm if present */
2790 audio_extn_sound_trigger_check_and_get_session(in);
2791
2792 *stream_in = &in->stream;
2793 ALOGV("%s: exit", __func__);
2794 return 0;
2795
2796 err_open:
2797 free(in);
2798 *stream_in = NULL;
2799 return ret;
2800 }
2801
adev_close_input_stream(struct audio_hw_device * dev __unused,struct audio_stream_in * stream)2802 static void adev_close_input_stream(struct audio_hw_device *dev __unused,
2803 struct audio_stream_in *stream)
2804 {
2805 ALOGV("%s", __func__);
2806
2807 in_standby(&stream->common);
2808 free(stream);
2809
2810 return;
2811 }
2812
adev_dump(const audio_hw_device_t * device __unused,int fd __unused)2813 static int adev_dump(const audio_hw_device_t *device __unused, int fd __unused)
2814 {
2815 return 0;
2816 }
2817
2818 /* verifies input and output devices and their capabilities.
2819 *
2820 * This verification is required when enabling extended bit-depth or
2821 * sampling rates, as not all qcom products support it.
2822 *
2823 * Suitable for calling only on initialization such as adev_open().
2824 * It fills the audio_device use_case_table[] array.
2825 *
2826 * Has a side-effect that it needs to configure audio routing / devices
2827 * in order to power up the devices and read the device parameters.
2828 * It does not acquire any hw device lock. Should restore the devices
2829 * back to "normal state" upon completion.
2830 */
adev_verify_devices(struct audio_device * adev)2831 static int adev_verify_devices(struct audio_device *adev)
2832 {
2833 /* enumeration is a bit difficult because one really wants to pull
2834 * the use_case, device id, etc from the hidden pcm_device_table[].
2835 * In this case there are the following use cases and device ids.
2836 *
2837 * [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {0, 0},
2838 * [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {15, 15},
2839 * [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {1, 1},
2840 * [USECASE_AUDIO_PLAYBACK_OFFLOAD] = {9, 9},
2841 * [USECASE_AUDIO_RECORD] = {0, 0},
2842 * [USECASE_AUDIO_RECORD_LOW_LATENCY] = {15, 15},
2843 * [USECASE_VOICE_CALL] = {2, 2},
2844 *
2845 * USECASE_AUDIO_PLAYBACK_OFFLOAD, USECASE_AUDIO_PLAYBACK_MULTI_CH omitted.
2846 * USECASE_VOICE_CALL omitted, but possible for either input or output.
2847 */
2848
2849 /* should be the usecases enabled in adev_open_input_stream() */
2850 static const int test_in_usecases[] = {
2851 USECASE_AUDIO_RECORD,
2852 USECASE_AUDIO_RECORD_LOW_LATENCY, /* does not appear to be used */
2853 };
2854 /* should be the usecases enabled in adev_open_output_stream()*/
2855 static const int test_out_usecases[] = {
2856 USECASE_AUDIO_PLAYBACK_DEEP_BUFFER,
2857 USECASE_AUDIO_PLAYBACK_LOW_LATENCY,
2858 };
2859 static const usecase_type_t usecase_type_by_dir[] = {
2860 PCM_PLAYBACK,
2861 PCM_CAPTURE,
2862 };
2863 static const unsigned flags_by_dir[] = {
2864 PCM_OUT,
2865 PCM_IN,
2866 };
2867
2868 size_t i;
2869 unsigned dir;
2870 const unsigned card_id = adev->snd_card;
2871 char info[512]; /* for possible debug info */
2872
2873 for (dir = 0; dir < 2; ++dir) {
2874 const usecase_type_t usecase_type = usecase_type_by_dir[dir];
2875 const unsigned flags_dir = flags_by_dir[dir];
2876 const size_t testsize =
2877 dir ? ARRAY_SIZE(test_in_usecases) : ARRAY_SIZE(test_out_usecases);
2878 const int *testcases =
2879 dir ? test_in_usecases : test_out_usecases;
2880 const audio_devices_t audio_device =
2881 dir ? AUDIO_DEVICE_IN_BUILTIN_MIC : AUDIO_DEVICE_OUT_SPEAKER;
2882
2883 for (i = 0; i < testsize; ++i) {
2884 const audio_usecase_t audio_usecase = testcases[i];
2885 int device_id;
2886 snd_device_t snd_device;
2887 struct pcm_params **pparams;
2888 struct stream_out out;
2889 struct stream_in in;
2890 struct audio_usecase uc_info;
2891 int retval;
2892
2893 pparams = &adev->use_case_table[audio_usecase];
2894 pcm_params_free(*pparams); /* can accept null input */
2895 *pparams = NULL;
2896
2897 /* find the device ID for the use case (signed, for error) */
2898 device_id = platform_get_pcm_device_id(audio_usecase, usecase_type);
2899 if (device_id < 0)
2900 continue;
2901
2902 /* prepare structures for device probing */
2903 memset(&uc_info, 0, sizeof(uc_info));
2904 uc_info.id = audio_usecase;
2905 uc_info.type = usecase_type;
2906 if (dir) {
2907 adev->active_input = ∈
2908 memset(&in, 0, sizeof(in));
2909 in.device = audio_device;
2910 in.source = AUDIO_SOURCE_VOICE_COMMUNICATION;
2911 uc_info.stream.in = ∈
2912 } else {
2913 adev->active_input = NULL;
2914 }
2915 memset(&out, 0, sizeof(out));
2916 out.devices = audio_device; /* only field needed in select_devices */
2917 uc_info.stream.out = &out;
2918 uc_info.devices = audio_device;
2919 uc_info.in_snd_device = SND_DEVICE_NONE;
2920 uc_info.out_snd_device = SND_DEVICE_NONE;
2921 list_add_tail(&adev->usecase_list, &uc_info.list);
2922
2923 /* select device - similar to start_(in/out)put_stream() */
2924 retval = select_devices(adev, audio_usecase);
2925 if (retval >= 0) {
2926 *pparams = pcm_params_get(card_id, device_id, flags_dir);
2927 #if LOG_NDEBUG == 0
2928 if (*pparams) {
2929 ALOGV("%s: (%s) card %d device %d", __func__,
2930 dir ? "input" : "output", card_id, device_id);
2931 pcm_params_to_string(*pparams, info, ARRAY_SIZE(info));
2932 } else {
2933 ALOGV("%s: cannot locate card %d device %d", __func__, card_id, device_id);
2934 }
2935 #endif
2936 }
2937
2938 /* deselect device - similar to stop_(in/out)put_stream() */
2939 /* 1. Get and set stream specific mixer controls */
2940 retval = disable_audio_route(adev, &uc_info);
2941 /* 2. Disable the rx device */
2942 retval = disable_snd_device(adev,
2943 dir ? uc_info.in_snd_device : uc_info.out_snd_device);
2944 list_remove(&uc_info.list);
2945 }
2946 }
2947 adev->active_input = NULL; /* restore adev state */
2948 return 0;
2949 }
2950
adev_close(hw_device_t * device)2951 static int adev_close(hw_device_t *device)
2952 {
2953 size_t i;
2954 struct audio_device *adev = (struct audio_device *)device;
2955
2956 if (!adev)
2957 return 0;
2958
2959 pthread_mutex_lock(&adev_init_lock);
2960
2961 if ((--audio_device_ref_count) == 0) {
2962 audio_route_free(adev->audio_route);
2963 free(adev->snd_dev_ref_cnt);
2964 platform_deinit(adev->platform);
2965 audio_extn_extspk_deinit(adev->extspk);
2966 audio_extn_sound_trigger_deinit(adev);
2967 for (i = 0; i < ARRAY_SIZE(adev->use_case_table); ++i) {
2968 pcm_params_free(adev->use_case_table[i]);
2969 }
2970 if (adev->adm_deinit)
2971 adev->adm_deinit(adev->adm_data);
2972 free(device);
2973 }
2974
2975 pthread_mutex_unlock(&adev_init_lock);
2976
2977 return 0;
2978 }
2979
2980 /* This returns 1 if the input parameter looks at all plausible as a low latency period size,
2981 * or 0 otherwise. A return value of 1 doesn't mean the value is guaranteed to work,
2982 * just that it _might_ work.
2983 */
period_size_is_plausible_for_low_latency(int period_size)2984 static int period_size_is_plausible_for_low_latency(int period_size)
2985 {
2986 switch (period_size) {
2987 case 48:
2988 case 96:
2989 case 144:
2990 case 160:
2991 case 192:
2992 case 240:
2993 case 320:
2994 case 480:
2995 return 1;
2996 default:
2997 return 0;
2998 }
2999 }
3000
adev_open(const hw_module_t * module,const char * name,hw_device_t ** device)3001 static int adev_open(const hw_module_t *module, const char *name,
3002 hw_device_t **device)
3003 {
3004 int i, ret;
3005
3006 ALOGD("%s: enter", __func__);
3007 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL;
3008 pthread_mutex_lock(&adev_init_lock);
3009 if (audio_device_ref_count != 0) {
3010 *device = &adev->device.common;
3011 audio_device_ref_count++;
3012 ALOGV("%s: returning existing instance of adev", __func__);
3013 ALOGV("%s: exit", __func__);
3014 pthread_mutex_unlock(&adev_init_lock);
3015 return 0;
3016 }
3017 adev = calloc(1, sizeof(struct audio_device));
3018
3019 pthread_mutex_init(&adev->lock, (const pthread_mutexattr_t *) NULL);
3020
3021 adev->device.common.tag = HARDWARE_DEVICE_TAG;
3022 adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
3023 adev->device.common.module = (struct hw_module_t *)module;
3024 adev->device.common.close = adev_close;
3025
3026 adev->device.init_check = adev_init_check;
3027 adev->device.set_voice_volume = adev_set_voice_volume;
3028 adev->device.set_master_volume = adev_set_master_volume;
3029 adev->device.get_master_volume = adev_get_master_volume;
3030 adev->device.set_master_mute = adev_set_master_mute;
3031 adev->device.get_master_mute = adev_get_master_mute;
3032 adev->device.set_mode = adev_set_mode;
3033 adev->device.set_mic_mute = adev_set_mic_mute;
3034 adev->device.get_mic_mute = adev_get_mic_mute;
3035 adev->device.set_parameters = adev_set_parameters;
3036 adev->device.get_parameters = adev_get_parameters;
3037 adev->device.get_input_buffer_size = adev_get_input_buffer_size;
3038 adev->device.open_output_stream = adev_open_output_stream;
3039 adev->device.close_output_stream = adev_close_output_stream;
3040 adev->device.open_input_stream = adev_open_input_stream;
3041 adev->device.close_input_stream = adev_close_input_stream;
3042 adev->device.dump = adev_dump;
3043
3044 /* Set the default route before the PCM stream is opened */
3045 pthread_mutex_lock(&adev->lock);
3046 adev->mode = AUDIO_MODE_NORMAL;
3047 adev->active_input = NULL;
3048 adev->primary_output = NULL;
3049 adev->bluetooth_nrec = true;
3050 adev->acdb_settings = TTY_MODE_OFF;
3051 /* adev->cur_hdmi_channels = 0; by calloc() */
3052 adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int));
3053 voice_init(adev);
3054 list_init(&adev->usecase_list);
3055 pthread_mutex_unlock(&adev->lock);
3056
3057 /* Loads platform specific libraries dynamically */
3058 adev->platform = platform_init(adev);
3059 if (!adev->platform) {
3060 free(adev->snd_dev_ref_cnt);
3061 free(adev);
3062 ALOGE("%s: Failed to init platform data, aborting.", __func__);
3063 *device = NULL;
3064 pthread_mutex_unlock(&adev_init_lock);
3065 return -EINVAL;
3066 }
3067
3068 adev->extspk = audio_extn_extspk_init(adev);
3069 audio_extn_sound_trigger_init(adev);
3070
3071 adev->visualizer_lib = dlopen(VISUALIZER_LIBRARY_PATH, RTLD_NOW);
3072 if (adev->visualizer_lib == NULL) {
3073 ALOGW("%s: DLOPEN failed for %s", __func__, VISUALIZER_LIBRARY_PATH);
3074 } else {
3075 ALOGV("%s: DLOPEN successful for %s", __func__, VISUALIZER_LIBRARY_PATH);
3076 adev->visualizer_start_output =
3077 (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib,
3078 "visualizer_hal_start_output");
3079 adev->visualizer_stop_output =
3080 (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib,
3081 "visualizer_hal_stop_output");
3082 }
3083
3084 adev->offload_effects_lib = dlopen(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, RTLD_NOW);
3085 if (adev->offload_effects_lib == NULL) {
3086 ALOGW("%s: DLOPEN failed for %s", __func__,
3087 OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH);
3088 } else {
3089 ALOGV("%s: DLOPEN successful for %s", __func__,
3090 OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH);
3091 adev->offload_effects_start_output =
3092 (int (*)(audio_io_handle_t, int))dlsym(adev->offload_effects_lib,
3093 "offload_effects_bundle_hal_start_output");
3094 adev->offload_effects_stop_output =
3095 (int (*)(audio_io_handle_t, int))dlsym(adev->offload_effects_lib,
3096 "offload_effects_bundle_hal_stop_output");
3097 }
3098
3099 adev->adm_lib = dlopen(ADM_LIBRARY_PATH, RTLD_NOW);
3100 if (adev->adm_lib == NULL) {
3101 ALOGW("%s: DLOPEN failed for %s", __func__, ADM_LIBRARY_PATH);
3102 } else {
3103 ALOGV("%s: DLOPEN successful for %s", __func__, ADM_LIBRARY_PATH);
3104 adev->adm_init = (adm_init_t)
3105 dlsym(adev->adm_lib, "adm_init");
3106 adev->adm_deinit = (adm_deinit_t)
3107 dlsym(adev->adm_lib, "adm_deinit");
3108 adev->adm_register_input_stream = (adm_register_input_stream_t)
3109 dlsym(adev->adm_lib, "adm_register_input_stream");
3110 adev->adm_register_output_stream = (adm_register_output_stream_t)
3111 dlsym(adev->adm_lib, "adm_register_output_stream");
3112 adev->adm_deregister_stream = (adm_deregister_stream_t)
3113 dlsym(adev->adm_lib, "adm_deregister_stream");
3114 adev->adm_request_focus = (adm_request_focus_t)
3115 dlsym(adev->adm_lib, "adm_request_focus");
3116 adev->adm_abandon_focus = (adm_abandon_focus_t)
3117 dlsym(adev->adm_lib, "adm_abandon_focus");
3118 }
3119
3120 adev->bt_wb_speech_enabled = false;
3121 adev->enable_voicerx = false;
3122
3123 *device = &adev->device.common;
3124
3125 if (k_enable_extended_precision)
3126 adev_verify_devices(adev);
3127
3128 char value[PROPERTY_VALUE_MAX];
3129 int trial;
3130 if (property_get("audio_hal.period_size", value, NULL) > 0) {
3131 trial = atoi(value);
3132 if (period_size_is_plausible_for_low_latency(trial)) {
3133 pcm_config_low_latency.period_size = trial;
3134 pcm_config_low_latency.start_threshold = trial / 4;
3135 pcm_config_low_latency.avail_min = trial / 4;
3136 configured_low_latency_capture_period_size = trial;
3137 }
3138 }
3139 if (property_get("audio_hal.in_period_size", value, NULL) > 0) {
3140 trial = atoi(value);
3141 if (period_size_is_plausible_for_low_latency(trial)) {
3142 configured_low_latency_capture_period_size = trial;
3143 }
3144 }
3145
3146 audio_device_ref_count++;
3147 pthread_mutex_unlock(&adev_init_lock);
3148
3149 if (adev->adm_init)
3150 adev->adm_data = adev->adm_init();
3151
3152 audio_extn_perf_lock_init();
3153
3154 ALOGD("%s: exit", __func__);
3155 return 0;
3156 }
3157
3158 static struct hw_module_methods_t hal_module_methods = {
3159 .open = adev_open,
3160 };
3161
3162 struct audio_module HAL_MODULE_INFO_SYM = {
3163 .common = {
3164 .tag = HARDWARE_MODULE_TAG,
3165 .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
3166 .hal_api_version = HARDWARE_HAL_API_VERSION,
3167 .id = AUDIO_HARDWARE_MODULE_ID,
3168 .name = "QCOM Audio HAL",
3169 .author = "Code Aurora Forum",
3170 .methods = &hal_module_methods,
3171 },
3172 };
3173