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