blob: 8b9147503874d3c5c75b1b264a3aa160c465b346 [file] [log] [blame]
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001/*
Aalique Grahame22e49102018-12-18 14:23:57 -08002 * Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -07003 * Not a Contribution.
4 *
Shiv Maliyappanahalli8911f282014-01-10 15:56:19 -08005 * Copyright (C) 2013 The Android Open Source Project
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
Jitendra Naruka1b6513f2014-11-22 19:34:13 -080018 *
19 * This file was modified by DTS, Inc. The portions of the
20 * code modified by DTS, Inc are copyrighted and
21 * licensed separately, as follows:
22 *
23 * (C) 2014 DTS, Inc.
24 *
25 * Licensed under the Apache License, Version 2.0 (the "License");
26 * you may not use this file except in compliance with the License.
27 * You may obtain a copy of the License at
28 *
29 * http://www.apache.org/licenses/LICENSE-2.0
30 *
31 * Unless required by applicable law or agreed to in writing, software
32 * distributed under the License is distributed on an "AS IS" BASIS,
33 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
34 * See the License for the specific language governing permissions and
35 * limitations under the License.
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080036 */
37
38#define LOG_TAG "audio_hw_primary"
Haynes Mathew George5beddd42016-06-27 18:33:40 -070039#define ATRACE_TAG (ATRACE_TAG_AUDIO|ATRACE_TAG_HAL)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080040/*#define LOG_NDEBUG 0*/
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070041/*#define VERY_VERY_VERBOSE_LOGGING*/
42#ifdef VERY_VERY_VERBOSE_LOGGING
43#define ALOGVV ALOGV
44#else
45#define ALOGVV(a...) do { } while(0)
46#endif
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080047
48#include <errno.h>
49#include <pthread.h>
50#include <stdint.h>
51#include <sys/time.h>
52#include <stdlib.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080053#include <math.h>
Eric Laurentc4aef752013-09-12 17:45:53 -070054#include <dlfcn.h>
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070055#include <sys/resource.h>
56#include <sys/prctl.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080057
Aalique Grahame22e49102018-12-18 14:23:57 -080058#include <log/log.h>
Haynes Mathew George5beddd42016-06-27 18:33:40 -070059#include <cutils/trace.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080060#include <cutils/str_parms.h>
61#include <cutils/properties.h>
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070062#include <cutils/atomic.h>
63#include <cutils/sched_policy.h>
Eric Laurentb23d5282013-05-14 15:27:20 -070064#include <hardware/audio_effect.h>
Haynes Mathew George484e8d22017-07-31 18:55:17 -070065#include <hardware/audio_alsaops.h>
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070066#include <system/thread_defs.h>
Haynes Mathew George16081042017-05-31 17:16:49 -070067#include <tinyalsa/asoundlib.h>
Eric Laurentb23d5282013-05-14 15:27:20 -070068#include <audio_effects/effect_aec.h>
69#include <audio_effects/effect_ns.h>
Ashish Jainf1eaa582016-05-23 20:54:24 +053070#include <audio_utils/format.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080071#include "audio_hw.h"
Wei Wangf7ca6c92017-11-21 14:51:20 -080072#include "audio_perf.h"
Eric Laurentb23d5282013-05-14 15:27:20 -070073#include "platform_api.h"
74#include <platform.h>
Apoorv Raghuvanshi9eaf94e2013-10-04 16:13:44 -070075#include "audio_extn.h"
Narsinga Rao Chella05573b72013-11-15 15:21:40 -080076#include "voice_extn.h"
Ashish Jaind5694242017-09-05 20:09:06 +053077#include "ip_hdlr_intf.h"
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080078
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070079#include "sound/compress_params.h"
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -080080#include "sound/asound.h"
ApurupaPattapu2e084df2013-12-18 15:47:59 -080081
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +053082#ifdef DYNAMIC_LOG_ENABLED
83#include <log_xml_parser.h>
84#define LOG_MASK HAL_MOD_FILE_AUDIO_HW
85#include <log_utils.h>
86#endif
87
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070088#define COMPRESS_OFFLOAD_NUM_FRAGMENTS 4
Ashish Jain5106d362016-05-11 19:23:33 +053089/*DIRECT PCM has same buffer sizes as DEEP Buffer*/
90#define DIRECT_PCM_NUM_FRAGMENTS 2
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070091#define COMPRESS_PLAYBACK_VOLUME_MAX 0x2000
Vikram Panduranga93f080e2017-06-07 18:16:14 -070092#define VOIP_PLAYBACK_VOLUME_MAX 0x2000
Arun Mirpuri5d170872019-03-26 13:21:31 -070093#define MMAP_PLAYBACK_VOLUME_MAX 0x2000
Ramu Gottipati97bdcfb2018-04-13 17:58:24 +053094#define PCM_PLAYBACK_VOLUME_MAX 0x2000
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +053095#define DSD_VOLUME_MIN_DB (-110)
Aniket Kumar Lata8426d1f2019-06-10 15:25:53 -070096#define INVALID_OUT_VOLUME -1
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070097
Aalique Grahame22e49102018-12-18 14:23:57 -080098#define RECORD_GAIN_MIN 0.0f
99#define RECORD_GAIN_MAX 1.0f
100#define RECORD_VOLUME_CTL_MAX 0x2000
101
102/* treat as unsigned Q1.13 */
103#define APP_TYPE_GAIN_DEFAULT 0x2000
104
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700105#define PROXY_OPEN_RETRY_COUNT 100
106#define PROXY_OPEN_WAIT_TIME 20
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800107
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800108#define GET_USECASE_AUDIO_PLAYBACK_PRIMARY(db) \
109 (db)? USECASE_AUDIO_PLAYBACK_DEEP_BUFFER : \
110 USECASE_AUDIO_PLAYBACK_LOW_LATENCY
111#define GET_PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY(db) \
112 (db)? pcm_config_deep_buffer : pcm_config_low_latency
Haynes Mathew Georgebf143712013-12-03 13:02:53 -0800113
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700114#define ULL_PERIOD_SIZE (DEFAULT_OUTPUT_SAMPLING_RATE/1000)
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700115#define DEFAULT_VOIP_BUF_DURATION_MS 20
116#define DEFAULT_VOIP_BIT_DEPTH_BYTE sizeof(int16_t)
117#define DEFAULT_VOIP_SAMP_RATE 48000
118
119#define VOIP_IO_BUF_SIZE(SR, DURATION_MS, BIT_DEPTH) (SR)/1000 * DURATION_MS * BIT_DEPTH
120
121struct pcm_config default_pcm_config_voip_copp = {
122 .channels = 1,
123 .rate = DEFAULT_VOIP_SAMP_RATE, /* changed when the stream is opened */
124 .period_size = VOIP_IO_BUF_SIZE(DEFAULT_VOIP_SAMP_RATE, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2,
125 .period_count = 2,
126 .format = PCM_FORMAT_S16_LE,
kunleiz95b597a2017-10-23 17:07:33 +0800127 .avail_min = VOIP_IO_BUF_SIZE(DEFAULT_VOIP_SAMP_RATE, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2,
128 .stop_threshold = INT_MAX,
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700129};
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700130
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700131#define MIN_CHANNEL_COUNT 1
132#define DEFAULT_CHANNEL_COUNT 2
133#define MAX_HIFI_CHANNEL_COUNT 8
134
Aalique Grahame22e49102018-12-18 14:23:57 -0800135#ifndef MAX_TARGET_SPECIFIC_CHANNEL_CNT
136#define MAX_CHANNEL_COUNT 1
137#else
138#define MAX_CHANNEL_COUNT atoi(XSTR(MAX_TARGET_SPECIFIC_CHANNEL_CNT))
139#define XSTR(x) STR(x)
140#define STR(x) #x
141#endif
142
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -0700143static unsigned int configured_low_latency_capture_period_size =
144 LOW_LATENCY_CAPTURE_PERIOD_SIZE;
145
Haynes Mathew George16081042017-05-31 17:16:49 -0700146#define MMAP_PERIOD_SIZE (DEFAULT_OUTPUT_SAMPLING_RATE/1000)
147#define MMAP_PERIOD_COUNT_MIN 32
148#define MMAP_PERIOD_COUNT_MAX 512
149#define MMAP_PERIOD_COUNT_DEFAULT (MMAP_PERIOD_COUNT_MAX)
150
Aalique Grahame22e49102018-12-18 14:23:57 -0800151/* This constant enables extended precision handling.
152 * TODO The flag is off until more testing is done.
153 */
154static const bool k_enable_extended_precision = false;
Arun Mirpurie008ed22019-03-21 11:21:04 -0700155extern int AUDIO_DEVICE_IN_ALL_CODEC_BACKEND;
Aalique Grahame22e49102018-12-18 14:23:57 -0800156
Eric Laurentb23d5282013-05-14 15:27:20 -0700157struct pcm_config pcm_config_deep_buffer = {
158 .channels = 2,
159 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
160 .period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE,
161 .period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT,
162 .format = PCM_FORMAT_S16_LE,
163 .start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
164 .stop_threshold = INT_MAX,
165 .avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
166};
167
168struct pcm_config pcm_config_low_latency = {
169 .channels = 2,
170 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
171 .period_size = LOW_LATENCY_OUTPUT_PERIOD_SIZE,
172 .period_count = LOW_LATENCY_OUTPUT_PERIOD_COUNT,
173 .format = PCM_FORMAT_S16_LE,
174 .start_threshold = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
175 .stop_threshold = INT_MAX,
176 .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
177};
178
Vignesh Kulothungana6927272019-02-20 15:17:07 -0800179struct pcm_config pcm_config_haptics_audio = {
180 .channels = 1,
181 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
182 .period_size = LOW_LATENCY_OUTPUT_PERIOD_SIZE,
183 .period_count = LOW_LATENCY_OUTPUT_PERIOD_COUNT,
184 .format = PCM_FORMAT_S16_LE,
185 .start_threshold = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
186 .stop_threshold = INT_MAX,
187 .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
188};
189
190struct pcm_config pcm_config_haptics = {
191 .channels = 1,
192 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
193 .period_size = LOW_LATENCY_OUTPUT_PERIOD_SIZE,
194 .period_count = LOW_LATENCY_OUTPUT_PERIOD_COUNT,
195 .format = PCM_FORMAT_S16_LE,
196 .start_threshold = LOW_LATENCY_OUTPUT_PERIOD_SIZE,
197 .stop_threshold = INT_MAX,
198 .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
199};
200
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700201static int af_period_multiplier = 4;
202struct pcm_config pcm_config_rt = {
203 .channels = 2,
204 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
205 .period_size = ULL_PERIOD_SIZE, //1 ms
206 .period_count = 512, //=> buffer size is 512ms
207 .format = PCM_FORMAT_S16_LE,
208 .start_threshold = ULL_PERIOD_SIZE*8, //8ms
209 .stop_threshold = INT_MAX,
210 .silence_threshold = 0,
211 .silence_size = 0,
212 .avail_min = ULL_PERIOD_SIZE, //1 ms
213};
214
Eric Laurentb23d5282013-05-14 15:27:20 -0700215struct pcm_config pcm_config_hdmi_multi = {
216 .channels = HDMI_MULTI_DEFAULT_CHANNEL_COUNT, /* changed when the stream is opened */
217 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, /* changed when the stream is opened */
218 .period_size = HDMI_MULTI_PERIOD_SIZE,
219 .period_count = HDMI_MULTI_PERIOD_COUNT,
220 .format = PCM_FORMAT_S16_LE,
221 .start_threshold = 0,
222 .stop_threshold = INT_MAX,
223 .avail_min = 0,
224};
225
Haynes Mathew George16081042017-05-31 17:16:49 -0700226struct pcm_config pcm_config_mmap_playback = {
227 .channels = 2,
228 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
229 .period_size = MMAP_PERIOD_SIZE,
230 .period_count = MMAP_PERIOD_COUNT_DEFAULT,
231 .format = PCM_FORMAT_S16_LE,
232 .start_threshold = MMAP_PERIOD_SIZE*8,
233 .stop_threshold = INT32_MAX,
234 .silence_threshold = 0,
235 .silence_size = 0,
236 .avail_min = MMAP_PERIOD_SIZE, //1 ms
237};
238
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700239struct pcm_config pcm_config_hifi = {
240 .channels = DEFAULT_CHANNEL_COUNT, /* changed when the stream is opened */
241 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, /* changed when the stream is opened */
242 .period_size = HIFI_BUFFER_OUTPUT_PERIOD_SIZE, /* change #define */
243 .period_count = HIFI_BUFFER_OUTPUT_PERIOD_COUNT,
244 .format = PCM_FORMAT_S24_3LE,
245 .start_threshold = 0,
246 .stop_threshold = INT_MAX,
247 .avail_min = 0,
248};
249
Eric Laurentb23d5282013-05-14 15:27:20 -0700250struct pcm_config pcm_config_audio_capture = {
251 .channels = 2,
Eric Laurentb23d5282013-05-14 15:27:20 -0700252 .period_count = AUDIO_CAPTURE_PERIOD_COUNT,
253 .format = PCM_FORMAT_S16_LE,
254};
255
Haynes Mathew George16081042017-05-31 17:16:49 -0700256struct pcm_config pcm_config_mmap_capture = {
257 .channels = 2,
258 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
259 .period_size = MMAP_PERIOD_SIZE,
260 .period_count = MMAP_PERIOD_COUNT_DEFAULT,
261 .format = PCM_FORMAT_S16_LE,
262 .start_threshold = 0,
263 .stop_threshold = INT_MAX,
264 .silence_threshold = 0,
265 .silence_size = 0,
266 .avail_min = MMAP_PERIOD_SIZE, //1 ms
267};
268
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700269#define AFE_PROXY_CHANNEL_COUNT 2
270#define AFE_PROXY_SAMPLING_RATE 48000
271
272#define AFE_PROXY_PLAYBACK_PERIOD_SIZE 768
273#define AFE_PROXY_PLAYBACK_PERIOD_COUNT 4
274
275struct pcm_config pcm_config_afe_proxy_playback = {
276 .channels = AFE_PROXY_CHANNEL_COUNT,
277 .rate = AFE_PROXY_SAMPLING_RATE,
278 .period_size = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
279 .period_count = AFE_PROXY_PLAYBACK_PERIOD_COUNT,
280 .format = PCM_FORMAT_S16_LE,
281 .start_threshold = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
282 .stop_threshold = INT_MAX,
283 .avail_min = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
284};
285
286#define AFE_PROXY_RECORD_PERIOD_SIZE 768
287#define AFE_PROXY_RECORD_PERIOD_COUNT 4
288
Aalique Grahame22e49102018-12-18 14:23:57 -0800289struct pcm_config pcm_config_audio_capture_rt = {
290 .channels = 2,
291 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
292 .period_size = ULL_PERIOD_SIZE,
293 .period_count = 512,
294 .format = PCM_FORMAT_S16_LE,
295 .start_threshold = 0,
296 .stop_threshold = AFE_PROXY_RECORD_PERIOD_SIZE * AFE_PROXY_RECORD_PERIOD_COUNT,
297 .silence_threshold = 0,
298 .silence_size = 0,
299 .avail_min = ULL_PERIOD_SIZE, //1 ms
300};
301
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700302struct pcm_config pcm_config_afe_proxy_record = {
303 .channels = AFE_PROXY_CHANNEL_COUNT,
304 .rate = AFE_PROXY_SAMPLING_RATE,
305 .period_size = AFE_PROXY_RECORD_PERIOD_SIZE,
306 .period_count = AFE_PROXY_RECORD_PERIOD_COUNT,
307 .format = PCM_FORMAT_S16_LE,
308 .start_threshold = AFE_PROXY_RECORD_PERIOD_SIZE,
309 .stop_threshold = INT_MAX,
310 .avail_min = AFE_PROXY_RECORD_PERIOD_SIZE,
311};
312
Ashish Jainf1eaa582016-05-23 20:54:24 +0530313#define AUDIO_MAX_PCM_FORMATS 7
314
315const uint32_t format_to_bitwidth_table[AUDIO_MAX_PCM_FORMATS] = {
316 [AUDIO_FORMAT_DEFAULT] = 0,
317 [AUDIO_FORMAT_PCM_16_BIT] = sizeof(uint16_t),
318 [AUDIO_FORMAT_PCM_8_BIT] = sizeof(uint8_t),
319 [AUDIO_FORMAT_PCM_32_BIT] = sizeof(uint32_t),
320 [AUDIO_FORMAT_PCM_8_24_BIT] = sizeof(uint32_t),
321 [AUDIO_FORMAT_PCM_FLOAT] = sizeof(float),
322 [AUDIO_FORMAT_PCM_24_BIT_PACKED] = sizeof(uint8_t) * 3,
323};
324
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -0800325const char * const use_case_table[AUDIO_USECASE_MAX] = {
Eric Laurentb23d5282013-05-14 15:27:20 -0700326 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = "deep-buffer-playback",
327 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = "low-latency-playback",
Vignesh Kulothungana6927272019-02-20 15:17:07 -0800328 [USECASE_AUDIO_PLAYBACK_WITH_HAPTICS] = "audio-with-haptics-playback",
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -0700329 [USECASE_AUDIO_PLAYBACK_ULL] = "audio-ull-playback",
330 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = "multi-channel-playback",
Shruthi Krishnaace10852013-10-25 14:32:12 -0700331 [USECASE_AUDIO_PLAYBACK_OFFLOAD] = "compress-offload-playback",
vivek mehta446c3962015-09-14 10:57:35 -0700332 //Enabled for Direct_PCM
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700333 [USECASE_AUDIO_PLAYBACK_OFFLOAD2] = "compress-offload-playback2",
334 [USECASE_AUDIO_PLAYBACK_OFFLOAD3] = "compress-offload-playback3",
335 [USECASE_AUDIO_PLAYBACK_OFFLOAD4] = "compress-offload-playback4",
336 [USECASE_AUDIO_PLAYBACK_OFFLOAD5] = "compress-offload-playback5",
337 [USECASE_AUDIO_PLAYBACK_OFFLOAD6] = "compress-offload-playback6",
338 [USECASE_AUDIO_PLAYBACK_OFFLOAD7] = "compress-offload-playback7",
339 [USECASE_AUDIO_PLAYBACK_OFFLOAD8] = "compress-offload-playback8",
340 [USECASE_AUDIO_PLAYBACK_OFFLOAD9] = "compress-offload-playback9",
Haynes Mathew George16081042017-05-31 17:16:49 -0700341 [USECASE_AUDIO_PLAYBACK_FM] = "play-fm",
342 [USECASE_AUDIO_PLAYBACK_MMAP] = "mmap-playback",
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700343 [USECASE_AUDIO_PLAYBACK_HIFI] = "hifi-playback",
Aalique Grahame22e49102018-12-18 14:23:57 -0800344 [USECASE_AUDIO_PLAYBACK_TTS] = "audio-tts-playback",
vivek mehta0ea887a2015-08-26 14:01:20 -0700345
Eric Laurentb23d5282013-05-14 15:27:20 -0700346 [USECASE_AUDIO_RECORD] = "audio-record",
Mingming Yine62d7842013-10-25 16:26:03 -0700347 [USECASE_AUDIO_RECORD_COMPRESS] = "audio-record-compress",
Dhananjay Kumaree4d2002016-10-25 18:02:58 +0530348 [USECASE_AUDIO_RECORD_COMPRESS2] = "audio-record-compress2",
349 [USECASE_AUDIO_RECORD_COMPRESS3] = "audio-record-compress3",
350 [USECASE_AUDIO_RECORD_COMPRESS4] = "audio-record-compress4",
Dhananjay Kumar376e38b2017-09-28 22:26:23 +0530351 [USECASE_AUDIO_RECORD_COMPRESS5] = "audio-record-compress5",
352 [USECASE_AUDIO_RECORD_COMPRESS6] = "audio-record-compress6",
Eric Laurentb23d5282013-05-14 15:27:20 -0700353 [USECASE_AUDIO_RECORD_LOW_LATENCY] = "low-latency-record",
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700354 [USECASE_AUDIO_RECORD_FM_VIRTUAL] = "fm-virtual-record",
Haynes Mathew George16081042017-05-31 17:16:49 -0700355 [USECASE_AUDIO_RECORD_MMAP] = "mmap-record",
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700356 [USECASE_AUDIO_RECORD_HIFI] = "hifi-record",
Haynes Mathew George16081042017-05-31 17:16:49 -0700357
Vimal Puthanveed5b4d3f12013-11-05 15:57:39 -0800358 [USECASE_AUDIO_HFP_SCO] = "hfp-sco",
Vimal Puthanveed47e64852013-12-20 13:23:39 -0800359 [USECASE_AUDIO_HFP_SCO_WB] = "hfp-sco-wb",
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700360 [USECASE_VOICE_CALL] = "voice-call",
Mingming Yin3ee55c62014-08-04 14:23:35 -0700361
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700362 [USECASE_VOICE2_CALL] = "voice2-call",
363 [USECASE_VOLTE_CALL] = "volte-call",
364 [USECASE_QCHAT_CALL] = "qchat-call",
Vicky Sehrawat7e4fc152014-02-12 17:58:59 -0800365 [USECASE_VOWLAN_CALL] = "vowlan-call",
Vidyakumar Athota0e109352015-02-12 17:38:22 -0800366 [USECASE_VOICEMMODE1_CALL] = "voicemmode1-call",
367 [USECASE_VOICEMMODE2_CALL] = "voicemmode2-call",
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800368 [USECASE_COMPRESS_VOIP_CALL] = "compress-voip-call",
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700369 [USECASE_INCALL_REC_UPLINK] = "incall-rec-uplink",
370 [USECASE_INCALL_REC_DOWNLINK] = "incall-rec-downlink",
371 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = "incall-rec-uplink-and-downlink",
Helen Zenge56b4852013-12-03 16:54:40 -0800372 [USECASE_INCALL_REC_UPLINK_COMPRESS] = "incall-rec-uplink-compress",
373 [USECASE_INCALL_REC_DOWNLINK_COMPRESS] = "incall-rec-downlink-compress",
374 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS] = "incall-rec-uplink-and-downlink-compress",
375
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -0700376 [USECASE_INCALL_MUSIC_UPLINK] = "incall_music_uplink",
377 [USECASE_INCALL_MUSIC_UPLINK2] = "incall_music_uplink2",
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700378 [USECASE_AUDIO_SPKR_CALIB_RX] = "spkr-rx-calib",
379 [USECASE_AUDIO_SPKR_CALIB_TX] = "spkr-vi-record",
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700380
381 [USECASE_AUDIO_PLAYBACK_AFE_PROXY] = "afe-proxy-playback",
382 [USECASE_AUDIO_RECORD_AFE_PROXY] = "afe-proxy-record",
Md Mansoor Ahmeddb1b4f92018-01-25 18:56:31 +0530383 [USECASE_AUDIO_PLAYBACK_SILENCE] = "silence-playback",
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700384
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530385 /* Transcode loopback cases */
Surendar Karka93cd25a2018-08-28 14:21:37 +0530386 [USECASE_AUDIO_TRANSCODE_LOOPBACK_RX] = "audio-transcode-loopback-rx",
387 [USECASE_AUDIO_TRANSCODE_LOOPBACK_TX] = "audio-transcode-loopback-tx",
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700388
389 [USECASE_AUDIO_PLAYBACK_VOIP] = "audio-playback-voip",
390 [USECASE_AUDIO_RECORD_VOIP] = "audio-record-voip",
Varun Balaraje49253e2017-07-06 19:48:56 +0530391 /* For Interactive Audio Streams */
392 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM1] = "audio-interactive-stream1",
393 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM2] = "audio-interactive-stream2",
394 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM3] = "audio-interactive-stream3",
395 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM4] = "audio-interactive-stream4",
396 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM5] = "audio-interactive-stream5",
397 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM6] = "audio-interactive-stream6",
398 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM7] = "audio-interactive-stream7",
399 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM8] = "audio-interactive-stream8",
Garmond Leunge2433c32017-09-28 21:51:22 -0700400
Aniket Kumar Lata7fd86e12018-02-20 19:26:10 -0800401 [USECASE_AUDIO_EC_REF_LOOPBACK] = "ec-ref-audio-capture",
402
Derek Chenf6318be2017-06-12 17:16:24 -0400403 [USECASE_AUDIO_A2DP_ABR_FEEDBACK] = "a2dp-abr-feedback",
404
405 [USECASE_AUDIO_PLAYBACK_MEDIA] = "media-playback",
406 [USECASE_AUDIO_PLAYBACK_SYS_NOTIFICATION] = "sys-notification-playback",
407 [USECASE_AUDIO_PLAYBACK_NAV_GUIDANCE] = "nav-guidance-playback",
408 [USECASE_AUDIO_PLAYBACK_PHONE] = "phone-playback",
Eric Laurentb23d5282013-05-14 15:27:20 -0700409};
410
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700411static const audio_usecase_t offload_usecases[] = {
412 USECASE_AUDIO_PLAYBACK_OFFLOAD,
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700413 USECASE_AUDIO_PLAYBACK_OFFLOAD2,
414 USECASE_AUDIO_PLAYBACK_OFFLOAD3,
415 USECASE_AUDIO_PLAYBACK_OFFLOAD4,
416 USECASE_AUDIO_PLAYBACK_OFFLOAD5,
417 USECASE_AUDIO_PLAYBACK_OFFLOAD6,
418 USECASE_AUDIO_PLAYBACK_OFFLOAD7,
419 USECASE_AUDIO_PLAYBACK_OFFLOAD8,
420 USECASE_AUDIO_PLAYBACK_OFFLOAD9,
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700421};
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800422
Varun Balaraje49253e2017-07-06 19:48:56 +0530423static const audio_usecase_t interactive_usecases[] = {
424 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM1,
425 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM2,
426 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM3,
427 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM4,
428 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM5,
429 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM6,
430 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM7,
431 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM8,
432};
433
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800434#define STRING_TO_ENUM(string) { #string, string }
435
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800436struct string_to_enum {
437 const char *name;
438 uint32_t value;
439};
440
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700441static const struct string_to_enum channels_name_to_enum_table[] = {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800442 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO),
Mingming Yin3a941d42016-02-17 18:08:05 -0800443 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_2POINT1),
444 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_QUAD),
445 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_SURROUND),
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700446 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_PENTA),
Mingming Yin3a941d42016-02-17 18:08:05 -0800447 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
448 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_6POINT1),
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800449 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700450 STRING_TO_ENUM(AUDIO_CHANNEL_IN_MONO),
451 STRING_TO_ENUM(AUDIO_CHANNEL_IN_STEREO),
452 STRING_TO_ENUM(AUDIO_CHANNEL_IN_FRONT_BACK),
453 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_1),
454 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_2),
455 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_3),
456 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_4),
457 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_5),
458 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_6),
459 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_7),
460 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_8),
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800461};
462
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700463static const struct string_to_enum formats_name_to_enum_table[] = {
464 STRING_TO_ENUM(AUDIO_FORMAT_PCM_16_BIT),
465 STRING_TO_ENUM(AUDIO_FORMAT_PCM_24_BIT_PACKED),
466 STRING_TO_ENUM(AUDIO_FORMAT_PCM_32_BIT),
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700467 STRING_TO_ENUM(AUDIO_FORMAT_AC3),
468 STRING_TO_ENUM(AUDIO_FORMAT_E_AC3),
469 STRING_TO_ENUM(AUDIO_FORMAT_E_AC3_JOC),
Ben Romberger1aaaf862017-04-06 17:49:46 -0700470 STRING_TO_ENUM(AUDIO_FORMAT_DOLBY_TRUEHD),
Mingming Yin3a941d42016-02-17 18:08:05 -0800471 STRING_TO_ENUM(AUDIO_FORMAT_DTS),
472 STRING_TO_ENUM(AUDIO_FORMAT_DTS_HD),
Naresh Tanniru928f0862017-04-07 16:44:23 -0700473 STRING_TO_ENUM(AUDIO_FORMAT_IEC61937)
Mingming Yin3a941d42016-02-17 18:08:05 -0800474};
475
476//list of all supported sample rates by HDMI specification.
477static const int out_hdmi_sample_rates[] = {
478 32000, 44100, 48000, 88200, 96000, 176400, 192000,
479};
480
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700481static const struct string_to_enum out_sample_rates_name_to_enum_table[] = {
Mingming Yin3a941d42016-02-17 18:08:05 -0800482 STRING_TO_ENUM(32000),
483 STRING_TO_ENUM(44100),
484 STRING_TO_ENUM(48000),
485 STRING_TO_ENUM(88200),
486 STRING_TO_ENUM(96000),
487 STRING_TO_ENUM(176400),
488 STRING_TO_ENUM(192000),
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700489};
490
Carter Hsu2e429db2019-05-14 18:50:52 +0800491struct in_effect_list {
492 struct listnode list;
493 effect_handle_t handle;
494};
495
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700496static struct audio_device *adev = NULL;
Ben Romberger02ab1192018-05-24 12:10:08 -0700497static pthread_mutex_t adev_init_lock = PTHREAD_MUTEX_INITIALIZER;
Kiran Kandi910e1862013-10-29 13:29:42 -0700498static unsigned int audio_device_ref_count;
vivek mehtab72d08d2016-04-29 03:16:47 -0700499//cache last MBDRC cal step level
500static int last_known_cal_step = -1 ;
Kiran Kandi910e1862013-10-29 13:29:42 -0700501
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +0530502static int check_a2dp_restore_l(struct audio_device *adev, struct stream_out *out, bool restore);
503static int out_set_compr_volume(struct audio_stream_out *stream, float left, float right);
Arun Mirpuri5d170872019-03-26 13:21:31 -0700504static int out_set_mmap_volume(struct audio_stream_out *stream, float left, float right);
Zhou Song2b8f28f2017-09-11 10:51:38 +0800505static int out_set_voip_volume(struct audio_stream_out *stream, float left, float right);
Ramu Gottipati97bdcfb2018-04-13 17:58:24 +0530506static int out_set_pcm_volume(struct audio_stream_out *stream, float left, float right);
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +0530507
Vatsal Buchac09ae062018-11-14 13:25:08 +0530508#ifdef AUDIO_FEATURE_ENABLED_GCOV
509extern void __gcov_flush();
510static void enable_gcov()
511{
512 __gcov_flush();
513}
514#else
515static void enable_gcov()
516{
517}
518#endif
519
justinweng20fb6d82019-02-21 18:49:00 -0700520static int in_set_microphone_direction(const struct audio_stream_in *stream,
521 audio_microphone_direction_t dir);
522static int in_set_microphone_field_dimension(const struct audio_stream_in *stream, float zoom);
523
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700524static bool may_use_noirq_mode(struct audio_device *adev, audio_usecase_t uc_id,
525 int flags __unused)
526{
527 int dir = 0;
528 switch (uc_id) {
529 case USECASE_AUDIO_RECORD_LOW_LATENCY:
530 dir = 1;
531 case USECASE_AUDIO_PLAYBACK_ULL:
532 break;
533 default:
534 return false;
535 }
536
537 int dev_id = platform_get_pcm_device_id(uc_id, dir == 0 ?
538 PCM_PLAYBACK : PCM_CAPTURE);
539 if (adev->adm_is_noirq_avail)
540 return adev->adm_is_noirq_avail(adev->adm_data,
541 adev->snd_card, dev_id, dir);
542 return false;
543}
544
545static void register_out_stream(struct stream_out *out)
546{
547 struct audio_device *adev = out->dev;
548 if (is_offload_usecase(out->usecase) ||
549 !adev->adm_register_output_stream)
550 return;
551
552 // register stream first for backward compatibility
553 adev->adm_register_output_stream(adev->adm_data,
554 out->handle,
555 out->flags);
556
557 if (!adev->adm_set_config)
558 return;
559
560 if (out->realtime)
561 adev->adm_set_config(adev->adm_data,
562 out->handle,
563 out->pcm, &out->config);
564}
565
566static void register_in_stream(struct stream_in *in)
567{
568 struct audio_device *adev = in->dev;
569 if (!adev->adm_register_input_stream)
570 return;
571
572 adev->adm_register_input_stream(adev->adm_data,
573 in->capture_handle,
574 in->flags);
575
576 if (!adev->adm_set_config)
577 return;
578
579 if (in->realtime)
580 adev->adm_set_config(adev->adm_data,
581 in->capture_handle,
582 in->pcm,
583 &in->config);
584}
585
586static void request_out_focus(struct stream_out *out, long ns)
587{
588 struct audio_device *adev = out->dev;
589
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700590 if (adev->adm_request_focus_v2)
591 adev->adm_request_focus_v2(adev->adm_data, out->handle, ns);
592 else if (adev->adm_request_focus)
593 adev->adm_request_focus(adev->adm_data, out->handle);
594}
595
Aniket Kumar Lata60586a92019-05-22 22:18:55 -0700596static int request_in_focus(struct stream_in *in, long ns)
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700597{
598 struct audio_device *adev = in->dev;
Aniket Kumar Lata60586a92019-05-22 22:18:55 -0700599 int ret = 0;
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700600
Aniket Kumar Lata60586a92019-05-22 22:18:55 -0700601 if (adev->adm_request_focus_v2_1)
602 ret = adev->adm_request_focus_v2_1(adev->adm_data, in->capture_handle, ns);
603 else if (adev->adm_request_focus_v2)
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700604 adev->adm_request_focus_v2(adev->adm_data, in->capture_handle, ns);
605 else if (adev->adm_request_focus)
606 adev->adm_request_focus(adev->adm_data, in->capture_handle);
Aniket Kumar Lata60586a92019-05-22 22:18:55 -0700607
608 return ret;
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700609}
610
611static void release_out_focus(struct stream_out *out)
612{
613 struct audio_device *adev = out->dev;
614
615 if (adev->adm_abandon_focus)
616 adev->adm_abandon_focus(adev->adm_data, out->handle);
617}
618
619static void release_in_focus(struct stream_in *in)
620{
621 struct audio_device *adev = in->dev;
622 if (adev->adm_abandon_focus)
623 adev->adm_abandon_focus(adev->adm_data, in->capture_handle);
624}
625
Dhananjay Kumare6293dd2017-05-25 17:25:30 +0530626static int parse_snd_card_status(struct str_parms *parms, int *card,
627 card_status_t *status)
628{
629 char value[32]={0};
630 char state[32]={0};
631
632 int ret = str_parms_get_str(parms, "SND_CARD_STATUS", value, sizeof(value));
633 if (ret < 0)
634 return -1;
635
636 // sscanf should be okay as value is of max length 32.
637 // same as sizeof state.
638 if (sscanf(value, "%d,%s", card, state) < 2)
639 return -1;
640
641 *status = !strcmp(state, "ONLINE") ? CARD_STATUS_ONLINE :
642 CARD_STATUS_OFFLINE;
643 return 0;
644}
645
Haynes Mathew Georgeb0f5dc32017-10-06 18:35:12 -0700646static inline void adjust_frames_for_device_delay(struct stream_out *out,
647 uint32_t *dsp_frames) {
648 // Adjustment accounts for A2dp encoder latency with offload usecases
649 // Note: Encoder latency is returned in ms.
650 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
651 unsigned long offset =
652 (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
653 *dsp_frames = (*dsp_frames > offset) ? (*dsp_frames - offset) : 0;
654 }
655}
656
vivek mehtaa76401a2015-04-24 14:12:15 -0700657__attribute__ ((visibility ("default")))
658bool audio_hw_send_gain_dep_calibration(int level) {
659 bool ret_val = false;
vivek mehtab72d08d2016-04-29 03:16:47 -0700660 ALOGV("%s: called ...", __func__);
vivek mehtaa76401a2015-04-24 14:12:15 -0700661
662 pthread_mutex_lock(&adev_init_lock);
663
664 if (adev != NULL && adev->platform != NULL) {
665 pthread_mutex_lock(&adev->lock);
666 ret_val = platform_send_gain_dep_cal(adev->platform, level);
vivek mehtab72d08d2016-04-29 03:16:47 -0700667
Preetam Singh Ranawatf4ae0222017-05-31 17:07:28 +0530668 // cache level info for any of the use case which
669 // was not started.
670 last_known_cal_step = level;;
vivek mehtab72d08d2016-04-29 03:16:47 -0700671
vivek mehtaa76401a2015-04-24 14:12:15 -0700672 pthread_mutex_unlock(&adev->lock);
673 } else {
674 ALOGE("%s: %s is NULL", __func__, adev == NULL ? "adev" : "adev->platform");
675 }
676
677 pthread_mutex_unlock(&adev_init_lock);
678
679 return ret_val;
680}
681
Ashish Jain5106d362016-05-11 19:23:33 +0530682static int check_and_set_gapless_mode(struct audio_device *adev, bool enable_gapless)
683{
Krishnankutty Kolathappilly6d8788b2014-01-09 12:45:31 -0800684 bool gapless_enabled = false;
685 const char *mixer_ctl_name = "Compress Gapless Playback";
686 struct mixer_ctl *ctl;
687
688 ALOGV("%s:", __func__);
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700689 gapless_enabled = property_get_bool("vendor.audio.offload.gapless.enabled", false);
Ashish Jain5106d362016-05-11 19:23:33 +0530690
691 /*Disable gapless if its AV playback*/
692 gapless_enabled = gapless_enabled && enable_gapless;
Krishnankutty Kolathappilly6d8788b2014-01-09 12:45:31 -0800693
694 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
695 if (!ctl) {
696 ALOGE("%s: Could not get ctl for mixer cmd - %s",
697 __func__, mixer_ctl_name);
698 return -EINVAL;
699 }
700
701 if (mixer_ctl_set_value(ctl, 0, gapless_enabled) < 0) {
702 ALOGE("%s: Could not set gapless mode %d",
703 __func__, gapless_enabled);
704 return -EINVAL;
705 }
706 return 0;
707}
Haynes Mathew George5191a852013-09-11 14:19:36 -0700708
Aniket Kumar Lataf56b6402016-10-27 12:03:18 -0700709__attribute__ ((visibility ("default")))
710int audio_hw_get_gain_level_mapping(struct amp_db_and_gain_table *mapping_tbl,
711 int table_size) {
712 int ret_val = 0;
713 ALOGV("%s: enter ... ", __func__);
714
715 pthread_mutex_lock(&adev_init_lock);
716 if (adev == NULL) {
717 ALOGW("%s: adev is NULL .... ", __func__);
718 goto done;
719 }
720
721 pthread_mutex_lock(&adev->lock);
722 ret_val = platform_get_gain_level_mapping(mapping_tbl, table_size);
723 pthread_mutex_unlock(&adev->lock);
724done:
725 pthread_mutex_unlock(&adev_init_lock);
726 ALOGV("%s: exit ... ", __func__);
727 return ret_val;
728}
729
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800730bool audio_hw_send_qdsp_parameter(int stream_type, float vol, bool active)
Aalique Grahame22e49102018-12-18 14:23:57 -0800731{
732 bool ret = false;
733 ALOGV("%s: enter ...", __func__);
734
735 pthread_mutex_lock(&adev_init_lock);
736
737 if (adev != NULL && adev->platform != NULL) {
738 pthread_mutex_lock(&adev->lock);
Arun Mirpurib1bec9c2019-01-29 16:42:45 -0800739 ret = audio_extn_qdsp_set_state(adev, stream_type, vol, active);
Aalique Grahame22e49102018-12-18 14:23:57 -0800740 pthread_mutex_unlock(&adev->lock);
741 }
742
743 pthread_mutex_unlock(&adev_init_lock);
744
745 ALOGV("%s: exit with ret %d", __func__, ret);
746 return ret;
747}
Aalique Grahame22e49102018-12-18 14:23:57 -0800748
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700749static bool is_supported_format(audio_format_t format)
750{
Eric Laurent86e17132013-09-12 17:49:30 -0700751 if (format == AUDIO_FORMAT_MP3 ||
Satish Babu Patakokila0c313922016-12-08 12:07:08 +0530752 format == AUDIO_FORMAT_MP2 ||
Ashish Jainf9b78162014-08-25 20:36:25 +0530753 format == AUDIO_FORMAT_AAC_LC ||
754 format == AUDIO_FORMAT_AAC_HE_V1 ||
755 format == AUDIO_FORMAT_AAC_HE_V2 ||
Manish Dewangana6fc5442015-08-24 20:30:31 +0530756 format == AUDIO_FORMAT_AAC_ADTS_LC ||
757 format == AUDIO_FORMAT_AAC_ADTS_HE_V1 ||
758 format == AUDIO_FORMAT_AAC_ADTS_HE_V2 ||
Arun Kumar Dasari3b174182016-12-27 13:01:14 +0530759 format == AUDIO_FORMAT_AAC_LATM_LC ||
760 format == AUDIO_FORMAT_AAC_LATM_HE_V1 ||
761 format == AUDIO_FORMAT_AAC_LATM_HE_V2 ||
Ashish Jain5106d362016-05-11 19:23:33 +0530762 format == AUDIO_FORMAT_PCM_24_BIT_PACKED ||
763 format == AUDIO_FORMAT_PCM_8_24_BIT ||
Ashish Jainf1eaa582016-05-23 20:54:24 +0530764 format == AUDIO_FORMAT_PCM_FLOAT ||
765 format == AUDIO_FORMAT_PCM_32_BIT ||
vivek mehta0ea887a2015-08-26 14:01:20 -0700766 format == AUDIO_FORMAT_PCM_16_BIT ||
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +0530767 format == AUDIO_FORMAT_AC3 ||
768 format == AUDIO_FORMAT_E_AC3 ||
Ben Romberger1aaaf862017-04-06 17:49:46 -0700769 format == AUDIO_FORMAT_DOLBY_TRUEHD ||
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +0530770 format == AUDIO_FORMAT_DTS ||
771 format == AUDIO_FORMAT_DTS_HD ||
Weiyin Jiang18ac4e92015-03-15 15:03:40 +0800772 format == AUDIO_FORMAT_FLAC ||
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +0530773 format == AUDIO_FORMAT_ALAC ||
774 format == AUDIO_FORMAT_APE ||
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530775 format == AUDIO_FORMAT_DSD ||
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +0530776 format == AUDIO_FORMAT_VORBIS ||
Weiyin Jiang18ac4e92015-03-15 15:03:40 +0800777 format == AUDIO_FORMAT_WMA ||
Dhanalakshmi Siddani18737932016-11-29 17:33:17 +0530778 format == AUDIO_FORMAT_WMA_PRO ||
Naresh Tanniru928f0862017-04-07 16:44:23 -0700779 format == AUDIO_FORMAT_APTX ||
780 format == AUDIO_FORMAT_IEC61937)
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800781 return true;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700782
783 return false;
784}
785
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700786static inline bool is_mmap_usecase(audio_usecase_t uc_id)
787{
788 return (uc_id == USECASE_AUDIO_RECORD_AFE_PROXY) ||
789 (uc_id == USECASE_AUDIO_PLAYBACK_AFE_PROXY);
790}
791
Aniket Kumar Lata8426d1f2019-06-10 15:25:53 -0700792static inline bool is_valid_volume(float left, float right)
793{
794 return ((left >= 0.0f && right >= 0.0f) ? true : false);
795}
796
Avinash Vaish71a8b972014-07-24 15:36:33 +0530797static int enable_audio_route_for_voice_usecases(struct audio_device *adev,
798 struct audio_usecase *uc_info)
799{
800 struct listnode *node;
801 struct audio_usecase *usecase;
802
803 if (uc_info == NULL)
804 return -EINVAL;
805
806 /* Re-route all voice usecases on the shared backend other than the
807 specified usecase to new snd devices */
808 list_for_each(node, &adev->usecase_list) {
809 usecase = node_to_item(node, struct audio_usecase, list);
Narsinga Rao Chellae7f33c12015-01-28 15:23:34 -0800810 if ((usecase->type == VOICE_CALL) && (usecase != uc_info))
Avinash Vaish71a8b972014-07-24 15:36:33 +0530811 enable_audio_route(adev, usecase);
812 }
813 return 0;
814}
815
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +0530816static void enable_asrc_mode(struct audio_device *adev)
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +0530817{
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +0530818 ALOGV("%s", __func__);
819 audio_route_apply_and_update_path(adev->audio_route,
820 "asrc-mode");
821 adev->asrc_mode_enabled = true;
822}
823
824static void disable_asrc_mode(struct audio_device *adev)
825{
826 ALOGV("%s", __func__);
827 audio_route_reset_and_update_path(adev->audio_route,
828 "asrc-mode");
829 adev->asrc_mode_enabled = false;
830}
831
832/*
833 * - Enable ASRC mode for incoming mix path use case(Headphone backend)if Headphone
834 * 44.1 or Native DSD backends are enabled for any of current use case.
835 * e.g. 48-> + (Naitve DSD or Headphone 44.1)
836 * - Disable current mix path use case(Headphone backend) and re-enable it with
837 * ASRC mode for incoming Headphone 44.1 or Native DSD use case.
838 * e.g. Naitve DSD or Headphone 44.1 -> + 48
839 */
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530840static void check_and_set_asrc_mode(struct audio_device *adev,
841 struct audio_usecase *uc_info,
842 snd_device_t snd_device)
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +0530843{
844 ALOGV("%s snd device %d", __func__, snd_device);
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530845 int i, num_new_devices = 0;
846 snd_device_t split_new_snd_devices[SND_DEVICE_OUT_END];
847 /*
848 *Split snd device for new combo use case
849 *e.g. Headphopne 44.1-> + Ringtone (Headphone + Speaker)
850 */
851 if (platform_split_snd_device(adev->platform,
852 snd_device,
853 &num_new_devices,
854 split_new_snd_devices) == 0) {
855 for (i = 0; i < num_new_devices; i++)
856 check_and_set_asrc_mode(adev, uc_info, split_new_snd_devices[i]);
857 } else {
858 int new_backend_idx = platform_get_backend_index(snd_device);
859 if (((new_backend_idx == HEADPHONE_BACKEND) ||
860 (new_backend_idx == HEADPHONE_44_1_BACKEND) ||
861 (new_backend_idx == DSD_NATIVE_BACKEND)) &&
862 !adev->asrc_mode_enabled) {
863 struct listnode *node = NULL;
864 struct audio_usecase *uc = NULL;
865 struct stream_out *curr_out = NULL;
866 int usecase_backend_idx = DEFAULT_CODEC_BACKEND;
867 int i, num_devices, ret = 0;
868 snd_device_t split_snd_devices[SND_DEVICE_OUT_END];
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +0530869
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530870 list_for_each(node, &adev->usecase_list) {
871 uc = node_to_item(node, struct audio_usecase, list);
872 curr_out = (struct stream_out*) uc->stream.out;
873 if (curr_out && PCM_PLAYBACK == uc->type && uc != uc_info) {
874 /*
875 *Split snd device for existing combo use case
876 *e.g. Ringtone (Headphone + Speaker) + Headphopne 44.1
877 */
878 ret = platform_split_snd_device(adev->platform,
879 uc->out_snd_device,
880 &num_devices,
881 split_snd_devices);
882 if (ret < 0 || num_devices == 0) {
883 ALOGV("%s: Unable to split uc->out_snd_device: %d",__func__, uc->out_snd_device);
884 split_snd_devices[0] = uc->out_snd_device;
885 num_devices = 1;
Garmond Leung50058f62017-02-08 09:49:30 -0800886 }
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530887 for (i = 0; i < num_devices; i++) {
888 usecase_backend_idx = platform_get_backend_index(split_snd_devices[i]);
889 ALOGD("%s:snd_dev %d usecase_backend_idx %d",__func__, split_snd_devices[i],usecase_backend_idx);
890 if((new_backend_idx == HEADPHONE_BACKEND) &&
891 ((usecase_backend_idx == HEADPHONE_44_1_BACKEND) ||
892 (usecase_backend_idx == DSD_NATIVE_BACKEND))) {
893 ALOGD("%s:DSD or native stream detected enabling asrcmode in hardware",
894 __func__);
895 enable_asrc_mode(adev);
896 break;
897 } else if(((new_backend_idx == HEADPHONE_44_1_BACKEND) ||
898 (new_backend_idx == DSD_NATIVE_BACKEND)) &&
899 (usecase_backend_idx == HEADPHONE_BACKEND)) {
900 ALOGD("%s:48K stream detected, disabling and enabling it with asrcmode in hardware",
901 __func__);
902 disable_audio_route(adev, uc);
903 disable_snd_device(adev, uc->out_snd_device);
904 // Apply true-high-quality-mode if DSD or > 44.1KHz or >=24-bit
905 if (new_backend_idx == DSD_NATIVE_BACKEND)
906 audio_route_apply_and_update_path(adev->audio_route,
907 "hph-true-highquality-mode");
908 else if ((new_backend_idx == HEADPHONE_44_1_BACKEND) &&
909 (curr_out->bit_width >= 24))
910 audio_route_apply_and_update_path(adev->audio_route,
911 "hph-highquality-mode");
912 enable_asrc_mode(adev);
913 enable_snd_device(adev, uc->out_snd_device);
914 enable_audio_route(adev, uc);
915 break;
916 }
917 }
918 // reset split devices count
919 num_devices = 0;
Garmond Leung50058f62017-02-08 09:49:30 -0800920 }
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530921 if (adev->asrc_mode_enabled)
922 break;
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +0530923 }
924 }
925 }
926}
927
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700928static int send_effect_enable_disable_mixer_ctl(struct audio_device *adev,
929 struct audio_effect_config effect_config,
930 unsigned int param_value)
931{
932 char mixer_ctl_name[] = "Audio Effect";
933 struct mixer_ctl *ctl;
934 long set_values[6];
Eric Laurent637e2d42018-11-15 12:24:31 -0800935 struct stream_in *in = adev_get_active_input(adev);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700936
Aniket Kumar Lata7de63522019-06-13 11:05:18 -0700937 if (in == NULL) {
938 ALOGE("%s: active input stream is NULL", __func__);
939 return -EINVAL;
940 }
941
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700942 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
943 if (!ctl) {
944 ALOGE("%s: Could not get mixer ctl - %s",
945 __func__, mixer_ctl_name);
946 return -EINVAL;
947 }
948
949 set_values[0] = 1; //0:Rx 1:Tx
950 set_values[1] = in->app_type_cfg.app_type;
951 set_values[2] = (long)effect_config.module_id;
952 set_values[3] = (long)effect_config.instance_id;
953 set_values[4] = (long)effect_config.param_id;
954 set_values[5] = param_value;
955
956 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
957
958 return 0;
959
960}
961
962static int update_effect_param_ecns(struct audio_device *adev, unsigned int module_id,
963 int effect_type, unsigned int *param_value)
964{
965 int ret = 0;
966 struct audio_effect_config other_effect_config;
967 struct audio_usecase *usecase = NULL;
Eric Laurent637e2d42018-11-15 12:24:31 -0800968 struct stream_in *in = adev_get_active_input(adev);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700969
Aniket Kumar Lata7de63522019-06-13 11:05:18 -0700970 if (in == NULL) {
971 ALOGE("%s: active input stream is NULL", __func__);
972 return -EINVAL;
973 }
974
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700975 usecase = get_usecase_from_list(adev, in->usecase);
976 if (!usecase)
977 return -EINVAL;
978
979 ret = platform_get_effect_config_data(usecase->in_snd_device, &other_effect_config,
980 effect_type == EFFECT_AEC ? EFFECT_NS : EFFECT_AEC);
981 if (ret < 0) {
982 ALOGE("%s Failed to get effect params %d", __func__, ret);
983 return ret;
984 }
985
986 if (module_id == other_effect_config.module_id) {
987 //Same module id for AEC/NS. Values need to be combined
988 if (((effect_type == EFFECT_AEC) && (in->enable_ns)) ||
989 ((effect_type == EFFECT_NS) && (in->enable_aec))) {
990 *param_value |= other_effect_config.param_value;
991 }
992 }
993
994 return ret;
995}
996
997static int enable_disable_effect(struct audio_device *adev, int effect_type, bool enable)
Gangadhar Sb0210342019-02-22 17:39:41 +0530998{
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700999 struct audio_effect_config effect_config;
1000 struct audio_usecase *usecase = NULL;
1001 int ret = 0;
1002 unsigned int param_value = 0;
Eric Laurent637e2d42018-11-15 12:24:31 -08001003 struct stream_in *in = adev_get_active_input(adev);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07001004
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08001005 if(!voice_extn_is_dynamic_ecns_enabled())
1006 return ENOSYS;
1007
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07001008 if (!in) {
1009 ALOGE("%s: Invalid input stream", __func__);
1010 return -EINVAL;
1011 }
1012
1013 ALOGD("%s: effect_type:%d enable:%d", __func__, effect_type, enable);
1014
1015 usecase = get_usecase_from_list(adev, in->usecase);
Weiyin Jiang20d3fa62018-08-01 18:06:27 +08001016 if (usecase == NULL) {
1017 ALOGE("%s: Could not find the usecase (%d) in the list",
1018 __func__, in->usecase);
1019 return -EINVAL;
1020 }
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07001021
1022 ret = platform_get_effect_config_data(usecase->in_snd_device, &effect_config, effect_type);
1023 if (ret < 0) {
1024 ALOGE("%s Failed to get module id %d", __func__, ret);
1025 return ret;
1026 }
1027 ALOGV("%s: %d %d usecase->id:%d usecase->in_snd_device:%d", __func__, effect_config.module_id,
1028 in->app_type_cfg.app_type, usecase->id, usecase->in_snd_device);
1029
1030 if(enable)
1031 param_value = effect_config.param_value;
1032
1033 /*Special handling for AEC & NS effects Param values need to be
1034 updated if module ids are same*/
1035
1036 if ((effect_type == EFFECT_AEC) || (effect_type == EFFECT_NS)) {
1037 ret = update_effect_param_ecns(adev, effect_config.module_id, effect_type, &param_value);
1038 if (ret < 0)
1039 return ret;
1040 }
1041
1042 ret = send_effect_enable_disable_mixer_ctl(adev, effect_config, param_value);
1043
1044 return ret;
1045}
1046
1047static void check_and_enable_effect(struct audio_device *adev)
1048{
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08001049 if(!voice_extn_is_dynamic_ecns_enabled())
1050 return;
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07001051
Eric Laurent637e2d42018-11-15 12:24:31 -08001052 struct stream_in *in = adev_get_active_input(adev);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07001053
Eric Laurent637e2d42018-11-15 12:24:31 -08001054 if (in != NULL && !in->standby) {
1055 if (in->enable_aec)
1056 enable_disable_effect(adev, EFFECT_AEC, true);
1057
1058 if (in->enable_ns &&
1059 in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
1060 enable_disable_effect(adev, EFFECT_NS, true);
1061 }
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07001062 }
1063}
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07001064
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07001065int pcm_ioctl(struct pcm *pcm, int request, ...)
1066{
1067 va_list ap;
1068 void * arg;
1069 int pcm_fd = *(int*)pcm;
1070
1071 va_start(ap, request);
1072 arg = va_arg(ap, void *);
1073 va_end(ap);
1074
1075 return ioctl(pcm_fd, request, arg);
1076}
1077
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -07001078int enable_audio_route(struct audio_device *adev,
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001079 struct audio_usecase *usecase)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001080{
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001081 snd_device_t snd_device;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07001082 char mixer_path[MIXER_PATH_MAX_LENGTH];
Manish Dewangan58229382017-02-02 15:48:41 +05301083 struct stream_out *out = NULL;
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05301084 struct stream_in *in = NULL;
Soumya Managoli6993b762018-06-28 16:04:57 +05301085 int ret = 0;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001086
1087 if (usecase == NULL)
1088 return -EINVAL;
1089
1090 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
1091
Carter Hsu2e429db2019-05-14 18:50:52 +08001092 if (usecase->type == PCM_CAPTURE) {
1093 struct stream_in *in = usecase->stream.in;
1094 struct audio_usecase *uinfo;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001095 snd_device = usecase->in_snd_device;
Carter Hsu2e429db2019-05-14 18:50:52 +08001096
1097 if (in) {
1098 if (in->enable_aec || in->enable_ec_port) {
1099 audio_devices_t out_device = AUDIO_DEVICE_OUT_SPEAKER;
1100 struct listnode *node;
1101 struct audio_usecase *voip_usecase = get_usecase_from_list(adev,
1102 USECASE_AUDIO_PLAYBACK_VOIP);
1103 if (voip_usecase) {
1104 out_device = voip_usecase->stream.out->devices;
1105 } else if (adev->primary_output &&
1106 !adev->primary_output->standby) {
1107 out_device = adev->primary_output->devices;
1108 } else {
1109 list_for_each(node, &adev->usecase_list) {
1110 uinfo = node_to_item(node, struct audio_usecase, list);
1111 if (uinfo->type != PCM_CAPTURE) {
1112 out_device = uinfo->stream.out->devices;
1113 break;
1114 }
1115 }
1116 }
1117 platform_set_echo_reference(adev, true, out_device);
1118 in->ec_opened = true;
1119 }
1120 }
1121 } else if (usecase->type == TRANSCODE_LOOPBACK_TX) {
1122 snd_device = usecase->in_snd_device;
1123 } else {
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001124 snd_device = usecase->out_snd_device;
Carter Hsu2e429db2019-05-14 18:50:52 +08001125 }
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001126
Subhash Chandra Bose Naripeddy7690c562013-12-14 00:34:53 -08001127#ifdef DS1_DOLBY_DAP_ENABLED
1128 audio_extn_dolby_set_dmid(adev);
1129 audio_extn_dolby_set_endpoint(adev);
1130#endif
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -07001131 audio_extn_dolby_ds2_set_endpoint(adev);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001132 audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_BUSY);
Dhananjay Kumar45b71742014-05-29 21:47:27 +05301133 audio_extn_listen_update_stream_status(usecase, LISTEN_EVENT_STREAM_BUSY);
Ben Romberger1fafdde2015-09-09 19:43:15 -07001134 audio_extn_utils_send_app_type_cfg(adev, usecase);
Jasmine Cha4dcc1092019-03-04 18:12:47 +08001135 if (audio_extn_is_maxx_audio_enabled())
1136 audio_extn_ma_set_device(usecase);
Dhananjay Kumar14170dd2015-08-28 13:24:16 +05301137 audio_extn_utils_send_audio_calibration(adev, usecase);
Manish Dewangan58229382017-02-02 15:48:41 +05301138 if ((usecase->type == PCM_PLAYBACK) && is_offload_usecase(usecase->id)) {
1139 out = usecase->stream.out;
1140 if (out && out->compr)
1141 audio_extn_utils_compress_set_clk_rec_mode(usecase);
1142 }
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05301143
1144 if (usecase->type == PCM_CAPTURE) {
1145 in = usecase->stream.in;
1146 if (in && is_loopback_input_device(in->device)) {
1147 ALOGD("%s: set custom mtmx params v1", __func__);
1148 audio_extn_set_custom_mtmx_params_v1(adev, usecase, true);
1149 }
1150 } else {
1151 audio_extn_set_custom_mtmx_params_v2(adev, usecase, true);
1152 }
Manish Dewangan58229382017-02-02 15:48:41 +05301153
Andy Hung756ecc12018-10-19 17:47:12 -07001154 // we shouldn't truncate mixer_path
1155 ALOGW_IF(strlcpy(mixer_path, use_case_table[usecase->id], sizeof(mixer_path))
1156 >= sizeof(mixer_path), "%s: truncation on mixer path", __func__);
1157 // this also appends to mixer_path
Banajit Goswami20cdd212015-09-11 01:11:30 -07001158 platform_add_backend_name(mixer_path, snd_device, usecase);
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07001159 ALOGD("%s: apply mixer and update path: %s", __func__, mixer_path);
Soumya Managoli6993b762018-06-28 16:04:57 +05301160 ret = audio_route_apply_and_update_path(adev->audio_route, mixer_path);
1161 if (!ret && usecase->id == USECASE_AUDIO_PLAYBACK_FM) {
1162 struct str_parms *parms = str_parms_create_str("fm_restore_volume=1");
1163 if (parms) {
1164 audio_extn_fm_set_parameters(adev, parms);
1165 str_parms_destroy(parms);
1166 }
1167 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001168 ALOGV("%s: exit", __func__);
1169 return 0;
1170}
1171
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07001172int disable_audio_route(struct audio_device *adev,
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001173 struct audio_usecase *usecase)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001174{
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001175 snd_device_t snd_device;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07001176 char mixer_path[MIXER_PATH_MAX_LENGTH];
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05301177 struct stream_in *in = NULL;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001178
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05301179 if (usecase == NULL || usecase->id == USECASE_INVALID)
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001180 return -EINVAL;
1181
1182 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
Surendar Karka93cd25a2018-08-28 14:21:37 +05301183 if (usecase->type == PCM_CAPTURE || usecase->type == TRANSCODE_LOOPBACK_TX)
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001184 snd_device = usecase->in_snd_device;
1185 else
1186 snd_device = usecase->out_snd_device;
Andy Hung756ecc12018-10-19 17:47:12 -07001187 // we shouldn't truncate mixer_path
1188 ALOGW_IF(strlcpy(mixer_path, use_case_table[usecase->id], sizeof(mixer_path))
1189 >= sizeof(mixer_path), "%s: truncation on mixer path", __func__);
1190 // this also appends to mixer_path
Banajit Goswami20cdd212015-09-11 01:11:30 -07001191 platform_add_backend_name(mixer_path, snd_device, usecase);
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07001192 ALOGD("%s: reset and update mixer path: %s", __func__, mixer_path);
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001193 audio_route_reset_and_update_path(adev->audio_route, mixer_path);
Carter Hsu2e429db2019-05-14 18:50:52 +08001194 if (usecase->type == PCM_CAPTURE) {
1195 struct stream_in *in = usecase->stream.in;
1196 if (in && in->ec_opened) {
1197 platform_set_echo_reference(in->dev, false, AUDIO_DEVICE_NONE);
1198 in->ec_opened = false;
1199 }
1200 }
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001201 audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_FREE);
Dhananjay Kumar45b71742014-05-29 21:47:27 +05301202 audio_extn_listen_update_stream_status(usecase, LISTEN_EVENT_STREAM_FREE);
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05301203
1204 if (usecase->type == PCM_CAPTURE) {
1205 in = usecase->stream.in;
1206 if (in && is_loopback_input_device(in->device)) {
1207 ALOGD("%s: reset custom mtmx params v1", __func__);
1208 audio_extn_set_custom_mtmx_params_v1(adev, usecase, false);
1209 }
1210 } else {
1211 audio_extn_set_custom_mtmx_params_v2(adev, usecase, false);
1212 }
1213
Weiyin Jiang298ffd92019-06-03 14:29:30 +08001214 if ((usecase->type == PCM_PLAYBACK) &&
1215 (usecase->stream.out != NULL))
Dhanalakshmi Siddani20628c82019-01-27 17:31:09 +05301216 usecase->stream.out->pspd_coeff_sent = false;
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05301217
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001218 ALOGV("%s: exit", __func__);
1219 return 0;
1220}
1221
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -07001222int enable_snd_device(struct audio_device *adev,
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001223 snd_device_t snd_device)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001224{
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301225 int i, num_devices = 0;
1226 snd_device_t new_snd_devices[SND_DEVICE_OUT_END];
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001227 char device_name[DEVICE_NAME_MAX_SIZE] = {0};
1228
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001229 if (snd_device < SND_DEVICE_MIN ||
1230 snd_device >= SND_DEVICE_MAX) {
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08001231 ALOGE("%s: Invalid sound device %d", __func__, snd_device);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001232 return -EINVAL;
1233 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001234
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001235 if (platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0) {
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001236 ALOGE("%s: Invalid sound device returned", __func__);
1237 return -EINVAL;
1238 }
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001239
1240 adev->snd_dev_ref_cnt[snd_device]++;
1241
1242 if ((adev->snd_dev_ref_cnt[snd_device] > 1) &&
1243 (platform_split_snd_device(adev->platform,
1244 snd_device,
1245 &num_devices,
1246 new_snd_devices) != 0)) {
Eric Laurent994a6932013-07-17 11:51:42 -07001247 ALOGV("%s: snd_device(%d: %s) is already active",
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001248 __func__, snd_device, device_name);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001249 return 0;
1250 }
1251
Gopikrishnaiah Anandane85d0462014-06-30 21:41:20 -07001252 if (audio_extn_spkr_prot_is_enabled())
1253 audio_extn_spkr_prot_calib_cancel(adev);
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -07001254
Aalique Grahame22e49102018-12-18 14:23:57 -08001255 audio_extn_dsm_feedback_enable(adev, snd_device, true);
1256
Xiaojun Sang040cc9f2015-08-03 19:38:28 +08001257 if (platform_can_enable_spkr_prot_on_device(snd_device) &&
1258 audio_extn_spkr_prot_is_enabled()) {
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001259 if (platform_get_spkr_prot_acdb_id(snd_device) < 0) {
1260 goto err;
1261 }
1262 audio_extn_dev_arbi_acquire(snd_device);
1263 if (audio_extn_spkr_prot_start_processing(snd_device)) {
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -08001264 ALOGE("%s: spkr_start_processing failed", __func__);
Ravit Dennisaaee49c2015-02-04 21:26:22 +02001265 audio_extn_dev_arbi_release(snd_device);
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001266 goto err;
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -08001267 }
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001268 } else if (platform_split_snd_device(adev->platform,
1269 snd_device,
1270 &num_devices,
1271 new_snd_devices) == 0) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301272 for (i = 0; i < num_devices; i++) {
1273 enable_snd_device(adev, new_snd_devices[i]);
1274 }
Aalique Grahame22e49102018-12-18 14:23:57 -08001275 platform_set_speaker_gain_in_combo(adev, snd_device, true);
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -08001276 } else {
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07001277 ALOGD("%s: snd_device(%d: %s)", __func__, snd_device, device_name);
Naresh Tannirucd2353e2016-08-19 00:37:25 +05301278
Preetam Singh Ranawatf1d417c2017-01-10 17:00:32 +05301279
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001280 if ((SND_DEVICE_OUT_BT_A2DP == snd_device) &&
1281 (audio_extn_a2dp_start_playback() < 0)) {
1282 ALOGE(" fail to configure A2dp Source control path ");
1283 goto err;
1284 }
Florian Pfister1a84f312018-07-19 14:38:18 +02001285
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001286 if ((SND_DEVICE_IN_BT_A2DP == snd_device) &&
1287 (audio_extn_a2dp_start_capture() < 0)) {
1288 ALOGE(" fail to configure A2dp Sink control path ");
1289 goto err;
1290 }
Naresh Tannirucd2353e2016-08-19 00:37:25 +05301291
Zhou Song12c29502019-03-16 10:37:18 +08001292 if (((SND_DEVICE_OUT_BT_SCO_SWB == snd_device) ||
1293 (SND_DEVICE_IN_BT_SCO_MIC_SWB_NREC == snd_device) ||
1294 (SND_DEVICE_IN_BT_SCO_MIC_SWB == snd_device)) &&
1295 (audio_extn_sco_start_configuration() < 0)) {
1296 ALOGE(" fail to configure sco control path ");
1297 goto err;
1298 }
1299
Bharath Ramachandramurthy0de16782014-03-28 21:34:33 -07001300 /* due to the possibility of calibration overwrite between listen
1301 and audio, notify listen hal before audio calibration is sent */
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001302 audio_extn_sound_trigger_update_device_status(snd_device,
1303 ST_EVENT_SND_DEVICE_BUSY);
Dhananjay Kumar45b71742014-05-29 21:47:27 +05301304 audio_extn_listen_update_device_status(snd_device,
1305 LISTEN_EVENT_SND_DEVICE_BUSY);
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -07001306 if (platform_get_snd_device_acdb_id(snd_device) < 0) {
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001307 audio_extn_sound_trigger_update_device_status(snd_device,
1308 ST_EVENT_SND_DEVICE_FREE);
Dhananjay Kumar45b71742014-05-29 21:47:27 +05301309 audio_extn_listen_update_device_status(snd_device,
1310 LISTEN_EVENT_SND_DEVICE_FREE);
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001311 goto err;
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -07001312 }
Lior Barenboim0b61bc72014-05-13 13:01:37 +03001313 audio_extn_dev_arbi_acquire(snd_device);
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001314 audio_route_apply_and_update_path(adev->audio_route, device_name);
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301315
1316 if (SND_DEVICE_OUT_HEADPHONES == snd_device &&
1317 !adev->native_playback_enabled &&
1318 audio_is_true_native_stream_active(adev)) {
1319 ALOGD("%s: %d: napb: enabling native mode in hardware",
1320 __func__, __LINE__);
1321 audio_route_apply_and_update_path(adev->audio_route,
1322 "true-native-mode");
1323 adev->native_playback_enabled = true;
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +05301324 }
Dhanalakshmi Siddani10621622018-04-30 15:07:27 +05301325 if (((snd_device == SND_DEVICE_IN_HANDSET_6MIC) ||
1326 (snd_device == SND_DEVICE_IN_HANDSET_QMIC)) &&
Eric Laurent637e2d42018-11-15 12:24:31 -08001327 (audio_extn_ffv_get_stream() == adev_get_active_input(adev))) {
Garmond Leunge2433c32017-09-28 21:51:22 -07001328 ALOGD("%s: init ec ref loopback", __func__);
1329 audio_extn_ffv_init_ec_ref_loopback(adev, snd_device);
1330 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001331 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001332 return 0;
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001333err:
1334 adev->snd_dev_ref_cnt[snd_device]--;
1335 return -EINVAL;;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001336}
1337
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07001338int disable_snd_device(struct audio_device *adev,
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001339 snd_device_t snd_device)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001340{
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301341 int i, num_devices = 0;
1342 snd_device_t new_snd_devices[SND_DEVICE_OUT_END];
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001343 char device_name[DEVICE_NAME_MAX_SIZE] = {0};
1344
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001345 if (snd_device < SND_DEVICE_MIN ||
1346 snd_device >= SND_DEVICE_MAX) {
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08001347 ALOGE("%s: Invalid sound device %d", __func__, snd_device);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001348 return -EINVAL;
1349 }
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001350
1351 if (platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0) {
1352 ALOGE("%s: Invalid sound device returned", __func__);
1353 return -EINVAL;
1354 }
1355
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001356 if (adev->snd_dev_ref_cnt[snd_device] <= 0) {
1357 ALOGE("%s: device ref cnt is already 0", __func__);
1358 return -EINVAL;
1359 }
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001360
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001361 adev->snd_dev_ref_cnt[snd_device]--;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -07001362
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001363
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001364 if (adev->snd_dev_ref_cnt[snd_device] == 0) {
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07001365 ALOGD("%s: snd_device(%d: %s)", __func__, snd_device, device_name);
Naresh Tanniru9d027a62015-03-13 01:32:10 +05301366
Aalique Grahame22e49102018-12-18 14:23:57 -08001367 audio_extn_dsm_feedback_enable(adev, snd_device, false);
1368
Xiaojun Sang040cc9f2015-08-03 19:38:28 +08001369 if (platform_can_enable_spkr_prot_on_device(snd_device) &&
1370 audio_extn_spkr_prot_is_enabled()) {
Anish Kumar46c7b872014-09-09 01:49:44 -07001371 audio_extn_spkr_prot_stop_processing(snd_device);
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07001372
1373 // when speaker device is disabled, reset swap.
1374 // will be renabled on usecase start
1375 platform_set_swap_channels(adev, false);
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001376 } else if (platform_split_snd_device(adev->platform,
1377 snd_device,
1378 &num_devices,
1379 new_snd_devices) == 0) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301380 for (i = 0; i < num_devices; i++) {
1381 disable_snd_device(adev, new_snd_devices[i]);
1382 }
Aalique Grahame22e49102018-12-18 14:23:57 -08001383 platform_set_speaker_gain_in_combo(adev, snd_device, false);
Lior Barenboim0b61bc72014-05-13 13:01:37 +03001384 } else {
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001385 audio_route_reset_and_update_path(adev->audio_route, device_name);
Lior Barenboim0b61bc72014-05-13 13:01:37 +03001386 }
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001387
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001388 if (snd_device == SND_DEVICE_OUT_BT_A2DP)
Naresh Tannirucd2353e2016-08-19 00:37:25 +05301389 audio_extn_a2dp_stop_playback();
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001390 else if (snd_device == SND_DEVICE_IN_BT_A2DP)
Florian Pfister1a84f312018-07-19 14:38:18 +02001391 audio_extn_a2dp_stop_capture();
Zhou Songd6d71752019-05-21 18:08:51 +08001392 else if ((snd_device == SND_DEVICE_OUT_HDMI) ||
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001393 (snd_device == SND_DEVICE_OUT_DISPLAY_PORT))
Ashish Jain81eb2a82015-05-13 10:52:34 +05301394 adev->is_channel_status_set = false;
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001395 else if ((snd_device == SND_DEVICE_OUT_HEADPHONES) &&
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301396 adev->native_playback_enabled) {
1397 ALOGD("%s: %d: napb: disabling native mode in hardware",
1398 __func__, __LINE__);
1399 audio_route_reset_and_update_path(adev->audio_route,
1400 "true-native-mode");
1401 adev->native_playback_enabled = false;
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001402 } else if ((snd_device == SND_DEVICE_OUT_HEADPHONES) &&
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +05301403 adev->asrc_mode_enabled) {
1404 ALOGD("%s: %d: disabling asrc mode in hardware", __func__, __LINE__);
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +05301405 disable_asrc_mode(adev);
1406 audio_route_apply_and_update_path(adev->audio_route, "hph-lowpower-mode");
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001407 } else if (((snd_device == SND_DEVICE_IN_HANDSET_6MIC) ||
Dhanalakshmi Siddaniaf4bd622019-02-27 16:28:06 +05301408 (snd_device == SND_DEVICE_IN_HANDSET_QMIC)) &&
Eric Laurent637e2d42018-11-15 12:24:31 -08001409 (audio_extn_ffv_get_stream() == adev_get_active_input(adev))) {
Garmond Leunge2433c32017-09-28 21:51:22 -07001410 ALOGD("%s: deinit ec ref loopback", __func__);
1411 audio_extn_ffv_deinit_ec_ref_loopback(adev, snd_device);
1412 }
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001413
1414 audio_extn_utils_release_snd_device(snd_device);
1415 } else {
1416 if (platform_split_snd_device(adev->platform,
1417 snd_device,
1418 &num_devices,
1419 new_snd_devices) == 0) {
1420 for (i = 0; i < num_devices; i++) {
1421 adev->snd_dev_ref_cnt[new_snd_devices[i]]--;
1422 }
1423 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001424 }
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001425
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001426 return 0;
1427}
1428
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001429/*
1430 legend:
1431 uc - existing usecase
1432 new_uc - new usecase
1433 d1, d11, d2 - SND_DEVICE enums
1434 a1, a2 - corresponding ANDROID device enums
1435 B1, B2 - backend strings
1436
1437case 1
1438 uc->dev d1 (a1) B1
1439 new_uc->dev d1 (a1), d2 (a2) B1, B2
1440
1441 resolution: disable and enable uc->dev on d1
1442
1443case 2
1444 uc->dev d1 (a1) B1
1445 new_uc->dev d11 (a1) B1
1446
1447 resolution: need to switch uc since d1 and d11 are related
1448 (e.g. speaker and voice-speaker)
1449 use ANDROID_DEVICE_OUT enums to match devices since SND_DEVICE enums may vary
1450
1451case 3
1452 uc->dev d1 (a1) B1
1453 new_uc->dev d2 (a2) B2
1454
1455 resolution: no need to switch uc
1456
1457case 4
1458 uc->dev d1 (a1) B1
1459 new_uc->dev d2 (a2) B1
1460
1461 resolution: disable enable uc-dev on d2 since backends match
1462 we cannot enable two streams on two different devices if they
1463 share the same backend. e.g. if offload is on speaker device using
1464 QUAD_MI2S backend and a low-latency stream is started on voice-handset
1465 using the same backend, offload must also be switched to voice-handset.
1466
1467case 5
1468 uc->dev d1 (a1) B1
1469 new_uc->dev d1 (a1), d2 (a2) B1
1470
1471 resolution: disable enable uc-dev on d2 since backends match
1472 we cannot enable two streams on two different devices if they
1473 share the same backend.
1474
1475case 6
1476 uc->dev d1 (a1) B1
1477 new_uc->dev d2 (a1) B2
1478
1479 resolution: no need to switch
1480
1481case 7
1482 uc->dev d1 (a1), d2 (a2) B1, B2
1483 new_uc->dev d1 (a1) B1
1484
1485 resolution: no need to switch
1486
Zhou Song4ba65882018-07-09 14:48:07 +08001487case 8
1488 uc->dev d1 (a1) B1
1489 new_uc->dev d11 (a1), d2 (a2) B1, B2
1490 resolution: compared to case 1, for this case, d1 and d11 are related
1491 then need to do the same as case 2 to siwtch to new uc
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001492*/
1493static snd_device_t derive_playback_snd_device(void * platform,
1494 struct audio_usecase *uc,
1495 struct audio_usecase *new_uc,
1496 snd_device_t new_snd_device)
1497{
Siddartha Shaik31b530e2017-05-19 15:26:33 +05301498 audio_devices_t a1, a2;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001499
1500 snd_device_t d1 = uc->out_snd_device;
1501 snd_device_t d2 = new_snd_device;
1502
Siddartha Shaik31b530e2017-05-19 15:26:33 +05301503 switch (uc->type) {
Surendar Karka93cd25a2018-08-28 14:21:37 +05301504 case TRANSCODE_LOOPBACK_RX :
Siddartha Shaik31b530e2017-05-19 15:26:33 +05301505 a1 = uc->stream.inout->out_config.devices;
1506 a2 = new_uc->stream.inout->out_config.devices;
1507 break;
1508 default :
1509 a1 = uc->stream.out->devices;
1510 a2 = new_uc->stream.out->devices;
1511 break;
1512 }
1513
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001514 // Treat as a special case when a1 and a2 are not disjoint
1515 if ((a1 != a2) && (a1 & a2)) {
1516 snd_device_t d3[2];
1517 int num_devices = 0;
1518 int ret = platform_split_snd_device(platform,
1519 popcount(a1) > 1 ? d1 : d2,
1520 &num_devices,
1521 d3);
1522 if (ret < 0) {
1523 if (ret != -ENOSYS) {
1524 ALOGW("%s failed to split snd_device %d",
1525 __func__,
1526 popcount(a1) > 1 ? d1 : d2);
1527 }
1528 goto end;
1529 }
1530
1531 // NB: case 7 is hypothetical and isn't a practical usecase yet.
1532 // But if it does happen, we need to give priority to d2 if
1533 // the combo devices active on the existing usecase share a backend.
1534 // This is because we cannot have a usecase active on a combo device
1535 // and a new usecase requests one device in this combo pair.
1536 if (platform_check_backends_match(d3[0], d3[1])) {
1537 return d2; // case 5
1538 } else {
Garmond Leungb9eeba42018-09-18 11:10:41 -07001539 // check if d1 is related to any of d3's
1540 if (d1 == d3[0] || d1 == d3[1])
Zhou Song4ba65882018-07-09 14:48:07 +08001541 return d1; // case 1
1542 else
1543 return d3[1]; // case 8
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001544 }
1545 } else {
1546 if (platform_check_backends_match(d1, d2)) {
1547 return d2; // case 2, 4
1548 } else {
1549 return d1; // case 6, 3
1550 }
1551 }
1552
1553end:
1554 return d2; // return whatever was calculated before.
1555}
1556
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001557static void check_usecases_codec_backend(struct audio_device *adev,
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301558 struct audio_usecase *uc_info,
1559 snd_device_t snd_device)
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001560{
1561 struct listnode *node;
1562 struct audio_usecase *usecase;
1563 bool switch_device[AUDIO_USECASE_MAX];
Chaithanya Krishna Bacharaju49e7db02017-03-14 11:57:26 +05301564 snd_device_t uc_derive_snd_device;
1565 snd_device_t derive_snd_device[AUDIO_USECASE_MAX];
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001566 snd_device_t split_snd_devices[SND_DEVICE_OUT_END];
1567 int i, num_uc_to_switch = 0, num_devices = 0;
kunleiz5cd52b82016-11-07 17:22:52 +08001568 int status = 0;
Naresh Tanniru9d027a62015-03-13 01:32:10 +05301569 bool force_restart_session = false;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001570 /*
1571 * This function is to make sure that all the usecases that are active on
1572 * the hardware codec backend are always routed to any one device that is
1573 * handled by the hardware codec.
1574 * For example, if low-latency and deep-buffer usecases are currently active
1575 * on speaker and out_set_parameters(headset) is received on low-latency
1576 * output, then we have to make sure deep-buffer is also switched to headset,
1577 * because of the limitation that both the devices cannot be enabled
1578 * at the same time as they share the same backend.
1579 */
Mingming Yin3ee55c62014-08-04 14:23:35 -07001580 /*
1581 * This call is to check if we need to force routing for a particular stream
1582 * If there is a backend configuration change for the device when a
1583 * new stream starts, then ADM needs to be closed and re-opened with the new
1584 * configuraion. This call check if we need to re-route all the streams
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -08001585 * associated with the backend. Touch tone + 24 bit + native playback.
Mingming Yin3ee55c62014-08-04 14:23:35 -07001586 */
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -08001587 bool force_routing = platform_check_and_set_codec_backend_cfg(adev, uc_info,
1588 snd_device);
Naresh Tanniru9d027a62015-03-13 01:32:10 +05301589 /* For a2dp device reconfigure all active sessions
1590 * with new AFE encoder format based on a2dp state
1591 */
1592 if ((SND_DEVICE_OUT_BT_A2DP == snd_device ||
1593 SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP == snd_device) &&
1594 audio_extn_a2dp_is_force_device_switch()) {
1595 force_routing = true;
1596 force_restart_session = true;
1597 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301598 ALOGD("%s:becf: force routing %d", __func__, force_routing);
1599
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001600 /* Disable all the usecases on the shared backend other than the
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -08001601 * specified usecase.
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -08001602 */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001603 for (i = 0; i < AUDIO_USECASE_MAX; i++)
1604 switch_device[i] = false;
1605
1606 list_for_each(node, &adev->usecase_list) {
1607 usecase = node_to_item(node, struct audio_usecase, list);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -08001608
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301609 ALOGD("%s:becf: (%d) check_usecases curr device: %s, usecase device:%s "
1610 "backends match %d",__func__, i,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301611 platform_get_snd_device_name(snd_device),
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301612 platform_get_snd_device_name(usecase->out_snd_device),
1613 platform_check_backends_match(snd_device, usecase->out_snd_device));
Ashish Jain6a65b352017-03-21 17:24:40 +05301614 if ((usecase->type != PCM_CAPTURE) && (usecase != uc_info)) {
1615 uc_derive_snd_device = derive_playback_snd_device(adev->platform,
1616 usecase, uc_info, snd_device);
1617 if (((uc_derive_snd_device != usecase->out_snd_device) || force_routing) &&
1618 ((usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
1619 (usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) ||
1620 (usecase->devices & AUDIO_DEVICE_OUT_USB_DEVICE) ||
Garmond Leung2fd4f122018-06-02 16:04:53 -07001621 (usecase->devices & AUDIO_DEVICE_OUT_USB_HEADSET) ||
Ashish Jain6a65b352017-03-21 17:24:40 +05301622 (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP) ||
1623 (usecase->devices & AUDIO_DEVICE_OUT_ALL_SCO)) &&
1624 ((force_restart_session) ||
1625 (platform_check_backends_match(snd_device, usecase->out_snd_device)))) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301626 ALOGD("%s:becf: check_usecases (%s) is active on (%s) - disabling ..",
1627 __func__, use_case_table[usecase->id],
1628 platform_get_snd_device_name(usecase->out_snd_device));
1629 disable_audio_route(adev, usecase);
1630 switch_device[usecase->id] = true;
Chaithanya Krishna Bacharaju49e7db02017-03-14 11:57:26 +05301631 /* Enable existing usecase on derived playback device */
1632 derive_snd_device[usecase->id] = uc_derive_snd_device;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301633 num_uc_to_switch++;
Ashish Jain6a65b352017-03-21 17:24:40 +05301634 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001635 }
1636 }
1637
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301638 ALOGD("%s:becf: check_usecases num.of Usecases to switch %d", __func__,
1639 num_uc_to_switch);
1640
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001641 if (num_uc_to_switch) {
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001642 /* All streams have been de-routed. Disable the device */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001643
Venkata Narendra Kumar Gutta7610e632014-04-14 23:16:38 +05301644 /* Make sure the previous devices to be disabled first and then enable the
1645 selected devices */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001646 list_for_each(node, &adev->usecase_list) {
1647 usecase = node_to_item(node, struct audio_usecase, list);
1648 if (switch_device[usecase->id]) {
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001649 /* Check if output sound device to be switched can be split and if any
1650 of the split devices match with derived sound device */
1651 if (platform_split_snd_device(adev->platform, usecase->out_snd_device,
1652 &num_devices, split_snd_devices) == 0) {
1653 adev->snd_dev_ref_cnt[usecase->out_snd_device]--;
1654 for (i = 0; i < num_devices; i++) {
1655 /* Disable devices that do not match with derived sound device */
1656 if (split_snd_devices[i] != derive_snd_device[usecase->id])
1657 disable_snd_device(adev, split_snd_devices[i]);
1658 }
1659 } else {
1660 disable_snd_device(adev, usecase->out_snd_device);
1661 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001662 }
1663 }
1664
Krishnankutty Kolathappillydc4f7572013-11-01 20:07:13 -07001665 list_for_each(node, &adev->usecase_list) {
1666 usecase = node_to_item(node, struct audio_usecase, list);
1667 if (switch_device[usecase->id]) {
Weiyin Jiang0d84c8e2019-04-09 22:59:54 +08001668 if (platform_split_snd_device(adev->platform, usecase->out_snd_device,
1669 &num_devices, split_snd_devices) == 0) {
1670 /* Enable derived sound device only if it does not match with
1671 one of the split sound devices. This is because the matching
1672 sound device was not disabled */
1673 bool should_enable = true;
1674 for (i = 0; i < num_devices; i++) {
1675 if (derive_snd_device[usecase->id] == split_snd_devices[i]) {
1676 should_enable = false;
1677 break;
1678 }
1679 }
1680 if (should_enable)
1681 enable_snd_device(adev, derive_snd_device[usecase->id]);
1682 } else {
1683 enable_snd_device(adev, derive_snd_device[usecase->id]);
1684 }
Krishnankutty Kolathappillydc4f7572013-11-01 20:07:13 -07001685 }
1686 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001687
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001688 /* Re-route all the usecases on the shared backend other than the
1689 specified usecase to new snd devices */
1690 list_for_each(node, &adev->usecase_list) {
1691 usecase = node_to_item(node, struct audio_usecase, list);
Karthik Reddy Katta3abfee22016-02-23 10:55:27 +05301692 /* Update the out_snd_device only before enabling the audio route */
1693 if (switch_device[usecase->id]) {
Chaithanya Krishna Bacharaju49e7db02017-03-14 11:57:26 +05301694 usecase->out_snd_device = derive_snd_device[usecase->id];
Karthik Reddy Katta3abfee22016-02-23 10:55:27 +05301695 if (usecase->type != VOICE_CALL) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301696 ALOGD("%s:becf: enabling usecase (%s) on (%s)", __func__,
Karthik Reddy Katta3abfee22016-02-23 10:55:27 +05301697 use_case_table[usecase->id],
1698 platform_get_snd_device_name(usecase->out_snd_device));
kunleiz5cd52b82016-11-07 17:22:52 +08001699 /* Update voc calibration before enabling VoIP route */
1700 if (usecase->type == VOIP_CALL)
1701 status = platform_switch_voice_call_device_post(adev->platform,
Eric Laurent637e2d42018-11-15 12:24:31 -08001702 usecase->out_snd_device,
1703 platform_get_input_snd_device(
1704 adev->platform, NULL,
1705 uc_info->devices));
Avinash Vaish71a8b972014-07-24 15:36:33 +05301706 enable_audio_route(adev, usecase);
Sujin Panicker390724d2019-04-26 10:43:36 +05301707 if (usecase->stream.out && usecase->id == USECASE_AUDIO_PLAYBACK_VOIP) {
kunleiz46c47dd2018-03-19 16:28:09 +08001708 out_set_voip_volume(&usecase->stream.out->stream,
1709 usecase->stream.out->volume_l,
1710 usecase->stream.out->volume_r);
1711 }
Karthik Reddy Katta3abfee22016-02-23 10:55:27 +05301712 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001713 }
1714 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001715 }
1716}
1717
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05301718static void check_usecases_capture_codec_backend(struct audio_device *adev,
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001719 struct audio_usecase *uc_info,
1720 snd_device_t snd_device)
1721{
1722 struct listnode *node;
1723 struct audio_usecase *usecase;
1724 bool switch_device[AUDIO_USECASE_MAX];
1725 int i, num_uc_to_switch = 0;
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +05301726 int backend_check_cond = AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND;
kunleiz5cd52b82016-11-07 17:22:52 +08001727 int status = 0;
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001728
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05301729 bool force_routing = platform_check_and_set_capture_codec_backend_cfg(adev, uc_info,
1730 snd_device);
1731 ALOGD("%s:becf: force routing %d", __func__, force_routing);
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +05301732
1733 /*
1734 * Make sure out devices is checked against out codec backend device and
1735 * also in devices against in codec backend. Checking out device against in
1736 * codec backend or vice versa causes issues.
1737 */
1738 if (uc_info->type == PCM_CAPTURE)
1739 backend_check_cond = AUDIO_DEVICE_IN_ALL_CODEC_BACKEND;
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001740 /*
1741 * This function is to make sure that all the active capture usecases
1742 * are always routed to the same input sound device.
1743 * For example, if audio-record and voice-call usecases are currently
1744 * active on speaker(rx) and speaker-mic (tx) and out_set_parameters(earpiece)
1745 * is received for voice call then we have to make sure that audio-record
1746 * usecase is also switched to earpiece i.e. voice-dmic-ef,
1747 * because of the limitation that two devices cannot be enabled
1748 * at the same time if they share the same backend.
1749 */
1750 for (i = 0; i < AUDIO_USECASE_MAX; i++)
1751 switch_device[i] = false;
1752
1753 list_for_each(node, &adev->usecase_list) {
1754 usecase = node_to_item(node, struct audio_usecase, list);
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +05301755 /*
1756 * TODO: Enhance below condition to handle BT sco/USB multi recording
1757 */
Shiv Maliyappanahalli80ac6282013-12-20 18:56:15 -08001758 if (usecase->type != PCM_PLAYBACK &&
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001759 usecase != uc_info &&
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05301760 (usecase->in_snd_device != snd_device || force_routing) &&
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +05301761 ((uc_info->devices & backend_check_cond) &&
Karthik Reddy Katta0d471762015-08-20 13:36:07 +05301762 (((usecase->devices & ~AUDIO_DEVICE_BIT_IN) & AUDIO_DEVICE_IN_ALL_CODEC_BACKEND) ||
Satya Krishna Pindiproli458b5a72017-03-13 15:14:24 +05301763 (usecase->type == VOIP_CALL))) &&
Carter Hsu1d2a0532018-10-04 09:24:36 +08001764 ((uc_info->type == VOICE_CALL &&
1765 usecase->devices == AUDIO_DEVICE_IN_VOICE_CALL) ||
1766 platform_check_backends_match(snd_device,\
1767 usecase->in_snd_device)) &&
Anish Kumara020a7c2014-10-17 11:13:22 -07001768 (usecase->id != USECASE_AUDIO_SPKR_CALIB_TX)) {
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001769 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
1770 __func__, use_case_table[usecase->id],
Devin Kim1e5f3532013-08-09 07:48:29 -07001771 platform_get_snd_device_name(usecase->in_snd_device));
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001772 disable_audio_route(adev, usecase);
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001773 switch_device[usecase->id] = true;
1774 num_uc_to_switch++;
1775 }
1776 }
1777
1778 if (num_uc_to_switch) {
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001779 /* All streams have been de-routed. Disable the device */
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001780
Venkata Narendra Kumar Gutta7610e632014-04-14 23:16:38 +05301781 /* Make sure the previous devices to be disabled first and then enable the
1782 selected devices */
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001783 list_for_each(node, &adev->usecase_list) {
1784 usecase = node_to_item(node, struct audio_usecase, list);
1785 if (switch_device[usecase->id]) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001786 disable_snd_device(adev, usecase->in_snd_device);
Shiv Maliyappanahalli80ac6282013-12-20 18:56:15 -08001787 }
1788 }
1789
1790 list_for_each(node, &adev->usecase_list) {
1791 usecase = node_to_item(node, struct audio_usecase, list);
1792 if (switch_device[usecase->id]) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001793 enable_snd_device(adev, snd_device);
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001794 }
1795 }
1796
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001797 /* Re-route all the usecases on the shared backend other than the
1798 specified usecase to new snd devices */
1799 list_for_each(node, &adev->usecase_list) {
1800 usecase = node_to_item(node, struct audio_usecase, list);
1801 /* Update the in_snd_device only before enabling the audio route */
1802 if (switch_device[usecase->id] ) {
1803 usecase->in_snd_device = snd_device;
kunleiz5cd52b82016-11-07 17:22:52 +08001804 if (usecase->type != VOICE_CALL) {
1805 /* Update voc calibration before enabling VoIP route */
1806 if (usecase->type == VOIP_CALL)
1807 status = platform_switch_voice_call_device_post(adev->platform,
Zhou Song557e7282017-05-05 17:18:18 +08001808 platform_get_output_snd_device(adev->platform, uc_info->stream.out),
kunleiz5cd52b82016-11-07 17:22:52 +08001809 usecase->in_snd_device);
Avinash Vaish71a8b972014-07-24 15:36:33 +05301810 enable_audio_route(adev, usecase);
kunleiz5cd52b82016-11-07 17:22:52 +08001811 }
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001812 }
1813 }
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001814 }
1815}
1816
Mingming Yin3a941d42016-02-17 18:08:05 -08001817static void reset_hdmi_sink_caps(struct stream_out *out) {
1818 int i = 0;
1819
1820 for (i = 0; i<= MAX_SUPPORTED_CHANNEL_MASKS; i++) {
1821 out->supported_channel_masks[i] = 0;
1822 }
1823 for (i = 0; i<= MAX_SUPPORTED_FORMATS; i++) {
1824 out->supported_formats[i] = 0;
1825 }
1826 for (i = 0; i<= MAX_SUPPORTED_SAMPLE_RATES; i++) {
1827 out->supported_sample_rates[i] = 0;
1828 }
1829}
1830
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001831/* must be called with hw device mutex locked */
Mingming Yin3a941d42016-02-17 18:08:05 -08001832static int read_hdmi_sink_caps(struct stream_out *out)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001833{
Mingming Yin3a941d42016-02-17 18:08:05 -08001834 int ret = 0, i = 0, j = 0;
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -07001835 int channels = platform_edid_get_max_channels(out->dev->platform);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001836
Mingming Yin3a941d42016-02-17 18:08:05 -08001837 reset_hdmi_sink_caps(out);
1838
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07001839 /* Cache ext disp type */
Garmond Leung37850ab2016-10-06 11:42:18 -07001840 if (platform_get_ext_disp_type(adev->platform) <= 0) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07001841 ALOGE("%s: Failed to query disp type, ret:%d", __func__, ret);
Garmond Leung37850ab2016-10-06 11:42:18 -07001842 return -EINVAL;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07001843 }
1844
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001845 switch (channels) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001846 case 8:
Mingming Yin3a941d42016-02-17 18:08:05 -08001847 ALOGV("%s: HDMI supports 7.1 channels", __func__);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07001848 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_7POINT1;
Mingming Yin3a941d42016-02-17 18:08:05 -08001849 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_6POINT1;
1850 case 6:
1851 ALOGV("%s: HDMI supports 5.1 channels", __func__);
1852 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_5POINT1;
1853 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_PENTA;
1854 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_QUAD;
1855 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_SURROUND;
1856 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_2POINT1;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001857 break;
1858 default:
Mingming Yin3a941d42016-02-17 18:08:05 -08001859 ALOGE("invalid/nonstandard channal count[%d]",channels);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001860 ret = -ENOSYS;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001861 break;
1862 }
Mingming Yin3a941d42016-02-17 18:08:05 -08001863
1864 // check channel format caps
1865 i = 0;
1866 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_AC3)) {
1867 ALOGV(":%s HDMI supports AC3/EAC3 formats", __func__);
1868 out->supported_formats[i++] = AUDIO_FORMAT_AC3;
1869 //Adding EAC3/EAC3_JOC formats if AC3 is supported by the sink.
1870 //EAC3/EAC3_JOC will be converted to AC3 for decoding if needed
1871 out->supported_formats[i++] = AUDIO_FORMAT_E_AC3;
1872 out->supported_formats[i++] = AUDIO_FORMAT_E_AC3_JOC;
1873 }
1874
Ben Romberger1aaaf862017-04-06 17:49:46 -07001875 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_DOLBY_TRUEHD)) {
1876 ALOGV(":%s HDMI supports TRUE HD format", __func__);
1877 out->supported_formats[i++] = AUDIO_FORMAT_DOLBY_TRUEHD;
1878 }
1879
Mingming Yin3a941d42016-02-17 18:08:05 -08001880 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_DTS)) {
1881 ALOGV(":%s HDMI supports DTS format", __func__);
1882 out->supported_formats[i++] = AUDIO_FORMAT_DTS;
1883 }
1884
1885 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_DTS_HD)) {
1886 ALOGV(":%s HDMI supports DTS HD format", __func__);
1887 out->supported_formats[i++] = AUDIO_FORMAT_DTS_HD;
1888 }
1889
Naresh Tanniru928f0862017-04-07 16:44:23 -07001890 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_IEC61937)) {
1891 ALOGV(":%s HDMI supports IEC61937 format", __func__);
1892 out->supported_formats[i++] = AUDIO_FORMAT_IEC61937;
1893 }
1894
Mingming Yin3a941d42016-02-17 18:08:05 -08001895
1896 // check sample rate caps
1897 i = 0;
1898 for (j = 0; j < MAX_SUPPORTED_SAMPLE_RATES; j++) {
1899 if (platform_is_edid_supported_sample_rate(out->dev->platform, out_hdmi_sample_rates[j])) {
1900 ALOGV(":%s HDMI supports sample rate:%d", __func__, out_hdmi_sample_rates[j]);
1901 out->supported_sample_rates[i++] = out_hdmi_sample_rates[j];
1902 }
1903 }
1904
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001905 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001906}
1907
Haynes Mathew George484e8d22017-07-31 18:55:17 -07001908static inline ssize_t read_usb_sup_sample_rates(bool is_playback __unused,
1909 uint32_t *supported_sample_rates __unused,
1910 uint32_t max_rates __unused)
1911{
1912 ssize_t count = audio_extn_usb_get_sup_sample_rates(is_playback,
1913 supported_sample_rates,
1914 max_rates);
Ashish Jain4847e9d2017-08-17 19:16:57 +05301915 ssize_t i = 0;
1916
1917 for (i=0; i<count; i++) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07001918 ALOGV("%s %s %d", __func__, is_playback ? "P" : "C",
1919 supported_sample_rates[i]);
1920 }
1921 return count;
1922}
1923
1924static inline int read_usb_sup_channel_masks(bool is_playback,
1925 audio_channel_mask_t *supported_channel_masks,
1926 uint32_t max_masks)
1927{
1928 int channels = audio_extn_usb_get_max_channels(is_playback);
1929 int channel_count;
1930 uint32_t num_masks = 0;
1931 if (channels > MAX_HIFI_CHANNEL_COUNT)
1932 channels = MAX_HIFI_CHANNEL_COUNT;
1933
1934 if (is_playback) {
Eric Laurent68a87112019-05-01 18:07:29 -07001935 // start from 2 channels as framework currently doesn't support mono.
1936 if (channels >= FCC_2) {
1937 supported_channel_masks[num_masks++] = audio_channel_out_mask_from_count(FCC_2);
1938 }
1939 for (channel_count = FCC_2;
1940 channel_count <= channels && num_masks < max_masks;
1941 ++channel_count) {
1942 supported_channel_masks[num_masks++] =
1943 audio_channel_mask_for_index_assignment_from_count(channel_count);
1944 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07001945 } else {
vincenttewf51c94e2019-05-07 10:28:53 +08001946 // For capture we report all supported channel masks from 1 channel up.
1947 channel_count = MIN_CHANNEL_COUNT;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07001948 // audio_channel_in_mask_from_count() does the right conversion to either positional or
1949 // indexed mask
Eric Laurent68a87112019-05-01 18:07:29 -07001950 for ( ; channel_count <= channels && num_masks < max_masks; channel_count++) {
1951 audio_channel_mask_t mask = AUDIO_CHANNEL_NONE;
1952 if (channel_count <= FCC_2) {
1953 mask = audio_channel_in_mask_from_count(channel_count);
1954 supported_channel_masks[num_masks++] = mask;
1955 }
1956 const audio_channel_mask_t index_mask =
1957 audio_channel_mask_for_index_assignment_from_count(channel_count);
1958 if (mask != index_mask && num_masks < max_masks) { // ensure index mask added.
1959 supported_channel_masks[num_masks++] = index_mask;
1960 }
1961 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07001962 }
Lakshman Chaluvarajub79fafd2018-11-21 10:24:37 +05301963
vincenttewf51c94e2019-05-07 10:28:53 +08001964 for (size_t i = 0; i < num_masks; ++i) {
1965 ALOGV("%s: %s supported ch %d supported_channel_masks[%zu] %08x num_masks %d", __func__,
1966 is_playback ? "P" : "C", channels, i, supported_channel_masks[i], num_masks);
Lakshman Chaluvarajub79fafd2018-11-21 10:24:37 +05301967 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07001968 return num_masks;
1969}
1970
1971static inline int read_usb_sup_formats(bool is_playback __unused,
1972 audio_format_t *supported_formats,
1973 uint32_t max_formats __unused)
1974{
1975 int bitwidth = audio_extn_usb_get_max_bit_width(is_playback);
1976 switch (bitwidth) {
1977 case 24:
1978 // XXX : usb.c returns 24 for s24 and s24_le?
1979 supported_formats[0] = AUDIO_FORMAT_PCM_24_BIT_PACKED;
1980 break;
1981 case 32:
1982 supported_formats[0] = AUDIO_FORMAT_PCM_32_BIT;
1983 break;
1984 case 16:
1985 default :
1986 supported_formats[0] = AUDIO_FORMAT_PCM_16_BIT;
1987 break;
1988 }
1989 ALOGV("%s: %s supported format %d", __func__,
1990 is_playback ? "P" : "C", bitwidth);
1991 return 1;
1992}
1993
1994static inline int read_usb_sup_params_and_compare(bool is_playback,
1995 audio_format_t *format,
1996 audio_format_t *supported_formats,
1997 uint32_t max_formats,
1998 audio_channel_mask_t *mask,
1999 audio_channel_mask_t *supported_channel_masks,
2000 uint32_t max_masks,
2001 uint32_t *rate,
2002 uint32_t *supported_sample_rates,
2003 uint32_t max_rates) {
2004 int ret = 0;
2005 int num_formats;
2006 int num_masks;
2007 int num_rates;
2008 int i;
2009
2010 num_formats = read_usb_sup_formats(is_playback, supported_formats,
2011 max_formats);
2012 num_masks = read_usb_sup_channel_masks(is_playback, supported_channel_masks,
2013 max_masks);
2014
2015 num_rates = read_usb_sup_sample_rates(is_playback,
2016 supported_sample_rates, max_rates);
2017
2018#define LUT(table, len, what, dflt) \
2019 for (i=0; i<len && (table[i] != what); i++); \
2020 if (i==len) { ret |= (what == dflt ? 0 : -1); what=table[0]; }
2021
2022 LUT(supported_formats, num_formats, *format, AUDIO_FORMAT_DEFAULT);
2023 LUT(supported_channel_masks, num_masks, *mask, AUDIO_CHANNEL_NONE);
2024 LUT(supported_sample_rates, num_rates, *rate, 0);
2025
2026#undef LUT
2027 return ret < 0 ? -EINVAL : 0; // HACK TBD
2028}
2029
Alexy Josephb1379942016-01-29 15:49:38 -08002030audio_usecase_t get_usecase_id_from_usecase_type(const struct audio_device *adev,
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -08002031 usecase_type_t type)
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07002032{
2033 struct audio_usecase *usecase;
2034 struct listnode *node;
2035
2036 list_for_each(node, &adev->usecase_list) {
2037 usecase = node_to_item(node, struct audio_usecase, list);
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -08002038 if (usecase->type == type) {
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07002039 ALOGV("%s: usecase id %d", __func__, usecase->id);
2040 return usecase->id;
2041 }
2042 }
2043 return USECASE_INVALID;
2044}
2045
Alexy Josephb1379942016-01-29 15:49:38 -08002046struct audio_usecase *get_usecase_from_list(const struct audio_device *adev,
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07002047 audio_usecase_t uc_id)
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002048{
2049 struct audio_usecase *usecase;
2050 struct listnode *node;
2051
2052 list_for_each(node, &adev->usecase_list) {
2053 usecase = node_to_item(node, struct audio_usecase, list);
2054 if (usecase->id == uc_id)
2055 return usecase;
2056 }
2057 return NULL;
2058}
2059
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302060/*
2061 * is a true native playback active
2062 */
2063bool audio_is_true_native_stream_active(struct audio_device *adev)
2064{
2065 bool active = false;
2066 int i = 0;
2067 struct listnode *node;
2068
2069 if (NATIVE_AUDIO_MODE_TRUE_44_1 != platform_get_native_support()) {
2070 ALOGV("%s:napb: not in true mode or non hdphones device",
2071 __func__);
2072 active = false;
2073 goto exit;
2074 }
2075
2076 list_for_each(node, &adev->usecase_list) {
2077 struct audio_usecase *uc;
2078 uc = node_to_item(node, struct audio_usecase, list);
2079 struct stream_out *curr_out =
2080 (struct stream_out*) uc->stream.out;
2081
2082 if (curr_out && PCM_PLAYBACK == uc->type) {
2083 ALOGD("%s:napb: (%d) (%s)id (%d) sr %d bw "
2084 "(%d) device %s", __func__, i++, use_case_table[uc->id],
2085 uc->id, curr_out->sample_rate,
2086 curr_out->bit_width,
2087 platform_get_snd_device_name(uc->out_snd_device));
2088
2089 if (is_offload_usecase(uc->id) &&
2090 (curr_out->sample_rate == OUTPUT_SAMPLING_RATE_44100)) {
2091 active = true;
2092 ALOGD("%s:napb:native stream detected", __func__);
2093 }
2094 }
2095 }
2096exit:
2097 return active;
2098}
2099
Xiaojun Sang785b5da2017-08-03 15:52:29 +08002100uint32_t adev_get_dsp_bit_width_enforce_mode()
2101{
2102 if (adev == NULL) {
2103 ALOGE("%s: adev is null. Disable DSP bit width enforce mode.\n", __func__);
2104 return 0;
2105 }
2106 return adev->dsp_bit_width_enforce_mode;
2107}
2108
2109static uint32_t adev_init_dsp_bit_width_enforce_mode(struct mixer *mixer)
2110{
2111 char value[PROPERTY_VALUE_MAX];
2112 int trial;
2113 uint32_t dsp_bit_width_enforce_mode = 0;
2114
2115 if (!mixer) {
2116 ALOGE("%s: adev mixer is null. cannot update DSP bitwidth.\n",
2117 __func__);
2118 return 0;
2119 }
2120
2121 if (property_get("persist.vendor.audio_hal.dsp_bit_width_enforce_mode",
2122 value, NULL) > 0) {
2123 trial = atoi(value);
2124 switch (trial) {
2125 case 16:
2126 dsp_bit_width_enforce_mode = 16;
2127 break;
2128 case 24:
2129 dsp_bit_width_enforce_mode = 24;
2130 break;
2131 case 32:
2132 dsp_bit_width_enforce_mode = 32;
2133 break;
2134 default:
2135 dsp_bit_width_enforce_mode = 0;
2136 ALOGD("%s Dynamic DSP bitwidth config is disabled.", __func__);
2137 break;
2138 }
2139 }
2140
2141 return dsp_bit_width_enforce_mode;
2142}
2143
2144static void audio_enable_asm_bit_width_enforce_mode(struct mixer *mixer,
2145 uint32_t enforce_mode,
2146 bool enable)
2147{
2148 struct mixer_ctl *ctl = NULL;
2149 const char *mixer_ctl_name = "ASM Bit Width";
2150 uint32_t asm_bit_width_mode = 0;
2151
2152 if (enforce_mode == 0) {
2153 ALOGD("%s: DSP bitwidth feature is disabled.", __func__);
2154 return;
2155 }
2156
2157 ctl = mixer_get_ctl_by_name(mixer, mixer_ctl_name);
2158 if (!ctl) {
2159 ALOGE("%s: Could not get ctl for mixer cmd - %s",
2160 __func__, mixer_ctl_name);
2161 return;
2162 }
2163
2164 if (enable)
2165 asm_bit_width_mode = enforce_mode;
2166 else
2167 asm_bit_width_mode = 0;
2168
2169 ALOGV("%s DSP bit width feature status is %d width=%d",
2170 __func__, enable, asm_bit_width_mode);
2171 if (mixer_ctl_set_value(ctl, 0, asm_bit_width_mode) < 0)
2172 ALOGE("%s: Could not set ASM biwidth %d", __func__,
2173 asm_bit_width_mode);
2174
2175 return;
2176}
2177
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05302178/*
2179 * if native DSD playback active
2180 */
2181bool audio_is_dsd_native_stream_active(struct audio_device *adev)
2182{
2183 bool active = false;
2184 struct listnode *node = NULL;
2185 struct audio_usecase *uc = NULL;
2186 struct stream_out *curr_out = NULL;
2187
2188 list_for_each(node, &adev->usecase_list) {
2189 uc = node_to_item(node, struct audio_usecase, list);
2190 curr_out = (struct stream_out*) uc->stream.out;
2191
2192 if (curr_out && PCM_PLAYBACK == uc->type &&
2193 (DSD_NATIVE_BACKEND == platform_get_backend_index(uc->out_snd_device))) {
2194 active = true;
2195 ALOGV("%s:DSD playback is active", __func__);
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05302196 break;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05302197 }
2198 }
2199 return active;
2200}
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302201
2202static bool force_device_switch(struct audio_usecase *usecase)
2203{
2204 bool ret = false;
2205 bool is_it_true_mode = false;
2206
Zhou Song30f2c3e2018-02-08 14:02:15 +08002207 if (usecase->type == PCM_CAPTURE ||
Surendar Karka93cd25a2018-08-28 14:21:37 +05302208 usecase->type == TRANSCODE_LOOPBACK_RX ||
2209 usecase->type == TRANSCODE_LOOPBACK_TX) {
Zhou Song30f2c3e2018-02-08 14:02:15 +08002210 return false;
2211 }
2212
Aalique Grahamecbc46a22017-10-05 10:30:23 -07002213 if(usecase->stream.out == NULL) {
2214 ALOGE("%s: stream.out is NULL", __func__);
2215 return false;
2216 }
2217
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302218 if (is_offload_usecase(usecase->id) &&
Xiaojun Sang869f2012016-02-23 16:33:07 +08002219 (usecase->stream.out->sample_rate == OUTPUT_SAMPLING_RATE_44100) &&
2220 (usecase->stream.out->devices == AUDIO_DEVICE_OUT_WIRED_HEADSET ||
2221 usecase->stream.out->devices == AUDIO_DEVICE_OUT_WIRED_HEADPHONE)) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302222 is_it_true_mode = (NATIVE_AUDIO_MODE_TRUE_44_1 == platform_get_native_support()? true : false);
2223 if ((is_it_true_mode && !adev->native_playback_enabled) ||
2224 (!is_it_true_mode && adev->native_playback_enabled)){
2225 ret = true;
2226 ALOGD("napb: time to toggle native mode");
2227 }
2228 }
2229
Naresh Tanniru9d027a62015-03-13 01:32:10 +05302230 // Force all a2dp output devices to reconfigure for proper AFE encode format
Ashish Jainc597d102016-12-12 10:31:34 +05302231 //Also handle a case where in earlier a2dp start failed as A2DP stream was
2232 //in suspended state, hence try to trigger a retry when we again get a routing request.
Aalique Grahamecbc46a22017-10-05 10:30:23 -07002233 if((usecase->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
Ashish Jainc597d102016-12-12 10:31:34 +05302234 audio_extn_a2dp_is_force_device_switch()) {
Naresh Tanniru9d027a62015-03-13 01:32:10 +05302235 ALOGD("Force a2dp device switch to update new encoder config");
2236 ret = true;
Florian Pfister1a84f312018-07-19 14:38:18 +02002237 }
Naresh Tanniru9d027a62015-03-13 01:32:10 +05302238
Florian Pfister1a84f312018-07-19 14:38:18 +02002239 if (usecase->stream.out->stream_config_changed) {
Manish Dewangan671a4202017-08-18 17:30:46 +05302240 ALOGD("Force stream_config_changed to update iec61937 transmission config");
2241 return true;
Florian Pfister1a84f312018-07-19 14:38:18 +02002242 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302243 return ret;
2244}
2245
Aalique Grahame22e49102018-12-18 14:23:57 -08002246static void stream_app_type_cfg_init(struct stream_app_type_cfg *cfg)
2247{
2248 cfg->gain[0] = cfg->gain[1] = APP_TYPE_GAIN_DEFAULT;
2249}
2250
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302251bool is_btsco_device(snd_device_t out_snd_device, snd_device_t in_snd_device)
2252{
2253 bool ret=false;
2254 if ((out_snd_device == SND_DEVICE_OUT_BT_SCO ||
2255 out_snd_device == SND_DEVICE_OUT_BT_SCO_WB) ||
2256 in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB_NREC ||
2257 in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB ||
2258 in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_NREC ||
2259 in_snd_device == SND_DEVICE_IN_BT_SCO_MIC)
2260 ret = true;
2261
2262 return ret;
2263}
2264
2265bool is_a2dp_device(snd_device_t out_snd_device)
2266{
2267 bool ret=false;
2268 if (out_snd_device == SND_DEVICE_OUT_BT_A2DP)
2269 ret = true;
2270
2271 return ret;
2272}
2273
2274bool is_bt_soc_on(struct audio_device *adev)
2275{
2276 struct mixer_ctl *ctl;
2277 char *mixer_ctl_name = "BT SOC status";
2278 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
2279 bool bt_soc_status = true;
2280 if (!ctl) {
2281 ALOGE("%s: Could not get ctl for mixer cmd - %s",
2282 __func__, mixer_ctl_name);
2283 /*This is to ensure we dont break targets which dont have the kernel change*/
2284 return true;
2285 }
2286 bt_soc_status = mixer_ctl_get_value(ctl, 0);
2287 ALOGD("BT SOC status: %d",bt_soc_status);
2288 return bt_soc_status;
2289}
2290
2291int out_standby_l(struct audio_stream *stream);
2292
Eric Laurent637e2d42018-11-15 12:24:31 -08002293struct stream_in *adev_get_active_input(const struct audio_device *adev)
2294{
2295 struct listnode *node;
2296 struct stream_in *last_active_in = NULL;
2297
2298 /* Get last added active input.
2299 * TODO: We may use a priority mechanism to pick highest priority active source */
2300 list_for_each(node, &adev->usecase_list)
2301 {
2302 struct audio_usecase *usecase = node_to_item(node, struct audio_usecase, list);
2303 if (usecase->type == PCM_CAPTURE && usecase->stream.in != NULL)
2304 last_active_in = usecase->stream.in;
2305 }
2306
2307 return last_active_in;
2308}
2309
2310struct stream_in *get_voice_communication_input(const struct audio_device *adev)
2311{
2312 struct listnode *node;
2313
2314 /* First check active inputs with voice communication source and then
2315 * any input if audio mode is in communication */
2316 list_for_each(node, &adev->usecase_list)
2317 {
2318 struct audio_usecase *usecase = node_to_item(node, struct audio_usecase, list);
2319 if (usecase->type == PCM_CAPTURE && usecase->stream.in != NULL &&
2320 usecase->stream.in->source == AUDIO_SOURCE_VOICE_COMMUNICATION)
2321 return usecase->stream.in;
2322 }
2323 if (adev->mode == AUDIO_MODE_IN_COMMUNICATION)
2324 return adev_get_active_input(adev);
2325
2326 return NULL;
2327}
2328
Carter Hsu2e429db2019-05-14 18:50:52 +08002329/*
2330 * Aligned with policy.h
2331 */
2332static inline int source_priority(int inputSource)
2333{
2334 switch (inputSource) {
2335 case AUDIO_SOURCE_VOICE_COMMUNICATION:
2336 return 9;
2337 case AUDIO_SOURCE_CAMCORDER:
2338 return 8;
2339 case AUDIO_SOURCE_VOICE_PERFORMANCE:
2340 return 7;
2341 case AUDIO_SOURCE_UNPROCESSED:
2342 return 6;
2343 case AUDIO_SOURCE_MIC:
2344 return 5;
2345 case AUDIO_SOURCE_ECHO_REFERENCE:
2346 return 4;
2347 case AUDIO_SOURCE_FM_TUNER:
2348 return 3;
2349 case AUDIO_SOURCE_VOICE_RECOGNITION:
2350 return 2;
2351 case AUDIO_SOURCE_HOTWORD:
2352 return 1;
2353 default:
2354 break;
2355 }
2356 return 0;
2357}
2358
2359static struct stream_in *get_priority_input(struct audio_device *adev)
2360{
2361 struct listnode *node;
2362 struct audio_usecase *usecase;
2363 int last_priority = 0, priority;
2364 struct stream_in *priority_in = NULL;
2365 struct stream_in *in;
2366
2367 list_for_each(node, &adev->usecase_list) {
2368 usecase = node_to_item(node, struct audio_usecase, list);
2369 if (usecase->type == PCM_CAPTURE) {
2370 in = usecase->stream.in;
2371 if (!in)
2372 continue;
2373 priority = source_priority(in->source);
2374
2375 if (priority > last_priority) {
2376 last_priority = priority;
2377 priority_in = in;
2378 }
2379 }
2380 }
2381 return priority_in;
2382}
2383
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07002384int select_devices(struct audio_device *adev, audio_usecase_t uc_id)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002385{
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08002386 snd_device_t out_snd_device = SND_DEVICE_NONE;
2387 snd_device_t in_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002388 struct audio_usecase *usecase = NULL;
2389 struct audio_usecase *vc_usecase = NULL;
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08002390 struct audio_usecase *voip_usecase = NULL;
Vimal Puthanveed37b4a1c2014-01-07 16:47:47 -08002391 struct audio_usecase *hfp_usecase = NULL;
Siddartha Shaik44dd7702017-06-14 12:13:25 +05302392 struct stream_out stream_out;
Vimal Puthanveed41fcff22014-01-23 15:56:53 -08002393 audio_usecase_t hfp_ucid;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002394 int status = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002395
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302396 ALOGD("%s for use case (%s)", __func__, use_case_table[uc_id]);
2397
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002398 usecase = get_usecase_from_list(adev, uc_id);
2399 if (usecase == NULL) {
2400 ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id);
2401 return -EINVAL;
2402 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002403
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08002404 if ((usecase->type == VOICE_CALL) ||
Vimal Puthanveed5b4d3f12013-11-05 15:57:39 -08002405 (usecase->type == VOIP_CALL) ||
2406 (usecase->type == PCM_HFP_CALL)) {
Aditya Bavanaribdda2f22016-10-19 15:02:05 +05302407 if(usecase->stream.out == NULL) {
2408 ALOGE("%s: stream.out is NULL", __func__);
2409 return -EINVAL;
2410 }
Eric Laurentb23d5282013-05-14 15:27:20 -07002411 out_snd_device = platform_get_output_snd_device(adev->platform,
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -08002412 usecase->stream.out);
Eric Laurent637e2d42018-11-15 12:24:31 -08002413 in_snd_device = platform_get_input_snd_device(adev->platform,
2414 NULL,
2415 usecase->stream.out->devices);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002416 usecase->devices = usecase->stream.out->devices;
Surendar Karka93cd25a2018-08-28 14:21:37 +05302417 } else if (usecase->type == TRANSCODE_LOOPBACK_RX) {
Siddartha Shaik31b530e2017-05-19 15:26:33 +05302418 if (usecase->stream.inout == NULL) {
2419 ALOGE("%s: stream.inout is NULL", __func__);
2420 return -EINVAL;
2421 }
Siddartha Shaik44dd7702017-06-14 12:13:25 +05302422 stream_out.devices = usecase->stream.inout->out_config.devices;
2423 stream_out.sample_rate = usecase->stream.inout->out_config.sample_rate;
2424 stream_out.format = usecase->stream.inout->out_config.format;
2425 stream_out.channel_mask = usecase->stream.inout->out_config.channel_mask;
2426 out_snd_device = platform_get_output_snd_device(adev->platform,
2427 &stream_out);
Surendar Karka93cd25a2018-08-28 14:21:37 +05302428 usecase->devices = out_snd_device;
2429 } else if (usecase->type == TRANSCODE_LOOPBACK_TX ) {
2430 if (usecase->stream.inout == NULL) {
2431 ALOGE("%s: stream.inout is NULL", __func__);
2432 return -EINVAL;
2433 }
Eric Laurent637e2d42018-11-15 12:24:31 -08002434 in_snd_device = platform_get_input_snd_device(adev->platform, NULL, AUDIO_DEVICE_NONE);
Surendar Karka93cd25a2018-08-28 14:21:37 +05302435 usecase->devices = in_snd_device;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002436 } else {
2437 /*
2438 * If the voice call is active, use the sound devices of voice call usecase
2439 * so that it would not result any device switch. All the usecases will
2440 * be switched to new device when select_devices() is called for voice call
2441 * usecase. This is to avoid switching devices for voice call when
2442 * check_usecases_codec_backend() is called below.
Alexy Joseph79dfa3c2016-04-20 18:44:56 -07002443 * choose voice call device only if the use case device is
2444 * also using the codec backend
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002445 */
Shiv Maliyappanahallibb4cf0b2016-01-21 11:30:06 -08002446 if (voice_is_in_call(adev) && adev->mode != AUDIO_MODE_NORMAL) {
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07002447 vc_usecase = get_usecase_from_list(adev,
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -08002448 get_usecase_id_from_usecase_type(adev, VOICE_CALL));
Alexy Josephdbcddf22016-05-16 17:54:09 -07002449 if ((vc_usecase) && (((vc_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) &&
2450 (usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND)) ||
Preetam Singh Ranawat097cb1f2016-07-19 13:49:04 +05302451 ((vc_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) &&
2452 (usecase->devices & AUDIO_DEVICE_IN_ALL_CODEC_BACKEND)) ||
juyuchen2d415992018-11-16 14:15:16 +08002453 (vc_usecase->devices == AUDIO_DEVICE_OUT_HEARING_AID) ||
2454 (usecase->devices == AUDIO_DEVICE_IN_VOICE_CALL))) {
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002455 in_snd_device = vc_usecase->in_snd_device;
2456 out_snd_device = vc_usecase->out_snd_device;
2457 }
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08002458 } else if (voice_extn_compress_voip_is_active(adev)) {
yidongh02ef86f2017-04-21 15:36:04 +08002459 bool out_snd_device_backend_match = true;
yidongh47785a82017-05-08 19:29:29 +08002460 voip_usecase = get_usecase_from_list(adev, USECASE_COMPRESS_VOIP_CALL);
yidongh6261d8e2017-05-15 17:04:02 +08002461 if ((voip_usecase != NULL) &&
2462 (usecase->type == PCM_PLAYBACK) &&
2463 (usecase->stream.out != NULL)) {
yidongh02ef86f2017-04-21 15:36:04 +08002464 out_snd_device_backend_match = platform_check_backends_match(
2465 voip_usecase->out_snd_device,
2466 platform_get_output_snd_device(
2467 adev->platform,
2468 usecase->stream.out));
2469 }
Mingming Yin2d8aa2e2014-08-14 00:00:51 -07002470 if ((voip_usecase) && ((voip_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) &&
Zhou Song0154bf12016-08-04 10:48:16 +08002471 ((usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
2472 ((usecase->devices & ~AUDIO_DEVICE_BIT_IN) & AUDIO_DEVICE_IN_ALL_CODEC_BACKEND)) &&
yidongh02ef86f2017-04-21 15:36:04 +08002473 out_snd_device_backend_match &&
Mingming Yin2d8aa2e2014-08-14 00:00:51 -07002474 (voip_usecase->stream.out != adev->primary_output))) {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08002475 in_snd_device = voip_usecase->in_snd_device;
2476 out_snd_device = voip_usecase->out_snd_device;
2477 }
Vimal Puthanveed37b4a1c2014-01-07 16:47:47 -08002478 } else if (audio_extn_hfp_is_active(adev)) {
Vimal Puthanveed41fcff22014-01-23 15:56:53 -08002479 hfp_ucid = audio_extn_hfp_get_usecase();
2480 hfp_usecase = get_usecase_from_list(adev, hfp_ucid);
Mingming Yin2d8aa2e2014-08-14 00:00:51 -07002481 if ((hfp_usecase) && (hfp_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND)) {
Vimal Puthanveed37b4a1c2014-01-07 16:47:47 -08002482 in_snd_device = hfp_usecase->in_snd_device;
2483 out_snd_device = hfp_usecase->out_snd_device;
2484 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002485 }
2486 if (usecase->type == PCM_PLAYBACK) {
Aditya Bavanaribdda2f22016-10-19 15:02:05 +05302487 if (usecase->stream.out == NULL) {
2488 ALOGE("%s: stream.out is NULL", __func__);
2489 return -EINVAL;
2490 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002491 usecase->devices = usecase->stream.out->devices;
2492 in_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002493 if (out_snd_device == SND_DEVICE_NONE) {
Eric Laurent637e2d42018-11-15 12:24:31 -08002494 struct stream_out *voip_out = adev->primary_output;
2495 struct stream_in *voip_in = get_voice_communication_input(adev);
Eric Laurentb23d5282013-05-14 15:27:20 -07002496 out_snd_device = platform_get_output_snd_device(adev->platform,
Eric Laurent637e2d42018-11-15 12:24:31 -08002497 usecase->stream.out);
kunleizdcf967a2018-08-07 17:09:11 +08002498 voip_usecase = get_usecase_from_list(adev, USECASE_AUDIO_PLAYBACK_VOIP);
kunleizdcf967a2018-08-07 17:09:11 +08002499
Eric Laurent637e2d42018-11-15 12:24:31 -08002500 if (voip_usecase)
2501 voip_out = voip_usecase->stream.out;
2502
2503 if (usecase->stream.out == voip_out && voip_in != NULL)
2504 select_devices(adev, voip_in->usecase);
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002505 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002506 } else if (usecase->type == PCM_CAPTURE) {
Aditya Bavanaribdda2f22016-10-19 15:02:05 +05302507 if (usecase->stream.in == NULL) {
2508 ALOGE("%s: stream.in is NULL", __func__);
2509 return -EINVAL;
2510 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002511 usecase->devices = usecase->stream.in->device;
2512 out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002513 if (in_snd_device == SND_DEVICE_NONE) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002514 audio_devices_t out_device = AUDIO_DEVICE_NONE;
Eric Laurent637e2d42018-11-15 12:24:31 -08002515 struct stream_in *voip_in = get_voice_communication_input(adev);
Carter Hsu2e429db2019-05-14 18:50:52 +08002516 struct stream_in *priority_in = NULL;
Eric Laurent637e2d42018-11-15 12:24:31 -08002517
2518 if (voip_in != NULL) {
Eric Laurent637e2d42018-11-15 12:24:31 -08002519 struct audio_usecase *voip_usecase = get_usecase_from_list(adev,
2520 USECASE_AUDIO_PLAYBACK_VOIP);
2521
Carter Hsu2e429db2019-05-14 18:50:52 +08002522 usecase->stream.in->enable_ec_port = false;
2523
Eric Laurent637e2d42018-11-15 12:24:31 -08002524 if (usecase->id == USECASE_AUDIO_RECORD_AFE_PROXY) {
2525 out_device = AUDIO_DEVICE_OUT_TELEPHONY_TX;
2526 } else if (voip_usecase) {
2527 out_device = voip_usecase->stream.out->devices;
2528 } else if (adev->primary_output &&
2529 !adev->primary_output->standby) {
2530 out_device = adev->primary_output->devices;
2531 } else {
2532 /* forcing speaker o/p device to get matching i/p pair
2533 in case o/p is not routed from same primary HAL */
2534 out_device = AUDIO_DEVICE_OUT_SPEAKER;
2535 }
Carter Hsu2e429db2019-05-14 18:50:52 +08002536 priority_in = voip_in;
2537 } else {
2538 /* get the input with the highest priority source*/
2539 priority_in = get_priority_input(adev);
2540
2541 if (!priority_in)
2542 priority_in = usecase->stream.in;
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002543 }
Carter Hsu2e429db2019-05-14 18:50:52 +08002544
Eric Laurent637e2d42018-11-15 12:24:31 -08002545 in_snd_device = platform_get_input_snd_device(adev->platform,
Carter Hsu2e429db2019-05-14 18:50:52 +08002546 priority_in,
Eric Laurent637e2d42018-11-15 12:24:31 -08002547 out_device);
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002548 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002549 }
2550 }
2551
2552 if (out_snd_device == usecase->out_snd_device &&
2553 in_snd_device == usecase->in_snd_device) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302554
2555 if (!force_device_switch(usecase))
2556 return 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002557 }
2558
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302559 if ((is_btsco_device(out_snd_device,in_snd_device) && !adev->bt_sco_on) ||
Florian Pfister1a84f312018-07-19 14:38:18 +02002560 (is_a2dp_device(out_snd_device) && !audio_extn_a2dp_source_is_ready())) {
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302561 ALOGD("SCO/A2DP is selected but they are not connected/ready hence dont route");
2562 return 0;
2563 }
2564
Aalique Grahame22e49102018-12-18 14:23:57 -08002565 if (out_snd_device != SND_DEVICE_NONE &&
2566 out_snd_device != adev->last_logged_snd_device[uc_id][0]) {
2567 ALOGD("%s: changing use case %s output device from(%d: %s, acdb %d) to (%d: %s, acdb %d)",
2568 __func__,
2569 use_case_table[uc_id],
2570 adev->last_logged_snd_device[uc_id][0],
2571 platform_get_snd_device_name(adev->last_logged_snd_device[uc_id][0]),
2572 adev->last_logged_snd_device[uc_id][0] != SND_DEVICE_NONE ?
2573 platform_get_snd_device_acdb_id(adev->last_logged_snd_device[uc_id][0]) :
2574 -1,
2575 out_snd_device,
2576 platform_get_snd_device_name(out_snd_device),
2577 platform_get_snd_device_acdb_id(out_snd_device));
2578 adev->last_logged_snd_device[uc_id][0] = out_snd_device;
2579 }
2580 if (in_snd_device != SND_DEVICE_NONE &&
2581 in_snd_device != adev->last_logged_snd_device[uc_id][1]) {
2582 ALOGD("%s: changing use case %s input device from(%d: %s, acdb %d) to (%d: %s, acdb %d)",
2583 __func__,
2584 use_case_table[uc_id],
2585 adev->last_logged_snd_device[uc_id][1],
2586 platform_get_snd_device_name(adev->last_logged_snd_device[uc_id][1]),
2587 adev->last_logged_snd_device[uc_id][1] != SND_DEVICE_NONE ?
2588 platform_get_snd_device_acdb_id(adev->last_logged_snd_device[uc_id][1]) :
2589 -1,
2590 in_snd_device,
2591 platform_get_snd_device_name(in_snd_device),
2592 platform_get_snd_device_acdb_id(in_snd_device));
2593 adev->last_logged_snd_device[uc_id][1] = in_snd_device;
2594 }
2595
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08002596
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002597 /*
2598 * Limitation: While in call, to do a device switch we need to disable
2599 * and enable both RX and TX devices though one of them is same as current
2600 * device.
2601 */
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -07002602 if ((usecase->type == VOICE_CALL) &&
2603 (usecase->in_snd_device != SND_DEVICE_NONE) &&
2604 (usecase->out_snd_device != SND_DEVICE_NONE)) {
Eric Laurentb23d5282013-05-14 15:27:20 -07002605 status = platform_switch_voice_call_device_pre(adev->platform);
Narsinga Rao Chella116142b2015-08-14 18:00:08 -07002606 }
2607
2608 if (((usecase->type == VOICE_CALL) ||
2609 (usecase->type == VOIP_CALL)) &&
2610 (usecase->out_snd_device != SND_DEVICE_NONE)) {
2611 /* Disable sidetone only if voice/voip call already exists */
2612 if (voice_is_call_state_active(adev) ||
2613 voice_extn_compress_voip_is_started(adev))
Bhalchandra Gajare45fee282015-06-09 22:23:45 -07002614 voice_set_sidetone(adev, usecase->out_snd_device, false);
Vidyakumar Athotaea269c62016-10-31 09:05:59 -07002615
2616 /* Disable aanc only if voice call exists */
2617 if (voice_is_call_state_active(adev))
2618 voice_check_and_update_aanc_path(adev, usecase->out_snd_device, false);
Ravi Kumar Alamanda610e8cc2013-02-12 01:42:38 -08002619 }
2620
Aalique Grahame22e49102018-12-18 14:23:57 -08002621 if ((out_snd_device == SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP ||
2622 out_snd_device == SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP) &&
Florian Pfister1a84f312018-07-19 14:38:18 +02002623 (!audio_extn_a2dp_source_is_ready())) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05302624 ALOGW("%s: A2DP profile is not ready, routing to speaker only", __func__);
Aalique Grahame22e49102018-12-18 14:23:57 -08002625 if (out_snd_device == SND_DEVICE_OUT_SPEAKER_SAFE_AND_BT_A2DP)
2626 out_snd_device = SND_DEVICE_OUT_SPEAKER_SAFE;
2627 else
2628 out_snd_device = SND_DEVICE_OUT_SPEAKER;
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05302629 }
2630
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002631 /* Disable current sound devices */
2632 if (usecase->out_snd_device != SND_DEVICE_NONE) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002633 disable_audio_route(adev, usecase);
2634 disable_snd_device(adev, usecase->out_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002635 }
2636
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002637 if (usecase->in_snd_device != SND_DEVICE_NONE) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002638 disable_audio_route(adev, usecase);
2639 disable_snd_device(adev, usecase->in_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002640 }
2641
Vidyakumar Athota545dbd32013-11-13 17:30:53 -08002642 /* Applicable only on the targets that has external modem.
2643 * New device information should be sent to modem before enabling
2644 * the devices to reduce in-call device switch time.
2645 */
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -07002646 if ((usecase->type == VOICE_CALL) &&
2647 (usecase->in_snd_device != SND_DEVICE_NONE) &&
2648 (usecase->out_snd_device != SND_DEVICE_NONE)) {
Vidyakumar Athota545dbd32013-11-13 17:30:53 -08002649 status = platform_switch_voice_call_enable_device_config(adev->platform,
2650 out_snd_device,
2651 in_snd_device);
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -07002652 }
Vidyakumar Athota545dbd32013-11-13 17:30:53 -08002653
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002654 /* Enable new sound devices */
2655 if (out_snd_device != SND_DEVICE_NONE) {
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08002656 check_usecases_codec_backend(adev, usecase, out_snd_device);
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +05302657 if (platform_check_codec_asrc_support(adev->platform))
2658 check_and_set_asrc_mode(adev, usecase, out_snd_device);
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002659 enable_snd_device(adev, out_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002660 }
2661
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07002662 if (in_snd_device != SND_DEVICE_NONE) {
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05302663 check_usecases_capture_codec_backend(adev, usecase, in_snd_device);
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002664 enable_snd_device(adev, in_snd_device);
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07002665 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002666
Avinash Vaish71a8b972014-07-24 15:36:33 +05302667 if (usecase->type == VOICE_CALL || usecase->type == VOIP_CALL) {
Eric Laurentb23d5282013-05-14 15:27:20 -07002668 status = platform_switch_voice_call_device_post(adev->platform,
2669 out_snd_device,
2670 in_snd_device);
Avinash Vaish71a8b972014-07-24 15:36:33 +05302671 enable_audio_route_for_voice_usecases(adev, usecase);
2672 }
Ravi Kumar Alamanda610e8cc2013-02-12 01:42:38 -08002673
sangwoo170731f2013-06-08 15:36:36 +09002674 usecase->in_snd_device = in_snd_device;
2675 usecase->out_snd_device = out_snd_device;
2676
Dhananjay Kumard6d32152016-10-13 16:11:03 +05302677 audio_extn_utils_update_stream_app_type_cfg_for_usecase(adev,
2678 usecase);
Preetam Singh Ranawata4a37d82014-09-25 16:56:38 +05302679 if (usecase->type == PCM_PLAYBACK) {
Weiyin Jiang6f4c8062016-11-23 15:30:29 +08002680 if ((24 == usecase->stream.out->bit_width) &&
2681 (usecase->stream.out->devices & AUDIO_DEVICE_OUT_SPEAKER)) {
2682 usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
2683 } else if ((out_snd_device == SND_DEVICE_OUT_HDMI ||
2684 out_snd_device == SND_DEVICE_OUT_USB_HEADSET ||
2685 out_snd_device == SND_DEVICE_OUT_DISPLAY_PORT) &&
2686 (usecase->stream.out->sample_rate >= OUTPUT_SAMPLING_RATE_44100)) {
2687 /*
2688 * To best utlize DSP, check if the stream sample rate is supported/multiple of
2689 * configured device sample rate, if not update the COPP rate to be equal to the
2690 * device sample rate, else open COPP at stream sample rate
2691 */
2692 platform_check_and_update_copp_sample_rate(adev->platform, out_snd_device,
2693 usecase->stream.out->sample_rate,
2694 &usecase->stream.out->app_type_cfg.sample_rate);
Ashish Jain4826f6c2017-02-06 13:33:20 +05302695 } else if (((out_snd_device != SND_DEVICE_OUT_HEADPHONES_44_1 &&
2696 !audio_is_true_native_stream_active(adev)) &&
Weiyin Jiang6f4c8062016-11-23 15:30:29 +08002697 usecase->stream.out->sample_rate == OUTPUT_SAMPLING_RATE_44100) ||
2698 (usecase->stream.out->sample_rate < OUTPUT_SAMPLING_RATE_44100)) {
2699 usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
2700 }
Weiyin Jiangcdece202019-07-08 16:13:16 +08002701 }
2702 enable_audio_route(adev, usecase);
Weiyin Jiang6f4c8062016-11-23 15:30:29 +08002703
Weiyin Jiangcdece202019-07-08 16:13:16 +08002704 /* Notify device change info to effect clients registered */
2705 if (usecase->type == PCM_PLAYBACK) {
Weiyin Jiangfa65d3e2019-03-05 23:39:45 +08002706 audio_extn_gef_notify_device_config(
2707 usecase->stream.out->devices,
2708 usecase->stream.out->channel_mask,
2709 usecase->stream.out->app_type_cfg.sample_rate,
Weiyin Jiang40dcdb92019-07-08 17:31:52 +08002710 platform_get_snd_device_acdb_id(usecase->out_snd_device),
2711 usecase->stream.out->app_type_cfg.app_type);
Preetam Singh Ranawata4a37d82014-09-25 16:56:38 +05302712 }
sangwoo170731f2013-06-08 15:36:36 +09002713
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08002714 audio_extn_qdsp_set_device(usecase);
Aalique Grahame22e49102018-12-18 14:23:57 -08002715
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07002716 /* If input stream is already running then effect needs to be
2717 applied on the new input device that's being enabled here. */
Eric Laurent637e2d42018-11-15 12:24:31 -08002718 if (in_snd_device != SND_DEVICE_NONE)
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07002719 check_and_enable_effect(adev);
2720
Vidyakumar Athota493f2892016-08-14 11:56:55 -07002721 if (usecase->type == VOICE_CALL || usecase->type == VOIP_CALL) {
Vidyakumar Athotaea269c62016-10-31 09:05:59 -07002722 /* Enable aanc only if voice call exists */
2723 if (voice_is_call_state_active(adev))
2724 voice_check_and_update_aanc_path(adev, out_snd_device, true);
2725
Vidyakumar Athota493f2892016-08-14 11:56:55 -07002726 /* Enable sidetone only if other voice/voip call already exists */
2727 if (voice_is_call_state_active(adev) ||
2728 voice_extn_compress_voip_is_started(adev))
2729 voice_set_sidetone(adev, out_snd_device, true);
2730 }
2731
Vidyakumar Athota1fd21792013-11-15 14:50:57 -08002732 /* Applicable only on the targets that has external modem.
2733 * Enable device command should be sent to modem only after
2734 * enabling voice call mixer controls
2735 */
Vidyakumar Athota339342f2014-07-01 15:30:57 -07002736 if (usecase->type == VOICE_CALL)
Vidyakumar Athota1fd21792013-11-15 14:50:57 -08002737 status = platform_switch_voice_call_usecase_route_post(adev->platform,
2738 out_snd_device,
2739 in_snd_device);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302740
2741 if (is_btsco_device(out_snd_device, in_snd_device) || is_a2dp_device(out_snd_device)) {
Eric Laurent637e2d42018-11-15 12:24:31 -08002742 struct stream_in *in = adev_get_active_input(adev);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302743 if (usecase->type == VOIP_CALL) {
Eric Laurent637e2d42018-11-15 12:24:31 -08002744 if (in != NULL && !in->standby) {
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302745 if (is_bt_soc_on(adev) == false){
2746 ALOGD("BT SCO MIC disconnected while in connection");
Eric Laurent637e2d42018-11-15 12:24:31 -08002747 if (in->pcm != NULL)
2748 pcm_stop(in->pcm);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302749 }
2750 }
2751 if ((usecase->stream.out != NULL) && (usecase->stream.out != adev->primary_output)
2752 && usecase->stream.out->started) {
2753 if (is_bt_soc_on(adev) == false) {
2754 ALOGD("BT SCO/A2DP disconnected while in connection");
2755 out_standby_l(&usecase->stream.out->stream.common);
2756 }
2757 }
2758 } else if ((usecase->stream.out != NULL) &&
2759 !(usecase->stream.out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
Surendar Karkae1dc8742018-11-19 16:23:14 +05302760 (usecase->type != TRANSCODE_LOOPBACK_TX) &&
2761 (usecase->type != TRANSCODE_LOOPBACK_RX) &&
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302762 usecase->stream.out->started) {
2763 if (is_bt_soc_on(adev) == false) {
2764 ALOGD("BT SCO/A2dp disconnected while in connection");
2765 out_standby_l(&usecase->stream.out->stream.common);
2766 }
2767 }
2768 }
2769
Yung Ti Su70cb8242018-06-22 17:38:47 +08002770 if (usecase->type != PCM_CAPTURE && usecase == voip_usecase) {
Aalique Grahame22e49102018-12-18 14:23:57 -08002771 struct stream_out *voip_out = voip_usecase->stream.out;
2772 audio_extn_utils_send_app_type_gain(adev,
2773 voip_out->app_type_cfg.app_type,
2774 &voip_out->app_type_cfg.gain[0]);
2775 }
2776
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05302777 ALOGD("%s: done",__func__);
2778
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002779 return status;
2780}
2781
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002782static int stop_input_stream(struct stream_in *in)
2783{
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05302784 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002785 struct audio_usecase *uc_info;
Pallavid7c7a272018-01-16 11:22:55 +05302786
2787 if (in == NULL) {
2788 ALOGE("%s: stream_in ptr is NULL", __func__);
2789 return -EINVAL;
2790 }
2791
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002792 struct audio_device *adev = in->dev;
Carter Hsu2e429db2019-05-14 18:50:52 +08002793 struct stream_in *priority_in = NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002794
Eric Laurent994a6932013-07-17 11:51:42 -07002795 ALOGV("%s: enter: usecase(%d: %s)", __func__,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002796 in->usecase, use_case_table[in->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002797 uc_info = get_usecase_from_list(adev, in->usecase);
2798 if (uc_info == NULL) {
2799 ALOGE("%s: Could not find the usecase (%d) in the list",
2800 __func__, in->usecase);
2801 return -EINVAL;
2802 }
2803
Carter Hsu2e429db2019-05-14 18:50:52 +08002804 priority_in = get_priority_input(adev);
2805
Derek Chenea197282019-01-07 17:35:01 -08002806 if (audio_extn_ext_hw_plugin_usecase_stop(adev->ext_hw_plugin, uc_info))
2807 ALOGE("%s: failed to stop ext hw plugin", __func__);
Derek Chend2530072014-11-24 12:39:14 -08002808
Vidyakumar Athota2850d532013-11-19 16:02:12 -08002809 /* Close in-call recording streams */
2810 voice_check_and_stop_incall_rec_usecase(adev, in);
2811
Eric Laurent150dbfe2013-02-27 14:31:02 -08002812 /* 1. Disable stream specific mixer controls */
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002813 disable_audio_route(adev, uc_info);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002814
2815 /* 2. Disable the tx device */
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002816 disable_snd_device(adev, uc_info->in_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002817
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05302818 if (is_loopback_input_device(in->device))
2819 audio_extn_keep_alive_stop(KEEP_ALIVE_OUT_PRIMARY);
2820
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08002821 list_remove(&uc_info->list);
2822 free(uc_info);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002823
Carter Hsu2e429db2019-05-14 18:50:52 +08002824 if (priority_in == in) {
2825 priority_in = get_priority_input(adev);
2826 if (priority_in)
2827 select_devices(adev, priority_in->usecase);
2828 }
2829
Vatsal Buchac09ae062018-11-14 13:25:08 +05302830 enable_gcov();
Eric Laurent994a6932013-07-17 11:51:42 -07002831 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002832 return ret;
2833}
2834
2835int start_input_stream(struct stream_in *in)
2836{
2837 /* 1. Enable output device and stream routing controls */
Eric Laurentc8400632013-02-14 19:04:54 -08002838 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002839 struct audio_usecase *uc_info;
Preetam Singh Ranawata87e9742018-02-13 16:52:53 +05302840
2841 if (in == NULL) {
2842 ALOGE("%s: stream_in ptr is NULL", __func__);
2843 return -EINVAL;
2844 }
2845
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002846 struct audio_device *adev = in->dev;
Garmond Leunge2433c32017-09-28 21:51:22 -07002847 struct pcm_config config = in->config;
Garmond Leung438932f2017-10-04 19:35:18 -07002848 int usecase = platform_update_usecase_from_source(in->source,in->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002849
Mingming Yin2664a5b2015-09-03 10:53:11 -07002850 if (get_usecase_from_list(adev, usecase) == NULL)
2851 in->usecase = usecase;
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05302852 ALOGD("%s: enter: stream(%p)usecase(%d: %s)",
2853 __func__, &in->stream, in->usecase, use_case_table[in->usecase]);
Shiv Maliyappanahallida107642013-10-17 11:16:13 -07002854
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05302855 if (CARD_STATUS_OFFLINE == in->card_status||
2856 CARD_STATUS_OFFLINE == adev->card_status) {
2857 ALOGW("in->card_status or adev->card_status offline, try again");
Dhanalakshmi Siddani4d57e992014-07-17 16:37:51 +05302858 ret = -EIO;
Naresh Tanniru4c630392014-05-12 01:05:52 +05302859 goto error_config;
2860 }
Naresh Tanniru4c630392014-05-12 01:05:52 +05302861
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302862 if (audio_is_bluetooth_sco_device(in->device)) {
2863 if (!adev->bt_sco_on) {
2864 ALOGE("%s: SCO profile is not ready, return error", __func__);
2865 ret = -EIO;
2866 goto error_config;
2867 }
2868 }
2869
Shiv Maliyappanahallida107642013-10-17 11:16:13 -07002870 /* Check if source matches incall recording usecase criteria */
2871 ret = voice_check_and_set_incall_rec_usecase(adev, in);
2872 if (ret)
2873 goto error_config;
2874 else
Mingming Yin2664a5b2015-09-03 10:53:11 -07002875 ALOGV("%s: usecase(%d)", __func__, in->usecase);
2876
2877 if (get_usecase_from_list(adev, in->usecase) != NULL) {
2878 ALOGE("%s: use case assigned already in use, stream(%p)usecase(%d: %s)",
2879 __func__, &in->stream, in->usecase, use_case_table[in->usecase]);
Zhou Song4e0704d2016-04-20 13:00:14 +08002880 return -EINVAL;
Mingming Yin2664a5b2015-09-03 10:53:11 -07002881 }
Shiv Maliyappanahallida107642013-10-17 11:16:13 -07002882
Eric Laurentb23d5282013-05-14 15:27:20 -07002883 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002884 if (in->pcm_device_id < 0) {
2885 ALOGE("%s: Could not find PCM device id for the usecase(%d)",
2886 __func__, in->usecase);
Eric Laurentc8400632013-02-14 19:04:54 -08002887 ret = -EINVAL;
2888 goto error_config;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002889 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002890
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002891 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07002892
2893 if (!uc_info) {
2894 ret = -ENOMEM;
2895 goto error_config;
2896 }
2897
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002898 uc_info->id = in->usecase;
2899 uc_info->type = PCM_CAPTURE;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08002900 uc_info->stream.in = in;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002901 uc_info->devices = in->device;
2902 uc_info->in_snd_device = SND_DEVICE_NONE;
2903 uc_info->out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002904
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08002905 list_add_tail(&adev->usecase_list, &uc_info->list);
Wei Wangf7ca6c92017-11-21 14:51:20 -08002906 audio_streaming_hint_start();
Sudheer Papothifa9d2282015-09-17 01:53:25 +05302907 audio_extn_perf_lock_acquire(&adev->perf_lock_handle, 0,
2908 adev->perf_lock_opts,
2909 adev->perf_lock_opts_size);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002910 select_devices(adev, in->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002911
Derek Chenea197282019-01-07 17:35:01 -08002912 if (audio_extn_ext_hw_plugin_usecase_start(adev->ext_hw_plugin, uc_info))
2913 ALOGE("%s: failed to start ext hw plugin", __func__);
Derek Chend2530072014-11-24 12:39:14 -08002914
Deeraj Soman30cc7ae2019-03-18 16:26:55 +05302915 android_atomic_acquire_cas(true, false, &(in->capture_stopped));
2916
Haynes Mathew George16081042017-05-31 17:16:49 -07002917 if (audio_extn_cin_attached_usecase(in->usecase)) {
Manish Dewangan46e07982018-12-13 18:18:59 +05302918 ret = audio_extn_cin_open_input_stream(in);
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05302919 if (ret)
2920 goto error_open;
2921 else
2922 goto done_open;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002923 }
2924
Haynes Mathew George16081042017-05-31 17:16:49 -07002925 if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002926 if (in->pcm == NULL || !pcm_is_ready(in->pcm)) {
Haynes Mathew George16081042017-05-31 17:16:49 -07002927 ALOGE("%s: pcm stream not ready", __func__);
2928 goto error_open;
2929 }
2930 ret = pcm_start(in->pcm);
2931 if (ret < 0) {
2932 ALOGE("%s: MMAP pcm_start failed ret %d", __func__, ret);
2933 goto error_open;
2934 }
2935 } else {
2936 unsigned int flags = PCM_IN | PCM_MONOTONIC;
2937 unsigned int pcm_open_retry_count = 0;
2938
2939 if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY) {
2940 flags |= PCM_MMAP | PCM_NOIRQ;
2941 pcm_open_retry_count = PROXY_OPEN_RETRY_COUNT;
2942 } else if (in->realtime) {
2943 flags |= PCM_MMAP | PCM_NOIRQ;
2944 }
2945
Garmond Leunge2433c32017-09-28 21:51:22 -07002946 if (audio_extn_ffv_get_stream() == in) {
2947 ALOGD("%s: ffv stream, update pcm config", __func__);
2948 audio_extn_ffv_update_pcm_config(&config);
2949 }
Haynes Mathew George16081042017-05-31 17:16:49 -07002950 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
2951 __func__, adev->snd_card, in->pcm_device_id, in->config.channels);
2952
2953 while (1) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07002954 ATRACE_BEGIN("pcm_in_open");
Haynes Mathew George16081042017-05-31 17:16:49 -07002955 in->pcm = pcm_open(adev->snd_card, in->pcm_device_id,
Garmond Leung438932f2017-10-04 19:35:18 -07002956 flags, &config);
Haynes Mathew George380745d2017-10-04 15:27:45 -07002957 ATRACE_END();
Satish Babu Patakokila54ce83d2018-07-06 18:00:37 +05302958 if (errno == ENETRESET && !pcm_is_ready(in->pcm)) {
Sharad Sanglec6f32552018-05-04 16:15:38 +05302959 ALOGE("%s: pcm_open failed errno:%d\n", __func__, errno);
2960 adev->card_status = CARD_STATUS_OFFLINE;
2961 in->card_status = CARD_STATUS_OFFLINE;
2962 ret = -EIO;
2963 goto error_open;
2964 }
2965
Haynes Mathew George16081042017-05-31 17:16:49 -07002966 if (in->pcm == NULL || !pcm_is_ready(in->pcm)) {
2967 ALOGE("%s: %s", __func__, pcm_get_error(in->pcm));
2968 if (in->pcm != NULL) {
2969 pcm_close(in->pcm);
2970 in->pcm = NULL;
2971 }
2972 if (pcm_open_retry_count-- == 0) {
2973 ret = -EIO;
2974 goto error_open;
2975 }
2976 usleep(PROXY_OPEN_WAIT_TIME * 1000);
2977 continue;
2978 }
2979 break;
2980 }
2981
2982 ALOGV("%s: pcm_prepare", __func__);
Haynes Mathew George380745d2017-10-04 15:27:45 -07002983 ATRACE_BEGIN("pcm_in_prepare");
Haynes Mathew George16081042017-05-31 17:16:49 -07002984 ret = pcm_prepare(in->pcm);
Haynes Mathew George380745d2017-10-04 15:27:45 -07002985 ATRACE_END();
Haynes Mathew George16081042017-05-31 17:16:49 -07002986 if (ret < 0) {
2987 ALOGE("%s: pcm_prepare returned %d", __func__, ret);
2988 pcm_close(in->pcm);
2989 in->pcm = NULL;
2990 goto error_open;
2991 }
2992 register_in_stream(in);
2993 if (in->realtime) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07002994 ATRACE_BEGIN("pcm_in_start");
Haynes Mathew George16081042017-05-31 17:16:49 -07002995 ret = pcm_start(in->pcm);
Haynes Mathew George380745d2017-10-04 15:27:45 -07002996 ATRACE_END();
Haynes Mathew George16081042017-05-31 17:16:49 -07002997 if (ret < 0) {
2998 ALOGE("%s: RT pcm_start failed ret %d", __func__, ret);
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002999 pcm_close(in->pcm);
3000 in->pcm = NULL;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003001 goto error_open;
3002 }
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003003 }
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003004 }
3005
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07003006 check_and_enable_effect(adev);
justinweng20fb6d82019-02-21 18:49:00 -07003007 audio_extn_audiozoom_set_microphone_direction(in, in->zoom);
3008 audio_extn_audiozoom_set_microphone_field_dimension(in, in->direction);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07003009
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05303010 if (is_loopback_input_device(in->device))
3011 audio_extn_keep_alive_start(KEEP_ALIVE_OUT_PRIMARY);
3012
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05303013done_open:
Wei Wangf7ca6c92017-11-21 14:51:20 -08003014 audio_streaming_hint_end();
Sudheer Papothifa9d2282015-09-17 01:53:25 +05303015 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07003016 ALOGD("%s: exit", __func__);
Vatsal Buchac09ae062018-11-14 13:25:08 +05303017 enable_gcov();
Eric Laurentc8400632013-02-14 19:04:54 -08003018 return ret;
3019
3020error_open:
Wei Wangf7ca6c92017-11-21 14:51:20 -08003021 audio_streaming_hint_end();
Sudheer Papothifa9d2282015-09-17 01:53:25 +05303022 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003023 stop_input_stream(in);
Wei Wangf7ca6c92017-11-21 14:51:20 -08003024
Eric Laurentc8400632013-02-14 19:04:54 -08003025error_config:
Laxminath Kasam2cb4b752015-09-24 03:59:15 +05303026 /*
3027 * sleep 50ms to allow sufficient time for kernel
3028 * drivers to recover incases like SSR.
3029 */
3030 usleep(50000);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003031 ALOGD("%s: exit: status(%d)", __func__, ret);
Vatsal Buchac09ae062018-11-14 13:25:08 +05303032 enable_gcov();
Eric Laurentc8400632013-02-14 19:04:54 -08003033 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003034}
3035
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07003036void lock_input_stream(struct stream_in *in)
3037{
3038 pthread_mutex_lock(&in->pre_lock);
3039 pthread_mutex_lock(&in->lock);
3040 pthread_mutex_unlock(&in->pre_lock);
3041}
3042
3043void lock_output_stream(struct stream_out *out)
3044{
3045 pthread_mutex_lock(&out->pre_lock);
3046 pthread_mutex_lock(&out->lock);
3047 pthread_mutex_unlock(&out->pre_lock);
3048}
3049
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003050/* must be called with out->lock locked */
3051static int send_offload_cmd_l(struct stream_out* out, int command)
3052{
3053 struct offload_cmd *cmd = (struct offload_cmd *)calloc(1, sizeof(struct offload_cmd));
3054
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07003055 if (!cmd) {
3056 ALOGE("failed to allocate mem for command 0x%x", command);
3057 return -ENOMEM;
3058 }
3059
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003060 ALOGVV("%s %d", __func__, command);
3061
3062 cmd->cmd = command;
3063 list_add_tail(&out->offload_cmd_list, &cmd->node);
3064 pthread_cond_signal(&out->offload_cond);
3065 return 0;
3066}
3067
3068/* must be called iwth out->lock locked */
3069static void stop_compressed_output_l(struct stream_out *out)
3070{
3071 out->offload_state = OFFLOAD_STATE_IDLE;
3072 out->playback_started = 0;
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003073 out->send_new_metadata = 1;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003074 if (out->compr != NULL) {
3075 compress_stop(out->compr);
3076 while (out->offload_thread_blocked) {
3077 pthread_cond_wait(&out->cond, &out->lock);
3078 }
3079 }
3080}
3081
Varun Balaraje49253e2017-07-06 19:48:56 +05303082bool is_interactive_usecase(audio_usecase_t uc_id)
3083{
3084 unsigned int i;
3085 for (i = 0; i < sizeof(interactive_usecases)/sizeof(interactive_usecases[0]); i++) {
3086 if (uc_id == interactive_usecases[i])
3087 return true;
3088 }
3089 return false;
3090}
3091
3092static audio_usecase_t get_interactive_usecase(struct audio_device *adev)
3093{
3094 audio_usecase_t ret_uc = USECASE_INVALID;
3095 unsigned int intract_uc_index;
3096 unsigned int num_usecase = sizeof(interactive_usecases)/sizeof(interactive_usecases[0]);
3097
3098 ALOGV("%s: num_usecase: %d", __func__, num_usecase);
3099 for (intract_uc_index = 0; intract_uc_index < num_usecase; intract_uc_index++) {
3100 if (!(adev->interactive_usecase_state & (0x1 << intract_uc_index))) {
3101 adev->interactive_usecase_state |= 0x1 << intract_uc_index;
3102 ret_uc = interactive_usecases[intract_uc_index];
3103 break;
3104 }
3105 }
3106
3107 ALOGV("%s: Interactive usecase is %d", __func__, ret_uc);
3108 return ret_uc;
3109}
3110
3111static void free_interactive_usecase(struct audio_device *adev,
3112 audio_usecase_t uc_id)
3113{
3114 unsigned int interact_uc_index;
3115 unsigned int num_usecase = sizeof(interactive_usecases)/sizeof(interactive_usecases[0]);
3116
3117 for (interact_uc_index = 0; interact_uc_index < num_usecase; interact_uc_index++) {
3118 if (interactive_usecases[interact_uc_index] == uc_id) {
3119 adev->interactive_usecase_state &= ~(0x1 << interact_uc_index);
3120 break;
3121 }
3122 }
3123 ALOGV("%s: free Interactive usecase %d", __func__, uc_id);
3124}
3125
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07003126bool is_offload_usecase(audio_usecase_t uc_id)
3127{
3128 unsigned int i;
3129 for (i = 0; i < sizeof(offload_usecases)/sizeof(offload_usecases[0]); i++) {
3130 if (uc_id == offload_usecases[i])
3131 return true;
3132 }
3133 return false;
3134}
3135
Dhananjay Kumarac341582017-02-23 23:42:25 +05303136static audio_usecase_t get_offload_usecase(struct audio_device *adev, bool is_compress)
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07003137{
vivek mehta446c3962015-09-14 10:57:35 -07003138 audio_usecase_t ret_uc = USECASE_INVALID;
3139 unsigned int offload_uc_index;
Alexy Josephb1379942016-01-29 15:49:38 -08003140 unsigned int num_usecase = sizeof(offload_usecases)/sizeof(offload_usecases[0]);
vivek mehta446c3962015-09-14 10:57:35 -07003141 if (!adev->multi_offload_enable) {
Dhananjay Kumarac341582017-02-23 23:42:25 +05303142 if (!is_compress)
vivek mehta446c3962015-09-14 10:57:35 -07003143 ret_uc = USECASE_AUDIO_PLAYBACK_OFFLOAD2;
3144 else
3145 ret_uc = USECASE_AUDIO_PLAYBACK_OFFLOAD;
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07003146
vivek mehta446c3962015-09-14 10:57:35 -07003147 pthread_mutex_lock(&adev->lock);
3148 if (get_usecase_from_list(adev, ret_uc) != NULL)
3149 ret_uc = USECASE_INVALID;
3150 pthread_mutex_unlock(&adev->lock);
3151
3152 return ret_uc;
3153 }
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07003154
3155 ALOGV("%s: num_usecase: %d", __func__, num_usecase);
vivek mehta446c3962015-09-14 10:57:35 -07003156 for (offload_uc_index = 0; offload_uc_index < num_usecase; offload_uc_index++) {
3157 if (!(adev->offload_usecases_state & (0x1 << offload_uc_index))) {
3158 adev->offload_usecases_state |= 0x1 << offload_uc_index;
3159 ret_uc = offload_usecases[offload_uc_index];
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07003160 break;
3161 }
3162 }
vivek mehta446c3962015-09-14 10:57:35 -07003163
3164 ALOGV("%s: offload usecase is %d", __func__, ret_uc);
3165 return ret_uc;
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07003166}
3167
3168static void free_offload_usecase(struct audio_device *adev,
3169 audio_usecase_t uc_id)
3170{
vivek mehta446c3962015-09-14 10:57:35 -07003171 unsigned int offload_uc_index;
Alexy Josephb1379942016-01-29 15:49:38 -08003172 unsigned int num_usecase = sizeof(offload_usecases)/sizeof(offload_usecases[0]);
vivek mehta446c3962015-09-14 10:57:35 -07003173
3174 if (!adev->multi_offload_enable)
3175 return;
3176
3177 for (offload_uc_index = 0; offload_uc_index < num_usecase; offload_uc_index++) {
3178 if (offload_usecases[offload_uc_index] == uc_id) {
3179 adev->offload_usecases_state &= ~(0x1 << offload_uc_index);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07003180 break;
3181 }
3182 }
3183 ALOGV("%s: free offload usecase %d", __func__, uc_id);
3184}
3185
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003186static void *offload_thread_loop(void *context)
3187{
3188 struct stream_out *out = (struct stream_out *) context;
3189 struct listnode *item;
Krishnankutty Kolathappillyd4f1d132014-01-06 18:33:58 -08003190 int ret = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003191
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003192 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08003193 //set_sched_policy(0, SP_FOREGROUND);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003194 prctl(PR_SET_NAME, (unsigned long)"Offload Callback", 0, 0, 0);
3195
3196 ALOGV("%s", __func__);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07003197 lock_output_stream(out);
juyuchen391b5fa2018-12-12 17:58:09 +08003198 out->offload_state = OFFLOAD_STATE_IDLE;
3199 out->playback_started = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003200 for (;;) {
3201 struct offload_cmd *cmd = NULL;
3202 stream_callback_event_t event;
3203 bool send_callback = false;
3204
3205 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
3206 __func__, list_empty(&out->offload_cmd_list),
3207 out->offload_state);
3208 if (list_empty(&out->offload_cmd_list)) {
3209 ALOGV("%s SLEEPING", __func__);
3210 pthread_cond_wait(&out->offload_cond, &out->lock);
3211 ALOGV("%s RUNNING", __func__);
3212 continue;
3213 }
3214
3215 item = list_head(&out->offload_cmd_list);
3216 cmd = node_to_item(item, struct offload_cmd, node);
3217 list_remove(item);
3218
3219 ALOGVV("%s STATE %d CMD %d out->compr %p",
3220 __func__, out->offload_state, cmd->cmd, out->compr);
3221
3222 if (cmd->cmd == OFFLOAD_CMD_EXIT) {
3223 free(cmd);
3224 break;
3225 }
3226
Haynes Mathew Georgeee5836f2017-11-21 18:02:10 -08003227 // allow OFFLOAD_CMD_ERROR reporting during standby
3228 // this is needed to handle failures during compress_open
3229 // Note however that on a pause timeout, the stream is closed
3230 // and no offload usecase will be active. Therefore this
3231 // special case is needed for compress_open failures alone
3232 if (cmd->cmd != OFFLOAD_CMD_ERROR &&
3233 out->compr == NULL) {
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003234 ALOGE("%s: Compress handle is NULL", __func__);
Haynes Mathew Georgea9abb202016-06-02 14:13:20 -07003235 free(cmd);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003236 pthread_cond_signal(&out->cond);
3237 continue;
3238 }
3239 out->offload_thread_blocked = true;
3240 pthread_mutex_unlock(&out->lock);
3241 send_callback = false;
3242 switch(cmd->cmd) {
3243 case OFFLOAD_CMD_WAIT_FOR_BUFFER:
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07003244 ALOGD("copl(%p):calling compress_wait", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003245 compress_wait(out->compr, -1);
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07003246 ALOGD("copl(%p):out of compress_wait", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003247 send_callback = true;
3248 event = STREAM_CBK_EVENT_WRITE_READY;
3249 break;
3250 case OFFLOAD_CMD_PARTIAL_DRAIN:
Krishnankutty Kolathappillyd4f1d132014-01-06 18:33:58 -08003251 ret = compress_next_track(out->compr);
Sidipotu Ashok55820562014-02-10 16:16:38 +05303252 if(ret == 0) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07003253 ALOGD("copl(%p):calling compress_partial_drain", out);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05303254 ret = compress_partial_drain(out->compr);
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07003255 ALOGD("copl(%p):out of compress_partial_drain", out);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05303256 if (ret < 0)
3257 ret = -errno;
Sidipotu Ashok55820562014-02-10 16:16:38 +05303258 }
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05303259 else if (ret == -ETIMEDOUT)
Aniket Kumar Lata3570fb12017-11-08 15:53:44 -08003260 ret = compress_drain(out->compr);
Krishnankutty Kolathappillyd4f1d132014-01-06 18:33:58 -08003261 else
3262 ALOGE("%s: Next track returned error %d",__func__, ret);
Aniket Kumar Lata3570fb12017-11-08 15:53:44 -08003263 if (-ENETRESET != ret && !(-EINTR == ret &&
3264 CARD_STATUS_OFFLINE == out->card_status)) {
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05303265 send_callback = true;
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05303266 pthread_mutex_lock(&out->lock);
3267 out->send_new_metadata = 1;
3268 out->send_next_track_params = true;
3269 pthread_mutex_unlock(&out->lock);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05303270 event = STREAM_CBK_EVENT_DRAIN_READY;
3271 ALOGV("copl(%p):send drain callback, ret %d", out, ret);
3272 } else
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05303273 ALOGI("%s: Block drain ready event during SSR", __func__);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003274 break;
3275 case OFFLOAD_CMD_DRAIN:
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07003276 ALOGD("copl(%p):calling compress_drain", out);
Aniket Kumar Lata3570fb12017-11-08 15:53:44 -08003277 ret = compress_drain(out->compr);
3278 ALOGD("copl(%p):out of compress_drain", out);
3279 // EINTR check avoids drain interruption due to SSR
3280 if (-ENETRESET != ret && !(-EINTR == ret &&
3281 CARD_STATUS_OFFLINE == out->card_status)) {
3282 send_callback = true;
3283 event = STREAM_CBK_EVENT_DRAIN_READY;
3284 } else
3285 ALOGI("%s: Block drain ready event during SSR", __func__);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003286 break;
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05303287 case OFFLOAD_CMD_ERROR:
3288 ALOGD("copl(%p): sending error callback to AF", out);
3289 send_callback = true;
3290 event = STREAM_CBK_EVENT_ERROR;
3291 break;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003292 default:
3293 ALOGE("%s unknown command received: %d", __func__, cmd->cmd);
3294 break;
3295 }
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07003296 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003297 out->offload_thread_blocked = false;
3298 pthread_cond_signal(&out->cond);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08003299 if (send_callback && out->client_callback) {
3300 ALOGVV("%s: sending client_callback event %d", __func__, event);
3301 out->client_callback(event, NULL, out->client_cookie);
Eric Laurent6e895242013-09-05 16:10:57 -07003302 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003303 free(cmd);
3304 }
3305
3306 pthread_cond_signal(&out->cond);
3307 while (!list_empty(&out->offload_cmd_list)) {
3308 item = list_head(&out->offload_cmd_list);
3309 list_remove(item);
3310 free(node_to_item(item, struct offload_cmd, node));
3311 }
3312 pthread_mutex_unlock(&out->lock);
3313
3314 return NULL;
3315}
3316
3317static int create_offload_callback_thread(struct stream_out *out)
3318{
3319 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
3320 list_init(&out->offload_cmd_list);
3321 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
3322 offload_thread_loop, out);
3323 return 0;
3324}
3325
3326static int destroy_offload_callback_thread(struct stream_out *out)
3327{
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07003328 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003329 stop_compressed_output_l(out);
3330 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
3331
3332 pthread_mutex_unlock(&out->lock);
3333 pthread_join(out->offload_thread, (void **) NULL);
3334 pthread_cond_destroy(&out->offload_cond);
3335
3336 return 0;
3337}
3338
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003339static int stop_output_stream(struct stream_out *out)
3340{
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05303341 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003342 struct audio_usecase *uc_info;
3343 struct audio_device *adev = out->dev;
Aalique Grahame22e49102018-12-18 14:23:57 -08003344 bool has_voip_usecase =
3345 get_usecase_from_list(adev, USECASE_AUDIO_PLAYBACK_VOIP) != NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003346
Eric Laurent994a6932013-07-17 11:51:42 -07003347 ALOGV("%s: enter: usecase(%d: %s)", __func__,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003348 out->usecase, use_case_table[out->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003349 uc_info = get_usecase_from_list(adev, out->usecase);
3350 if (uc_info == NULL) {
3351 ALOGE("%s: Could not find the usecase (%d) in the list",
3352 __func__, out->usecase);
3353 return -EINVAL;
3354 }
3355
Derek Chenea197282019-01-07 17:35:01 -08003356 if (audio_extn_ext_hw_plugin_usecase_stop(adev->ext_hw_plugin, uc_info))
3357 ALOGE("%s: failed to stop ext hw plugin", __func__);
Derek Chend2530072014-11-24 12:39:14 -08003358
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003359 if (is_offload_usecase(out->usecase) &&
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05303360 !(audio_extn_passthru_is_passthrough_stream(out))) {
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08003361 if (adev->visualizer_stop_output != NULL)
3362 adev->visualizer_stop_output(out->handle, out->pcm_device_id);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08003363
3364 audio_extn_dts_remove_state_notifier_node(out->usecase);
3365
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08003366 if (adev->offload_effects_stop_output != NULL)
3367 adev->offload_effects_stop_output(out->handle, out->pcm_device_id);
vivek mehtad15d2bf2019-05-17 13:35:10 -07003368 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_ULL ||
3369 out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
3370 audio_low_latency_hint_end();
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08003371 }
Eric Laurentc4aef752013-09-12 17:45:53 -07003372
Arun Mirpurief53ce52018-09-11 18:00:09 -07003373 if (out->usecase == USECASE_INCALL_MUSIC_UPLINK)
3374 voice_set_device_mute_flag(adev, false);
3375
Eric Laurent150dbfe2013-02-27 14:31:02 -08003376 /* 1. Get and set stream specific mixer controls */
Haynes Mathew George1376ca62014-04-24 11:55:48 -07003377 disable_audio_route(adev, uc_info);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003378
3379 /* 2. Disable the rx device */
Haynes Mathew George1376ca62014-04-24 11:55:48 -07003380 disable_snd_device(adev, uc_info->out_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003381
Aalique Grahame22e49102018-12-18 14:23:57 -08003382 audio_extn_extspk_update(adev->extspk);
3383
Xiaojun Sang785b5da2017-08-03 15:52:29 +08003384 if (is_offload_usecase(out->usecase)) {
3385 audio_enable_asm_bit_width_enforce_mode(adev->mixer,
3386 adev->dsp_bit_width_enforce_mode,
3387 false);
3388 }
Garmond Leung5fd0b552018-04-17 11:56:12 -07003389 if (audio_is_usb_out_device(out->devices & AUDIO_DEVICE_OUT_ALL_USB)) {
3390 ret = audio_extn_usb_check_and_set_svc_int(uc_info,
3391 false);
3392
3393 if (ret != 0)
3394 check_usecases_codec_backend(adev, uc_info, uc_info->out_snd_device);
3395 /* default service interval was successfully updated,
3396 reopen USB backend with new service interval */
3397 ret = 0;
3398 }
Xiaojun Sang785b5da2017-08-03 15:52:29 +08003399
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08003400 list_remove(&uc_info->list);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05303401 out->started = 0;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003402 if (is_offload_usecase(out->usecase) &&
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05303403 (audio_extn_passthru_is_passthrough_stream(out))) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003404 ALOGV("Disable passthrough , reset mixer to pcm");
3405 /* NO_PASSTHROUGH */
3406 out->compr_config.codec->compr_passthr = 0;
Mingming Yin21854652016-04-13 11:54:02 -07003407 audio_extn_passthru_on_stop(out);
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003408 audio_extn_dolby_set_dap_bypass(adev, DAP_STATE_ON);
3409 }
Eric Laurent07eeafd2013-10-06 12:52:49 -07003410
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05303411 /* Must be called after removing the usecase from list */
3412 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
Md Mansoor Ahmeddb1b4f92018-01-25 18:56:31 +05303413 audio_extn_keep_alive_start(KEEP_ALIVE_OUT_HDMI);
Ashish Jaind84fd6a2016-07-27 12:33:25 +05303414
Manish Dewangan21a850a2017-08-14 12:03:55 +05303415 if (out->ip_hdlr_handle) {
Naresh Tanniru85819452017-05-04 18:55:45 -07003416 ret = audio_extn_ip_hdlr_intf_close(out->ip_hdlr_handle, true, out);
3417 if (ret < 0)
3418 ALOGE("%s: audio_extn_ip_hdlr_intf_close failed %d",__func__, ret);
3419 }
3420
juyuchen2d415992018-11-16 14:15:16 +08003421 /* 1) media + voip output routing to handset must route media back to
3422 speaker when voip stops.
3423 2) trigger voip input to reroute when voip output changes to
3424 hearing aid. */
Aalique Grahame22e49102018-12-18 14:23:57 -08003425 if (has_voip_usecase ||
3426 out->devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) {
3427 struct listnode *node;
3428 struct audio_usecase *usecase;
3429 list_for_each(node, &adev->usecase_list) {
3430 usecase = node_to_item(node, struct audio_usecase, list);
juyuchen2d415992018-11-16 14:15:16 +08003431 if ((usecase->type == PCM_CAPTURE &&
3432 usecase->id != USECASE_AUDIO_RECORD_VOIP)
3433 || usecase == uc_info)
Aalique Grahame22e49102018-12-18 14:23:57 -08003434 continue;
3435
3436 ALOGD("%s: select_devices at usecase(%d: %s) after removing the usecase(%d: %s)",
3437 __func__, usecase->id, use_case_table[usecase->id],
3438 out->usecase, use_case_table[out->usecase]);
3439 select_devices(adev, usecase->id);
3440 }
3441 }
3442
Garmond Leung5fd0b552018-04-17 11:56:12 -07003443 free(uc_info);
Eric Laurent994a6932013-07-17 11:51:42 -07003444 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003445 return ret;
3446}
3447
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003448struct pcm* pcm_open_prepare_helper(unsigned int snd_card, unsigned int pcm_device_id,
3449 unsigned int flags, unsigned int pcm_open_retry_count,
3450 struct pcm_config *config)
3451{
3452 struct pcm* pcm = NULL;
3453
3454 while (1) {
3455 pcm = pcm_open(snd_card, pcm_device_id, flags, config);
3456 if (pcm == NULL || !pcm_is_ready(pcm)) {
3457 ALOGE("%s: %s", __func__, pcm_get_error(pcm));
3458 if (pcm != NULL) {
3459 pcm_close(pcm);
3460 pcm = NULL;
3461 }
3462 if (pcm_open_retry_count-- == 0)
3463 return NULL;
3464
3465 usleep(PROXY_OPEN_WAIT_TIME * 1000);
3466 continue;
3467 }
3468 break;
3469 }
3470
3471 if (pcm_is_ready(pcm)) {
3472 int ret = pcm_prepare(pcm);
3473 if (ret < 0) {
3474 ALOGE("%s: pcm_prepare returned %d", __func__, ret);
3475 pcm_close(pcm);
3476 pcm = NULL;
3477 }
3478 }
3479
3480 return pcm;
3481}
3482
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003483int start_output_stream(struct stream_out *out)
3484{
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003485 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003486 struct audio_usecase *uc_info;
3487 struct audio_device *adev = out->dev;
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08003488 char mixer_ctl_name[128];
3489 struct mixer_ctl *ctl = NULL;
3490 char* perf_mode[] = {"ULL", "ULL_PP", "LL"};
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303491 bool a2dp_combo = false;
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003492 bool is_haptic_usecase = (out->usecase == USECASE_AUDIO_PLAYBACK_WITH_HAPTICS) ? true: false;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003493
Haynes Mathew George380745d2017-10-04 15:27:45 -07003494 ATRACE_BEGIN("start_output_stream");
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07003495 if ((out->usecase < 0) || (out->usecase >= AUDIO_USECASE_MAX)) {
3496 ret = -EINVAL;
3497 goto error_config;
3498 }
3499
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003500 ALOGD("%s: enter: stream(%p)usecase(%d: %s) devices(%#x) is_haptic_usecase(%d)",
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05303501 __func__, &out->stream, out->usecase, use_case_table[out->usecase],
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003502 out->devices, is_haptic_usecase);
Naresh Tanniru4c630392014-05-12 01:05:52 +05303503
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05303504 if (CARD_STATUS_OFFLINE == out->card_status ||
3505 CARD_STATUS_OFFLINE == adev->card_status) {
3506 ALOGW("out->card_status or adev->card_status offline, try again");
Dhanalakshmi Siddani4d57e992014-07-17 16:37:51 +05303507 ret = -EIO;
Naresh Tanniru4c630392014-05-12 01:05:52 +05303508 goto error_config;
3509 }
Naresh Tanniru4c630392014-05-12 01:05:52 +05303510
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05303511 if (out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
Florian Pfister1a84f312018-07-19 14:38:18 +02003512 if (!audio_extn_a2dp_source_is_ready()) {
Aalique Grahame22e49102018-12-18 14:23:57 -08003513 if (out->devices &
3514 (AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303515 a2dp_combo = true;
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05303516 } else {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303517 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
3518 ALOGE("%s: A2DP profile is not ready, return error", __func__);
3519 ret = -EAGAIN;
3520 goto error_config;
3521 }
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05303522 }
3523 }
3524 }
Ashish Jain1b9b30c2017-05-18 20:57:40 +05303525 if (out->devices & AUDIO_DEVICE_OUT_ALL_SCO) {
3526 if (!adev->bt_sco_on) {
3527 if (out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
3528 //combo usecase just by pass a2dp
3529 ALOGW("%s: SCO is not connected, route it to speaker", __func__);
3530 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
3531 } else {
3532 ALOGE("%s: SCO profile is not ready, return error", __func__);
3533 ret = -EAGAIN;
3534 goto error_config;
3535 }
3536 }
3537 }
3538
Eric Laurentb23d5282013-05-14 15:27:20 -07003539 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003540 if (out->pcm_device_id < 0) {
3541 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
3542 __func__, out->pcm_device_id, out->usecase);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08003543 ret = -EINVAL;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003544 goto error_open;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003545 }
3546
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003547 if (is_haptic_usecase) {
3548 adev->haptic_pcm_device_id = platform_get_haptics_pcm_device_id();
3549 if (adev->haptic_pcm_device_id < 0) {
3550 ALOGE("%s: Invalid Haptics pcm device id(%d) for the usecase(%d)",
3551 __func__, adev->haptic_pcm_device_id, out->usecase);
3552 ret = -EINVAL;
3553 goto error_config;
3554 }
3555 }
3556
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003557 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07003558
3559 if (!uc_info) {
3560 ret = -ENOMEM;
3561 goto error_config;
3562 }
3563
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003564 uc_info->id = out->usecase;
3565 uc_info->type = PCM_PLAYBACK;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08003566 uc_info->stream.out = out;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003567 uc_info->devices = out->devices;
3568 uc_info->in_snd_device = SND_DEVICE_NONE;
3569 uc_info->out_snd_device = SND_DEVICE_NONE;
Garmond Leung5fd0b552018-04-17 11:56:12 -07003570
3571 /* This must be called before adding this usecase to the list */
3572 if (audio_is_usb_out_device(out->devices & AUDIO_DEVICE_OUT_ALL_USB)) {
3573 audio_extn_usb_check_and_set_svc_int(uc_info, true);
3574 /* USB backend is not reopened immediately.
3575 This is eventually done as part of select_devices */
3576 }
3577
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08003578 list_add_tail(&adev->usecase_list, &uc_info->list);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003579
Wei Wangf7ca6c92017-11-21 14:51:20 -08003580 audio_streaming_hint_start();
Sudheer Papothifa9d2282015-09-17 01:53:25 +05303581 audio_extn_perf_lock_acquire(&adev->perf_lock_handle, 0,
3582 adev->perf_lock_opts,
3583 adev->perf_lock_opts_size);
Ashish Jaind84fd6a2016-07-27 12:33:25 +05303584
3585 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
Md Mansoor Ahmeddb1b4f92018-01-25 18:56:31 +05303586 audio_extn_keep_alive_stop(KEEP_ALIVE_OUT_HDMI);
Ashish Jaind84fd6a2016-07-27 12:33:25 +05303587 if (audio_extn_passthru_is_enabled() &&
3588 audio_extn_passthru_is_passthrough_stream(out)) {
3589 audio_extn_passthru_on_start(out);
Ashish Jaind84fd6a2016-07-27 12:33:25 +05303590 }
3591 }
3592
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303593 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
Florian Pfister1a84f312018-07-19 14:38:18 +02003594 (!audio_extn_a2dp_source_is_ready())) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303595 if (!a2dp_combo) {
3596 check_a2dp_restore_l(adev, out, false);
3597 } else {
3598 audio_devices_t dev = out->devices;
Aalique Grahame22e49102018-12-18 14:23:57 -08003599 if (dev & AUDIO_DEVICE_OUT_SPEAKER_SAFE)
3600 out->devices = AUDIO_DEVICE_OUT_SPEAKER_SAFE;
3601 else
3602 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303603 select_devices(adev, out->usecase);
3604 out->devices = dev;
3605 }
3606 } else {
3607 select_devices(adev, out->usecase);
3608 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003609
Arun Mirpurief53ce52018-09-11 18:00:09 -07003610 if (out->usecase == USECASE_INCALL_MUSIC_UPLINK)
3611 voice_set_device_mute_flag(adev, true);
3612
Derek Chenea197282019-01-07 17:35:01 -08003613 if (audio_extn_ext_hw_plugin_usecase_start(adev->ext_hw_plugin, uc_info))
3614 ALOGE("%s: failed to start ext hw plugin", __func__);
Derek Chend2530072014-11-24 12:39:14 -08003615
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003616 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d) format(%#x)",
3617 __func__, adev->snd_card, out->pcm_device_id, out->config.format);
Haynes Mathew George16081042017-05-31 17:16:49 -07003618
3619 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
Arun Mirpuri5d170872019-03-26 13:21:31 -07003620 ALOGD("%s: Starting MMAP stream", __func__);
Haynes Mathew George16081042017-05-31 17:16:49 -07003621 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
3622 ALOGE("%s: pcm stream not ready", __func__);
3623 goto error_open;
3624 }
3625 ret = pcm_start(out->pcm);
3626 if (ret < 0) {
3627 ALOGE("%s: MMAP pcm_start failed ret %d", __func__, ret);
3628 goto error_open;
3629 }
Arun Mirpuri5d170872019-03-26 13:21:31 -07003630 out_set_mmap_volume(&out->stream, out->volume_l, out->volume_r);
Haynes Mathew George16081042017-05-31 17:16:49 -07003631 } else if (!is_offload_usecase(out->usecase)) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003632 unsigned int flags = PCM_OUT;
3633 unsigned int pcm_open_retry_count = 0;
3634 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
3635 flags |= PCM_MMAP | PCM_NOIRQ;
3636 pcm_open_retry_count = PROXY_OPEN_RETRY_COUNT;
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003637 } else if (out->realtime) {
Haynes Mathew George4ab3ba92017-12-11 14:49:43 -08003638 flags |= PCM_MMAP | PCM_NOIRQ | PCM_MONOTONIC;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003639 } else
3640 flags |= PCM_MONOTONIC;
3641
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08003642 if ((adev->vr_audio_mode_enabled) &&
3643 (out->flags & AUDIO_OUTPUT_FLAG_RAW)) {
3644 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
3645 "PCM_Dev %d Topology", out->pcm_device_id);
3646 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
3647 if (!ctl) {
3648 ALOGI("%s: Could not get ctl for mixer cmd might be ULL - %s",
3649 __func__, mixer_ctl_name);
3650 } else {
3651 //if success use ULLPP
3652 ALOGI("%s: mixer ctrl %s succeeded setting up ULL for %d",
3653 __func__, mixer_ctl_name, out->pcm_device_id);
3654 //There is a still a possibility that some sessions
3655 // that request for FAST|RAW when 3D audio is active
3656 //can go through ULLPP. Ideally we expects apps to
3657 //listen to audio focus and stop concurrent playback
3658 //Also, we will look for mode flag (voice_in_communication)
3659 //before enabling the realtime flag.
3660 mixer_ctl_set_enum_by_string(ctl, perf_mode[1]);
3661 }
3662 }
3663
Surendar Karka91fa3682018-07-02 18:12:12 +05303664 if (out->realtime)
3665 platform_set_stream_channel_map(adev->platform, out->channel_mask,
3666 out->pcm_device_id, &out->channel_map_param.channel_map[0]);
3667
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003668 out->pcm = pcm_open_prepare_helper(adev->snd_card, out->pcm_device_id,
3669 flags, pcm_open_retry_count,
3670 &(out->config));
3671 if (out->pcm == NULL) {
3672 ret = -EIO;
3673 goto error_open;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003674 }
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003675
3676 if (is_haptic_usecase) {
3677 adev->haptic_pcm = pcm_open_prepare_helper(adev->snd_card,
3678 adev->haptic_pcm_device_id,
3679 flags, pcm_open_retry_count,
3680 &(adev->haptics_config));
3681 // failure to open haptics pcm shouldnt stop audio,
3682 // so do not close audio pcm in case of error
Vignesh Kulothungane4039c12019-05-07 15:51:39 -07003683
3684 if (property_get_bool("vendor.audio.enable_haptic_audio_sync", false)) {
3685 ALOGD("%s: enable haptic audio synchronization", __func__);
3686 platform_set_qtime(adev->platform, out->pcm_device_id, adev->haptic_pcm_device_id);
3687 }
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003688 }
3689
Surendar Karka91fa3682018-07-02 18:12:12 +05303690 if (!out->realtime)
3691 platform_set_stream_channel_map(adev->platform, out->channel_mask,
Surendar Karkaf51b5842018-04-26 11:28:38 +05303692 out->pcm_device_id, &out->channel_map_param.channel_map[0]);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07003693
Zhou Song2b8f28f2017-09-11 10:51:38 +08003694 // apply volume for voip playback after path is set up
3695 if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP)
3696 out_set_voip_volume(&out->stream, out->volume_l, out->volume_r);
Ramu Gottipati36547092018-12-28 11:32:09 +05303697 else if ((out->usecase == USECASE_AUDIO_PLAYBACK_LOW_LATENCY || out->usecase == USECASE_AUDIO_PLAYBACK_DEEP_BUFFER ||
3698 out->usecase == USECASE_AUDIO_PLAYBACK_ULL) && (out->apply_volume)) {
Ramu Gottipati97bdcfb2018-04-13 17:58:24 +05303699 out_set_pcm_volume(&out->stream, out->volume_l, out->volume_r);
3700 out->apply_volume = false;
Derek Chenf13dd492018-11-13 14:53:51 -08003701 } else if (audio_extn_auto_hal_is_bus_device_usecase(out->usecase)) {
3702 out_set_pcm_volume(&out->stream, out->volume_l, out->volume_r);
Ramu Gottipati97bdcfb2018-04-13 17:58:24 +05303703 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003704 } else {
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07003705 platform_set_stream_channel_map(adev->platform, out->channel_mask,
Naresh Tanniru29bce4e2017-04-27 17:54:30 +05303706 out->pcm_device_id, &out->channel_map_param.channel_map[0]);
Xiaojun Sang785b5da2017-08-03 15:52:29 +08003707 audio_enable_asm_bit_width_enforce_mode(adev->mixer,
3708 adev->dsp_bit_width_enforce_mode,
3709 true);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003710 out->pcm = NULL;
Haynes Mathew George380745d2017-10-04 15:27:45 -07003711 ATRACE_BEGIN("compress_open");
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -08003712 out->compr = compress_open(adev->snd_card,
3713 out->pcm_device_id,
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003714 COMPRESS_IN, &out->compr_config);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003715 ATRACE_END();
Satish Babu Patakokila54ce83d2018-07-06 18:00:37 +05303716 if (errno == ENETRESET && !is_compress_ready(out->compr)) {
Sharad Sanglec6f32552018-05-04 16:15:38 +05303717 ALOGE("%s: compress_open failed errno:%d\n", __func__, errno);
3718 adev->card_status = CARD_STATUS_OFFLINE;
3719 out->card_status = CARD_STATUS_OFFLINE;
3720 ret = -EIO;
3721 goto error_open;
3722 }
3723
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003724 if (out->compr && !is_compress_ready(out->compr)) {
Haynes Mathew Georgeee5836f2017-11-21 18:02:10 -08003725 ALOGE("%s: failed /w error %s", __func__, compress_get_error(out->compr));
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003726 compress_close(out->compr);
3727 out->compr = NULL;
3728 ret = -EIO;
3729 goto error_open;
3730 }
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05303731 /* compress_open sends params of the track, so reset the flag here */
3732 out->is_compr_metadata_avail = false;
3733
Ben Rombergerd771a7c2017-02-22 18:05:17 -08003734 if (out->client_callback)
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003735 compress_nonblock(out->compr, out->non_blocking);
Eric Laurentc4aef752013-09-12 17:45:53 -07003736
Fred Oh3f43e742015-03-04 18:42:34 -08003737 /* Since small bufs uses blocking writes, a write will be blocked
3738 for the default max poll time (20s) in the event of an SSR.
3739 Reduce the poll time to observe and deal with SSR faster.
3740 */
Ashish Jain5106d362016-05-11 19:23:33 +05303741 if (!out->non_blocking) {
Fred Oh3f43e742015-03-04 18:42:34 -08003742 compress_set_max_poll_wait(out->compr, 1000);
3743 }
3744
Manish Dewangan69426c82017-01-30 17:35:36 +05303745 audio_extn_utils_compress_set_render_mode(out);
Manish Dewangan58229382017-02-02 15:48:41 +05303746 audio_extn_utils_compress_set_clk_rec_mode(uc_info);
Manish Dewangan69426c82017-01-30 17:35:36 +05303747
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08003748 audio_extn_dts_create_state_notifier_node(out->usecase);
3749 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
3750 popcount(out->channel_mask),
3751 out->playback_started);
3752
Subhash Chandra Bose Naripeddy7690c562013-12-14 00:34:53 -08003753#ifdef DS1_DOLBY_DDP_ENABLED
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05303754 if (audio_extn_utils_is_dolby_format(out->format))
Subhash Chandra Bose Naripeddy7690c562013-12-14 00:34:53 -08003755 audio_extn_dolby_send_ddp_endp_params(adev);
3756#endif
Preetam Singh Ranawatd18d8832017-02-08 17:34:54 +05303757 if (!(audio_extn_passthru_is_passthrough_stream(out)) &&
3758 (out->sample_rate != 176400 && out->sample_rate <= 192000)) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003759 if (adev->visualizer_start_output != NULL)
3760 adev->visualizer_start_output(out->handle, out->pcm_device_id);
3761 if (adev->offload_effects_start_output != NULL)
Ashish Jain5106d362016-05-11 19:23:33 +05303762 adev->offload_effects_start_output(out->handle, out->pcm_device_id, adev->mixer);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08003763 audio_extn_check_and_set_dts_hpx_state(adev);
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003764 }
Derek Chenf13dd492018-11-13 14:53:51 -08003765
3766 if (out->devices & AUDIO_DEVICE_OUT_BUS) {
3767 /* Update cached volume from media to offload/direct stream */
3768 struct listnode *node = NULL;
3769 list_for_each(node, &adev->active_outputs_list) {
3770 streams_output_ctxt_t *out_ctxt = node_to_item(node,
3771 streams_output_ctxt_t,
3772 list);
3773 if (out_ctxt->output->usecase == USECASE_AUDIO_PLAYBACK_MEDIA) {
3774 out->volume_l = out_ctxt->output->volume_l;
3775 out->volume_r = out_ctxt->output->volume_r;
3776 }
3777 }
3778 out_set_compr_volume(&out->stream,
3779 out->volume_l, out->volume_r);
3780 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003781 }
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003782
3783 if (ret == 0) {
3784 register_out_stream(out);
3785 if (out->realtime) {
Aniket Kumar Lataf9f246e2017-09-15 15:20:16 -07003786 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
3787 ALOGE("%s: pcm stream not ready", __func__);
3788 goto error_open;
3789 }
Haynes Mathew George380745d2017-10-04 15:27:45 -07003790 ATRACE_BEGIN("pcm_start");
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003791 ret = pcm_start(out->pcm);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003792 ATRACE_END();
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003793 if (ret < 0)
3794 goto error_open;
3795 }
3796 }
Wei Wangf7ca6c92017-11-21 14:51:20 -08003797 audio_streaming_hint_end();
Sudheer Papothifa9d2282015-09-17 01:53:25 +05303798 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07003799 ALOGD("%s: exit", __func__);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07003800
vivek mehtad15d2bf2019-05-17 13:35:10 -07003801 if (out->usecase == USECASE_AUDIO_PLAYBACK_ULL ||
3802 out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
3803 audio_low_latency_hint_start();
3804 }
3805
Manish Dewangan21a850a2017-08-14 12:03:55 +05303806 if (out->ip_hdlr_handle) {
Vidyakumar Athota6d655882017-05-22 18:26:24 -07003807 ret = audio_extn_ip_hdlr_intf_open(out->ip_hdlr_handle, true, out, out->usecase);
Naresh Tanniru85819452017-05-04 18:55:45 -07003808 if (ret < 0)
3809 ALOGE("%s: audio_extn_ip_hdlr_intf_open failed %d",__func__, ret);
3810 }
3811
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07003812 // consider a scenario where on pause lower layers are tear down.
3813 // so on resume, swap mixer control need to be sent only when
3814 // backend is active, hence rather than sending from enable device
3815 // sending it from start of streamtream
3816
3817 platform_set_swap_channels(adev, true);
3818
Haynes Mathew George380745d2017-10-04 15:27:45 -07003819 ATRACE_END();
Vatsal Buchac09ae062018-11-14 13:25:08 +05303820 enable_gcov();
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003821 return ret;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003822error_open:
Vignesh Kulothungana6927272019-02-20 15:17:07 -08003823 if (adev->haptic_pcm) {
3824 pcm_close(adev->haptic_pcm);
3825 adev->haptic_pcm = NULL;
3826 }
Wei Wangf7ca6c92017-11-21 14:51:20 -08003827 audio_streaming_hint_end();
Sudheer Papothifa9d2282015-09-17 01:53:25 +05303828 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003829 stop_output_stream(out);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08003830error_config:
Laxminath Kasam2cb4b752015-09-24 03:59:15 +05303831 /*
3832 * sleep 50ms to allow sufficient time for kernel
3833 * drivers to recover incases like SSR.
3834 */
3835 usleep(50000);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003836 ATRACE_END();
Vatsal Buchac09ae062018-11-14 13:25:08 +05303837 enable_gcov();
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08003838 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003839}
3840
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003841static int check_input_parameters(uint32_t sample_rate,
3842 audio_format_t format,
Aalique Grahame22e49102018-12-18 14:23:57 -08003843 int channel_count,
3844 bool is_usb_hifi)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003845{
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003846 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003847
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05303848 if (((format != AUDIO_FORMAT_PCM_16_BIT) && (format != AUDIO_FORMAT_PCM_8_24_BIT) &&
3849 (format != AUDIO_FORMAT_PCM_24_BIT_PACKED) && (format != AUDIO_FORMAT_PCM_32_BIT) &&
3850 (format != AUDIO_FORMAT_PCM_FLOAT)) &&
Mingming Yine62d7842013-10-25 16:26:03 -07003851 !voice_extn_compress_voip_is_format_supported(format) &&
Ralf Herzaec80262018-07-03 07:08:49 +02003852 !audio_extn_compr_cap_format_supported(format) &&
3853 !audio_extn_cin_format_supported(format))
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003854 ret = -EINVAL;
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003855
Aalique Grahame22e49102018-12-18 14:23:57 -08003856 int max_channel_count = is_usb_hifi ? MAX_HIFI_CHANNEL_COUNT : MAX_CHANNEL_COUNT;
3857 if ((channel_count < MIN_CHANNEL_COUNT) || (channel_count > max_channel_count)) {
3858 ALOGE("%s: unsupported channel count (%d) passed Min / Max (%d / %d)", __func__,
3859 channel_count, MIN_CHANNEL_COUNT, max_channel_count);
3860 return -EINVAL;
3861 }
3862
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003863 switch (channel_count) {
3864 case 1:
3865 case 2:
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +05303866 case 3:
3867 case 4:
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003868 case 6:
Karthikeyan Mani07faa602018-08-20 11:01:32 -07003869 case 8:
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05303870 case 10:
3871 case 12:
3872 case 14:
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003873 break;
3874 default:
3875 ret = -EINVAL;
3876 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003877
3878 switch (sample_rate) {
3879 case 8000:
3880 case 11025:
3881 case 12000:
3882 case 16000:
3883 case 22050:
3884 case 24000:
3885 case 32000:
3886 case 44100:
3887 case 48000:
Haynes Mathew Georgec9253d12017-12-13 15:58:28 -08003888 case 88200:
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05303889 case 96000:
Haynes Mathew Georgec9253d12017-12-13 15:58:28 -08003890 case 176400:
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05303891 case 192000:
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003892 break;
3893 default:
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003894 ret = -EINVAL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003895 }
3896
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003897 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003898}
3899
Naresh Tanniru04f71882018-06-26 17:46:22 +05303900
3901/** Add a value in a list if not already present.
3902 * @return true if value was successfully inserted or already present,
3903 * false if the list is full and does not contain the value.
3904 */
3905static bool register_uint(uint32_t value, uint32_t* list, size_t list_length) {
3906 for (size_t i = 0; i < list_length; i++) {
3907 if (list[i] == value) return true; // value is already present
3908 if (list[i] == 0) { // no values in this slot
3909 list[i] = value;
3910 return true; // value inserted
3911 }
3912 }
3913 return false; // could not insert value
3914}
3915
3916/** Add channel_mask in supported_channel_masks if not already present.
3917 * @return true if channel_mask was successfully inserted or already present,
3918 * false if supported_channel_masks is full and does not contain channel_mask.
3919 */
3920static void register_channel_mask(audio_channel_mask_t channel_mask,
3921 audio_channel_mask_t supported_channel_masks[static MAX_SUPPORTED_CHANNEL_MASKS]) {
3922 ALOGE_IF(!register_uint(channel_mask, supported_channel_masks, MAX_SUPPORTED_CHANNEL_MASKS),
3923 "%s: stream can not declare supporting its channel_mask %x", __func__, channel_mask);
3924}
3925
3926/** Add format in supported_formats if not already present.
3927 * @return true if format was successfully inserted or already present,
3928 * false if supported_formats is full and does not contain format.
3929 */
3930static void register_format(audio_format_t format,
3931 audio_format_t supported_formats[static MAX_SUPPORTED_FORMATS]) {
3932 ALOGE_IF(!register_uint(format, supported_formats, MAX_SUPPORTED_FORMATS),
3933 "%s: stream can not declare supporting its format %x", __func__, format);
3934}
3935/** Add sample_rate in supported_sample_rates if not already present.
3936 * @return true if sample_rate was successfully inserted or already present,
3937 * false if supported_sample_rates is full and does not contain sample_rate.
3938 */
3939static void register_sample_rate(uint32_t sample_rate,
3940 uint32_t supported_sample_rates[static MAX_SUPPORTED_SAMPLE_RATES]) {
3941 ALOGE_IF(!register_uint(sample_rate, supported_sample_rates, MAX_SUPPORTED_SAMPLE_RATES),
3942 "%s: stream can not declare supporting its sample rate %x", __func__, sample_rate);
3943}
3944
Karthikeyan Manib38769c2018-11-07 15:44:13 -08003945static inline uint32_t lcm(uint32_t num1, uint32_t num2)
3946{
3947 uint32_t high = num1, low = num2, temp = 0;
3948
3949 if (!num1 || !num2)
3950 return 0;
3951
3952 if (num1 < num2) {
3953 high = num2;
3954 low = num1;
3955 }
3956
3957 while (low != 0) {
3958 temp = low;
3959 low = high % low;
3960 high = temp;
3961 }
3962 return (num1 * num2)/high;
3963}
3964
3965static inline uint32_t nearest_multiple(uint32_t num, uint32_t multiplier)
3966{
3967 uint32_t remainder = 0;
3968
3969 if (!multiplier)
3970 return num;
3971
3972 remainder = num % multiplier;
3973 if (remainder)
3974 num += (multiplier - remainder);
3975
3976 return num;
3977}
3978
Aalique Grahame22e49102018-12-18 14:23:57 -08003979static size_t get_stream_buffer_size(size_t duration_ms,
3980 uint32_t sample_rate,
3981 audio_format_t format,
3982 int channel_count,
3983 bool is_low_latency)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003984{
3985 size_t size = 0;
Karthikeyan Manib38769c2018-11-07 15:44:13 -08003986 uint32_t bytes_per_period_sample = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003987
Aalique Grahame22e49102018-12-18 14:23:57 -08003988 size = (sample_rate * duration_ms) / 1000;
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07003989 if (is_low_latency)
3990 size = configured_low_latency_capture_period_size;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05303991
Karthikeyan Manib38769c2018-11-07 15:44:13 -08003992 bytes_per_period_sample = audio_bytes_per_sample(format) * channel_count;
Aalique Grahame22e49102018-12-18 14:23:57 -08003993 size *= audio_bytes_per_sample(format) * channel_count;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003994
Ralf Herzbd08d632018-09-28 15:50:49 +02003995 /* make sure the size is multiple of 32 bytes and additionally multiple of
3996 * the frame_size (required for 24bit samples and non-power-of-2 channel counts)
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07003997 * At 48 kHz mono 16-bit PCM:
3998 * 5.000 ms = 240 frames = 15*16*1*2 = 480, a whole multiple of 32 (15)
3999 * 3.333 ms = 160 frames = 10*16*1*2 = 320, a whole multiple of 32 (10)
Karthikeyan Manib38769c2018-11-07 15:44:13 -08004000 * Also, make sure the size is multiple of bytes per period sample
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07004001 */
Karthikeyan Manib38769c2018-11-07 15:44:13 -08004002 size = nearest_multiple(size, lcm(32, bytes_per_period_sample));
Ravi Kumar Alamanda33d33062013-06-11 14:40:01 -07004003
4004 return size;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004005}
4006
Aalique Grahame22e49102018-12-18 14:23:57 -08004007static size_t get_input_buffer_size(uint32_t sample_rate,
4008 audio_format_t format,
4009 int channel_count,
4010 bool is_low_latency)
4011{
4012 /* Don't know if USB HIFI in this context so use true to be conservative */
4013 if (check_input_parameters(sample_rate, format, channel_count,
4014 true /*is_usb_hifi */) != 0)
4015 return 0;
4016
4017 return get_stream_buffer_size(AUDIO_CAPTURE_PERIOD_DURATION_MSEC,
4018 sample_rate,
4019 format,
4020 channel_count,
4021 is_low_latency);
4022}
4023
Derek Chenf6318be2017-06-12 17:16:24 -04004024size_t get_output_period_size(uint32_t sample_rate,
4025 audio_format_t format,
4026 int channel_count,
4027 int duration /*in millisecs*/)
Ashish Jain058165c2016-09-28 23:18:48 +05304028{
4029 size_t size = 0;
4030 uint32_t bytes_per_sample = audio_bytes_per_sample(format);
4031
4032 if ((duration == 0) || (sample_rate == 0) ||
4033 (bytes_per_sample == 0) || (channel_count == 0)) {
4034 ALOGW("Invalid config duration %d sr %d bps %d ch %d", duration, sample_rate,
4035 bytes_per_sample, channel_count);
4036 return -EINVAL;
4037 }
4038
4039 size = (sample_rate *
4040 duration *
4041 bytes_per_sample *
4042 channel_count) / 1000;
4043 /*
4044 * To have same PCM samples for all channels, the buffer size requires to
4045 * be multiple of (number of channels * bytes per sample)
4046 * For writes to succeed, the buffer must be written at address which is multiple of 32
4047 */
4048 size = ALIGN(size, (bytes_per_sample * channel_count * 32));
4049
4050 return (size/(channel_count * bytes_per_sample));
4051}
4052
Zhou Song48453a02018-01-10 17:50:59 +08004053static uint64_t get_actual_pcm_frames_rendered(struct stream_out *out, struct timespec *timestamp)
Ashish Jain5106d362016-05-11 19:23:33 +05304054{
4055 uint64_t actual_frames_rendered = 0;
4056 size_t kernel_buffer_size = out->compr_config.fragment_size * out->compr_config.fragments;
4057
4058 /* This adjustment accounts for buffering after app processor.
4059 * It is based on estimated DSP latency per use case, rather than exact.
4060 */
4061 int64_t platform_latency = platform_render_latency(out->usecase) *
4062 out->sample_rate / 1000000LL;
4063
Zhou Song48453a02018-01-10 17:50:59 +08004064 pthread_mutex_lock(&out->position_query_lock);
Ashish Jain5106d362016-05-11 19:23:33 +05304065 /* not querying actual state of buffering in kernel as it would involve an ioctl call
4066 * which then needs protection, this causes delay in TS query for pcm_offload usecase
4067 * hence only estimate.
4068 */
4069 int64_t signed_frames = out->written - kernel_buffer_size;
4070
4071 signed_frames = signed_frames / (audio_bytes_per_sample(out->format) * popcount(out->channel_mask)) - platform_latency;
4072
Zhou Song48453a02018-01-10 17:50:59 +08004073 if (signed_frames > 0) {
Ashish Jain5106d362016-05-11 19:23:33 +05304074 actual_frames_rendered = signed_frames;
Zhou Song48453a02018-01-10 17:50:59 +08004075 if (timestamp != NULL )
4076 *timestamp = out->writeAt;
4077 } else if (timestamp != NULL) {
4078 clock_gettime(CLOCK_MONOTONIC, timestamp);
4079 }
4080 pthread_mutex_unlock(&out->position_query_lock);
Ashish Jain5106d362016-05-11 19:23:33 +05304081
4082 ALOGVV("%s signed frames %lld out_written %lld kernel_buffer_size %d"
4083 "bytes/sample %zu channel count %d", __func__,(long long int)signed_frames,
4084 (long long int)out->written, (int)kernel_buffer_size,
4085 audio_bytes_per_sample(out->compr_config.codec->format),
4086 popcount(out->channel_mask));
4087
4088 return actual_frames_rendered;
4089}
4090
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004091static uint32_t out_get_sample_rate(const struct audio_stream *stream)
4092{
4093 struct stream_out *out = (struct stream_out *)stream;
4094
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004095 return out->sample_rate;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004096}
4097
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07004098static int out_set_sample_rate(struct audio_stream *stream __unused,
4099 uint32_t rate __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004100{
4101 return -ENOSYS;
4102}
4103
4104static size_t out_get_buffer_size(const struct audio_stream *stream)
4105{
4106 struct stream_out *out = (struct stream_out *)stream;
4107
Varun Balaraje49253e2017-07-06 19:48:56 +05304108 if (is_interactive_usecase(out->usecase)) {
Sri Karri27279e12017-08-07 16:05:20 +05304109 return out->config.period_size * out->config.period_count;
Varun Balaraje49253e2017-07-06 19:48:56 +05304110 } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Naresh Tanniruee3499a2017-01-05 14:05:35 +05304111 if (out->flags & AUDIO_OUTPUT_FLAG_TIMESTAMP)
4112 return out->compr_config.fragment_size - sizeof(struct snd_codec_metadata);
4113 else
4114 return out->compr_config.fragment_size;
4115 } else if(out->usecase == USECASE_COMPRESS_VOIP_CALL)
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08004116 return voice_extn_compress_voip_out_get_buffer_size(out);
Dhananjay Kumarac341582017-02-23 23:42:25 +05304117 else if (is_offload_usecase(out->usecase) &&
4118 out->flags == AUDIO_OUTPUT_FLAG_DIRECT)
Ashish Jain83a6cc22016-06-28 14:34:17 +05304119 return out->hal_fragment_size;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004120
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004121 return out->config.period_size * out->af_period_multiplier *
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07004122 audio_stream_out_frame_size((const struct audio_stream_out *)stream);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004123}
4124
4125static uint32_t out_get_channels(const struct audio_stream *stream)
4126{
4127 struct stream_out *out = (struct stream_out *)stream;
4128
4129 return out->channel_mask;
4130}
4131
4132static audio_format_t out_get_format(const struct audio_stream *stream)
4133{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004134 struct stream_out *out = (struct stream_out *)stream;
4135
4136 return out->format;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004137}
4138
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07004139static int out_set_format(struct audio_stream *stream __unused,
4140 audio_format_t format __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004141{
4142 return -ENOSYS;
4143}
4144
4145static int out_standby(struct audio_stream *stream)
4146{
4147 struct stream_out *out = (struct stream_out *)stream;
4148 struct audio_device *adev = out->dev;
Haynes Mathew George16081042017-05-31 17:16:49 -07004149 bool do_stop = true;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004150
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05304151 ALOGD("%s: enter: stream (%p) usecase(%d: %s)", __func__,
4152 stream, out->usecase, use_case_table[out->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004153
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004154 lock_output_stream(out);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004155 if (!out->standby) {
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07004156 if (adev->adm_deregister_stream)
4157 adev->adm_deregister_stream(adev->adm_data, out->handle);
4158
Haynes Mathew George7fce0a52016-06-23 18:22:27 -07004159 if (is_offload_usecase(out->usecase))
4160 stop_compressed_output_l(out);
4161
Ravi Kumar Alamanda8bba9e92013-11-11 21:09:07 -08004162 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004163 out->standby = true;
Zhou Songa8895042016-07-05 17:54:22 +08004164 if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
4165 voice_extn_compress_voip_close_output_stream(stream);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05304166 out->started = 0;
Zhou Songa8895042016-07-05 17:54:22 +08004167 pthread_mutex_unlock(&adev->lock);
4168 pthread_mutex_unlock(&out->lock);
4169 ALOGD("VOIP output entered standby");
4170 return 0;
4171 } else if (!is_offload_usecase(out->usecase)) {
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004172 if (out->pcm) {
4173 pcm_close(out->pcm);
4174 out->pcm = NULL;
4175 }
Haynes Mathew George16081042017-05-31 17:16:49 -07004176 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
4177 do_stop = out->playback_started;
4178 out->playback_started = false;
4179 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004180 } else {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07004181 ALOGD("copl(%p):standby", out);
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05304182 out->send_next_track_params = false;
4183 out->is_compr_metadata_avail = false;
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004184 out->gapless_mdata.encoder_delay = 0;
4185 out->gapless_mdata.encoder_padding = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004186 if (out->compr != NULL) {
4187 compress_close(out->compr);
4188 out->compr = NULL;
4189 }
Eric Laurent150dbfe2013-02-27 14:31:02 -08004190 }
Haynes Mathew George16081042017-05-31 17:16:49 -07004191 if (do_stop) {
4192 stop_output_stream(out);
4193 }
Eric Laurent150dbfe2013-02-27 14:31:02 -08004194 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004195 }
4196 pthread_mutex_unlock(&out->lock);
Ashish Jainbbce4322016-02-16 13:25:27 +05304197 ALOGD("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004198 return 0;
4199}
4200
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304201static int out_on_error(struct audio_stream *stream)
4202{
4203 struct stream_out *out = (struct stream_out *)stream;
Ben Rombergerfd02a2f2018-09-17 10:23:23 -07004204 int status = 0;
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304205
4206 lock_output_stream(out);
Haynes Mathew Georgeee5836f2017-11-21 18:02:10 -08004207 // always send CMD_ERROR for offload streams, this
4208 // is needed e.g. when SSR happens within compress_open
4209 // since the stream is active, offload_callback_thread is also active.
4210 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
4211 stop_compressed_output_l(out);
Ben Rombergerfd02a2f2018-09-17 10:23:23 -07004212 }
4213 pthread_mutex_unlock(&out->lock);
4214
4215 status = out_standby(&out->stream.common);
4216
4217 lock_output_stream(out);
4218 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Haynes Mathew Georgeee5836f2017-11-21 18:02:10 -08004219 send_offload_cmd_l(out, OFFLOAD_CMD_ERROR);
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304220 }
Manisha Agarwal7b3e3772019-02-20 14:33:45 +05304221
4222 if (is_offload_usecase(out->usecase) && out->card_status == CARD_STATUS_OFFLINE) {
4223 ALOGD("Setting previous card status if offline");
4224 out->prev_card_status_offline = true;
4225 }
4226
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304227 pthread_mutex_unlock(&out->lock);
4228
Ben Rombergerfd02a2f2018-09-17 10:23:23 -07004229 return status;
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304230}
4231
Ashish Jain1b9b30c2017-05-18 20:57:40 +05304232/*
4233 *standby implementation without locks, assumes that the callee already
4234 *has taken adev and out lock.
4235 */
4236int out_standby_l(struct audio_stream *stream)
4237{
4238 struct stream_out *out = (struct stream_out *)stream;
4239 struct audio_device *adev = out->dev;
4240
4241 ALOGD("%s: enter: stream (%p) usecase(%d: %s)", __func__,
4242 stream, out->usecase, use_case_table[out->usecase]);
4243
4244 if (!out->standby) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07004245 ATRACE_BEGIN("out_standby_l");
Ashish Jain1b9b30c2017-05-18 20:57:40 +05304246 if (adev->adm_deregister_stream)
4247 adev->adm_deregister_stream(adev->adm_data, out->handle);
4248
4249 if (is_offload_usecase(out->usecase))
4250 stop_compressed_output_l(out);
4251
4252 out->standby = true;
4253 if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
4254 voice_extn_compress_voip_close_output_stream(stream);
4255 out->started = 0;
4256 ALOGD("VOIP output entered standby");
Haynes Mathew George380745d2017-10-04 15:27:45 -07004257 ATRACE_END();
Ashish Jain1b9b30c2017-05-18 20:57:40 +05304258 return 0;
4259 } else if (!is_offload_usecase(out->usecase)) {
4260 if (out->pcm) {
4261 pcm_close(out->pcm);
4262 out->pcm = NULL;
4263 }
Vignesh Kulothungana6927272019-02-20 15:17:07 -08004264 if (out->usecase == USECASE_AUDIO_PLAYBACK_WITH_HAPTICS) {
4265 if (adev->haptic_pcm) {
4266 pcm_close(adev->haptic_pcm);
4267 adev->haptic_pcm = NULL;
4268 }
4269
4270 if (adev->haptic_buffer != NULL) {
4271 free(adev->haptic_buffer);
4272 adev->haptic_buffer = NULL;
4273 adev->haptic_buffer_size = 0;
4274 }
4275 adev->haptic_pcm_device_id = 0;
4276 }
Ashish Jain1b9b30c2017-05-18 20:57:40 +05304277 } else {
4278 ALOGD("copl(%p):standby", out);
4279 out->send_next_track_params = false;
4280 out->is_compr_metadata_avail = false;
4281 out->gapless_mdata.encoder_delay = 0;
4282 out->gapless_mdata.encoder_padding = 0;
4283 if (out->compr != NULL) {
4284 compress_close(out->compr);
4285 out->compr = NULL;
4286 }
4287 }
4288 stop_output_stream(out);
Haynes Mathew George380745d2017-10-04 15:27:45 -07004289 ATRACE_END();
Ashish Jain1b9b30c2017-05-18 20:57:40 +05304290 }
4291 ALOGD("%s: exit", __func__);
4292 return 0;
4293}
4294
Aalique Grahame22e49102018-12-18 14:23:57 -08004295static int out_dump(const struct audio_stream *stream, int fd)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004296{
Aalique Grahame22e49102018-12-18 14:23:57 -08004297 struct stream_out *out = (struct stream_out *)stream;
4298
4299 // We try to get the lock for consistency,
4300 // but it isn't necessary for these variables.
4301 // If we're not in standby, we may be blocked on a write.
4302 const bool locked = (pthread_mutex_trylock(&out->lock) == 0);
4303 dprintf(fd, " Standby: %s\n", out->standby ? "yes" : "no");
4304 dprintf(fd, " Frames written: %lld\n", (long long)out->written);
4305
4306 if (locked) {
4307 pthread_mutex_unlock(&out->lock);
4308 }
4309
4310 // dump error info
4311 (void)error_log_dump(
4312 out->error_log, fd, " " /* prefix */, 0 /* lines */, 0 /* limit_ns */);
4313
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004314 return 0;
4315}
4316
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004317static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
4318{
4319 int ret = 0;
4320 char value[32];
ApurupaPattapu2e084df2013-12-18 15:47:59 -08004321
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004322 if (!out || !parms) {
Krishnankutty Kolathappillyeb78be72013-12-15 12:03:07 -08004323 ALOGE("%s: return invalid ",__func__);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004324 return -EINVAL;
4325 }
4326
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +05304327 ret = audio_extn_parse_compress_metadata(out, parms);
Weiyin Jiang18ac4e92015-03-15 15:03:40 +08004328
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004329 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES, value, sizeof(value));
4330 if (ret >= 0) {
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +05304331 out->gapless_mdata.encoder_delay = atoi(value); //whats a good limit check?
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004332 }
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004333 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES, value, sizeof(value));
4334 if (ret >= 0) {
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +05304335 out->gapless_mdata.encoder_padding = atoi(value);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004336 }
4337
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004338 ALOGV("%s new encoder delay %u and padding %u", __func__,
4339 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
4340
4341 return 0;
4342}
4343
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07004344static bool output_drives_call(struct audio_device *adev, struct stream_out *out)
4345{
4346 return out == adev->primary_output || out == adev->voice_tx_output;
4347}
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004348
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304349// note: this call is safe only if the stream_cb is
4350// removed first in close_output_stream (as is done now).
4351static void out_snd_mon_cb(void * stream, struct str_parms * parms)
4352{
4353 if (!stream || !parms)
4354 return;
4355
4356 struct stream_out *out = (struct stream_out *)stream;
4357 struct audio_device *adev = out->dev;
4358
4359 card_status_t status;
4360 int card;
4361 if (parse_snd_card_status(parms, &card, &status) < 0)
4362 return;
4363
4364 pthread_mutex_lock(&adev->lock);
4365 bool valid_cb = (card == adev->snd_card);
4366 pthread_mutex_unlock(&adev->lock);
4367
4368 if (!valid_cb)
4369 return;
4370
4371 lock_output_stream(out);
4372 if (out->card_status != status)
4373 out->card_status = status;
4374 pthread_mutex_unlock(&out->lock);
4375
4376 ALOGI("out_snd_mon_cb for card %d usecase %s, status %s", card,
4377 use_case_table[out->usecase],
4378 status == CARD_STATUS_OFFLINE ? "offline" : "online");
4379
Aditya Bavanari59ebed42019-02-05 17:44:57 +05304380 if (status == CARD_STATUS_OFFLINE) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304381 out_on_error(stream);
Aditya Bavanari59ebed42019-02-05 17:44:57 +05304382 if (voice_is_call_state_active(adev) &&
4383 out == adev->primary_output) {
4384 ALOGD("%s: SSR/PDR occurred, end all calls\n", __func__);
4385 pthread_mutex_lock(&adev->lock);
4386 voice_stop_call(adev);
4387 adev->mode = AUDIO_MODE_NORMAL;
4388 pthread_mutex_unlock(&adev->lock);
4389 }
4390 }
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304391 return;
4392}
4393
Kevin Rocardfce19002017-08-07 19:21:36 -07004394static int get_alive_usb_card(struct str_parms* parms) {
4395 int card;
4396 if ((str_parms_get_int(parms, "card", &card) >= 0) &&
4397 !audio_extn_usb_alive(card)) {
4398 return card;
4399 }
4400 return -ENODEV;
4401}
4402
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004403static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
4404{
4405 struct stream_out *out = (struct stream_out *)stream;
4406 struct audio_device *adev = out->dev;
4407 struct str_parms *parms;
4408 char value[32];
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08004409 int ret = 0, val = 0, err;
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304410 bool bypass_a2dp = false;
Garmond Leung5fd0b552018-04-17 11:56:12 -07004411 bool reconfig = false;
4412 unsigned long service_interval = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004413
sangwoobc677242013-08-08 16:53:43 +09004414 ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s",
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07004415 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004416 parms = str_parms_create_str(kvpairs);
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05304417 if (!parms)
4418 goto error;
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08004419 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
4420 if (err >= 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004421 val = atoi(value);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004422 lock_output_stream(out);
Eric Laurent150dbfe2013-02-27 14:31:02 -08004423 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004424
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07004425 /*
Weiyin Jiang4256eeb2016-05-19 13:28:30 +08004426 * When HDMI cable is unplugged the music playback is paused and
4427 * the policy manager sends routing=0. But the audioflinger continues
4428 * to write data until standby time (3sec). As the HDMI core is
4429 * turned off, the write gets blocked.
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07004430 * Avoid this by routing audio to speaker until standby.
4431 */
Weiyin Jiang4256eeb2016-05-19 13:28:30 +08004432 if ((out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL) &&
4433 (val == AUDIO_DEVICE_NONE) &&
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05304434 !audio_extn_passthru_is_passthrough_stream(out) &&
Weiyin Jiang4256eeb2016-05-19 13:28:30 +08004435 (platform_get_edid_info(adev->platform) != 0) /* HDMI disconnected */) {
4436 val = AUDIO_DEVICE_OUT_SPEAKER;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07004437 }
Naresh Tanniru9d027a62015-03-13 01:32:10 +05304438 /*
4439 * When A2DP is disconnected the
4440 * music playback is paused and the policy manager sends routing=0
Florian Pfister1a84f312018-07-19 14:38:18 +02004441 * But the audioflinger continues to write data until standby time
Naresh Tanniru9d027a62015-03-13 01:32:10 +05304442 * (3sec). As BT is turned off, the write gets blocked.
4443 * Avoid this by routing audio to speaker until standby.
4444 */
Naresh Tanniruf7e9e632016-11-04 14:54:20 -07004445 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
Aniket Kumar Lata1fb11cb2017-09-08 13:48:55 -07004446 (val == AUDIO_DEVICE_NONE) &&
Aniket Kumar Lata2cf6a922019-05-07 17:01:43 -07004447 !audio_extn_a2dp_source_is_ready() &&
4448 !adev->bt_sco_on) {
Naresh Tanniru9d027a62015-03-13 01:32:10 +05304449 val = AUDIO_DEVICE_OUT_SPEAKER;
4450 }
Sharad Sangled0a50b22018-04-05 23:28:32 +05304451 /*
4452 * When USB headset is disconnected the music platback paused
4453 * and the policy manager send routing=0. But if the USB is connected
4454 * back before the standby time, AFE is not closed and opened
4455 * when USB is connected back. So routing to speker will guarantee
4456 * AFE reconfiguration and AFE will be opend once USB is connected again
4457 */
4458 if ((out->devices & AUDIO_DEVICE_OUT_ALL_USB) &&
4459 (val == AUDIO_DEVICE_NONE) &&
4460 !audio_extn_usb_connected(parms)) {
4461 val = AUDIO_DEVICE_OUT_SPEAKER;
4462 }
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05304463 /* To avoid a2dp to sco overlapping / BT device improper state
4464 * check with BT lib about a2dp streaming support before routing
Naresh Tanniru03f9dd52016-10-19 18:46:22 +05304465 */
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05304466 if (val & AUDIO_DEVICE_OUT_ALL_A2DP) {
Florian Pfister1a84f312018-07-19 14:38:18 +02004467 if (!audio_extn_a2dp_source_is_ready()) {
Aalique Grahame22e49102018-12-18 14:23:57 -08004468 if (val &
4469 (AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_OUT_SPEAKER_SAFE)) {
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05304470 //combo usecase just by pass a2dp
4471 ALOGW("%s: A2DP profile is not ready,routing to speaker only", __func__);
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304472 bypass_a2dp = true;
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05304473 } else {
4474 ALOGE("%s: A2DP profile is not ready,ignoring routing request", __func__);
4475 /* update device to a2dp and don't route as BT returned error
4476 * However it is still possible a2dp routing called because
4477 * of current active device disconnection (like wired headset)
4478 */
4479 out->devices = val;
4480 pthread_mutex_unlock(&out->lock);
4481 pthread_mutex_unlock(&adev->lock);
4482 goto error;
4483 }
4484 }
Naresh Tanniru03f9dd52016-10-19 18:46:22 +05304485 }
Kevin Rocardfce19002017-08-07 19:21:36 -07004486
4487 audio_devices_t new_dev = val;
4488
4489 // Workaround: If routing to an non existing usb device, fail gracefully
4490 // The routing request will otherwise block during 10 second
4491 int card;
4492 if (audio_is_usb_out_device(new_dev) &&
4493 (card = get_alive_usb_card(parms)) >= 0) {
4494
4495 ALOGW("out_set_parameters() ignoring rerouting to non existing USB card %d", card);
4496 pthread_mutex_unlock(&adev->lock);
4497 pthread_mutex_unlock(&out->lock);
4498 ret = -ENOSYS;
4499 goto routing_fail;
4500 }
4501
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07004502 /*
4503 * select_devices() call below switches all the usecases on the same
4504 * backend to the new device. Refer to check_usecases_codec_backend() in
4505 * the select_devices(). But how do we undo this?
4506 *
4507 * For example, music playback is active on headset (deep-buffer usecase)
4508 * and if we go to ringtones and select a ringtone, low-latency usecase
4509 * will be started on headset+speaker. As we can't enable headset+speaker
4510 * and headset devices at the same time, select_devices() switches the music
4511 * playback to headset+speaker while starting low-lateny usecase for ringtone.
4512 * So when the ringtone playback is completed, how do we undo the same?
4513 *
4514 * We are relying on the out_set_parameters() call on deep-buffer output,
4515 * once the ringtone playback is ended.
4516 * NOTE: We should not check if the current devices are same as new devices.
4517 * Because select_devices() must be called to switch back the music
4518 * playback to headset.
4519 */
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08004520 if (val != 0) {
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004521 audio_devices_t new_dev = val;
4522 bool same_dev = out->devices == new_dev;
4523 out->devices = new_dev;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07004524
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -07004525 if (output_drives_call(adev, out)) {
kunleiz61b9c2e2017-11-01 13:47:23 +08004526 if (!voice_is_call_state_active(adev)) {
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -07004527 if (adev->mode == AUDIO_MODE_IN_CALL) {
4528 adev->current_call_output = out;
Garmond Leung5fd0b552018-04-17 11:56:12 -07004529 if (audio_is_usb_out_device(out->devices & AUDIO_DEVICE_OUT_ALL_USB)) {
4530 service_interval = audio_extn_usb_find_service_interval(true, true /*playback*/);
4531 audio_extn_usb_set_service_interval(true /*playback*/,
4532 service_interval,
4533 &reconfig);
4534 ALOGD("%s, svc_int(%ld),reconfig(%d)",__func__,service_interval, reconfig);
4535 }
4536 ret = voice_start_call(adev);
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -07004537 }
4538 } else {
4539 adev->current_call_output = out;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07004540 voice_update_devices_for_all_voice_usecases(adev);
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -07004541 }
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08004542 }
Shiv Maliyappanahalli6b32c4c2015-11-04 18:10:20 -08004543
4544 if (!out->standby) {
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004545 if (!same_dev) {
4546 ALOGV("update routing change");
Sudheer Papothi80266982016-08-16 02:36:18 +05304547 audio_extn_perf_lock_acquire(&adev->perf_lock_handle, 0,
4548 adev->perf_lock_opts,
4549 adev->perf_lock_opts_size);
Haynes Mathew George822b5492016-07-01 16:57:24 -07004550 if (adev->adm_on_routing_change)
4551 adev->adm_on_routing_change(adev->adm_data,
4552 out->handle);
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004553 }
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304554 if (!bypass_a2dp) {
4555 select_devices(adev, out->usecase);
4556 } else {
Aalique Grahame22e49102018-12-18 14:23:57 -08004557 if (new_dev & AUDIO_DEVICE_OUT_SPEAKER_SAFE)
4558 out->devices = AUDIO_DEVICE_OUT_SPEAKER_SAFE;
4559 else
4560 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304561 select_devices(adev, out->usecase);
4562 out->devices = new_dev;
4563 }
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07004564
4565 if (!same_dev) {
4566 // on device switch force swap, lower functions will make sure
4567 // to check if swap is allowed or not.
4568 platform_set_swap_channels(adev, true);
Sudheer Papothi80266982016-08-16 02:36:18 +05304569 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07004570 }
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304571 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
4572 out->a2dp_compress_mute &&
Florian Pfister1a84f312018-07-19 14:38:18 +02004573 (!(out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) || audio_extn_a2dp_source_is_ready())) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304574 pthread_mutex_lock(&out->compr_mute_lock);
4575 out->a2dp_compress_mute = false;
4576 out_set_compr_volume(&out->stream, out->volume_l, out->volume_r);
4577 pthread_mutex_unlock(&out->compr_mute_lock);
kunleizba786432018-01-26 15:31:59 +08004578 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP) {
4579 out_set_voip_volume(&out->stream, out->volume_l, out->volume_r);
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304580 }
Shiv Maliyappanahalli6b32c4c2015-11-04 18:10:20 -08004581 }
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08004582 }
4583
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004584 pthread_mutex_unlock(&adev->lock);
Eric Laurent150dbfe2013-02-27 14:31:02 -08004585 pthread_mutex_unlock(&out->lock);
Aalique Grahame22e49102018-12-18 14:23:57 -08004586
4587 /*handles device and call state changes*/
4588 audio_extn_extspk_update(adev->extspk);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004589 }
Kevin Rocardfce19002017-08-07 19:21:36 -07004590 routing_fail:
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07004591
4592 if (out == adev->primary_output) {
4593 pthread_mutex_lock(&adev->lock);
4594 audio_extn_set_parameters(adev, parms);
4595 pthread_mutex_unlock(&adev->lock);
4596 }
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07004597 if (is_offload_usecase(out->usecase)) {
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004598 lock_output_stream(out);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004599 parse_compress_metadata(out, parms);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08004600
4601 audio_extn_dts_create_state_notifier_node(out->usecase);
4602 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
4603 popcount(out->channel_mask),
4604 out->playback_started);
4605
Krishnankutty Kolathappillyeb78be72013-12-15 12:03:07 -08004606 pthread_mutex_unlock(&out->lock);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004607 }
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07004608
Surendar Karkaf51b5842018-04-26 11:28:38 +05304609 err = str_parms_get_str(parms, AUDIO_PARAMETER_DUAL_MONO, value,
4610 sizeof(value));
4611 if (err >= 0) {
4612 if (!strncmp("true", value, sizeof("true")) || atoi(value))
4613 audio_extn_send_dual_mono_mixing_coefficients(out);
4614 }
4615
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05304616 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_PROFILE, value, sizeof(value));
4617 if (err >= 0) {
4618 strlcpy(out->profile, value, sizeof(out->profile));
4619 ALOGV("updating stream profile with value '%s'", out->profile);
4620 lock_output_stream(out);
4621 audio_extn_utils_update_stream_output_app_type_cfg(adev->platform,
4622 &adev->streams_output_cfg_list,
Aalique Grahame65780b52017-09-27 14:59:56 -07004623 out->devices, out->flags, out->hal_op_format,
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05304624 out->sample_rate, out->bit_width,
4625 out->channel_mask, out->profile,
4626 &out->app_type_cfg);
4627 pthread_mutex_unlock(&out->lock);
4628 }
4629
Alexy Joseph98988832017-01-13 14:56:59 -08004630 //suspend, resume handling block
Aniket Kumar Lata932f4872017-11-06 18:29:44 -08004631 //remove QOS only if vendor.audio.hal.dynamic.qos.config.supported is set to true
4632 // and vendor.audio.hal.output.suspend.supported is set to true
4633 if (out->hal_output_suspend_supported && out->dynamic_pm_qos_config_supported) {
Alexy Joseph98988832017-01-13 14:56:59 -08004634 //check suspend parameter only for low latency and if the property
4635 //is enabled
4636 if (str_parms_get_str(parms, "suspend_playback", value, sizeof(value)) >= 0) {
4637 ALOGI("%s: got suspend_playback %s", __func__, value);
4638 lock_output_stream(out);
4639 if (!strncmp(value, "false", 5)) {
4640 //suspend_playback=false is supposed to set QOS value back to 75%
4641 //the mixer control sent with value Enable will achieve that
4642 ret = audio_route_apply_and_update_path(adev->audio_route, out->pm_qos_mixer_path);
4643 } else if (!strncmp (value, "true", 4)) {
4644 //suspend_playback=true is supposed to remove QOS value
4645 //resetting the mixer control will set the default value
4646 //for the mixer control which is Disable and this removes the QOS vote
4647 ret = audio_route_reset_and_update_path(adev->audio_route, out->pm_qos_mixer_path);
4648 } else {
4649 ALOGE("%s: Wrong value sent for suspend_playback, expected true/false,"
4650 " got %s", __func__, value);
4651 ret = -1;
4652 }
4653
4654 if (ret != 0) {
4655 ALOGE("%s: %s mixer ctl failed with %d, ignore suspend/resume setparams",
4656 __func__, out->pm_qos_mixer_path, ret);
4657 }
4658
4659 pthread_mutex_unlock(&out->lock);
4660 }
4661 }
4662 //end suspend, resume handling block
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004663 str_parms_destroy(parms);
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05304664error:
Eric Laurent994a6932013-07-17 11:51:42 -07004665 ALOGV("%s: exit: code(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004666 return ret;
4667}
4668
Paul McLeana50b7332018-12-17 08:24:21 -07004669static int in_set_microphone_direction(const struct audio_stream_in *stream,
4670 audio_microphone_direction_t dir) {
justinweng20fb6d82019-02-21 18:49:00 -07004671 struct stream_in *in = (struct stream_in *)stream;
4672
4673 ALOGVV("%s: standby %d source %d dir %d", __func__, in->standby, in->source, dir);
4674
4675 in->direction = dir;
4676
4677 if (in->standby)
4678 return 0;
4679
4680 return audio_extn_audiozoom_set_microphone_direction(in, dir);
Paul McLeana50b7332018-12-17 08:24:21 -07004681}
4682
4683static int in_set_microphone_field_dimension(const struct audio_stream_in *stream, float zoom) {
justinweng20fb6d82019-02-21 18:49:00 -07004684 struct stream_in *in = (struct stream_in *)stream;
4685
4686 ALOGVV("%s: standby %d source %d zoom %f", __func__, in->standby, in->source, zoom);
4687
4688 if (zoom > 1.0 || zoom < -1.0)
4689 return -EINVAL;
4690
4691 in->zoom = zoom;
4692
4693 if (in->standby)
4694 return 0;
4695
4696 return audio_extn_audiozoom_set_microphone_field_dimension(in, zoom);
Paul McLeana50b7332018-12-17 08:24:21 -07004697}
4698
4699
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004700static bool stream_get_parameter_channels(struct str_parms *query,
4701 struct str_parms *reply,
4702 audio_channel_mask_t *supported_channel_masks) {
4703 int ret = -1;
4704 char value[512];
4705 bool first = true;
4706 size_t i, j;
4707
4708 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS)) {
4709 ret = 0;
4710 value[0] = '\0';
4711 i = 0;
4712 while (supported_channel_masks[i] != 0) {
4713 for (j = 0; j < ARRAY_SIZE(channels_name_to_enum_table); j++) {
4714 if (channels_name_to_enum_table[j].value == supported_channel_masks[i]) {
4715 if (!first)
Satya Krishna Pindiprolib22ac722017-10-09 15:44:16 +05304716 strlcat(value, "|", sizeof(value));
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004717
Satya Krishna Pindiprolib22ac722017-10-09 15:44:16 +05304718 strlcat(value, channels_name_to_enum_table[j].name, sizeof(value));
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004719 first = false;
4720 break;
4721 }
4722 }
4723 i++;
4724 }
4725 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
4726 }
4727 return ret == 0;
4728}
4729
4730static bool stream_get_parameter_formats(struct str_parms *query,
4731 struct str_parms *reply,
4732 audio_format_t *supported_formats) {
4733 int ret = -1;
4734 char value[256];
4735 size_t i, j;
4736 bool first = true;
4737
4738 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS)) {
4739 ret = 0;
4740 value[0] = '\0';
4741 i = 0;
4742 while (supported_formats[i] != 0) {
4743 for (j = 0; j < ARRAY_SIZE(formats_name_to_enum_table); j++) {
4744 if (formats_name_to_enum_table[j].value == supported_formats[i]) {
4745 if (!first) {
Satya Krishna Pindiprolib22ac722017-10-09 15:44:16 +05304746 strlcat(value, "|", sizeof(value));
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004747 }
Satya Krishna Pindiprolib22ac722017-10-09 15:44:16 +05304748 strlcat(value, formats_name_to_enum_table[j].name, sizeof(value));
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004749 first = false;
4750 break;
4751 }
4752 }
4753 i++;
4754 }
4755 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_FORMATS, value);
4756 }
4757 return ret == 0;
4758}
4759
4760static bool stream_get_parameter_rates(struct str_parms *query,
4761 struct str_parms *reply,
4762 uint32_t *supported_sample_rates) {
4763
4764 int i;
4765 char value[256];
4766 int ret = -1;
4767 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES)) {
4768 ret = 0;
4769 value[0] = '\0';
4770 i=0;
4771 int cursor = 0;
4772 while (supported_sample_rates[i]) {
4773 int avail = sizeof(value) - cursor;
4774 ret = snprintf(value + cursor, avail, "%s%d",
4775 cursor > 0 ? "|" : "",
4776 supported_sample_rates[i]);
4777 if (ret < 0 || ret >= avail) {
4778 // if cursor is at the last element of the array
4779 // overwrite with \0 is duplicate work as
4780 // snprintf already put a \0 in place.
4781 // else
4782 // we had space to write the '|' at value[cursor]
4783 // (which will be overwritten) or no space to fill
4784 // the first element (=> cursor == 0)
4785 value[cursor] = '\0';
4786 break;
4787 }
4788 cursor += ret;
4789 ++i;
4790 }
4791 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES,
4792 value);
4793 }
4794 return ret >= 0;
4795}
4796
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004797static char* out_get_parameters(const struct audio_stream *stream, const char *keys)
4798{
4799 struct stream_out *out = (struct stream_out *)stream;
4800 struct str_parms *query = str_parms_create_str(keys);
Alexy Josephaee4fdd2016-01-29 13:02:07 -08004801 char *str = (char*) NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004802 char value[256];
4803 struct str_parms *reply = str_parms_create();
4804 size_t i, j;
4805 int ret;
4806 bool first = true;
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07004807
4808 if (!query || !reply) {
Alexy Josephaee4fdd2016-01-29 13:02:07 -08004809 if (reply) {
4810 str_parms_destroy(reply);
4811 }
4812 if (query) {
4813 str_parms_destroy(query);
4814 }
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07004815 ALOGE("out_get_parameters: failed to allocate mem for query or reply");
4816 return NULL;
4817 }
4818
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004819 ALOGV("%s: %s enter: keys - %s", __func__, use_case_table[out->usecase], keys);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004820 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
4821 if (ret >= 0) {
4822 value[0] = '\0';
4823 i = 0;
4824 while (out->supported_channel_masks[i] != 0) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004825 for (j = 0; j < ARRAY_SIZE(channels_name_to_enum_table); j++) {
4826 if (channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004827 if (!first) {
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -08004828 strlcat(value, "|", sizeof(value));
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004829 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004830 strlcat(value, channels_name_to_enum_table[j].name, sizeof(value));
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004831 first = false;
4832 break;
4833 }
4834 }
4835 i++;
4836 }
4837 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
4838 str = str_parms_to_str(reply);
4839 } else {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08004840 voice_extn_out_get_parameters(out, query, reply);
4841 str = str_parms_to_str(reply);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004842 }
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07004843
Alexy Joseph62142aa2015-11-16 15:10:34 -08004844
4845 ret = str_parms_get_str(query, "is_direct_pcm_track", value, sizeof(value));
4846 if (ret >= 0) {
4847 value[0] = '\0';
Dhananjay Kumarac341582017-02-23 23:42:25 +05304848 if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
4849 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Alexy Joseph62142aa2015-11-16 15:10:34 -08004850 ALOGV("in direct_pcm");
Satya Krishna Pindiprolib6655542017-07-03 19:38:19 +05304851 strlcat(value, "true", sizeof(value));
Alexy Joseph62142aa2015-11-16 15:10:34 -08004852 } else {
4853 ALOGV("not in direct_pcm");
Sharad Sangle3dd5a4a2015-12-10 18:39:17 +05304854 strlcat(value, "false", sizeof(value));
Alexy Joseph62142aa2015-11-16 15:10:34 -08004855 }
4856 str_parms_add_str(reply, "is_direct_pcm_track", value);
Alexy Josephaee4fdd2016-01-29 13:02:07 -08004857 if (str)
4858 free(str);
Alexy Joseph62142aa2015-11-16 15:10:34 -08004859 str = str_parms_to_str(reply);
4860 }
4861
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07004862 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS, value, sizeof(value));
4863 if (ret >= 0) {
4864 value[0] = '\0';
4865 i = 0;
4866 first = true;
4867 while (out->supported_formats[i] != 0) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004868 for (j = 0; j < ARRAY_SIZE(formats_name_to_enum_table); j++) {
4869 if (formats_name_to_enum_table[j].value == out->supported_formats[i]) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07004870 if (!first) {
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -08004871 strlcat(value, "|", sizeof(value));
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07004872 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004873 strlcat(value, formats_name_to_enum_table[j].name, sizeof(value));
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07004874 first = false;
4875 break;
4876 }
4877 }
4878 i++;
4879 }
4880 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_FORMATS, value);
Alexy Josephaee4fdd2016-01-29 13:02:07 -08004881 if (str)
4882 free(str);
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07004883 str = str_parms_to_str(reply);
4884 }
Mingming Yin3a941d42016-02-17 18:08:05 -08004885
4886 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES, value, sizeof(value));
4887 if (ret >= 0) {
4888 value[0] = '\0';
4889 i = 0;
4890 first = true;
4891 while (out->supported_sample_rates[i] != 0) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004892 for (j = 0; j < ARRAY_SIZE(out_sample_rates_name_to_enum_table); j++) {
4893 if (out_sample_rates_name_to_enum_table[j].value == out->supported_sample_rates[i]) {
Mingming Yin3a941d42016-02-17 18:08:05 -08004894 if (!first) {
4895 strlcat(value, "|", sizeof(value));
4896 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07004897 strlcat(value, out_sample_rates_name_to_enum_table[j].name, sizeof(value));
Mingming Yin3a941d42016-02-17 18:08:05 -08004898 first = false;
4899 break;
4900 }
4901 }
4902 i++;
4903 }
4904 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES, value);
4905 if (str)
4906 free(str);
4907 str = str_parms_to_str(reply);
4908 }
4909
Alexy Joseph98988832017-01-13 14:56:59 -08004910 if (str_parms_get_str(query, "supports_hw_suspend", value, sizeof(value)) >= 0) {
4911 //only low latency track supports suspend_resume
4912 str_parms_add_int(reply, "supports_hw_suspend",
Aniket Kumar Lata932f4872017-11-06 18:29:44 -08004913 (out->hal_output_suspend_supported));
Alexy Joseph98988832017-01-13 14:56:59 -08004914 if (str)
4915 free(str);
4916 str = str_parms_to_str(reply);
4917 }
4918
4919
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004920 str_parms_destroy(query);
4921 str_parms_destroy(reply);
Eric Laurent994a6932013-07-17 11:51:42 -07004922 ALOGV("%s: exit: returns - %s", __func__, str);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004923 return str;
4924}
4925
4926static uint32_t out_get_latency(const struct audio_stream_out *stream)
4927{
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004928 uint32_t period_ms;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004929 struct stream_out *out = (struct stream_out *)stream;
Alexy Josephaa54c872014-12-03 02:46:47 -08004930 uint32_t latency = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004931
Alexy Josephaa54c872014-12-03 02:46:47 -08004932 if (is_offload_usecase(out->usecase)) {
Manish Dewangan07de2142017-02-27 19:27:20 +05304933 lock_output_stream(out);
4934 latency = audio_extn_utils_compress_get_dsp_latency(out);
4935 pthread_mutex_unlock(&out->lock);
Haynes Mathew George16081042017-05-31 17:16:49 -07004936 } else if ((out->realtime) ||
4937 (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP)) {
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004938 // since the buffer won't be filled up faster than realtime,
4939 // return a smaller number
4940 if (out->config.rate)
4941 period_ms = (out->af_period_multiplier * out->config.period_size *
4942 1000) / (out->config.rate);
4943 else
4944 period_ms = 0;
4945 latency = period_ms + platform_render_latency(out->usecase)/1000;
Alexy Josephaa54c872014-12-03 02:46:47 -08004946 } else {
4947 latency = (out->config.period_count * out->config.period_size * 1000) /
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004948 (out->config.rate);
Alexy Josephaa54c872014-12-03 02:46:47 -08004949 }
4950
yidongh0515e042017-07-06 15:00:34 +08004951 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices)
Aniket Kumar Latad5972fa2017-02-08 13:53:48 -08004952 latency += audio_extn_a2dp_get_encoder_latency();
4953
Anish Kumar50ebcbf2014-12-09 04:01:39 +05304954 ALOGV("%s: Latency %d", __func__, latency);
Alexy Josephaa54c872014-12-03 02:46:47 -08004955 return latency;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004956}
4957
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05304958static float AmpToDb(float amplification)
4959{
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05304960 float db = DSD_VOLUME_MIN_DB;
4961 if (amplification > 0) {
4962 db = 20 * log10(amplification);
4963 if(db < DSD_VOLUME_MIN_DB)
4964 return DSD_VOLUME_MIN_DB;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05304965 }
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05304966 return db;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05304967}
4968
Arun Mirpuri5d170872019-03-26 13:21:31 -07004969static int out_set_mmap_volume(struct audio_stream_out *stream, float left,
4970 float right)
4971{
4972 struct stream_out *out = (struct stream_out *)stream;
4973 long volume = 0;
4974 char mixer_ctl_name[128] = "";
4975 struct audio_device *adev = out->dev;
4976 struct mixer_ctl *ctl = NULL;
4977 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
4978 PCM_PLAYBACK);
4979
4980 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
4981 "Playback %d Volume", pcm_device_id);
4982 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4983 if (!ctl) {
4984 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4985 __func__, mixer_ctl_name);
4986 return -EINVAL;
4987 }
4988 if (left != right)
4989 ALOGW("%s: Left and right channel volume mismatch:%f,%f",
4990 __func__, left, right);
4991 volume = (long)(left * (MMAP_PLAYBACK_VOLUME_MAX*1.0));
4992 if (mixer_ctl_set_value(ctl, 0, volume) < 0){
4993 ALOGE("%s:ctl for mixer cmd - %s, volume %ld returned error",
4994 __func__, mixer_ctl_name, volume);
4995 return -EINVAL;
4996 }
4997 return 0;
4998}
4999
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305000static int out_set_compr_volume(struct audio_stream_out *stream, float left,
5001 float right)
5002{
5003 struct stream_out *out = (struct stream_out *)stream;
Manish Dewangan338c50a2017-09-12 15:22:03 +05305004 long volume[2];
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305005 char mixer_ctl_name[128];
5006 struct audio_device *adev = out->dev;
5007 struct mixer_ctl *ctl;
5008 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
5009 PCM_PLAYBACK);
5010
5011 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
5012 "Compress Playback %d Volume", pcm_device_id);
5013 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
5014 if (!ctl) {
5015 ALOGE("%s: Could not get ctl for mixer cmd - %s",
5016 __func__, mixer_ctl_name);
5017 return -EINVAL;
5018 }
5019 ALOGE("%s:ctl for mixer cmd - %s, left %f, right %f",
5020 __func__, mixer_ctl_name, left, right);
5021 volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX);
5022 volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX);
5023 mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
5024
5025 return 0;
5026}
5027
Zhou Song2b8f28f2017-09-11 10:51:38 +08005028static int out_set_voip_volume(struct audio_stream_out *stream, float left,
5029 float right)
5030{
5031 struct stream_out *out = (struct stream_out *)stream;
5032 char mixer_ctl_name[] = "App Type Gain";
5033 struct audio_device *adev = out->dev;
5034 struct mixer_ctl *ctl;
Manish Dewangan338c50a2017-09-12 15:22:03 +05305035 long set_values[4];
Zhou Song2b8f28f2017-09-11 10:51:38 +08005036
Aniket Kumar Lata8426d1f2019-06-10 15:25:53 -07005037 if (!is_valid_volume(left, right)) {
5038 ALOGE("%s: Invalid stream volume for left=%f, right=%f",
5039 __func__, left, right);
5040 return -EINVAL;
5041 }
5042
Zhou Song2b8f28f2017-09-11 10:51:38 +08005043 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
5044 if (!ctl) {
5045 ALOGE("%s: Could not get ctl for mixer cmd - %s",
5046 __func__, mixer_ctl_name);
5047 return -EINVAL;
5048 }
5049
5050 set_values[0] = 0; //0: Rx Session 1:Tx Session
5051 set_values[1] = out->app_type_cfg.app_type;
Manish Dewangan338c50a2017-09-12 15:22:03 +05305052 set_values[2] = (long)(left * VOIP_PLAYBACK_VOLUME_MAX);
5053 set_values[3] = (long)(right * VOIP_PLAYBACK_VOLUME_MAX);
Zhou Song2b8f28f2017-09-11 10:51:38 +08005054
5055 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
5056 return 0;
5057}
5058
Ramu Gottipati97bdcfb2018-04-13 17:58:24 +05305059static int out_set_pcm_volume(struct audio_stream_out *stream, float left,
5060 float right)
5061{
5062 struct stream_out *out = (struct stream_out *)stream;
5063 /* Volume control for pcm playback */
5064 if (left != right) {
5065 return -EINVAL;
5066 } else {
5067 char mixer_ctl_name[128];
5068 struct audio_device *adev = out->dev;
5069 struct mixer_ctl *ctl;
5070 int pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
5071 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name), "Playback %d Volume", pcm_device_id);
5072 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
5073 if (!ctl) {
5074 ALOGE("%s : Could not get ctl for mixer cmd - %s", __func__, mixer_ctl_name);
5075 return -EINVAL;
5076 }
5077
5078 int volume = (int) (left * PCM_PLAYBACK_VOLUME_MAX);
5079 int ret = mixer_ctl_set_value(ctl, 0, volume);
5080 if (ret < 0) {
5081 ALOGE("%s: Could not set ctl, error:%d ", __func__, ret);
5082 return -EINVAL;
5083 }
5084
5085 ALOGV("%s : Pcm set volume value %d left %f", __func__, volume, left);
5086
5087 return 0;
5088 }
5089}
5090
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005091static int out_set_volume(struct audio_stream_out *stream, float left,
5092 float right)
5093{
Eric Laurenta9024de2013-04-04 09:19:12 -07005094 struct stream_out *out = (struct stream_out *)stream;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005095 int volume[2];
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305096 int ret = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005097
Arun Mirpuri5d170872019-03-26 13:21:31 -07005098 ALOGD("%s: called with left_vol=%f, right_vol=%f", __func__, left, right);
Eric Laurenta9024de2013-04-04 09:19:12 -07005099 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
5100 /* only take left channel into account: the API is for stereo anyway */
5101 out->muted = (left == 0.0f);
5102 return 0;
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07005103 } else if (is_offload_usecase(out->usecase)) {
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305104 if (audio_extn_passthru_is_passthrough_stream(out)) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07005105 /*
5106 * Set mute or umute on HDMI passthrough stream.
5107 * Only take left channel into account.
5108 * Mute is 0 and unmute 1
5109 */
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305110 audio_extn_passthru_set_volume(out, (left == 0.0f));
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05305111 } else if (out->format == AUDIO_FORMAT_DSD){
5112 char mixer_ctl_name[128] = "DSD Volume";
5113 struct audio_device *adev = out->dev;
5114 struct mixer_ctl *ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
5115
5116 if (!ctl) {
5117 ALOGE("%s: Could not get ctl for mixer cmd - %s",
5118 __func__, mixer_ctl_name);
5119 return -EINVAL;
5120 }
Manish Dewangan338c50a2017-09-12 15:22:03 +05305121 volume[0] = (long)(AmpToDb(left));
5122 volume[1] = (long)(AmpToDb(right));
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05305123 mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
5124 return 0;
Philippe Gravel1c9ac352019-05-28 16:08:37 -07005125 } else if ((out->devices & AUDIO_DEVICE_OUT_BUS) &&
5126 (audio_extn_auto_hal_get_snd_device_for_car_audio_stream(out) ==
5127 SND_DEVICE_OUT_BUS_MEDIA)) {
5128 ALOGD("%s: Overriding offload set volume for media bus stream", __func__);
5129 struct listnode *node = NULL;
5130 list_for_each(node, &adev->active_outputs_list) {
5131 streams_output_ctxt_t *out_ctxt = node_to_item(node,
5132 streams_output_ctxt_t,
5133 list);
5134 if (out_ctxt->output->usecase == USECASE_AUDIO_PLAYBACK_MEDIA) {
5135 out->volume_l = out_ctxt->output->volume_l;
5136 out->volume_r = out_ctxt->output->volume_r;
5137 }
5138 }
5139 if (!out->a2dp_compress_mute) {
5140 ret = out_set_compr_volume(&out->stream, out->volume_l, out->volume_r);
5141 }
5142 return ret;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07005143 } else {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305144 pthread_mutex_lock(&out->compr_mute_lock);
Arun Mirpuri5d170872019-03-26 13:21:31 -07005145 ALOGV("%s: compress mute %d", __func__, out->a2dp_compress_mute);
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305146 if (!out->a2dp_compress_mute)
5147 ret = out_set_compr_volume(stream, left, right);
5148 out->volume_l = left;
5149 out->volume_r = right;
5150 pthread_mutex_unlock(&out->compr_mute_lock);
5151 return ret;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005152 }
Vikram Panduranga93f080e2017-06-07 18:16:14 -07005153 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP) {
Aalique Grahame22e49102018-12-18 14:23:57 -08005154 out->app_type_cfg.gain[0] = (int)(left * VOIP_PLAYBACK_VOLUME_MAX);
5155 out->app_type_cfg.gain[1] = (int)(right * VOIP_PLAYBACK_VOLUME_MAX);
5156 if (!out->standby) {
5157 audio_extn_utils_send_app_type_gain(out->dev,
5158 out->app_type_cfg.app_type,
5159 &out->app_type_cfg.gain[0]);
Zhou Song2b8f28f2017-09-11 10:51:38 +08005160 ret = out_set_voip_volume(stream, left, right);
Aalique Grahame22e49102018-12-18 14:23:57 -08005161 }
Zhou Song2b8f28f2017-09-11 10:51:38 +08005162 out->volume_l = left;
5163 out->volume_r = right;
5164 return ret;
Arun Mirpuri5d170872019-03-26 13:21:31 -07005165 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
5166 ALOGV("%s: MMAP set volume called", __func__);
5167 if (!out->standby)
5168 ret = out_set_mmap_volume(stream, left, right);
5169 out->volume_l = left;
5170 out->volume_r = right;
5171 return ret;
Ramu Gottipati97bdcfb2018-04-13 17:58:24 +05305172 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_LOW_LATENCY ||
Ramu Gottipati36547092018-12-28 11:32:09 +05305173 out->usecase == USECASE_AUDIO_PLAYBACK_DEEP_BUFFER ||
5174 out->usecase == USECASE_AUDIO_PLAYBACK_ULL) {
Ramu Gottipati97bdcfb2018-04-13 17:58:24 +05305175 /* Volume control for pcm playback */
5176 if (!out->standby)
5177 ret = out_set_pcm_volume(stream, left, right);
5178 else
5179 out->apply_volume = true;
5180
5181 out->volume_l = left;
5182 out->volume_r = right;
5183 return ret;
Derek Chenf13dd492018-11-13 14:53:51 -08005184 } else if (audio_extn_auto_hal_is_bus_device_usecase(out->usecase)) {
5185 ALOGV("%s: bus device set volume called", __func__);
5186 if (!out->standby)
5187 ret = out_set_pcm_volume(stream, left, right);
5188 out->volume_l = left;
5189 out->volume_r = right;
5190 return ret;
Eric Laurenta9024de2013-04-04 09:19:12 -07005191 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005192
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005193 return -ENOSYS;
5194}
5195
Zhou Songc9672822017-08-16 16:01:39 +08005196static void update_frames_written(struct stream_out *out, size_t bytes)
5197{
5198 size_t bpf = 0;
5199
5200 if (is_offload_usecase(out->usecase) && !out->non_blocking &&
5201 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD))
5202 bpf = 1;
5203 else if (!is_offload_usecase(out->usecase))
5204 bpf = audio_bytes_per_sample(out->format) *
5205 audio_channel_count_from_out_mask(out->channel_mask);
Zhou Song48453a02018-01-10 17:50:59 +08005206
5207 pthread_mutex_lock(&out->position_query_lock);
5208 if (bpf != 0) {
Zhou Songc9672822017-08-16 16:01:39 +08005209 out->written += bytes / bpf;
Zhou Song48453a02018-01-10 17:50:59 +08005210 clock_gettime(CLOCK_MONOTONIC, &out->writeAt);
5211 }
5212 pthread_mutex_unlock(&out->position_query_lock);
Zhou Songc9672822017-08-16 16:01:39 +08005213}
5214
Vignesh Kulothungana6927272019-02-20 15:17:07 -08005215int split_and_write_audio_haptic_data(struct stream_out *out,
5216 const void *buffer, size_t bytes_to_write)
5217{
5218 struct audio_device *adev = out->dev;
5219
5220 int ret = 0;
5221 size_t channel_count = audio_channel_count_from_out_mask(out->channel_mask);
5222 size_t bytes_per_sample = audio_bytes_per_sample(out->format);
5223 size_t frame_size = channel_count * bytes_per_sample;
5224 size_t frame_count = bytes_to_write / frame_size;
5225
5226 bool force_haptic_path =
5227 property_get_bool("vendor.audio.test_haptic", false);
5228
5229 // extract Haptics data from Audio buffer
5230 bool alloc_haptic_buffer = false;
5231 int haptic_channel_count = adev->haptics_config.channels;
5232 size_t haptic_frame_size = bytes_per_sample * haptic_channel_count;
5233 size_t audio_frame_size = frame_size - haptic_frame_size;
5234 size_t total_haptic_buffer_size = frame_count * haptic_frame_size;
5235
5236 if (adev->haptic_buffer == NULL) {
5237 alloc_haptic_buffer = true;
5238 } else if (adev->haptic_buffer_size < total_haptic_buffer_size) {
5239 free(adev->haptic_buffer);
5240 adev->haptic_buffer_size = 0;
5241 alloc_haptic_buffer = true;
5242 }
5243
5244 if (alloc_haptic_buffer) {
5245 adev->haptic_buffer = (uint8_t *)calloc(1, total_haptic_buffer_size);
Mingshu Pang1513f972019-05-24 12:43:51 +08005246 if(adev->haptic_buffer == NULL) {
5247 ALOGE("%s: failed to allocate mem for dev->haptic_buffer", __func__);
5248 return -ENOMEM;
5249 }
Vignesh Kulothungana6927272019-02-20 15:17:07 -08005250 adev->haptic_buffer_size = total_haptic_buffer_size;
5251 }
5252
5253 size_t src_index = 0, aud_index = 0, hap_index = 0;
5254 uint8_t *audio_buffer = (uint8_t *)buffer;
5255 uint8_t *haptic_buffer = adev->haptic_buffer;
5256
5257 // This is required for testing only. This works for stereo data only.
5258 // One channel is fed to audio stream and other to haptic stream for testing.
5259 if (force_haptic_path)
5260 audio_frame_size = haptic_frame_size = bytes_per_sample;
5261
5262 for (size_t i = 0; i < frame_count; i++) {
5263 memcpy(audio_buffer + aud_index, audio_buffer + src_index,
5264 audio_frame_size);
5265 aud_index += audio_frame_size;
5266 src_index += audio_frame_size;
5267
5268 if (adev->haptic_pcm)
5269 memcpy(haptic_buffer + hap_index, audio_buffer + src_index,
5270 haptic_frame_size);
5271 hap_index += haptic_frame_size;
5272 src_index += haptic_frame_size;
5273
5274 // This is required for testing only.
5275 // Discard haptic channel data.
5276 if (force_haptic_path)
5277 src_index += haptic_frame_size;
5278 }
5279
5280 // write to audio pipeline
5281 ret = pcm_write(out->pcm, (void *)audio_buffer,
5282 frame_count * audio_frame_size);
5283
5284 // write to haptics pipeline
5285 if (adev->haptic_pcm)
5286 ret = pcm_write(adev->haptic_pcm, (void *)adev->haptic_buffer,
5287 frame_count * haptic_frame_size);
5288
5289 return ret;
5290}
5291
Aalique Grahame22e49102018-12-18 14:23:57 -08005292#ifdef NO_AUDIO_OUT
5293static ssize_t out_write_for_no_output(struct audio_stream_out *stream,
5294 const void *buffer __unused, size_t bytes)
5295{
5296 struct stream_out *out = (struct stream_out *)stream;
5297
5298 /* No Output device supported other than BT for playback.
5299 * Sleep for the amount of buffer duration
5300 */
5301 lock_output_stream(out);
5302 usleep(bytes * 1000000 / audio_stream_out_frame_size(
5303 (const struct audio_stream_out *)&out->stream) /
5304 out_get_sample_rate(&out->stream.common));
5305 pthread_mutex_unlock(&out->lock);
5306 return bytes;
5307}
5308#endif
5309
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005310static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
5311 size_t bytes)
5312{
5313 struct stream_out *out = (struct stream_out *)stream;
5314 struct audio_device *adev = out->dev;
Eric Laurent6e895242013-09-05 16:10:57 -07005315 ssize_t ret = 0;
Satish Babu Patakokila715b1422017-08-22 14:33:21 +05305316 int channels = 0;
Arun Mirpuri7da752a2018-09-11 18:01:15 -07005317 const size_t frame_size = audio_stream_out_frame_size(stream);
5318 const size_t frames = (frame_size != 0) ? bytes / frame_size : bytes;
Dhanalakshmi Siddani20628c82019-01-27 17:31:09 +05305319 struct audio_usecase *usecase = NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005320
Haynes Mathew George380745d2017-10-04 15:27:45 -07005321 ATRACE_BEGIN("out_write");
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005322 lock_output_stream(out);
Naresh Tanniru4c630392014-05-12 01:05:52 +05305323
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305324 if (CARD_STATUS_OFFLINE == out->card_status) {
Zhou Song0b2e5dc2015-03-16 14:41:38 +08005325
Dhananjay Kumarac341582017-02-23 23:42:25 +05305326 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Ashish Jainbbce4322016-02-16 13:25:27 +05305327 /*during SSR for compress usecase we should return error to flinger*/
Naresh Tanniru80659832014-06-04 18:17:56 +05305328 ALOGD(" copl %s: sound card is not active/SSR state", __func__);
5329 pthread_mutex_unlock(&out->lock);
Haynes Mathew George380745d2017-10-04 15:27:45 -07005330 ATRACE_END();
Naresh Tanniru80659832014-06-04 18:17:56 +05305331 return -ENETRESET;
Ashish Jainbbce4322016-02-16 13:25:27 +05305332 } else {
Ashish Jainbbce4322016-02-16 13:25:27 +05305333 ALOGD(" %s: sound card is not active/SSR state", __func__);
5334 ret= -EIO;
5335 goto exit;
Naresh Tanniru4c630392014-05-12 01:05:52 +05305336 }
5337 }
5338
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305339 if (audio_extn_passthru_should_drop_data(out)) {
Ashish Jaind84fd6a2016-07-27 12:33:25 +05305340 ALOGV(" %s : Drop data as compress passthrough session is going on", __func__);
Ashish Jaind84fd6a2016-07-27 12:33:25 +05305341 ret = -EIO;
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305342 goto exit;
5343 }
5344
Haynes Mathew George16081042017-05-31 17:16:49 -07005345 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
5346 ret = -EINVAL;
5347 goto exit;
5348 }
5349
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05305350 if ((out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) &&
5351 !out->is_iec61937_info_available) {
5352
5353 if (!audio_extn_passthru_is_passthrough_stream(out)) {
5354 out->is_iec61937_info_available = true;
5355 } else if (audio_extn_passthru_is_enabled()) {
5356 audio_extn_passthru_update_stream_configuration(adev, out, buffer, bytes);
Manish Dewangan37864bc2017-06-09 12:28:37 +05305357 out->is_iec61937_info_available = true;
Manish Dewangan671a4202017-08-18 17:30:46 +05305358
5359 if((out->format == AUDIO_FORMAT_DTS) ||
5360 (out->format == AUDIO_FORMAT_DTS_HD)) {
5361 ret = audio_extn_passthru_update_dts_stream_configuration(out,
5362 buffer, bytes);
5363 if (ret) {
5364 if (ret != -ENOSYS) {
5365 out->is_iec61937_info_available = false;
5366 ALOGD("iec61937 transmission info not yet updated retry");
5367 }
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05305368 } else if (!out->standby) {
Manish Dewangan671a4202017-08-18 17:30:46 +05305369 /* if stream has started and after that there is
5370 * stream config change (iec transmission config)
5371 * then trigger select_device to update backend configuration.
5372 */
5373 out->stream_config_changed = true;
5374 pthread_mutex_lock(&adev->lock);
5375 select_devices(adev, out->usecase);
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05305376 if (!audio_extn_passthru_is_supported_backend_edid_cfg(adev, out)) {
Weiyin Jiang29c08a42019-04-30 17:11:10 +08005377 pthread_mutex_unlock(&adev->lock);
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05305378 ret = -EINVAL;
5379 goto exit;
5380 }
Manish Dewangan671a4202017-08-18 17:30:46 +05305381 pthread_mutex_unlock(&adev->lock);
5382 out->stream_config_changed = false;
5383 out->is_iec61937_info_available = true;
5384 }
5385 }
Satish Babu Patakokila715b1422017-08-22 14:33:21 +05305386
Garmond Leung317cbf12017-09-13 16:20:50 -07005387 if ((channels < (int)audio_channel_count_from_out_mask(out->channel_mask)) &&
Satish Babu Patakokila715b1422017-08-22 14:33:21 +05305388 (out->compr_config.codec->compr_passthr == PASSTHROUGH) &&
5389 (out->is_iec61937_info_available == true)) {
5390 ALOGE("%s: ERROR: Unsupported channel config in passthrough mode", __func__);
5391 ret = -EINVAL;
5392 goto exit;
5393 }
Manish Dewangan37864bc2017-06-09 12:28:37 +05305394 }
5395 }
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305396
5397 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
Florian Pfister1a84f312018-07-19 14:38:18 +02005398 (audio_extn_a2dp_source_is_suspended())) {
Aalique Grahame22e49102018-12-18 14:23:57 -08005399 if (!(out->devices &
5400 (AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_OUT_SPEAKER_SAFE))) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305401 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305402 ret = -EIO;
5403 goto exit;
5404 }
5405 }
5406 }
5407
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005408 if (out->standby) {
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07005409 out->standby = false;
Eric Laurent150dbfe2013-02-27 14:31:02 -08005410 pthread_mutex_lock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08005411 if (out->usecase == USECASE_COMPRESS_VOIP_CALL)
5412 ret = voice_extn_compress_voip_start_output_stream(out);
5413 else
5414 ret = start_output_stream(out);
Eric Laurent150dbfe2013-02-27 14:31:02 -08005415 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005416 /* ToDo: If use case is compress offload should return 0 */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005417 if (ret != 0) {
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07005418 out->standby = true;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005419 goto exit;
5420 }
Ashish Jain1b9b30c2017-05-18 20:57:40 +05305421 out->started = 1;
vivek mehtab72d08d2016-04-29 03:16:47 -07005422 if (last_known_cal_step != -1) {
5423 ALOGD("%s: retry previous failed cal level set", __func__);
5424 audio_hw_send_gain_dep_calibration(last_known_cal_step);
Preetam Singh Ranawatf4ae0222017-05-31 17:07:28 +05305425 last_known_cal_step = -1;
vivek mehtab72d08d2016-04-29 03:16:47 -07005426 }
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05305427
5428 if ((out->is_iec61937_info_available == true) &&
5429 (audio_extn_passthru_is_passthrough_stream(out))&&
5430 (!audio_extn_passthru_is_supported_backend_edid_cfg(adev, out))) {
5431 ret = -EINVAL;
5432 goto exit;
5433 }
Surendar Karkaf51b5842018-04-26 11:28:38 +05305434 if (out->set_dual_mono)
5435 audio_extn_send_dual_mono_mixing_coefficients(out);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005436 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005437
Ashish Jain81eb2a82015-05-13 10:52:34 +05305438 if (adev->is_channel_status_set == false && (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)){
Alexy Josephb1379942016-01-29 15:49:38 -08005439 audio_utils_set_hdmi_channel_status(out, (void *)buffer, bytes);
Ashish Jain81eb2a82015-05-13 10:52:34 +05305440 adev->is_channel_status_set = true;
5441 }
5442
Dhanalakshmi Siddani20628c82019-01-27 17:31:09 +05305443 if ((adev->use_old_pspd_mix_ctrl == true) &&
5444 (out->pspd_coeff_sent == false)) {
5445 /*
5446 * Need to resend pspd coefficients after stream started for
5447 * older kernel version as it does not save the coefficients
5448 * and also stream has to be started for coeff to apply.
5449 */
5450 usecase = get_usecase_from_list(adev, out->usecase);
5451 if (usecase != NULL) {
Chaithanya Krishna Bacharajuc9f99712019-04-16 15:32:52 +05305452 audio_extn_set_custom_mtmx_params_v2(adev, usecase, true);
Dhanalakshmi Siddani20628c82019-01-27 17:31:09 +05305453 out->pspd_coeff_sent = true;
5454 }
5455 }
5456
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07005457 if (is_offload_usecase(out->usecase)) {
Alexy Joseph01e54e62015-03-03 19:01:03 -08005458 ALOGVV("copl(%p): writing buffer (%zu bytes) to compress device", out, bytes);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07005459 if (out->send_new_metadata) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07005460 ALOGD("copl(%p):send new gapless metadata", out);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07005461 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
5462 out->send_new_metadata = 0;
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05305463 if (out->send_next_track_params && out->is_compr_metadata_avail) {
5464 ALOGD("copl(%p):send next track params in gapless", out);
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08005465 // compress_set_next_track_param(out->compr, &(out->compr_config.codec->options));
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05305466 out->send_next_track_params = false;
5467 out->is_compr_metadata_avail = false;
5468 }
Haynes Mathew George352f27b2013-07-26 00:00:15 -07005469 }
Dhananjay Kumarac341582017-02-23 23:42:25 +05305470 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
Ashish Jain83a6cc22016-06-28 14:34:17 +05305471 (out->convert_buffer) != NULL) {
Haynes Mathew George352f27b2013-07-26 00:00:15 -07005472
Ashish Jain83a6cc22016-06-28 14:34:17 +05305473 if ((bytes > out->hal_fragment_size)) {
Ashish Jainf1eaa582016-05-23 20:54:24 +05305474 ALOGW("Error written bytes %zu > %d (fragment_size)",
Ashish Jain83a6cc22016-06-28 14:34:17 +05305475 bytes, out->hal_fragment_size);
Ashish Jainf1eaa582016-05-23 20:54:24 +05305476 pthread_mutex_unlock(&out->lock);
Haynes Mathew George380745d2017-10-04 15:27:45 -07005477 ATRACE_END();
Ashish Jainf1eaa582016-05-23 20:54:24 +05305478 return -EINVAL;
5479 } else {
Ashish Jain83a6cc22016-06-28 14:34:17 +05305480 audio_format_t dst_format = out->hal_op_format;
5481 audio_format_t src_format = out->hal_ip_format;
Ashish Jainf1eaa582016-05-23 20:54:24 +05305482
Dieter Luecking5d57def2018-09-07 14:23:37 +02005483 /* prevent division-by-zero */
5484 uint32_t bitwidth_src = format_to_bitwidth_table[src_format];
5485 uint32_t bitwidth_dst = format_to_bitwidth_table[dst_format];
5486 if ((bitwidth_src == 0) || (bitwidth_dst == 0)) {
5487 ALOGE("%s: Error bitwidth == 0", __func__);
Ramu Gottipati02809682018-12-19 16:46:12 +05305488 pthread_mutex_unlock(&out->lock);
Dieter Luecking5d57def2018-09-07 14:23:37 +02005489 ATRACE_END();
5490 return -EINVAL;
5491 }
5492
Ashish Jainf1eaa582016-05-23 20:54:24 +05305493 uint32_t frames = bytes / format_to_bitwidth_table[src_format];
5494 uint32_t bytes_to_write = frames * format_to_bitwidth_table[dst_format];
5495
Ashish Jain83a6cc22016-06-28 14:34:17 +05305496 memcpy_by_audio_format(out->convert_buffer,
Ashish Jainf1eaa582016-05-23 20:54:24 +05305497 dst_format,
5498 buffer,
5499 src_format,
5500 frames);
5501
Ashish Jain83a6cc22016-06-28 14:34:17 +05305502 ret = compress_write(out->compr, out->convert_buffer,
Ashish Jainf1eaa582016-05-23 20:54:24 +05305503 bytes_to_write);
5504
5505 /*Convert written bytes in audio flinger format*/
5506 if (ret > 0)
5507 ret = ((ret * format_to_bitwidth_table[out->format]) /
5508 format_to_bitwidth_table[dst_format]);
5509 }
5510 } else
5511 ret = compress_write(out->compr, buffer, bytes);
5512
Zhou Songc9672822017-08-16 16:01:39 +08005513 if ((ret < 0 || ret == (ssize_t)bytes) && !out->non_blocking)
5514 update_frames_written(out, bytes);
5515
Dhanalakshmi Siddani37ca1d62014-08-20 12:28:34 +05305516 if (ret < 0)
5517 ret = -errno;
Weiyin Jiangcc60dbb2018-08-21 13:12:03 +08005518 ALOGVV("%s: writing buffer (%zu bytes) to compress device returned %d", __func__, bytes, (int)ret);
Ashish Jainb26edfb2016-08-25 00:10:11 +05305519 /*msg to cb thread only if non blocking write is enabled*/
5520 if (ret >= 0 && ret < (ssize_t)bytes && out->non_blocking) {
Sidipotu Ashok55820562014-02-10 16:16:38 +05305521 ALOGD("No space available in compress driver, post msg to cb thread");
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005522 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
Naresh Tanniru80659832014-06-04 18:17:56 +05305523 } else if (-ENETRESET == ret) {
5524 ALOGE("copl %s: received sound card offline state on compress write", __func__);
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305525 out->card_status = CARD_STATUS_OFFLINE;
Naresh Tanniru80659832014-06-04 18:17:56 +05305526 pthread_mutex_unlock(&out->lock);
Dhananjay Kumar1248dd82017-07-28 21:22:16 +05305527 out_on_error(&out->stream.common);
Haynes Mathew George380745d2017-10-04 15:27:45 -07005528 ATRACE_END();
Naresh Tanniru80659832014-06-04 18:17:56 +05305529 return ret;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005530 }
Ashish Jain5106d362016-05-11 19:23:33 +05305531
Dhanalakshmi Siddania6b76c72016-09-09 18:10:31 +05305532 /* Call compr start only when non-zero bytes of data is there to be rendered */
5533 if (!out->playback_started && ret > 0) {
5534 int status = compress_start(out->compr);
5535 if (status < 0) {
5536 ret = status;
5537 ALOGE("%s: compr start failed with err %d", __func__, errno);
5538 goto exit;
5539 }
Alexy Joseph7de344d2015-03-30 10:40:03 -07005540 audio_extn_dts_eagle_fade(adev, true, out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005541 out->playback_started = 1;
5542 out->offload_state = OFFLOAD_STATE_PLAYING;
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08005543
5544 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
5545 popcount(out->channel_mask),
5546 out->playback_started);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005547 }
5548 pthread_mutex_unlock(&out->lock);
Haynes Mathew George380745d2017-10-04 15:27:45 -07005549 ATRACE_END();
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005550 return ret;
5551 } else {
5552 if (out->pcm) {
Arun Mirpuri7da752a2018-09-11 18:01:15 -07005553 size_t bytes_to_write = bytes;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005554 if (out->muted)
5555 memset((void *)buffer, 0, bytes);
Arun Mirpuri7da752a2018-09-11 18:01:15 -07005556 ALOGV("%s: frames=%zu, frame_size=%zu, bytes_to_write=%zu",
5557 __func__, frames, frame_size, bytes_to_write);
5558
Aalique Grahame22e49102018-12-18 14:23:57 -08005559 if (out->usecase == USECASE_INCALL_MUSIC_UPLINK ||
Aniket Kumar Lata4f9a2a52019-05-09 18:44:09 -07005560 out->usecase == USECASE_INCALL_MUSIC_UPLINK2 ||
5561 (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP &&
5562 !audio_extn_utils_is_vendor_enhanced_fwk())) {
Arun Mirpuri7da752a2018-09-11 18:01:15 -07005563 size_t channel_count = audio_channel_count_from_out_mask(out->channel_mask);
5564 int16_t *src = (int16_t *)buffer;
5565 int16_t *dst = (int16_t *)buffer;
5566
5567 LOG_ALWAYS_FATAL_IF(out->config.channels != 1 || channel_count != 2 ||
5568 out->format != AUDIO_FORMAT_PCM_16_BIT,
Aalique Grahame22e49102018-12-18 14:23:57 -08005569 "out_write called for %s use case with wrong properties",
5570 use_case_table[out->usecase]);
Arun Mirpuri7da752a2018-09-11 18:01:15 -07005571
5572 /*
5573 * FIXME: this can be removed once audio flinger mixer supports
5574 * mono output
5575 */
5576
5577 /*
5578 * Code below goes over each frame in the buffer and adds both
5579 * L and R samples and then divides by 2 to convert to mono
5580 */
5581 for (size_t i = 0; i < frames ; i++, dst++, src += 2) {
5582 *dst = (int16_t)(((int32_t)src[0] + (int32_t)src[1]) >> 1);
5583 }
5584 bytes_to_write /= 2;
5585 }
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07005586
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05305587 ALOGVV("%s: writing buffer (%zu bytes) to pcm device", __func__, bytes);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07005588
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005589 long ns = 0;
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07005590
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005591 if (out->config.rate)
5592 ns = pcm_bytes_to_frames(out->pcm, bytes)*1000000000LL/
5593 out->config.rate;
5594
Arun Mirpuri7da752a2018-09-11 18:01:15 -07005595 request_out_focus(out, ns);
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005596 bool use_mmap = is_mmap_usecase(out->usecase) || out->realtime;
5597
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005598 if (use_mmap)
Arun Mirpuri7da752a2018-09-11 18:01:15 -07005599 ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes_to_write);
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005600 else if (out->hal_op_format != out->hal_ip_format &&
Ashish Jain83a6cc22016-06-28 14:34:17 +05305601 out->convert_buffer != NULL) {
5602
5603 memcpy_by_audio_format(out->convert_buffer,
5604 out->hal_op_format,
5605 buffer,
5606 out->hal_ip_format,
5607 out->config.period_size * out->config.channels);
5608
5609 ret = pcm_write(out->pcm, out->convert_buffer,
5610 (out->config.period_size *
5611 out->config.channels *
5612 format_to_bitwidth_table[out->hal_op_format]));
5613 } else {
Aditya Bavanarid4db8ee2017-05-29 21:08:03 +05305614 /*
5615 * To avoid underrun in DSP when the application is not pumping
5616 * data at required rate, check for the no. of bytes and ignore
5617 * pcm_write if it is less than actual buffer size.
5618 * It is a work around to a change in compress VOIP driver.
5619 */
5620 if ((out->flags & AUDIO_OUTPUT_FLAG_VOIP_RX) &&
5621 bytes < (out->config.period_size * out->config.channels *
5622 audio_bytes_per_sample(out->format))) {
5623 size_t voip_buf_size =
5624 out->config.period_size * out->config.channels *
5625 audio_bytes_per_sample(out->format);
5626 ALOGE("%s:VOIP underrun: bytes received %zu, required:%zu\n",
5627 __func__, bytes, voip_buf_size);
5628 usleep(((uint64_t)voip_buf_size - bytes) *
5629 1000000 / audio_stream_out_frame_size(stream) /
5630 out_get_sample_rate(&out->stream.common));
5631 ret = 0;
Vignesh Kulothungana6927272019-02-20 15:17:07 -08005632 } else {
5633 if (out->usecase == USECASE_AUDIO_PLAYBACK_WITH_HAPTICS)
5634 ret = split_and_write_audio_haptic_data(out, buffer, bytes);
5635 else
5636 ret = pcm_write(out->pcm, (void *)buffer, bytes_to_write);
5637 }
Ashish Jain83a6cc22016-06-28 14:34:17 +05305638 }
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07005639
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005640 release_out_focus(out);
5641
Dhanalakshmi Siddani37ca1d62014-08-20 12:28:34 +05305642 if (ret < 0)
5643 ret = -errno;
Zhou Songc9672822017-08-16 16:01:39 +08005644 else if (ret > 0)
Ashish Jain83a6cc22016-06-28 14:34:17 +05305645 ret = -EINVAL;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005646 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005647 }
5648
5649exit:
Zhou Songc9672822017-08-16 16:01:39 +08005650 update_frames_written(out, bytes);
Naresh Tanniru4c630392014-05-12 01:05:52 +05305651 if (-ENETRESET == ret) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305652 out->card_status = CARD_STATUS_OFFLINE;
Naresh Tanniru4c630392014-05-12 01:05:52 +05305653 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005654 pthread_mutex_unlock(&out->lock);
5655
5656 if (ret != 0) {
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07005657 if (out->pcm)
Alexy Josephb1379942016-01-29 15:49:38 -08005658 ALOGE("%s: error %d, %s", __func__, (int)ret, pcm_get_error(out->pcm));
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05305659 if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05305660 pthread_mutex_lock(&adev->lock);
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05305661 voice_extn_compress_voip_close_output_stream(&out->stream.common);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05305662 out->started = 0;
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05305663 pthread_mutex_unlock(&adev->lock);
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05305664 out->standby = true;
5665 }
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305666 out_on_error(&out->stream.common);
Dieter Luecking5d57def2018-09-07 14:23:37 +02005667 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
5668 /* prevent division-by-zero */
5669 uint32_t stream_size = audio_stream_out_frame_size(stream);
5670 uint32_t srate = out_get_sample_rate(&out->stream.common);
Vidyakumar Athotaa9d3a5f2017-08-09 12:13:05 -07005671
Dieter Luecking5d57def2018-09-07 14:23:37 +02005672 if ((stream_size == 0) || (srate == 0)) {
5673 ALOGE("%s: stream_size= %d, srate = %d", __func__, stream_size, srate);
5674 ATRACE_END();
5675 return -EINVAL;
5676 }
5677 usleep((uint64_t)bytes * 1000000 / stream_size / srate);
5678 }
Vidyakumar Athotaa9d3a5f2017-08-09 12:13:05 -07005679 if (audio_extn_passthru_is_passthrough_stream(out)) {
Rajshekar Eashwarappa88834522018-04-02 17:20:15 +05305680 //ALOGE("%s: write error, ret = %zd", __func__, ret);
Haynes Mathew George380745d2017-10-04 15:27:45 -07005681 ATRACE_END();
Vidyakumar Athotaa9d3a5f2017-08-09 12:13:05 -07005682 return ret;
5683 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005684 }
Haynes Mathew George380745d2017-10-04 15:27:45 -07005685 ATRACE_END();
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005686 return bytes;
5687}
5688
5689static int out_get_render_position(const struct audio_stream_out *stream,
5690 uint32_t *dsp_frames)
5691{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005692 struct stream_out *out = (struct stream_out *)stream;
Zhou Song32a556e2015-05-05 10:46:56 +08005693
5694 if (dsp_frames == NULL)
5695 return -EINVAL;
5696
5697 *dsp_frames = 0;
5698 if (is_offload_usecase(out->usecase)) {
Mingming Yin9e348b52014-11-19 16:18:55 -08005699 ssize_t ret = 0;
Ashish Jain5106d362016-05-11 19:23:33 +05305700
5701 /* Below piece of code is not guarded against any lock beacuse audioFliner serializes
5702 * this operation and adev_close_output_stream(where out gets reset).
5703 */
Dhananjay Kumarac341582017-02-23 23:42:25 +05305704 if (!out->non_blocking && !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Zhou Song48453a02018-01-10 17:50:59 +08005705 *dsp_frames = get_actual_pcm_frames_rendered(out, NULL);
Ashish Jain5106d362016-05-11 19:23:33 +05305706 ALOGVV("dsp_frames %d sampleRate %d",(int)*dsp_frames,out->sample_rate);
Haynes Mathew Georgeb0f5dc32017-10-06 18:35:12 -07005707 adjust_frames_for_device_delay(out, dsp_frames);
Ashish Jain5106d362016-05-11 19:23:33 +05305708 return 0;
5709 }
5710
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005711 lock_output_stream(out);
Ashish Jain5106d362016-05-11 19:23:33 +05305712 if (out->compr != NULL && out->non_blocking) {
Naresh Tanniru80659832014-06-04 18:17:56 +05305713 ret = compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005714 &out->sample_rate);
Dhanalakshmi Siddani37ca1d62014-08-20 12:28:34 +05305715 if (ret < 0)
5716 ret = -errno;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005717 ALOGVV("%s rendered frames %d sample_rate %d",
Ashish Jain5106d362016-05-11 19:23:33 +05305718 __func__, *dsp_frames, out->sample_rate);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005719 }
Naresh Tanniru80659832014-06-04 18:17:56 +05305720 if (-ENETRESET == ret) {
5721 ALOGE(" ERROR: sound card not active Unable to get time stamp from compress driver");
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305722 out->card_status = CARD_STATUS_OFFLINE;
5723 ret = -EINVAL;
Naresh Tanniru80659832014-06-04 18:17:56 +05305724 } else if(ret < 0) {
5725 ALOGE(" ERROR: Unable to get time stamp from compress driver");
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305726 ret = -EINVAL;
5727 } else if (out->card_status == CARD_STATUS_OFFLINE) {
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05305728 /*
5729 * Handle corner case where compress session is closed during SSR
5730 * and timestamp is queried
5731 */
5732 ALOGE(" ERROR: sound card not active, return error");
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305733 ret = -EINVAL;
Manisha Agarwal7b3e3772019-02-20 14:33:45 +05305734 } else if (out->prev_card_status_offline) {
5735 ALOGE("ERROR: previously sound card was offline,return error");
5736 ret = -EINVAL;
Naresh Tanniru80659832014-06-04 18:17:56 +05305737 } else {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305738 ret = 0;
Haynes Mathew Georgeb0f5dc32017-10-06 18:35:12 -07005739 adjust_frames_for_device_delay(out, dsp_frames);
Naresh Tanniru80659832014-06-04 18:17:56 +05305740 }
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305741 pthread_mutex_unlock(&out->lock);
5742 return ret;
Zhou Song32a556e2015-05-05 10:46:56 +08005743 } else if (audio_is_linear_pcm(out->format)) {
5744 *dsp_frames = out->written;
Haynes Mathew Georgeb0f5dc32017-10-06 18:35:12 -07005745 adjust_frames_for_device_delay(out, dsp_frames);
Zhou Song32a556e2015-05-05 10:46:56 +08005746 return 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005747 } else
5748 return -EINVAL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005749}
5750
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07005751static int out_add_audio_effect(const struct audio_stream *stream __unused,
5752 effect_handle_t effect __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005753{
5754 return 0;
5755}
5756
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07005757static int out_remove_audio_effect(const struct audio_stream *stream __unused,
5758 effect_handle_t effect __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005759{
5760 return 0;
5761}
5762
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07005763static int out_get_next_write_timestamp(const struct audio_stream_out *stream __unused,
5764 int64_t *timestamp __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005765{
Satya Krishna Pindiprolib6655542017-07-03 19:38:19 +05305766 return -ENOSYS;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005767}
5768
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07005769static int out_get_presentation_position(const struct audio_stream_out *stream,
5770 uint64_t *frames, struct timespec *timestamp)
5771{
5772 struct stream_out *out = (struct stream_out *)stream;
pavance65c2fe2017-10-18 17:52:01 +05305773 int ret = -ENODATA;
Eric Laurent949a0892013-09-20 09:20:13 -07005774 unsigned long dsp_frames;
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07005775
Ashish Jain5106d362016-05-11 19:23:33 +05305776 /* below piece of code is not guarded against any lock because audioFliner serializes
5777 * this operation and adev_close_output_stream( where out gets reset).
5778 */
5779 if (is_offload_usecase(out->usecase) && !out->non_blocking &&
Dhananjay Kumarac341582017-02-23 23:42:25 +05305780 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Zhou Song48453a02018-01-10 17:50:59 +08005781 *frames = get_actual_pcm_frames_rendered(out, timestamp);
Ashish Jain5106d362016-05-11 19:23:33 +05305782 ALOGVV("frames %lld playedat %lld",(long long int)*frames,
5783 timestamp->tv_sec * 1000000LL + timestamp->tv_nsec / 1000);
5784 return 0;
5785 }
5786
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005787 lock_output_stream(out);
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07005788
Ashish Jain5106d362016-05-11 19:23:33 +05305789 if (is_offload_usecase(out->usecase) && out->compr != NULL && out->non_blocking) {
5790 ret = compress_get_tstamp(out->compr, &dsp_frames,
5791 &out->sample_rate);
yidongh0515e042017-07-06 15:00:34 +08005792 // Adjustment accounts for A2dp encoder latency with offload usecases
5793 // Note: Encoder latency is returned in ms.
5794 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
5795 unsigned long offset =
5796 (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
5797 dsp_frames = (dsp_frames > offset) ? (dsp_frames - offset) : 0;
5798 }
Ashish Jain5106d362016-05-11 19:23:33 +05305799 ALOGVV("%s rendered frames %ld sample_rate %d",
5800 __func__, dsp_frames, out->sample_rate);
5801 *frames = dsp_frames;
5802 if (ret < 0)
5803 ret = -errno;
5804 if (-ENETRESET == ret) {
5805 ALOGE(" ERROR: sound card not active Unable to get time stamp from compress driver");
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305806 out->card_status = CARD_STATUS_OFFLINE;
Ashish Jain5106d362016-05-11 19:23:33 +05305807 ret = -EINVAL;
5808 } else
5809 ret = 0;
5810 /* this is the best we can do */
5811 clock_gettime(CLOCK_MONOTONIC, timestamp);
Eric Laurent949a0892013-09-20 09:20:13 -07005812 } else {
5813 if (out->pcm) {
Weiyin Jiangd4633762018-03-16 12:05:03 +08005814 unsigned int avail;
5815 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
5816 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
5817 int64_t signed_frames = out->written - kernel_buffer_size + avail;
5818 // This adjustment accounts for buffering after app processor.
5819 // It is based on estimated DSP latency per use case, rather than exact.
Haynes Mathew George7ff216f2013-09-11 19:51:41 -07005820 signed_frames -=
Weiyin Jiangd4633762018-03-16 12:05:03 +08005821 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
Aniket Kumar Lataff613152017-07-18 18:19:21 -07005822
Weiyin Jiangd4633762018-03-16 12:05:03 +08005823 // Adjustment accounts for A2dp encoder latency with non offload usecases
5824 // Note: Encoder latency is returned in ms, while platform_render_latency in us.
5825 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
5826 signed_frames -=
5827 (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
5828 }
5829
5830 // It would be unusual for this value to be negative, but check just in case ...
5831 if (signed_frames >= 0) {
5832 *frames = signed_frames;
5833 ret = 0;
5834 }
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07005835 }
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305836 } else if (out->card_status == CARD_STATUS_OFFLINE) {
Ashish Jainbbce4322016-02-16 13:25:27 +05305837 *frames = out->written;
5838 clock_gettime(CLOCK_MONOTONIC, timestamp);
Manisha Agarwal7b3e3772019-02-20 14:33:45 +05305839 if (is_offload_usecase(out->usecase))
5840 ret = -EINVAL;
5841 else
5842 ret = 0;
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07005843 }
5844 }
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07005845 pthread_mutex_unlock(&out->lock);
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07005846 return ret;
5847}
5848
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005849static int out_set_callback(struct audio_stream_out *stream,
5850 stream_callback_t callback, void *cookie)
5851{
5852 struct stream_out *out = (struct stream_out *)stream;
Ben Rombergerd771a7c2017-02-22 18:05:17 -08005853 int ret;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005854
5855 ALOGV("%s", __func__);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005856 lock_output_stream(out);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08005857 out->client_callback = callback;
5858 out->client_cookie = cookie;
5859 if (out->adsp_hdlr_stream_handle) {
5860 ret = audio_extn_adsp_hdlr_stream_set_callback(
5861 out->adsp_hdlr_stream_handle,
5862 callback,
5863 cookie);
5864 if (ret)
5865 ALOGW("%s:adsp hdlr callback registration failed %d",
5866 __func__, ret);
5867 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005868 pthread_mutex_unlock(&out->lock);
5869 return 0;
5870}
5871
5872static int out_pause(struct audio_stream_out* stream)
5873{
5874 struct stream_out *out = (struct stream_out *)stream;
5875 int status = -ENOSYS;
5876 ALOGV("%s", __func__);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07005877 if (is_offload_usecase(out->usecase)) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07005878 ALOGD("copl(%p):pause compress driver", out);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005879 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005880 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305881 if (out->card_status != CARD_STATUS_OFFLINE)
Naresh Tanniru80659832014-06-04 18:17:56 +05305882 status = compress_pause(out->compr);
5883
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005884 out->offload_state = OFFLOAD_STATE_PAUSED;
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08005885
Mingming Yin21854652016-04-13 11:54:02 -07005886 if (audio_extn_passthru_is_active()) {
5887 ALOGV("offload use case, pause passthru");
5888 audio_extn_passthru_on_pause(out);
5889 }
5890
Dhanalakshmi Siddani79415e72015-03-23 11:54:47 +05305891 audio_extn_dts_eagle_fade(adev, false, out);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08005892 audio_extn_dts_notify_playback_state(out->usecase, 0,
5893 out->sample_rate, popcount(out->channel_mask),
5894 0);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005895 }
5896 pthread_mutex_unlock(&out->lock);
5897 }
5898 return status;
5899}
5900
5901static int out_resume(struct audio_stream_out* stream)
5902{
5903 struct stream_out *out = (struct stream_out *)stream;
5904 int status = -ENOSYS;
5905 ALOGV("%s", __func__);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07005906 if (is_offload_usecase(out->usecase)) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07005907 ALOGD("copl(%p):resume compress driver", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005908 status = 0;
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005909 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005910 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305911 if (out->card_status != CARD_STATUS_OFFLINE) {
Naresh Tanniru80659832014-06-04 18:17:56 +05305912 status = compress_resume(out->compr);
Mingming Yin21854652016-04-13 11:54:02 -07005913 }
5914 if (!status) {
5915 out->offload_state = OFFLOAD_STATE_PLAYING;
5916 }
Dhanalakshmi Siddani79415e72015-03-23 11:54:47 +05305917 audio_extn_dts_eagle_fade(adev, true, out);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08005918 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
5919 popcount(out->channel_mask), 1);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005920 }
5921 pthread_mutex_unlock(&out->lock);
5922 }
5923 return status;
5924}
5925
5926static int out_drain(struct audio_stream_out* stream, audio_drain_type_t type )
5927{
5928 struct stream_out *out = (struct stream_out *)stream;
5929 int status = -ENOSYS;
5930 ALOGV("%s", __func__);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07005931 if (is_offload_usecase(out->usecase)) {
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005932 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005933 if (type == AUDIO_DRAIN_EARLY_NOTIFY)
5934 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
5935 else
5936 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
5937 pthread_mutex_unlock(&out->lock);
5938 }
5939 return status;
5940}
5941
5942static int out_flush(struct audio_stream_out* stream)
5943{
5944 struct stream_out *out = (struct stream_out *)stream;
5945 ALOGV("%s", __func__);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07005946 if (is_offload_usecase(out->usecase)) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07005947 ALOGD("copl(%p):calling compress flush", out);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005948 lock_output_stream(out);
Haynes Mathew Georgeafe54d82016-09-21 14:39:19 -07005949 if (out->offload_state == OFFLOAD_STATE_PAUSED) {
5950 stop_compressed_output_l(out);
Haynes Mathew Georgeafe54d82016-09-21 14:39:19 -07005951 } else {
5952 ALOGW("%s called in invalid state %d", __func__, out->offload_state);
5953 }
Weiyin Jiang547e4152017-09-14 17:24:18 +08005954 out->written = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005955 pthread_mutex_unlock(&out->lock);
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07005956 ALOGD("copl(%p):out of compress flush", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005957 return 0;
5958 }
5959 return -ENOSYS;
5960}
5961
Haynes Mathew George16081042017-05-31 17:16:49 -07005962static int out_stop(const struct audio_stream_out* stream)
5963{
5964 struct stream_out *out = (struct stream_out *)stream;
5965 struct audio_device *adev = out->dev;
5966 int ret = -ENOSYS;
5967
5968 ALOGV("%s", __func__);
5969 pthread_mutex_lock(&adev->lock);
5970 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP && !out->standby &&
5971 out->playback_started && out->pcm != NULL) {
5972 pcm_stop(out->pcm);
5973 ret = stop_output_stream(out);
5974 out->playback_started = false;
5975 }
5976 pthread_mutex_unlock(&adev->lock);
5977 return ret;
5978}
5979
5980static int out_start(const struct audio_stream_out* stream)
5981{
5982 struct stream_out *out = (struct stream_out *)stream;
5983 struct audio_device *adev = out->dev;
5984 int ret = -ENOSYS;
5985
5986 ALOGV("%s", __func__);
5987 pthread_mutex_lock(&adev->lock);
5988 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP && !out->standby &&
5989 !out->playback_started && out->pcm != NULL) {
5990 ret = start_output_stream(out);
5991 if (ret == 0) {
5992 out->playback_started = true;
5993 }
5994 }
5995 pthread_mutex_unlock(&adev->lock);
5996 return ret;
5997}
5998
5999/*
6000 * Modify config->period_count based on min_size_frames
6001 */
6002static void adjust_mmap_period_count(struct pcm_config *config, int32_t min_size_frames)
6003{
6004 int periodCountRequested = (min_size_frames + config->period_size - 1)
6005 / config->period_size;
6006 int periodCount = MMAP_PERIOD_COUNT_MIN;
6007
6008 ALOGV("%s original config.period_size = %d config.period_count = %d",
6009 __func__, config->period_size, config->period_count);
6010
6011 while (periodCount < periodCountRequested && (periodCount * 2) < MMAP_PERIOD_COUNT_MAX) {
6012 periodCount *= 2;
6013 }
6014 config->period_count = periodCount;
6015
6016 ALOGV("%s requested config.period_count = %d", __func__, config->period_count);
6017}
6018
Phil Burkfe17efd2019-03-25 10:23:35 -07006019// Read offset for the positional timestamp from a persistent vendor property.
6020// This is to workaround apparent inaccuracies in the timing information that
6021// is used by the AAudio timing model. The inaccuracies can cause glitches.
6022static int64_t get_mmap_out_time_offset() {
6023 const int32_t kDefaultOffsetMicros = 0;
6024 int32_t mmap_time_offset_micros = property_get_int32(
Weiyin Jiangbd68b4d2019-05-17 16:29:50 +08006025 "persist.vendor.audio.out_mmap_delay_micros", kDefaultOffsetMicros);
Phil Burkfe17efd2019-03-25 10:23:35 -07006026 ALOGI("mmap_time_offset_micros = %d for output", mmap_time_offset_micros);
6027 return mmap_time_offset_micros * (int64_t)1000;
6028}
6029
Haynes Mathew George16081042017-05-31 17:16:49 -07006030static int out_create_mmap_buffer(const struct audio_stream_out *stream,
6031 int32_t min_size_frames,
6032 struct audio_mmap_buffer_info *info)
6033{
6034 struct stream_out *out = (struct stream_out *)stream;
6035 struct audio_device *adev = out->dev;
6036 int ret = 0;
Aalique Grahame1f123102017-10-12 10:38:32 -07006037 unsigned int offset1 = 0;
6038 unsigned int frames1 = 0;
Haynes Mathew George16081042017-05-31 17:16:49 -07006039 const char *step = "";
Haynes Mathew Georgeef514882017-05-01 17:46:23 -07006040 uint32_t mmap_size;
Arun Mirpuri5d170872019-03-26 13:21:31 -07006041 uint32_t buffer_size;
Haynes Mathew George16081042017-05-31 17:16:49 -07006042
Arun Mirpuri5d170872019-03-26 13:21:31 -07006043 ALOGD("%s", __func__);
Sharad Sanglec6f32552018-05-04 16:15:38 +05306044 lock_output_stream(out);
Haynes Mathew George16081042017-05-31 17:16:49 -07006045 pthread_mutex_lock(&adev->lock);
6046
Sharad Sanglec6f32552018-05-04 16:15:38 +05306047 if (CARD_STATUS_OFFLINE == out->card_status ||
6048 CARD_STATUS_OFFLINE == adev->card_status) {
6049 ALOGW("out->card_status or adev->card_status offline, try again");
6050 ret = -EIO;
6051 goto exit;
6052 }
Haynes Mathew George16081042017-05-31 17:16:49 -07006053 if (info == NULL || min_size_frames == 0) {
6054 ALOGE("%s: info = %p, min_size_frames = %d", __func__, info, min_size_frames);
6055 ret = -EINVAL;
6056 goto exit;
6057 }
6058 if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP || !out->standby) {
6059 ALOGE("%s: usecase = %d, standby = %d", __func__, out->usecase, out->standby);
6060 ret = -ENOSYS;
6061 goto exit;
6062 }
6063 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
6064 if (out->pcm_device_id < 0) {
6065 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
6066 __func__, out->pcm_device_id, out->usecase);
6067 ret = -EINVAL;
6068 goto exit;
6069 }
6070
6071 adjust_mmap_period_count(&out->config, min_size_frames);
6072
Arun Mirpuri5d170872019-03-26 13:21:31 -07006073 ALOGD("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
Haynes Mathew George16081042017-05-31 17:16:49 -07006074 __func__, adev->snd_card, out->pcm_device_id, out->config.channels);
6075 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
6076 (PCM_OUT | PCM_MMAP | PCM_NOIRQ | PCM_MONOTONIC), &out->config);
Satish Babu Patakokila54ce83d2018-07-06 18:00:37 +05306077 if (errno == ENETRESET && !pcm_is_ready(out->pcm)) {
Sharad Sanglec6f32552018-05-04 16:15:38 +05306078 ALOGE("%s: pcm_open failed errno:%d\n", __func__, errno);
6079 out->card_status = CARD_STATUS_OFFLINE;
6080 adev->card_status = CARD_STATUS_OFFLINE;
6081 ret = -EIO;
6082 goto exit;
6083 }
6084
Haynes Mathew George16081042017-05-31 17:16:49 -07006085 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
6086 step = "open";
6087 ret = -ENODEV;
6088 goto exit;
6089 }
6090 ret = pcm_mmap_begin(out->pcm, &info->shared_memory_address, &offset1, &frames1);
6091 if (ret < 0) {
6092 step = "begin";
6093 goto exit;
6094 }
6095 info->buffer_size_frames = pcm_get_buffer_size(out->pcm);
Arun Mirpuri5d170872019-03-26 13:21:31 -07006096 buffer_size = pcm_frames_to_bytes(out->pcm, info->buffer_size_frames);
Haynes Mathew George16081042017-05-31 17:16:49 -07006097 info->burst_size_frames = out->config.period_size;
Haynes Mathew Georgeef514882017-05-01 17:46:23 -07006098 ret = platform_get_mmap_data_fd(adev->platform,
6099 out->pcm_device_id, 0 /*playback*/,
6100 &info->shared_memory_fd,
6101 &mmap_size);
6102 if (ret < 0) {
Arun Mirpuri5d170872019-03-26 13:21:31 -07006103 // Fall back to non exclusive mode
6104 info->shared_memory_fd = pcm_get_poll_fd(out->pcm);
6105 } else {
6106 if (mmap_size < buffer_size) {
6107 step = "mmap";
6108 goto exit;
6109 }
6110 // FIXME: indicate exclusive mode support by returning a negative buffer size
6111 info->buffer_size_frames *= -1;
Haynes Mathew Georgeef514882017-05-01 17:46:23 -07006112 }
Haynes Mathew George16081042017-05-31 17:16:49 -07006113 memset(info->shared_memory_address, 0, pcm_frames_to_bytes(out->pcm,
Haynes Mathew Georgeef514882017-05-01 17:46:23 -07006114 info->buffer_size_frames));
Haynes Mathew George16081042017-05-31 17:16:49 -07006115
6116 ret = pcm_mmap_commit(out->pcm, 0, MMAP_PERIOD_SIZE);
6117 if (ret < 0) {
6118 step = "commit";
6119 goto exit;
6120 }
6121
Phil Burkfe17efd2019-03-25 10:23:35 -07006122 out->mmap_time_offset_nanos = get_mmap_out_time_offset();
6123
Haynes Mathew George16081042017-05-31 17:16:49 -07006124 out->standby = false;
6125 ret = 0;
6126
Arun Mirpuri5d170872019-03-26 13:21:31 -07006127 ALOGD("%s: got mmap buffer address %p info->buffer_size_frames %d",
Haynes Mathew George16081042017-05-31 17:16:49 -07006128 __func__, info->shared_memory_address, info->buffer_size_frames);
6129
6130exit:
6131 if (ret != 0) {
6132 if (out->pcm == NULL) {
6133 ALOGE("%s: %s - %d", __func__, step, ret);
6134 } else {
6135 ALOGE("%s: %s %s", __func__, step, pcm_get_error(out->pcm));
6136 pcm_close(out->pcm);
6137 out->pcm = NULL;
6138 }
6139 }
6140 pthread_mutex_unlock(&adev->lock);
Sharad Sanglec6f32552018-05-04 16:15:38 +05306141 pthread_mutex_unlock(&out->lock);
Haynes Mathew George16081042017-05-31 17:16:49 -07006142 return ret;
6143}
6144
6145static int out_get_mmap_position(const struct audio_stream_out *stream,
6146 struct audio_mmap_position *position)
6147{
6148 struct stream_out *out = (struct stream_out *)stream;
6149 ALOGVV("%s", __func__);
6150 if (position == NULL) {
6151 return -EINVAL;
6152 }
6153 if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP) {
Haynes Mathew George4ab3ba92017-12-11 14:49:43 -08006154 ALOGE("%s: called on %s", __func__, use_case_table[out->usecase]);
Haynes Mathew George16081042017-05-31 17:16:49 -07006155 return -ENOSYS;
6156 }
6157 if (out->pcm == NULL) {
6158 return -ENOSYS;
6159 }
6160
6161 struct timespec ts = { 0, 0 };
6162 int ret = pcm_mmap_get_hw_ptr(out->pcm, (unsigned int *)&position->position_frames, &ts);
6163 if (ret < 0) {
6164 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
6165 return ret;
6166 }
Phil Burkfe17efd2019-03-25 10:23:35 -07006167 position->time_nanoseconds = ts.tv_sec*1000000000LL + ts.tv_nsec
6168 + out->mmap_time_offset_nanos;
Haynes Mathew George16081042017-05-31 17:16:49 -07006169 return 0;
6170}
6171
6172
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006173/** audio_stream_in implementation **/
6174static uint32_t in_get_sample_rate(const struct audio_stream *stream)
6175{
6176 struct stream_in *in = (struct stream_in *)stream;
6177
6178 return in->config.rate;
6179}
6180
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006181static int in_set_sample_rate(struct audio_stream *stream __unused,
6182 uint32_t rate __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006183{
6184 return -ENOSYS;
6185}
6186
6187static size_t in_get_buffer_size(const struct audio_stream *stream)
6188{
6189 struct stream_in *in = (struct stream_in *)stream;
6190
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006191 if(in->usecase == USECASE_COMPRESS_VOIP_CALL)
6192 return voice_extn_compress_voip_in_get_buffer_size(in);
Mingming Yine62d7842013-10-25 16:26:03 -07006193 else if(audio_extn_compr_cap_usecase_supported(in->usecase))
6194 return audio_extn_compr_cap_get_buffer_size(in->config.format);
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306195 else if(audio_extn_cin_attached_usecase(in->usecase))
6196 return audio_extn_cin_get_buffer_size(in);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006197
Haynes Mathew George5beddd42016-06-27 18:33:40 -07006198 return in->config.period_size * in->af_period_multiplier *
6199 audio_stream_in_frame_size((const struct audio_stream_in *)stream);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006200}
6201
6202static uint32_t in_get_channels(const struct audio_stream *stream)
6203{
6204 struct stream_in *in = (struct stream_in *)stream;
6205
6206 return in->channel_mask;
6207}
6208
6209static audio_format_t in_get_format(const struct audio_stream *stream)
6210{
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006211 struct stream_in *in = (struct stream_in *)stream;
6212
6213 return in->format;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006214}
6215
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006216static int in_set_format(struct audio_stream *stream __unused,
6217 audio_format_t format __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006218{
6219 return -ENOSYS;
6220}
6221
6222static int in_standby(struct audio_stream *stream)
6223{
6224 struct stream_in *in = (struct stream_in *)stream;
6225 struct audio_device *adev = in->dev;
6226 int status = 0;
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05306227 ALOGD("%s: enter: stream (%p) usecase(%d: %s)", __func__,
6228 stream, in->usecase, use_case_table[in->usecase]);
Haynes Mathew George16081042017-05-31 17:16:49 -07006229 bool do_stop = true;
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05306230
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07006231 lock_input_stream(in);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07006232 if (!in->standby && in->is_st_session) {
6233 ALOGD("%s: sound trigger pcm stop lab", __func__);
6234 audio_extn_sound_trigger_stop_lab(in);
Quinn Malef6050362019-01-30 15:55:40 -08006235 adev->num_va_sessions--;
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07006236 in->standby = 1;
6237 }
6238
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006239 if (!in->standby) {
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07006240 if (adev->adm_deregister_stream)
6241 adev->adm_deregister_stream(adev->adm_data, in->capture_handle);
6242
Ravi Kumar Alamanda8bba9e92013-11-11 21:09:07 -08006243 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006244 in->standby = true;
Zhou Songa8895042016-07-05 17:54:22 +08006245 if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
kunleizbecba2d2017-09-07 13:37:16 +08006246 do_stop = false;
Zhou Songa8895042016-07-05 17:54:22 +08006247 voice_extn_compress_voip_close_input_stream(stream);
6248 ALOGD("VOIP input entered standby");
Haynes Mathew George16081042017-05-31 17:16:49 -07006249 } else if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
6250 do_stop = in->capture_started;
6251 in->capture_started = false;
Zhou Songa8895042016-07-05 17:54:22 +08006252 } else {
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306253 if (audio_extn_cin_attached_usecase(in->usecase))
Manish Dewangan46e07982018-12-13 18:18:59 +05306254 audio_extn_cin_close_input_stream(in);
kunleizbecba2d2017-09-07 13:37:16 +08006255 }
6256
Arun Mirpuri5d170872019-03-26 13:21:31 -07006257 if (in->pcm) {
6258 ATRACE_BEGIN("pcm_in_close");
6259 pcm_close(in->pcm);
6260 ATRACE_END();
6261 in->pcm = NULL;
6262 }
6263
Carter Hsu2e429db2019-05-14 18:50:52 +08006264 if (in->source == AUDIO_SOURCE_VOICE_COMMUNICATION)
Aalique Grahame22e49102018-12-18 14:23:57 -08006265 adev->enable_voicerx = false;
Carter Hsu2e429db2019-05-14 18:50:52 +08006266
6267 if (do_stop)
Zhou Songa8895042016-07-05 17:54:22 +08006268 status = stop_input_stream(in);
Quinn Malef6050362019-01-30 15:55:40 -08006269
6270 if (in->source == AUDIO_SOURCE_VOICE_RECOGNITION)
6271 adev->num_va_sessions--;
6272
Eric Laurent150dbfe2013-02-27 14:31:02 -08006273 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006274 }
6275 pthread_mutex_unlock(&in->lock);
Eric Laurent994a6932013-07-17 11:51:42 -07006276 ALOGV("%s: exit: status(%d)", __func__, status);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006277 return status;
6278}
6279
Aalique Grahame22e49102018-12-18 14:23:57 -08006280static int in_dump(const struct audio_stream *stream,
6281 int fd)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006282{
Aalique Grahame22e49102018-12-18 14:23:57 -08006283 struct stream_in *in = (struct stream_in *)stream;
6284
6285 // We try to get the lock for consistency,
6286 // but it isn't necessary for these variables.
6287 // If we're not in standby, we may be blocked on a read.
6288 const bool locked = (pthread_mutex_trylock(&in->lock) == 0);
6289 dprintf(fd, " Standby: %s\n", in->standby ? "yes" : "no");
6290 dprintf(fd, " Frames read: %lld\n", (long long)in->frames_read);
6291 dprintf(fd, " Frames muted: %lld\n", (long long)in->frames_muted);
6292
6293 if (locked) {
6294 pthread_mutex_unlock(&in->lock);
6295 }
6296
6297 // dump error info
6298 (void)error_log_dump(
6299 in->error_log, fd, " " /* prefix */, 0 /* lines */, 0 /* limit_ns */);
6300
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006301 return 0;
6302}
6303
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306304static void in_snd_mon_cb(void * stream, struct str_parms * parms)
6305{
6306 if (!stream || !parms)
6307 return;
6308
6309 struct stream_in *in = (struct stream_in *)stream;
6310 struct audio_device *adev = in->dev;
6311
6312 card_status_t status;
6313 int card;
6314 if (parse_snd_card_status(parms, &card, &status) < 0)
6315 return;
6316
6317 pthread_mutex_lock(&adev->lock);
6318 bool valid_cb = (card == adev->snd_card);
6319 pthread_mutex_unlock(&adev->lock);
6320
6321 if (!valid_cb)
6322 return;
6323
6324 lock_input_stream(in);
6325 if (in->card_status != status)
6326 in->card_status = status;
6327 pthread_mutex_unlock(&in->lock);
6328
6329 ALOGW("in_snd_mon_cb for card %d usecase %s, status %s", card,
6330 use_case_table[in->usecase],
6331 status == CARD_STATUS_OFFLINE ? "offline" : "online");
6332
6333 // a better solution would be to report error back to AF and let
6334 // it put the stream to standby
6335 if (status == CARD_STATUS_OFFLINE)
6336 in_standby(&in->stream.common);
6337
6338 return;
6339}
6340
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006341static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
6342{
6343 struct stream_in *in = (struct stream_in *)stream;
6344 struct audio_device *adev = in->dev;
6345 struct str_parms *parms;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006346 char value[32];
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08006347 int ret = 0, val = 0, err;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006348
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05306349 ALOGD("%s: enter: kvpairs=%s", __func__, kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006350 parms = str_parms_create_str(kvpairs);
6351
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05306352 if (!parms)
6353 goto error;
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07006354 lock_input_stream(in);
Eric Laurent150dbfe2013-02-27 14:31:02 -08006355 pthread_mutex_lock(&adev->lock);
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08006356
6357 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
6358 if (err >= 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006359 val = atoi(value);
6360 /* no audio source uses val == 0 */
6361 if ((in->source != val) && (val != 0)) {
6362 in->source = val;
Narsinga Rao Chella2a99dea2014-01-24 15:33:23 -08006363 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) &&
6364 (in->dev->mode == AUDIO_MODE_IN_COMMUNICATION) &&
6365 (voice_extn_compress_voip_is_format_supported(in->format)) &&
Shiv Maliyappanahallie66aba22016-01-27 16:08:57 -08006366 (in->config.rate == 8000 || in->config.rate == 16000 ||
6367 in->config.rate == 32000 || in->config.rate == 48000 ) &&
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006368 (audio_channel_count_from_in_mask(in->channel_mask) == 1)) {
Narsinga Rao Chella7d5a3e82014-02-04 16:23:52 -08006369 err = voice_extn_compress_voip_open_input_stream(in);
6370 if (err != 0) {
Narsinga Rao Chella2a99dea2014-01-24 15:33:23 -08006371 ALOGE("%s: Compress voip input cannot be opened, error:%d",
Narsinga Rao Chella7d5a3e82014-02-04 16:23:52 -08006372 __func__, err);
Narsinga Rao Chella2a99dea2014-01-24 15:33:23 -08006373 }
6374 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006375 }
6376 }
6377
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08006378 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
6379 if (err >= 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006380 val = atoi(value);
Kevin Rocardfce19002017-08-07 19:21:36 -07006381 if (((int)in->device != val) && (val != 0) && audio_is_input_device(val) ) {
6382
6383 // Workaround: If routing to an non existing usb device, fail gracefully
6384 // The routing request will otherwise block during 10 second
6385 int card;
6386 if (audio_is_usb_in_device(val) &&
6387 (card = get_alive_usb_card(parms)) >= 0) {
6388
6389 ALOGW("in_set_parameters() ignoring rerouting to non existing USB card %d", card);
6390 ret = -ENOSYS;
6391 } else {
6392
6393 in->device = val;
6394 /* If recording is in progress, change the tx device to new device */
6395 if (!in->standby && !in->is_st_session) {
6396 ALOGV("update input routing change");
6397 // inform adm before actual routing to prevent glitches.
6398 if (adev->adm_on_routing_change) {
Haynes Mathew George822b5492016-07-01 16:57:24 -07006399 adev->adm_on_routing_change(adev->adm_data,
6400 in->capture_handle);
Kevin Rocardfce19002017-08-07 19:21:36 -07006401 ret = select_devices(adev, in->usecase);
Aniket Kumar Lata60586a92019-05-22 22:18:55 -07006402 if (in->usecase == USECASE_AUDIO_RECORD_LOW_LATENCY)
6403 adev->adm_routing_changed = true;
Kevin Rocardfce19002017-08-07 19:21:36 -07006404 }
6405 }
Haynes Mathew George5beddd42016-06-27 18:33:40 -07006406 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006407 }
6408 }
6409
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05306410 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_PROFILE, value, sizeof(value));
6411 if (err >= 0) {
6412 strlcpy(in->profile, value, sizeof(in->profile));
6413 ALOGV("updating stream profile with value '%s'", in->profile);
6414 audio_extn_utils_update_stream_input_app_type_cfg(adev->platform,
6415 &adev->streams_input_cfg_list,
6416 in->device, in->flags, in->format,
6417 in->sample_rate, in->bit_width,
6418 in->profile, &in->app_type_cfg);
6419 }
6420
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006421 pthread_mutex_unlock(&adev->lock);
Eric Laurent150dbfe2013-02-27 14:31:02 -08006422 pthread_mutex_unlock(&in->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006423
6424 str_parms_destroy(parms);
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05306425error:
Eric Laurent994a6932013-07-17 11:51:42 -07006426 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006427 return ret;
6428}
6429
6430static char* in_get_parameters(const struct audio_stream *stream,
6431 const char *keys)
6432{
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006433 struct stream_in *in = (struct stream_in *)stream;
6434 struct str_parms *query = str_parms_create_str(keys);
6435 char *str;
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006436 struct str_parms *reply = str_parms_create();
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07006437
6438 if (!query || !reply) {
Alexy Josephaee4fdd2016-01-29 13:02:07 -08006439 if (reply) {
6440 str_parms_destroy(reply);
6441 }
6442 if (query) {
6443 str_parms_destroy(query);
6444 }
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07006445 ALOGE("in_get_parameters: failed to create query or reply");
6446 return NULL;
6447 }
6448
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006449 ALOGV("%s: enter: keys - %s %s ", __func__, use_case_table[in->usecase], keys);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006450
6451 voice_extn_in_get_parameters(in, query, reply);
6452
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006453 stream_get_parameter_channels(query, reply,
6454 &in->supported_channel_masks[0]);
6455 stream_get_parameter_formats(query, reply,
6456 &in->supported_formats[0]);
6457 stream_get_parameter_rates(query, reply,
6458 &in->supported_sample_rates[0]);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006459 str = str_parms_to_str(reply);
6460 str_parms_destroy(query);
6461 str_parms_destroy(reply);
6462
6463 ALOGV("%s: exit: returns - %s", __func__, str);
6464 return str;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006465}
6466
Aalique Grahame22e49102018-12-18 14:23:57 -08006467static int in_set_gain(struct audio_stream_in *stream,
6468 float gain)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006469{
Aalique Grahame22e49102018-12-18 14:23:57 -08006470 struct stream_in *in = (struct stream_in *)stream;
6471 char mixer_ctl_name[128];
6472 struct mixer_ctl *ctl;
6473 int ctl_value;
6474
6475 ALOGV("%s: gain %f", __func__, gain);
6476
6477 if (stream == NULL)
6478 return -EINVAL;
6479
6480 /* in_set_gain() only used to silence MMAP capture for now */
6481 if (in->usecase != USECASE_AUDIO_RECORD_MMAP)
6482 return -ENOSYS;
6483
6484 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name), "Capture %d Volume", in->pcm_device_id);
6485
6486 ctl = mixer_get_ctl_by_name(in->dev->mixer, mixer_ctl_name);
6487 if (!ctl) {
6488 ALOGW("%s: Could not get ctl for mixer cmd - %s",
6489 __func__, mixer_ctl_name);
6490 return -ENOSYS;
6491 }
6492
6493 if (gain < RECORD_GAIN_MIN)
6494 gain = RECORD_GAIN_MIN;
6495 else if (gain > RECORD_GAIN_MAX)
6496 gain = RECORD_GAIN_MAX;
6497 ctl_value = (int)(RECORD_VOLUME_CTL_MAX * gain);
6498
6499 mixer_ctl_set_value(ctl, 0, ctl_value);
6500
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006501 return 0;
6502}
6503
6504static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
6505 size_t bytes)
6506{
6507 struct stream_in *in = (struct stream_in *)stream;
Pallavid7c7a272018-01-16 11:22:55 +05306508
6509 if (in == NULL) {
6510 ALOGE("%s: stream_in ptr is NULL", __func__);
6511 return -EINVAL;
6512 }
6513
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006514 struct audio_device *adev = in->dev;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05306515 int ret = -1;
Dhananjay Kumar97b81e32019-05-15 21:00:21 +05306516 size_t bytes_read = 0, frame_size = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006517
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07006518 lock_input_stream(in);
Naresh Tanniru4c630392014-05-12 01:05:52 +05306519
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07006520 if (in->is_st_session) {
6521 ALOGVV(" %s: reading on st session bytes=%zu", __func__, bytes);
6522 /* Read from sound trigger HAL */
6523 audio_extn_sound_trigger_read(in, buffer, bytes);
Quinn Malef6050362019-01-30 15:55:40 -08006524 if (in->standby) {
6525 adev->num_va_sessions++;
6526 in->standby = 0;
6527 }
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07006528 pthread_mutex_unlock(&in->lock);
6529 return bytes;
6530 }
6531
Haynes Mathew George16081042017-05-31 17:16:49 -07006532 if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
6533 ret = -ENOSYS;
6534 goto exit;
6535 }
6536
Aniket Kumar Lata60586a92019-05-22 22:18:55 -07006537 if (in->usecase == USECASE_AUDIO_RECORD_LOW_LATENCY &&
6538 !in->standby && adev->adm_routing_changed) {
6539 ret = -ENOSYS;
6540 goto exit;
6541 }
6542
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006543 if (in->standby) {
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07006544 pthread_mutex_lock(&adev->lock);
6545 if (in->usecase == USECASE_COMPRESS_VOIP_CALL)
6546 ret = voice_extn_compress_voip_start_input_stream(in);
6547 else
6548 ret = start_input_stream(in);
Quinn Malef6050362019-01-30 15:55:40 -08006549 if (!ret && in->source == AUDIO_SOURCE_VOICE_RECOGNITION)
6550 adev->num_va_sessions++;
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07006551 pthread_mutex_unlock(&adev->lock);
6552 if (ret != 0) {
6553 goto exit;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006554 }
6555 in->standby = 0;
6556 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006557
Deeraj Soman30cc7ae2019-03-18 16:26:55 +05306558 /* Avoid read if capture_stopped is set */
6559 if (android_atomic_acquire_load(&(in->capture_stopped)) > 0) {
6560 ALOGD("%s: force stopped catpure session, ignoring read request", __func__);
6561 ret = -EINVAL;
6562 goto exit;
6563 }
6564
Haynes Mathew George5beddd42016-06-27 18:33:40 -07006565 // what's the duration requested by the client?
6566 long ns = 0;
6567
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306568 if (in->pcm && in->config.rate)
Haynes Mathew George5beddd42016-06-27 18:33:40 -07006569 ns = pcm_bytes_to_frames(in->pcm, bytes)*1000000000LL/
6570 in->config.rate;
6571
Aniket Kumar Lata60586a92019-05-22 22:18:55 -07006572 ret = request_in_focus(in, ns);
6573 if (ret != 0)
6574 goto exit;
Haynes Mathew George5beddd42016-06-27 18:33:40 -07006575 bool use_mmap = is_mmap_usecase(in->usecase) || in->realtime;
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07006576
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306577 if (audio_extn_cin_attached_usecase(in->usecase)) {
6578 ret = audio_extn_cin_read(in, buffer, bytes, &bytes_read);
6579 } else if (in->pcm) {
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05306580 if (audio_extn_ssr_get_stream() == in) {
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07006581 ret = audio_extn_ssr_read(stream, buffer, bytes);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05306582 } else if (audio_extn_compr_cap_usecase_supported(in->usecase)) {
Mingming Yine62d7842013-10-25 16:26:03 -07006583 ret = audio_extn_compr_cap_read(in, buffer, bytes);
Haynes Mathew George5beddd42016-06-27 18:33:40 -07006584 } else if (use_mmap) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07006585 ret = pcm_mmap_read(in->pcm, buffer, bytes);
Garmond Leunge2433c32017-09-28 21:51:22 -07006586 } else if (audio_extn_ffv_get_stream() == in) {
6587 ret = audio_extn_ffv_read(stream, buffer, bytes);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05306588 } else {
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07006589 ret = pcm_read(in->pcm, buffer, bytes);
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306590 /* data from DSP comes in 24_8 format, convert it to 8_24 */
6591 if (!ret && bytes > 0 && (in->format == AUDIO_FORMAT_PCM_8_24_BIT)) {
6592 if (audio_extn_utils_convert_format_24_8_to_8_24(buffer, bytes)
6593 != bytes) {
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05306594 ret = -EINVAL;
6595 goto exit;
6596 }
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306597 } else if (ret < 0) {
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05306598 ret = -errno;
6599 }
6600 }
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306601 /* bytes read is always set to bytes for non compress usecases */
6602 bytes_read = bytes;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006603 }
6604
Haynes Mathew George5beddd42016-06-27 18:33:40 -07006605 release_in_focus(in);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07006606
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006607 /*
Quinn Malef6050362019-01-30 15:55:40 -08006608 * Instead of writing zeroes here, we could trust the hardware to always
6609 * provide zeroes when muted. This is also muted with voice recognition
6610 * usecases so that other clients do not have access to voice recognition
6611 * data.
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006612 */
Quinn Malef6050362019-01-30 15:55:40 -08006613 if ((ret == 0 && voice_get_mic_mute(adev) &&
6614 !voice_is_in_call_rec_stream(in) &&
6615 in->usecase != USECASE_AUDIO_RECORD_AFE_PROXY) ||
6616 (adev->num_va_sessions &&
6617 in->source != AUDIO_SOURCE_VOICE_RECOGNITION &&
6618 property_get_bool("persist.vendor.audio.va_concurrency_mute_enabled",
6619 false)))
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006620 memset(buffer, 0, bytes);
6621
6622exit:
Dhananjay Kumar97b81e32019-05-15 21:00:21 +05306623 frame_size = audio_stream_in_frame_size(stream);
6624 if (frame_size > 0)
6625 in->frames_read += bytes_read/frame_size;
6626
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07006627 if (-ENETRESET == ret)
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306628 in->card_status = CARD_STATUS_OFFLINE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006629 pthread_mutex_unlock(&in->lock);
6630
6631 if (ret != 0) {
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05306632 if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05306633 pthread_mutex_lock(&adev->lock);
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05306634 voice_extn_compress_voip_close_input_stream(&in->stream.common);
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05306635 pthread_mutex_unlock(&adev->lock);
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05306636 in->standby = true;
6637 }
Sharad Sangled17c9122017-03-20 15:58:52 +05306638 if (!audio_extn_cin_attached_usecase(in->usecase)) {
6639 bytes_read = bytes;
6640 memset(buffer, 0, bytes);
6641 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006642 in_standby(&in->stream.common);
Aniket Kumar Lata60586a92019-05-22 22:18:55 -07006643 if (in->usecase == USECASE_AUDIO_RECORD_LOW_LATENCY)
6644 adev->adm_routing_changed = false;
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07006645 ALOGV("%s: read failed status %d- sleeping for buffer duration", __func__, ret);
Ashish Jainbbce4322016-02-16 13:25:27 +05306646 usleep((uint64_t)bytes * 1000000 / audio_stream_in_frame_size(stream) /
Naresh Tanniru4c630392014-05-12 01:05:52 +05306647 in_get_sample_rate(&in->stream.common));
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006648 }
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306649 return bytes_read;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006650}
6651
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006652static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006653{
6654 return 0;
6655}
6656
Aalique Grahame22e49102018-12-18 14:23:57 -08006657static int in_get_capture_position(const struct audio_stream_in *stream,
6658 int64_t *frames, int64_t *time)
6659{
6660 if (stream == NULL || frames == NULL || time == NULL) {
6661 return -EINVAL;
6662 }
6663 struct stream_in *in = (struct stream_in *)stream;
6664 int ret = -ENOSYS;
6665
6666 lock_input_stream(in);
6667 // note: ST sessions do not close the alsa pcm driver synchronously
6668 // on standby. Therefore, we may return an error even though the
6669 // pcm stream is still opened.
6670 if (in->standby) {
6671 ALOGE_IF(in->pcm != NULL && !in->is_st_session,
6672 "%s stream in standby but pcm not NULL for non ST session", __func__);
6673 goto exit;
6674 }
6675 if (in->pcm) {
6676 struct timespec timestamp;
6677 unsigned int avail;
6678 if (pcm_get_htimestamp(in->pcm, &avail, &timestamp) == 0) {
6679 *frames = in->frames_read + avail;
6680 *time = timestamp.tv_sec * 1000000000LL + timestamp.tv_nsec;
6681 ret = 0;
6682 }
6683 }
6684exit:
6685 pthread_mutex_unlock(&in->lock);
6686 return ret;
6687}
6688
Carter Hsu2e429db2019-05-14 18:50:52 +08006689static int in_update_effect_list(bool add, effect_handle_t effect,
6690 struct listnode *head)
6691{
6692 struct listnode *node;
6693 struct in_effect_list *elist = NULL;
6694 struct in_effect_list *target = NULL;
6695 int ret = 0;
6696
6697 if (!head)
6698 return ret;
6699
6700 list_for_each(node, head) {
6701 elist = node_to_item(node, struct in_effect_list, list);
6702 if (elist->handle == effect) {
6703 target = elist;
6704 break;
6705 }
6706 }
6707
6708 if (add) {
6709 if (target) {
6710 ALOGD("effect %p already exist", effect);
6711 return ret;
6712 }
6713
6714 target = (struct in_effect_list *)
6715 calloc(1, sizeof(struct in_effect_list));
6716
6717 if (!target) {
6718 ALOGE("%s:fail to allocate memory", __func__);
6719 return -ENOMEM;
6720 }
6721
6722 target->handle = effect;
6723 list_add_tail(head, &target->list);
6724 } else {
6725 if (target) {
6726 list_remove(&target->list);
6727 free(target);
6728 }
6729 }
6730
6731 return ret;
6732}
6733
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006734static int add_remove_audio_effect(const struct audio_stream *stream,
6735 effect_handle_t effect,
6736 bool enable)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006737{
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006738 struct stream_in *in = (struct stream_in *)stream;
6739 int status = 0;
6740 effect_descriptor_t desc;
6741
6742 status = (*effect)->get_descriptor(effect, &desc);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07006743 ALOGV("%s: status %d in->standby %d enable:%d", __func__, status, in->standby, enable);
6744
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006745 if (status != 0)
6746 return status;
6747
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07006748 lock_input_stream(in);
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006749 pthread_mutex_lock(&in->dev->lock);
kunleizd96526c2018-04-09 11:12:32 +08006750 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
Carter Hsu2e429db2019-05-14 18:50:52 +08006751 in->source == AUDIO_SOURCE_VOICE_RECOGNITION ||
6752 adev->mode == AUDIO_MODE_IN_COMMUNICATION) &&
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006753 (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) {
Carter Hsu2e429db2019-05-14 18:50:52 +08006754
6755 in_update_effect_list(enable, effect, &in->aec_list);
6756 enable = !list_empty(&in->aec_list);
6757 if (enable == in->enable_aec)
6758 goto exit;
6759
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006760 in->enable_aec = enable;
Carter Hsu2e429db2019-05-14 18:50:52 +08006761 ALOGD("AEC enable %d", enable);
6762
Aalique Grahame22e49102018-12-18 14:23:57 -08006763 if (in->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
6764 in->dev->mode == AUDIO_MODE_IN_COMMUNICATION) {
6765 in->dev->enable_voicerx = enable;
6766 struct audio_usecase *usecase;
6767 struct listnode *node;
6768 list_for_each(node, &in->dev->usecase_list) {
6769 usecase = node_to_item(node, struct audio_usecase, list);
6770 if (usecase->type == PCM_PLAYBACK)
6771 select_devices(in->dev, usecase->id);
6772 }
6773 }
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07006774 if (!in->standby) {
6775 if (enable_disable_effect(in->dev, EFFECT_AEC, enable) == ENOSYS)
6776 select_devices(in->dev, in->usecase);
6777 }
6778
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006779 }
Carter Hsu2e429db2019-05-14 18:50:52 +08006780 if (memcmp(&desc.type, FX_IID_NS, sizeof(effect_uuid_t)) == 0) {
6781
6782 in_update_effect_list(enable, effect, &in->ns_list);
6783 enable = !list_empty(&in->ns_list);
6784 if (enable == in->enable_ns)
6785 goto exit;
6786
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -08006787 in->enable_ns = enable;
Carter Hsu2e429db2019-05-14 18:50:52 +08006788 ALOGD("NS enable %d", enable);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07006789 if (!in->standby) {
kunleizd96526c2018-04-09 11:12:32 +08006790 if (in->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
6791 in->dev->mode == AUDIO_MODE_IN_COMMUNICATION) {
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07006792 if (enable_disable_effect(in->dev, EFFECT_NS, enable) == ENOSYS)
6793 select_devices(in->dev, in->usecase);
6794 } else
6795 select_devices(in->dev, in->usecase);
6796 }
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -08006797 }
Carter Hsu2e429db2019-05-14 18:50:52 +08006798exit:
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006799 pthread_mutex_unlock(&in->dev->lock);
6800 pthread_mutex_unlock(&in->lock);
6801
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006802 return 0;
6803}
6804
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006805static int in_add_audio_effect(const struct audio_stream *stream,
6806 effect_handle_t effect)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006807{
Eric Laurent994a6932013-07-17 11:51:42 -07006808 ALOGV("%s: effect %p", __func__, effect);
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006809 return add_remove_audio_effect(stream, effect, true);
6810}
6811
6812static int in_remove_audio_effect(const struct audio_stream *stream,
6813 effect_handle_t effect)
6814{
Eric Laurent994a6932013-07-17 11:51:42 -07006815 ALOGV("%s: effect %p", __func__, effect);
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07006816 return add_remove_audio_effect(stream, effect, false);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006817}
6818
Derek Chenf939fb72018-11-13 13:34:41 -08006819streams_input_ctxt_t *in_get_stream(struct audio_device *dev,
6820 audio_io_handle_t input)
6821{
6822 struct listnode *node;
6823
6824 list_for_each(node, &dev->active_inputs_list) {
6825 streams_input_ctxt_t *in_ctxt = node_to_item(node,
6826 streams_input_ctxt_t,
6827 list);
6828 if (in_ctxt->input->capture_handle == input) {
6829 return in_ctxt;
6830 }
6831 }
6832 return NULL;
6833}
6834
6835streams_output_ctxt_t *out_get_stream(struct audio_device *dev,
6836 audio_io_handle_t output)
6837{
6838 struct listnode *node;
6839
6840 list_for_each(node, &dev->active_outputs_list) {
6841 streams_output_ctxt_t *out_ctxt = node_to_item(node,
6842 streams_output_ctxt_t,
6843 list);
6844 if (out_ctxt->output->handle == output) {
6845 return out_ctxt;
6846 }
6847 }
6848 return NULL;
6849}
6850
Haynes Mathew George16081042017-05-31 17:16:49 -07006851static int in_stop(const struct audio_stream_in* stream)
6852{
6853 struct stream_in *in = (struct stream_in *)stream;
6854 struct audio_device *adev = in->dev;
6855
6856 int ret = -ENOSYS;
6857 ALOGV("%s", __func__);
6858 pthread_mutex_lock(&adev->lock);
6859 if (in->usecase == USECASE_AUDIO_RECORD_MMAP && !in->standby &&
6860 in->capture_started && in->pcm != NULL) {
6861 pcm_stop(in->pcm);
6862 ret = stop_input_stream(in);
6863 in->capture_started = false;
6864 }
6865 pthread_mutex_unlock(&adev->lock);
6866 return ret;
6867}
6868
6869static int in_start(const struct audio_stream_in* stream)
6870{
6871 struct stream_in *in = (struct stream_in *)stream;
6872 struct audio_device *adev = in->dev;
6873 int ret = -ENOSYS;
6874
6875 ALOGV("%s in %p", __func__, in);
6876 pthread_mutex_lock(&adev->lock);
6877 if (in->usecase == USECASE_AUDIO_RECORD_MMAP && !in->standby &&
6878 !in->capture_started && in->pcm != NULL) {
6879 if (!in->capture_started) {
6880 ret = start_input_stream(in);
6881 if (ret == 0) {
6882 in->capture_started = true;
6883 }
6884 }
6885 }
6886 pthread_mutex_unlock(&adev->lock);
6887 return ret;
6888}
6889
Phil Burke0a86d12019-02-16 22:28:11 -08006890// Read offset for the positional timestamp from a persistent vendor property.
6891// This is to workaround apparent inaccuracies in the timing information that
6892// is used by the AAudio timing model. The inaccuracies can cause glitches.
6893static int64_t in_get_mmap_time_offset() {
6894 const int32_t kDefaultOffsetMicros = 0;
6895 int32_t mmap_time_offset_micros = property_get_int32(
Weiyin Jiangbd68b4d2019-05-17 16:29:50 +08006896 "persist.vendor.audio.in_mmap_delay_micros", kDefaultOffsetMicros);
Phil Burke0a86d12019-02-16 22:28:11 -08006897 ALOGI("mmap_time_offset_micros = %d for input", mmap_time_offset_micros);
6898 return mmap_time_offset_micros * (int64_t)1000;
6899}
6900
Haynes Mathew George16081042017-05-31 17:16:49 -07006901static int in_create_mmap_buffer(const struct audio_stream_in *stream,
6902 int32_t min_size_frames,
6903 struct audio_mmap_buffer_info *info)
6904{
6905 struct stream_in *in = (struct stream_in *)stream;
6906 struct audio_device *adev = in->dev;
6907 int ret = 0;
Aniket Kumar Lataf9f246e2017-09-15 15:20:16 -07006908 unsigned int offset1 = 0;
6909 unsigned int frames1 = 0;
Haynes Mathew George16081042017-05-31 17:16:49 -07006910 const char *step = "";
Arun Mirpuri5d170872019-03-26 13:21:31 -07006911 uint32_t mmap_size = 0;
6912 uint32_t buffer_size = 0;
Haynes Mathew George16081042017-05-31 17:16:49 -07006913
6914 pthread_mutex_lock(&adev->lock);
6915 ALOGV("%s in %p", __func__, in);
6916
Sharad Sanglec6f32552018-05-04 16:15:38 +05306917 if (CARD_STATUS_OFFLINE == in->card_status||
6918 CARD_STATUS_OFFLINE == adev->card_status) {
6919 ALOGW("in->card_status or adev->card_status offline, try again");
6920 ret = -EIO;
6921 goto exit;
6922 }
6923
Haynes Mathew George16081042017-05-31 17:16:49 -07006924 if (info == NULL || min_size_frames == 0) {
6925 ALOGE("%s invalid argument info %p min_size_frames %d", __func__, info, min_size_frames);
6926 ret = -EINVAL;
6927 goto exit;
6928 }
6929 if (in->usecase != USECASE_AUDIO_RECORD_MMAP || !in->standby) {
6930 ALOGE("%s: usecase = %d, standby = %d", __func__, in->usecase, in->standby);
6931 ALOGV("%s in %p", __func__, in);
6932 ret = -ENOSYS;
6933 goto exit;
6934 }
6935 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
6936 if (in->pcm_device_id < 0) {
6937 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
6938 __func__, in->pcm_device_id, in->usecase);
6939 ret = -EINVAL;
6940 goto exit;
6941 }
6942
6943 adjust_mmap_period_count(&in->config, min_size_frames);
6944
6945 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
6946 __func__, adev->snd_card, in->pcm_device_id, in->config.channels);
6947 in->pcm = pcm_open(adev->snd_card, in->pcm_device_id,
6948 (PCM_IN | PCM_MMAP | PCM_NOIRQ | PCM_MONOTONIC), &in->config);
Satish Babu Patakokila54ce83d2018-07-06 18:00:37 +05306949 if (errno == ENETRESET && !pcm_is_ready(in->pcm)) {
Sharad Sanglec6f32552018-05-04 16:15:38 +05306950 ALOGE("%s: pcm_open failed errno:%d\n", __func__, errno);
6951 in->card_status = CARD_STATUS_OFFLINE;
6952 adev->card_status = CARD_STATUS_OFFLINE;
6953 ret = -EIO;
6954 goto exit;
6955 }
6956
Haynes Mathew George16081042017-05-31 17:16:49 -07006957 if (in->pcm == NULL || !pcm_is_ready(in->pcm)) {
6958 step = "open";
6959 ret = -ENODEV;
6960 goto exit;
6961 }
6962
6963 ret = pcm_mmap_begin(in->pcm, &info->shared_memory_address, &offset1, &frames1);
6964 if (ret < 0) {
6965 step = "begin";
6966 goto exit;
6967 }
Haynes Mathew George16081042017-05-31 17:16:49 -07006968
Arun Mirpuri5d170872019-03-26 13:21:31 -07006969 info->buffer_size_frames = pcm_get_buffer_size(in->pcm);
6970 buffer_size = pcm_frames_to_bytes(in->pcm, info->buffer_size_frames);
6971 info->burst_size_frames = in->config.period_size;
6972 ret = platform_get_mmap_data_fd(adev->platform,
6973 in->pcm_device_id, 1 /*capture*/,
6974 &info->shared_memory_fd,
6975 &mmap_size);
6976 if (ret < 0) {
6977 // Fall back to non exclusive mode
6978 info->shared_memory_fd = pcm_get_poll_fd(in->pcm);
6979 } else {
6980 if (mmap_size < buffer_size) {
6981 step = "mmap";
6982 goto exit;
6983 }
6984 // FIXME: indicate exclusive mode support by returning a negative buffer size
6985 info->buffer_size_frames *= -1;
6986 }
6987
6988 memset(info->shared_memory_address, 0, buffer_size);
Haynes Mathew George16081042017-05-31 17:16:49 -07006989
6990 ret = pcm_mmap_commit(in->pcm, 0, MMAP_PERIOD_SIZE);
6991 if (ret < 0) {
6992 step = "commit";
6993 goto exit;
6994 }
6995
Phil Burke0a86d12019-02-16 22:28:11 -08006996 in->mmap_time_offset_nanos = in_get_mmap_time_offset();
6997
Haynes Mathew George16081042017-05-31 17:16:49 -07006998 in->standby = false;
6999 ret = 0;
7000
7001 ALOGV("%s: got mmap buffer address %p info->buffer_size_frames %d",
7002 __func__, info->shared_memory_address, info->buffer_size_frames);
7003
7004exit:
7005 if (ret != 0) {
7006 if (in->pcm == NULL) {
7007 ALOGE("%s: %s - %d", __func__, step, ret);
7008 } else {
7009 ALOGE("%s: %s %s", __func__, step, pcm_get_error(in->pcm));
7010 pcm_close(in->pcm);
7011 in->pcm = NULL;
7012 }
7013 }
7014 pthread_mutex_unlock(&adev->lock);
7015 return ret;
7016}
7017
7018static int in_get_mmap_position(const struct audio_stream_in *stream,
7019 struct audio_mmap_position *position)
7020{
7021 struct stream_in *in = (struct stream_in *)stream;
7022 ALOGVV("%s", __func__);
7023 if (position == NULL) {
7024 return -EINVAL;
7025 }
7026 if (in->usecase != USECASE_AUDIO_RECORD_MMAP) {
7027 return -ENOSYS;
7028 }
7029 if (in->pcm == NULL) {
7030 return -ENOSYS;
7031 }
7032 struct timespec ts = { 0, 0 };
7033 int ret = pcm_mmap_get_hw_ptr(in->pcm, (unsigned int *)&position->position_frames, &ts);
7034 if (ret < 0) {
7035 ALOGE("%s: %s", __func__, pcm_get_error(in->pcm));
7036 return ret;
7037 }
Phil Burke0a86d12019-02-16 22:28:11 -08007038 position->time_nanoseconds = ts.tv_sec*1000000000LL + ts.tv_nsec
7039 + in->mmap_time_offset_nanos;
Haynes Mathew George16081042017-05-31 17:16:49 -07007040 return 0;
7041}
7042
Naresh Tannirudcb47c52018-06-25 16:23:32 +05307043static int in_get_active_microphones(const struct audio_stream_in *stream,
7044 struct audio_microphone_characteristic_t *mic_array,
7045 size_t *mic_count) {
7046 struct stream_in *in = (struct stream_in *)stream;
7047 struct audio_device *adev = in->dev;
7048 ALOGVV("%s", __func__);
7049
7050 lock_input_stream(in);
7051 pthread_mutex_lock(&adev->lock);
7052 int ret = platform_get_active_microphones(adev->platform,
7053 audio_channel_count_from_in_mask(in->channel_mask),
7054 in->usecase, mic_array, mic_count);
7055 pthread_mutex_unlock(&adev->lock);
7056 pthread_mutex_unlock(&in->lock);
7057
7058 return ret;
7059}
7060
7061static int adev_get_microphones(const struct audio_hw_device *dev,
7062 struct audio_microphone_characteristic_t *mic_array,
7063 size_t *mic_count) {
7064 struct audio_device *adev = (struct audio_device *)dev;
7065 ALOGVV("%s", __func__);
7066
7067 pthread_mutex_lock(&adev->lock);
7068 int ret = platform_get_microphones(adev->platform, mic_array, mic_count);
7069 pthread_mutex_unlock(&adev->lock);
7070
7071 return ret;
7072}
juyuchendb308c22019-01-21 11:57:17 -07007073
7074static void in_update_sink_metadata(struct audio_stream_in *stream,
7075 const struct sink_metadata *sink_metadata) {
7076
7077 if (stream == NULL
7078 || sink_metadata == NULL
7079 || sink_metadata->tracks == NULL) {
7080 return;
7081 }
7082
7083 int error = 0;
7084 struct stream_in *in = (struct stream_in *)stream;
7085 struct audio_device *adev = in->dev;
7086 audio_devices_t device = AUDIO_DEVICE_NONE;
7087
7088 if (sink_metadata->track_count != 0)
7089 device = sink_metadata->tracks->dest_device;
7090
7091 lock_input_stream(in);
7092 pthread_mutex_lock(&adev->lock);
7093 ALOGV("%s: in->usecase: %d, device: %x", __func__, in->usecase, device);
7094
7095 if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY
7096 && device != AUDIO_DEVICE_NONE
7097 && adev->voice_tx_output != NULL) {
7098 /* Use the rx device from afe-proxy record to route voice call because
7099 there is no routing if tx device is on primary hal and rx device
7100 is on other hal during voice call. */
7101 adev->voice_tx_output->devices = device;
7102
7103 if (!voice_is_call_state_active(adev)) {
7104 if (adev->mode == AUDIO_MODE_IN_CALL) {
7105 adev->current_call_output = adev->voice_tx_output;
7106 error = voice_start_call(adev);
7107 if (error != 0)
7108 ALOGE("%s: start voice call failed %d", __func__, error);
7109 }
7110 } else {
7111 adev->current_call_output = adev->voice_tx_output;
7112 voice_update_devices_for_all_voice_usecases(adev);
7113 }
7114 }
7115
7116 pthread_mutex_unlock(&adev->lock);
7117 pthread_mutex_unlock(&in->lock);
7118}
7119
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05307120int adev_open_output_stream(struct audio_hw_device *dev,
Haynes Mathew George16081042017-05-31 17:16:49 -07007121 audio_io_handle_t handle,
7122 audio_devices_t devices,
7123 audio_output_flags_t flags,
7124 struct audio_config *config,
7125 struct audio_stream_out **stream_out,
Derek Chenf6318be2017-06-12 17:16:24 -04007126 const char *address)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007127{
7128 struct audio_device *adev = (struct audio_device *)dev;
7129 struct stream_out *out;
Gangadhar Sb0210342019-02-22 17:39:41 +05307130 int ret = 0, ip_hdlr_stream = 0, ip_hdlr_dev = 0;
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -07007131 audio_format_t format;
Ben Rombergerd771a7c2017-02-22 18:05:17 -08007132 struct adsp_hdlr_stream_cfg hdlr_stream_cfg;
Manish Dewangan21a850a2017-08-14 12:03:55 +05307133 bool is_direct_passthough = false;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07007134 bool is_hdmi = devices & AUDIO_DEVICE_OUT_AUX_DIGITAL;
7135 bool is_usb_dev = audio_is_usb_out_device(devices) &&
7136 (devices != AUDIO_DEVICE_OUT_USB_ACCESSORY);
7137 bool direct_dev = is_hdmi || is_usb_dev;
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08007138 bool use_db_as_primary =
vivek mehtaae1018c2019-05-09 12:19:57 -07007139 property_get_bool("vendor.audio.feature.deepbuffer_as_primary.enable",
7140 false);
Vignesh Kulothungana6927272019-02-20 15:17:07 -08007141 bool force_haptic_path =
7142 property_get_bool("vendor.audio.test_haptic", false);
Aniket Kumar Lata23d8cbf2019-04-10 19:54:46 -07007143 bool is_voip_rx = flags & AUDIO_OUTPUT_FLAG_VOIP_RX;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007144
kunleizdff872d2018-08-20 14:40:33 +08007145 if (is_usb_dev && (!audio_extn_usb_connected(NULL))) {
kunleizd6a9e0c2018-07-30 15:38:52 +08007146 is_usb_dev = false;
7147 devices = AUDIO_DEVICE_OUT_SPEAKER;
7148 ALOGW("%s: ignore set device to non existing USB card, use output device(%#x)",
7149 __func__, devices);
7150 }
7151
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007152 *stream_out = NULL;
Naresh Tanniru80659832014-06-04 18:17:56 +05307153
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007154 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
7155
Mingming Yin3a941d42016-02-17 18:08:05 -08007156 ALOGD("%s: enter: format(%#x) sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)\
Derek Chenf6318be2017-06-12 17:16:24 -04007157 stream_handle(%p) address(%s)", __func__, config->format, config->sample_rate, config->channel_mask,
7158 devices, flags, &out->stream, address);
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05307159
7160
Haynes Mathew Georgeb9012ab2013-12-10 13:44:56 -08007161 if (!out) {
7162 return -ENOMEM;
7163 }
7164
Haynes Mathew George204045b2015-02-25 20:32:03 -08007165 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07007166 pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL);
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05307167 pthread_mutex_init(&out->compr_mute_lock, (const pthread_mutexattr_t *) NULL);
Zhou Song48453a02018-01-10 17:50:59 +08007168 pthread_mutex_init(&out->position_query_lock, (const pthread_mutexattr_t *) NULL);
Haynes Mathew George204045b2015-02-25 20:32:03 -08007169 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
7170
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007171 if (devices == AUDIO_DEVICE_NONE)
7172 devices = AUDIO_DEVICE_OUT_SPEAKER;
7173
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007174 out->flags = flags;
7175 out->devices = devices;
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -07007176 out->dev = adev;
Aalique Grahame65780b52017-09-27 14:59:56 -07007177 out->hal_op_format = out->hal_ip_format = format = out->format = config->format;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007178 out->sample_rate = config->sample_rate;
Sachin Mohan Gadag3d09acd2017-06-19 12:43:44 +05307179 out->channel_mask = config->channel_mask;
Ramjee Singh5857aeb2017-08-03 19:18:50 +05307180 if (out->channel_mask == AUDIO_CHANNEL_NONE)
7181 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
7182 else
7183 out->supported_channel_masks[0] = out->channel_mask;
Eric Laurentc4aef752013-09-12 17:45:53 -07007184 out->handle = handle;
Mingming Yin3ee55c62014-08-04 14:23:35 -07007185 out->bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Alexy Josephaa54c872014-12-03 02:46:47 -08007186 out->non_blocking = 0;
Ashish Jain83a6cc22016-06-28 14:34:17 +05307187 out->convert_buffer = NULL;
Ashish Jain1b9b30c2017-05-18 20:57:40 +05307188 out->started = 0;
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05307189 out->a2dp_compress_mute = false;
Aniket Kumar Lata932f4872017-11-06 18:29:44 -08007190 out->hal_output_suspend_supported = 0;
7191 out->dynamic_pm_qos_config_supported = 0;
Surendar Karkaf51b5842018-04-26 11:28:38 +05307192 out->set_dual_mono = false;
Manisha Agarwal7b3e3772019-02-20 14:33:45 +05307193 out->prev_card_status_offline = false;
Dhanalakshmi Siddani20628c82019-01-27 17:31:09 +05307194 out->pspd_coeff_sent = false;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007195
Nikhil Laturkar26b690b2017-07-25 11:06:14 +05307196 if ((flags & AUDIO_OUTPUT_FLAG_BD) &&
Satish Babu Patakokila37e7c482018-02-02 11:50:06 +05307197 (property_get_bool("vendor.audio.matrix.limiter.enable", false)))
Ben Romberger6c4d3812017-06-13 17:46:45 -07007198 platform_set_device_params(out, DEVICE_PARAM_LIMITER_ID, 1);
7199
Aalique Grahame22e49102018-12-18 14:23:57 -08007200 if (direct_dev &&
7201 (audio_is_linear_pcm(out->format) ||
7202 config->format == AUDIO_FORMAT_DEFAULT) &&
7203 out->flags == AUDIO_OUTPUT_FLAG_NONE) {
7204 audio_format_t req_format = config->format;
7205 audio_channel_mask_t req_channel_mask = config->channel_mask;
7206 uint32_t req_sample_rate = config->sample_rate;
7207
7208 pthread_mutex_lock(&adev->lock);
7209 if (is_hdmi) {
7210 ALOGV("AUDIO_DEVICE_OUT_AUX_DIGITAL and DIRECT|OFFLOAD, check hdmi caps");
7211 ret = read_hdmi_sink_caps(out);
7212 if (config->sample_rate == 0)
7213 config->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
7214 if (config->channel_mask == AUDIO_CHANNEL_NONE)
7215 config->channel_mask = AUDIO_CHANNEL_OUT_5POINT1;
7216 if (config->format == AUDIO_FORMAT_DEFAULT)
7217 config->format = AUDIO_FORMAT_PCM_16_BIT;
7218 } else if (is_usb_dev) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07007219 ret = read_usb_sup_params_and_compare(true /*is_playback*/,
7220 &config->format,
7221 &out->supported_formats[0],
7222 MAX_SUPPORTED_FORMATS,
7223 &config->channel_mask,
7224 &out->supported_channel_masks[0],
7225 MAX_SUPPORTED_CHANNEL_MASKS,
7226 &config->sample_rate,
7227 &out->supported_sample_rates[0],
7228 MAX_SUPPORTED_SAMPLE_RATES);
7229 ALOGV("plugged dev USB ret %d", ret);
Haynes Mathew George484e8d22017-07-31 18:55:17 -07007230 }
Aalique Grahame22e49102018-12-18 14:23:57 -08007231
Haynes Mathew George484e8d22017-07-31 18:55:17 -07007232 pthread_mutex_unlock(&adev->lock);
7233 if (ret != 0) {
Mingming Yin3a941d42016-02-17 18:08:05 -08007234 if (ret == -ENOSYS) {
7235 /* ignore and go with default */
7236 ret = 0;
Aalique Grahame22e49102018-12-18 14:23:57 -08007237 }
7238 // For MMAP NO IRQ, allow conversions in ADSP
7239 else if (is_hdmi || (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0)
7240 goto error_open;
7241 else {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07007242 ALOGE("error reading direct dev sink caps");
Mingming Yin3a941d42016-02-17 18:08:05 -08007243 goto error_open;
7244 }
Aalique Grahame22e49102018-12-18 14:23:57 -08007245
7246 if (req_sample_rate != 0 && config->sample_rate != req_sample_rate)
7247 config->sample_rate = req_sample_rate;
7248 if (req_channel_mask != AUDIO_CHANNEL_NONE && config->channel_mask != req_channel_mask)
7249 config->channel_mask = req_channel_mask;
7250 if (req_format != AUDIO_FORMAT_DEFAULT && config->format != req_format)
7251 config->format = req_format;
Mingming Yin3a941d42016-02-17 18:08:05 -08007252 }
Aalique Grahame22e49102018-12-18 14:23:57 -08007253
7254 out->sample_rate = config->sample_rate;
7255 out->channel_mask = config->channel_mask;
7256 out->format = config->format;
7257 if (is_hdmi) {
7258 out->usecase = USECASE_AUDIO_PLAYBACK_HIFI;
7259 out->config = pcm_config_hdmi_multi;
7260 } else if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
7261 out->usecase = USECASE_AUDIO_PLAYBACK_MMAP;
7262 out->config = pcm_config_mmap_playback;
7263 out->stream.start = out_start;
7264 out->stream.stop = out_stop;
7265 out->stream.create_mmap_buffer = out_create_mmap_buffer;
7266 out->stream.get_mmap_position = out_get_mmap_position;
7267 } else {
7268 out->usecase = USECASE_AUDIO_PLAYBACK_HIFI;
7269 out->config = pcm_config_hifi;
7270 }
7271
7272 out->config.rate = out->sample_rate;
7273 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
7274 if (is_hdmi) {
7275 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels *
7276 audio_bytes_per_sample(out->format));
7277 }
7278 out->config.format = pcm_format_from_audio_format(out->format);
Mingming Yin3a941d42016-02-17 18:08:05 -08007279 }
7280
Derek Chenf6318be2017-06-12 17:16:24 -04007281 /* validate bus device address */
7282 if (out->devices & AUDIO_DEVICE_OUT_BUS) {
7283 /* extract car audio stream index */
7284 out->car_audio_stream =
7285 audio_extn_auto_hal_get_car_audio_stream_from_address(address);
7286 if (out->car_audio_stream < 0) {
7287 ALOGE("%s: invalid car audio stream %x",
7288 __func__, out->car_audio_stream);
7289 ret = -EINVAL;
7290 goto error_open;
7291 }
7292 /* save car audio stream and address for bus device */
7293 strlcpy(out->address, address, AUDIO_DEVICE_MAX_ADDRESS_LEN);
7294 ALOGV("%s: address %s, car_audio_stream %x",
7295 __func__, out->address, out->car_audio_stream);
7296 }
7297
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08007298 /* Check for VOIP usecase */
Aniket Kumar Lata23d8cbf2019-04-10 19:54:46 -07007299 if (is_voip_rx) {
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08007300 if (!voice_extn_is_compress_voip_supported()) {
7301 if (out->sample_rate == 8000 || out->sample_rate == 16000 ||
7302 out->sample_rate == 32000 || out->sample_rate == 48000) {
Aniket Kumar Lata4f9a2a52019-05-09 18:44:09 -07007303 out->channel_mask = audio_extn_utils_is_vendor_enhanced_fwk() ?
7304 AUDIO_CHANNEL_OUT_MONO : AUDIO_CHANNEL_OUT_STEREO;
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08007305 out->usecase = USECASE_AUDIO_PLAYBACK_VOIP;
7306 out->format = AUDIO_FORMAT_PCM_16_BIT;
Aniket Kumar Lata8426d1f2019-06-10 15:25:53 -07007307 out->volume_l = INVALID_OUT_VOLUME;
7308 out->volume_r = INVALID_OUT_VOLUME;
Vikram Panduranga93f080e2017-06-07 18:16:14 -07007309
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08007310 out->config = default_pcm_config_voip_copp;
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08007311 out->config.rate = out->sample_rate;
Aniket Kumar Lata1e344f22019-06-19 17:09:01 -07007312 uint32_t channel_count =
7313 audio_channel_count_from_out_mask(out->channel_mask);
7314 uint32_t buffer_size = get_stream_buffer_size(DEFAULT_VOIP_BUF_DURATION_MS,
7315 out->sample_rate, out->format,
7316 channel_count, false);
7317 uint32_t frame_size = audio_bytes_per_sample(out->format) * channel_count;
7318 if (frame_size != 0)
7319 out->config.period_size = buffer_size / frame_size;
7320 else
7321 ALOGW("%s: frame size is 0 for format %#x", __func__, out->format);
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08007322 }
7323 } else {
7324 if ((out->dev->mode == AUDIO_MODE_IN_COMMUNICATION ||
7325 voice_extn_compress_voip_is_active(out->dev)) &&
7326 (voice_extn_compress_voip_is_config_supported(config))) {
7327 ret = voice_extn_compress_voip_open_output_stream(out);
7328 if (ret != 0) {
7329 ALOGE("%s: Compress voip output cannot be opened, error:%d",
7330 __func__, ret);
7331 goto error_open;
7332 }
7333 }
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08007334 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07007335 } else if (audio_is_linear_pcm(out->format) &&
7336 out->flags == AUDIO_OUTPUT_FLAG_NONE && is_usb_dev) {
7337 out->channel_mask = config->channel_mask;
7338 out->sample_rate = config->sample_rate;
7339 out->format = config->format;
7340 out->usecase = USECASE_AUDIO_PLAYBACK_HIFI;
7341 // does this change?
7342 out->config = is_hdmi ? pcm_config_hdmi_multi : pcm_config_hifi;
7343 out->config.rate = config->sample_rate;
7344 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
7345 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels *
7346 audio_bytes_per_sample(config->format));
7347 out->config.format = pcm_format_from_audio_format(out->format);
vivek mehta0ea887a2015-08-26 14:01:20 -07007348 } else if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) ||
Dhananjay Kumarac341582017-02-23 23:42:25 +05307349 (out->flags == AUDIO_OUTPUT_FLAG_DIRECT)) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05307350 pthread_mutex_lock(&adev->lock);
7351 bool offline = (adev->card_status == CARD_STATUS_OFFLINE);
7352 pthread_mutex_unlock(&adev->lock);
7353
7354 // reject offload during card offline to allow
7355 // fallback to s/w paths
7356 if (offline) {
7357 ret = -ENODEV;
7358 goto error_open;
7359 }
vivek mehta0ea887a2015-08-26 14:01:20 -07007360
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007361 if (config->offload_info.version != AUDIO_INFO_INITIALIZER.version ||
7362 config->offload_info.size != AUDIO_INFO_INITIALIZER.size) {
7363 ALOGE("%s: Unsupported Offload information", __func__);
7364 ret = -EINVAL;
7365 goto error_open;
7366 }
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07007367
Atul Khare3fa6e542017-08-09 00:56:17 +05307368 if (config->offload_info.format == 0)
7369 config->offload_info.format = config->format;
7370 if (config->offload_info.sample_rate == 0)
7371 config->offload_info.sample_rate = config->sample_rate;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07007372
Mingming Yin90310102013-11-13 16:57:00 -08007373 if (!is_supported_format(config->offload_info.format) &&
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05307374 !audio_extn_passthru_is_supported_format(config->offload_info.format)) {
vivek mehta0ea887a2015-08-26 14:01:20 -07007375 ALOGE("%s: Unsupported audio format %x " , __func__, config->offload_info.format);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007376 ret = -EINVAL;
7377 goto error_open;
7378 }
7379
Ben Romberger0f8c87b2017-05-24 17:41:11 -07007380 /* TrueHD only supported for 48k multiples (48k, 96k, 192k) */
7381 if ((config->offload_info.format == AUDIO_FORMAT_DOLBY_TRUEHD) &&
7382 (audio_extn_passthru_is_passthrough_stream(out)) &&
7383 !((config->sample_rate == 48000) ||
7384 (config->sample_rate == 96000) ||
7385 (config->sample_rate == 192000))) {
7386 ALOGE("%s: Unsupported sample rate %d for audio format %x",
7387 __func__, config->sample_rate, config->offload_info.format);
7388 ret = -EINVAL;
7389 goto error_open;
7390 }
7391
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007392 out->compr_config.codec = (struct snd_codec *)
7393 calloc(1, sizeof(struct snd_codec));
7394
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07007395 if (!out->compr_config.codec) {
7396 ret = -ENOMEM;
7397 goto error_open;
7398 }
7399
Dhananjay Kumarac341582017-02-23 23:42:25 +05307400 out->stream.pause = out_pause;
7401 out->stream.resume = out_resume;
7402 out->stream.flush = out_flush;
Ashish Jain4847e9d2017-08-17 19:16:57 +05307403 out->stream.set_callback = out_set_callback;
Dhananjay Kumarac341582017-02-23 23:42:25 +05307404 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Mingming Yin21d60472015-09-30 13:56:25 -07007405 out->stream.drain = out_drain;
Dhananjay Kumarac341582017-02-23 23:42:25 +05307406 out->usecase = get_offload_usecase(adev, true /* is_compress */);
vivek mehta446c3962015-09-14 10:57:35 -07007407 ALOGV("Compress Offload usecase .. usecase selected %d", out->usecase);
Dhananjay Kumarac341582017-02-23 23:42:25 +05307408 } else {
7409 out->usecase = get_offload_usecase(adev, false /* is_compress */);
7410 ALOGV("non-offload DIRECT_usecase ... usecase selected %d ", out->usecase);
vivek mehta0ea887a2015-08-26 14:01:20 -07007411 }
vivek mehta446c3962015-09-14 10:57:35 -07007412
Deeraj Somanfa377bf2019-02-06 12:57:59 +05307413 if (out->flags & AUDIO_OUTPUT_FLAG_FAST) {
7414 ALOGD("%s: Setting latency mode to true", __func__);
7415 out->compr_config.codec->flags |= audio_extn_utils_get_perf_mode_flag();
7416 }
7417
vivek mehta446c3962015-09-14 10:57:35 -07007418 if (out->usecase == USECASE_INVALID) {
Mingming Yin3a941d42016-02-17 18:08:05 -08007419 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL &&
7420 config->format == 0 && config->sample_rate == 0 &&
7421 config->channel_mask == 0) {
Mingming Yin21854652016-04-13 11:54:02 -07007422 ALOGI("%s dummy open to query sink capability",__func__);
Mingming Yin3a941d42016-02-17 18:08:05 -08007423 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
7424 } else {
7425 ALOGE("%s, Max allowed OFFLOAD usecase reached ... ", __func__);
7426 ret = -EEXIST;
7427 goto error_open;
7428 }
vivek mehta446c3962015-09-14 10:57:35 -07007429 }
7430
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007431 if (config->offload_info.channel_mask)
7432 out->channel_mask = config->offload_info.channel_mask;
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -08007433 else if (config->channel_mask) {
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007434 out->channel_mask = config->channel_mask;
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -08007435 config->offload_info.channel_mask = config->channel_mask;
Haynes Mathew Georgea99f7532016-08-24 16:01:21 -07007436 } else {
Dhananjay Kumarac341582017-02-23 23:42:25 +05307437 ALOGE("out->channel_mask not set for OFFLOAD/DIRECT usecase");
Haynes Mathew Georgea99f7532016-08-24 16:01:21 -07007438 ret = -EINVAL;
7439 goto error_open;
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -08007440 }
Haynes Mathew Georgea99f7532016-08-24 16:01:21 -07007441
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -07007442 format = out->format = config->offload_info.format;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007443 out->sample_rate = config->offload_info.sample_rate;
7444
Mingming Yin3ee55c62014-08-04 14:23:35 -07007445 out->bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007446
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05307447 out->compr_config.codec->id = get_snd_codec_id(config->offload_info.format);
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05307448 if (audio_extn_utils_is_dolby_format(config->offload_info.format)) {
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05307449 audio_extn_dolby_send_ddp_endp_params(adev);
7450 audio_extn_dolby_set_dmid(adev);
7451 }
vivek mehta0ea887a2015-08-26 14:01:20 -07007452
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007453 out->compr_config.codec->sample_rate =
Ravi Kumar Alamandab91bff32014-11-14 12:05:54 -08007454 config->offload_info.sample_rate;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007455 out->compr_config.codec->bit_rate =
7456 config->offload_info.bit_rate;
7457 out->compr_config.codec->ch_in =
Dhanalakshmi Siddania15c6792016-08-10 15:33:53 +05307458 audio_channel_count_from_out_mask(out->channel_mask);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007459 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
Satish Babu Patakokilaa395a9e2016-11-01 12:18:49 +05307460 /* Update bit width only for non passthrough usecases.
7461 * For passthrough usecases, the output will always be opened @16 bit
7462 */
7463 if (!audio_extn_passthru_is_passthrough_stream(out))
7464 out->bit_width = AUDIO_OUTPUT_BIT_WIDTH;
Naresh Tanniruee3499a2017-01-05 14:05:35 +05307465
7466 if (out->flags & AUDIO_OUTPUT_FLAG_TIMESTAMP)
7467 out->compr_config.codec->flags |= COMPRESSED_TIMESTAMP_FLAG;
7468 ALOGVV("%s : out->compr_config.codec->flags -> (%#x) ", __func__, out->compr_config.codec->flags);
7469
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07007470 /*TODO: Do we need to change it for passthrough */
7471 out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_RAW;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007472
Manish Dewangana6fc5442015-08-24 20:30:31 +05307473 if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC)
7474 out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_RAW;
Arun Kumar Dasari3b174182016-12-27 13:01:14 +05307475 else if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC_ADTS)
Manish Dewangana6fc5442015-08-24 20:30:31 +05307476 out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_MP4ADTS;
Arun Kumar Dasari3b174182016-12-27 13:01:14 +05307477 else if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC_LATM)
7478 out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_MP4LATM;
Ashish Jainf1eaa582016-05-23 20:54:24 +05307479
7480 if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) ==
7481 AUDIO_FORMAT_PCM) {
7482
7483 /*Based on platform support, configure appropriate alsa format for corresponding
7484 *hal input format.
7485 */
7486 out->compr_config.codec->format = hal_format_to_alsa(
7487 config->offload_info.format);
7488
Ashish Jain83a6cc22016-06-28 14:34:17 +05307489 out->hal_op_format = alsa_format_to_hal(
Ashish Jainf1eaa582016-05-23 20:54:24 +05307490 out->compr_config.codec->format);
Ashish Jain83a6cc22016-06-28 14:34:17 +05307491 out->hal_ip_format = out->format;
Ashish Jainf1eaa582016-05-23 20:54:24 +05307492
Dhananjay Kumarac341582017-02-23 23:42:25 +05307493 /*for direct non-compress playback populate bit_width based on selected alsa format as
Ashish Jainf1eaa582016-05-23 20:54:24 +05307494 *hal input format and alsa format might differ based on platform support.
7495 */
7496 out->bit_width = audio_bytes_per_sample(
Ashish Jain83a6cc22016-06-28 14:34:17 +05307497 out->hal_op_format) << 3;
Ashish Jainf1eaa582016-05-23 20:54:24 +05307498
7499 out->compr_config.fragments = DIRECT_PCM_NUM_FRAGMENTS;
7500
Deeraj Soman65358ab2019-02-07 15:40:49 +05307501 if ((config->offload_info.duration_us >= MIN_OFFLOAD_BUFFER_DURATION_MS * 1000) &&
7502 (config->offload_info.duration_us <= MAX_OFFLOAD_BUFFER_DURATION_MS * 1000))
7503 out->info.duration_us = (int64_t)config->offload_info.duration_us;
7504
Ashish Jainf1eaa582016-05-23 20:54:24 +05307505 /* Check if alsa session is configured with the same format as HAL input format,
7506 * if not then derive correct fragment size needed to accomodate the
7507 * conversion of HAL input format to alsa format.
7508 */
7509 audio_extn_utils_update_direct_pcm_fragment_size(out);
7510
7511 /*if hal input and output fragment size is different this indicates HAL input format is
7512 *not same as the alsa format
7513 */
Ashish Jain83a6cc22016-06-28 14:34:17 +05307514 if (out->hal_fragment_size != out->compr_config.fragment_size) {
Ashish Jainf1eaa582016-05-23 20:54:24 +05307515 /*Allocate a buffer to convert input data to the alsa configured format.
7516 *size of convert buffer is equal to the size required to hold one fragment size
7517 *worth of pcm data, this is because flinger does not write more than fragment_size
7518 */
Ashish Jain83a6cc22016-06-28 14:34:17 +05307519 out->convert_buffer = calloc(1,out->compr_config.fragment_size);
7520 if (out->convert_buffer == NULL){
Ashish Jainf1eaa582016-05-23 20:54:24 +05307521 ALOGE("Allocation failed for convert buffer for size %d", out->compr_config.fragment_size);
7522 ret = -ENOMEM;
7523 goto error_open;
7524 }
7525 }
7526 } else if (audio_extn_passthru_is_passthrough_stream(out)) {
7527 out->compr_config.fragment_size =
7528 audio_extn_passthru_get_buffer_size(&config->offload_info);
7529 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
7530 } else {
7531 out->compr_config.fragment_size =
7532 platform_get_compress_offload_buffer_size(&config->offload_info);
7533 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
7534 }
Mingming Yin3ee55c62014-08-04 14:23:35 -07007535
Naresh Tanniruee3499a2017-01-05 14:05:35 +05307536 if (out->flags & AUDIO_OUTPUT_FLAG_TIMESTAMP) {
7537 out->compr_config.fragment_size += sizeof(struct snd_codec_metadata);
7538 }
Amit Shekhar6f461b12014-08-01 14:52:58 -07007539 if (config->offload_info.format == AUDIO_FORMAT_FLAC)
Satya Krishna Pindiproli5d82d012015-08-12 18:21:25 +05307540 out->compr_config.codec->options.flac_dec.sample_size = AUDIO_OUTPUT_BIT_WIDTH;
Mingming Yin3ee55c62014-08-04 14:23:35 -07007541
Dhanalakshmi Siddani18737932016-11-29 17:33:17 +05307542 if (config->offload_info.format == AUDIO_FORMAT_APTX) {
7543 audio_extn_send_aptx_dec_bt_addr_to_dsp(out);
7544 }
7545
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007546 if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING)
7547 out->non_blocking = 1;
Haynes Mathew George352f27b2013-07-26 00:00:15 -07007548
Manish Dewangan69426c82017-01-30 17:35:36 +05307549 if ((flags & AUDIO_OUTPUT_FLAG_TIMESTAMP) &&
7550 (flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC)) {
7551 out->render_mode = RENDER_MODE_AUDIO_STC_MASTER;
7552 } else if(flags & AUDIO_OUTPUT_FLAG_TIMESTAMP) {
7553 out->render_mode = RENDER_MODE_AUDIO_MASTER;
7554 } else {
7555 out->render_mode = RENDER_MODE_AUDIO_NO_TIMESTAMP;
7556 }
Alexy Josephaa54c872014-12-03 02:46:47 -08007557
Naresh Tanniru29bce4e2017-04-27 17:54:30 +05307558 memset(&out->channel_map_param, 0,
7559 sizeof(struct audio_out_channel_map_param));
7560
Haynes Mathew George352f27b2013-07-26 00:00:15 -07007561 out->send_new_metadata = 1;
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05307562 out->send_next_track_params = false;
7563 out->is_compr_metadata_avail = false;
Haynes Mathew Georgeb9012ab2013-12-10 13:44:56 -08007564 out->offload_state = OFFLOAD_STATE_IDLE;
7565 out->playback_started = 0;
Zhou Song48453a02018-01-10 17:50:59 +08007566 out->writeAt.tv_sec = 0;
7567 out->writeAt.tv_nsec = 0;
Haynes Mathew Georgeb9012ab2013-12-10 13:44:56 -08007568
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08007569 audio_extn_dts_create_state_notifier_node(out->usecase);
7570
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007571 ALOGV("%s: offloaded output offload_info version %04x bit rate %d",
7572 __func__, config->offload_info.version,
7573 config->offload_info.bit_rate);
Ashish Jain5106d362016-05-11 19:23:33 +05307574
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05307575 /* Check if DSD audio format is supported in codec
7576 * and there is no active native DSD use case
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05307577 */
7578
7579 if ((config->format == AUDIO_FORMAT_DSD) &&
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05307580 (!platform_check_codec_dsd_support(adev->platform) ||
7581 audio_is_dsd_native_stream_active(adev))) {
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05307582 ret = -EINVAL;
7583 goto error_open;
7584 }
7585
Ashish Jain5106d362016-05-11 19:23:33 +05307586 /* Disable gapless if any of the following is true
7587 * passthrough playback
7588 * AV playback
Dhananjay Kumarac341582017-02-23 23:42:25 +05307589 * non compressed Direct playback
Ashish Jain5106d362016-05-11 19:23:33 +05307590 */
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05307591 if (audio_extn_passthru_is_passthrough_stream(out) ||
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05307592 (config->format == AUDIO_FORMAT_DSD) ||
Naresh Tanniru928f0862017-04-07 16:44:23 -07007593 (config->format == AUDIO_FORMAT_IEC61937) ||
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05307594 config->offload_info.has_video ||
Dhananjay Kumarac341582017-02-23 23:42:25 +05307595 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Ashish Jain5106d362016-05-11 19:23:33 +05307596 check_and_set_gapless_mode(adev, false);
7597 } else
7598 check_and_set_gapless_mode(adev, true);
Mingming Yin21854652016-04-13 11:54:02 -07007599
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05307600 if (audio_extn_passthru_is_passthrough_stream(out)) {
Mingming Yin21854652016-04-13 11:54:02 -07007601 out->flags |= AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH;
7602 }
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05307603 if (config->format == AUDIO_FORMAT_DSD) {
7604 out->flags |= AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH;
7605 out->compr_config.codec->compr_passthr = PASSTHROUGH_DSD;
7606 }
Aalique Grahame0359a1f2016-09-08 16:54:22 -07007607
7608 create_offload_callback_thread(out);
7609
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -07007610 } else if (out->flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) {
Arun Mirpuri7da752a2018-09-11 18:01:15 -07007611 switch (config->sample_rate) {
7612 case 0:
7613 out->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
7614 break;
7615 case 8000:
7616 case 16000:
7617 case 48000:
7618 out->sample_rate = config->sample_rate;
7619 break;
7620 default:
7621 ALOGE("%s: Unsupported sampling rate %d for Incall Music", __func__,
7622 config->sample_rate);
7623 config->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
7624 ret = -EINVAL;
7625 goto error_open;
7626 }
7627 //FIXME: add support for MONO stream configuration when audioflinger mixer supports it
7628 switch (config->channel_mask) {
7629 case AUDIO_CHANNEL_NONE:
7630 case AUDIO_CHANNEL_OUT_STEREO:
7631 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
7632 break;
7633 default:
7634 ALOGE("%s: Unsupported channel mask %#x for Incall Music", __func__,
7635 config->channel_mask);
7636 config->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
7637 ret = -EINVAL;
7638 goto error_open;
7639 }
7640 switch (config->format) {
7641 case AUDIO_FORMAT_DEFAULT:
7642 case AUDIO_FORMAT_PCM_16_BIT:
7643 out->format = AUDIO_FORMAT_PCM_16_BIT;
7644 break;
7645 default:
7646 ALOGE("%s: Unsupported format %#x for Incall Music", __func__,
7647 config->format);
7648 config->format = AUDIO_FORMAT_PCM_16_BIT;
7649 ret = -EINVAL;
7650 goto error_open;
7651 }
7652
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05307653 ret = voice_extn_check_and_set_incall_music_usecase(adev, out);
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -07007654 if (ret != 0) {
7655 ALOGE("%s: Incall music delivery usecase cannot be set error:%d",
Arun Mirpuri7da752a2018-09-11 18:01:15 -07007656 __func__, ret);
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -07007657 goto error_open;
7658 }
Arun Mirpuri7da752a2018-09-11 18:01:15 -07007659 } else if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) {
Aalique Grahame22e49102018-12-18 14:23:57 -08007660 switch (config->sample_rate) {
7661 case 0:
7662 out->sample_rate = AFE_PROXY_SAMPLING_RATE;
7663 break;
7664 case 8000:
7665 case 16000:
7666 case 48000:
7667 out->sample_rate = config->sample_rate;
7668 break;
7669 default:
7670 ALOGE("%s: Unsupported sampling rate %d for Telephony TX", __func__,
7671 config->sample_rate);
7672 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
7673 ret = -EINVAL;
7674 break;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07007675 }
Aalique Grahame22e49102018-12-18 14:23:57 -08007676 //FIXME: add support for MONO stream configuration when audioflinger mixer supports it
7677 switch (config->channel_mask) {
7678 case AUDIO_CHANNEL_NONE:
7679 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
7680 break;
7681 case AUDIO_CHANNEL_OUT_STEREO:
7682 out->channel_mask = config->channel_mask;
7683 break;
7684 default:
7685 ALOGE("%s: Unsupported channel mask %#x for Telephony TX", __func__,
7686 config->channel_mask);
7687 config->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
7688 ret = -EINVAL;
7689 break;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07007690 }
Aalique Grahame22e49102018-12-18 14:23:57 -08007691 switch (config->format) {
7692 case AUDIO_FORMAT_DEFAULT:
7693 out->format = AUDIO_FORMAT_PCM_16_BIT;
7694 break;
7695 case AUDIO_FORMAT_PCM_16_BIT:
7696 out->format = config->format;
7697 break;
7698 default:
7699 ALOGE("%s: Unsupported format %#x for Telephony TX", __func__,
7700 config->format);
7701 config->format = AUDIO_FORMAT_PCM_16_BIT;
7702 ret = -EINVAL;
7703 break;
7704 }
7705 if (ret != 0)
7706 goto error_open;
7707
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07007708 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
7709 out->config = pcm_config_afe_proxy_playback;
Aalique Grahame22e49102018-12-18 14:23:57 -08007710 out->config.rate = out->sample_rate;
7711 out->config.channels =
7712 audio_channel_count_from_out_mask(out->channel_mask);
7713 out->config.format = pcm_format_from_audio_format(out->format);
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07007714 adev->voice_tx_output = out;
Ravi Kumar Alamanda8f715d92013-11-01 20:37:38 -07007715 } else {
Ashish Jain058165c2016-09-28 23:18:48 +05307716 unsigned int channels = 0;
7717 /*Update config params to default if not set by the caller*/
7718 if (config->sample_rate == 0)
7719 config->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
7720 if (config->channel_mask == AUDIO_CHANNEL_NONE)
7721 config->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
7722 if (config->format == AUDIO_FORMAT_DEFAULT)
7723 config->format = AUDIO_FORMAT_PCM_16_BIT;
7724
7725 channels = audio_channel_count_from_out_mask(out->channel_mask);
7726
Varun Balaraje49253e2017-07-06 19:48:56 +05307727 if (out->flags & AUDIO_OUTPUT_FLAG_INTERACTIVE) {
7728 out->usecase = get_interactive_usecase(adev);
7729 out->config = pcm_config_low_latency;
7730 } else if (out->flags & AUDIO_OUTPUT_FLAG_RAW) {
Ashish Jain83a6cc22016-06-28 14:34:17 +05307731 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
Haynes Mathew George5beddd42016-06-27 18:33:40 -07007732 out->realtime = may_use_noirq_mode(adev, USECASE_AUDIO_PLAYBACK_ULL,
7733 out->flags);
7734 out->config = out->realtime ? pcm_config_rt : pcm_config_low_latency;
Haynes Mathew George16081042017-05-31 17:16:49 -07007735 } else if (out->flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
7736 out->usecase = USECASE_AUDIO_PLAYBACK_MMAP;
7737 out->config = pcm_config_mmap_playback;
7738 out->stream.start = out_start;
7739 out->stream.stop = out_stop;
7740 out->stream.create_mmap_buffer = out_create_mmap_buffer;
7741 out->stream.get_mmap_position = out_get_mmap_position;
Ashish Jain83a6cc22016-06-28 14:34:17 +05307742 } else if (out->flags & AUDIO_OUTPUT_FLAG_FAST) {
7743 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
Aniket Kumar Lata932f4872017-11-06 18:29:44 -08007744 out->hal_output_suspend_supported =
7745 property_get_bool("vendor.audio.hal.output.suspend.supported", false);
7746 out->dynamic_pm_qos_config_supported =
7747 property_get_bool("vendor.audio.hal.dynamic.qos.config.supported", false);
7748 if (!out->dynamic_pm_qos_config_supported) {
Alexy Joseph98988832017-01-13 14:56:59 -08007749 ALOGI("%s: dynamic qos voting not enabled for platform", __func__);
7750 } else {
7751 ALOGI("%s: dynamic qos voting enabled for platform", __func__);
7752 //the mixer path will be a string similar to "low-latency-playback resume"
7753 strlcpy(out->pm_qos_mixer_path, use_case_table[out->usecase], MAX_MIXER_PATH_LEN);
7754 strlcat(out->pm_qos_mixer_path,
7755 " resume", MAX_MIXER_PATH_LEN);
7756 ALOGI("%s: created %s pm_qos_mixer_path" , __func__,
7757 out->pm_qos_mixer_path);
7758 }
Ashish Jain83a6cc22016-06-28 14:34:17 +05307759 out->config = pcm_config_low_latency;
7760 } else if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
7761 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
7762 out->config = pcm_config_deep_buffer;
Ashish Jain058165c2016-09-28 23:18:48 +05307763 out->config.period_size = get_output_period_size(config->sample_rate, out->format,
7764 channels, DEEP_BUFFER_OUTPUT_PERIOD_DURATION);
7765 if (out->config.period_size <= 0) {
7766 ALOGE("Invalid configuration period size is not valid");
7767 ret = -EINVAL;
7768 goto error_open;
7769 }
Aalique Grahame22e49102018-12-18 14:23:57 -08007770 } else if (flags & AUDIO_OUTPUT_FLAG_TTS) {
7771 out->usecase = USECASE_AUDIO_PLAYBACK_TTS;
7772 out->config = pcm_config_deep_buffer;
Vignesh Kulothungana6927272019-02-20 15:17:07 -08007773 } else if (config->channel_mask & AUDIO_CHANNEL_HAPTIC_ALL) {
7774 out->usecase = USECASE_AUDIO_PLAYBACK_WITH_HAPTICS;
7775 out->config = pcm_config_haptics_audio;
7776 if (force_haptic_path)
7777 adev->haptics_config = pcm_config_haptics_audio;
7778 else
7779 adev->haptics_config = pcm_config_haptics;
7780
7781 out->config.channels =
7782 audio_channel_count_from_out_mask(out->channel_mask & ~AUDIO_CHANNEL_HAPTIC_ALL);
7783
7784 if (force_haptic_path) {
7785 out->config.channels = 1;
7786 adev->haptics_config.channels = 1;
7787 } else
7788 adev->haptics_config.channels = audio_channel_count_from_out_mask(out->channel_mask & AUDIO_CHANNEL_HAPTIC_ALL);
Derek Chenf6318be2017-06-12 17:16:24 -04007789 } else if (out->devices & AUDIO_DEVICE_OUT_BUS) {
7790 ret = audio_extn_auto_hal_open_output_stream(out);
7791 if (ret) {
7792 ALOGE("%s: Failed to open output stream for bus device", __func__);
7793 ret = -EINVAL;
7794 goto error_open;
7795 }
Ashish Jain83a6cc22016-06-28 14:34:17 +05307796 } else {
7797 /* primary path is the default path selected if no other outputs are available/suitable */
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08007798 out->usecase = GET_USECASE_AUDIO_PLAYBACK_PRIMARY(use_db_as_primary);
7799 out->config = GET_PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY(use_db_as_primary);
Ashish Jain83a6cc22016-06-28 14:34:17 +05307800 }
7801 out->hal_ip_format = format = out->format;
7802 out->config.format = hal_format_to_pcm(out->hal_ip_format);
7803 out->hal_op_format = pcm_format_to_hal(out->config.format);
7804 out->bit_width = format_to_bitwidth_table[out->hal_op_format] << 3;
7805 out->config.rate = config->sample_rate;
Ravi Kumar Alamanda8f715d92013-11-01 20:37:38 -07007806 out->sample_rate = out->config.rate;
Ashish Jain058165c2016-09-28 23:18:48 +05307807 out->config.channels = channels;
Ashish Jain83a6cc22016-06-28 14:34:17 +05307808 if (out->hal_ip_format != out->hal_op_format) {
7809 uint32_t buffer_size = out->config.period_size *
7810 format_to_bitwidth_table[out->hal_op_format] *
7811 out->config.channels;
7812 out->convert_buffer = calloc(1, buffer_size);
7813 if (out->convert_buffer == NULL){
7814 ALOGE("Allocation failed for convert buffer for size %d",
7815 out->compr_config.fragment_size);
7816 ret = -ENOMEM;
7817 goto error_open;
7818 }
7819 ALOGD("Convert buffer allocated of size %d", buffer_size);
7820 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007821 }
7822
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08007823 ALOGV("%s devices:%d, format:%x, out->sample_rate:%d,out->bit_width:%d out->format:%d out->flags:%x, flags: %x usecase %d",
7824 __func__, devices, format, out->sample_rate, out->bit_width, out->format, out->flags, flags, out->usecase);
Ashish Jain83a6cc22016-06-28 14:34:17 +05307825
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07007826 /* TODO remove this hardcoding and check why width is zero*/
7827 if (out->bit_width == 0)
7828 out->bit_width = 16;
Dhananjay Kumard6d32152016-10-13 16:11:03 +05307829 audio_extn_utils_update_stream_output_app_type_cfg(adev->platform,
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -07007830 &adev->streams_output_cfg_list,
Aalique Grahame65780b52017-09-27 14:59:56 -07007831 devices, out->flags, out->hal_op_format, out->sample_rate,
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05307832 out->bit_width, out->channel_mask, out->profile,
Manish Dewangan837dc462015-05-27 10:17:41 +05307833 &out->app_type_cfg);
Aalique Grahame6e763712019-01-31 16:18:17 -08007834 if ((out->usecase == (audio_usecase_t)(GET_USECASE_AUDIO_PLAYBACK_PRIMARY(use_db_as_primary))) ||
Haynes Mathew Georgebf143712013-12-03 13:02:53 -08007835 (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
7836 /* Ensure the default output is not selected twice */
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08007837 if(adev->primary_output == NULL)
7838 adev->primary_output = out;
7839 else {
7840 ALOGE("%s: Primary output is already opened", __func__);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07007841 ret = -EEXIST;
7842 goto error_open;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08007843 }
7844 }
7845
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007846 /* Check if this usecase is already existing */
7847 pthread_mutex_lock(&adev->lock);
Narsinga Rao Chella7ce05352014-04-17 20:00:41 -07007848 if ((get_usecase_from_list(adev, out->usecase) != NULL) &&
7849 (out->usecase != USECASE_COMPRESS_VOIP_CALL)) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007850 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007851 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07007852 ret = -EEXIST;
7853 goto error_open;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007854 }
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08007855
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007856 pthread_mutex_unlock(&adev->lock);
7857
7858 out->stream.common.get_sample_rate = out_get_sample_rate;
7859 out->stream.common.set_sample_rate = out_set_sample_rate;
7860 out->stream.common.get_buffer_size = out_get_buffer_size;
7861 out->stream.common.get_channels = out_get_channels;
7862 out->stream.common.get_format = out_get_format;
7863 out->stream.common.set_format = out_set_format;
7864 out->stream.common.standby = out_standby;
7865 out->stream.common.dump = out_dump;
7866 out->stream.common.set_parameters = out_set_parameters;
7867 out->stream.common.get_parameters = out_get_parameters;
7868 out->stream.common.add_audio_effect = out_add_audio_effect;
7869 out->stream.common.remove_audio_effect = out_remove_audio_effect;
7870 out->stream.get_latency = out_get_latency;
7871 out->stream.set_volume = out_set_volume;
Aalique Grahame22e49102018-12-18 14:23:57 -08007872#ifdef NO_AUDIO_OUT
7873 out->stream.write = out_write_for_no_output;
7874#else
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007875 out->stream.write = out_write;
Aalique Grahame22e49102018-12-18 14:23:57 -08007876#endif
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007877 out->stream.get_render_position = out_get_render_position;
7878 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07007879 out->stream.get_presentation_position = out_get_presentation_position;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007880
Haynes Mathew George16081042017-05-31 17:16:49 -07007881 if (out->realtime)
7882 out->af_period_multiplier = af_period_multiplier;
7883 else
7884 out->af_period_multiplier = 1;
7885
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007886 out->standby = 1;
Eric Laurenta9024de2013-04-04 09:19:12 -07007887 /* out->muted = false; by calloc() */
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07007888 /* out->written = 0; by calloc() */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007889
7890 config->format = out->stream.common.get_format(&out->stream.common);
7891 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
7892 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
Naresh Tanniru04f71882018-06-26 17:46:22 +05307893 register_format(out->format, out->supported_formats);
7894 register_channel_mask(out->channel_mask, out->supported_channel_masks);
7895 register_sample_rate(out->sample_rate, out->supported_sample_rates);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007896
Aalique Grahame22e49102018-12-18 14:23:57 -08007897 out->error_log = error_log_create(
7898 ERROR_LOG_ENTRIES,
7899 1000000000 /* aggregate consecutive identical errors within one second in ns */);
7900
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05307901 /*
7902 By locking output stream before registering, we allow the callback
7903 to update stream's state only after stream's initial state is set to
7904 adev state.
7905 */
7906 lock_output_stream(out);
7907 audio_extn_snd_mon_register_listener(out, out_snd_mon_cb);
7908 pthread_mutex_lock(&adev->lock);
7909 out->card_status = adev->card_status;
7910 pthread_mutex_unlock(&adev->lock);
7911 pthread_mutex_unlock(&out->lock);
7912
Aalique Grahame22e49102018-12-18 14:23:57 -08007913 stream_app_type_cfg_init(&out->app_type_cfg);
7914
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007915 *stream_out = &out->stream;
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05307916 ALOGD("%s: Stream (%p) picks up usecase (%s)", __func__, &out->stream,
vivek mehta0ea887a2015-08-26 14:01:20 -07007917 use_case_table[out->usecase]);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08007918
7919 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
7920 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
7921 popcount(out->channel_mask), out->playback_started);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08007922 /* setup a channel for client <--> adsp communication for stream events */
Manish Dewangan21a850a2017-08-14 12:03:55 +05307923 is_direct_passthough = audio_extn_passthru_is_direct_passthrough(out);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08007924 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) ||
Naresh Tanniru85819452017-05-04 18:55:45 -07007925 (out->flags & AUDIO_OUTPUT_FLAG_DIRECT_PCM) ||
Gangadhar Sb0210342019-02-22 17:39:41 +05307926 audio_extn_ip_hdlr_intf_supported_for_copp(adev->platform) ||
7927 (audio_extn_ip_hdlr_intf_supported(config->format, is_direct_passthough, false))) {
Ben Rombergerd771a7c2017-02-22 18:05:17 -08007928 hdlr_stream_cfg.pcm_device_id = platform_get_pcm_device_id(
7929 out->usecase, PCM_PLAYBACK);
7930 hdlr_stream_cfg.flags = out->flags;
7931 hdlr_stream_cfg.type = PCM_PLAYBACK;
7932 ret = audio_extn_adsp_hdlr_stream_open(&out->adsp_hdlr_stream_handle,
7933 &hdlr_stream_cfg);
7934 if (ret) {
7935 ALOGE("%s: adsp_hdlr_stream_open failed %d",__func__, ret);
7936 out->adsp_hdlr_stream_handle = NULL;
7937 }
7938 }
Gangadhar Sb0210342019-02-22 17:39:41 +05307939 ip_hdlr_stream = audio_extn_ip_hdlr_intf_supported(config->format,
7940 is_direct_passthough, false);
7941 ip_hdlr_dev = audio_extn_ip_hdlr_intf_supported_for_copp(adev->platform);
7942 if (ip_hdlr_stream || ip_hdlr_dev ) {
Vidyakumar Athota2062f912017-06-27 14:46:15 -07007943 ret = audio_extn_ip_hdlr_intf_init(&out->ip_hdlr_handle, NULL, NULL, adev, out->usecase);
Naresh Tanniru85819452017-05-04 18:55:45 -07007944 if (ret < 0) {
7945 ALOGE("%s: audio_extn_ip_hdlr_intf_init failed %d",__func__, ret);
7946 out->ip_hdlr_handle = NULL;
7947 }
7948 }
Derek Chenf939fb72018-11-13 13:34:41 -08007949
7950 streams_output_ctxt_t *out_ctxt = (streams_output_ctxt_t *)
7951 calloc(1, sizeof(streams_output_ctxt_t));
7952 if (out_ctxt == NULL) {
7953 ALOGE("%s fail to allocate output ctxt", __func__);
7954 ret = -ENOMEM;
7955 goto error_open;
7956 }
7957 out_ctxt->output = out;
7958
7959 pthread_mutex_lock(&adev->lock);
7960 list_add_tail(&adev->active_outputs_list, &out_ctxt->list);
7961 pthread_mutex_unlock(&adev->lock);
7962
Eric Laurent994a6932013-07-17 11:51:42 -07007963 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007964 return 0;
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07007965
7966error_open:
Ashish Jain83a6cc22016-06-28 14:34:17 +05307967 if (out->convert_buffer)
7968 free(out->convert_buffer);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07007969 free(out);
7970 *stream_out = NULL;
7971 ALOGD("%s: exit: ret %d", __func__, ret);
7972 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007973}
7974
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05307975void adev_close_output_stream(struct audio_hw_device *dev __unused,
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007976 struct audio_stream_out *stream)
7977{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007978 struct stream_out *out = (struct stream_out *)stream;
7979 struct audio_device *adev = out->dev;
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08007980 int ret = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07007981
Haynes Mathew George484e8d22017-07-31 18:55:17 -07007982 ALOGD("%s: enter:stream_handle(%s)",__func__, use_case_table[out->usecase]);
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05307983
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05307984 // must deregister from sndmonitor first to prevent races
7985 // between the callback and close_stream
7986 audio_extn_snd_mon_unregister_listener(out);
7987
Ben Rombergerd771a7c2017-02-22 18:05:17 -08007988 /* close adsp hdrl session before standby */
7989 if (out->adsp_hdlr_stream_handle) {
7990 ret = audio_extn_adsp_hdlr_stream_close(out->adsp_hdlr_stream_handle);
7991 if (ret)
7992 ALOGE("%s: adsp_hdlr_stream_close failed %d",__func__, ret);
7993 out->adsp_hdlr_stream_handle = NULL;
7994 }
7995
Manish Dewangan21a850a2017-08-14 12:03:55 +05307996 if (out->ip_hdlr_handle) {
Naresh Tanniru85819452017-05-04 18:55:45 -07007997 audio_extn_ip_hdlr_intf_deinit(out->ip_hdlr_handle);
7998 out->ip_hdlr_handle = NULL;
7999 }
8000
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08008001 if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05308002 pthread_mutex_lock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08008003 ret = voice_extn_compress_voip_close_output_stream(&stream->common);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05308004 out->started = 0;
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05308005 pthread_mutex_unlock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08008006 if(ret != 0)
8007 ALOGE("%s: Compress voip output cannot be closed, error:%d",
8008 __func__, ret);
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008009 } else
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08008010 out_standby(&stream->common);
8011
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07008012 if (is_offload_usecase(out->usecase)) {
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08008013 audio_extn_dts_remove_state_notifier_node(out->usecase);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07008014 destroy_offload_callback_thread(out);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07008015 free_offload_usecase(adev, out->usecase);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07008016 if (out->compr_config.codec != NULL)
8017 free(out->compr_config.codec);
8018 }
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07008019
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05308020 out->a2dp_compress_mute = false;
8021
Varun Balaraje49253e2017-07-06 19:48:56 +05308022 if (is_interactive_usecase(out->usecase))
8023 free_interactive_usecase(adev, out->usecase);
8024
Ashish Jain83a6cc22016-06-28 14:34:17 +05308025 if (out->convert_buffer != NULL) {
8026 free(out->convert_buffer);
8027 out->convert_buffer = NULL;
8028 }
8029
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07008030 if (adev->voice_tx_output == out)
8031 adev->voice_tx_output = NULL;
8032
Aalique Grahame22e49102018-12-18 14:23:57 -08008033 error_log_destroy(out->error_log);
8034 out->error_log = NULL;
8035
Dhanalakshmi Siddani6c3d0992017-01-16 16:52:33 +05308036 if (adev->primary_output == out)
8037 adev->primary_output = NULL;
8038
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07008039 pthread_cond_destroy(&out->cond);
8040 pthread_mutex_destroy(&out->lock);
Derek Chenf939fb72018-11-13 13:34:41 -08008041
8042 pthread_mutex_lock(&adev->lock);
8043 streams_output_ctxt_t *out_ctxt = out_get_stream(adev, out->handle);
8044 if (out_ctxt != NULL) {
8045 list_remove(&out_ctxt->list);
8046 free(out_ctxt);
8047 } else {
8048 ALOGW("%s, output stream already closed", __func__);
8049 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008050 free(stream);
Derek Chenf939fb72018-11-13 13:34:41 -08008051 pthread_mutex_unlock(&adev->lock);
Eric Laurent994a6932013-07-17 11:51:42 -07008052 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008053}
8054
8055static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
8056{
8057 struct audio_device *adev = (struct audio_device *)dev;
8058 struct str_parms *parms;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008059 char value[32];
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07008060 int val;
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008061 int ret;
8062 int status = 0;
Aalique Grahame22e49102018-12-18 14:23:57 -08008063 bool a2dp_reconfig = false;
Zhou Songd6d71752019-05-21 18:08:51 +08008064 struct listnode *node;
8065 struct audio_usecase *usecase = NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008066
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08008067 ALOGD("%s: enter: %s", __func__, kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008068 parms = str_parms_create_str(kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008069
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05308070 if (!parms)
8071 goto error;
Naresh Tanniru4c630392014-05-12 01:05:52 +05308072
Zhou Songd6d71752019-05-21 18:08:51 +08008073 pthread_mutex_lock(&adev->lock);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05308074 ret = str_parms_get_str(parms, "BT_SCO", value, sizeof(value));
8075 if (ret >= 0) {
8076 /* When set to false, HAL should disable EC and NS */
Zhou Songd6d71752019-05-21 18:08:51 +08008077 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0){
Ashish Jain1b9b30c2017-05-18 20:57:40 +05308078 adev->bt_sco_on = true;
Zhou Songd6d71752019-05-21 18:08:51 +08008079 } else {
8080 ALOGD("sco is off, reset sco and route device to handset/mic");
Ashish Jain1b9b30c2017-05-18 20:57:40 +05308081 adev->bt_sco_on = false;
Zhou Songd6d71752019-05-21 18:08:51 +08008082 audio_extn_sco_reset_configuration();
8083 list_for_each(node, &adev->usecase_list) {
8084 usecase = node_to_item(node, struct audio_usecase, list);
8085 if ((usecase->type == PCM_PLAYBACK) && usecase->stream.out &&
8086 (usecase->stream.out->devices & AUDIO_DEVICE_OUT_ALL_SCO))
8087 usecase->stream.out->devices = AUDIO_DEVICE_OUT_EARPIECE;
8088 else if ((usecase->type == PCM_CAPTURE) && usecase->stream.in &&
8089 (usecase->stream.in->device & AUDIO_DEVICE_IN_ALL_SCO))
8090 usecase->stream.in->device = AUDIO_DEVICE_IN_BUILTIN_MIC;
8091 else
8092 continue;
8093 select_devices(adev, usecase->id);
8094 }
8095 }
Ashish Jain1b9b30c2017-05-18 20:57:40 +05308096 }
8097
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008098 status = voice_set_parameters(adev, parms);
8099 if (status != 0)
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08008100 goto done;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008101
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008102 status = platform_set_parameters(adev->platform, parms);
8103 if (status != 0)
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08008104 goto done;
8105
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008106 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
8107 if (ret >= 0) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -07008108 /* When set to false, HAL should disable EC and NS */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008109 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
8110 adev->bluetooth_nrec = true;
8111 else
8112 adev->bluetooth_nrec = false;
8113 }
8114
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008115 ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
8116 if (ret >= 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008117 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
8118 adev->screen_off = false;
8119 else
8120 adev->screen_off = true;
Quinn Male70f20f32019-06-26 16:50:26 -07008121 audio_extn_sound_trigger_update_screen_status(adev->screen_off);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008122 }
8123
Eric Laurent4b084132018-10-19 17:33:43 -07008124 ret = str_parms_get_int(parms, "rotation", &val);
8125 if (ret >= 0) {
8126 bool reverse_speakers = false;
8127 int camera_rotation = CAMERA_ROTATION_LANDSCAPE;
8128 switch (val) {
8129 // FIXME: note that the code below assumes that the speakers are in the correct placement
8130 // relative to the user when the device is rotated 90deg from its default rotation. This
8131 // assumption is device-specific, not platform-specific like this code.
8132 case 270:
8133 reverse_speakers = true;
8134 camera_rotation = CAMERA_ROTATION_INVERT_LANDSCAPE;
8135 break;
8136 case 0:
8137 case 180:
8138 camera_rotation = CAMERA_ROTATION_PORTRAIT;
8139 break;
8140 case 90:
8141 camera_rotation = CAMERA_ROTATION_LANDSCAPE;
8142 break;
8143 default:
8144 ALOGE("%s: unexpected rotation of %d", __func__, val);
8145 status = -EINVAL;
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07008146 }
Eric Laurent4b084132018-10-19 17:33:43 -07008147 if (status == 0) {
8148 // check and set swap
8149 // - check if orientation changed and speaker active
8150 // - set rotation and cache the rotation value
8151 adev->camera_orientation =
8152 (adev->camera_orientation & ~CAMERA_ROTATION_MASK) | camera_rotation;
8153 if (!audio_extn_is_maxx_audio_enabled())
8154 platform_check_and_set_swap_lr_channels(adev, reverse_speakers);
8155 }
8156 }
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07008157
Mingming Yin514a8bc2014-07-29 15:22:21 -07008158 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_SCO_WB, value, sizeof(value));
8159 if (ret >= 0) {
8160 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
8161 adev->bt_wb_speech_enabled = true;
8162 else
8163 adev->bt_wb_speech_enabled = false;
8164 }
8165
Zhou Song12c29502019-03-16 10:37:18 +08008166 ret = str_parms_get_str(parms, "bt_swb", value, sizeof(value));
8167 if (ret >= 0) {
8168 val = atoi(value);
8169 adev->swb_speech_mode = val;
8170 }
8171
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07008172 ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_CONNECT, value, sizeof(value));
8173 if (ret >= 0) {
8174 val = atoi(value);
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +05308175 audio_devices_t device = (audio_devices_t) val;
Zhou Song681350a2017-10-19 16:28:42 +08008176 if (audio_is_output_device(val) &&
8177 (val & AUDIO_DEVICE_OUT_AUX_DIGITAL)) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07008178 ALOGV("cache new ext disp type and edid");
8179 ret = platform_get_ext_disp_type(adev->platform);
8180 if (ret < 0) {
8181 ALOGE("%s: Failed to query disp type, ret:%d", __func__, ret);
Manisha Agarwal2f5ff882018-08-08 17:09:29 +05308182 } else {
8183 platform_cache_edid(adev->platform);
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07008184 }
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +05308185 } else if (audio_is_usb_out_device(device) || audio_is_usb_in_device(device)) {
vivek mehta344576a2016-04-12 18:56:03 -07008186 /*
8187 * Do not allow AFE proxy port usage by WFD source when USB headset is connected.
8188 * Per AudioPolicyManager, USB device is higher priority than WFD.
8189 * For Voice call over USB headset, voice call audio is routed to AFE proxy ports.
8190 * If WFD use case occupies AFE proxy, it may result unintended behavior while
8191 * starting voice call on USB
8192 */
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08008193 ret = str_parms_get_str(parms, "card", value, sizeof(value));
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +05308194 if (ret >= 0)
8195 audio_extn_usb_add_device(device, atoi(value));
8196
Zhou Song6f862822017-11-06 17:27:57 +08008197 if (!audio_extn_usb_is_tunnel_supported()) {
8198 ALOGV("detected USB connect .. disable proxy");
8199 adev->allow_afe_proxy_usage = false;
8200 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07008201 }
8202 }
8203
8204 ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_DISCONNECT, value, sizeof(value));
8205 if (ret >= 0) {
8206 val = atoi(value);
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +05308207 audio_devices_t device = (audio_devices_t) val;
Garmond Leunge3b6d482016-10-25 16:48:01 -07008208 /*
8209 * The HDMI / Displayport disconnect handling has been moved to
8210 * audio extension to ensure that its parameters are not
8211 * invalidated prior to updating sysfs of the disconnect event
8212 * Invalidate will be handled by audio_extn_ext_disp_set_parameters()
8213 */
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +05308214 if (audio_is_usb_out_device(device) || audio_is_usb_in_device(device)) {
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08008215 ret = str_parms_get_str(parms, "card", value, sizeof(value));
Satya Krishna Pindiprolice227962017-12-13 16:07:14 +05308216 if (ret >= 0)
8217 audio_extn_usb_remove_device(device, atoi(value));
8218
Zhou Song6f862822017-11-06 17:27:57 +08008219 if (!audio_extn_usb_is_tunnel_supported()) {
8220 ALOGV("detected USB disconnect .. enable proxy");
8221 adev->allow_afe_proxy_usage = true;
8222 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07008223 }
Manisha Agarwalc2188fb2019-05-27 10:00:29 +05308224 if (audio_is_a2dp_out_device(device)) {
8225 struct audio_usecase *usecase;
8226 struct listnode *node;
8227 list_for_each(node, &adev->usecase_list) {
8228 usecase = node_to_item(node, struct audio_usecase, list);
8229 if (PCM_PLAYBACK == usecase->type && usecase->stream.out &&
8230 (usecase->stream.out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
8231 usecase->stream.out->a2dp_compress_mute) {
8232 struct stream_out *out = usecase->stream.out;
8233 ALOGD("Unmuting the stream when Bt-A2dp disconnected and stream is mute");
8234 out->a2dp_compress_mute = false;
8235 out_set_compr_volume(&out->stream, out->volume_l, out->volume_r);
8236 }
8237 }
8238 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07008239 }
8240
Aalique Grahame22e49102018-12-18 14:23:57 -08008241 audio_extn_hfp_set_parameters(adev, parms);
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08008242 audio_extn_qdsp_set_parameters(adev, parms);
Aalique Grahame22e49102018-12-18 14:23:57 -08008243
8244 status = audio_extn_a2dp_set_parameters(parms, &a2dp_reconfig);
Aniket Kumar Lata23300322019-02-20 22:25:30 -08008245 if (status >= 0 && a2dp_reconfig) {
Naresh Tanniru9d027a62015-03-13 01:32:10 +05308246 struct audio_usecase *usecase;
8247 struct listnode *node;
8248 list_for_each(node, &adev->usecase_list) {
8249 usecase = node_to_item(node, struct audio_usecase, list);
Sujin Panicker390724d2019-04-26 10:43:36 +05308250 if (usecase->stream.out && (usecase->type == PCM_PLAYBACK) &&
Naresh Tanniruf7e9e632016-11-04 14:54:20 -07008251 (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP)){
Naresh Tanniru9d027a62015-03-13 01:32:10 +05308252 ALOGD("reconfigure a2dp... forcing device switch");
Weiyin Jiang425180d2017-06-05 16:40:23 +08008253 pthread_mutex_unlock(&adev->lock);
Naresh Tannirucd2353e2016-08-19 00:37:25 +05308254 lock_output_stream(usecase->stream.out);
Weiyin Jiang425180d2017-06-05 16:40:23 +08008255 pthread_mutex_lock(&adev->lock);
Naresh Tannirucd2353e2016-08-19 00:37:25 +05308256 audio_extn_a2dp_set_handoff_mode(true);
Manisha Agarwalf1c3b6b2019-06-25 13:00:33 +05308257 ALOGD("Switching to speaker and muting the stream before select_devices");
8258 check_a2dp_restore_l(adev, usecase->stream.out, false);
Naresh Tanniru9d027a62015-03-13 01:32:10 +05308259 //force device switch to re configure encoder
8260 select_devices(adev, usecase->id);
Manisha Agarwalf1c3b6b2019-06-25 13:00:33 +05308261 ALOGD("Unmuting the stream after select_devices");
8262 usecase->stream.out->a2dp_compress_mute = false;
8263 out_set_compr_volume(&usecase->stream.out->stream, usecase->stream.out->volume_l, usecase->stream.out->volume_r);
Naresh Tannirucd2353e2016-08-19 00:37:25 +05308264 audio_extn_a2dp_set_handoff_mode(false);
8265 pthread_mutex_unlock(&usecase->stream.out->lock);
Naresh Tanniru9d027a62015-03-13 01:32:10 +05308266 break;
8267 }
8268 }
8269 }
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08008270
8271 //handle vr audio setparam
8272 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VR_AUDIO_MODE,
8273 value, sizeof(value));
8274 if (ret >= 0) {
8275 ALOGI("Setting vr mode to be %s", value);
8276 if (!strncmp(value, "true", 4)) {
8277 adev->vr_audio_mode_enabled = true;
8278 ALOGI("Setting vr mode to true");
8279 } else if (!strncmp(value, "false", 5)) {
8280 adev->vr_audio_mode_enabled = false;
8281 ALOGI("Setting vr mode to false");
8282 } else {
8283 ALOGI("wrong vr mode set");
8284 }
8285 }
8286
Eric Laurent4b084132018-10-19 17:33:43 -07008287 //FIXME: to be replaced by proper video capture properties API
8288 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_CAMERA_FACING, value, sizeof(value));
8289 if (ret >= 0) {
8290 int camera_facing = CAMERA_FACING_BACK;
8291 if (strcmp(value, AUDIO_PARAMETER_VALUE_FRONT) == 0)
8292 camera_facing = CAMERA_FACING_FRONT;
8293 else if (strcmp(value, AUDIO_PARAMETER_VALUE_BACK) == 0)
8294 camera_facing = CAMERA_FACING_BACK;
8295 else {
8296 ALOGW("%s: invalid camera facing value: %s", __func__, value);
8297 goto done;
8298 }
8299 adev->camera_orientation =
8300 (adev->camera_orientation & ~CAMERA_FACING_MASK) | camera_facing;
8301 struct audio_usecase *usecase;
8302 struct listnode *node;
8303 list_for_each(node, &adev->usecase_list) {
8304 usecase = node_to_item(node, struct audio_usecase, list);
8305 struct stream_in *in = usecase->stream.in;
8306 if (usecase->type == PCM_CAPTURE && in != NULL &&
8307 in->source == AUDIO_SOURCE_CAMCORDER && !in->standby) {
8308 select_devices(adev, in->usecase);
8309 }
8310 }
8311 }
8312
Naresh Tannirucd2353e2016-08-19 00:37:25 +05308313 audio_extn_set_parameters(adev, parms);
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08008314done:
8315 str_parms_destroy(parms);
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08008316 pthread_mutex_unlock(&adev->lock);
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05308317error:
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008318 ALOGV("%s: exit with code(%d)", __func__, status);
8319 return status;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008320}
8321
8322static char* adev_get_parameters(const struct audio_hw_device *dev,
8323 const char *keys)
8324{
Sidipotu Ashokaa4fa6a2018-12-21 09:19:26 +05308325 ALOGD("%s:%s", __func__, keys);
8326
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07008327 struct audio_device *adev = (struct audio_device *)dev;
8328 struct str_parms *reply = str_parms_create();
8329 struct str_parms *query = str_parms_create_str(keys);
8330 char *str;
Naresh Tannirud7205b62014-06-20 02:54:48 +05308331 char value[256] = {0};
8332 int ret = 0;
8333
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07008334 if (!query || !reply) {
Alexy Josephaee4fdd2016-01-29 13:02:07 -08008335 if (reply) {
8336 str_parms_destroy(reply);
8337 }
8338 if (query) {
8339 str_parms_destroy(query);
8340 }
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07008341 ALOGE("adev_get_parameters: failed to create query or reply");
8342 return NULL;
8343 }
8344
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08008345 //handle vr audio getparam
8346
8347 ret = str_parms_get_str(query,
8348 AUDIO_PARAMETER_KEY_VR_AUDIO_MODE,
8349 value, sizeof(value));
8350
8351 if (ret >= 0) {
8352 bool vr_audio_enabled = false;
8353 pthread_mutex_lock(&adev->lock);
8354 vr_audio_enabled = adev->vr_audio_mode_enabled;
8355 pthread_mutex_unlock(&adev->lock);
8356
8357 ALOGI("getting vr mode to %d", vr_audio_enabled);
8358
8359 if (vr_audio_enabled) {
8360 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VR_AUDIO_MODE,
8361 "true");
8362 goto exit;
8363 } else {
8364 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VR_AUDIO_MODE,
8365 "false");
8366 goto exit;
8367 }
8368 }
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07008369
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08008370 pthread_mutex_lock(&adev->lock);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07008371 audio_extn_get_parameters(adev, query, reply);
Shiv Maliyappanahallif9308492013-12-12 12:18:09 -08008372 voice_get_parameters(adev, query, reply);
Aalique Grahame22e49102018-12-18 14:23:57 -08008373 audio_extn_a2dp_get_parameters(query, reply);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07008374 platform_get_parameters(adev->platform, query, reply);
Naresh Tanniru80659832014-06-04 18:17:56 +05308375 pthread_mutex_unlock(&adev->lock);
8376
Naresh Tannirud7205b62014-06-20 02:54:48 +05308377exit:
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07008378 str = str_parms_to_str(reply);
8379 str_parms_destroy(query);
8380 str_parms_destroy(reply);
8381
Sidipotu Ashokaa4fa6a2018-12-21 09:19:26 +05308382 ALOGD("%s: exit: returns - %s", __func__, str);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07008383 return str;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008384}
8385
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07008386static int adev_init_check(const struct audio_hw_device *dev __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008387{
8388 return 0;
8389}
8390
8391static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
8392{
Haynes Mathew George5191a852013-09-11 14:19:36 -07008393 int ret;
8394 struct audio_device *adev = (struct audio_device *)dev;
Aalique Grahame22e49102018-12-18 14:23:57 -08008395
8396 audio_extn_extspk_set_voice_vol(adev->extspk, volume);
8397
Haynes Mathew George5191a852013-09-11 14:19:36 -07008398 pthread_mutex_lock(&adev->lock);
8399 /* cache volume */
Shruthi Krishnaace10852013-10-25 14:32:12 -07008400 ret = voice_set_volume(adev, volume);
Haynes Mathew George5191a852013-09-11 14:19:36 -07008401 pthread_mutex_unlock(&adev->lock);
8402 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008403}
8404
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07008405static int adev_set_master_volume(struct audio_hw_device *dev __unused,
8406 float volume __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008407{
8408 return -ENOSYS;
8409}
8410
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07008411static int adev_get_master_volume(struct audio_hw_device *dev __unused,
8412 float *volume __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008413{
8414 return -ENOSYS;
8415}
8416
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07008417static int adev_set_master_mute(struct audio_hw_device *dev __unused,
8418 bool muted __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008419{
8420 return -ENOSYS;
8421}
8422
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07008423static int adev_get_master_mute(struct audio_hw_device *dev __unused,
8424 bool *muted __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008425{
8426 return -ENOSYS;
8427}
8428
8429static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
8430{
8431 struct audio_device *adev = (struct audio_device *)dev;
Garmond Leung5fd0b552018-04-17 11:56:12 -07008432 struct listnode *node;
8433 struct audio_usecase *usecase = NULL;
8434 int ret = 0;
kunleizdc4af9d2017-05-04 12:15:35 +08008435
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008436 pthread_mutex_lock(&adev->lock);
8437 if (adev->mode != mode) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07008438 ALOGD("%s: mode %d\n", __func__, mode);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008439 adev->mode = mode;
Kunlei Zhang1d5c7f22019-05-21 14:25:57 +08008440 if (voice_is_in_call(adev) &&
8441 (mode == AUDIO_MODE_NORMAL ||
8442 (mode == AUDIO_MODE_IN_COMMUNICATION && !voice_is_call_state_active(adev)))) {
Garmond Leung5fd0b552018-04-17 11:56:12 -07008443 list_for_each(node, &adev->usecase_list) {
8444 usecase = node_to_item(node, struct audio_usecase, list);
8445 if (usecase->type == VOICE_CALL)
8446 break;
8447 }
8448 if (usecase &&
8449 audio_is_usb_out_device(usecase->out_snd_device & AUDIO_DEVICE_OUT_ALL_USB)) {
8450 ret = audio_extn_usb_check_and_set_svc_int(usecase,
8451 true);
8452 if (ret != 0) {
8453 /* default service interval was successfully updated,
8454 reopen USB backend with new service interval */
8455 check_usecases_codec_backend(adev,
8456 usecase,
8457 usecase->out_snd_device);
8458 }
8459 }
8460
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07008461 voice_stop_call(adev);
Banajit Goswami20cdd212015-09-11 01:11:30 -07008462 platform_set_gsm_mode(adev->platform, false);
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07008463 adev->current_call_output = NULL;
kunleizdc4af9d2017-05-04 12:15:35 +08008464 // restore device for other active usecases after stop call
8465 list_for_each(node, &adev->usecase_list) {
8466 usecase = node_to_item(node, struct audio_usecase, list);
8467 select_devices(adev, usecase->id);
8468 }
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07008469 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008470 }
8471 pthread_mutex_unlock(&adev->lock);
8472 return 0;
8473}
8474
8475static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
8476{
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08008477 int ret;
Aalique Grahame22e49102018-12-18 14:23:57 -08008478 struct audio_device *adev = (struct audio_device *)dev;
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08008479
8480 pthread_mutex_lock(&adev->lock);
Vidyakumar Athota2850d532013-11-19 16:02:12 -08008481 ALOGD("%s state %d\n", __func__, state);
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08008482 ret = voice_set_mic_mute((struct audio_device *)dev, state);
Aalique Grahame22e49102018-12-18 14:23:57 -08008483
Derek Chend2530072014-11-24 12:39:14 -08008484 if (adev->ext_hw_plugin)
8485 ret = audio_extn_ext_hw_plugin_set_mic_mute(adev->ext_hw_plugin, state);
Aalique Grahame22e49102018-12-18 14:23:57 -08008486
8487 adev->mic_muted = state;
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08008488 pthread_mutex_unlock(&adev->lock);
8489
8490 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008491}
8492
8493static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
8494{
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07008495 *state = voice_get_mic_mute((struct audio_device *)dev);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008496 return 0;
8497}
8498
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07008499static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev __unused,
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008500 const struct audio_config *config)
8501{
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008502 int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008503
Aalique Grahame22e49102018-12-18 14:23:57 -08008504 /* Don't know if USB HIFI in this context so use true to be conservative */
8505 if (check_input_parameters(config->sample_rate, config->format, channel_count,
8506 true /*is_usb_hifi */) != 0)
8507 return 0;
8508
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07008509 return get_input_buffer_size(config->sample_rate, config->format, channel_count,
8510 false /* is_low_latency: since we don't know, be conservative */);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008511}
8512
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008513static bool adev_input_allow_hifi_record(struct audio_device *adev,
8514 audio_devices_t devices,
8515 audio_input_flags_t flags,
8516 audio_source_t source) {
8517 const bool allowed = true;
8518
8519 if (!audio_is_usb_in_device(devices))
8520 return !allowed;
8521
8522 switch (flags) {
8523 case AUDIO_INPUT_FLAG_NONE:
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008524 break;
Haynes Mathew George59862182017-10-24 16:23:57 -07008525 case AUDIO_INPUT_FLAG_FAST: // disallow hifi record for FAST as
8526 // it affects RTD numbers over USB
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008527 default:
8528 return !allowed;
8529 }
8530
8531 switch (source) {
8532 case AUDIO_SOURCE_DEFAULT:
8533 case AUDIO_SOURCE_MIC:
8534 case AUDIO_SOURCE_UNPROCESSED:
8535 break;
8536 default:
8537 return !allowed;
8538 }
8539
8540 switch (adev->mode) {
8541 case 0:
8542 break;
8543 default:
8544 return !allowed;
8545 }
8546
8547 return allowed;
8548}
8549
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008550static int adev_update_voice_comm_input_stream(struct stream_in *in,
8551 struct audio_config *config)
8552{
8553 bool valid_rate = (config->sample_rate == 8000 ||
8554 config->sample_rate == 16000 ||
8555 config->sample_rate == 32000 ||
8556 config->sample_rate == 48000);
8557 bool valid_ch = audio_channel_count_from_in_mask(in->channel_mask) == 1;
8558
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08008559 if(!voice_extn_is_compress_voip_supported()) {
kunleiz28c73e72019-03-27 17:24:04 +08008560 if (valid_rate && valid_ch) {
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008561 in->usecase = USECASE_AUDIO_RECORD_VOIP;
8562 in->config = default_pcm_config_voip_copp;
8563 in->config.period_size = VOIP_IO_BUF_SIZE(in->sample_rate,
8564 DEFAULT_VOIP_BUF_DURATION_MS,
8565 DEFAULT_VOIP_BIT_DEPTH_BYTE)/2;
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08008566 } else {
8567 ALOGW("%s No valid input in voip, use defaults"
8568 "sample rate %u, channel mask 0x%X",
8569 __func__, config->sample_rate, in->channel_mask);
8570 }
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008571 in->config.rate = config->sample_rate;
8572 in->sample_rate = config->sample_rate;
8573 } else {
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08008574 //XXX needed for voice_extn_compress_voip_open_input_stream
8575 in->config.rate = config->sample_rate;
8576 if ((in->dev->mode == AUDIO_MODE_IN_COMMUNICATION ||
8577 voice_extn_compress_voip_is_active(in->dev)) &&
8578 (voice_extn_compress_voip_is_format_supported(in->format)) &&
8579 valid_rate && valid_ch) {
8580 voice_extn_compress_voip_open_input_stream(in);
8581 // update rate entries to match config from AF
8582 in->config.rate = config->sample_rate;
8583 in->sample_rate = config->sample_rate;
8584 } else {
8585 ALOGW("%s compress voip not active, use defaults", __func__);
8586 }
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008587 }
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008588 return 0;
8589}
8590
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008591static int adev_open_input_stream(struct audio_hw_device *dev,
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07008592 audio_io_handle_t handle,
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008593 audio_devices_t devices,
8594 struct audio_config *config,
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008595 struct audio_stream_in **stream_in,
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05308596 audio_input_flags_t flags,
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008597 const char *address __unused,
Vidyakumar Athota5c398212015-03-31 21:53:21 -07008598 audio_source_t source)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008599{
8600 struct audio_device *adev = (struct audio_device *)dev;
8601 struct stream_in *in;
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08008602 int ret = 0, buffer_size, frame_size;
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07008603 int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07008604 bool is_low_latency = false;
Divya Narayanan Poojary45f19192016-09-30 18:52:13 +05308605 bool channel_mask_updated = false;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008606 bool is_usb_dev = audio_is_usb_in_device(devices);
8607 bool may_use_hifi_record = adev_input_allow_hifi_record(adev,
8608 devices,
8609 flags,
8610 source);
Andy Hung94320602018-10-29 18:31:12 -07008611 ALOGV("%s: enter: flags %#x, is_usb_dev %d, may_use_hifi_record %d,"
8612 " sample_rate %u, channel_mask %#x, format %#x",
8613 __func__, flags, is_usb_dev, may_use_hifi_record,
8614 config->sample_rate, config->channel_mask, config->format);
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05308615
kunleizdff872d2018-08-20 14:40:33 +08008616 if (is_usb_dev && (!audio_extn_usb_connected(NULL))) {
kunleizd6a9e0c2018-07-30 15:38:52 +08008617 is_usb_dev = false;
8618 devices = AUDIO_DEVICE_IN_BUILTIN_MIC;
8619 ALOGW("%s: ignore set device to non existing USB card, use input device(%#x)",
8620 __func__, devices);
8621 }
8622
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008623 *stream_in = NULL;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008624
8625 if (!(is_usb_dev && may_use_hifi_record)) {
8626 if (config->sample_rate == 0)
8627 config->sample_rate = 48000;
8628 if (config->channel_mask == AUDIO_CHANNEL_NONE)
8629 config->channel_mask = AUDIO_CHANNEL_IN_MONO;
8630 if (config->format == AUDIO_FORMAT_DEFAULT)
8631 config->format = AUDIO_FORMAT_PCM_16_BIT;
8632
8633 channel_count = audio_channel_count_from_in_mask(config->channel_mask);
8634
Aalique Grahame22e49102018-12-18 14:23:57 -08008635 if (check_input_parameters(config->sample_rate, config->format, channel_count,
8636 false) != 0)
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008637 return -EINVAL;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +05308638 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008639
8640 in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07008641
8642 if (!in) {
8643 ALOGE("failed to allocate input stream");
8644 return -ENOMEM;
8645 }
8646
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05308647 ALOGD("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x)\
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05308648 stream_handle(%p) io_handle(%d) source(%d) format %x",__func__, config->sample_rate,
8649 config->channel_mask, devices, &in->stream, handle, source, config->format);
Ravi Kumar Alamanda40703102014-04-24 10:34:41 -07008650 pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07008651 pthread_mutex_init(&in->pre_lock, (const pthread_mutexattr_t *) NULL);
Ravi Kumar Alamanda40703102014-04-24 10:34:41 -07008652
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008653 in->stream.common.get_sample_rate = in_get_sample_rate;
8654 in->stream.common.set_sample_rate = in_set_sample_rate;
8655 in->stream.common.get_buffer_size = in_get_buffer_size;
8656 in->stream.common.get_channels = in_get_channels;
8657 in->stream.common.get_format = in_get_format;
8658 in->stream.common.set_format = in_set_format;
8659 in->stream.common.standby = in_standby;
8660 in->stream.common.dump = in_dump;
8661 in->stream.common.set_parameters = in_set_parameters;
8662 in->stream.common.get_parameters = in_get_parameters;
8663 in->stream.common.add_audio_effect = in_add_audio_effect;
8664 in->stream.common.remove_audio_effect = in_remove_audio_effect;
8665 in->stream.set_gain = in_set_gain;
8666 in->stream.read = in_read;
8667 in->stream.get_input_frames_lost = in_get_input_frames_lost;
Aalique Grahame22e49102018-12-18 14:23:57 -08008668 in->stream.get_capture_position = in_get_capture_position;
Naresh Tannirudcb47c52018-06-25 16:23:32 +05308669 in->stream.get_active_microphones = in_get_active_microphones;
Paul McLeana50b7332018-12-17 08:24:21 -07008670 in->stream.set_microphone_direction = in_set_microphone_direction;
8671 in->stream.set_microphone_field_dimension = in_set_microphone_field_dimension;
juyuchendb308c22019-01-21 11:57:17 -07008672 in->stream.update_sink_metadata = in_update_sink_metadata;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008673
8674 in->device = devices;
Vidyakumar Athota5c398212015-03-31 21:53:21 -07008675 in->source = source;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008676 in->dev = adev;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008677 in->standby = 1;
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07008678 in->capture_handle = handle;
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07008679 in->flags = flags;
Haynes Mathew George46740472017-10-27 18:40:12 -07008680 in->bit_width = 16;
8681 in->af_period_multiplier = 1;
justinweng20fb6d82019-02-21 18:49:00 -07008682 in->direction = MIC_DIRECTION_UNSPECIFIED;
8683 in->zoom = 0;
Carter Hsu2e429db2019-05-14 18:50:52 +08008684 list_init(&in->aec_list);
8685 list_init(&in->ns_list);
Haynes Mathew George46740472017-10-27 18:40:12 -07008686
Andy Hung94320602018-10-29 18:31:12 -07008687 ALOGV("%s: source %d, config->channel_mask %#x", __func__, source, config->channel_mask);
Aalique Grahame22e49102018-12-18 14:23:57 -08008688 if (source == AUDIO_SOURCE_VOICE_UPLINK ||
8689 source == AUDIO_SOURCE_VOICE_DOWNLINK) {
8690 /* Force channel config requested to mono if incall
8691 record is being requested for only uplink/downlink */
8692 if (config->channel_mask != AUDIO_CHANNEL_IN_MONO) {
8693 config->channel_mask = AUDIO_CHANNEL_IN_MONO;
8694 ret = -EINVAL;
8695 goto err_open;
8696 }
8697 }
8698
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008699 if (is_usb_dev && may_use_hifi_record) {
8700 /* HiFi record selects an appropriate format, channel, rate combo
8701 depending on sink capabilities*/
8702 ret = read_usb_sup_params_and_compare(false /*is_playback*/,
8703 &config->format,
8704 &in->supported_formats[0],
8705 MAX_SUPPORTED_FORMATS,
8706 &config->channel_mask,
8707 &in->supported_channel_masks[0],
8708 MAX_SUPPORTED_CHANNEL_MASKS,
8709 &config->sample_rate,
8710 &in->supported_sample_rates[0],
8711 MAX_SUPPORTED_SAMPLE_RATES);
8712 if (ret != 0) {
8713 ret = -EINVAL;
8714 goto err_open;
8715 }
8716 channel_count = audio_channel_count_from_in_mask(config->channel_mask);
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008717 } else if (config->format == AUDIO_FORMAT_DEFAULT) {
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05308718 config->format = AUDIO_FORMAT_PCM_16_BIT;
Surendar karkaaca3d082017-11-09 15:18:37 +05308719 } else if (property_get_bool("vendor.audio.capture.pcm.32bit.enable", false)
8720 && config->format == AUDIO_FORMAT_PCM_32_BIT) {
8721 in->config.format = PCM_FORMAT_S32_LE;
8722 in->bit_width = 32;
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05308723 } else if ((config->format == AUDIO_FORMAT_PCM_FLOAT) ||
8724 (config->format == AUDIO_FORMAT_PCM_32_BIT) ||
8725 (config->format == AUDIO_FORMAT_PCM_24_BIT_PACKED) ||
8726 (config->format == AUDIO_FORMAT_PCM_8_24_BIT)) {
8727 bool ret_error = false;
8728 in->bit_width = 24;
8729 /* 24 bit is restricted to UNPROCESSED source only,also format supported
8730 from HAL is 24_packed and 8_24
8731 *> In case of UNPROCESSED source, for 24 bit, if format requested is other than
8732 24_packed return error indicating supported format is 24_packed
8733 *> In case of any other source requesting 24 bit or float return error
8734 indicating format supported is 16 bit only.
8735
8736 on error flinger will retry with supported format passed
8737 */
8738 if ((source != AUDIO_SOURCE_UNPROCESSED) &&
8739 (source != AUDIO_SOURCE_CAMCORDER)) {
8740 config->format = AUDIO_FORMAT_PCM_16_BIT;
8741 if (config->sample_rate > 48000)
8742 config->sample_rate = 48000;
8743 ret_error = true;
Haynes Mathew George46740472017-10-27 18:40:12 -07008744 } else if (!(config->format == AUDIO_FORMAT_PCM_24_BIT_PACKED ||
8745 config->format == AUDIO_FORMAT_PCM_8_24_BIT)) {
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05308746 config->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
8747 ret_error = true;
8748 }
8749
8750 if (ret_error) {
8751 ret = -EINVAL;
8752 goto err_open;
8753 }
8754 }
8755
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008756 in->channel_mask = config->channel_mask;
8757 in->format = config->format;
8758
8759 in->usecase = USECASE_AUDIO_RECORD;
Samyak Jain0aa07ab2019-04-04 14:36:32 +05308760
8761 if (in->source == AUDIO_SOURCE_FM_TUNER) {
8762 if(!get_usecase_from_list(adev, USECASE_AUDIO_RECORD_FM_VIRTUAL))
8763 in->usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL;
8764 else {
8765 ret = -EINVAL;
8766 goto err_open;
8767 }
8768 }
8769
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008770 if (config->sample_rate == LOW_LATENCY_CAPTURE_SAMPLE_RATE &&
Deeraj Somanfa377bf2019-02-06 12:57:59 +05308771 (flags & AUDIO_INPUT_FLAG_TIMESTAMP) == 0 &&
8772 (flags & AUDIO_INPUT_FLAG_COMPRESS) == 0 &&
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008773 (flags & AUDIO_INPUT_FLAG_FAST) != 0) {
8774 is_low_latency = true;
8775#if LOW_LATENCY_CAPTURE_USE_CASE
8776 in->usecase = USECASE_AUDIO_RECORD_LOW_LATENCY;
8777#endif
8778 in->realtime = may_use_noirq_mode(adev, in->usecase, in->flags);
Aalique Grahame22e49102018-12-18 14:23:57 -08008779 if (!in->realtime) {
8780 in->config = pcm_config_audio_capture;
8781 frame_size = audio_stream_in_frame_size(&in->stream);
8782 buffer_size = get_input_buffer_size(config->sample_rate,
8783 config->format,
8784 channel_count,
8785 is_low_latency);
8786 in->config.period_size = buffer_size / frame_size;
8787 in->config.rate = config->sample_rate;
8788 in->af_period_multiplier = 1;
8789 } else {
8790 // period size is left untouched for rt mode playback
8791 in->config = pcm_config_audio_capture_rt;
8792 in->af_period_multiplier = af_period_multiplier;
8793 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008794 }
8795
8796 if ((config->sample_rate == LOW_LATENCY_CAPTURE_SAMPLE_RATE) &&
8797 ((in->flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0)) {
8798 in->realtime = 0;
8799 in->usecase = USECASE_AUDIO_RECORD_MMAP;
8800 in->config = pcm_config_mmap_capture;
Haynes Mathew George46740472017-10-27 18:40:12 -07008801 in->config.format = pcm_format_from_audio_format(config->format);
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008802 in->stream.start = in_start;
8803 in->stream.stop = in_stop;
8804 in->stream.create_mmap_buffer = in_create_mmap_buffer;
8805 in->stream.get_mmap_position = in_get_mmap_position;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008806 ALOGV("%s: USECASE_AUDIO_RECORD_MMAP", __func__);
8807 } else if (in->realtime) {
8808 in->config = pcm_config_audio_capture_rt;
Haynes Mathew George46740472017-10-27 18:40:12 -07008809 in->config.format = pcm_format_from_audio_format(config->format);
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008810 in->af_period_multiplier = af_period_multiplier;
Haynes Mathew George46740472017-10-27 18:40:12 -07008811 } else if (is_usb_dev && may_use_hifi_record) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008812 in->usecase = USECASE_AUDIO_RECORD_HIFI;
8813 in->config = pcm_config_audio_capture;
8814 frame_size = audio_stream_in_frame_size(&in->stream);
8815 buffer_size = get_input_buffer_size(config->sample_rate,
8816 config->format,
8817 channel_count,
8818 false /*is_low_latency*/);
8819 in->config.period_size = buffer_size / frame_size;
8820 in->config.rate = config->sample_rate;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008821 in->config.format = pcm_format_from_audio_format(config->format);
Karthikeyan Mani07faa602018-08-20 11:01:32 -07008822 switch (config->format) {
8823 case AUDIO_FORMAT_PCM_32_BIT:
8824 in->bit_width = 32;
8825 break;
8826 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
8827 case AUDIO_FORMAT_PCM_8_24_BIT:
8828 in->bit_width = 24;
8829 break;
8830 default:
8831 in->bit_width = 16;
8832 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07008833 } else if ((in->device == AUDIO_DEVICE_IN_TELEPHONY_RX) ||
Dhanalakshmi Siddani0b1488e2016-09-06 12:58:42 +05308834 (in->device == AUDIO_DEVICE_IN_PROXY)) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07008835 if (config->sample_rate == 0)
8836 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
8837 if (config->sample_rate != 48000 && config->sample_rate != 16000 &&
8838 config->sample_rate != 8000) {
8839 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
8840 ret = -EINVAL;
8841 goto err_open;
8842 }
8843 if (config->format == AUDIO_FORMAT_DEFAULT)
8844 config->format = AUDIO_FORMAT_PCM_16_BIT;
8845 if (config->format != AUDIO_FORMAT_PCM_16_BIT) {
8846 config->format = AUDIO_FORMAT_PCM_16_BIT;
8847 ret = -EINVAL;
8848 goto err_open;
8849 }
8850
8851 in->usecase = USECASE_AUDIO_RECORD_AFE_PROXY;
8852 in->config = pcm_config_afe_proxy_record;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07008853 in->config.rate = config->sample_rate;
Aalique Grahame22e49102018-12-18 14:23:57 -08008854 in->af_period_multiplier = 1;
8855 } else if (in->source == AUDIO_SOURCE_VOICE_COMMUNICATION &&
8856 in->flags & AUDIO_INPUT_FLAG_VOIP_TX &&
8857 (config->sample_rate == 8000 ||
8858 config->sample_rate == 16000 ||
8859 config->sample_rate == 32000 ||
8860 config->sample_rate == 48000) &&
8861 channel_count == 1) {
8862 in->usecase = USECASE_AUDIO_RECORD_VOIP;
8863 in->config = pcm_config_audio_capture;
8864 frame_size = audio_stream_in_frame_size(&in->stream);
8865 buffer_size = get_stream_buffer_size(VOIP_CAPTURE_PERIOD_DURATION_MSEC,
8866 config->sample_rate,
8867 config->format,
8868 channel_count, false /*is_low_latency*/);
8869 in->config.period_size = buffer_size / frame_size;
8870 in->config.period_count = VOIP_CAPTURE_PERIOD_COUNT;
8871 in->config.rate = config->sample_rate;
8872 in->af_period_multiplier = 1;
Haynes Mathew George46740472017-10-27 18:40:12 -07008873 } else {
Revathi Uddarajud2634032017-12-07 14:42:34 +05308874 int ret_val;
8875 pthread_mutex_lock(&adev->lock);
8876 ret_val = audio_extn_check_and_set_multichannel_usecase(adev,
8877 in, config, &channel_mask_updated);
8878 pthread_mutex_unlock(&adev->lock);
8879
8880 if (!ret_val) {
8881 if (channel_mask_updated == true) {
8882 ALOGD("%s: return error to retry with updated channel mask (%#x)",
8883 __func__, config->channel_mask);
8884 ret = -EINVAL;
8885 goto err_open;
8886 }
8887 ALOGD("%s: created multi-channel session succesfully",__func__);
8888 } else if (audio_extn_compr_cap_enabled() &&
8889 audio_extn_compr_cap_format_supported(config->format) &&
8890 (in->dev->mode != AUDIO_MODE_IN_COMMUNICATION)) {
8891 audio_extn_compr_cap_init(in);
8892 } else if (audio_extn_cin_applicable_stream(in)) {
Deeraj Soman14230922019-01-30 16:39:30 +05308893 ret = audio_extn_cin_configure_input_stream(in, config);
Revathi Uddarajud2634032017-12-07 14:42:34 +05308894 if (ret)
8895 goto err_open;
8896 } else {
8897 in->config = pcm_config_audio_capture;
8898 in->config.rate = config->sample_rate;
8899 in->config.format = pcm_format_from_audio_format(config->format);
Revathi Uddarajud2634032017-12-07 14:42:34 +05308900 in->format = config->format;
8901 frame_size = audio_stream_in_frame_size(&in->stream);
8902 buffer_size = get_input_buffer_size(config->sample_rate,
Haynes Mathew George46740472017-10-27 18:40:12 -07008903 config->format,
8904 channel_count,
8905 is_low_latency);
Dieter Luecking5d57def2018-09-07 14:23:37 +02008906 /* prevent division-by-zero */
8907 if (frame_size == 0) {
8908 ALOGE("%s: Error frame_size==0", __func__);
8909 ret = -EINVAL;
8910 goto err_open;
8911 }
8912
Revathi Uddarajud2634032017-12-07 14:42:34 +05308913 in->config.period_size = buffer_size / frame_size;
Aalique Grahame22e49102018-12-18 14:23:57 -08008914 in->af_period_multiplier = 1;
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008915
Revathi Uddarajud2634032017-12-07 14:42:34 +05308916 if (in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
8917 /* optionally use VOIP usecase depending on config(s) */
8918 ret = adev_update_voice_comm_input_stream(in, config);
8919 }
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008920
Revathi Uddarajud2634032017-12-07 14:42:34 +05308921 if (ret) {
8922 ALOGE("%s AUDIO_SOURCE_VOICE_COMMUNICATION invalid args", __func__);
8923 goto err_open;
8924 }
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008925 }
Samyak Jainc37062f2019-04-25 18:41:06 +05308926 if (audio_extn_is_concurrent_capture_enabled()) {
8927 /* Acquire lock to avoid two concurrent use cases initialized to
8928 same pcm record use case */
kunleiz28c73e72019-03-27 17:24:04 +08008929
Samyak Jainc37062f2019-04-25 18:41:06 +05308930 if (in->usecase == USECASE_AUDIO_RECORD) {
8931 pthread_mutex_lock(&adev->lock);
8932 if (!(adev->pcm_record_uc_state)) {
8933 ALOGV("%s: using USECASE_AUDIO_RECORD",__func__);
8934 adev->pcm_record_uc_state = 1;
8935 pthread_mutex_unlock(&adev->lock);
8936 } else {
8937 pthread_mutex_unlock(&adev->lock);
8938 /* Assign compress record use case for second record */
8939 in->usecase = USECASE_AUDIO_RECORD_COMPRESS2;
8940 in->flags |= AUDIO_INPUT_FLAG_COMPRESS;
8941 ALOGV("%s: overriding usecase with USECASE_AUDIO_RECORD_COMPRESS2 and appending compress flag", __func__);
8942 if (audio_extn_cin_applicable_stream(in)) {
8943 in->sample_rate = config->sample_rate;
Deeraj Soman14230922019-01-30 16:39:30 +05308944 ret = audio_extn_cin_configure_input_stream(in, config);
Samyak Jainc37062f2019-04-25 18:41:06 +05308945 if (ret)
8946 goto err_open;
8947 }
8948 }
8949 }
kunleiz28c73e72019-03-27 17:24:04 +08008950 }
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07008951 }
Aniket Kumar Lata23d8cbf2019-04-10 19:54:46 -07008952
8953 in->config.channels = channel_count;
8954 in->sample_rate = in->config.rate;
8955
Dhananjay Kumard6d32152016-10-13 16:11:03 +05308956 audio_extn_utils_update_stream_input_app_type_cfg(adev->platform,
8957 &adev->streams_input_cfg_list,
Haynes Mathew George4ffef292017-11-21 15:08:02 -08008958 devices, flags, in->format,
8959 in->sample_rate, in->bit_width,
8960 in->profile, &in->app_type_cfg);
Naresh Tanniru04f71882018-06-26 17:46:22 +05308961 register_format(in->format, in->supported_formats);
8962 register_channel_mask(in->channel_mask, in->supported_channel_masks);
8963 register_sample_rate(in->sample_rate, in->supported_sample_rates);
Dhananjay Kumard6d32152016-10-13 16:11:03 +05308964
Aalique Grahame22e49102018-12-18 14:23:57 -08008965 in->error_log = error_log_create(
8966 ERROR_LOG_ENTRIES,
8967 1000000000 /* aggregate consecutive identical errors within one second */);
8968
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07008969 /* This stream could be for sound trigger lab,
8970 get sound trigger pcm if present */
8971 audio_extn_sound_trigger_check_and_get_session(in);
8972
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05308973 lock_input_stream(in);
8974 audio_extn_snd_mon_register_listener(in, in_snd_mon_cb);
8975 pthread_mutex_lock(&adev->lock);
8976 in->card_status = adev->card_status;
8977 pthread_mutex_unlock(&adev->lock);
8978 pthread_mutex_unlock(&in->lock);
8979
Aalique Grahame22e49102018-12-18 14:23:57 -08008980 stream_app_type_cfg_init(&in->app_type_cfg);
8981
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008982 *stream_in = &in->stream;
Derek Chenf939fb72018-11-13 13:34:41 -08008983
8984 streams_input_ctxt_t *in_ctxt = (streams_input_ctxt_t *)
8985 calloc(1, sizeof(streams_input_ctxt_t));
8986 if (in_ctxt == NULL) {
8987 ALOGE("%s fail to allocate input ctxt", __func__);
8988 ret = -ENOMEM;
8989 goto err_open;
8990 }
8991 in_ctxt->input = in;
8992
8993 pthread_mutex_lock(&adev->lock);
8994 list_add_tail(&adev->active_inputs_list, &in_ctxt->list);
8995 pthread_mutex_unlock(&adev->lock);
8996
Eric Laurent994a6932013-07-17 11:51:42 -07008997 ALOGV("%s: exit", __func__);
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08008998 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08008999
9000err_open:
Samyak Jainc37062f2019-04-25 18:41:06 +05309001 if (in->usecase == USECASE_AUDIO_RECORD) {
9002 pthread_mutex_lock(&adev->lock);
9003 adev->pcm_record_uc_state = 0;
9004 pthread_mutex_unlock(&adev->lock);
9005 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009006 free(in);
9007 *stream_in = NULL;
9008 return ret;
9009}
9010
9011static void adev_close_input_stream(struct audio_hw_device *dev,
9012 struct audio_stream_in *stream)
9013{
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08009014 int ret;
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07009015 struct stream_in *in = (struct stream_in *)stream;
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07009016 struct audio_device *adev = (struct audio_device *)dev;
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05309017
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05309018 ALOGD("%s: enter:stream_handle(%p)",__func__, in);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08009019
kunleiz70e57612018-12-28 17:50:23 +08009020 /* must deregister from sndmonitor first to prevent races
9021 * between the callback and close_stream
9022 */
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05309023 audio_extn_snd_mon_unregister_listener(stream);
9024
kunleiz70e57612018-12-28 17:50:23 +08009025 /* Disable echo reference if there are no active input, hfp call
9026 * and sound trigger while closing input stream
9027 */
Eric Laurent637e2d42018-11-15 12:24:31 -08009028 if (adev_get_active_input(adev) == NULL &&
kunleiz70e57612018-12-28 17:50:23 +08009029 !audio_extn_hfp_is_active(adev) &&
9030 !audio_extn_sound_trigger_check_ec_ref_enable())
kunleiz8c93ce62018-11-29 15:04:56 +08009031 platform_set_echo_reference(adev, false, AUDIO_DEVICE_NONE);
kunleiz70e57612018-12-28 17:50:23 +08009032 else
9033 audio_extn_sound_trigger_update_ec_ref_status(false);
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +05309034
Pallavid7c7a272018-01-16 11:22:55 +05309035 if (in == NULL) {
9036 ALOGE("%s: audio_stream_in ptr is NULL", __func__);
9037 return;
9038 }
Weiyin Jiang2995f662019-04-17 14:25:12 +08009039 error_log_destroy(in->error_log);
9040 in->error_log = NULL;
9041
Pallavid7c7a272018-01-16 11:22:55 +05309042
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08009043 if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05309044 pthread_mutex_lock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08009045 ret = voice_extn_compress_voip_close_input_stream(&stream->common);
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05309046 pthread_mutex_unlock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08009047 if (ret != 0)
9048 ALOGE("%s: Compress voip input cannot be closed, error:%d",
9049 __func__, ret);
9050 } else
9051 in_standby(&stream->common);
9052
Revathi Uddarajud2634032017-12-07 14:42:34 +05309053 pthread_mutex_lock(&adev->lock);
Samyak Jain15fda662018-12-18 16:40:52 +05309054 if (in->usecase == USECASE_AUDIO_RECORD) {
9055 adev->pcm_record_uc_state = 0;
9056 }
9057
Shiv Maliyappanahalli5a10aea2015-07-02 10:36:23 -07009058 if (audio_extn_ssr_get_stream() == in) {
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07009059 audio_extn_ssr_deinit();
9060 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009061
Garmond Leunge2433c32017-09-28 21:51:22 -07009062 if (audio_extn_ffv_get_stream() == in) {
9063 audio_extn_ffv_stream_deinit();
9064 }
9065
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05309066 if (audio_extn_compr_cap_enabled() &&
Mingming Yine62d7842013-10-25 16:26:03 -07009067 audio_extn_compr_cap_format_supported(in->config.format))
9068 audio_extn_compr_cap_deinit();
Dhanalakshmi Siddani74cf00b2016-12-02 13:55:57 +05309069
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05309070 if (audio_extn_cin_attached_usecase(in->usecase))
Manish Dewangan46e07982018-12-13 18:18:59 +05309071 audio_extn_cin_free_input_stream_resources(in);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07009072
Mingming Yinfd7607b2016-01-22 12:48:44 -08009073 if (in->is_st_session) {
9074 ALOGV("%s: sound trigger pcm stop lab", __func__);
9075 audio_extn_sound_trigger_stop_lab(in);
9076 }
Derek Chenf939fb72018-11-13 13:34:41 -08009077 streams_input_ctxt_t *in_ctxt = in_get_stream(adev, in->capture_handle);
9078 if (in_ctxt != NULL) {
9079 list_remove(&in_ctxt->list);
9080 free(in_ctxt);
9081 } else {
9082 ALOGW("%s, input stream already closed", __func__);
9083 }
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07009084 free(stream);
Revathi Uddarajud2634032017-12-07 14:42:34 +05309085 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009086 return;
9087}
9088
Aalique Grahame22e49102018-12-18 14:23:57 -08009089/* verifies input and output devices and their capabilities.
9090 *
9091 * This verification is required when enabling extended bit-depth or
9092 * sampling rates, as not all qcom products support it.
9093 *
9094 * Suitable for calling only on initialization such as adev_open().
9095 * It fills the audio_device use_case_table[] array.
9096 *
9097 * Has a side-effect that it needs to configure audio routing / devices
9098 * in order to power up the devices and read the device parameters.
9099 * It does not acquire any hw device lock. Should restore the devices
9100 * back to "normal state" upon completion.
9101 */
9102static int adev_verify_devices(struct audio_device *adev)
9103{
9104 /* enumeration is a bit difficult because one really wants to pull
9105 * the use_case, device id, etc from the hidden pcm_device_table[].
9106 * In this case there are the following use cases and device ids.
9107 *
9108 * [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {0, 0},
9109 * [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {15, 15},
9110 * [USECASE_AUDIO_PLAYBACK_HIFI] = {1, 1},
9111 * [USECASE_AUDIO_PLAYBACK_OFFLOAD] = {9, 9},
9112 * [USECASE_AUDIO_RECORD] = {0, 0},
9113 * [USECASE_AUDIO_RECORD_LOW_LATENCY] = {15, 15},
9114 * [USECASE_VOICE_CALL] = {2, 2},
9115 *
9116 * USECASE_AUDIO_PLAYBACK_OFFLOAD, USECASE_AUDIO_PLAYBACK_HIFI omitted.
9117 * USECASE_VOICE_CALL omitted, but possible for either input or output.
9118 */
9119
9120 /* should be the usecases enabled in adev_open_input_stream() */
9121 static const int test_in_usecases[] = {
9122 USECASE_AUDIO_RECORD,
9123 USECASE_AUDIO_RECORD_LOW_LATENCY, /* does not appear to be used */
9124 };
9125 /* should be the usecases enabled in adev_open_output_stream()*/
9126 static const int test_out_usecases[] = {
9127 USECASE_AUDIO_PLAYBACK_DEEP_BUFFER,
9128 USECASE_AUDIO_PLAYBACK_LOW_LATENCY,
9129 };
9130 static const usecase_type_t usecase_type_by_dir[] = {
9131 PCM_PLAYBACK,
9132 PCM_CAPTURE,
9133 };
9134 static const unsigned flags_by_dir[] = {
9135 PCM_OUT,
9136 PCM_IN,
9137 };
9138
9139 size_t i;
9140 unsigned dir;
9141 const unsigned card_id = adev->snd_card;
9142
9143 for (dir = 0; dir < 2; ++dir) {
9144 const usecase_type_t usecase_type = usecase_type_by_dir[dir];
9145 const unsigned flags_dir = flags_by_dir[dir];
9146 const size_t testsize =
9147 dir ? ARRAY_SIZE(test_in_usecases) : ARRAY_SIZE(test_out_usecases);
9148 const int *testcases =
9149 dir ? test_in_usecases : test_out_usecases;
9150 const audio_devices_t audio_device =
9151 dir ? AUDIO_DEVICE_IN_BUILTIN_MIC : AUDIO_DEVICE_OUT_SPEAKER;
9152
9153 for (i = 0; i < testsize; ++i) {
9154 const audio_usecase_t audio_usecase = testcases[i];
9155 int device_id;
9156 struct pcm_params **pparams;
9157 struct stream_out out;
9158 struct stream_in in;
9159 struct audio_usecase uc_info;
9160 int retval;
9161
9162 pparams = &adev->use_case_table[audio_usecase];
9163 pcm_params_free(*pparams); /* can accept null input */
9164 *pparams = NULL;
9165
9166 /* find the device ID for the use case (signed, for error) */
9167 device_id = platform_get_pcm_device_id(audio_usecase, usecase_type);
9168 if (device_id < 0)
9169 continue;
9170
9171 /* prepare structures for device probing */
9172 memset(&uc_info, 0, sizeof(uc_info));
9173 uc_info.id = audio_usecase;
9174 uc_info.type = usecase_type;
9175 if (dir) {
Aalique Grahame22e49102018-12-18 14:23:57 -08009176 memset(&in, 0, sizeof(in));
9177 in.device = audio_device;
9178 in.source = AUDIO_SOURCE_VOICE_COMMUNICATION;
9179 uc_info.stream.in = &in;
Aalique Grahame22e49102018-12-18 14:23:57 -08009180 }
9181 memset(&out, 0, sizeof(out));
9182 out.devices = audio_device; /* only field needed in select_devices */
9183 uc_info.stream.out = &out;
9184 uc_info.devices = audio_device;
9185 uc_info.in_snd_device = SND_DEVICE_NONE;
9186 uc_info.out_snd_device = SND_DEVICE_NONE;
9187 list_add_tail(&adev->usecase_list, &uc_info.list);
9188
9189 /* select device - similar to start_(in/out)put_stream() */
9190 retval = select_devices(adev, audio_usecase);
9191 if (retval >= 0) {
9192 *pparams = pcm_params_get(card_id, device_id, flags_dir);
9193#if LOG_NDEBUG == 0
Aalique Grahame203bee02019-03-13 17:49:36 -07009194 char info[512]; /* for possible debug info */
Aalique Grahame22e49102018-12-18 14:23:57 -08009195 if (*pparams) {
9196 ALOGV("%s: (%s) card %d device %d", __func__,
9197 dir ? "input" : "output", card_id, device_id);
9198 pcm_params_to_string(*pparams, info, ARRAY_SIZE(info));
9199 } else {
9200 ALOGV("%s: cannot locate card %d device %d", __func__, card_id, device_id);
9201 }
9202#endif
9203 }
9204
9205 /* deselect device - similar to stop_(in/out)put_stream() */
9206 /* 1. Get and set stream specific mixer controls */
9207 retval = disable_audio_route(adev, &uc_info);
9208 /* 2. Disable the rx device */
9209 retval = disable_snd_device(adev,
9210 dir ? uc_info.in_snd_device : uc_info.out_snd_device);
9211 list_remove(&uc_info.list);
9212 }
9213 }
Aalique Grahame22e49102018-12-18 14:23:57 -08009214 return 0;
9215}
9216
Siddartha Shaik31b530e2017-05-19 15:26:33 +05309217int adev_create_audio_patch(struct audio_hw_device *dev,
9218 unsigned int num_sources,
9219 const struct audio_port_config *sources,
9220 unsigned int num_sinks,
9221 const struct audio_port_config *sinks,
9222 audio_patch_handle_t *handle)
9223{
Derek Chenf939fb72018-11-13 13:34:41 -08009224 int ret;
Siddartha Shaik31b530e2017-05-19 15:26:33 +05309225
Derek Chenf939fb72018-11-13 13:34:41 -08009226 ret = audio_extn_hw_loopback_create_audio_patch(dev,
9227 num_sources,
9228 sources,
9229 num_sinks,
9230 sinks,
9231 handle);
9232 ret |= audio_extn_auto_hal_create_audio_patch(dev,
9233 num_sources,
9234 sources,
9235 num_sinks,
9236 sinks,
9237 handle);
9238 return ret;
Siddartha Shaik31b530e2017-05-19 15:26:33 +05309239}
9240
9241int adev_release_audio_patch(struct audio_hw_device *dev,
9242 audio_patch_handle_t handle)
9243{
Derek Chenf939fb72018-11-13 13:34:41 -08009244 int ret;
9245
9246 ret = audio_extn_hw_loopback_release_audio_patch(dev, handle);
9247 ret |= audio_extn_auto_hal_release_audio_patch(dev, handle);
9248 return ret;
Siddartha Shaik31b530e2017-05-19 15:26:33 +05309249}
9250
9251int adev_get_audio_port(struct audio_hw_device *dev, struct audio_port *config)
9252{
Derek Chenf13dd492018-11-13 14:53:51 -08009253 int ret = 0;
9254
9255 ret = audio_extn_hw_loopback_get_audio_port(dev, config);
9256 ret |= audio_extn_auto_hal_get_audio_port(dev, config);
9257 return ret;
Siddartha Shaik31b530e2017-05-19 15:26:33 +05309258}
9259
9260int adev_set_audio_port_config(struct audio_hw_device *dev,
9261 const struct audio_port_config *config)
9262{
Derek Chenf13dd492018-11-13 14:53:51 -08009263 int ret = 0;
9264
9265 ret = audio_extn_hw_loopback_set_audio_port_config(dev, config);
9266 ret |= audio_extn_auto_hal_set_audio_port_config(dev, config);
9267 return ret;
Siddartha Shaik31b530e2017-05-19 15:26:33 +05309268}
9269
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07009270static int adev_dump(const audio_hw_device_t *device __unused,
9271 int fd __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009272{
9273 return 0;
9274}
9275
9276static int adev_close(hw_device_t *device)
9277{
Aalique Grahame22e49102018-12-18 14:23:57 -08009278 size_t i;
Preetam Singh Ranawatacc64542019-06-24 15:11:28 +05309279 struct audio_device *adev_temp = (struct audio_device *)device;
Kiran Kandi910e1862013-10-29 13:29:42 -07009280
Preetam Singh Ranawatacc64542019-06-24 15:11:28 +05309281 if (!adev_temp)
Kiran Kandi910e1862013-10-29 13:29:42 -07009282 return 0;
9283
9284 pthread_mutex_lock(&adev_init_lock);
9285
9286 if ((--audio_device_ref_count) == 0) {
Sujin Panicker390724d2019-04-26 10:43:36 +05309287 if (audio_extn_spkr_prot_is_enabled())
9288 audio_extn_spkr_prot_deinit();
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05309289 audio_extn_snd_mon_unregister_listener(adev);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07009290 audio_extn_sound_trigger_deinit(adev);
Kiran Kandide144c82013-11-20 15:58:32 -08009291 audio_extn_listen_deinit(adev);
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08009292 audio_extn_qdsp_deinit();
Aalique Grahame22e49102018-12-18 14:23:57 -08009293 audio_extn_extspk_deinit(adev->extspk);
Dhananjay Kumard6d32152016-10-13 16:11:03 +05309294 audio_extn_utils_release_streams_cfg_lists(
9295 &adev->streams_output_cfg_list,
9296 &adev->streams_input_cfg_list);
Sidipotu Ashokd2f10ba2019-05-06 15:41:56 +05309297 if (audio_extn_qap_is_enabled())
9298 audio_extn_qap_deinit();
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05309299 if (audio_extn_qaf_is_enabled())
9300 audio_extn_qaf_deinit();
Kiran Kandi910e1862013-10-29 13:29:42 -07009301 audio_route_free(adev->audio_route);
Weiyin Jiangfa65d3e2019-03-05 23:39:45 +08009302 audio_extn_gef_deinit(adev);
Kiran Kandi910e1862013-10-29 13:29:42 -07009303 free(adev->snd_dev_ref_cnt);
9304 platform_deinit(adev->platform);
Aalique Grahame22e49102018-12-18 14:23:57 -08009305 for (i = 0; i < ARRAY_SIZE(adev->use_case_table); ++i) {
9306 pcm_params_free(adev->use_case_table[i]);
9307 }
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07009308 if (adev->adm_deinit)
9309 adev->adm_deinit(adev->adm_data);
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05309310 qahwi_deinit(device);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08009311 audio_extn_adsp_hdlr_deinit();
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05309312 audio_extn_snd_mon_deinit();
Siddartha Shaik44dd7702017-06-14 12:13:25 +05309313 audio_extn_hw_loopback_deinit(adev);
Garmond Leunge2433c32017-09-28 21:51:22 -07009314 audio_extn_ffv_deinit();
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +05309315 if (adev->device_cfg_params) {
9316 free(adev->device_cfg_params);
9317 adev->device_cfg_params = NULL;
9318 }
Derek Chend2530072014-11-24 12:39:14 -08009319 if(adev->ext_hw_plugin)
9320 audio_extn_ext_hw_plugin_deinit(adev->ext_hw_plugin);
Derek Chenae7b0342019-02-08 15:17:04 -08009321 audio_extn_auto_hal_deinit();
Kiran Kandi910e1862013-10-29 13:29:42 -07009322 free(device);
9323 adev = NULL;
9324 }
9325 pthread_mutex_unlock(&adev_init_lock);
Vatsal Buchac09ae062018-11-14 13:25:08 +05309326 enable_gcov();
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009327 return 0;
9328}
9329
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07009330/* This returns 1 if the input parameter looks at all plausible as a low latency period size,
9331 * or 0 otherwise. A return value of 1 doesn't mean the value is guaranteed to work,
9332 * just that it _might_ work.
9333 */
9334static int period_size_is_plausible_for_low_latency(int period_size)
9335{
9336 switch (period_size) {
9337 case 160:
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -07009338 case 192:
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07009339 case 240:
9340 case 320:
9341 case 480:
9342 return 1;
9343 default:
9344 return 0;
9345 }
9346}
9347
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05309348static void adev_snd_mon_cb(void *cookie, struct str_parms *parms)
9349{
9350 bool is_snd_card_status = false;
9351 bool is_ext_device_status = false;
9352 char value[32];
9353 int card = -1;
9354 card_status_t status;
9355
9356 if (cookie != adev || !parms)
9357 return;
9358
9359 if (!parse_snd_card_status(parms, &card, &status)) {
9360 is_snd_card_status = true;
9361 } else if (0 < str_parms_get_str(parms, "ext_audio_device", value, sizeof(value))) {
9362 is_ext_device_status = true;
9363 } else {
9364 // not a valid event
9365 return;
9366 }
9367
9368 pthread_mutex_lock(&adev->lock);
9369 if (card == adev->snd_card || is_ext_device_status) {
9370 if (is_snd_card_status && adev->card_status != status) {
9371 adev->card_status = status;
9372 platform_snd_card_update(adev->platform, status);
9373 audio_extn_fm_set_parameters(adev, parms);
Derek Chend6f371d2019-03-01 13:45:58 -08009374 audio_extn_auto_hal_set_parameters(adev, parms);
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05309375 } else if (is_ext_device_status) {
9376 platform_set_parameters(adev->platform, parms);
9377 }
9378 }
9379 pthread_mutex_unlock(&adev->lock);
9380 return;
9381}
9382
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05309383/* out and adev lock held */
9384static int check_a2dp_restore_l(struct audio_device *adev, struct stream_out *out, bool restore)
9385{
9386 struct audio_usecase *uc_info;
9387 float left_p;
9388 float right_p;
9389 audio_devices_t devices;
9390
9391 uc_info = get_usecase_from_list(adev, out->usecase);
9392 if (uc_info == NULL) {
9393 ALOGE("%s: Could not find the usecase (%d) in the list",
9394 __func__, out->usecase);
9395 return -EINVAL;
9396 }
9397
9398 ALOGD("%s: enter: usecase(%d: %s)", __func__,
9399 out->usecase, use_case_table[out->usecase]);
9400
9401 if (restore) {
9402 // restore A2DP device for active usecases and unmute if required
9403 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
9404 (uc_info->out_snd_device != SND_DEVICE_OUT_BT_A2DP)) {
9405 ALOGD("%s: restoring A2dp and unmuting stream", __func__);
9406 select_devices(adev, uc_info->id);
9407 pthread_mutex_lock(&out->compr_mute_lock);
9408 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
Manisha Agarwalc2188fb2019-05-27 10:00:29 +05309409 (out->a2dp_compress_mute) && (uc_info->out_snd_device == SND_DEVICE_OUT_BT_A2DP)) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05309410 out->a2dp_compress_mute = false;
9411 out_set_compr_volume(&out->stream, out->volume_l, out->volume_r);
9412 }
9413 pthread_mutex_unlock(&out->compr_mute_lock);
9414 }
9415 } else {
9416 // mute compress stream if suspended
9417 pthread_mutex_lock(&out->compr_mute_lock);
9418 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
9419 (!out->a2dp_compress_mute)) {
9420 if (!out->standby) {
9421 ALOGD("%s: selecting speaker and muting stream", __func__);
9422 devices = out->devices;
9423 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
9424 left_p = out->volume_l;
9425 right_p = out->volume_r;
9426 if (out->offload_state == OFFLOAD_STATE_PLAYING)
9427 compress_pause(out->compr);
9428 out_set_compr_volume(&out->stream, (float)0, (float)0);
9429 out->a2dp_compress_mute = true;
9430 select_devices(adev, out->usecase);
9431 if (out->offload_state == OFFLOAD_STATE_PLAYING)
9432 compress_resume(out->compr);
9433 out->devices = devices;
9434 out->volume_l = left_p;
9435 out->volume_r = right_p;
9436 }
9437 }
9438 pthread_mutex_unlock(&out->compr_mute_lock);
9439 }
9440 ALOGV("%s: exit", __func__);
9441 return 0;
9442}
9443
9444int check_a2dp_restore(struct audio_device *adev, struct stream_out *out, bool restore)
9445{
9446 int ret = 0;
9447
9448 lock_output_stream(out);
9449 pthread_mutex_lock(&adev->lock);
9450
9451 ret = check_a2dp_restore_l(adev, out, restore);
9452
9453 pthread_mutex_unlock(&adev->lock);
9454 pthread_mutex_unlock(&out->lock);
9455 return ret;
9456}
9457
Haynes Mathew George01156f92018-04-13 15:29:54 -07009458void adev_on_battery_status_changed(bool charging)
9459{
9460 pthread_mutex_lock(&adev->lock);
9461 ALOGI("%s: battery status changed to %scharging", __func__, charging ? "" : "not ");
9462 adev->is_charging = charging;
Zhou Songc1088ea2018-06-12 00:17:29 +08009463 audio_extn_sound_trigger_update_battery_status(charging);
Haynes Mathew George01156f92018-04-13 15:29:54 -07009464 pthread_mutex_unlock(&adev->lock);
9465}
9466
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009467static int adev_open(const hw_module_t *module, const char *name,
9468 hw_device_t **device)
9469{
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05309470 int ret;
Derek Chenf939fb72018-11-13 13:34:41 -08009471 char value[PROPERTY_VALUE_MAX] = {0};
Dhanalakshmi Siddani20628c82019-01-27 17:31:09 +05309472 char mixer_ctl_name[128] = {0};
9473 struct mixer_ctl *ctl = NULL;
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05309474
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08009475 ALOGD("%s: enter", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009476 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL;
9477
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07009478 pthread_mutex_lock(&adev_init_lock);
Kiran Kandi910e1862013-10-29 13:29:42 -07009479 if (audio_device_ref_count != 0){
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07009480 *device = &adev->device.common;
Kiran Kandi910e1862013-10-29 13:29:42 -07009481 audio_device_ref_count++;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07009482 ALOGD("%s: returning existing instance of adev", __func__);
9483 ALOGD("%s: exit", __func__);
9484 pthread_mutex_unlock(&adev_init_lock);
9485 return 0;
9486 }
9487
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009488 adev = calloc(1, sizeof(struct audio_device));
9489
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07009490 if (!adev) {
9491 pthread_mutex_unlock(&adev_init_lock);
9492 return -ENOMEM;
9493 }
9494
Ravi Kumar Alamanda40703102014-04-24 10:34:41 -07009495 pthread_mutex_init(&adev->lock, (const pthread_mutexattr_t *) NULL);
9496
Weiyin Jiange6ce6312019-01-28 18:28:22 +08009497 // register audio ext hidl at the earliest
9498 audio_extn_hidl_init();
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +05309499#ifdef DYNAMIC_LOG_ENABLED
9500 register_for_dynamic_logging("hal");
9501#endif
9502
Derek Chenf939fb72018-11-13 13:34:41 -08009503 /* default audio HAL major version */
9504 uint32_t maj_version = 2;
9505 if(property_get("vendor.audio.hal.maj.version", value, NULL))
9506 maj_version = atoi(value);
9507
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009508 adev->device.common.tag = HARDWARE_DEVICE_TAG;
Derek Chenf939fb72018-11-13 13:34:41 -08009509 adev->device.common.version = HARDWARE_DEVICE_API_VERSION(maj_version, 0);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009510 adev->device.common.module = (struct hw_module_t *)module;
9511 adev->device.common.close = adev_close;
9512
9513 adev->device.init_check = adev_init_check;
9514 adev->device.set_voice_volume = adev_set_voice_volume;
9515 adev->device.set_master_volume = adev_set_master_volume;
9516 adev->device.get_master_volume = adev_get_master_volume;
9517 adev->device.set_master_mute = adev_set_master_mute;
9518 adev->device.get_master_mute = adev_get_master_mute;
9519 adev->device.set_mode = adev_set_mode;
9520 adev->device.set_mic_mute = adev_set_mic_mute;
9521 adev->device.get_mic_mute = adev_get_mic_mute;
9522 adev->device.set_parameters = adev_set_parameters;
9523 adev->device.get_parameters = adev_get_parameters;
9524 adev->device.get_input_buffer_size = adev_get_input_buffer_size;
9525 adev->device.open_output_stream = adev_open_output_stream;
9526 adev->device.close_output_stream = adev_close_output_stream;
9527 adev->device.open_input_stream = adev_open_input_stream;
9528 adev->device.close_input_stream = adev_close_input_stream;
Siddartha Shaik31b530e2017-05-19 15:26:33 +05309529 adev->device.create_audio_patch = adev_create_audio_patch;
9530 adev->device.release_audio_patch = adev_release_audio_patch;
9531 adev->device.get_audio_port = adev_get_audio_port;
9532 adev->device.set_audio_port_config = adev_set_audio_port_config;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009533 adev->device.dump = adev_dump;
Naresh Tannirudcb47c52018-06-25 16:23:32 +05309534 adev->device.get_microphones = adev_get_microphones;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009535
9536 /* Set the default route before the PCM stream is opened */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009537 adev->mode = AUDIO_MODE_NORMAL;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08009538 adev->primary_output = NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009539 adev->out_device = AUDIO_DEVICE_NONE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009540 adev->bluetooth_nrec = true;
Ravi Kumar Alamandaf9967042013-02-14 19:35:14 -08009541 adev->acdb_settings = TTY_MODE_OFF;
vivek mehta344576a2016-04-12 18:56:03 -07009542 adev->allow_afe_proxy_usage = true;
Ashish Jain1b9b30c2017-05-18 20:57:40 +05309543 adev->bt_sco_on = false;
Eric Laurent07eeafd2013-10-06 12:52:49 -07009544 /* adev->cur_hdmi_channels = 0; by calloc() */
Eric Laurentb23d5282013-05-14 15:27:20 -07009545 adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int));
vivek mehtaae1018c2019-05-09 12:19:57 -07009546 /* Init audio and voice feature */
9547 audio_extn_feature_init();
9548 voice_extn_feature_init();
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07009549 voice_init(adev);
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08009550 list_init(&adev->usecase_list);
Derek Chenf939fb72018-11-13 13:34:41 -08009551 list_init(&adev->active_inputs_list);
9552 list_init(&adev->active_outputs_list);
Krishnankutty Kolathappilly0b2de1c2014-02-14 14:45:49 -08009553 adev->cur_wfd_channels = 2;
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07009554 adev->offload_usecases_state = 0;
Samyak Jain15fda662018-12-18 16:40:52 +05309555 adev->pcm_record_uc_state = 0;
Ashish Jain81eb2a82015-05-13 10:52:34 +05309556 adev->is_channel_status_set = false;
Sudheer Papothifa9d2282015-09-17 01:53:25 +05309557 adev->perf_lock_opts[0] = 0x101;
9558 adev->perf_lock_opts[1] = 0x20E;
9559 adev->perf_lock_opts_size = 2;
Xiaojun Sang785b5da2017-08-03 15:52:29 +08009560 adev->dsp_bit_width_enforce_mode = 0;
Aalique Grahame552b0832019-03-11 10:16:38 -07009561 adev->enable_hfp = false;
Dhanalakshmi Siddani20628c82019-01-27 17:31:09 +05309562 adev->use_old_pspd_mix_ctrl = false;
Aniket Kumar Lata60586a92019-05-22 22:18:55 -07009563 adev->adm_routing_changed = false;
Naresh Tanniru4c630392014-05-12 01:05:52 +05309564
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009565 /* Loads platform specific libraries dynamically */
Eric Laurentb23d5282013-05-14 15:27:20 -07009566 adev->platform = platform_init(adev);
9567 if (!adev->platform) {
Ben Romberger2684ad72018-06-04 12:41:39 -07009568 pthread_mutex_destroy(&adev->lock);
Eric Laurentb23d5282013-05-14 15:27:20 -07009569 free(adev->snd_dev_ref_cnt);
9570 free(adev);
Ben Romberger2684ad72018-06-04 12:41:39 -07009571 adev = NULL;
Eric Laurentb23d5282013-05-14 15:27:20 -07009572 ALOGE("%s: Failed to init platform data, aborting.", __func__);
9573 *device = NULL;
Apoorv Raghuvanshi6e57d7e2013-12-16 16:02:45 -08009574 pthread_mutex_unlock(&adev_init_lock);
Eric Laurentb23d5282013-05-14 15:27:20 -07009575 return -EINVAL;
9576 }
Eric Laurentc4aef752013-09-12 17:45:53 -07009577
Aalique Grahame22e49102018-12-18 14:23:57 -08009578 adev->extspk = audio_extn_extspk_init(adev);
Sidipotu Ashokd2f10ba2019-05-06 15:41:56 +05309579 if (audio_extn_qap_is_enabled()) {
9580 ret = audio_extn_qap_init(adev);
9581 if (ret < 0) {
9582 pthread_mutex_destroy(&adev->lock);
9583 free(adev);
9584 adev = NULL;
9585 ALOGE("%s: Failed to init platform data, aborting.", __func__);
9586 *device = NULL;
9587 pthread_mutex_unlock(&adev_init_lock);
9588 return ret;
9589 }
9590 adev->device.open_output_stream = audio_extn_qap_open_output_stream;
9591 adev->device.close_output_stream = audio_extn_qap_close_output_stream;
9592 }
Aalique Grahame22e49102018-12-18 14:23:57 -08009593
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05309594 if (audio_extn_qaf_is_enabled()) {
9595 ret = audio_extn_qaf_init(adev);
9596 if (ret < 0) {
Ben Romberger2684ad72018-06-04 12:41:39 -07009597 pthread_mutex_destroy(&adev->lock);
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05309598 free(adev);
Ben Romberger2684ad72018-06-04 12:41:39 -07009599 adev = NULL;
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05309600 ALOGE("%s: Failed to init platform data, aborting.", __func__);
9601 *device = NULL;
9602 pthread_mutex_unlock(&adev_init_lock);
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05309603 return ret;
9604 }
9605
9606 adev->device.open_output_stream = audio_extn_qaf_open_output_stream;
9607 adev->device.close_output_stream = audio_extn_qaf_close_output_stream;
9608 }
9609
Derek Chenae7b0342019-02-08 15:17:04 -08009610 audio_extn_auto_hal_init(adev);
Derek Chend2530072014-11-24 12:39:14 -08009611 adev->ext_hw_plugin = audio_extn_ext_hw_plugin_init(adev);
9612
Eric Laurentc4aef752013-09-12 17:45:53 -07009613 if (access(VISUALIZER_LIBRARY_PATH, R_OK) == 0) {
9614 adev->visualizer_lib = dlopen(VISUALIZER_LIBRARY_PATH, RTLD_NOW);
9615 if (adev->visualizer_lib == NULL) {
9616 ALOGE("%s: DLOPEN failed for %s", __func__, VISUALIZER_LIBRARY_PATH);
9617 } else {
9618 ALOGV("%s: DLOPEN successful for %s", __func__, VISUALIZER_LIBRARY_PATH);
9619 adev->visualizer_start_output =
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08009620 (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib,
Eric Laurentc4aef752013-09-12 17:45:53 -07009621 "visualizer_hal_start_output");
9622 adev->visualizer_stop_output =
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08009623 (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib,
Eric Laurentc4aef752013-09-12 17:45:53 -07009624 "visualizer_hal_stop_output");
9625 }
9626 }
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +05309627 audio_extn_init(adev);
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08009628 voice_extn_init(adev);
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -08009629 audio_extn_listen_init(adev, adev->snd_card);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +08009630 audio_extn_gef_init(adev);
Siddartha Shaik44dd7702017-06-14 12:13:25 +05309631 audio_extn_hw_loopback_init(adev);
Garmond Leunge2433c32017-09-28 21:51:22 -07009632 audio_extn_ffv_init(adev);
Eric Laurentc4aef752013-09-12 17:45:53 -07009633
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08009634 if (access(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, R_OK) == 0) {
9635 adev->offload_effects_lib = dlopen(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, RTLD_NOW);
9636 if (adev->offload_effects_lib == NULL) {
9637 ALOGE("%s: DLOPEN failed for %s", __func__,
9638 OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH);
9639 } else {
9640 ALOGV("%s: DLOPEN successful for %s", __func__,
9641 OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH);
9642 adev->offload_effects_start_output =
Ashish Jain5106d362016-05-11 19:23:33 +05309643 (int (*)(audio_io_handle_t, int, struct mixer *))dlsym(adev->offload_effects_lib,
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08009644 "offload_effects_bundle_hal_start_output");
9645 adev->offload_effects_stop_output =
9646 (int (*)(audio_io_handle_t, int))dlsym(adev->offload_effects_lib,
9647 "offload_effects_bundle_hal_stop_output");
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08009648 adev->offload_effects_set_hpx_state =
9649 (int (*)(bool))dlsym(adev->offload_effects_lib,
9650 "offload_effects_bundle_set_hpx_state");
Dhananjay Kumard68883d2015-09-04 13:39:26 +05309651 adev->offload_effects_get_parameters =
9652 (void (*)(struct str_parms *, struct str_parms *))
9653 dlsym(adev->offload_effects_lib,
9654 "offload_effects_bundle_get_parameters");
9655 adev->offload_effects_set_parameters =
9656 (void (*)(struct str_parms *))dlsym(adev->offload_effects_lib,
9657 "offload_effects_bundle_set_parameters");
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08009658 }
9659 }
9660
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07009661 if (access(ADM_LIBRARY_PATH, R_OK) == 0) {
9662 adev->adm_lib = dlopen(ADM_LIBRARY_PATH, RTLD_NOW);
9663 if (adev->adm_lib == NULL) {
9664 ALOGE("%s: DLOPEN failed for %s", __func__, ADM_LIBRARY_PATH);
9665 } else {
9666 ALOGV("%s: DLOPEN successful for %s", __func__, ADM_LIBRARY_PATH);
9667 adev->adm_init = (adm_init_t)
9668 dlsym(adev->adm_lib, "adm_init");
9669 adev->adm_deinit = (adm_deinit_t)
9670 dlsym(adev->adm_lib, "adm_deinit");
9671 adev->adm_register_input_stream = (adm_register_input_stream_t)
9672 dlsym(adev->adm_lib, "adm_register_input_stream");
9673 adev->adm_register_output_stream = (adm_register_output_stream_t)
9674 dlsym(adev->adm_lib, "adm_register_output_stream");
9675 adev->adm_deregister_stream = (adm_deregister_stream_t)
9676 dlsym(adev->adm_lib, "adm_deregister_stream");
9677 adev->adm_request_focus = (adm_request_focus_t)
9678 dlsym(adev->adm_lib, "adm_request_focus");
9679 adev->adm_abandon_focus = (adm_abandon_focus_t)
9680 dlsym(adev->adm_lib, "adm_abandon_focus");
Haynes Mathew George5beddd42016-06-27 18:33:40 -07009681 adev->adm_set_config = (adm_set_config_t)
9682 dlsym(adev->adm_lib, "adm_set_config");
9683 adev->adm_request_focus_v2 = (adm_request_focus_v2_t)
9684 dlsym(adev->adm_lib, "adm_request_focus_v2");
9685 adev->adm_is_noirq_avail = (adm_is_noirq_avail_t)
9686 dlsym(adev->adm_lib, "adm_is_noirq_avail");
9687 adev->adm_on_routing_change = (adm_on_routing_change_t)
9688 dlsym(adev->adm_lib, "adm_on_routing_change");
Aniket Kumar Lata60586a92019-05-22 22:18:55 -07009689 adev->adm_request_focus_v2_1 = (adm_request_focus_v2_1_t)
9690 dlsym(adev->adm_lib, "adm_request_focus_v2_1");
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07009691 }
9692 }
9693
Aalique Grahame22e49102018-12-18 14:23:57 -08009694 adev->enable_voicerx = false;
Mingming Yin514a8bc2014-07-29 15:22:21 -07009695 adev->bt_wb_speech_enabled = false;
Zhou Song12c29502019-03-16 10:37:18 +08009696 adev->swb_speech_mode = SPEECH_MODE_INVALID;
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08009697 //initialize this to false for now,
9698 //this will be set to true through set param
9699 adev->vr_audio_mode_enabled = false;
Mingming Yin514a8bc2014-07-29 15:22:21 -07009700
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -07009701 audio_extn_ds2_enable(adev);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009702 *device = &adev->device.common;
Aalique Grahame22e49102018-12-18 14:23:57 -08009703
9704 if (k_enable_extended_precision)
9705 adev_verify_devices(adev);
9706
Xiaojun Sang785b5da2017-08-03 15:52:29 +08009707 adev->dsp_bit_width_enforce_mode =
9708 adev_init_dsp_bit_width_enforce_mode(adev->mixer);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009709
Dhananjay Kumard6d32152016-10-13 16:11:03 +05309710 audio_extn_utils_update_streams_cfg_lists(adev->platform, adev->mixer,
9711 &adev->streams_output_cfg_list,
9712 &adev->streams_input_cfg_list);
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -07009713
Kiran Kandi910e1862013-10-29 13:29:42 -07009714 audio_device_ref_count++;
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07009715
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07009716 int trial;
Aalique Grahame22e49102018-12-18 14:23:57 -08009717 if ((property_get("vendor.audio_hal.period_size", value, NULL) > 0) ||
9718 (property_get("audio_hal.period_size", value, NULL) > 0)) {
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07009719 trial = atoi(value);
9720 if (period_size_is_plausible_for_low_latency(trial)) {
9721 pcm_config_low_latency.period_size = trial;
9722 pcm_config_low_latency.start_threshold = trial / 4;
9723 pcm_config_low_latency.avail_min = trial / 4;
9724 configured_low_latency_capture_period_size = trial;
9725 }
9726 }
Aalique Grahame22e49102018-12-18 14:23:57 -08009727 if ((property_get("vendor.audio_hal.in_period_size", value, NULL) > 0) ||
9728 (property_get("audio_hal.in_period_size", value, NULL) > 0)) {
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07009729 trial = atoi(value);
9730 if (period_size_is_plausible_for_low_latency(trial)) {
9731 configured_low_latency_capture_period_size = trial;
9732 }
9733 }
9734
Vignesh Kulothungan7d374312018-02-21 17:12:00 -08009735 adev->mic_break_enabled = property_get_bool("vendor.audio.mic_break", false);
9736
Eric Laurent4b084132018-10-19 17:33:43 -07009737 adev->camera_orientation = CAMERA_DEFAULT;
9738
Aalique Grahame22e49102018-12-18 14:23:57 -08009739 if ((property_get("vendor.audio_hal.period_multiplier",value,NULL) > 0) ||
9740 (property_get("audio_hal.period_multiplier",value,NULL) > 0)) {
Haynes Mathew George5beddd42016-06-27 18:33:40 -07009741 af_period_multiplier = atoi(value);
9742 if (af_period_multiplier < 0)
9743 af_period_multiplier = 2;
9744 else if (af_period_multiplier > 4)
9745 af_period_multiplier = 4;
9746
9747 ALOGV("new period_multiplier = %d", af_period_multiplier);
9748 }
9749
Arun Mirpurib1bec9c2019-01-29 16:42:45 -08009750 audio_extn_qdsp_init(adev->platform);
Aalique Grahame22e49102018-12-18 14:23:57 -08009751
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -07009752 adev->multi_offload_enable = property_get_bool("vendor.audio.offload.multiple.enabled", false);
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07009753 pthread_mutex_unlock(&adev_init_lock);
9754
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07009755 if (adev->adm_init)
9756 adev->adm_data = adev->adm_init();
9757
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05309758 qahwi_init(*device);
Sudheer Papothifa9d2282015-09-17 01:53:25 +05309759 audio_extn_perf_lock_init();
Ben Rombergerd771a7c2017-02-22 18:05:17 -08009760 audio_extn_adsp_hdlr_init(adev->mixer);
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05309761
9762 audio_extn_snd_mon_init();
9763 pthread_mutex_lock(&adev->lock);
9764 audio_extn_snd_mon_register_listener(adev, adev_snd_mon_cb);
9765 adev->card_status = CARD_STATUS_ONLINE;
Haynes Mathew George01156f92018-04-13 15:29:54 -07009766 audio_extn_battery_properties_listener_init(adev_on_battery_status_changed);
9767 /*
9768 * if the battery state callback happens before charging can be queried,
9769 * it will be guarded with the adev->lock held in the cb function and so
9770 * the callback value will reflect the latest state
9771 */
9772 adev->is_charging = audio_extn_battery_properties_is_charging();
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05309773 audio_extn_sound_trigger_init(adev); /* dependent on snd_mon_init() */
Zhou Songc1088ea2018-06-12 00:17:29 +08009774 audio_extn_sound_trigger_update_battery_status(adev->is_charging);
justinweng20fb6d82019-02-21 18:49:00 -07009775 audio_extn_audiozoom_init();
Zhou Songc1088ea2018-06-12 00:17:29 +08009776 pthread_mutex_unlock(&adev->lock);
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +05309777 /* Allocate memory for Device config params */
9778 adev->device_cfg_params = (struct audio_device_config_param*)
9779 calloc(platform_get_max_codec_backend(),
9780 sizeof(struct audio_device_config_param));
9781 if (adev->device_cfg_params == NULL)
9782 ALOGE("%s: Memory allocation failed for Device config params", __func__);
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05309783
Dhanalakshmi Siddani20628c82019-01-27 17:31:09 +05309784 /*
9785 * Check if new PSPD matrix mixer control is supported. If not
9786 * supported, then set flag so that old mixer ctrl is sent while
9787 * sending pspd coefficients on older kernel version. Query mixer
9788 * control for default pcm id and channel value one.
9789 */
9790 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
9791 "AudStr %d ChMixer Weight Ch %d", 0, 1);
9792
9793 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
9794 if (!ctl) {
9795 ALOGE("%s: ERROR. Could not get ctl for mixer cmd - %s",
9796 __func__, mixer_ctl_name);
9797 adev->use_old_pspd_mix_ctrl = true;
9798 }
9799
Eric Laurent994a6932013-07-17 11:51:42 -07009800 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009801 return 0;
9802}
9803
9804static struct hw_module_methods_t hal_module_methods = {
9805 .open = adev_open,
9806};
9807
9808struct audio_module HAL_MODULE_INFO_SYM = {
9809 .common = {
9810 .tag = HARDWARE_MODULE_TAG,
9811 .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
9812 .hal_api_version = HARDWARE_HAL_API_VERSION,
9813 .id = AUDIO_HARDWARE_MODULE_ID,
9814 .name = "QCOM Audio HAL",
Duy Truongfae19622013-11-24 02:17:54 -08009815 .author = "The Linux Foundation",
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08009816 .methods = &hal_module_methods,
9817 },
9818};