1 /*
2 * Copyright (C) 2013 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 <system/thread_defs.h>
44 #include <audio_effects/effect_aec.h>
45 #include <audio_effects/effect_ns.h>
46 #include "audio_hw.h"
47
48 #include "sound/compress_params.h"
49
50 #define MIXER_CTL_COMPRESS_PLAYBACK_VOLUME "Compress Playback Volume"
51
52 /* TODO: the following PCM device profiles could be read from a config file */
53 struct pcm_device_profile pcm_device_playback_hs = {
54 .config = {
55 .channels = PLAYBACK_DEFAULT_CHANNEL_COUNT,
56 .rate = PLAYBACK_DEFAULT_SAMPLING_RATE,
57 .period_size = PLAYBACK_PERIOD_SIZE,
58 .period_count = PLAYBACK_PERIOD_COUNT,
59 .format = PCM_FORMAT_S16_LE,
60 .start_threshold = PLAYBACK_START_THRESHOLD,
61 .stop_threshold = PLAYBACK_STOP_THRESHOLD,
62 .silence_threshold = 0,
63 .avail_min = PLAYBACK_AVAILABLE_MIN,
64 },
65 .card = SOUND_CARD,
66 .id = 0,
67 .type = PCM_PLAYBACK,
68 .devices = AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
69 };
70
71 struct pcm_device_profile pcm_device_capture = {
72 .config = {
73 .channels = CAPTURE_DEFAULT_CHANNEL_COUNT,
74 .rate = CAPTURE_DEFAULT_SAMPLING_RATE,
75 .period_size = CAPTURE_PERIOD_SIZE,
76 .period_count = CAPTURE_PERIOD_COUNT,
77 .format = PCM_FORMAT_S16_LE,
78 .start_threshold = CAPTURE_START_THRESHOLD,
79 .stop_threshold = 0,
80 .silence_threshold = 0,
81 .avail_min = 0,
82 },
83 .card = SOUND_CARD,
84 .id = 0,
85 .type = PCM_CAPTURE,
86 .devices = AUDIO_DEVICE_IN_BUILTIN_MIC|AUDIO_DEVICE_IN_WIRED_HEADSET|AUDIO_DEVICE_IN_BACK_MIC,
87 };
88
89 struct pcm_device_profile pcm_device_capture_loopback_aec = {
90 .config = {
91 .channels = CAPTURE_DEFAULT_CHANNEL_COUNT,
92 .rate = CAPTURE_DEFAULT_SAMPLING_RATE,
93 .period_size = CAPTURE_PERIOD_SIZE,
94 .period_count = CAPTURE_PERIOD_COUNT,
95 .format = PCM_FORMAT_S16_LE,
96 .start_threshold = CAPTURE_START_THRESHOLD,
97 .stop_threshold = 0,
98 .silence_threshold = 0,
99 .avail_min = 0,
100 },
101 .card = SOUND_CARD,
102 .id = 1,
103 .type = PCM_CAPTURE,
104 .devices = SND_DEVICE_IN_LOOPBACK_AEC,
105 };
106
107 struct pcm_device_profile pcm_device_playback_spk = {
108 .config = {
109 .channels = PLAYBACK_DEFAULT_CHANNEL_COUNT,
110 .rate = PLAYBACK_DEFAULT_SAMPLING_RATE,
111 .period_size = PLAYBACK_PERIOD_SIZE,
112 .period_count = PLAYBACK_PERIOD_COUNT,
113 .format = PCM_FORMAT_S16_LE,
114 .start_threshold = PLAYBACK_START_THRESHOLD,
115 .stop_threshold = PLAYBACK_STOP_THRESHOLD,
116 .silence_threshold = 0,
117 .avail_min = PLAYBACK_AVAILABLE_MIN,
118 },
119 .card = SOUND_CARD,
120 .id = 1,
121 .type = PCM_PLAYBACK,
122 .devices = AUDIO_DEVICE_OUT_SPEAKER,
123 };
124
125 struct pcm_device_profile pcm_device_playback_sco = {
126 .config = {
127 .channels = SCO_DEFAULT_CHANNEL_COUNT,
128 .rate = SCO_DEFAULT_SAMPLING_RATE,
129 .period_size = SCO_PERIOD_SIZE,
130 .period_count = SCO_PERIOD_COUNT,
131 .format = PCM_FORMAT_S16_LE,
132 .start_threshold = SCO_START_THRESHOLD,
133 .stop_threshold = SCO_STOP_THRESHOLD,
134 .silence_threshold = 0,
135 .avail_min = SCO_AVAILABLE_MIN,
136 },
137 .card = SOUND_CARD,
138 .id = 2,
139 .type = PCM_PLAYBACK,
140 .devices =
141 AUDIO_DEVICE_OUT_BLUETOOTH_SCO|AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET|
142 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT,
143 };
144
145 struct pcm_device_profile pcm_device_capture_sco = {
146 .config = {
147 .channels = SCO_DEFAULT_CHANNEL_COUNT,
148 .rate = SCO_DEFAULT_SAMPLING_RATE,
149 .period_size = SCO_PERIOD_SIZE,
150 .period_count = SCO_PERIOD_COUNT,
151 .format = PCM_FORMAT_S16_LE,
152 .start_threshold = CAPTURE_START_THRESHOLD,
153 .stop_threshold = 0,
154 .silence_threshold = 0,
155 .avail_min = 0,
156 },
157 .card = SOUND_CARD,
158 .id = 2,
159 .type = PCM_CAPTURE,
160 .devices = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET,
161 };
162
163 struct pcm_device_profile pcm_device_hotword_streaming = {
164 .config = {
165 .channels = 1,
166 .rate = 16000,
167 .period_size = CAPTURE_PERIOD_SIZE,
168 .period_count = CAPTURE_PERIOD_COUNT,
169 .format = PCM_FORMAT_S16_LE,
170 .start_threshold = CAPTURE_START_THRESHOLD,
171 .stop_threshold = 0,
172 .silence_threshold = 0,
173 .avail_min = 0,
174 },
175 .card = SOUND_CARD,
176 .id = 0,
177 .type = PCM_HOTWORD_STREAMING,
178 .devices = AUDIO_DEVICE_IN_BUILTIN_MIC|AUDIO_DEVICE_IN_WIRED_HEADSET|AUDIO_DEVICE_IN_BACK_MIC
179 };
180
181 struct pcm_device_profile *pcm_devices[] = {
182 &pcm_device_playback_hs,
183 &pcm_device_capture,
184 &pcm_device_playback_spk,
185 &pcm_device_playback_sco,
186 &pcm_device_capture_sco,
187 &pcm_device_capture_loopback_aec,
188 &pcm_device_hotword_streaming,
189 NULL,
190 };
191
192 static const char * const use_case_table[AUDIO_USECASE_MAX] = {
193 [USECASE_AUDIO_PLAYBACK] = "playback",
194 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = "playback multi-channel",
195 [USECASE_AUDIO_PLAYBACK_OFFLOAD] = "compress-offload-playback",
196 [USECASE_AUDIO_CAPTURE] = "capture",
197 [USECASE_AUDIO_CAPTURE_HOTWORD] = "capture-hotword",
198 [USECASE_VOICE_CALL] = "voice-call",
199 };
200
201
202 #define STRING_TO_ENUM(string) { #string, string }
203
204 static unsigned int audio_device_ref_count;
205
206 struct pcm_config pcm_config_deep_buffer = {
207 .channels = 2,
208 .rate = DEEP_BUFFER_OUTPUT_SAMPLING_RATE,
209 .period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE,
210 .period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT,
211 .format = PCM_FORMAT_S16_LE,
212 .start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
213 .stop_threshold = INT_MAX,
214 .avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
215 };
216
217 struct string_to_enum {
218 const char *name;
219 uint32_t value;
220 };
221
222 static const struct string_to_enum out_channels_name_to_enum_table[] = {
223 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO),
224 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
225 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
226 };
227
228 static void dummybuf_thread_close(struct audio_device *adev);
229
is_supported_format(audio_format_t format)230 static bool is_supported_format(audio_format_t format)
231 {
232 if (format == AUDIO_FORMAT_MP3 ||
233 ((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC))
234 return true;
235
236 return false;
237 }
238
get_snd_codec_id(audio_format_t format)239 static int get_snd_codec_id(audio_format_t format)
240 {
241 int id = 0;
242
243 switch (format & AUDIO_FORMAT_MAIN_MASK) {
244 case AUDIO_FORMAT_MP3:
245 id = SND_AUDIOCODEC_MP3;
246 break;
247 case AUDIO_FORMAT_AAC:
248 id = SND_AUDIOCODEC_AAC;
249 break;
250 default:
251 ALOGE("%s: Unsupported audio format", __func__);
252 }
253
254 return id;
255 }
256
257 /* Array to store sound devices */
258 static const char * const device_table[SND_DEVICE_MAX] = {
259 [SND_DEVICE_NONE] = "none",
260 /* Playback sound devices */
261 [SND_DEVICE_OUT_HANDSET] = "handset",
262 [SND_DEVICE_OUT_SPEAKER] = "speaker",
263 [SND_DEVICE_OUT_HEADPHONES] = "headphones",
264 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",
265 [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset",
266 [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker",
267 [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones",
268 [SND_DEVICE_OUT_HDMI] = "hdmi",
269 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
270 [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset",
271 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
272 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
273 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset",
274
275 /* Capture sound devices */
276 [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic",
277 [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic",
278 [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic",
279 [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic",
280 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "voice-speaker-mic",
281 [SND_DEVICE_IN_HEADSET_MIC_AEC] = "headset-mic",
282 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic",
283 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic",
284 [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic",
285 [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic",
286 [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic",
287 [SND_DEVICE_IN_VOICE_DMIC_1] = "voice-dmic-1",
288 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_1] = "voice-speaker-dmic-1",
289 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic",
290 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic",
291 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic",
292 [SND_DEVICE_IN_VOICE_REC_HEADSET_MIC] = "voice-rec-headset-mic",
293 [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic",
294 [SND_DEVICE_IN_VOICE_REC_DMIC_1] = "voice-rec-dmic-1",
295 [SND_DEVICE_IN_VOICE_REC_DMIC_NS_1] = "voice-rec-dmic-ns-1",
296 [SND_DEVICE_IN_LOOPBACK_AEC] = "loopback-aec",
297 };
298
adev_get_mixer_for_card(struct audio_device * adev,int card)299 struct mixer_card *adev_get_mixer_for_card(struct audio_device *adev, int card)
300 {
301 struct mixer_card *mixer_card;
302 struct listnode *node;
303
304 list_for_each(node, &adev->mixer_list) {
305 mixer_card = node_to_item(node, struct mixer_card, adev_list_node);
306 if (mixer_card->card == card)
307 return mixer_card;
308 }
309 return NULL;
310 }
311
uc_get_mixer_for_card(struct audio_usecase * usecase,int card)312 struct mixer_card *uc_get_mixer_for_card(struct audio_usecase *usecase, int card)
313 {
314 struct mixer_card *mixer_card;
315 struct listnode *node;
316
317 list_for_each(node, &usecase->mixer_list) {
318 mixer_card = node_to_item(node, struct mixer_card, uc_list_node[usecase->id]);
319 if (mixer_card->card == card)
320 return mixer_card;
321 }
322 return NULL;
323 }
324
free_mixer_list(struct audio_device * adev)325 void free_mixer_list(struct audio_device *adev)
326 {
327 struct mixer_card *mixer_card;
328 struct listnode *node;
329 struct listnode *next;
330
331 list_for_each_safe(node, next, &adev->mixer_list) {
332 mixer_card = node_to_item(node, struct mixer_card, adev_list_node);
333 list_remove(node);
334 audio_route_free(mixer_card->audio_route);
335 free(mixer_card);
336 }
337 }
338
mixer_init(struct audio_device * adev)339 int mixer_init(struct audio_device *adev)
340 {
341 int i;
342 int card;
343 int retry_num;
344 struct mixer *mixer;
345 struct audio_route *audio_route;
346 char mixer_path[PATH_MAX];
347 struct mixer_card *mixer_card;
348 struct listnode *node;
349
350 list_init(&adev->mixer_list);
351
352 for (i = 0; pcm_devices[i] != NULL; i++) {
353 card = pcm_devices[i]->card;
354 if (adev_get_mixer_for_card(adev, card) == NULL) {
355 retry_num = 0;
356 do {
357 mixer = mixer_open(card);
358 if (mixer == NULL) {
359 if (++retry_num > RETRY_NUMBER) {
360 ALOGE("%s unable to open the mixer for--card %d, aborting.",
361 __func__, card);
362 goto error;
363 }
364 usleep(RETRY_US);
365 }
366 } while (mixer == NULL);
367
368 sprintf(mixer_path, "/system/etc/mixer_paths_%d.xml", card);
369 audio_route = audio_route_init(card, mixer_path);
370 if (!audio_route) {
371 ALOGE("%s: Failed to init audio route controls for card %d, aborting.",
372 __func__, card);
373 goto error;
374 }
375 mixer_card = calloc(1, sizeof(struct mixer_card));
376 mixer_card->card = card;
377 mixer_card->mixer = mixer;
378 mixer_card->audio_route = audio_route;
379 list_add_tail(&adev->mixer_list, &mixer_card->adev_list_node);
380 }
381 }
382
383 return 0;
384
385 error:
386 free_mixer_list(adev);
387 return -ENODEV;
388 }
389
get_snd_device_name(snd_device_t snd_device)390 const char *get_snd_device_name(snd_device_t snd_device)
391 {
392 const char *name = NULL;
393
394 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX)
395 name = device_table[snd_device];
396
397 ALOGE_IF(name == NULL, "%s: invalid snd device %d", __func__, snd_device);
398
399 return name;
400 }
401
get_snd_device_display_name(snd_device_t snd_device)402 const char *get_snd_device_display_name(snd_device_t snd_device)
403 {
404 const char *name = get_snd_device_name(snd_device);
405
406 if (name == NULL)
407 name = "SND DEVICE NOT FOUND";
408
409 return name;
410 }
411
get_pcm_device(usecase_type_t uc_type,audio_devices_t devices)412 struct pcm_device_profile *get_pcm_device(usecase_type_t uc_type, audio_devices_t devices)
413 {
414 int i;
415
416 devices &= ~AUDIO_DEVICE_BIT_IN;
417 for (i = 0; pcm_devices[i] != NULL; i++) {
418 if ((pcm_devices[i]->type == uc_type) &&
419 (devices & pcm_devices[i]->devices))
420 break;
421 }
422 return pcm_devices[i];
423 }
424
get_usecase_from_id(struct audio_device * adev,audio_usecase_t uc_id)425 static struct audio_usecase *get_usecase_from_id(struct audio_device *adev,
426 audio_usecase_t uc_id)
427 {
428 struct audio_usecase *usecase;
429 struct listnode *node;
430
431 list_for_each(node, &adev->usecase_list) {
432 usecase = node_to_item(node, struct audio_usecase, adev_list_node);
433 if (usecase->id == uc_id)
434 return usecase;
435 }
436 return NULL;
437 }
438
get_usecase_from_type(struct audio_device * adev,usecase_type_t type)439 static struct audio_usecase *get_usecase_from_type(struct audio_device *adev,
440 usecase_type_t type)
441 {
442 struct audio_usecase *usecase;
443 struct listnode *node;
444
445 list_for_each(node, &adev->usecase_list) {
446 usecase = node_to_item(node, struct audio_usecase, adev_list_node);
447 if (usecase->type & type)
448 return usecase;
449 }
450 return NULL;
451 }
452
453 /* always called with adev lock held */
set_voice_volume_l(struct audio_device * adev,float volume)454 static int set_voice_volume_l(struct audio_device *adev, float volume)
455 {
456 int err = 0;
457 (void)volume;
458
459 if (adev->mode == AUDIO_MODE_IN_CALL) {
460 /* TODO */
461 }
462 return err;
463 }
464
465
get_output_snd_device(struct audio_device * adev,audio_devices_t devices)466 snd_device_t get_output_snd_device(struct audio_device *adev, audio_devices_t devices)
467 {
468
469 audio_mode_t mode = adev->mode;
470 snd_device_t snd_device = SND_DEVICE_NONE;
471
472 ALOGV("%s: enter: output devices(%#x), mode(%d)", __func__, devices, mode);
473 if (devices == AUDIO_DEVICE_NONE ||
474 devices & AUDIO_DEVICE_BIT_IN) {
475 ALOGV("%s: Invalid output devices (%#x)", __func__, devices);
476 goto exit;
477 }
478
479 if (mode == AUDIO_MODE_IN_CALL) {
480 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
481 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
482 if (adev->tty_mode == TTY_MODE_FULL)
483 snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES;
484 else if (adev->tty_mode == TTY_MODE_VCO)
485 snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES;
486 else if (adev->tty_mode == TTY_MODE_HCO)
487 snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET;
488 else
489 snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES;
490 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
491 snd_device = SND_DEVICE_OUT_BT_SCO;
492 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
493 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
494 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
495 snd_device = SND_DEVICE_OUT_HANDSET;
496 }
497 if (snd_device != SND_DEVICE_NONE) {
498 goto exit;
499 }
500 }
501
502 if (popcount(devices) == 2) {
503 if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
504 AUDIO_DEVICE_OUT_SPEAKER)) {
505 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
506 } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET |
507 AUDIO_DEVICE_OUT_SPEAKER)) {
508 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
509 } else {
510 ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
511 goto exit;
512 }
513 if (snd_device != SND_DEVICE_NONE) {
514 goto exit;
515 }
516 }
517
518 if (popcount(devices) != 1) {
519 ALOGE("%s: Invalid output devices(%#x)", __func__, devices);
520 goto exit;
521 }
522
523 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
524 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
525 snd_device = SND_DEVICE_OUT_HEADPHONES;
526 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
527 snd_device = SND_DEVICE_OUT_SPEAKER;
528 } else if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
529 snd_device = SND_DEVICE_OUT_BT_SCO;
530 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
531 snd_device = SND_DEVICE_OUT_HANDSET;
532 } else {
533 ALOGE("%s: Unknown device(s) %#x", __func__, devices);
534 }
535 exit:
536 ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]);
537 return snd_device;
538 }
539
get_input_snd_device(struct audio_device * adev,audio_devices_t out_device)540 snd_device_t get_input_snd_device(struct audio_device *adev, audio_devices_t out_device)
541 {
542 audio_source_t source;
543 audio_mode_t mode = adev->mode;
544 audio_devices_t in_device;
545 audio_channel_mask_t channel_mask;
546 snd_device_t snd_device = SND_DEVICE_NONE;
547 struct stream_in *active_input = NULL;
548 struct audio_usecase *usecase;
549
550 usecase = get_usecase_from_type(adev, PCM_CAPTURE|VOICE_CALL);
551 if (usecase != NULL) {
552 active_input = (struct stream_in *)usecase->stream;
553 }
554 source = (active_input == NULL) ?
555 AUDIO_SOURCE_DEFAULT : active_input->source;
556
557 in_device = ((active_input == NULL) ?
558 AUDIO_DEVICE_NONE : active_input->devices)
559 & ~AUDIO_DEVICE_BIT_IN;
560 channel_mask = (active_input == NULL) ?
561 AUDIO_CHANNEL_IN_MONO : active_input->main_channels;
562
563 ALOGV("%s: enter: out_device(%#x) in_device(%#x)",
564 __func__, out_device, in_device);
565 if (mode == AUDIO_MODE_IN_CALL) {
566 if (out_device == AUDIO_DEVICE_NONE) {
567 ALOGE("%s: No output device set for voice call", __func__);
568 goto exit;
569 }
570 if (adev->tty_mode != TTY_MODE_OFF) {
571 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
572 out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
573 switch (adev->tty_mode) {
574 case TTY_MODE_FULL:
575 snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC;
576 break;
577 case TTY_MODE_VCO:
578 snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC;
579 break;
580 case TTY_MODE_HCO:
581 snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC;
582 break;
583 default:
584 ALOGE("%s: Invalid TTY mode (%#x)", __func__, adev->tty_mode);
585 }
586 goto exit;
587 }
588 }
589 if (out_device & AUDIO_DEVICE_OUT_EARPIECE ||
590 out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
591 snd_device = SND_DEVICE_IN_HANDSET_MIC;
592 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
593 snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC;
594 } else if (out_device & AUDIO_DEVICE_OUT_ALL_SCO) {
595 snd_device = SND_DEVICE_IN_BT_SCO_MIC ;
596 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
597 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
598 }
599 } else if (source == AUDIO_SOURCE_CAMCORDER) {
600 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
601 in_device & AUDIO_DEVICE_IN_BACK_MIC) {
602 snd_device = SND_DEVICE_IN_CAMCORDER_MIC;
603 }
604 } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) {
605 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
606 if (adev->dualmic_config == DUALMIC_CONFIG_1) {
607 if (channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK)
608 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_1;
609 else if (adev->ns_in_voice_rec)
610 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_NS_1;
611 }
612
613 if (snd_device == SND_DEVICE_NONE) {
614 snd_device = SND_DEVICE_IN_VOICE_REC_MIC;
615 }
616 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
617 snd_device = SND_DEVICE_IN_VOICE_REC_HEADSET_MIC;
618 }
619 } else if (source == AUDIO_SOURCE_VOICE_COMMUNICATION || source == AUDIO_SOURCE_MIC) {
620 if (out_device & AUDIO_DEVICE_OUT_SPEAKER)
621 in_device = AUDIO_DEVICE_IN_BACK_MIC;
622 if (active_input) {
623 if (active_input->enable_aec) {
624 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
625 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
626 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
627 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
628 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
629 } else {
630 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC;
631 }
632 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
633 snd_device = SND_DEVICE_IN_HEADSET_MIC_AEC;
634 }
635 }
636 /* TODO: set echo reference */
637 }
638 } else if (source == AUDIO_SOURCE_DEFAULT) {
639 goto exit;
640 }
641
642
643 if (snd_device != SND_DEVICE_NONE) {
644 goto exit;
645 }
646
647 if (in_device != AUDIO_DEVICE_NONE &&
648 !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) &&
649 !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) {
650 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
651 snd_device = SND_DEVICE_IN_HANDSET_MIC;
652 } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
653 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
654 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
655 snd_device = SND_DEVICE_IN_HEADSET_MIC;
656 } else if (in_device & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
657 snd_device = SND_DEVICE_IN_BT_SCO_MIC ;
658 } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) {
659 snd_device = SND_DEVICE_IN_HDMI_MIC;
660 } else {
661 ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
662 ALOGW("%s: Using default handset-mic", __func__);
663 snd_device = SND_DEVICE_IN_HANDSET_MIC;
664 }
665 } else {
666 if (out_device & AUDIO_DEVICE_OUT_EARPIECE) {
667 snd_device = SND_DEVICE_IN_HANDSET_MIC;
668 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
669 snd_device = SND_DEVICE_IN_HEADSET_MIC;
670 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
671 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
672 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
673 snd_device = SND_DEVICE_IN_HANDSET_MIC;
674 } else if (out_device & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET) {
675 snd_device = SND_DEVICE_IN_BT_SCO_MIC;
676 } else {
677 ALOGE("%s: Unknown output device(s) %#x", __func__, out_device);
678 ALOGW("%s: Using default handset-mic", __func__);
679 snd_device = SND_DEVICE_IN_HANDSET_MIC;
680 }
681 }
682 exit:
683 ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]);
684 return snd_device;
685 }
686
set_hdmi_channels(struct audio_device * adev,int channel_count)687 int set_hdmi_channels(struct audio_device *adev, int channel_count)
688 {
689 struct mixer_ctl *ctl;
690 const char *mixer_ctl_name = "";
691 (void)adev;
692 (void)channel_count;
693 /* TODO */
694
695 return 0;
696 }
697
edid_get_max_channels(struct audio_device * adev)698 int edid_get_max_channels(struct audio_device *adev)
699 {
700 int max_channels = 2;
701 struct mixer_ctl *ctl;
702 (void)adev;
703
704 /* TODO */
705 return max_channels;
706 }
707
708 /* Delay in Us */
render_latency(audio_usecase_t usecase)709 int64_t render_latency(audio_usecase_t usecase)
710 {
711 (void)usecase;
712 /* TODO */
713 return 0;
714 }
715
enable_snd_device(struct audio_device * adev,struct audio_usecase * uc_info,snd_device_t snd_device,bool update_mixer)716 static int enable_snd_device(struct audio_device *adev,
717 struct audio_usecase *uc_info,
718 snd_device_t snd_device,
719 bool update_mixer)
720 {
721 struct mixer_card *mixer_card;
722 struct listnode *node;
723 const char *snd_device_name = get_snd_device_name(snd_device);
724
725 if (snd_device_name == NULL)
726 return -EINVAL;
727
728 adev->snd_dev_ref_cnt[snd_device]++;
729 if (adev->snd_dev_ref_cnt[snd_device] > 1) {
730 ALOGV("%s: snd_device(%d: %s) is already active",
731 __func__, snd_device, snd_device_name);
732 return 0;
733 }
734
735 ALOGV("%s: snd_device(%d: %s)", __func__,
736 snd_device, snd_device_name);
737
738 list_for_each(node, &uc_info->mixer_list) {
739 mixer_card = node_to_item(node, struct mixer_card, uc_list_node[uc_info->id]);
740 audio_route_apply_path(mixer_card->audio_route, snd_device_name);
741 if (update_mixer)
742 audio_route_update_mixer(mixer_card->audio_route);
743 }
744
745 return 0;
746 }
747
disable_snd_device(struct audio_device * adev,struct audio_usecase * uc_info,snd_device_t snd_device,bool update_mixer)748 static int disable_snd_device(struct audio_device *adev,
749 struct audio_usecase *uc_info,
750 snd_device_t snd_device,
751 bool update_mixer)
752 {
753 struct mixer_card *mixer_card;
754 struct listnode *node;
755 const char *snd_device_name = get_snd_device_name(snd_device);
756
757 if (snd_device_name == NULL)
758 return -EINVAL;
759
760 if (adev->snd_dev_ref_cnt[snd_device] <= 0) {
761 ALOGE("%s: device ref cnt is already 0", __func__);
762 return -EINVAL;
763 }
764 adev->snd_dev_ref_cnt[snd_device]--;
765 if (adev->snd_dev_ref_cnt[snd_device] == 0) {
766 ALOGV("%s: snd_device(%d: %s)", __func__,
767 snd_device, snd_device_name);
768 list_for_each(node, &uc_info->mixer_list) {
769 mixer_card = node_to_item(node, struct mixer_card, uc_list_node[uc_info->id]);
770 audio_route_reset_path(mixer_card->audio_route, snd_device_name);
771 if (update_mixer)
772 audio_route_update_mixer(mixer_card->audio_route);
773 }
774 }
775 return 0;
776 }
777
select_devices(struct audio_device * adev,audio_usecase_t uc_id)778 static int select_devices(struct audio_device *adev,
779 audio_usecase_t uc_id)
780 {
781 snd_device_t out_snd_device = SND_DEVICE_NONE;
782 snd_device_t in_snd_device = SND_DEVICE_NONE;
783 struct audio_usecase *usecase = NULL;
784 struct audio_usecase *vc_usecase = NULL;
785 struct listnode *node;
786 struct stream_in *active_input = NULL;
787 struct stream_out *active_out;
788 struct mixer_card *mixer_card;
789
790 ALOGV("%s: usecase(%d)", __func__, uc_id);
791
792 if (uc_id == USECASE_AUDIO_CAPTURE_HOTWORD)
793 return 0;
794
795 usecase = get_usecase_from_type(adev, PCM_CAPTURE|VOICE_CALL);
796 if (usecase != NULL) {
797 active_input = (struct stream_in *)usecase->stream;
798 }
799
800 usecase = get_usecase_from_id(adev, uc_id);
801 if (usecase == NULL) {
802 ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id);
803 return -EINVAL;
804 }
805 active_out = (struct stream_out *)usecase->stream;
806
807 if (usecase->type == VOICE_CALL) {
808 out_snd_device = get_output_snd_device(adev, active_out->devices);
809 in_snd_device = get_input_snd_device(adev, active_out->devices);
810 usecase->devices = active_out->devices;
811 } else {
812 /*
813 * If the voice call is active, use the sound devices of voice call usecase
814 * so that it would not result any device switch. All the usecases will
815 * be switched to new device when select_devices() is called for voice call
816 * usecase.
817 */
818 if (adev->in_call) {
819 vc_usecase = get_usecase_from_id(adev, USECASE_VOICE_CALL);
820 if (usecase == NULL) {
821 ALOGE("%s: Could not find the voice call usecase", __func__);
822 } else {
823 in_snd_device = vc_usecase->in_snd_device;
824 out_snd_device = vc_usecase->out_snd_device;
825 }
826 }
827 if (usecase->type == PCM_PLAYBACK) {
828 usecase->devices = active_out->devices;
829 in_snd_device = SND_DEVICE_NONE;
830 if (out_snd_device == SND_DEVICE_NONE) {
831 out_snd_device = get_output_snd_device(adev, active_out->devices);
832 if (active_out == adev->primary_output &&
833 active_input &&
834 active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
835 select_devices(adev, active_input->usecase);
836 }
837 }
838 } else if (usecase->type == PCM_CAPTURE) {
839 usecase->devices = ((struct stream_in *)usecase->stream)->devices;
840 out_snd_device = SND_DEVICE_NONE;
841 if (in_snd_device == SND_DEVICE_NONE) {
842 if (active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION &&
843 adev->primary_output && !adev->primary_output->standby) {
844 in_snd_device = get_input_snd_device(adev, adev->primary_output->devices);
845 } else {
846 in_snd_device = get_input_snd_device(adev, AUDIO_DEVICE_NONE);
847 }
848 }
849 }
850 }
851
852 if (out_snd_device == usecase->out_snd_device &&
853 in_snd_device == usecase->in_snd_device) {
854 return 0;
855 }
856
857 ALOGV("%s: out_snd_device(%d: %s) in_snd_device(%d: %s)", __func__,
858 out_snd_device, get_snd_device_display_name(out_snd_device),
859 in_snd_device, get_snd_device_display_name(in_snd_device));
860
861
862 /* Disable current sound devices */
863 if (usecase->out_snd_device != SND_DEVICE_NONE) {
864 pthread_mutex_lock(&adev->tfa9895_lock);
865 disable_snd_device(adev, usecase, usecase->out_snd_device, false);
866 pthread_mutex_unlock(&adev->tfa9895_lock);
867 }
868
869 if (usecase->in_snd_device != SND_DEVICE_NONE) {
870 disable_snd_device(adev, usecase, usecase->in_snd_device, false);
871 }
872
873 /* Enable new sound devices */
874 if (out_snd_device != SND_DEVICE_NONE) {
875 enable_snd_device(adev, usecase, out_snd_device, false);
876 }
877
878 if (in_snd_device != SND_DEVICE_NONE) {
879 enable_snd_device(adev, usecase, in_snd_device, false);
880 }
881
882 list_for_each(node, &usecase->mixer_list) {
883 mixer_card = node_to_item(node, struct mixer_card, uc_list_node[usecase->id]);
884 audio_route_update_mixer(mixer_card->audio_route);
885 }
886
887 usecase->in_snd_device = in_snd_device;
888 usecase->out_snd_device = out_snd_device;
889
890 if (out_snd_device != SND_DEVICE_NONE)
891 if (usecase->devices & (AUDIO_DEVICE_OUT_WIRED_HEADSET | AUDIO_DEVICE_OUT_WIRED_HEADPHONE))
892 if (adev->htc_acoustic_set_rt5506_amp != NULL)
893 adev->htc_acoustic_set_rt5506_amp(adev->mode, usecase->devices);
894 return 0;
895 }
896
897
898 static ssize_t read_frames(struct stream_in *in, void *buffer, ssize_t frames);
899 static int do_in_standby_l(struct stream_in *in);
900
901 #ifdef PREPROCESSING_ENABLED
get_capture_reference_delay(struct stream_in * in,size_t frames,struct echo_reference_buffer * buffer)902 static void get_capture_reference_delay(struct stream_in *in,
903 size_t frames,
904 struct echo_reference_buffer *buffer)
905 {
906 ALOGVV("%s: enter:)", __func__);
907
908 /* read frames available in kernel driver buffer */
909 unsigned int kernel_frames;
910 struct timespec tstamp;
911 long buf_delay;
912 long kernel_delay;
913 long delay_ns;
914 struct pcm_device *ref_device;
915 long rsmp_delay = 0;
916
917 ref_device = node_to_item(list_tail(&in->pcm_dev_list),
918 struct pcm_device, stream_list_node);
919
920 if (pcm_get_htimestamp(ref_device->pcm, &kernel_frames, &tstamp) < 0) {
921 buffer->time_stamp.tv_sec = 0;
922 buffer->time_stamp.tv_nsec = 0;
923 buffer->delay_ns = 0;
924 ALOGW("read get_capture_reference_delay(): pcm_htimestamp error");
925 return;
926 }
927
928 /* adjust render time stamp with delay added by current driver buffer.
929 * Add the duration of current frame as we want the render time of the last
930 * sample being written. */
931
932 kernel_delay = (long)(((int64_t)kernel_frames * 1000000000) / ref_device->pcm_profile->config.rate);
933
934 buffer->time_stamp = tstamp;
935 buffer->delay_ns = kernel_delay;
936
937 ALOGVV("get_capture_reference_delay_time_stamp Secs: [%10ld], nSecs: [%9ld], kernel_frames: [%5d],"
938 " delay_ns: [%d] , frames:[%zd]",
939 buffer->time_stamp.tv_sec , buffer->time_stamp.tv_nsec, kernel_frames, buffer->delay_ns, frames);
940 }
941
get_capture_delay(struct stream_in * in,size_t frames,struct echo_reference_buffer * buffer)942 static void get_capture_delay(struct stream_in *in,
943 size_t frames,
944 struct echo_reference_buffer *buffer)
945 {
946 ALOGVV("%s: enter:)", __func__);
947 /* read frames available in kernel driver buffer */
948 unsigned int kernel_frames;
949 struct timespec tstamp;
950 long buf_delay;
951 long rsmp_delay;
952 long kernel_delay;
953 long delay_ns;
954 struct pcm_device *pcm_device;
955
956 pcm_device = node_to_item(list_head(&in->pcm_dev_list),
957 struct pcm_device, stream_list_node);
958
959 if (pcm_get_htimestamp(pcm_device->pcm, &kernel_frames, &tstamp) < 0) {
960 buffer->time_stamp.tv_sec = 0;
961 buffer->time_stamp.tv_nsec = 0;
962 buffer->delay_ns = 0;
963 ALOGW("read get_capture_delay(): pcm_htimestamp error");
964 return;
965 }
966
967 /* read frames available in audio HAL input buffer
968 * add number of frames being read as we want the capture time of first sample
969 * in current buffer */
970 /* frames in in->read_buf are at driver sampling rate while frames in in->proc_buf are
971 * at requested sampling rate */
972 buf_delay = (long)(((int64_t)(in->read_buf_frames) * 1000000000) / in->config.rate +
973 ((int64_t)(in->proc_buf_frames) * 1000000000) / in->requested_rate );
974
975 /* add delay introduced by resampler */
976 rsmp_delay = 0;
977 if (in->resampler) {
978 rsmp_delay = in->resampler->delay_ns(in->resampler);
979 }
980
981 kernel_delay = (long)(((int64_t)kernel_frames * 1000000000) / in->config.rate);
982
983 delay_ns = kernel_delay + buf_delay + rsmp_delay;
984
985 buffer->time_stamp = tstamp;
986 buffer->delay_ns = delay_ns;
987 ALOGVV("get_capture_delay_time_stamp Secs: [%10ld], nSecs: [%9ld], kernel_frames:[%5d],"
988 " delay_ns: [%d], kernel_delay:[%ld], buf_delay:[%ld], rsmp_delay:[%ld], "
989 "in->read_buf_frames:[%zd], in->proc_buf_frames:[%zd], frames:[%zd]",
990 buffer->time_stamp.tv_sec , buffer->time_stamp.tv_nsec, kernel_frames,
991 buffer->delay_ns, kernel_delay, buf_delay, rsmp_delay,
992 in->read_buf_frames, in->proc_buf_frames, frames);
993 }
994
update_echo_reference(struct stream_in * in,size_t frames)995 static int32_t update_echo_reference(struct stream_in *in, size_t frames)
996 {
997 ALOGVV("%s: enter:), in->config.channels(%d)", __func__,in->config.channels);
998 struct echo_reference_buffer b;
999 b.delay_ns = 0;
1000 struct pcm_device *pcm_device;
1001
1002 pcm_device = node_to_item(list_head(&in->pcm_dev_list),
1003 struct pcm_device, stream_list_node);
1004
1005 ALOGVV("update_echo_reference, in->config.channels(%d), frames = [%zd], in->ref_buf_frames = [%zd], "
1006 "b.frame_count = [%zd]",
1007 in->config.channels, frames, in->ref_buf_frames, frames - in->ref_buf_frames);
1008 if (in->ref_buf_frames < frames) {
1009 if (in->ref_buf_size < frames) {
1010 in->ref_buf_size = frames;
1011 in->ref_buf = (int16_t *)realloc(in->ref_buf, pcm_frames_to_bytes(pcm_device->pcm, frames));
1012 ALOG_ASSERT((in->ref_buf != NULL),
1013 "update_echo_reference() failed to reallocate ref_buf");
1014 ALOGVV("update_echo_reference(): ref_buf %p extended to %d bytes",
1015 in->ref_buf, pcm_frames_to_bytes(pcm_device->pcm, frames));
1016 }
1017 b.frame_count = frames - in->ref_buf_frames;
1018 b.raw = (void *)(in->ref_buf + in->ref_buf_frames * in->config.channels);
1019
1020 get_capture_delay(in, frames, &b);
1021
1022 if (in->echo_reference->read(in->echo_reference, &b) == 0)
1023 {
1024 in->ref_buf_frames += b.frame_count;
1025 ALOGVV("update_echo_reference(): in->ref_buf_frames:[%zd], "
1026 "in->ref_buf_size:[%zd], frames:[%zd], b.frame_count:[%zd]",
1027 in->ref_buf_frames, in->ref_buf_size, frames, b.frame_count);
1028 }
1029 } else
1030 ALOGW("update_echo_reference(): NOT enough frames to read ref buffer");
1031 return b.delay_ns;
1032 }
1033
set_preprocessor_param(effect_handle_t handle,effect_param_t * param)1034 static int set_preprocessor_param(effect_handle_t handle,
1035 effect_param_t *param)
1036 {
1037 uint32_t size = sizeof(int);
1038 uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) +
1039 param->vsize;
1040
1041 int status = (*handle)->command(handle,
1042 EFFECT_CMD_SET_PARAM,
1043 sizeof (effect_param_t) + psize,
1044 param,
1045 &size,
1046 ¶m->status);
1047 if (status == 0)
1048 status = param->status;
1049
1050 return status;
1051 }
1052
set_preprocessor_echo_delay(effect_handle_t handle,int32_t delay_us)1053 static int set_preprocessor_echo_delay(effect_handle_t handle,
1054 int32_t delay_us)
1055 {
1056 struct {
1057 effect_param_t param;
1058 uint32_t data_0;
1059 int32_t data_1;
1060 } buf;
1061 memset(&buf, 0, sizeof(buf));
1062
1063 buf.param.psize = sizeof(uint32_t);
1064 buf.param.vsize = sizeof(uint32_t);
1065 buf.data_0 = AEC_PARAM_ECHO_DELAY;
1066 buf.data_1 = delay_us;
1067
1068 return set_preprocessor_param(handle, &buf.param);
1069 }
1070
push_echo_reference(struct stream_in * in,size_t frames)1071 static void push_echo_reference(struct stream_in *in, size_t frames)
1072 {
1073 ALOGVV("%s: enter:)", __func__);
1074 /* read frames from echo reference buffer and update echo delay
1075 * in->ref_buf_frames is updated with frames available in in->ref_buf */
1076
1077 int32_t delay_us = update_echo_reference(in, frames)/1000;
1078 int32_t size_in_bytes = 0;
1079 int i;
1080 audio_buffer_t buf;
1081
1082 if (in->ref_buf_frames < frames)
1083 frames = in->ref_buf_frames;
1084
1085 buf.frameCount = frames;
1086 buf.raw = in->ref_buf;
1087
1088 for (i = 0; i < in->num_preprocessors; i++) {
1089 if ((*in->preprocessors[i].effect_itfe)->process_reverse == NULL)
1090 continue;
1091 ALOGVV("%s: effect_itfe)->process_reverse() BEGIN i=(%d) ", __func__, i);
1092 (*in->preprocessors[i].effect_itfe)->process_reverse(in->preprocessors[i].effect_itfe,
1093 &buf,
1094 NULL);
1095 ALOGVV("%s: effect_itfe)->process_reverse() END i=(%d) ", __func__, i);
1096 set_preprocessor_echo_delay(in->preprocessors[i].effect_itfe, delay_us);
1097 }
1098
1099 in->ref_buf_frames -= buf.frameCount;
1100 ALOGVV("%s: in->ref_buf_frames(%zd), in->config.channels(%d) ",
1101 __func__, in->ref_buf_frames, in->config.channels);
1102 if (in->ref_buf_frames) {
1103 memcpy(in->ref_buf,
1104 in->ref_buf + buf.frameCount * in->config.channels,
1105 in->ref_buf_frames * in->config.channels * sizeof(int16_t));
1106 }
1107 }
1108
put_echo_reference(struct audio_device * adev,struct echo_reference_itfe * reference)1109 static void put_echo_reference(struct audio_device *adev,
1110 struct echo_reference_itfe *reference)
1111 {
1112 ALOGV("%s: enter:)", __func__);
1113 int32_t prev_generation = adev->echo_reference_generation;
1114 struct stream_out *out = adev->primary_output;
1115
1116 if (adev->echo_reference != NULL &&
1117 reference == adev->echo_reference) {
1118 /* echo reference is taken from the low latency output stream used
1119 * for voice use cases */
1120 adev->echo_reference = NULL;
1121 android_atomic_inc(&adev->echo_reference_generation);
1122 if (out != NULL && out->usecase == USECASE_AUDIO_PLAYBACK) {
1123 // if the primary output is in standby or did not pick the echo reference yet
1124 // we can safely get rid of it here.
1125 // otherwise, out_write() or out_standby() will detect the change in echo reference
1126 // generation and release the echo reference owned by the stream.
1127 if ((out->echo_reference_generation != prev_generation) || out->standby)
1128 release_echo_reference(reference);
1129 } else {
1130 release_echo_reference(reference);
1131 }
1132 ALOGV("release_echo_reference");
1133 }
1134 }
1135
get_echo_reference(struct audio_device * adev,audio_format_t format __unused,uint32_t channel_count,uint32_t sampling_rate)1136 static struct echo_reference_itfe *get_echo_reference(struct audio_device *adev,
1137 audio_format_t format __unused,
1138 uint32_t channel_count,
1139 uint32_t sampling_rate)
1140 {
1141 ALOGV("%s: enter:)", __func__);
1142 put_echo_reference(adev, adev->echo_reference);
1143 /* echo reference is taken from the low latency output stream used
1144 * for voice use cases */
1145 if (adev->primary_output!= NULL && adev->primary_output->usecase == USECASE_AUDIO_PLAYBACK &&
1146 !adev->primary_output->standby) {
1147 struct audio_stream *stream =
1148 &adev->primary_output->stream.common;
1149 uint32_t wr_channel_count = audio_channel_count_from_out_mask(stream->get_channels(stream));
1150 uint32_t wr_sampling_rate = stream->get_sample_rate(stream);
1151 ALOGV("Calling create_echo_reference");
1152 int status = create_echo_reference(AUDIO_FORMAT_PCM_16_BIT,
1153 channel_count,
1154 sampling_rate,
1155 AUDIO_FORMAT_PCM_16_BIT,
1156 wr_channel_count,
1157 wr_sampling_rate,
1158 &adev->echo_reference);
1159 if (status == 0)
1160 android_atomic_inc(&adev->echo_reference_generation);
1161 }
1162 return adev->echo_reference;
1163 }
1164
1165 #ifdef HW_AEC_LOOPBACK
get_hw_echo_reference(struct stream_in * in)1166 static int get_hw_echo_reference(struct stream_in *in)
1167 {
1168 struct pcm_device_profile *ref_pcm_profile;
1169 struct pcm_device *ref_device;
1170 struct audio_device *adev = in->dev;
1171
1172 in->hw_echo_reference = false;
1173
1174 if (adev->primary_output!= NULL &&
1175 !adev->primary_output->standby &&
1176 adev->primary_output->usecase == USECASE_AUDIO_PLAYBACK &&
1177 adev->primary_output->devices == AUDIO_DEVICE_OUT_SPEAKER) {
1178 struct audio_stream *stream = &adev->primary_output->stream.common;
1179
1180 ref_pcm_profile = get_pcm_device(PCM_CAPTURE, pcm_device_capture_loopback_aec.devices);
1181 if (ref_pcm_profile == NULL) {
1182 ALOGE("%s: Could not find PCM device id for the usecase(%d)",
1183 __func__, pcm_device_capture_loopback_aec.devices);
1184 return -EINVAL;
1185 }
1186
1187 if (in->input_flags & AUDIO_INPUT_FLAG_FAST) {
1188 ALOGV("%s: change capture period size to low latency size %d",
1189 __func__, CAPTURE_PERIOD_SIZE_LOW_LATENCY);
1190 ref_pcm_profile->config.period_size = CAPTURE_PERIOD_SIZE_LOW_LATENCY;
1191 }
1192
1193 ref_device = (struct pcm_device *)calloc(1, sizeof(struct pcm_device));
1194 ref_device->pcm_profile = ref_pcm_profile;
1195
1196 ALOGV("%s: ref_device rate:%d, ch:%d", __func__, ref_pcm_profile->config.rate, ref_pcm_profile->config.channels);
1197 ref_device->pcm = pcm_open(ref_device->pcm_profile->card, ref_device->pcm_profile->id, PCM_IN | PCM_MONOTONIC, &ref_device->pcm_profile->config);
1198
1199 if (ref_device->pcm && !pcm_is_ready(ref_device->pcm)) {
1200 ALOGE("%s: %s", __func__, pcm_get_error(ref_device->pcm));
1201 pcm_close(ref_device->pcm);
1202 ref_device->pcm = NULL;
1203 return -EIO;
1204 }
1205 list_add_tail(&in->pcm_dev_list, &ref_device->stream_list_node);
1206
1207 in->hw_echo_reference = true;
1208
1209 ALOGV("%s: hw_echo_reference is true", __func__);
1210 }
1211
1212 return 0;
1213 }
1214 #endif
1215
get_playback_delay(struct stream_out * out,size_t frames,struct echo_reference_buffer * buffer)1216 static int get_playback_delay(struct stream_out *out,
1217 size_t frames,
1218 struct echo_reference_buffer *buffer)
1219 {
1220 unsigned int kernel_frames;
1221 int status;
1222 int primary_pcm = 0;
1223 struct pcm_device *pcm_device;
1224
1225 pcm_device = node_to_item(list_head(&out->pcm_dev_list),
1226 struct pcm_device, stream_list_node);
1227
1228 status = pcm_get_htimestamp(pcm_device->pcm, &kernel_frames, &buffer->time_stamp);
1229 if (status < 0) {
1230 buffer->time_stamp.tv_sec = 0;
1231 buffer->time_stamp.tv_nsec = 0;
1232 buffer->delay_ns = 0;
1233 ALOGV("get_playback_delay(): pcm_get_htimestamp error,"
1234 "setting playbackTimestamp to 0");
1235 return status;
1236 }
1237
1238 kernel_frames = pcm_get_buffer_size(pcm_device->pcm) - kernel_frames;
1239
1240 /* adjust render time stamp with delay added by current driver buffer.
1241 * Add the duration of current frame as we want the render time of the last
1242 * sample being written. */
1243 buffer->delay_ns = (long)(((int64_t)(kernel_frames + frames)* 1000000000)/
1244 out->config.rate);
1245 ALOGVV("get_playback_delay_time_stamp Secs: [%10ld], nSecs: [%9ld], kernel_frames: [%5u], delay_ns: [%d],",
1246 buffer->time_stamp.tv_sec, buffer->time_stamp.tv_nsec, kernel_frames, buffer->delay_ns);
1247
1248 return 0;
1249 }
1250
1251 #define GET_COMMAND_STATUS(status, fct_status, cmd_status) \
1252 do { \
1253 if (fct_status != 0) \
1254 status = fct_status; \
1255 else if (cmd_status != 0) \
1256 status = cmd_status; \
1257 } while(0)
1258
in_configure_reverse(struct stream_in * in)1259 static int in_configure_reverse(struct stream_in *in)
1260 {
1261 int32_t cmd_status;
1262 uint32_t size = sizeof(int);
1263 effect_config_t config;
1264 int32_t status = 0;
1265 int32_t fct_status = 0;
1266 int i;
1267 ALOGV("%s: enter: in->num_preprocessors(%d)", __func__, in->num_preprocessors);
1268 if (in->num_preprocessors > 0) {
1269 config.inputCfg.channels = in->main_channels;
1270 config.outputCfg.channels = in->main_channels;
1271 config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
1272 config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
1273 config.inputCfg.samplingRate = in->requested_rate;
1274 config.outputCfg.samplingRate = in->requested_rate;
1275 config.inputCfg.mask =
1276 ( EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT );
1277 config.outputCfg.mask =
1278 ( EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT );
1279
1280 for (i = 0; i < in->num_preprocessors; i++)
1281 {
1282 if ((*in->preprocessors[i].effect_itfe)->process_reverse == NULL)
1283 continue;
1284 fct_status = (*(in->preprocessors[i].effect_itfe))->command(
1285 in->preprocessors[i].effect_itfe,
1286 EFFECT_CMD_SET_CONFIG_REVERSE,
1287 sizeof(effect_config_t),
1288 &config,
1289 &size,
1290 &cmd_status);
1291 ALOGV("%s: calling EFFECT_CMD_SET_CONFIG_REVERSE",__func__);
1292 GET_COMMAND_STATUS(status, fct_status, cmd_status);
1293 }
1294 }
1295 return status;
1296 }
1297
1298 #define MAX_NUM_CHANNEL_CONFIGS 10
1299
in_read_audio_effect_channel_configs(struct stream_in * in __unused,struct effect_info_s * effect_info)1300 static void in_read_audio_effect_channel_configs(struct stream_in *in __unused,
1301 struct effect_info_s *effect_info)
1302 {
1303 /* size and format of the cmd are defined in hardware/audio_effect.h */
1304 effect_handle_t effect = effect_info->effect_itfe;
1305 uint32_t cmd_size = 2 * sizeof(uint32_t);
1306 uint32_t cmd[] = { EFFECT_FEATURE_AUX_CHANNELS, MAX_NUM_CHANNEL_CONFIGS };
1307 /* reply = status + number of configs (n) + n x channel_config_t */
1308 uint32_t reply_size =
1309 2 * sizeof(uint32_t) + (MAX_NUM_CHANNEL_CONFIGS * sizeof(channel_config_t));
1310 int32_t reply[reply_size];
1311 int32_t cmd_status;
1312
1313 ALOG_ASSERT((effect_info->num_channel_configs == 0),
1314 "in_read_audio_effect_channel_configs() num_channel_configs not cleared");
1315 ALOG_ASSERT((effect_info->channel_configs == NULL),
1316 "in_read_audio_effect_channel_configs() channel_configs not cleared");
1317
1318 /* if this command is not supported, then the effect is supposed to return -EINVAL.
1319 * This error will be interpreted as if the effect supports the main_channels but does not
1320 * support any aux_channels */
1321 cmd_status = (*effect)->command(effect,
1322 EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS,
1323 cmd_size,
1324 (void*)&cmd,
1325 &reply_size,
1326 (void*)&reply);
1327
1328 if (cmd_status != 0) {
1329 ALOGV("in_read_audio_effect_channel_configs(): "
1330 "fx->command returned %d", cmd_status);
1331 return;
1332 }
1333
1334 if (reply[0] != 0) {
1335 ALOGW("in_read_audio_effect_channel_configs(): "
1336 "command EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS error %d num configs %d",
1337 reply[0], (reply[0] == -ENOMEM) ? reply[1] : MAX_NUM_CHANNEL_CONFIGS);
1338 return;
1339 }
1340
1341 /* the feature is not supported */
1342 ALOGV("in_read_audio_effect_channel_configs()(): "
1343 "Feature supported and adding %d channel configs to the list", reply[1]);
1344 effect_info->num_channel_configs = reply[1];
1345 effect_info->channel_configs =
1346 (channel_config_t *) malloc(sizeof(channel_config_t) * reply[1]); /* n x configs */
1347 memcpy(effect_info->channel_configs, (reply + 2), sizeof(channel_config_t) * reply[1]);
1348 }
1349
1350
1351 #define NUM_IN_AUX_CNL_CONFIGS 2
1352 channel_config_t in_aux_cnl_configs[NUM_IN_AUX_CNL_CONFIGS] = {
1353 { AUDIO_CHANNEL_IN_FRONT , AUDIO_CHANNEL_IN_BACK},
1354 { AUDIO_CHANNEL_IN_STEREO , AUDIO_CHANNEL_IN_RIGHT}
1355 };
in_get_aux_channels(struct stream_in * in)1356 static uint32_t in_get_aux_channels(struct stream_in *in)
1357 {
1358 int i;
1359 channel_config_t new_chcfg = {0, 0};
1360
1361 if (in->num_preprocessors == 0)
1362 return 0;
1363
1364 /* do not enable dual mic configurations when capturing from other microphones than
1365 * main or sub */
1366 if (!(in->devices & (AUDIO_DEVICE_IN_BUILTIN_MIC | AUDIO_DEVICE_IN_BACK_MIC)))
1367 return 0;
1368
1369 /* retain most complex aux channels configuration compatible with requested main channels and
1370 * supported by audio driver and all pre processors */
1371 for (i = 0; i < NUM_IN_AUX_CNL_CONFIGS; i++) {
1372 channel_config_t *cur_chcfg = &in_aux_cnl_configs[i];
1373 if (cur_chcfg->main_channels == in->main_channels) {
1374 size_t match_cnt;
1375 size_t idx_preproc;
1376 for (idx_preproc = 0, match_cnt = 0;
1377 /* no need to continue if at least one preprocessor doesn't match */
1378 idx_preproc < (size_t)in->num_preprocessors && match_cnt == idx_preproc;
1379 idx_preproc++) {
1380 struct effect_info_s *effect_info = &in->preprocessors[idx_preproc];
1381 size_t idx_chcfg;
1382
1383 for (idx_chcfg = 0; idx_chcfg < effect_info->num_channel_configs; idx_chcfg++) {
1384 if (memcmp(effect_info->channel_configs + idx_chcfg,
1385 cur_chcfg,
1386 sizeof(channel_config_t)) == 0) {
1387 match_cnt++;
1388 break;
1389 }
1390 }
1391 }
1392 /* if all preprocessors match, we have a candidate */
1393 if (match_cnt == (size_t)in->num_preprocessors) {
1394 /* retain most complex aux channels configuration */
1395 if (audio_channel_count_from_in_mask(cur_chcfg->aux_channels) > audio_channel_count_from_in_mask(new_chcfg.aux_channels)) {
1396 new_chcfg = *cur_chcfg;
1397 }
1398 }
1399 }
1400 }
1401
1402 ALOGV("in_get_aux_channels(): return %04x", new_chcfg.aux_channels);
1403
1404 return new_chcfg.aux_channels;
1405 }
1406
in_configure_effect_channels(effect_handle_t effect,channel_config_t * channel_config)1407 static int in_configure_effect_channels(effect_handle_t effect,
1408 channel_config_t *channel_config)
1409 {
1410 int status = 0;
1411 int fct_status;
1412 int32_t cmd_status;
1413 uint32_t reply_size;
1414 effect_config_t config;
1415 uint32_t cmd[(sizeof(uint32_t) + sizeof(channel_config_t) - 1) / sizeof(uint32_t) + 1];
1416
1417 ALOGV("in_configure_effect_channels(): configure effect with channels: [%04x][%04x]",
1418 channel_config->main_channels,
1419 channel_config->aux_channels);
1420
1421 config.inputCfg.mask = EFFECT_CONFIG_CHANNELS;
1422 config.outputCfg.mask = EFFECT_CONFIG_CHANNELS;
1423 reply_size = sizeof(effect_config_t);
1424 fct_status = (*effect)->command(effect,
1425 EFFECT_CMD_GET_CONFIG,
1426 0,
1427 NULL,
1428 &reply_size,
1429 &config);
1430 if (fct_status != 0) {
1431 ALOGE("in_configure_effect_channels(): EFFECT_CMD_GET_CONFIG failed");
1432 return fct_status;
1433 }
1434
1435 config.inputCfg.channels = channel_config->main_channels | channel_config->aux_channels;
1436 config.outputCfg.channels = config.inputCfg.channels;
1437 reply_size = sizeof(uint32_t);
1438 fct_status = (*effect)->command(effect,
1439 EFFECT_CMD_SET_CONFIG,
1440 sizeof(effect_config_t),
1441 &config,
1442 &reply_size,
1443 &cmd_status);
1444 GET_COMMAND_STATUS(status, fct_status, cmd_status);
1445
1446 cmd[0] = EFFECT_FEATURE_AUX_CHANNELS;
1447 memcpy(cmd + 1, channel_config, sizeof(channel_config_t));
1448 reply_size = sizeof(uint32_t);
1449 fct_status = (*effect)->command(effect,
1450 EFFECT_CMD_SET_FEATURE_CONFIG,
1451 sizeof(cmd), //sizeof(uint32_t) + sizeof(channel_config_t),
1452 cmd,
1453 &reply_size,
1454 &cmd_status);
1455 GET_COMMAND_STATUS(status, fct_status, cmd_status);
1456
1457 /* some implementations need to be re-enabled after a config change */
1458 reply_size = sizeof(uint32_t);
1459 fct_status = (*effect)->command(effect,
1460 EFFECT_CMD_ENABLE,
1461 0,
1462 NULL,
1463 &reply_size,
1464 &cmd_status);
1465 GET_COMMAND_STATUS(status, fct_status, cmd_status);
1466
1467 return status;
1468 }
1469
in_reconfigure_channels(struct stream_in * in,effect_handle_t effect,channel_config_t * channel_config,bool config_changed)1470 static int in_reconfigure_channels(struct stream_in *in,
1471 effect_handle_t effect,
1472 channel_config_t *channel_config,
1473 bool config_changed) {
1474
1475 int status = 0;
1476
1477 ALOGV("in_reconfigure_channels(): config_changed %d effect %p",
1478 config_changed, effect);
1479
1480 /* if config changed, reconfigure all previously added effects */
1481 if (config_changed) {
1482 int i;
1483 ALOGV("%s: config_changed (%d)", __func__, config_changed);
1484 for (i = 0; i < in->num_preprocessors; i++)
1485 {
1486 int cur_status = in_configure_effect_channels(in->preprocessors[i].effect_itfe,
1487 channel_config);
1488 ALOGV("%s: in_configure_effect_channels i=(%d), [main_channel,aux_channel]=[%d|%d], status=%d",
1489 __func__, i, channel_config->main_channels, channel_config->aux_channels, cur_status);
1490 if (cur_status != 0) {
1491 ALOGV("in_reconfigure_channels(): error %d configuring effect "
1492 "%d with channels: [%04x][%04x]",
1493 cur_status,
1494 i,
1495 channel_config->main_channels,
1496 channel_config->aux_channels);
1497 status = cur_status;
1498 }
1499 }
1500 } else if (effect != NULL && channel_config->aux_channels) {
1501 /* if aux channels config did not change but aux channels are present,
1502 * we still need to configure the effect being added */
1503 status = in_configure_effect_channels(effect, channel_config);
1504 }
1505 return status;
1506 }
1507
in_update_aux_channels(struct stream_in * in,effect_handle_t effect)1508 static void in_update_aux_channels(struct stream_in *in,
1509 effect_handle_t effect)
1510 {
1511 uint32_t aux_channels;
1512 channel_config_t channel_config;
1513 int status;
1514
1515 aux_channels = in_get_aux_channels(in);
1516
1517 channel_config.main_channels = in->main_channels;
1518 channel_config.aux_channels = aux_channels;
1519 status = in_reconfigure_channels(in,
1520 effect,
1521 &channel_config,
1522 (aux_channels != in->aux_channels));
1523
1524 if (status != 0) {
1525 ALOGV("in_update_aux_channels(): in_reconfigure_channels error %d", status);
1526 /* resetting aux channels configuration */
1527 aux_channels = 0;
1528 channel_config.aux_channels = 0;
1529 in_reconfigure_channels(in, effect, &channel_config, true);
1530 }
1531 ALOGV("%s: aux_channels=%d, in->aux_channels_changed=%d", __func__, aux_channels, in->aux_channels_changed);
1532 if (in->aux_channels != aux_channels) {
1533 in->aux_channels_changed = true;
1534 in->aux_channels = aux_channels;
1535 do_in_standby_l(in);
1536 }
1537 }
1538 #endif
1539
1540 /* This function reads PCM data and:
1541 * - resample if needed
1542 * - process if pre-processors are attached
1543 * - discard unwanted channels
1544 */
read_and_process_frames(struct stream_in * in,void * buffer,ssize_t frames)1545 static ssize_t read_and_process_frames(struct stream_in *in, void* buffer, ssize_t frames)
1546 {
1547 ssize_t frames_wr = 0;
1548 audio_buffer_t in_buf;
1549 audio_buffer_t out_buf;
1550 size_t src_channels = in->config.channels;
1551 size_t dst_channels = audio_channel_count_from_in_mask(in->main_channels);
1552 int i;
1553 void *proc_buf_out;
1554 struct pcm_device *pcm_device;
1555 bool has_additional_channels = (dst_channels != src_channels) ? true : false;
1556 #ifdef PREPROCESSING_ENABLED
1557 bool has_processing = (in->num_preprocessors != 0) ? true : false;
1558 #endif
1559
1560 /* Additional channels might be added on top of main_channels:
1561 * - aux_channels (by processing effects)
1562 * - extra channels due to HW limitations
1563 * In case of additional channels, we cannot work inplace
1564 */
1565 if (has_additional_channels)
1566 proc_buf_out = in->proc_buf_out;
1567 else
1568 proc_buf_out = buffer;
1569
1570 if (list_empty(&in->pcm_dev_list)) {
1571 ALOGE("%s: pcm device list empty", __func__);
1572 return -EINVAL;
1573 }
1574
1575 pcm_device = node_to_item(list_head(&in->pcm_dev_list),
1576 struct pcm_device, stream_list_node);
1577
1578 #ifdef PREPROCESSING_ENABLED
1579 if (has_processing) {
1580 /* since all the processing below is done in frames and using the config.channels
1581 * as the number of channels, no changes is required in case aux_channels are present */
1582 while (frames_wr < frames) {
1583 /* first reload enough frames at the end of process input buffer */
1584 if (in->proc_buf_frames < (size_t)frames) {
1585 ssize_t frames_rd;
1586 if (in->proc_buf_size < (size_t)frames) {
1587 size_t size_in_bytes = pcm_frames_to_bytes(pcm_device->pcm, frames);
1588 in->proc_buf_size = (size_t)frames;
1589 in->proc_buf_in = (int16_t *)realloc(in->proc_buf_in, size_in_bytes);
1590 ALOG_ASSERT((in->proc_buf_in != NULL),
1591 "process_frames() failed to reallocate proc_buf_in");
1592 if (has_additional_channels) {
1593 in->proc_buf_out = (int16_t *)realloc(in->proc_buf_out, size_in_bytes);
1594 ALOG_ASSERT((in->proc_buf_out != NULL),
1595 "process_frames() failed to reallocate proc_buf_out");
1596 proc_buf_out = in->proc_buf_out;
1597 }
1598 }
1599 frames_rd = read_frames(in,
1600 in->proc_buf_in +
1601 in->proc_buf_frames * in->config.channels,
1602 frames - in->proc_buf_frames);
1603 if (frames_rd < 0) {
1604 /* Return error code */
1605 frames_wr = frames_rd;
1606 break;
1607 }
1608 in->proc_buf_frames += frames_rd;
1609 }
1610
1611 if (in->echo_reference != NULL) {
1612 push_echo_reference(in, in->proc_buf_frames);
1613 }
1614
1615 /* in_buf.frameCount and out_buf.frameCount indicate respectively
1616 * the maximum number of frames to be consumed and produced by process() */
1617 in_buf.frameCount = in->proc_buf_frames;
1618 in_buf.s16 = in->proc_buf_in;
1619 out_buf.frameCount = frames - frames_wr;
1620 out_buf.s16 = (int16_t *)proc_buf_out + frames_wr * in->config.channels;
1621
1622 /* FIXME: this works because of current pre processing library implementation that
1623 * does the actual process only when the last enabled effect process is called.
1624 * The generic solution is to have an output buffer for each effect and pass it as
1625 * input to the next.
1626 */
1627 for (i = 0; i < in->num_preprocessors; i++) {
1628 (*in->preprocessors[i].effect_itfe)->process(in->preprocessors[i].effect_itfe,
1629 &in_buf,
1630 &out_buf);
1631 }
1632
1633 /* process() has updated the number of frames consumed and produced in
1634 * in_buf.frameCount and out_buf.frameCount respectively
1635 * move remaining frames to the beginning of in->proc_buf_in */
1636 in->proc_buf_frames -= in_buf.frameCount;
1637
1638 if (in->proc_buf_frames) {
1639 memcpy(in->proc_buf_in,
1640 in->proc_buf_in + in_buf.frameCount * in->config.channels,
1641 in->proc_buf_frames * in->config.channels * sizeof(int16_t));
1642 }
1643
1644 /* if not enough frames were passed to process(), read more and retry. */
1645 if (out_buf.frameCount == 0) {
1646 ALOGW("No frames produced by preproc");
1647 continue;
1648 }
1649
1650 if ((frames_wr + (ssize_t)out_buf.frameCount) <= frames) {
1651 frames_wr += out_buf.frameCount;
1652 } else {
1653 /* The effect does not comply to the API. In theory, we should never end up here! */
1654 ALOGE("preprocessing produced too many frames: %d + %zd > %d !",
1655 (unsigned int)frames_wr, out_buf.frameCount, (unsigned int)frames);
1656 frames_wr = frames;
1657 }
1658 }
1659 }
1660 else
1661 #endif //PREPROCESSING_ENABLED
1662 {
1663 /* No processing effects attached */
1664 if (has_additional_channels) {
1665 /* With additional channels, we cannot use original buffer */
1666 if (in->proc_buf_size < (size_t)frames) {
1667 size_t size_in_bytes = pcm_frames_to_bytes(pcm_device->pcm, frames);
1668 in->proc_buf_size = (size_t)frames;
1669 in->proc_buf_out = (int16_t *)realloc(in->proc_buf_out, size_in_bytes);
1670 ALOG_ASSERT((in->proc_buf_out != NULL),
1671 "process_frames() failed to reallocate proc_buf_out");
1672 proc_buf_out = in->proc_buf_out;
1673 }
1674 }
1675 frames_wr = read_frames(in, proc_buf_out, frames);
1676 }
1677
1678 /* Remove all additional channels that have been added on top of main_channels:
1679 * - aux_channels
1680 * - extra channels from HW due to HW limitations
1681 * Assumption is made that the channels are interleaved and that the main
1682 * channels are first. */
1683
1684 if (has_additional_channels)
1685 {
1686 int16_t* src_buffer = (int16_t *)proc_buf_out;
1687 int16_t* dst_buffer = (int16_t *)buffer;
1688
1689 if (dst_channels == 1) {
1690 for (i = frames_wr; i > 0; i--)
1691 {
1692 *dst_buffer++ = *src_buffer;
1693 src_buffer += src_channels;
1694 }
1695 } else {
1696 for (i = frames_wr; i > 0; i--)
1697 {
1698 memcpy(dst_buffer, src_buffer, dst_channels*sizeof(int16_t));
1699 dst_buffer += dst_channels;
1700 src_buffer += src_channels;
1701 }
1702 }
1703 }
1704
1705 return frames_wr;
1706 }
1707
get_next_buffer(struct resampler_buffer_provider * buffer_provider,struct resampler_buffer * buffer)1708 static int get_next_buffer(struct resampler_buffer_provider *buffer_provider,
1709 struct resampler_buffer* buffer)
1710 {
1711 struct stream_in *in;
1712 struct pcm_device *pcm_device;
1713
1714 if (buffer_provider == NULL || buffer == NULL)
1715 return -EINVAL;
1716
1717 in = (struct stream_in *)((char *)buffer_provider -
1718 offsetof(struct stream_in, buf_provider));
1719
1720 if (list_empty(&in->pcm_dev_list)) {
1721 buffer->raw = NULL;
1722 buffer->frame_count = 0;
1723 in->read_status = -ENODEV;
1724 return -ENODEV;
1725 }
1726
1727 pcm_device = node_to_item(list_head(&in->pcm_dev_list),
1728 struct pcm_device, stream_list_node);
1729
1730 if (in->read_buf_frames == 0) {
1731 size_t size_in_bytes = pcm_frames_to_bytes(pcm_device->pcm, in->config.period_size);
1732 if (in->read_buf_size < in->config.period_size) {
1733 in->read_buf_size = in->config.period_size;
1734 in->read_buf = (int16_t *) realloc(in->read_buf, size_in_bytes);
1735 ALOG_ASSERT((in->read_buf != NULL),
1736 "get_next_buffer() failed to reallocate read_buf");
1737 }
1738
1739 in->read_status = pcm_read(pcm_device->pcm, (void*)in->read_buf, size_in_bytes);
1740
1741 if (in->read_status != 0) {
1742 ALOGE("get_next_buffer() pcm_read error %d", in->read_status);
1743 buffer->raw = NULL;
1744 buffer->frame_count = 0;
1745 return in->read_status;
1746 }
1747 in->read_buf_frames = in->config.period_size;
1748
1749 #ifdef PREPROCESSING_ENABLED
1750 #ifdef HW_AEC_LOOPBACK
1751 if (in->hw_echo_reference) {
1752 struct pcm_device *temp_device = NULL;
1753 struct pcm_device *ref_device = NULL;
1754 struct listnode *node = NULL;
1755 struct echo_reference_buffer b;
1756 size_t size_hw_ref_bytes;
1757 size_t size_hw_ref_frames;
1758 int read_status = 0;
1759
1760 ref_device = node_to_item(list_tail(&in->pcm_dev_list),
1761 struct pcm_device, stream_list_node);
1762 list_for_each(node, &in->pcm_dev_list) {
1763 temp_device = node_to_item(node, struct pcm_device, stream_list_node);
1764 if (temp_device->pcm_profile->id == 1) {
1765 ref_device = temp_device;
1766 break;
1767 }
1768 }
1769 if (ref_device) {
1770 size_hw_ref_bytes = pcm_frames_to_bytes(ref_device->pcm, ref_device->pcm_profile->config.period_size);
1771 size_hw_ref_frames = ref_device->pcm_profile->config.period_size;
1772 if (in->hw_ref_buf_size < size_hw_ref_frames) {
1773 in->hw_ref_buf_size = size_hw_ref_frames;
1774 in->hw_ref_buf = (int16_t *) realloc(in->hw_ref_buf, size_hw_ref_bytes);
1775 ALOG_ASSERT((in->hw_ref_buf != NULL),
1776 "get_next_buffer() failed to reallocate hw_ref_buf");
1777 ALOGV("get_next_buffer(): hw_ref_buf %p extended to %zd bytes",
1778 in->hw_ref_buf, size_hw_ref_bytes);
1779 }
1780
1781 read_status = pcm_read(ref_device->pcm, (void*)in->hw_ref_buf, size_hw_ref_bytes);
1782 if (read_status != 0) {
1783 ALOGE("process_frames() pcm_read error for HW reference %d", read_status);
1784 b.raw = NULL;
1785 b.frame_count = 0;
1786 }
1787 else {
1788 get_capture_reference_delay(in, size_hw_ref_frames, &b);
1789 b.raw = (void *)in->hw_ref_buf;
1790 b.frame_count = size_hw_ref_frames;
1791 if (b.delay_ns != 0)
1792 b.delay_ns = -b.delay_ns; // as this is capture delay, it needs to be subtracted from the microphone delay
1793 in->echo_reference->write(in->echo_reference, &b);
1794 }
1795 }
1796 }
1797 #endif // HW_AEC_LOOPBACK
1798 #endif // PREPROCESSING_ENABLED
1799 }
1800
1801 buffer->frame_count = (buffer->frame_count > in->read_buf_frames) ?
1802 in->read_buf_frames : buffer->frame_count;
1803 buffer->i16 = in->read_buf + (in->config.period_size - in->read_buf_frames) *
1804 in->config.channels;
1805 return in->read_status;
1806 }
1807
release_buffer(struct resampler_buffer_provider * buffer_provider,struct resampler_buffer * buffer)1808 static void release_buffer(struct resampler_buffer_provider *buffer_provider,
1809 struct resampler_buffer* buffer)
1810 {
1811 struct stream_in *in;
1812
1813 if (buffer_provider == NULL || buffer == NULL)
1814 return;
1815
1816 in = (struct stream_in *)((char *)buffer_provider -
1817 offsetof(struct stream_in, buf_provider));
1818
1819 in->read_buf_frames -= buffer->frame_count;
1820 }
1821
1822 /* read_frames() reads frames from kernel driver, down samples to capture rate
1823 * if necessary and output the number of frames requested to the buffer specified */
read_frames(struct stream_in * in,void * buffer,ssize_t frames)1824 static ssize_t read_frames(struct stream_in *in, void *buffer, ssize_t frames)
1825 {
1826 ssize_t frames_wr = 0;
1827
1828 struct pcm_device *pcm_device;
1829
1830 if (list_empty(&in->pcm_dev_list)) {
1831 ALOGE("%s: pcm device list empty", __func__);
1832 return -EINVAL;
1833 }
1834
1835 pcm_device = node_to_item(list_head(&in->pcm_dev_list),
1836 struct pcm_device, stream_list_node);
1837
1838 while (frames_wr < frames) {
1839 size_t frames_rd = frames - frames_wr;
1840 ALOGVV("%s: frames_rd: %zd, frames_wr: %zd, in->config.channels: %d",
1841 __func__,frames_rd,frames_wr,in->config.channels);
1842 if (in->resampler != NULL) {
1843 in->resampler->resample_from_provider(in->resampler,
1844 (int16_t *)((char *)buffer +
1845 pcm_frames_to_bytes(pcm_device->pcm, frames_wr)),
1846 &frames_rd);
1847 } else {
1848 struct resampler_buffer buf = {
1849 { raw : NULL, },
1850 frame_count : frames_rd,
1851 };
1852 get_next_buffer(&in->buf_provider, &buf);
1853 if (buf.raw != NULL) {
1854 memcpy((char *)buffer +
1855 pcm_frames_to_bytes(pcm_device->pcm, frames_wr),
1856 buf.raw,
1857 pcm_frames_to_bytes(pcm_device->pcm, buf.frame_count));
1858 frames_rd = buf.frame_count;
1859 }
1860 release_buffer(&in->buf_provider, &buf);
1861 }
1862 /* in->read_status is updated by getNextBuffer() also called by
1863 * in->resampler->resample_from_provider() */
1864 if (in->read_status != 0)
1865 return in->read_status;
1866
1867 frames_wr += frames_rd;
1868 }
1869 return frames_wr;
1870 }
1871
in_release_pcm_devices(struct stream_in * in)1872 static int in_release_pcm_devices(struct stream_in *in)
1873 {
1874 struct pcm_device *pcm_device;
1875 struct listnode *node;
1876 struct listnode *next;
1877
1878 list_for_each_safe(node, next, &in->pcm_dev_list) {
1879 pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
1880 list_remove(node);
1881 free(pcm_device);
1882 }
1883
1884 return 0;
1885 }
1886
stop_input_stream(struct stream_in * in)1887 static int stop_input_stream(struct stream_in *in)
1888 {
1889 struct audio_usecase *uc_info;
1890 struct audio_device *adev = in->dev;
1891
1892 adev->active_input = NULL;
1893 ALOGV("%s: enter: usecase(%d: %s)", __func__,
1894 in->usecase, use_case_table[in->usecase]);
1895 uc_info = get_usecase_from_id(adev, in->usecase);
1896 if (uc_info == NULL) {
1897 ALOGE("%s: Could not find the usecase (%d) in the list",
1898 __func__, in->usecase);
1899 return -EINVAL;
1900 }
1901
1902 /* Disable the tx device */
1903 disable_snd_device(adev, uc_info, uc_info->in_snd_device, true);
1904
1905 list_remove(&uc_info->adev_list_node);
1906 free(uc_info);
1907
1908 if (list_empty(&in->pcm_dev_list)) {
1909 ALOGE("%s: pcm device list empty", __func__);
1910 return -EINVAL;
1911 }
1912
1913 in_release_pcm_devices(in);
1914 list_init(&in->pcm_dev_list);
1915
1916 #ifdef HW_AEC_LOOPBACK
1917 if (in->hw_echo_reference)
1918 {
1919 in->hw_echo_reference = false;
1920 }
1921 #endif
1922
1923 ALOGV("%s: exit", __func__);
1924 return 0;
1925 }
1926
start_input_stream(struct stream_in * in)1927 int start_input_stream(struct stream_in *in)
1928 {
1929 /* Enable output device and stream routing controls */
1930 int ret = 0;
1931 bool recreate_resampler = false;
1932 struct audio_usecase *uc_info;
1933 struct audio_device *adev = in->dev;
1934 struct pcm_device_profile *pcm_profile;
1935 struct pcm_device *pcm_device;
1936
1937 ALOGV("%s: enter: usecase(%d)", __func__, in->usecase);
1938 adev->active_input = in;
1939 pcm_profile = get_pcm_device(in->usecase == USECASE_AUDIO_CAPTURE_HOTWORD
1940 ? PCM_HOTWORD_STREAMING : PCM_CAPTURE, in->devices);
1941 if (pcm_profile == NULL) {
1942 ALOGE("%s: Could not find PCM device id for the usecase(%d)",
1943 __func__, in->usecase);
1944 ret = -EINVAL;
1945 goto error_config;
1946 }
1947
1948 if (in->input_flags & AUDIO_INPUT_FLAG_FAST) {
1949 ALOGV("%s: change capture period size to low latency size %d",
1950 __func__, CAPTURE_PERIOD_SIZE_LOW_LATENCY);
1951 pcm_profile->config.period_size = CAPTURE_PERIOD_SIZE_LOW_LATENCY;
1952 }
1953
1954 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
1955 uc_info->id = in->usecase;
1956 uc_info->type = PCM_CAPTURE;
1957 uc_info->stream = (struct audio_stream *)in;
1958 uc_info->devices = in->devices;
1959 uc_info->in_snd_device = SND_DEVICE_NONE;
1960 uc_info->out_snd_device = SND_DEVICE_NONE;
1961
1962 pcm_device = (struct pcm_device *)calloc(1, sizeof(struct pcm_device));
1963 pcm_device->pcm_profile = pcm_profile;
1964 list_init(&in->pcm_dev_list);
1965 list_add_tail(&in->pcm_dev_list, &pcm_device->stream_list_node);
1966
1967 list_init(&uc_info->mixer_list);
1968 list_add_tail(&uc_info->mixer_list,
1969 &adev_get_mixer_for_card(adev,
1970 pcm_device->pcm_profile->card)->uc_list_node[uc_info->id]);
1971
1972 list_add_tail(&adev->usecase_list, &uc_info->adev_list_node);
1973
1974 select_devices(adev, in->usecase);
1975
1976 /* Config should be updated as profile can be changed between different calls
1977 * to this function:
1978 * - Trigger resampler creation
1979 * - Config needs to be updated */
1980 if (in->config.rate != pcm_profile->config.rate) {
1981 recreate_resampler = true;
1982 }
1983 in->config = pcm_profile->config;
1984
1985 #ifdef PREPROCESSING_ENABLED
1986 if (in->aux_channels_changed) {
1987 in->config.channels = audio_channel_count_from_in_mask(in->main_channels | in->aux_channels);
1988 recreate_resampler = true;
1989 }
1990 #endif
1991
1992 if (in->requested_rate != in->config.rate) {
1993 recreate_resampler = true;
1994 }
1995
1996 if (recreate_resampler) {
1997 if (in->resampler) {
1998 release_resampler(in->resampler);
1999 in->resampler = NULL;
2000 }
2001 in->buf_provider.get_next_buffer = get_next_buffer;
2002 in->buf_provider.release_buffer = release_buffer;
2003 ret = create_resampler(in->config.rate,
2004 in->requested_rate,
2005 in->config.channels,
2006 RESAMPLER_QUALITY_DEFAULT,
2007 &in->buf_provider,
2008 &in->resampler);
2009 }
2010
2011 #ifdef PREPROCESSING_ENABLED
2012 if (in->enable_aec && in->echo_reference == NULL) {
2013 in->echo_reference = get_echo_reference(adev,
2014 AUDIO_FORMAT_PCM_16_BIT,
2015 audio_channel_count_from_in_mask(in->main_channels),
2016 in->requested_rate
2017 );
2018 }
2019
2020 #ifdef HW_AEC_LOOPBACK
2021 if (in->enable_aec) {
2022 ret = get_hw_echo_reference(in);
2023 if (ret!=0)
2024 goto error_open;
2025
2026 /* force ref buffer reallocation */
2027 in->hw_ref_buf_size = 0;
2028 }
2029 #endif
2030 #endif
2031
2032 /* Open the PCM device.
2033 * The HW is limited to support only the default pcm_profile settings.
2034 * As such a change in aux_channels will not have an effect.
2035 */
2036 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d, smp rate %d format %d, \
2037 period_size %d", __func__, pcm_device->pcm_profile->card, pcm_device->pcm_profile->id,
2038 pcm_device->pcm_profile->config.channels,pcm_device->pcm_profile->config.rate,
2039 pcm_device->pcm_profile->config.format, pcm_device->pcm_profile->config.period_size);
2040
2041 if (pcm_profile->type == PCM_HOTWORD_STREAMING) {
2042 if (!adev->sound_trigger_open_for_streaming) {
2043 ALOGE("%s: No handle to sound trigger HAL", __func__);
2044 ret = -EIO;
2045 goto error_open;
2046 }
2047 pcm_device->pcm = NULL;
2048 pcm_device->sound_trigger_handle = adev->sound_trigger_open_for_streaming();
2049 if (pcm_device->sound_trigger_handle <= 0) {
2050 ALOGE("%s: Failed to open DSP for streaming", __func__);
2051 ret = -EIO;
2052 goto error_open;
2053 }
2054 ALOGV("Opened DSP successfully");
2055 } else {
2056 pcm_device->sound_trigger_handle = 0;
2057 pcm_device->pcm = pcm_open(pcm_device->pcm_profile->card, pcm_device->pcm_profile->id,
2058 PCM_IN | PCM_MONOTONIC, &pcm_device->pcm_profile->config);
2059
2060 if (pcm_device->pcm && !pcm_is_ready(pcm_device->pcm)) {
2061 ALOGE("%s: %s", __func__, pcm_get_error(pcm_device->pcm));
2062 pcm_close(pcm_device->pcm);
2063 pcm_device->pcm = NULL;
2064 ret = -EIO;
2065 goto error_open;
2066 }
2067 }
2068
2069 /* force read and proc buffer reallocation in case of frame size or
2070 * channel count change */
2071 in->proc_buf_frames = 0;
2072 in->proc_buf_size = 0;
2073 in->read_buf_size = 0;
2074 in->read_buf_frames = 0;
2075
2076 /* if no supported sample rate is available, use the resampler */
2077 if (in->resampler) {
2078 in->resampler->reset(in->resampler);
2079 }
2080
2081 ALOGV("%s: exit", __func__);
2082 return ret;
2083
2084 error_open:
2085 if (in->resampler) {
2086 release_resampler(in->resampler);
2087 in->resampler = NULL;
2088 }
2089 stop_input_stream(in);
2090
2091 error_config:
2092 ALOGD("%s: exit: status(%d)", __func__, ret);
2093 adev->active_input = NULL;
2094 return ret;
2095 }
2096
2097 /* must be called with out->lock locked */
send_offload_cmd_l(struct stream_out * out,int command)2098 static int send_offload_cmd_l(struct stream_out* out, int command)
2099 {
2100 struct offload_cmd *cmd = (struct offload_cmd *)calloc(1, sizeof(struct offload_cmd));
2101
2102 ALOGVV("%s %d", __func__, command);
2103
2104 cmd->cmd = command;
2105 list_add_tail(&out->offload_cmd_list, &cmd->node);
2106 pthread_cond_signal(&out->offload_cond);
2107 return 0;
2108 }
2109
2110 /* must be called iwth out->lock locked */
stop_compressed_output_l(struct stream_out * out)2111 static void stop_compressed_output_l(struct stream_out *out)
2112 {
2113 out->send_new_metadata = 1;
2114 if (out->compr != NULL) {
2115 compress_stop(out->compr);
2116 while (out->offload_thread_blocked) {
2117 pthread_cond_wait(&out->cond, &out->lock);
2118 }
2119 }
2120 }
2121
offload_thread_loop(void * context)2122 static void *offload_thread_loop(void *context)
2123 {
2124 struct stream_out *out = (struct stream_out *) context;
2125 struct listnode *item;
2126
2127 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
2128 set_sched_policy(0, SP_FOREGROUND);
2129 prctl(PR_SET_NAME, (unsigned long)"Offload Callback", 0, 0, 0);
2130
2131 ALOGV("%s", __func__);
2132 pthread_mutex_lock(&out->lock);
2133 for (;;) {
2134 struct offload_cmd *cmd = NULL;
2135 stream_callback_event_t event;
2136 bool send_callback = false;
2137
2138 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
2139 __func__, list_empty(&out->offload_cmd_list),
2140 out->offload_state);
2141 if (list_empty(&out->offload_cmd_list)) {
2142 ALOGV("%s SLEEPING", __func__);
2143 pthread_cond_wait(&out->offload_cond, &out->lock);
2144 ALOGV("%s RUNNING", __func__);
2145 continue;
2146 }
2147
2148 item = list_head(&out->offload_cmd_list);
2149 cmd = node_to_item(item, struct offload_cmd, node);
2150 list_remove(item);
2151
2152 ALOGVV("%s STATE %d CMD %d out->compr %p",
2153 __func__, out->offload_state, cmd->cmd, out->compr);
2154
2155 if (cmd->cmd == OFFLOAD_CMD_EXIT) {
2156 free(cmd);
2157 break;
2158 }
2159
2160 if (out->compr == NULL) {
2161 ALOGE("%s: Compress handle is NULL", __func__);
2162 pthread_cond_signal(&out->cond);
2163 continue;
2164 }
2165 out->offload_thread_blocked = true;
2166 pthread_mutex_unlock(&out->lock);
2167 send_callback = false;
2168 switch(cmd->cmd) {
2169 case OFFLOAD_CMD_WAIT_FOR_BUFFER:
2170 compress_wait(out->compr, -1);
2171 send_callback = true;
2172 event = STREAM_CBK_EVENT_WRITE_READY;
2173 break;
2174 case OFFLOAD_CMD_PARTIAL_DRAIN:
2175 compress_next_track(out->compr);
2176 compress_partial_drain(out->compr);
2177 send_callback = true;
2178 event = STREAM_CBK_EVENT_DRAIN_READY;
2179 break;
2180 case OFFLOAD_CMD_DRAIN:
2181 compress_drain(out->compr);
2182 send_callback = true;
2183 event = STREAM_CBK_EVENT_DRAIN_READY;
2184 break;
2185 default:
2186 ALOGE("%s unknown command received: %d", __func__, cmd->cmd);
2187 break;
2188 }
2189 pthread_mutex_lock(&out->lock);
2190 out->offload_thread_blocked = false;
2191 pthread_cond_signal(&out->cond);
2192 if (send_callback) {
2193 out->offload_callback(event, NULL, out->offload_cookie);
2194 }
2195 free(cmd);
2196 }
2197
2198 pthread_cond_signal(&out->cond);
2199 while (!list_empty(&out->offload_cmd_list)) {
2200 item = list_head(&out->offload_cmd_list);
2201 list_remove(item);
2202 free(node_to_item(item, struct offload_cmd, node));
2203 }
2204 pthread_mutex_unlock(&out->lock);
2205
2206 return NULL;
2207 }
2208
create_offload_callback_thread(struct stream_out * out)2209 static int create_offload_callback_thread(struct stream_out *out)
2210 {
2211 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
2212 list_init(&out->offload_cmd_list);
2213 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
2214 offload_thread_loop, out);
2215 return 0;
2216 }
2217
destroy_offload_callback_thread(struct stream_out * out)2218 static int destroy_offload_callback_thread(struct stream_out *out)
2219 {
2220 pthread_mutex_lock(&out->lock);
2221 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
2222
2223 pthread_mutex_unlock(&out->lock);
2224 pthread_join(out->offload_thread, (void **) NULL);
2225 pthread_cond_destroy(&out->offload_cond);
2226
2227 return 0;
2228 }
2229
uc_release_pcm_devices(struct audio_usecase * usecase)2230 static int uc_release_pcm_devices(struct audio_usecase *usecase)
2231 {
2232 struct stream_out *out = (struct stream_out *)usecase->stream;
2233 struct pcm_device *pcm_device;
2234 struct listnode *node;
2235 struct listnode *next;
2236
2237 list_for_each_safe(node, next, &out->pcm_dev_list) {
2238 pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
2239 list_remove(node);
2240 free(pcm_device);
2241 }
2242 list_init(&usecase->mixer_list);
2243
2244 return 0;
2245 }
2246
uc_select_pcm_devices(struct audio_usecase * usecase)2247 static int uc_select_pcm_devices(struct audio_usecase *usecase)
2248
2249 {
2250 struct stream_out *out = (struct stream_out *)usecase->stream;
2251 struct pcm_device *pcm_device;
2252 struct pcm_device_profile *pcm_profile;
2253 struct mixer_card *mixer_card;
2254 audio_devices_t devices = usecase->devices;
2255
2256 list_init(&usecase->mixer_list);
2257 list_init(&out->pcm_dev_list);
2258
2259 while ((pcm_profile = get_pcm_device(usecase->type, devices)) != NULL) {
2260 pcm_device = calloc(1, sizeof(struct pcm_device));
2261 pcm_device->pcm_profile = pcm_profile;
2262 list_add_tail(&out->pcm_dev_list, &pcm_device->stream_list_node);
2263 mixer_card = uc_get_mixer_for_card(usecase, pcm_profile->card);
2264 if (mixer_card == NULL) {
2265 mixer_card = adev_get_mixer_for_card(out->dev, pcm_profile->card);
2266 list_add_tail(&usecase->mixer_list, &mixer_card->uc_list_node[usecase->id]);
2267 }
2268 devices &= ~pcm_profile->devices;
2269 }
2270
2271 return 0;
2272 }
2273
out_close_pcm_devices(struct stream_out * out)2274 static int out_close_pcm_devices(struct stream_out *out)
2275 {
2276 struct pcm_device *pcm_device;
2277 struct listnode *node;
2278 struct audio_device *adev = out->dev;
2279
2280 list_for_each(node, &out->pcm_dev_list) {
2281 pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
2282 if (pcm_device->sound_trigger_handle > 0) {
2283 adev->sound_trigger_close_for_streaming(pcm_device->sound_trigger_handle);
2284 pcm_device->sound_trigger_handle = 0;
2285 }
2286 if (pcm_device->pcm) {
2287 pcm_close(pcm_device->pcm);
2288 pcm_device->pcm = NULL;
2289 }
2290 if (pcm_device->resampler) {
2291 release_resampler(pcm_device->resampler);
2292 pcm_device->resampler = NULL;
2293 }
2294 if (pcm_device->res_buffer) {
2295 free(pcm_device->res_buffer);
2296 pcm_device->res_buffer = NULL;
2297 }
2298 }
2299
2300 return 0;
2301 }
2302
out_open_pcm_devices(struct stream_out * out)2303 static int out_open_pcm_devices(struct stream_out *out)
2304 {
2305 struct pcm_device *pcm_device;
2306 struct listnode *node;
2307 int ret = 0;
2308
2309 list_for_each(node, &out->pcm_dev_list) {
2310 pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
2311 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d)",
2312 __func__, pcm_device->pcm_profile->card, pcm_device->pcm_profile->id);
2313
2314 pcm_device->pcm = pcm_open(pcm_device->pcm_profile->card, pcm_device->pcm_profile->id,
2315 PCM_OUT | PCM_MONOTONIC, &pcm_device->pcm_profile->config);
2316
2317 if (pcm_device->pcm && !pcm_is_ready(pcm_device->pcm)) {
2318 ALOGE("%s: %s", __func__, pcm_get_error(pcm_device->pcm));
2319 pcm_device->pcm = NULL;
2320 ret = -EIO;
2321 goto error_open;
2322 }
2323 /*
2324 * If the stream rate differs from the PCM rate, we need to
2325 * create a resampler.
2326 */
2327 if (out->sample_rate != pcm_device->pcm_profile->config.rate) {
2328 ALOGV("%s: create_resampler(), pcm_device_card(%d), pcm_device_id(%d), \
2329 out_rate(%d), device_rate(%d)",__func__,
2330 pcm_device->pcm_profile->card, pcm_device->pcm_profile->id,
2331 out->sample_rate, pcm_device->pcm_profile->config.rate);
2332 ret = create_resampler(out->sample_rate,
2333 pcm_device->pcm_profile->config.rate,
2334 audio_channel_count_from_out_mask(out->channel_mask),
2335 RESAMPLER_QUALITY_DEFAULT,
2336 NULL,
2337 &pcm_device->resampler);
2338 pcm_device->res_byte_count = 0;
2339 pcm_device->res_buffer = NULL;
2340 }
2341 }
2342 return ret;
2343
2344 error_open:
2345 out_close_pcm_devices(out);
2346 return ret;
2347 }
2348
disable_output_path_l(struct stream_out * out)2349 static int disable_output_path_l(struct stream_out *out)
2350 {
2351 struct audio_device *adev = out->dev;
2352 struct audio_usecase *uc_info;
2353
2354 uc_info = get_usecase_from_id(adev, out->usecase);
2355 if (uc_info == NULL) {
2356 ALOGE("%s: Could not find the usecase (%d) in the list",
2357 __func__, out->usecase);
2358 return -EINVAL;
2359 }
2360 disable_snd_device(adev, uc_info, uc_info->out_snd_device, true);
2361 uc_release_pcm_devices(uc_info);
2362 list_remove(&uc_info->adev_list_node);
2363 free(uc_info);
2364
2365 return 0;
2366 }
2367
enable_output_path_l(struct stream_out * out)2368 static void enable_output_path_l(struct stream_out *out)
2369 {
2370 struct audio_device *adev = out->dev;
2371 struct audio_usecase *uc_info;
2372
2373 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
2374 uc_info->id = out->usecase;
2375 uc_info->type = PCM_PLAYBACK;
2376 uc_info->stream = (struct audio_stream *)out;
2377 uc_info->devices = out->devices;
2378 uc_info->in_snd_device = SND_DEVICE_NONE;
2379 uc_info->out_snd_device = SND_DEVICE_NONE;
2380 uc_select_pcm_devices(uc_info);
2381
2382 list_add_tail(&adev->usecase_list, &uc_info->adev_list_node);
2383
2384 select_devices(adev, out->usecase);
2385 }
2386
stop_output_stream(struct stream_out * out)2387 static int stop_output_stream(struct stream_out *out)
2388 {
2389 int ret = 0;
2390 struct audio_device *adev = out->dev;
2391 bool do_disable = true;
2392
2393 ALOGV("%s: enter: usecase(%d: %s)", __func__,
2394 out->usecase, use_case_table[out->usecase]);
2395
2396 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD &&
2397 adev->offload_fx_stop_output != NULL) {
2398 adev->offload_fx_stop_output(out->handle);
2399
2400 if (out->offload_state == OFFLOAD_STATE_PAUSED ||
2401 out->offload_state == OFFLOAD_STATE_PAUSED_FLUSHED)
2402 do_disable = false;
2403 out->offload_state = OFFLOAD_STATE_IDLE;
2404 }
2405 if (do_disable)
2406 ret = disable_output_path_l(out);
2407
2408 ALOGV("%s: exit: status(%d)", __func__, ret);
2409 return ret;
2410 }
2411
start_output_stream(struct stream_out * out)2412 int start_output_stream(struct stream_out *out)
2413 {
2414 int ret = 0;
2415 struct audio_device *adev = out->dev;
2416
2417 ALOGV("%s: enter: usecase(%d: %s) devices(%#x) channels(%d)",
2418 __func__, out->usecase, use_case_table[out->usecase], out->devices, out->config.channels);
2419
2420 enable_output_path_l(out);
2421
2422 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2423 out->compr = NULL;
2424 ret = out_open_pcm_devices(out);
2425 if (ret != 0)
2426 goto error_open;
2427 #ifdef PREPROCESSING_ENABLED
2428 out->echo_reference = NULL;
2429 out->echo_reference_generation = adev->echo_reference_generation;
2430 if (adev->echo_reference != NULL)
2431 out->echo_reference = adev->echo_reference;
2432 #endif
2433 } else {
2434 out->compr = compress_open(COMPRESS_CARD, COMPRESS_DEVICE,
2435 COMPRESS_IN, &out->compr_config);
2436 if (out->compr && !is_compress_ready(out->compr)) {
2437 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
2438 compress_close(out->compr);
2439 out->compr = NULL;
2440 ret = -EIO;
2441 goto error_open;
2442 }
2443 if (out->offload_callback)
2444 compress_nonblock(out->compr, out->non_blocking);
2445
2446 if (adev->offload_fx_start_output != NULL)
2447 adev->offload_fx_start_output(out->handle);
2448 }
2449 ALOGV("%s: exit", __func__);
2450 return 0;
2451 error_open:
2452 stop_output_stream(out);
2453 error_config:
2454 return ret;
2455 }
2456
stop_voice_call(struct audio_device * adev)2457 static int stop_voice_call(struct audio_device *adev)
2458 {
2459 struct audio_usecase *uc_info;
2460
2461 ALOGV("%s: enter", __func__);
2462 adev->in_call = false;
2463
2464 /* TODO: implement voice call stop */
2465
2466 uc_info = get_usecase_from_id(adev, USECASE_VOICE_CALL);
2467 if (uc_info == NULL) {
2468 ALOGE("%s: Could not find the usecase (%d) in the list",
2469 __func__, USECASE_VOICE_CALL);
2470 return -EINVAL;
2471 }
2472
2473 disable_snd_device(adev, uc_info, uc_info->out_snd_device, false);
2474 disable_snd_device(adev, uc_info, uc_info->in_snd_device, true);
2475
2476 uc_release_pcm_devices(uc_info);
2477 list_remove(&uc_info->adev_list_node);
2478 free(uc_info);
2479
2480 ALOGV("%s: exit", __func__);
2481 return 0;
2482 }
2483
2484 /* always called with adev lock held */
start_voice_call(struct audio_device * adev)2485 static int start_voice_call(struct audio_device *adev)
2486 {
2487 struct audio_usecase *uc_info;
2488
2489 ALOGV("%s: enter", __func__);
2490
2491 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
2492 uc_info->id = USECASE_VOICE_CALL;
2493 uc_info->type = VOICE_CALL;
2494 uc_info->stream = (struct audio_stream *)adev->primary_output;
2495 uc_info->devices = adev->primary_output->devices;
2496 uc_info->in_snd_device = SND_DEVICE_NONE;
2497 uc_info->out_snd_device = SND_DEVICE_NONE;
2498
2499 uc_select_pcm_devices(uc_info);
2500
2501 list_add_tail(&adev->usecase_list, &uc_info->adev_list_node);
2502
2503 select_devices(adev, USECASE_VOICE_CALL);
2504
2505
2506 /* TODO: implement voice call start */
2507
2508 /* set cached volume */
2509 set_voice_volume_l(adev, adev->voice_volume);
2510
2511 adev->in_call = true;
2512 ALOGV("%s: exit", __func__);
2513 return 0;
2514 }
2515
check_input_parameters(uint32_t sample_rate,audio_format_t format,int channel_count)2516 static int check_input_parameters(uint32_t sample_rate,
2517 audio_format_t format,
2518 int channel_count)
2519 {
2520 if (format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL;
2521
2522 if ((channel_count < 1) || (channel_count > 2)) return -EINVAL;
2523
2524 switch (sample_rate) {
2525 case 8000:
2526 case 11025:
2527 case 12000:
2528 case 16000:
2529 case 22050:
2530 case 24000:
2531 case 32000:
2532 case 44100:
2533 case 48000:
2534 break;
2535 default:
2536 return -EINVAL;
2537 }
2538
2539 return 0;
2540 }
2541
get_input_buffer_size(uint32_t sample_rate,audio_format_t format,int channel_count,audio_devices_t devices)2542 static size_t get_input_buffer_size(uint32_t sample_rate,
2543 audio_format_t format,
2544 int channel_count,
2545 audio_devices_t devices)
2546 {
2547 size_t size = 0;
2548 struct pcm_device_profile *pcm_profile;
2549
2550 if (check_input_parameters(sample_rate, format, channel_count) != 0)
2551 return 0;
2552
2553 pcm_profile = get_pcm_device(PCM_CAPTURE, devices);
2554 if (pcm_profile == NULL)
2555 return 0;
2556
2557 /*
2558 * take resampling into account and return the closest majoring
2559 * multiple of 16 frames, as audioflinger expects audio buffers to
2560 * be a multiple of 16 frames
2561 */
2562 size = (pcm_profile->config.period_size * sample_rate) / pcm_profile->config.rate;
2563 size = ((size + 15) / 16) * 16;
2564
2565 return (size * channel_count * audio_bytes_per_sample(format));
2566
2567 }
2568
out_get_sample_rate(const struct audio_stream * stream)2569 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
2570 {
2571 struct stream_out *out = (struct stream_out *)stream;
2572
2573 return out->sample_rate;
2574 }
2575
out_set_sample_rate(struct audio_stream * stream,uint32_t rate)2576 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
2577 {
2578 (void)stream;
2579 (void)rate;
2580 return -ENOSYS;
2581 }
2582
out_get_buffer_size(const struct audio_stream * stream)2583 static size_t out_get_buffer_size(const struct audio_stream *stream)
2584 {
2585 struct stream_out *out = (struct stream_out *)stream;
2586
2587 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2588 return out->compr_config.fragment_size;
2589 }
2590
2591 return out->config.period_size *
2592 audio_stream_out_frame_size((const struct audio_stream_out *)stream);
2593 }
2594
out_get_channels(const struct audio_stream * stream)2595 static uint32_t out_get_channels(const struct audio_stream *stream)
2596 {
2597 struct stream_out *out = (struct stream_out *)stream;
2598
2599 return out->channel_mask;
2600 }
2601
out_get_format(const struct audio_stream * stream)2602 static audio_format_t out_get_format(const struct audio_stream *stream)
2603 {
2604 struct stream_out *out = (struct stream_out *)stream;
2605
2606 return out->format;
2607 }
2608
out_set_format(struct audio_stream * stream,audio_format_t format)2609 static int out_set_format(struct audio_stream *stream, audio_format_t format)
2610 {
2611 (void)stream;
2612 (void)format;
2613 return -ENOSYS;
2614 }
2615
do_out_standby_l(struct stream_out * out)2616 static int do_out_standby_l(struct stream_out *out)
2617 {
2618 struct audio_device *adev = out->dev;
2619 int status = 0;
2620
2621 out->standby = true;
2622 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2623 out_close_pcm_devices(out);
2624 #ifdef PREPROCESSING_ENABLED
2625 /* stop writing to echo reference */
2626 if (out->echo_reference != NULL) {
2627 out->echo_reference->write(out->echo_reference, NULL);
2628 if (out->echo_reference_generation != adev->echo_reference_generation) {
2629 ALOGV("%s: release_echo_reference %p", __func__, out->echo_reference);
2630 release_echo_reference(out->echo_reference);
2631 out->echo_reference_generation = adev->echo_reference_generation;
2632 }
2633 out->echo_reference = NULL;
2634 }
2635 #endif
2636 } else {
2637 stop_compressed_output_l(out);
2638 out->gapless_mdata.encoder_delay = 0;
2639 out->gapless_mdata.encoder_padding = 0;
2640 if (out->compr != NULL) {
2641 compress_close(out->compr);
2642 out->compr = NULL;
2643 }
2644 }
2645 status = stop_output_stream(out);
2646
2647 return status;
2648 }
2649
out_standby(struct audio_stream * stream)2650 static int out_standby(struct audio_stream *stream)
2651 {
2652 struct stream_out *out = (struct stream_out *)stream;
2653 struct audio_device *adev = out->dev;
2654
2655 ALOGV("%s: enter: usecase(%d: %s)", __func__,
2656 out->usecase, use_case_table[out->usecase]);
2657 pthread_mutex_lock(&out->lock);
2658 if (!out->standby) {
2659 pthread_mutex_lock(&adev->lock);
2660 do_out_standby_l(out);
2661 pthread_mutex_unlock(&adev->lock);
2662 }
2663 pthread_mutex_unlock(&out->lock);
2664 ALOGV("%s: exit", __func__);
2665 return 0;
2666 }
2667
out_dump(const struct audio_stream * stream,int fd)2668 static int out_dump(const struct audio_stream *stream, int fd)
2669 {
2670 (void)stream;
2671 (void)fd;
2672
2673 return 0;
2674 }
2675
parse_compress_metadata(struct stream_out * out,struct str_parms * parms)2676 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
2677 {
2678 int ret = 0;
2679 char value[32];
2680 struct compr_gapless_mdata tmp_mdata;
2681
2682 if (!out || !parms) {
2683 return -EINVAL;
2684 }
2685
2686 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES, value, sizeof(value));
2687 if (ret >= 0) {
2688 tmp_mdata.encoder_delay = atoi(value); /* what is a good limit check? */
2689 } else {
2690 return -EINVAL;
2691 }
2692
2693 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES, value, sizeof(value));
2694 if (ret >= 0) {
2695 tmp_mdata.encoder_padding = atoi(value);
2696 } else {
2697 return -EINVAL;
2698 }
2699
2700 out->gapless_mdata = tmp_mdata;
2701 out->send_new_metadata = 1;
2702 ALOGV("%s new encoder delay %u and padding %u", __func__,
2703 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
2704
2705 return 0;
2706 }
2707
2708
out_set_parameters(struct audio_stream * stream,const char * kvpairs)2709 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
2710 {
2711 struct stream_out *out = (struct stream_out *)stream;
2712 struct audio_device *adev = out->dev;
2713 struct audio_usecase *usecase;
2714 struct listnode *node;
2715 struct str_parms *parms;
2716 char value[32];
2717 int ret, val = 0;
2718 struct audio_usecase *uc_info;
2719 bool do_standby = false;
2720 struct pcm_device *pcm_device;
2721 struct pcm_device_profile *pcm_profile;
2722 #ifdef PREPROCESSING_ENABLED
2723 struct stream_in *in = NULL; /* if non-NULL, then force input to standby */
2724 #endif
2725
2726 ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s out->devices(%d) adev->mode(%d)",
2727 __func__, out->usecase, use_case_table[out->usecase], kvpairs, out->devices, adev->mode);
2728 parms = str_parms_create_str(kvpairs);
2729 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
2730 if (ret >= 0) {
2731 val = atoi(value);
2732 pthread_mutex_lock(&adev->lock_inputs);
2733 pthread_mutex_lock(&out->lock);
2734 pthread_mutex_lock(&adev->lock);
2735 #ifdef PREPROCESSING_ENABLED
2736 if (((int)out->devices != val) && (val != 0) && (!out->standby) &&
2737 (out->usecase == USECASE_AUDIO_PLAYBACK)) {
2738 /* reset active input:
2739 * - to attach the echo reference
2740 * - because a change in output device may change mic settings */
2741 if (adev->active_input && (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
2742 adev->active_input->source == AUDIO_SOURCE_MIC)) {
2743 in = adev->active_input;
2744 }
2745 }
2746 #endif
2747 if (val != 0) {
2748 out->devices = val;
2749
2750 if (!out->standby) {
2751 uc_info = get_usecase_from_id(adev, out->usecase);
2752 if (uc_info == NULL) {
2753 ALOGE("%s: Could not find the usecase (%d) in the list",
2754 __func__, out->usecase);
2755 } else {
2756 list_for_each(node, &out->pcm_dev_list) {
2757 pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
2758 if ((pcm_device->pcm_profile->devices & val) == 0)
2759 do_standby = true;
2760 val &= ~pcm_device->pcm_profile->devices;
2761 }
2762 if (val != 0)
2763 do_standby = true;
2764 }
2765 if (do_standby)
2766 do_out_standby_l(out);
2767 else
2768 select_devices(adev, out->usecase);
2769 }
2770
2771 if ((adev->mode == AUDIO_MODE_IN_CALL) && !adev->in_call &&
2772 (out == adev->primary_output)) {
2773 start_voice_call(adev);
2774 } else if ((adev->mode == AUDIO_MODE_IN_CALL) && adev->in_call &&
2775 (out == adev->primary_output)) {
2776 select_devices(adev, USECASE_VOICE_CALL);
2777 }
2778 }
2779
2780 if ((adev->mode == AUDIO_MODE_NORMAL) && adev->in_call &&
2781 (out == adev->primary_output)) {
2782 stop_voice_call(adev);
2783 }
2784 pthread_mutex_unlock(&adev->lock);
2785 pthread_mutex_unlock(&out->lock);
2786 #ifdef PREPROCESSING_ENABLED
2787 if (in) {
2788 /* The lock on adev->lock_inputs prevents input stream from being closed */
2789 pthread_mutex_lock(&in->lock);
2790 pthread_mutex_lock(&adev->lock);
2791 LOG_ALWAYS_FATAL_IF(in != adev->active_input);
2792 do_in_standby_l(in);
2793 pthread_mutex_unlock(&adev->lock);
2794 pthread_mutex_unlock(&in->lock);
2795 }
2796 #endif
2797 pthread_mutex_unlock(&adev->lock_inputs);
2798 }
2799
2800 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2801 parse_compress_metadata(out, parms);
2802 }
2803
2804 str_parms_destroy(parms);
2805 ALOGV("%s: exit: code(%d)", __func__, ret);
2806 return ret;
2807 }
2808
out_get_parameters(const struct audio_stream * stream,const char * keys)2809 static char* out_get_parameters(const struct audio_stream *stream, const char *keys)
2810 {
2811 struct stream_out *out = (struct stream_out *)stream;
2812 struct str_parms *query = str_parms_create_str(keys);
2813 char *str;
2814 char value[256];
2815 struct str_parms *reply = str_parms_create();
2816 size_t i, j;
2817 int ret;
2818 bool first = true;
2819 ALOGV("%s: enter: keys - %s", __func__, keys);
2820 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
2821 if (ret >= 0) {
2822 value[0] = '\0';
2823 i = 0;
2824 while (out->supported_channel_masks[i] != 0) {
2825 for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) {
2826 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
2827 if (!first) {
2828 strcat(value, "|");
2829 }
2830 strcat(value, out_channels_name_to_enum_table[j].name);
2831 first = false;
2832 break;
2833 }
2834 }
2835 i++;
2836 }
2837 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
2838 str = str_parms_to_str(reply);
2839 } else {
2840 str = strdup(keys);
2841 }
2842 str_parms_destroy(query);
2843 str_parms_destroy(reply);
2844 ALOGV("%s: exit: returns - %s", __func__, str);
2845 return str;
2846 }
2847
out_get_latency(const struct audio_stream_out * stream)2848 static uint32_t out_get_latency(const struct audio_stream_out *stream)
2849 {
2850 struct stream_out *out = (struct stream_out *)stream;
2851
2852 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
2853 return COMPRESS_OFFLOAD_PLAYBACK_LATENCY;
2854
2855 return (out->config.period_count * out->config.period_size * 1000) /
2856 (out->config.rate);
2857 }
2858
out_set_volume(struct audio_stream_out * stream,float left,float right)2859 static int out_set_volume(struct audio_stream_out *stream, float left,
2860 float right)
2861 {
2862 struct stream_out *out = (struct stream_out *)stream;
2863 struct audio_device *adev = out->dev;
2864 int offload_volume[2];//For stereo
2865
2866 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
2867 /* only take left channel into account: the API is for stereo anyway */
2868 out->muted = (left == 0.0f);
2869 return 0;
2870 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2871 struct mixer_ctl *ctl;
2872 struct mixer *mixer = NULL;
2873
2874 offload_volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX);
2875 offload_volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX);
2876
2877 mixer = mixer_open(MIXER_CARD);
2878 if (!mixer) {
2879 ALOGE("%s unable to open the mixer for card %d, aborting.",
2880 __func__, MIXER_CARD);
2881 return -EINVAL;
2882 }
2883 ctl = mixer_get_ctl_by_name(mixer, MIXER_CTL_COMPRESS_PLAYBACK_VOLUME);
2884 if (!ctl) {
2885 ALOGE("%s: Could not get ctl for mixer cmd - %s",
2886 __func__, MIXER_CTL_COMPRESS_PLAYBACK_VOLUME);
2887 mixer_close(mixer);
2888 return -EINVAL;
2889 }
2890 ALOGD("out_set_volume set offload volume (%f, %f)", left, right);
2891 mixer_ctl_set_array(ctl, offload_volume,
2892 sizeof(offload_volume)/sizeof(offload_volume[0]));
2893 mixer_close(mixer);
2894 return 0;
2895 }
2896
2897 return -ENOSYS;
2898 }
2899
tfa9895_config_thread(void * context)2900 static void *tfa9895_config_thread(void *context)
2901 {
2902 ALOGD("%s: enter", __func__);
2903 pthread_detach(pthread_self());
2904 struct audio_device *adev = (struct audio_device *)context;
2905 pthread_mutex_lock(&adev->tfa9895_lock);
2906 adev->tfa9895_init =
2907 adev->htc_acoustic_set_amp_mode(adev->mode, AUDIO_DEVICE_OUT_SPEAKER, 0, 0, false);
2908 if (!adev->tfa9895_init) {
2909 ALOGE("set_amp_mode failed, need to re-config again");
2910 adev->tfa9895_mode_change |= 0x1;
2911 }
2912 ALOGI("@@##tfa9895_config_thread Done!! tfa9895_mode_change=%d", adev->tfa9895_mode_change);
2913 pthread_mutex_unlock(&adev->tfa9895_lock);
2914 dummybuf_thread_close(adev);
2915 return NULL;
2916 }
2917
out_write(struct audio_stream_out * stream,const void * buffer,size_t bytes)2918 static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
2919 size_t bytes)
2920 {
2921 struct stream_out *out = (struct stream_out *)stream;
2922 struct audio_device *adev = out->dev;
2923 ssize_t ret = 0;
2924 struct pcm_device *pcm_device;
2925 struct listnode *node;
2926 size_t frame_size = audio_stream_out_frame_size(stream);
2927 size_t frames_wr = 0, frames_rq = 0;
2928 unsigned char *data = NULL;
2929 struct pcm_config config;
2930 #ifdef PREPROCESSING_ENABLED
2931 size_t in_frames = bytes / frame_size;
2932 size_t out_frames = in_frames;
2933 struct stream_in *in = NULL;
2934 #endif
2935
2936 pthread_mutex_lock(&out->lock);
2937 if (out->standby) {
2938 #ifdef PREPROCESSING_ENABLED
2939 pthread_mutex_unlock(&out->lock);
2940 /* Prevent input stream from being closed */
2941 pthread_mutex_lock(&adev->lock_inputs);
2942 pthread_mutex_lock(&out->lock);
2943 if (!out->standby) {
2944 pthread_mutex_unlock(&adev->lock_inputs);
2945 goto false_alarm;
2946 }
2947 #endif
2948 pthread_mutex_lock(&adev->lock);
2949 ret = start_output_stream(out);
2950 /* ToDo: If use case is compress offload should return 0 */
2951 if (ret != 0) {
2952 pthread_mutex_unlock(&adev->lock);
2953 #ifdef PREPROCESSING_ENABLED
2954 pthread_mutex_unlock(&adev->lock_inputs);
2955 #endif
2956 goto exit;
2957 }
2958 out->standby = false;
2959
2960 #ifdef PREPROCESSING_ENABLED
2961 /* A change in output device may change the microphone selection */
2962 if (adev->active_input &&
2963 (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
2964 adev->active_input->source == AUDIO_SOURCE_MIC)) {
2965 in = adev->active_input;
2966 ALOGV("%s: enter:) force_input_standby true", __func__);
2967 }
2968 #endif
2969 pthread_mutex_unlock(&adev->lock);
2970 #ifdef PREPROCESSING_ENABLED
2971 if (!in) {
2972 /* Leave mutex locked iff in != NULL */
2973 pthread_mutex_unlock(&adev->lock_inputs);
2974 }
2975 #endif
2976 }
2977 false_alarm:
2978
2979 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2980 ALOGVV("%s: writing buffer (%d bytes) to compress device", __func__, bytes);
2981
2982 if (out->offload_state == OFFLOAD_STATE_PAUSED_FLUSHED) {
2983 ALOGV("start offload write from pause state");
2984 pthread_mutex_lock(&adev->lock);
2985 enable_output_path_l(out);
2986 pthread_mutex_unlock(&adev->lock);
2987 }
2988
2989 if (out->send_new_metadata) {
2990 ALOGVV("send new gapless metadata");
2991 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
2992 out->send_new_metadata = 0;
2993 }
2994
2995 ret = compress_write(out->compr, buffer, bytes);
2996 ALOGVV("%s: writing buffer (%d bytes) to compress device returned %d", __func__, bytes, ret);
2997 if (ret >= 0 && ret < (ssize_t)bytes) {
2998 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
2999 }
3000 if (out->offload_state != OFFLOAD_STATE_PLAYING) {
3001 compress_start(out->compr);
3002 out->offload_state = OFFLOAD_STATE_PLAYING;
3003 }
3004 pthread_mutex_unlock(&out->lock);
3005 #ifdef PREPROCESSING_ENABLED
3006 if (in) {
3007 /* This mutex was left locked iff in != NULL */
3008 pthread_mutex_unlock(&adev->lock_inputs);
3009 }
3010 #endif
3011 return ret;
3012 } else {
3013 #ifdef PREPROCESSING_ENABLED
3014 if (android_atomic_acquire_load(&adev->echo_reference_generation)
3015 != out->echo_reference_generation) {
3016 pthread_mutex_lock(&adev->lock);
3017 if (out->echo_reference != NULL) {
3018 ALOGV("%s: release_echo_reference %p", __func__, out->echo_reference);
3019 release_echo_reference(out->echo_reference);
3020 }
3021 // note that adev->echo_reference_generation here can be different from the one
3022 // tested above but it doesn't matter as we now have the adev mutex and it is consistent
3023 // with what has been set by get_echo_reference() or put_echo_reference()
3024 out->echo_reference_generation = adev->echo_reference_generation;
3025 out->echo_reference = adev->echo_reference;
3026 ALOGV("%s: update echo reference generation %d", __func__,
3027 out->echo_reference_generation);
3028 pthread_mutex_unlock(&adev->lock);
3029 }
3030 #endif
3031
3032 if (out->muted)
3033 memset((void *)buffer, 0, bytes);
3034 list_for_each(node, &out->pcm_dev_list) {
3035 pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
3036 if (pcm_device->resampler) {
3037 if (bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size
3038 > pcm_device->res_byte_count) {
3039 pcm_device->res_byte_count =
3040 bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size;
3041 pcm_device->res_buffer =
3042 realloc(pcm_device->res_buffer, pcm_device->res_byte_count);
3043 ALOGV("%s: resampler res_byte_count = %zu", __func__,
3044 pcm_device->res_byte_count);
3045 }
3046 frames_rq = bytes / frame_size;
3047 frames_wr = pcm_device->res_byte_count / frame_size;
3048 ALOGVV("%s: resampler request frames = %d frame_size = %d",
3049 __func__, frames_rq, frame_size);
3050 pcm_device->resampler->resample_from_input(pcm_device->resampler,
3051 (int16_t *)buffer, &frames_rq, (int16_t *)pcm_device->res_buffer, &frames_wr);
3052 ALOGVV("%s: resampler output frames_= %d", __func__, frames_wr);
3053 }
3054 if (pcm_device->pcm) {
3055 #ifdef PREPROCESSING_ENABLED
3056 if (out->echo_reference != NULL && pcm_device->pcm_profile->devices != SND_DEVICE_OUT_SPEAKER) {
3057 struct echo_reference_buffer b;
3058 b.raw = (void *)buffer;
3059 b.frame_count = in_frames;
3060
3061 get_playback_delay(out, out_frames, &b);
3062 out->echo_reference->write(out->echo_reference, &b);
3063 }
3064 #endif
3065 if (adev->tfa9895_mode_change == 0x1) {
3066 if (out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
3067 pthread_mutex_lock(&adev->tfa9895_lock);
3068 data = (unsigned char *)
3069 calloc(pcm_frames_to_bytes(pcm_device->pcm, out->config.period_size),
3070 sizeof(unsigned char));
3071 if (data) {
3072 int i;
3073
3074 // reopen pcm with stop_threshold = INT_MAX/2
3075 memcpy(&config, &pcm_device->pcm_profile->config,
3076 sizeof(struct pcm_config));
3077 config.stop_threshold = INT_MAX/2;
3078
3079 if (pcm_device->pcm)
3080 pcm_close(pcm_device->pcm);
3081
3082 for (i = 0; i < RETRY_NUMBER; i++) {
3083 pcm_device->pcm = pcm_open(pcm_device->pcm_profile->card,
3084 pcm_device->pcm_profile->id,
3085 PCM_OUT | PCM_MONOTONIC, &config);
3086 if (pcm_device->pcm != NULL && pcm_is_ready(pcm_device->pcm))
3087 break;
3088 else
3089 usleep(10000);
3090 }
3091 if (i >= RETRY_NUMBER)
3092 ALOGE("%s: failed to reopen pcm device", __func__);
3093
3094 if (pcm_device->pcm) {
3095 for (i = out->config.period_count; i > 0; i--)
3096 pcm_write(pcm_device->pcm, (void *)data,
3097 pcm_frames_to_bytes(pcm_device->pcm,
3098 out->config.period_size));
3099 /* TODO: Hold on 100 ms and wait i2s signal ready
3100 before giving dsp related i2c commands */
3101 usleep(100000);
3102 adev->tfa9895_mode_change &= ~0x1;
3103 ALOGD("@@##checking - 2: tfa9895_config_thread: "
3104 "adev->tfa9895_mode_change=%d", adev->tfa9895_mode_change);
3105 adev->tfa9895_init =
3106 adev->htc_acoustic_set_amp_mode(
3107 adev->mode, AUDIO_DEVICE_OUT_SPEAKER, 0, 0, false);
3108 }
3109 free(data);
3110
3111 // reopen pcm with normal stop_threshold
3112 if (pcm_device->pcm)
3113 pcm_close(pcm_device->pcm);
3114
3115 for (i = 0; i < RETRY_NUMBER; i++) {
3116 pcm_device->pcm = pcm_open(pcm_device->pcm_profile->card,
3117 pcm_device->pcm_profile->id,
3118 PCM_OUT | PCM_MONOTONIC, &pcm_device->pcm_profile->config);
3119 if (pcm_device->pcm != NULL && pcm_is_ready(pcm_device->pcm))
3120 break;
3121 else
3122 usleep(10000);
3123 }
3124 if (i >= RETRY_NUMBER) {
3125 ALOGE("%s: failed to reopen pcm device, error return", __func__);
3126 pthread_mutex_unlock(&adev->tfa9895_lock);
3127 pthread_mutex_unlock(&out->lock);
3128 return -1;
3129 }
3130 }
3131 }
3132 pthread_mutex_unlock(&adev->tfa9895_lock);
3133 }
3134 ALOGVV("%s: writing buffer (%d bytes) to pcm device", __func__, bytes);
3135 if (pcm_device->resampler && pcm_device->res_buffer)
3136 pcm_device->status =
3137 pcm_write(pcm_device->pcm, (void *)pcm_device->res_buffer,
3138 frames_wr * frame_size);
3139 else
3140 pcm_device->status = pcm_write(pcm_device->pcm, (void *)buffer, bytes);
3141 if (pcm_device->status != 0)
3142 ret = pcm_device->status;
3143 }
3144 }
3145 if (ret == 0)
3146 out->written += bytes / (out->config.channels * sizeof(short));
3147 }
3148
3149 exit:
3150 pthread_mutex_unlock(&out->lock);
3151
3152 if (ret != 0) {
3153 list_for_each(node, &out->pcm_dev_list) {
3154 pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
3155 if (pcm_device->pcm && pcm_device->status != 0)
3156 ALOGE("%s: error %zd - %s", __func__, ret, pcm_get_error(pcm_device->pcm));
3157 }
3158 out_standby(&out->stream.common);
3159 usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) /
3160 out_get_sample_rate(&out->stream.common));
3161 }
3162
3163 #ifdef PREPROCESSING_ENABLED
3164 if (in) {
3165 /* The lock on adev->lock_inputs prevents input stream from being closed */
3166 pthread_mutex_lock(&in->lock);
3167 pthread_mutex_lock(&adev->lock);
3168 LOG_ALWAYS_FATAL_IF(in != adev->active_input);
3169 do_in_standby_l(in);
3170 pthread_mutex_unlock(&adev->lock);
3171 pthread_mutex_unlock(&in->lock);
3172 /* This mutex was left locked iff in != NULL */
3173 pthread_mutex_unlock(&adev->lock_inputs);
3174 }
3175 #endif
3176
3177 return bytes;
3178 }
3179
out_get_render_position(const struct audio_stream_out * stream,uint32_t * dsp_frames)3180 static int out_get_render_position(const struct audio_stream_out *stream,
3181 uint32_t *dsp_frames)
3182 {
3183 struct stream_out *out = (struct stream_out *)stream;
3184 *dsp_frames = 0;
3185 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
3186 pthread_mutex_lock(&out->lock);
3187 if (out->compr != NULL) {
3188 compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
3189 &out->sample_rate);
3190 ALOGVV("%s rendered frames %d sample_rate %d",
3191 __func__, *dsp_frames, out->sample_rate);
3192 }
3193 pthread_mutex_unlock(&out->lock);
3194 return 0;
3195 } else
3196 return -EINVAL;
3197 }
3198
out_add_audio_effect(const struct audio_stream * stream,effect_handle_t effect)3199 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
3200 {
3201 (void)stream;
3202 (void)effect;
3203 return 0;
3204 }
3205
out_remove_audio_effect(const struct audio_stream * stream,effect_handle_t effect)3206 static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
3207 {
3208 (void)stream;
3209 (void)effect;
3210 return 0;
3211 }
3212
out_get_next_write_timestamp(const struct audio_stream_out * stream,int64_t * timestamp)3213 static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
3214 int64_t *timestamp)
3215 {
3216 (void)stream;
3217 (void)timestamp;
3218 return -EINVAL;
3219 }
3220
out_get_presentation_position(const struct audio_stream_out * stream,uint64_t * frames,struct timespec * timestamp)3221 static int out_get_presentation_position(const struct audio_stream_out *stream,
3222 uint64_t *frames, struct timespec *timestamp)
3223 {
3224 struct stream_out *out = (struct stream_out *)stream;
3225 int ret = -1;
3226 unsigned long dsp_frames;
3227
3228 pthread_mutex_lock(&out->lock);
3229
3230 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3231 if (out->compr != NULL) {
3232 compress_get_tstamp(out->compr, &dsp_frames,
3233 &out->sample_rate);
3234 ALOGVV("%s rendered frames %ld sample_rate %d",
3235 __func__, dsp_frames, out->sample_rate);
3236 *frames = dsp_frames;
3237 ret = 0;
3238 /* this is the best we can do */
3239 clock_gettime(CLOCK_MONOTONIC, timestamp);
3240 }
3241 } else {
3242 /* FIXME: which device to read from? */
3243 if (!list_empty(&out->pcm_dev_list)) {
3244 unsigned int avail;
3245 struct pcm_device *pcm_device = node_to_item(list_head(&out->pcm_dev_list),
3246 struct pcm_device, stream_list_node);
3247
3248 if (pcm_get_htimestamp(pcm_device->pcm, &avail, timestamp) == 0) {
3249 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
3250 int64_t signed_frames = out->written - kernel_buffer_size + avail;
3251 /* This adjustment accounts for buffering after app processor.
3252 It is based on estimated DSP latency per use case, rather than exact. */
3253 signed_frames -=
3254 (render_latency(out->usecase) * out->sample_rate / 1000000LL);
3255
3256 /* It would be unusual for this value to be negative, but check just in case ... */
3257 if (signed_frames >= 0) {
3258 *frames = signed_frames;
3259 ret = 0;
3260 }
3261 }
3262 }
3263 }
3264
3265 pthread_mutex_unlock(&out->lock);
3266
3267 return ret;
3268 }
3269
out_set_callback(struct audio_stream_out * stream,stream_callback_t callback,void * cookie)3270 static int out_set_callback(struct audio_stream_out *stream,
3271 stream_callback_t callback, void *cookie)
3272 {
3273 struct stream_out *out = (struct stream_out *)stream;
3274
3275 ALOGV("%s", __func__);
3276 pthread_mutex_lock(&out->lock);
3277 out->offload_callback = callback;
3278 out->offload_cookie = cookie;
3279 pthread_mutex_unlock(&out->lock);
3280 return 0;
3281 }
3282
out_pause(struct audio_stream_out * stream)3283 static int out_pause(struct audio_stream_out* stream)
3284 {
3285 struct stream_out *out = (struct stream_out *)stream;
3286 int status = -ENOSYS;
3287 ALOGV("%s", __func__);
3288 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3289 pthread_mutex_lock(&out->lock);
3290 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
3291 status = compress_pause(out->compr);
3292 out->offload_state = OFFLOAD_STATE_PAUSED;
3293 pthread_mutex_lock(&out->dev->lock);
3294 status = disable_output_path_l(out);
3295 pthread_mutex_unlock(&out->dev->lock);
3296 }
3297 pthread_mutex_unlock(&out->lock);
3298 }
3299 return status;
3300 }
3301
out_resume(struct audio_stream_out * stream)3302 static int out_resume(struct audio_stream_out* stream)
3303 {
3304 struct stream_out *out = (struct stream_out *)stream;
3305 int status = -ENOSYS;
3306 ALOGV("%s", __func__);
3307 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3308 status = 0;
3309 pthread_mutex_lock(&out->lock);
3310 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
3311 pthread_mutex_lock(&out->dev->lock);
3312 enable_output_path_l(out);
3313 pthread_mutex_unlock(&out->dev->lock);
3314 status = compress_resume(out->compr);
3315 out->offload_state = OFFLOAD_STATE_PLAYING;
3316 }
3317 pthread_mutex_unlock(&out->lock);
3318 }
3319 return status;
3320 }
3321
out_drain(struct audio_stream_out * stream,audio_drain_type_t type)3322 static int out_drain(struct audio_stream_out* stream, audio_drain_type_t type )
3323 {
3324 struct stream_out *out = (struct stream_out *)stream;
3325 int status = -ENOSYS;
3326 ALOGV("%s", __func__);
3327 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3328 pthread_mutex_lock(&out->lock);
3329 if (type == AUDIO_DRAIN_EARLY_NOTIFY)
3330 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
3331 else
3332 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
3333 pthread_mutex_unlock(&out->lock);
3334 }
3335 return status;
3336 }
3337
out_flush(struct audio_stream_out * stream)3338 static int out_flush(struct audio_stream_out* stream)
3339 {
3340 struct stream_out *out = (struct stream_out *)stream;
3341 ALOGV("%s", __func__);
3342 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3343 pthread_mutex_lock(&out->lock);
3344 if (out->offload_state == OFFLOAD_STATE_PLAYING) {
3345 ALOGE("out_flush() called in wrong state %d", out->offload_state);
3346 pthread_mutex_unlock(&out->lock);
3347 return -ENOSYS;
3348 }
3349 if (out->offload_state == OFFLOAD_STATE_PAUSED) {
3350 stop_compressed_output_l(out);
3351 out->offload_state = OFFLOAD_STATE_PAUSED_FLUSHED;
3352 }
3353 pthread_mutex_unlock(&out->lock);
3354 return 0;
3355 }
3356 return -ENOSYS;
3357 }
3358
3359 /** audio_stream_in implementation **/
in_get_sample_rate(const struct audio_stream * stream)3360 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
3361 {
3362 struct stream_in *in = (struct stream_in *)stream;
3363
3364 return in->requested_rate;
3365 }
3366
in_set_sample_rate(struct audio_stream * stream,uint32_t rate)3367 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
3368 {
3369 (void)stream;
3370 (void)rate;
3371 return -ENOSYS;
3372 }
3373
in_get_channels(const struct audio_stream * stream)3374 static uint32_t in_get_channels(const struct audio_stream *stream)
3375 {
3376 struct stream_in *in = (struct stream_in *)stream;
3377
3378 return in->main_channels;
3379 }
3380
in_get_format(const struct audio_stream * stream)3381 static audio_format_t in_get_format(const struct audio_stream *stream)
3382 {
3383 (void)stream;
3384 return AUDIO_FORMAT_PCM_16_BIT;
3385 }
3386
in_set_format(struct audio_stream * stream,audio_format_t format)3387 static int in_set_format(struct audio_stream *stream, audio_format_t format)
3388 {
3389 (void)stream;
3390 (void)format;
3391
3392 return -ENOSYS;
3393 }
3394
in_get_buffer_size(const struct audio_stream * stream)3395 static size_t in_get_buffer_size(const struct audio_stream *stream)
3396 {
3397 struct stream_in *in = (struct stream_in *)stream;
3398
3399 return get_input_buffer_size(in->requested_rate,
3400 in_get_format(stream),
3401 audio_channel_count_from_in_mask(in->main_channels),
3402 in->devices);
3403 }
3404
in_close_pcm_devices(struct stream_in * in)3405 static int in_close_pcm_devices(struct stream_in *in)
3406 {
3407 struct pcm_device *pcm_device;
3408 struct listnode *node;
3409 struct audio_device *adev = in->dev;
3410
3411 list_for_each(node, &in->pcm_dev_list) {
3412 pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
3413 if (pcm_device) {
3414 if (pcm_device->pcm)
3415 pcm_close(pcm_device->pcm);
3416 pcm_device->pcm = NULL;
3417 if (pcm_device->sound_trigger_handle > 0)
3418 adev->sound_trigger_close_for_streaming(pcm_device->sound_trigger_handle);
3419 pcm_device->sound_trigger_handle = 0;
3420 }
3421 }
3422 return 0;
3423 }
3424
3425
3426 /* must be called with stream and hw device mutex locked */
do_in_standby_l(struct stream_in * in)3427 static int do_in_standby_l(struct stream_in *in)
3428 {
3429 int status = 0;
3430
3431 #ifdef PREPROCESSING_ENABLED
3432 struct audio_device *adev = in->dev;
3433 #endif
3434 if (!in->standby) {
3435
3436 in_close_pcm_devices(in);
3437
3438 #ifdef PREPROCESSING_ENABLED
3439 if (in->echo_reference != NULL) {
3440 /* stop reading from echo reference */
3441 in->echo_reference->read(in->echo_reference, NULL);
3442 put_echo_reference(adev, in->echo_reference);
3443 in->echo_reference = NULL;
3444 }
3445 #ifdef HW_AEC_LOOPBACK
3446 if (in->hw_echo_reference)
3447 {
3448 if (in->hw_ref_buf) {
3449 free(in->hw_ref_buf);
3450 in->hw_ref_buf = NULL;
3451 }
3452 }
3453 #endif // HW_AEC_LOOPBACK
3454 #endif // PREPROCESSING_ENABLED
3455
3456 status = stop_input_stream(in);
3457
3458 if (in->read_buf) {
3459 free(in->read_buf);
3460 in->read_buf = NULL;
3461 }
3462
3463 in->standby = 1;
3464 }
3465 return 0;
3466 }
3467
3468 // called with adev->lock_inputs locked
in_standby_l(struct stream_in * in)3469 static int in_standby_l(struct stream_in *in)
3470 {
3471 struct audio_device *adev = in->dev;
3472 int status = 0;
3473 pthread_mutex_lock(&in->lock);
3474 if (!in->standby) {
3475 pthread_mutex_lock(&adev->lock);
3476 status = do_in_standby_l(in);
3477 pthread_mutex_unlock(&adev->lock);
3478 }
3479 pthread_mutex_unlock(&in->lock);
3480 return status;
3481 }
3482
in_standby(struct audio_stream * stream)3483 static int in_standby(struct audio_stream *stream)
3484 {
3485 struct stream_in *in = (struct stream_in *)stream;
3486 struct audio_device *adev = in->dev;
3487 int status;
3488 ALOGV("%s: enter", __func__);
3489 pthread_mutex_lock(&adev->lock_inputs);
3490 status = in_standby_l(in);
3491 pthread_mutex_unlock(&adev->lock_inputs);
3492 ALOGV("%s: exit: status(%d)", __func__, status);
3493 return status;
3494 }
3495
in_dump(const struct audio_stream * stream,int fd)3496 static int in_dump(const struct audio_stream *stream, int fd)
3497 {
3498 (void)stream;
3499 (void)fd;
3500
3501 return 0;
3502 }
3503
in_set_parameters(struct audio_stream * stream,const char * kvpairs)3504 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
3505 {
3506 struct stream_in *in = (struct stream_in *)stream;
3507 struct audio_device *adev = in->dev;
3508 struct str_parms *parms;
3509 char *str;
3510 char value[32];
3511 int ret, val = 0;
3512 struct audio_usecase *uc_info;
3513 bool do_standby = false;
3514 struct listnode *node;
3515 struct pcm_device *pcm_device;
3516 struct pcm_device_profile *pcm_profile;
3517
3518 ALOGV("%s: enter: kvpairs=%s", __func__, kvpairs);
3519 parms = str_parms_create_str(kvpairs);
3520
3521 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
3522
3523 pthread_mutex_lock(&adev->lock_inputs);
3524 pthread_mutex_lock(&in->lock);
3525 pthread_mutex_lock(&adev->lock);
3526 if (ret >= 0) {
3527 val = atoi(value);
3528 /* no audio source uses val == 0 */
3529 if (((int)in->source != val) && (val != 0)) {
3530 in->source = val;
3531 }
3532 }
3533
3534 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
3535 if (ret >= 0) {
3536 val = atoi(value);
3537 if (((int)in->devices != val) && (val != 0)) {
3538 in->devices = val;
3539 /* If recording is in progress, change the tx device to new device */
3540 if (!in->standby) {
3541 uc_info = get_usecase_from_id(adev, in->usecase);
3542 if (uc_info == NULL) {
3543 ALOGE("%s: Could not find the usecase (%d) in the list",
3544 __func__, in->usecase);
3545 } else {
3546 if (list_empty(&in->pcm_dev_list))
3547 ALOGE("%s: pcm device list empty", __func__);
3548 else {
3549 pcm_device = node_to_item(list_head(&in->pcm_dev_list),
3550 struct pcm_device, stream_list_node);
3551 if ((pcm_device->pcm_profile->devices & val & ~AUDIO_DEVICE_BIT_IN) == 0) {
3552 do_standby = true;
3553 }
3554 }
3555 }
3556 if (do_standby) {
3557 ret = do_in_standby_l(in);
3558 } else
3559 ret = select_devices(adev, in->usecase);
3560 }
3561 }
3562 }
3563 pthread_mutex_unlock(&adev->lock);
3564 pthread_mutex_unlock(&in->lock);
3565 pthread_mutex_unlock(&adev->lock_inputs);
3566 str_parms_destroy(parms);
3567 ALOGV("%s: exit: status(%d)", __func__, ret);
3568 return ret;
3569 }
3570
in_get_parameters(const struct audio_stream * stream,const char * keys)3571 static char* in_get_parameters(const struct audio_stream *stream,
3572 const char *keys)
3573 {
3574 (void)stream;
3575 (void)keys;
3576
3577 return strdup("");
3578 }
3579
in_set_gain(struct audio_stream_in * stream,float gain)3580 static int in_set_gain(struct audio_stream_in *stream, float gain)
3581 {
3582 (void)stream;
3583 (void)gain;
3584
3585 return 0;
3586 }
3587
read_bytes_from_dsp(struct stream_in * in,void * buffer,size_t bytes)3588 static ssize_t read_bytes_from_dsp(struct stream_in *in, void* buffer,
3589 size_t bytes)
3590 {
3591 struct pcm_device *pcm_device;
3592 struct audio_device *adev = in->dev;
3593
3594 pcm_device = node_to_item(list_head(&in->pcm_dev_list),
3595 struct pcm_device, stream_list_node);
3596
3597 if (pcm_device->sound_trigger_handle > 0)
3598 return adev->sound_trigger_read_samples(pcm_device->sound_trigger_handle, buffer, bytes);
3599 else
3600 return 0;
3601 }
3602
in_read(struct audio_stream_in * stream,void * buffer,size_t bytes)3603 static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
3604 size_t bytes)
3605 {
3606 struct stream_in *in = (struct stream_in *)stream;
3607 struct audio_device *adev = in->dev;
3608 ssize_t frames = -1;
3609 int ret = -1;
3610 int read_and_process_successful = false;
3611
3612 size_t frames_rq = bytes / audio_stream_in_frame_size(stream);
3613
3614 /* no need to acquire adev->lock_inputs because API contract prevents a close */
3615 pthread_mutex_lock(&in->lock);
3616 if (in->standby) {
3617 pthread_mutex_unlock(&in->lock);
3618 pthread_mutex_lock(&adev->lock_inputs);
3619 pthread_mutex_lock(&in->lock);
3620 if (!in->standby) {
3621 pthread_mutex_unlock(&adev->lock_inputs);
3622 goto false_alarm;
3623 }
3624 pthread_mutex_lock(&adev->lock);
3625 ret = start_input_stream(in);
3626 pthread_mutex_unlock(&adev->lock);
3627 pthread_mutex_unlock(&adev->lock_inputs);
3628 if (ret != 0) {
3629 goto exit;
3630 }
3631 in->standby = 0;
3632 }
3633 false_alarm:
3634
3635 if (!list_empty(&in->pcm_dev_list)) {
3636 if (in->usecase == USECASE_AUDIO_CAPTURE_HOTWORD) {
3637 bytes = read_bytes_from_dsp(in, buffer, bytes);
3638 if (bytes > 0)
3639 read_and_process_successful = true;
3640 } else {
3641 /*
3642 * Read PCM and:
3643 * - resample if needed
3644 * - process if pre-processors are attached
3645 * - discard unwanted channels
3646 */
3647 frames = read_and_process_frames(in, buffer, frames_rq);
3648 if (frames >= 0)
3649 read_and_process_successful = true;
3650 }
3651 }
3652
3653 /*
3654 * Instead of writing zeroes here, we could trust the hardware
3655 * to always provide zeroes when muted.
3656 */
3657 if (read_and_process_successful == true && adev->mic_mute)
3658 memset(buffer, 0, bytes);
3659
3660 exit:
3661 pthread_mutex_unlock(&in->lock);
3662
3663 if (read_and_process_successful == false) {
3664 in_standby(&in->stream.common);
3665 ALOGV("%s: read failed - sleeping for buffer duration", __func__);
3666 usleep(bytes * 1000000 / audio_stream_in_frame_size(stream) /
3667 in->requested_rate);
3668 }
3669 return bytes;
3670 }
3671
in_get_input_frames_lost(struct audio_stream_in * stream)3672 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
3673 {
3674 (void)stream;
3675
3676 return 0;
3677 }
3678
add_remove_audio_effect(const struct audio_stream * stream,effect_handle_t effect,bool enable)3679 static int add_remove_audio_effect(const struct audio_stream *stream,
3680 effect_handle_t effect,
3681 bool enable)
3682 {
3683 struct stream_in *in = (struct stream_in *)stream;
3684 struct audio_device *adev = in->dev;
3685 int status = 0;
3686 effect_descriptor_t desc;
3687 #ifdef PREPROCESSING_ENABLED
3688 int i;
3689 #endif
3690 status = (*effect)->get_descriptor(effect, &desc);
3691 if (status != 0)
3692 return status;
3693
3694 ALOGI("add_remove_audio_effect(), effect type: %08x, enable: %d ", desc.type.timeLow, enable);
3695
3696 pthread_mutex_lock(&adev->lock_inputs);
3697 pthread_mutex_lock(&in->lock);
3698 pthread_mutex_lock(&in->dev->lock);
3699 #ifndef PREPROCESSING_ENABLED
3700 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) &&
3701 in->enable_aec != enable &&
3702 (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) {
3703 in->enable_aec = enable;
3704 if (!in->standby)
3705 select_devices(in->dev, in->usecase);
3706 }
3707 #else
3708 if ( (in->num_preprocessors > MAX_PREPROCESSORS) && (enable == true) ) {
3709 status = -ENOSYS;
3710 goto exit;
3711 }
3712 if ( enable == true ) {
3713 in->preprocessors[in->num_preprocessors].effect_itfe = effect;
3714 /* add the supported channel of the effect in the channel_configs */
3715 in_read_audio_effect_channel_configs(in, &in->preprocessors[in->num_preprocessors]);
3716 in->num_preprocessors ++;
3717 /* check compatibility between main channel supported and possible auxiliary channels */
3718 in_update_aux_channels(in, effect);//wesley crash
3719 in->aux_channels_changed = true;
3720 } else {
3721 /* if ( enable == false ) */
3722 if (in->num_preprocessors <= 0) {
3723 status = -ENOSYS;
3724 goto exit;
3725 }
3726 status = -EINVAL;
3727 for (i=0; i < in->num_preprocessors; i++) {
3728 if (status == 0) { /* status == 0 means an effect was removed from a previous slot */
3729 in->preprocessors[i - 1].effect_itfe = in->preprocessors[i].effect_itfe;
3730 in->preprocessors[i - 1].channel_configs = in->preprocessors[i].channel_configs;
3731 in->preprocessors[i - 1].num_channel_configs =
3732 in->preprocessors[i].num_channel_configs;
3733 ALOGV("add_remove_audio_effect moving fx from %d to %d", i, i-1);
3734 continue;
3735 }
3736 if ( in->preprocessors[i].effect_itfe == effect ) {
3737 ALOGV("add_remove_audio_effect found fx at index %d", i);
3738 free(in->preprocessors[i].channel_configs);
3739 status = 0;
3740 }
3741 }
3742 if (status != 0)
3743 goto exit;
3744 in->num_preprocessors--;
3745 /* if we remove one effect, at least the last proproc should be reset */
3746 in->preprocessors[in->num_preprocessors].num_channel_configs = 0;
3747 in->preprocessors[in->num_preprocessors].effect_itfe = NULL;
3748 in->preprocessors[in->num_preprocessors].channel_configs = NULL;
3749 in->aux_channels_changed = false;
3750 ALOGV("%s: enable(%d), in->aux_channels_changed(%d)", __func__, enable, in->aux_channels_changed);
3751 }
3752 ALOGI("%s: num_preprocessors = %d", __func__, in->num_preprocessors);
3753
3754 if ( memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) {
3755 in->enable_aec = enable;
3756 ALOGV("add_remove_audio_effect(), FX_IID_AEC, enable: %d", enable);
3757 if (!in->standby) {
3758 select_devices(in->dev, in->usecase);
3759 do_in_standby_l(in);
3760 }
3761 if (in->enable_aec == true) {
3762 in_configure_reverse(in);
3763 }
3764 }
3765 exit:
3766 #endif
3767 ALOGW_IF(status != 0, "add_remove_audio_effect() error %d", status);
3768 pthread_mutex_unlock(&in->dev->lock);
3769 pthread_mutex_unlock(&in->lock);
3770 pthread_mutex_unlock(&adev->lock_inputs);
3771 return status;
3772 }
3773
in_add_audio_effect(const struct audio_stream * stream,effect_handle_t effect)3774 static int in_add_audio_effect(const struct audio_stream *stream,
3775 effect_handle_t effect)
3776 {
3777 ALOGV("%s: effect %p", __func__, effect);
3778 return add_remove_audio_effect(stream, effect, true);
3779 }
3780
in_remove_audio_effect(const struct audio_stream * stream,effect_handle_t effect)3781 static int in_remove_audio_effect(const struct audio_stream *stream,
3782 effect_handle_t effect)
3783 {
3784 ALOGV("%s: effect %p", __func__, effect);
3785 return add_remove_audio_effect(stream, effect, false);
3786 }
3787
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)3788 static int adev_open_output_stream(struct audio_hw_device *dev,
3789 audio_io_handle_t handle,
3790 audio_devices_t devices,
3791 audio_output_flags_t flags,
3792 struct audio_config *config,
3793 struct audio_stream_out **stream_out,
3794 const char *address __unused)
3795 {
3796 struct audio_device *adev = (struct audio_device *)dev;
3797 struct stream_out *out;
3798 int i, ret;
3799 struct pcm_device_profile *pcm_profile;
3800
3801 ALOGV("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)",
3802 __func__, config->sample_rate, config->channel_mask, devices, flags);
3803 *stream_out = NULL;
3804 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
3805
3806 if (devices == AUDIO_DEVICE_NONE)
3807 devices = AUDIO_DEVICE_OUT_SPEAKER;
3808
3809 out->flags = flags;
3810 out->devices = devices;
3811 out->dev = adev;
3812 out->format = config->format;
3813 out->sample_rate = config->sample_rate;
3814 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3815 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
3816 out->handle = handle;
3817
3818 pcm_profile = get_pcm_device(PCM_PLAYBACK, devices);
3819 if (pcm_profile == NULL) {
3820 ret = -EINVAL;
3821 goto error_open;
3822 }
3823 out->config = pcm_profile->config;
3824
3825 /* Init use case and pcm_config */
3826 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
3827 if (config->offload_info.version != AUDIO_INFO_INITIALIZER.version ||
3828 config->offload_info.size != AUDIO_INFO_INITIALIZER.size) {
3829 ALOGE("%s: Unsupported Offload information", __func__);
3830 ret = -EINVAL;
3831 goto error_open;
3832 }
3833 if (!is_supported_format(config->offload_info.format)) {
3834 ALOGE("%s: Unsupported audio format", __func__);
3835 ret = -EINVAL;
3836 goto error_open;
3837 }
3838
3839 out->compr_config.codec = (struct snd_codec *)
3840 calloc(1, sizeof(struct snd_codec));
3841
3842 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
3843 if (config->offload_info.channel_mask)
3844 out->channel_mask = config->offload_info.channel_mask;
3845 else if (config->channel_mask)
3846 out->channel_mask = config->channel_mask;
3847 out->format = config->offload_info.format;
3848 out->sample_rate = config->offload_info.sample_rate;
3849
3850 out->stream.set_callback = out_set_callback;
3851 out->stream.pause = out_pause;
3852 out->stream.resume = out_resume;
3853 out->stream.drain = out_drain;
3854 out->stream.flush = out_flush;
3855
3856 out->compr_config.codec->id =
3857 get_snd_codec_id(config->offload_info.format);
3858 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
3859 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
3860 out->compr_config.codec->sample_rate = config->offload_info.sample_rate;
3861 out->compr_config.codec->bit_rate =
3862 config->offload_info.bit_rate;
3863 out->compr_config.codec->ch_in =
3864 audio_channel_count_from_out_mask(config->channel_mask);
3865 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
3866
3867 if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING)
3868 out->non_blocking = 1;
3869
3870 out->send_new_metadata = 1;
3871 create_offload_callback_thread(out);
3872 out->offload_state = OFFLOAD_STATE_IDLE;
3873
3874 ALOGV("%s: offloaded output offload_info version %04x bit rate %d",
3875 __func__, config->offload_info.version,
3876 config->offload_info.bit_rate);
3877 } else if (out->flags & (AUDIO_OUTPUT_FLAG_DEEP_BUFFER)) {
3878 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
3879 out->config = pcm_config_deep_buffer;
3880 out->sample_rate = out->config.rate;
3881 ALOGD("%s: use AUDIO_PLAYBACK_DEEP_BUFFER",__func__);
3882 } else {
3883 out->usecase = USECASE_AUDIO_PLAYBACK;
3884 out->sample_rate = out->config.rate;
3885 }
3886
3887 if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) {
3888 if (adev->primary_output == NULL)
3889 adev->primary_output = out;
3890 else {
3891 ALOGE("%s: Primary output is already opened", __func__);
3892 ret = -EEXIST;
3893 goto error_open;
3894 }
3895 }
3896
3897 /* Check if this usecase is already existing */
3898 pthread_mutex_lock(&adev->lock);
3899 if (get_usecase_from_id(adev, out->usecase) != NULL) {
3900 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
3901 pthread_mutex_unlock(&adev->lock);
3902 ret = -EEXIST;
3903 goto error_open;
3904 }
3905 pthread_mutex_unlock(&adev->lock);
3906
3907 out->stream.common.get_sample_rate = out_get_sample_rate;
3908 out->stream.common.set_sample_rate = out_set_sample_rate;
3909 out->stream.common.get_buffer_size = out_get_buffer_size;
3910 out->stream.common.get_channels = out_get_channels;
3911 out->stream.common.get_format = out_get_format;
3912 out->stream.common.set_format = out_set_format;
3913 out->stream.common.standby = out_standby;
3914 out->stream.common.dump = out_dump;
3915 out->stream.common.set_parameters = out_set_parameters;
3916 out->stream.common.get_parameters = out_get_parameters;
3917 out->stream.common.add_audio_effect = out_add_audio_effect;
3918 out->stream.common.remove_audio_effect = out_remove_audio_effect;
3919 out->stream.get_latency = out_get_latency;
3920 out->stream.set_volume = out_set_volume;
3921 out->stream.write = out_write;
3922 out->stream.get_render_position = out_get_render_position;
3923 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
3924 out->stream.get_presentation_position = out_get_presentation_position;
3925
3926 out->standby = 1;
3927 /* out->muted = false; by calloc() */
3928 /* out->written = 0; by calloc() */
3929
3930 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
3931 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
3932
3933 config->format = out->stream.common.get_format(&out->stream.common);
3934 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
3935 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
3936
3937 *stream_out = &out->stream;
3938 ALOGV("%s: exit", __func__);
3939 return 0;
3940
3941 error_open:
3942 free(out);
3943 *stream_out = NULL;
3944 ALOGD("%s: exit: ret %d", __func__, ret);
3945 return ret;
3946 }
3947
adev_close_output_stream(struct audio_hw_device * dev,struct audio_stream_out * stream)3948 static void adev_close_output_stream(struct audio_hw_device *dev,
3949 struct audio_stream_out *stream)
3950 {
3951 struct stream_out *out = (struct stream_out *)stream;
3952 struct audio_device *adev = out->dev;
3953 (void)dev;
3954
3955 ALOGV("%s: enter", __func__);
3956 out_standby(&stream->common);
3957 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3958 destroy_offload_callback_thread(out);
3959
3960 if (out->compr_config.codec != NULL)
3961 free(out->compr_config.codec);
3962 }
3963 pthread_cond_destroy(&out->cond);
3964 pthread_mutex_destroy(&out->lock);
3965 free(stream);
3966 ALOGV("%s: exit", __func__);
3967 }
3968
adev_set_parameters(struct audio_hw_device * dev,const char * kvpairs)3969 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
3970 {
3971 struct audio_device *adev = (struct audio_device *)dev;
3972 struct str_parms *parms;
3973 char *str;
3974 char value[32];
3975 int val;
3976 int ret;
3977
3978 ALOGV("%s: enter: %s", __func__, kvpairs);
3979
3980 parms = str_parms_create_str(kvpairs);
3981 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value));
3982 if (ret >= 0) {
3983 int tty_mode;
3984
3985 if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0)
3986 tty_mode = TTY_MODE_OFF;
3987 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0)
3988 tty_mode = TTY_MODE_VCO;
3989 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0)
3990 tty_mode = TTY_MODE_HCO;
3991 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0)
3992 tty_mode = TTY_MODE_FULL;
3993 else
3994 return -EINVAL;
3995
3996 pthread_mutex_lock(&adev->lock);
3997 if (tty_mode != adev->tty_mode) {
3998 adev->tty_mode = tty_mode;
3999 if (adev->in_call)
4000 select_devices(adev, USECASE_VOICE_CALL);
4001 }
4002 pthread_mutex_unlock(&adev->lock);
4003 }
4004
4005 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
4006 if (ret >= 0) {
4007 /* When set to false, HAL should disable EC and NS
4008 * But it is currently not supported.
4009 */
4010 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
4011 adev->bluetooth_nrec = true;
4012 else
4013 adev->bluetooth_nrec = false;
4014 }
4015
4016 ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
4017 if (ret >= 0) {
4018 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
4019 adev->screen_off = false;
4020 else
4021 adev->screen_off = true;
4022 }
4023
4024 ret = str_parms_get_int(parms, "rotation", &val);
4025 if (ret >= 0) {
4026 bool reverse_speakers = false;
4027 switch(val) {
4028 /* FIXME: note that the code below assumes that the speakers are in the correct placement
4029 relative to the user when the device is rotated 90deg from its default rotation. This
4030 assumption is device-specific, not platform-specific like this code. */
4031 case 270:
4032 reverse_speakers = true;
4033 break;
4034 case 0:
4035 case 90:
4036 case 180:
4037 break;
4038 default:
4039 ALOGE("%s: unexpected rotation of %d", __func__, val);
4040 }
4041 pthread_mutex_lock(&adev->lock);
4042 if (adev->speaker_lr_swap != reverse_speakers) {
4043 adev->speaker_lr_swap = reverse_speakers;
4044 /* only update the selected device if there is active pcm playback */
4045 struct audio_usecase *usecase;
4046 struct listnode *node;
4047 list_for_each(node, &adev->usecase_list) {
4048 usecase = node_to_item(node, struct audio_usecase, adev_list_node);
4049 if (usecase->type == PCM_PLAYBACK) {
4050 select_devices(adev, usecase->id);
4051 if (adev->htc_acoustic_spk_reverse)
4052 adev->htc_acoustic_spk_reverse(adev->speaker_lr_swap);
4053 break;
4054 }
4055 }
4056 }
4057 pthread_mutex_unlock(&adev->lock);
4058 }
4059
4060 str_parms_destroy(parms);
4061 ALOGV("%s: exit with code(%d)", __func__, ret);
4062 return ret;
4063 }
4064
adev_get_parameters(const struct audio_hw_device * dev,const char * keys)4065 static char* adev_get_parameters(const struct audio_hw_device *dev,
4066 const char *keys)
4067 {
4068 (void)dev;
4069 (void)keys;
4070
4071 return strdup("");
4072 }
4073
adev_init_check(const struct audio_hw_device * dev)4074 static int adev_init_check(const struct audio_hw_device *dev)
4075 {
4076 (void)dev;
4077
4078 return 0;
4079 }
4080
adev_set_voice_volume(struct audio_hw_device * dev,float volume)4081 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
4082 {
4083 int ret = 0;
4084 struct audio_device *adev = (struct audio_device *)dev;
4085 pthread_mutex_lock(&adev->lock);
4086 /* cache volume */
4087 adev->voice_volume = volume;
4088 ret = set_voice_volume_l(adev, adev->voice_volume);
4089 pthread_mutex_unlock(&adev->lock);
4090 return ret;
4091 }
4092
adev_set_master_volume(struct audio_hw_device * dev,float volume)4093 static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
4094 {
4095 (void)dev;
4096 (void)volume;
4097
4098 return -ENOSYS;
4099 }
4100
adev_get_master_volume(struct audio_hw_device * dev,float * volume)4101 static int adev_get_master_volume(struct audio_hw_device *dev,
4102 float *volume)
4103 {
4104 (void)dev;
4105 (void)volume;
4106
4107 return -ENOSYS;
4108 }
4109
adev_set_master_mute(struct audio_hw_device * dev,bool muted)4110 static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
4111 {
4112 (void)dev;
4113 (void)muted;
4114
4115 return -ENOSYS;
4116 }
4117
adev_get_master_mute(struct audio_hw_device * dev,bool * muted)4118 static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
4119 {
4120 (void)dev;
4121 (void)muted;
4122
4123 return -ENOSYS;
4124 }
4125
adev_set_mode(struct audio_hw_device * dev,audio_mode_t mode)4126 static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
4127 {
4128 struct audio_device *adev = (struct audio_device *)dev;
4129
4130 pthread_mutex_lock(&adev->lock);
4131 if (adev->mode != mode) {
4132 ALOGI("%s mode = %d", __func__, mode);
4133 adev->mode = mode;
4134 pthread_mutex_lock(&adev->tfa9895_lock);
4135 adev->tfa9895_mode_change |= 0x1;
4136 pthread_mutex_unlock(&adev->tfa9895_lock);
4137 }
4138 pthread_mutex_unlock(&adev->lock);
4139 return 0;
4140 }
4141
adev_set_mic_mute(struct audio_hw_device * dev,bool state)4142 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
4143 {
4144 struct audio_device *adev = (struct audio_device *)dev;
4145 int err = 0;
4146
4147 pthread_mutex_lock(&adev->lock);
4148 adev->mic_mute = state;
4149
4150 if (adev->mode == AUDIO_MODE_IN_CALL) {
4151 /* TODO */
4152 }
4153
4154 pthread_mutex_unlock(&adev->lock);
4155 return err;
4156 }
4157
adev_get_mic_mute(const struct audio_hw_device * dev,bool * state)4158 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
4159 {
4160 struct audio_device *adev = (struct audio_device *)dev;
4161
4162 *state = adev->mic_mute;
4163
4164 return 0;
4165 }
4166
adev_get_input_buffer_size(const struct audio_hw_device * dev,const struct audio_config * config)4167 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
4168 const struct audio_config *config)
4169 {
4170 (void)dev;
4171
4172 /* NOTE: we default to built in mic which may cause a mismatch between what we
4173 * report here and the actual buffer size
4174 */
4175 return get_input_buffer_size(config->sample_rate,
4176 config->format,
4177 audio_channel_count_from_in_mask(config->channel_mask),
4178 AUDIO_DEVICE_IN_BUILTIN_MIC);
4179 }
4180
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)4181 static int adev_open_input_stream(struct audio_hw_device *dev,
4182 audio_io_handle_t handle __unused,
4183 audio_devices_t devices,
4184 struct audio_config *config,
4185 struct audio_stream_in **stream_in,
4186 audio_input_flags_t flags,
4187 const char *address __unused,
4188 audio_source_t source)
4189 {
4190 struct audio_device *adev = (struct audio_device *)dev;
4191 struct stream_in *in;
4192 struct pcm_device_profile *pcm_profile;
4193
4194 ALOGV("%s: enter", __func__);
4195
4196 *stream_in = NULL;
4197 if (check_input_parameters(config->sample_rate, config->format,
4198 audio_channel_count_from_in_mask(config->channel_mask)) != 0)
4199 return -EINVAL;
4200
4201 if (source == AUDIO_SOURCE_HOTWORD) {
4202 pcm_profile = get_pcm_device(PCM_HOTWORD_STREAMING, devices);
4203 } else {
4204 pcm_profile = get_pcm_device(PCM_CAPTURE, devices);
4205 }
4206 if (pcm_profile == NULL)
4207 return -EINVAL;
4208
4209 in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
4210
4211 in->stream.common.get_sample_rate = in_get_sample_rate;
4212 in->stream.common.set_sample_rate = in_set_sample_rate;
4213 in->stream.common.get_buffer_size = in_get_buffer_size;
4214 in->stream.common.get_channels = in_get_channels;
4215 in->stream.common.get_format = in_get_format;
4216 in->stream.common.set_format = in_set_format;
4217 in->stream.common.standby = in_standby;
4218 in->stream.common.dump = in_dump;
4219 in->stream.common.set_parameters = in_set_parameters;
4220 in->stream.common.get_parameters = in_get_parameters;
4221 in->stream.common.add_audio_effect = in_add_audio_effect;
4222 in->stream.common.remove_audio_effect = in_remove_audio_effect;
4223 in->stream.set_gain = in_set_gain;
4224 in->stream.read = in_read;
4225 in->stream.get_input_frames_lost = in_get_input_frames_lost;
4226
4227 in->devices = devices;
4228 in->source = source;
4229 in->dev = adev;
4230 in->standby = 1;
4231 in->main_channels = config->channel_mask;
4232 in->requested_rate = config->sample_rate;
4233 if (config->sample_rate != CAPTURE_DEFAULT_SAMPLING_RATE)
4234 flags = flags & ~AUDIO_INPUT_FLAG_FAST;
4235 in->input_flags = flags;
4236 /* HW codec is limited to default channels. No need to update with
4237 * requested channels */
4238 in->config = pcm_profile->config;
4239
4240 /* Update config params with the requested sample rate and channels */
4241 if (source == AUDIO_SOURCE_HOTWORD) {
4242 in->usecase = USECASE_AUDIO_CAPTURE_HOTWORD;
4243 } else {
4244 in->usecase = USECASE_AUDIO_CAPTURE;
4245 }
4246
4247 *stream_in = &in->stream;
4248 ALOGV("%s: exit", __func__);
4249 return 0;
4250 }
4251
adev_close_input_stream(struct audio_hw_device * dev,struct audio_stream_in * stream)4252 static void adev_close_input_stream(struct audio_hw_device *dev,
4253 struct audio_stream_in *stream)
4254 {
4255 struct audio_device *adev = (struct audio_device *)dev;
4256 struct stream_in *in = (struct stream_in*)stream;
4257 ALOGV("%s", __func__);
4258
4259 /* prevent concurrent out_set_parameters, or out_write from standby */
4260 pthread_mutex_lock(&adev->lock_inputs);
4261
4262 #ifdef PREPROCESSING_ENABLED
4263 int i;
4264
4265 for (i=0; i<in->num_preprocessors; i++) {
4266 free(in->preprocessors[i].channel_configs);
4267 }
4268
4269 if (in->read_buf) {
4270 free(in->read_buf);
4271 in->read_buf = NULL;
4272 }
4273
4274 if (in->proc_buf_in) {
4275 free(in->proc_buf_in);
4276 in->proc_buf_in = NULL;
4277 }
4278
4279 if (in->proc_buf_out) {
4280 free(in->proc_buf_out);
4281 in->proc_buf_out = NULL;
4282 }
4283
4284 if (in->ref_buf) {
4285 free(in->ref_buf);
4286 in->ref_buf = NULL;
4287 }
4288
4289 if (in->resampler) {
4290 release_resampler(in->resampler);
4291 in->resampler = NULL;
4292 }
4293 #endif
4294
4295 in_standby_l(in);
4296 free(stream);
4297
4298 pthread_mutex_unlock(&adev->lock_inputs);
4299
4300 return;
4301 }
4302
adev_dump(const audio_hw_device_t * device,int fd)4303 static int adev_dump(const audio_hw_device_t *device, int fd)
4304 {
4305 (void)device;
4306 (void)fd;
4307
4308 return 0;
4309 }
4310
adev_close(hw_device_t * device)4311 static int adev_close(hw_device_t *device)
4312 {
4313 struct audio_device *adev = (struct audio_device *)device;
4314 audio_device_ref_count--;
4315 free(adev->snd_dev_ref_cnt);
4316 free_mixer_list(adev);
4317 free(device);
4318 return 0;
4319 }
4320
dummybuf_thread(void * context)4321 static void *dummybuf_thread(void *context)
4322 {
4323 ALOGD("%s: enter", __func__);
4324 pthread_detach(pthread_self());
4325 struct audio_device *adev = (struct audio_device *)context;
4326 struct pcm_config config;
4327 const char *mixer_ctl_name = "Headphone Jack Switch";
4328 struct mixer *mixer = NULL;
4329 struct mixer_ctl *ctl;
4330 unsigned char *data = NULL;
4331 struct pcm *pcm = NULL;
4332 struct pcm_device_profile *profile = NULL;
4333
4334 memset(&config, 0, sizeof(struct pcm_config));
4335 if (adev->dummybuf_thread_devices == AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
4336 profile = &pcm_device_playback_hs;
4337 mixer = mixer_open(profile->card);
4338 }
4339 else
4340 profile = &pcm_device_playback_spk;
4341
4342 memcpy(&config, &profile->config, sizeof(struct pcm_config));
4343 /* Use large value for stop_threshold so that automatic
4344 trigger for stop is avoided, when this thread fails to write data */
4345 config.stop_threshold = INT_MAX/2;
4346 pthread_mutex_lock(&adev->dummybuf_thread_lock);
4347 pcm = pcm_open(profile->card, profile->id,
4348 (PCM_OUT | PCM_MONOTONIC), &config);
4349 if (pcm != NULL && !pcm_is_ready(pcm)) {
4350 ALOGE("pcm_open: card=%d, id=%d is not ready", profile->card, profile->id);
4351 pcm_close(pcm);
4352 pcm = NULL;
4353 } else {
4354 ALOGD("pcm_open: card=%d, id=%d", profile->card, profile->id);
4355 }
4356
4357 if (mixer) {
4358 ctl = mixer_get_ctl_by_name(mixer, mixer_ctl_name);
4359 if (ctl != NULL)
4360 mixer_ctl_set_value(ctl, 0, 1);
4361 else {
4362 ALOGE("Invalid mixer control: name(%s): skip dummy thread", mixer_ctl_name);
4363 adev->dummybuf_thread_active = 1;
4364 mixer_close(mixer);
4365 if (pcm) {
4366 pcm_close(pcm);
4367 pcm = NULL;
4368 }
4369 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4370 return NULL;
4371 }
4372 }
4373 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4374
4375 while (1) {
4376 pthread_mutex_lock(&adev->dummybuf_thread_lock);
4377 if (pcm) {
4378 if (data == NULL)
4379 data = (unsigned char *)calloc(DEEP_BUFFER_OUTPUT_PERIOD_SIZE * 8,
4380 sizeof(unsigned char));
4381 if (data) {
4382 pcm_write(pcm, (void *)data, DEEP_BUFFER_OUTPUT_PERIOD_SIZE * 8);
4383 adev->dummybuf_thread_active = 1;
4384 } else {
4385 ALOGD("%s: cant open a buffer, retry to open it", __func__);
4386 }
4387 } else {
4388 ALOGD("%s: cant open a output deep stream, retry to open it", __func__);
4389 pcm = pcm_open(profile->card, profile->id,
4390 (PCM_OUT | PCM_MONOTONIC), &config);
4391 if (pcm != NULL && !pcm_is_ready(pcm)) {
4392 ALOGE("pcm_open: card=%d, id=%d is not ready", profile->card, profile->id);
4393 pcm_close(pcm);
4394 pcm = NULL;
4395 } else {
4396 ALOGD("pcm_open: card=%d, id=%d", profile->card, profile->id);
4397 }
4398 }
4399
4400 if (adev->dummybuf_thread_cancel || adev->dummybuf_thread_timeout-- <= 0) {
4401 adev->dummybuf_thread_active = 0;
4402 adev->dummybuf_thread_cancel = 0;
4403 if (pcm) {
4404 ALOGD("pcm_close ++ card=%d, id=%d", profile->card, profile->id);
4405 pcm_close(pcm);
4406 if (mixer) {
4407 mixer_ctl_set_value(ctl, 0, 0);
4408 mixer_close(mixer);
4409 }
4410 ALOGD("pcm_close -- card=%d, id=%d", profile->card, profile->id);
4411 pcm = NULL;
4412 }
4413 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4414
4415 break;
4416 }
4417
4418 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4419 usleep(3000);
4420 }
4421
4422 if (data)
4423 free(data);
4424
4425 return NULL;
4426 }
4427
dummybuf_thread_open(struct audio_device * adev)4428 static void dummybuf_thread_open(struct audio_device *adev)
4429 {
4430 adev->dummybuf_thread_timeout = 6000; /* in 18 sec */
4431 adev->dummybuf_thread_cancel = 0;
4432 adev->dummybuf_thread_active = 0;
4433 pthread_mutex_init(&adev->dummybuf_thread_lock, (const pthread_mutexattr_t *) NULL);
4434 if (!adev->dummybuf_thread)
4435 pthread_create(&adev->dummybuf_thread, (const pthread_attr_t *) NULL, dummybuf_thread, adev);
4436 }
4437
dummybuf_thread_close(struct audio_device * adev)4438 static void dummybuf_thread_close(struct audio_device *adev)
4439 {
4440 ALOGD("%s: enter", __func__);
4441 int retry_cnt = 20;
4442
4443 if (adev->dummybuf_thread == 0)
4444 return;
4445
4446 pthread_mutex_lock(&adev->dummybuf_thread_lock);
4447 adev->dummybuf_thread_cancel = 1;
4448 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4449
4450 while (retry_cnt > 0) {
4451 pthread_mutex_lock(&adev->dummybuf_thread_lock);
4452 if (adev->dummybuf_thread_active == 0) {
4453 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4454 break;
4455 }
4456 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4457 retry_cnt--;
4458 usleep(1000);
4459 }
4460
4461 pthread_join(adev->dummybuf_thread, (void **) NULL);
4462 pthread_mutex_destroy(&adev->dummybuf_thread_lock);
4463 adev->dummybuf_thread = 0;
4464 }
4465
adev_open(const hw_module_t * module,const char * name,hw_device_t ** device)4466 static int adev_open(const hw_module_t *module, const char *name,
4467 hw_device_t **device)
4468 {
4469 struct audio_device *adev;
4470 int i, ret, retry_count;
4471
4472 ALOGD("%s: enter", __func__);
4473 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL;
4474
4475 adev = calloc(1, sizeof(struct audio_device));
4476
4477 adev->device.common.tag = HARDWARE_DEVICE_TAG;
4478 adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
4479 adev->device.common.module = (struct hw_module_t *)module;
4480 adev->device.common.close = adev_close;
4481
4482 adev->device.init_check = adev_init_check;
4483 adev->device.set_voice_volume = adev_set_voice_volume;
4484 adev->device.set_master_volume = adev_set_master_volume;
4485 adev->device.get_master_volume = adev_get_master_volume;
4486 adev->device.set_master_mute = adev_set_master_mute;
4487 adev->device.get_master_mute = adev_get_master_mute;
4488 adev->device.set_mode = adev_set_mode;
4489 adev->device.set_mic_mute = adev_set_mic_mute;
4490 adev->device.get_mic_mute = adev_get_mic_mute;
4491 adev->device.set_parameters = adev_set_parameters;
4492 adev->device.get_parameters = adev_get_parameters;
4493 adev->device.get_input_buffer_size = adev_get_input_buffer_size;
4494 adev->device.open_output_stream = adev_open_output_stream;
4495 adev->device.close_output_stream = adev_close_output_stream;
4496 adev->device.open_input_stream = adev_open_input_stream;
4497 adev->device.close_input_stream = adev_close_input_stream;
4498 adev->device.dump = adev_dump;
4499
4500 /* Set the default route before the PCM stream is opened */
4501 adev->mode = AUDIO_MODE_NORMAL;
4502 adev->active_input = NULL;
4503 adev->primary_output = NULL;
4504 adev->voice_volume = 1.0f;
4505 adev->tty_mode = TTY_MODE_OFF;
4506 adev->bluetooth_nrec = true;
4507 adev->in_call = false;
4508 /* adev->cur_hdmi_channels = 0; by calloc() */
4509 adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int));
4510
4511 adev->dualmic_config = DUALMIC_CONFIG_NONE;
4512 adev->ns_in_voice_rec = false;
4513
4514 list_init(&adev->usecase_list);
4515
4516 if (mixer_init(adev) != 0) {
4517 free(adev->snd_dev_ref_cnt);
4518 free(adev);
4519 ALOGE("%s: Failed to init, aborting.", __func__);
4520 *device = NULL;
4521 return -EINVAL;
4522 }
4523
4524 if (access(OFFLOAD_FX_LIBRARY_PATH, R_OK) == 0) {
4525 adev->offload_fx_lib = dlopen(OFFLOAD_FX_LIBRARY_PATH, RTLD_NOW);
4526 if (adev->offload_fx_lib == NULL) {
4527 ALOGE("%s: DLOPEN failed for %s", __func__, OFFLOAD_FX_LIBRARY_PATH);
4528 } else {
4529 ALOGV("%s: DLOPEN successful for %s", __func__, OFFLOAD_FX_LIBRARY_PATH);
4530 adev->offload_fx_start_output =
4531 (int (*)(audio_io_handle_t))dlsym(adev->offload_fx_lib,
4532 "visualizer_hal_start_output");
4533 adev->offload_fx_stop_output =
4534 (int (*)(audio_io_handle_t))dlsym(adev->offload_fx_lib,
4535 "visualizer_hal_stop_output");
4536 }
4537 }
4538
4539 if (access(HTC_ACOUSTIC_LIBRARY_PATH, R_OK) == 0) {
4540 adev->htc_acoustic_lib = dlopen(HTC_ACOUSTIC_LIBRARY_PATH, RTLD_NOW);
4541 if (adev->htc_acoustic_lib == NULL) {
4542 ALOGE("%s: DLOPEN failed for %s", __func__, HTC_ACOUSTIC_LIBRARY_PATH);
4543 } else {
4544 ALOGV("%s: DLOPEN successful for %s", __func__, HTC_ACOUSTIC_LIBRARY_PATH);
4545 adev->htc_acoustic_init_rt5506 =
4546 (int (*)())dlsym(adev->htc_acoustic_lib,
4547 "init_rt5506");
4548 adev->htc_acoustic_set_rt5506_amp =
4549 (int (*)(int, int))dlsym(adev->htc_acoustic_lib,
4550 "set_rt5506_amp");
4551 adev->htc_acoustic_set_amp_mode =
4552 (int (*)(int , int, int, int, bool))dlsym(adev->htc_acoustic_lib,
4553 "set_amp_mode");
4554 adev->htc_acoustic_spk_reverse =
4555 (int (*)(bool))dlsym(adev->htc_acoustic_lib,
4556 "spk_reverse");
4557 if (adev->htc_acoustic_spk_reverse)
4558 adev->htc_acoustic_spk_reverse(adev->speaker_lr_swap);
4559 }
4560 }
4561
4562 if (access(SOUND_TRIGGER_HAL_LIBRARY_PATH, R_OK) == 0) {
4563 adev->sound_trigger_lib = dlopen(SOUND_TRIGGER_HAL_LIBRARY_PATH, RTLD_NOW);
4564 if (adev->sound_trigger_lib == NULL) {
4565 ALOGE("%s: DLOPEN failed for %s", __func__, SOUND_TRIGGER_HAL_LIBRARY_PATH);
4566 } else {
4567 ALOGV("%s: DLOPEN successful for %s", __func__, SOUND_TRIGGER_HAL_LIBRARY_PATH);
4568 adev->sound_trigger_open_for_streaming =
4569 (int (*)(void))dlsym(adev->sound_trigger_lib,
4570 "sound_trigger_open_for_streaming");
4571 adev->sound_trigger_read_samples =
4572 (int (*)(audio_io_handle_t, int))dlsym(adev->sound_trigger_lib,
4573 "sound_trigger_read_samples");
4574 adev->sound_trigger_close_for_streaming =
4575 (int (*)(int))dlsym(adev->sound_trigger_lib,
4576 "sound_trigger_close_for_streaming");
4577 if (!adev->sound_trigger_open_for_streaming ||
4578 !adev->sound_trigger_read_samples ||
4579 !adev->sound_trigger_close_for_streaming) {
4580
4581 ALOGE("%s: Error grabbing functions in %s", __func__, SOUND_TRIGGER_HAL_LIBRARY_PATH);
4582 adev->sound_trigger_open_for_streaming = 0;
4583 adev->sound_trigger_read_samples = 0;
4584 adev->sound_trigger_close_for_streaming = 0;
4585 }
4586 }
4587 }
4588
4589
4590 *device = &adev->device.common;
4591
4592 if (adev->htc_acoustic_init_rt5506 != NULL)
4593 adev->htc_acoustic_init_rt5506();
4594
4595 if (audio_device_ref_count == 0) {
4596 /* For HS GPIO initial config */
4597 adev->dummybuf_thread_devices = AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
4598 dummybuf_thread_open(adev);
4599 retry_count = RETRY_NUMBER;
4600 while (retry_count-- > 0) {
4601 pthread_mutex_lock(&adev->dummybuf_thread_lock);
4602 if (adev->dummybuf_thread_active != 0) {
4603 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4604 break;
4605 }
4606 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4607 usleep(10000);
4608 }
4609 dummybuf_thread_close(adev);
4610
4611 /* For NXP DSP config */
4612 if (adev->htc_acoustic_set_amp_mode) {
4613 pthread_t th;
4614 adev->dummybuf_thread_devices = AUDIO_DEVICE_OUT_SPEAKER;
4615 dummybuf_thread_open(adev);
4616 pthread_mutex_lock(&adev->dummybuf_thread_lock);
4617 retry_count = RETRY_NUMBER;
4618 while (retry_count-- > 0) {
4619 if (adev->dummybuf_thread_active) {
4620 break;
4621 }
4622 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4623 usleep(10000);
4624 pthread_mutex_lock(&adev->dummybuf_thread_lock);
4625 }
4626 if (adev->dummybuf_thread_active) {
4627 usleep(10000); /* tfa9895 spk amp need more than 1ms i2s signal before giving dsp related i2c commands*/
4628 if (pthread_create(&th, NULL, tfa9895_config_thread, (void* )adev) != 0) {
4629 ALOGE("@@##THREAD_FADE_IN_UPPER_SPEAKER thread create fail");
4630 }
4631 }
4632 pthread_mutex_unlock(&adev->dummybuf_thread_lock);
4633 /* Then, dummybuf_thread_close() is called by tfa9895_config_thread() */
4634 }
4635 }
4636 audio_device_ref_count++;
4637
4638 ALOGV("%s: exit", __func__);
4639 return 0;
4640 }
4641
4642 static struct hw_module_methods_t hal_module_methods = {
4643 .open = adev_open,
4644 };
4645
4646 struct audio_module HAL_MODULE_INFO_SYM = {
4647 .common = {
4648 .tag = HARDWARE_MODULE_TAG,
4649 .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
4650 .hal_api_version = HARDWARE_HAL_API_VERSION,
4651 .id = AUDIO_HARDWARE_MODULE_ID,
4652 .name = "NVIDIA Tegra Audio HAL",
4653 .author = "The Android Open Source Project",
4654 .methods = &hal_module_methods,
4655 },
4656 };
4657