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