blob: dd3d8755700b25fe1da290e57445212631db34a5 [file] [log] [blame]
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001/*
Arun Kumar Dasari3b174182016-12-27 13:01:14 +05302 * Copyright (c) 2013-2017, 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
58#include <cutils/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>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080064
Eric Laurentb23d5282013-05-14 15:27:20 -070065#include <hardware/audio_effect.h>
Haynes Mathew George484e8d22017-07-31 18:55:17 -070066#include <hardware/audio_alsaops.h>
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070067#include <system/thread_defs.h>
Haynes Mathew George16081042017-05-31 17:16:49 -070068#include <tinyalsa/asoundlib.h>
Eric Laurentb23d5282013-05-14 15:27:20 -070069#include <audio_effects/effect_aec.h>
70#include <audio_effects/effect_ns.h>
Ashish Jainf1eaa582016-05-23 20:54:24 +053071#include <audio_utils/format.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080072#include "audio_hw.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
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +053093#define DSD_VOLUME_MIN_DB (-110)
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070094
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -070095#define PROXY_OPEN_RETRY_COUNT 100
96#define PROXY_OPEN_WAIT_TIME 20
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -080097
Mingming Yin08c7e312015-03-16 18:10:58 -070098#ifdef USE_LL_AS_PRIMARY_OUTPUT
99#define USECASE_AUDIO_PLAYBACK_PRIMARY USECASE_AUDIO_PLAYBACK_LOW_LATENCY
100#define PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY pcm_config_low_latency
101#else
Haynes Mathew Georgebf143712013-12-03 13:02:53 -0800102#define USECASE_AUDIO_PLAYBACK_PRIMARY USECASE_AUDIO_PLAYBACK_DEEP_BUFFER
Mingming Yin08c7e312015-03-16 18:10:58 -0700103#define PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY pcm_config_deep_buffer
104#endif
Haynes Mathew Georgebf143712013-12-03 13:02:53 -0800105
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700106#define ULL_PERIOD_SIZE (DEFAULT_OUTPUT_SAMPLING_RATE/1000)
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700107#define DEFAULT_VOIP_BUF_DURATION_MS 20
108#define DEFAULT_VOIP_BIT_DEPTH_BYTE sizeof(int16_t)
109#define DEFAULT_VOIP_SAMP_RATE 48000
110
111#define VOIP_IO_BUF_SIZE(SR, DURATION_MS, BIT_DEPTH) (SR)/1000 * DURATION_MS * BIT_DEPTH
112
113struct pcm_config default_pcm_config_voip_copp = {
114 .channels = 1,
115 .rate = DEFAULT_VOIP_SAMP_RATE, /* changed when the stream is opened */
116 .period_size = VOIP_IO_BUF_SIZE(DEFAULT_VOIP_SAMP_RATE, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2,
117 .period_count = 2,
118 .format = PCM_FORMAT_S16_LE,
kunleiz95b597a2017-10-23 17:07:33 +0800119 .avail_min = VOIP_IO_BUF_SIZE(DEFAULT_VOIP_SAMP_RATE, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2,
120 .stop_threshold = INT_MAX,
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700121};
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700122
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700123#define MIN_CHANNEL_COUNT 1
124#define DEFAULT_CHANNEL_COUNT 2
125#define MAX_HIFI_CHANNEL_COUNT 8
126
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -0700127static unsigned int configured_low_latency_capture_period_size =
128 LOW_LATENCY_CAPTURE_PERIOD_SIZE;
129
Haynes Mathew George16081042017-05-31 17:16:49 -0700130#define MMAP_PERIOD_SIZE (DEFAULT_OUTPUT_SAMPLING_RATE/1000)
131#define MMAP_PERIOD_COUNT_MIN 32
132#define MMAP_PERIOD_COUNT_MAX 512
133#define MMAP_PERIOD_COUNT_DEFAULT (MMAP_PERIOD_COUNT_MAX)
134
Eric Laurentb23d5282013-05-14 15:27:20 -0700135struct pcm_config pcm_config_deep_buffer = {
136 .channels = 2,
137 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
138 .period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE,
139 .period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT,
140 .format = PCM_FORMAT_S16_LE,
141 .start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
142 .stop_threshold = INT_MAX,
143 .avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
144};
145
146struct pcm_config pcm_config_low_latency = {
147 .channels = 2,
148 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
149 .period_size = LOW_LATENCY_OUTPUT_PERIOD_SIZE,
150 .period_count = LOW_LATENCY_OUTPUT_PERIOD_COUNT,
151 .format = PCM_FORMAT_S16_LE,
152 .start_threshold = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
153 .stop_threshold = INT_MAX,
154 .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
155};
156
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700157static int af_period_multiplier = 4;
158struct pcm_config pcm_config_rt = {
159 .channels = 2,
160 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
161 .period_size = ULL_PERIOD_SIZE, //1 ms
162 .period_count = 512, //=> buffer size is 512ms
163 .format = PCM_FORMAT_S16_LE,
164 .start_threshold = ULL_PERIOD_SIZE*8, //8ms
165 .stop_threshold = INT_MAX,
166 .silence_threshold = 0,
167 .silence_size = 0,
168 .avail_min = ULL_PERIOD_SIZE, //1 ms
169};
170
Eric Laurentb23d5282013-05-14 15:27:20 -0700171struct pcm_config pcm_config_hdmi_multi = {
172 .channels = HDMI_MULTI_DEFAULT_CHANNEL_COUNT, /* changed when the stream is opened */
173 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, /* changed when the stream is opened */
174 .period_size = HDMI_MULTI_PERIOD_SIZE,
175 .period_count = HDMI_MULTI_PERIOD_COUNT,
176 .format = PCM_FORMAT_S16_LE,
177 .start_threshold = 0,
178 .stop_threshold = INT_MAX,
179 .avail_min = 0,
180};
181
Haynes Mathew George16081042017-05-31 17:16:49 -0700182struct pcm_config pcm_config_mmap_playback = {
183 .channels = 2,
184 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
185 .period_size = MMAP_PERIOD_SIZE,
186 .period_count = MMAP_PERIOD_COUNT_DEFAULT,
187 .format = PCM_FORMAT_S16_LE,
188 .start_threshold = MMAP_PERIOD_SIZE*8,
189 .stop_threshold = INT32_MAX,
190 .silence_threshold = 0,
191 .silence_size = 0,
192 .avail_min = MMAP_PERIOD_SIZE, //1 ms
193};
194
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700195struct pcm_config pcm_config_hifi = {
196 .channels = DEFAULT_CHANNEL_COUNT, /* changed when the stream is opened */
197 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, /* changed when the stream is opened */
198 .period_size = HIFI_BUFFER_OUTPUT_PERIOD_SIZE, /* change #define */
199 .period_count = HIFI_BUFFER_OUTPUT_PERIOD_COUNT,
200 .format = PCM_FORMAT_S24_3LE,
201 .start_threshold = 0,
202 .stop_threshold = INT_MAX,
203 .avail_min = 0,
204};
205
Eric Laurentb23d5282013-05-14 15:27:20 -0700206struct pcm_config pcm_config_audio_capture = {
207 .channels = 2,
Eric Laurentb23d5282013-05-14 15:27:20 -0700208 .period_count = AUDIO_CAPTURE_PERIOD_COUNT,
209 .format = PCM_FORMAT_S16_LE,
210};
211
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700212struct pcm_config pcm_config_audio_capture_rt = {
213 .channels = 2,
214 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
215 .period_size = ULL_PERIOD_SIZE,
216 .period_count = 512,
217 .format = PCM_FORMAT_S16_LE,
218 .start_threshold = 0,
219 .stop_threshold = INT_MAX,
220 .silence_threshold = 0,
221 .silence_size = 0,
222 .avail_min = ULL_PERIOD_SIZE, //1 ms
223};
224
Haynes Mathew George16081042017-05-31 17:16:49 -0700225struct pcm_config pcm_config_mmap_capture = {
226 .channels = 2,
227 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
228 .period_size = MMAP_PERIOD_SIZE,
229 .period_count = MMAP_PERIOD_COUNT_DEFAULT,
230 .format = PCM_FORMAT_S16_LE,
231 .start_threshold = 0,
232 .stop_threshold = INT_MAX,
233 .silence_threshold = 0,
234 .silence_size = 0,
235 .avail_min = MMAP_PERIOD_SIZE, //1 ms
236};
237
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700238#define AFE_PROXY_CHANNEL_COUNT 2
239#define AFE_PROXY_SAMPLING_RATE 48000
240
241#define AFE_PROXY_PLAYBACK_PERIOD_SIZE 768
242#define AFE_PROXY_PLAYBACK_PERIOD_COUNT 4
243
244struct pcm_config pcm_config_afe_proxy_playback = {
245 .channels = AFE_PROXY_CHANNEL_COUNT,
246 .rate = AFE_PROXY_SAMPLING_RATE,
247 .period_size = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
248 .period_count = AFE_PROXY_PLAYBACK_PERIOD_COUNT,
249 .format = PCM_FORMAT_S16_LE,
250 .start_threshold = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
251 .stop_threshold = INT_MAX,
252 .avail_min = AFE_PROXY_PLAYBACK_PERIOD_SIZE,
253};
254
255#define AFE_PROXY_RECORD_PERIOD_SIZE 768
256#define AFE_PROXY_RECORD_PERIOD_COUNT 4
257
258struct pcm_config pcm_config_afe_proxy_record = {
259 .channels = AFE_PROXY_CHANNEL_COUNT,
260 .rate = AFE_PROXY_SAMPLING_RATE,
261 .period_size = AFE_PROXY_RECORD_PERIOD_SIZE,
262 .period_count = AFE_PROXY_RECORD_PERIOD_COUNT,
263 .format = PCM_FORMAT_S16_LE,
264 .start_threshold = AFE_PROXY_RECORD_PERIOD_SIZE,
265 .stop_threshold = INT_MAX,
266 .avail_min = AFE_PROXY_RECORD_PERIOD_SIZE,
267};
268
Ashish Jainf1eaa582016-05-23 20:54:24 +0530269#define AUDIO_MAX_PCM_FORMATS 7
270
271const uint32_t format_to_bitwidth_table[AUDIO_MAX_PCM_FORMATS] = {
272 [AUDIO_FORMAT_DEFAULT] = 0,
273 [AUDIO_FORMAT_PCM_16_BIT] = sizeof(uint16_t),
274 [AUDIO_FORMAT_PCM_8_BIT] = sizeof(uint8_t),
275 [AUDIO_FORMAT_PCM_32_BIT] = sizeof(uint32_t),
276 [AUDIO_FORMAT_PCM_8_24_BIT] = sizeof(uint32_t),
277 [AUDIO_FORMAT_PCM_FLOAT] = sizeof(float),
278 [AUDIO_FORMAT_PCM_24_BIT_PACKED] = sizeof(uint8_t) * 3,
279};
280
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -0800281const char * const use_case_table[AUDIO_USECASE_MAX] = {
Eric Laurentb23d5282013-05-14 15:27:20 -0700282 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = "deep-buffer-playback",
283 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = "low-latency-playback",
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -0700284 [USECASE_AUDIO_PLAYBACK_ULL] = "audio-ull-playback",
285 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = "multi-channel-playback",
Shruthi Krishnaace10852013-10-25 14:32:12 -0700286 [USECASE_AUDIO_PLAYBACK_OFFLOAD] = "compress-offload-playback",
vivek mehta446c3962015-09-14 10:57:35 -0700287 //Enabled for Direct_PCM
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700288 [USECASE_AUDIO_PLAYBACK_OFFLOAD2] = "compress-offload-playback2",
289 [USECASE_AUDIO_PLAYBACK_OFFLOAD3] = "compress-offload-playback3",
290 [USECASE_AUDIO_PLAYBACK_OFFLOAD4] = "compress-offload-playback4",
291 [USECASE_AUDIO_PLAYBACK_OFFLOAD5] = "compress-offload-playback5",
292 [USECASE_AUDIO_PLAYBACK_OFFLOAD6] = "compress-offload-playback6",
293 [USECASE_AUDIO_PLAYBACK_OFFLOAD7] = "compress-offload-playback7",
294 [USECASE_AUDIO_PLAYBACK_OFFLOAD8] = "compress-offload-playback8",
295 [USECASE_AUDIO_PLAYBACK_OFFLOAD9] = "compress-offload-playback9",
Haynes Mathew George16081042017-05-31 17:16:49 -0700296 [USECASE_AUDIO_PLAYBACK_FM] = "play-fm",
297 [USECASE_AUDIO_PLAYBACK_MMAP] = "mmap-playback",
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700298 [USECASE_AUDIO_PLAYBACK_HIFI] = "hifi-playback",
vivek mehta0ea887a2015-08-26 14:01:20 -0700299
Eric Laurentb23d5282013-05-14 15:27:20 -0700300 [USECASE_AUDIO_RECORD] = "audio-record",
Mingming Yine62d7842013-10-25 16:26:03 -0700301 [USECASE_AUDIO_RECORD_COMPRESS] = "audio-record-compress",
Dhananjay Kumaree4d2002016-10-25 18:02:58 +0530302 [USECASE_AUDIO_RECORD_COMPRESS2] = "audio-record-compress2",
303 [USECASE_AUDIO_RECORD_COMPRESS3] = "audio-record-compress3",
304 [USECASE_AUDIO_RECORD_COMPRESS4] = "audio-record-compress4",
Dhananjay Kumar376e38b2017-09-28 22:26:23 +0530305 [USECASE_AUDIO_RECORD_COMPRESS5] = "audio-record-compress5",
306 [USECASE_AUDIO_RECORD_COMPRESS6] = "audio-record-compress6",
Eric Laurentb23d5282013-05-14 15:27:20 -0700307 [USECASE_AUDIO_RECORD_LOW_LATENCY] = "low-latency-record",
Preetam Singh Ranawatde84f1a2013-11-01 14:58:16 -0700308 [USECASE_AUDIO_RECORD_FM_VIRTUAL] = "fm-virtual-record",
Haynes Mathew George16081042017-05-31 17:16:49 -0700309 [USECASE_AUDIO_RECORD_MMAP] = "mmap-record",
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700310 [USECASE_AUDIO_RECORD_HIFI] = "hifi-record",
Haynes Mathew George16081042017-05-31 17:16:49 -0700311
Vimal Puthanveed5b4d3f12013-11-05 15:57:39 -0800312 [USECASE_AUDIO_HFP_SCO] = "hfp-sco",
Vimal Puthanveed47e64852013-12-20 13:23:39 -0800313 [USECASE_AUDIO_HFP_SCO_WB] = "hfp-sco-wb",
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700314 [USECASE_VOICE_CALL] = "voice-call",
Mingming Yin3ee55c62014-08-04 14:23:35 -0700315
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -0700316 [USECASE_VOICE2_CALL] = "voice2-call",
317 [USECASE_VOLTE_CALL] = "volte-call",
318 [USECASE_QCHAT_CALL] = "qchat-call",
Vicky Sehrawat7e4fc152014-02-12 17:58:59 -0800319 [USECASE_VOWLAN_CALL] = "vowlan-call",
Vidyakumar Athota0e109352015-02-12 17:38:22 -0800320 [USECASE_VOICEMMODE1_CALL] = "voicemmode1-call",
321 [USECASE_VOICEMMODE2_CALL] = "voicemmode2-call",
Narsinga Rao Chella05573b72013-11-15 15:21:40 -0800322 [USECASE_COMPRESS_VOIP_CALL] = "compress-voip-call",
Shiv Maliyappanahallida107642013-10-17 11:16:13 -0700323 [USECASE_INCALL_REC_UPLINK] = "incall-rec-uplink",
324 [USECASE_INCALL_REC_DOWNLINK] = "incall-rec-downlink",
325 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK] = "incall-rec-uplink-and-downlink",
Helen Zenge56b4852013-12-03 16:54:40 -0800326 [USECASE_INCALL_REC_UPLINK_COMPRESS] = "incall-rec-uplink-compress",
327 [USECASE_INCALL_REC_DOWNLINK_COMPRESS] = "incall-rec-downlink-compress",
328 [USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS] = "incall-rec-uplink-and-downlink-compress",
329
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -0700330 [USECASE_INCALL_MUSIC_UPLINK] = "incall_music_uplink",
331 [USECASE_INCALL_MUSIC_UPLINK2] = "incall_music_uplink2",
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700332 [USECASE_AUDIO_SPKR_CALIB_RX] = "spkr-rx-calib",
333 [USECASE_AUDIO_SPKR_CALIB_TX] = "spkr-vi-record",
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -0700334
335 [USECASE_AUDIO_PLAYBACK_AFE_PROXY] = "afe-proxy-playback",
336 [USECASE_AUDIO_RECORD_AFE_PROXY] = "afe-proxy-record",
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -0700337 [USECASE_AUDIO_PLAYBACK_EXT_DISP_SILENCE] = "silence-playback",
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700338
Siddartha Shaik31b530e2017-05-19 15:26:33 +0530339 /* Transcode loopback cases */
340 [USECASE_AUDIO_TRANSCODE_LOOPBACK] = "audio-transcode-loopback",
Vikram Panduranga93f080e2017-06-07 18:16:14 -0700341
342 [USECASE_AUDIO_PLAYBACK_VOIP] = "audio-playback-voip",
343 [USECASE_AUDIO_RECORD_VOIP] = "audio-record-voip",
Varun Balaraje49253e2017-07-06 19:48:56 +0530344 /* For Interactive Audio Streams */
345 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM1] = "audio-interactive-stream1",
346 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM2] = "audio-interactive-stream2",
347 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM3] = "audio-interactive-stream3",
348 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM4] = "audio-interactive-stream4",
349 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM5] = "audio-interactive-stream5",
350 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM6] = "audio-interactive-stream6",
351 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM7] = "audio-interactive-stream7",
352 [USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM8] = "audio-interactive-stream8",
Garmond Leunge2433c32017-09-28 21:51:22 -0700353
354 [USECASE_AUDIO_EC_REF_LOOPBACK] = "ec-ref-audio-capture"
Eric Laurentb23d5282013-05-14 15:27:20 -0700355};
356
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700357static const audio_usecase_t offload_usecases[] = {
358 USECASE_AUDIO_PLAYBACK_OFFLOAD,
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700359 USECASE_AUDIO_PLAYBACK_OFFLOAD2,
360 USECASE_AUDIO_PLAYBACK_OFFLOAD3,
361 USECASE_AUDIO_PLAYBACK_OFFLOAD4,
362 USECASE_AUDIO_PLAYBACK_OFFLOAD5,
363 USECASE_AUDIO_PLAYBACK_OFFLOAD6,
364 USECASE_AUDIO_PLAYBACK_OFFLOAD7,
365 USECASE_AUDIO_PLAYBACK_OFFLOAD8,
366 USECASE_AUDIO_PLAYBACK_OFFLOAD9,
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -0700367};
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800368
Varun Balaraje49253e2017-07-06 19:48:56 +0530369static const audio_usecase_t interactive_usecases[] = {
370 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM1,
371 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM2,
372 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM3,
373 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM4,
374 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM5,
375 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM6,
376 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM7,
377 USECASE_AUDIO_PLAYBACK_INTERACTIVE_STREAM8,
378};
379
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800380#define STRING_TO_ENUM(string) { #string, string }
381
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800382struct string_to_enum {
383 const char *name;
384 uint32_t value;
385};
386
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700387static const struct string_to_enum channels_name_to_enum_table[] = {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800388 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO),
Mingming Yin3a941d42016-02-17 18:08:05 -0800389 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_2POINT1),
390 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_QUAD),
391 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_SURROUND),
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -0700392 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_PENTA),
Mingming Yin3a941d42016-02-17 18:08:05 -0800393 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
394 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_6POINT1),
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800395 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700396 STRING_TO_ENUM(AUDIO_CHANNEL_IN_MONO),
397 STRING_TO_ENUM(AUDIO_CHANNEL_IN_STEREO),
398 STRING_TO_ENUM(AUDIO_CHANNEL_IN_FRONT_BACK),
399 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_1),
400 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_2),
401 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_3),
402 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_4),
403 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_5),
404 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_6),
405 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_7),
406 STRING_TO_ENUM(AUDIO_CHANNEL_INDEX_MASK_8),
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800407};
408
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700409static const struct string_to_enum formats_name_to_enum_table[] = {
410 STRING_TO_ENUM(AUDIO_FORMAT_PCM_16_BIT),
411 STRING_TO_ENUM(AUDIO_FORMAT_PCM_24_BIT_PACKED),
412 STRING_TO_ENUM(AUDIO_FORMAT_PCM_32_BIT),
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700413 STRING_TO_ENUM(AUDIO_FORMAT_AC3),
414 STRING_TO_ENUM(AUDIO_FORMAT_E_AC3),
415 STRING_TO_ENUM(AUDIO_FORMAT_E_AC3_JOC),
Ben Romberger1aaaf862017-04-06 17:49:46 -0700416 STRING_TO_ENUM(AUDIO_FORMAT_DOLBY_TRUEHD),
Mingming Yin3a941d42016-02-17 18:08:05 -0800417 STRING_TO_ENUM(AUDIO_FORMAT_DTS),
418 STRING_TO_ENUM(AUDIO_FORMAT_DTS_HD),
Naresh Tanniru928f0862017-04-07 16:44:23 -0700419 STRING_TO_ENUM(AUDIO_FORMAT_IEC61937)
Mingming Yin3a941d42016-02-17 18:08:05 -0800420};
421
422//list of all supported sample rates by HDMI specification.
423static const int out_hdmi_sample_rates[] = {
424 32000, 44100, 48000, 88200, 96000, 176400, 192000,
425};
426
Haynes Mathew George484e8d22017-07-31 18:55:17 -0700427static const struct string_to_enum out_sample_rates_name_to_enum_table[] = {
Mingming Yin3a941d42016-02-17 18:08:05 -0800428 STRING_TO_ENUM(32000),
429 STRING_TO_ENUM(44100),
430 STRING_TO_ENUM(48000),
431 STRING_TO_ENUM(88200),
432 STRING_TO_ENUM(96000),
433 STRING_TO_ENUM(176400),
434 STRING_TO_ENUM(192000),
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700435};
436
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700437static struct audio_device *adev = NULL;
438static pthread_mutex_t adev_init_lock;
Kiran Kandi910e1862013-10-29 13:29:42 -0700439static unsigned int audio_device_ref_count;
vivek mehtab72d08d2016-04-29 03:16:47 -0700440//cache last MBDRC cal step level
441static int last_known_cal_step = -1 ;
Kiran Kandi910e1862013-10-29 13:29:42 -0700442
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +0530443static int check_a2dp_restore_l(struct audio_device *adev, struct stream_out *out, bool restore);
444static int out_set_compr_volume(struct audio_stream_out *stream, float left, float right);
Zhou Song2b8f28f2017-09-11 10:51:38 +0800445static int out_set_voip_volume(struct audio_stream_out *stream, float left, float right);
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +0530446
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700447static bool may_use_noirq_mode(struct audio_device *adev, audio_usecase_t uc_id,
448 int flags __unused)
449{
450 int dir = 0;
451 switch (uc_id) {
452 case USECASE_AUDIO_RECORD_LOW_LATENCY:
453 dir = 1;
454 case USECASE_AUDIO_PLAYBACK_ULL:
455 break;
456 default:
457 return false;
458 }
459
460 int dev_id = platform_get_pcm_device_id(uc_id, dir == 0 ?
461 PCM_PLAYBACK : PCM_CAPTURE);
462 if (adev->adm_is_noirq_avail)
463 return adev->adm_is_noirq_avail(adev->adm_data,
464 adev->snd_card, dev_id, dir);
465 return false;
466}
467
468static void register_out_stream(struct stream_out *out)
469{
470 struct audio_device *adev = out->dev;
471 if (is_offload_usecase(out->usecase) ||
472 !adev->adm_register_output_stream)
473 return;
474
475 // register stream first for backward compatibility
476 adev->adm_register_output_stream(adev->adm_data,
477 out->handle,
478 out->flags);
479
480 if (!adev->adm_set_config)
481 return;
482
483 if (out->realtime)
484 adev->adm_set_config(adev->adm_data,
485 out->handle,
486 out->pcm, &out->config);
487}
488
489static void register_in_stream(struct stream_in *in)
490{
491 struct audio_device *adev = in->dev;
492 if (!adev->adm_register_input_stream)
493 return;
494
495 adev->adm_register_input_stream(adev->adm_data,
496 in->capture_handle,
497 in->flags);
498
499 if (!adev->adm_set_config)
500 return;
501
502 if (in->realtime)
503 adev->adm_set_config(adev->adm_data,
504 in->capture_handle,
505 in->pcm,
506 &in->config);
507}
508
509static void request_out_focus(struct stream_out *out, long ns)
510{
511 struct audio_device *adev = out->dev;
512
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700513 if (adev->adm_request_focus_v2)
514 adev->adm_request_focus_v2(adev->adm_data, out->handle, ns);
515 else if (adev->adm_request_focus)
516 adev->adm_request_focus(adev->adm_data, out->handle);
517}
518
519static void request_in_focus(struct stream_in *in, long ns)
520{
521 struct audio_device *adev = in->dev;
522
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700523 if (adev->adm_request_focus_v2)
524 adev->adm_request_focus_v2(adev->adm_data, in->capture_handle, ns);
525 else if (adev->adm_request_focus)
526 adev->adm_request_focus(adev->adm_data, in->capture_handle);
527}
528
529static void release_out_focus(struct stream_out *out)
530{
531 struct audio_device *adev = out->dev;
532
533 if (adev->adm_abandon_focus)
534 adev->adm_abandon_focus(adev->adm_data, out->handle);
535}
536
537static void release_in_focus(struct stream_in *in)
538{
539 struct audio_device *adev = in->dev;
540 if (adev->adm_abandon_focus)
541 adev->adm_abandon_focus(adev->adm_data, in->capture_handle);
542}
543
Dhananjay Kumare6293dd2017-05-25 17:25:30 +0530544static int parse_snd_card_status(struct str_parms *parms, int *card,
545 card_status_t *status)
546{
547 char value[32]={0};
548 char state[32]={0};
549
550 int ret = str_parms_get_str(parms, "SND_CARD_STATUS", value, sizeof(value));
551 if (ret < 0)
552 return -1;
553
554 // sscanf should be okay as value is of max length 32.
555 // same as sizeof state.
556 if (sscanf(value, "%d,%s", card, state) < 2)
557 return -1;
558
559 *status = !strcmp(state, "ONLINE") ? CARD_STATUS_ONLINE :
560 CARD_STATUS_OFFLINE;
561 return 0;
562}
563
Haynes Mathew Georgeb0f5dc32017-10-06 18:35:12 -0700564static inline void adjust_frames_for_device_delay(struct stream_out *out,
565 uint32_t *dsp_frames) {
566 // Adjustment accounts for A2dp encoder latency with offload usecases
567 // Note: Encoder latency is returned in ms.
568 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
569 unsigned long offset =
570 (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
571 *dsp_frames = (*dsp_frames > offset) ? (*dsp_frames - offset) : 0;
572 }
573}
574
vivek mehtaa76401a2015-04-24 14:12:15 -0700575__attribute__ ((visibility ("default")))
576bool audio_hw_send_gain_dep_calibration(int level) {
577 bool ret_val = false;
vivek mehtab72d08d2016-04-29 03:16:47 -0700578 ALOGV("%s: called ...", __func__);
vivek mehtaa76401a2015-04-24 14:12:15 -0700579
580 pthread_mutex_lock(&adev_init_lock);
581
582 if (adev != NULL && adev->platform != NULL) {
583 pthread_mutex_lock(&adev->lock);
584 ret_val = platform_send_gain_dep_cal(adev->platform, level);
vivek mehtab72d08d2016-04-29 03:16:47 -0700585
Preetam Singh Ranawatf4ae0222017-05-31 17:07:28 +0530586 // cache level info for any of the use case which
587 // was not started.
588 last_known_cal_step = level;;
vivek mehtab72d08d2016-04-29 03:16:47 -0700589
vivek mehtaa76401a2015-04-24 14:12:15 -0700590 pthread_mutex_unlock(&adev->lock);
591 } else {
592 ALOGE("%s: %s is NULL", __func__, adev == NULL ? "adev" : "adev->platform");
593 }
594
595 pthread_mutex_unlock(&adev_init_lock);
596
597 return ret_val;
598}
599
Ashish Jain5106d362016-05-11 19:23:33 +0530600static int check_and_set_gapless_mode(struct audio_device *adev, bool enable_gapless)
601{
Krishnankutty Kolathappilly6d8788b2014-01-09 12:45:31 -0800602 bool gapless_enabled = false;
603 const char *mixer_ctl_name = "Compress Gapless Playback";
604 struct mixer_ctl *ctl;
605
606 ALOGV("%s:", __func__);
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -0700607 gapless_enabled = property_get_bool("vendor.audio.offload.gapless.enabled", false);
Ashish Jain5106d362016-05-11 19:23:33 +0530608
609 /*Disable gapless if its AV playback*/
610 gapless_enabled = gapless_enabled && enable_gapless;
Krishnankutty Kolathappilly6d8788b2014-01-09 12:45:31 -0800611
612 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
613 if (!ctl) {
614 ALOGE("%s: Could not get ctl for mixer cmd - %s",
615 __func__, mixer_ctl_name);
616 return -EINVAL;
617 }
618
619 if (mixer_ctl_set_value(ctl, 0, gapless_enabled) < 0) {
620 ALOGE("%s: Could not set gapless mode %d",
621 __func__, gapless_enabled);
622 return -EINVAL;
623 }
624 return 0;
625}
Haynes Mathew George5191a852013-09-11 14:19:36 -0700626
Aniket Kumar Lataf56b6402016-10-27 12:03:18 -0700627__attribute__ ((visibility ("default")))
628int audio_hw_get_gain_level_mapping(struct amp_db_and_gain_table *mapping_tbl,
629 int table_size) {
630 int ret_val = 0;
631 ALOGV("%s: enter ... ", __func__);
632
633 pthread_mutex_lock(&adev_init_lock);
634 if (adev == NULL) {
635 ALOGW("%s: adev is NULL .... ", __func__);
636 goto done;
637 }
638
639 pthread_mutex_lock(&adev->lock);
640 ret_val = platform_get_gain_level_mapping(mapping_tbl, table_size);
641 pthread_mutex_unlock(&adev->lock);
642done:
643 pthread_mutex_unlock(&adev_init_lock);
644 ALOGV("%s: exit ... ", __func__);
645 return ret_val;
646}
647
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700648static bool is_supported_format(audio_format_t format)
649{
Eric Laurent86e17132013-09-12 17:49:30 -0700650 if (format == AUDIO_FORMAT_MP3 ||
Satish Babu Patakokila0c313922016-12-08 12:07:08 +0530651 format == AUDIO_FORMAT_MP2 ||
Ashish Jainf9b78162014-08-25 20:36:25 +0530652 format == AUDIO_FORMAT_AAC_LC ||
653 format == AUDIO_FORMAT_AAC_HE_V1 ||
654 format == AUDIO_FORMAT_AAC_HE_V2 ||
Manish Dewangana6fc5442015-08-24 20:30:31 +0530655 format == AUDIO_FORMAT_AAC_ADTS_LC ||
656 format == AUDIO_FORMAT_AAC_ADTS_HE_V1 ||
657 format == AUDIO_FORMAT_AAC_ADTS_HE_V2 ||
Arun Kumar Dasari3b174182016-12-27 13:01:14 +0530658 format == AUDIO_FORMAT_AAC_LATM_LC ||
659 format == AUDIO_FORMAT_AAC_LATM_HE_V1 ||
660 format == AUDIO_FORMAT_AAC_LATM_HE_V2 ||
Ashish Jain5106d362016-05-11 19:23:33 +0530661 format == AUDIO_FORMAT_PCM_24_BIT_PACKED ||
662 format == AUDIO_FORMAT_PCM_8_24_BIT ||
Ashish Jainf1eaa582016-05-23 20:54:24 +0530663 format == AUDIO_FORMAT_PCM_FLOAT ||
664 format == AUDIO_FORMAT_PCM_32_BIT ||
vivek mehta0ea887a2015-08-26 14:01:20 -0700665 format == AUDIO_FORMAT_PCM_16_BIT ||
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +0530666 format == AUDIO_FORMAT_AC3 ||
667 format == AUDIO_FORMAT_E_AC3 ||
Ben Romberger1aaaf862017-04-06 17:49:46 -0700668 format == AUDIO_FORMAT_DOLBY_TRUEHD ||
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +0530669 format == AUDIO_FORMAT_DTS ||
670 format == AUDIO_FORMAT_DTS_HD ||
Weiyin Jiang18ac4e92015-03-15 15:03:40 +0800671 format == AUDIO_FORMAT_FLAC ||
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +0530672 format == AUDIO_FORMAT_ALAC ||
673 format == AUDIO_FORMAT_APE ||
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +0530674 format == AUDIO_FORMAT_DSD ||
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +0530675 format == AUDIO_FORMAT_VORBIS ||
Weiyin Jiang18ac4e92015-03-15 15:03:40 +0800676 format == AUDIO_FORMAT_WMA ||
Dhanalakshmi Siddani18737932016-11-29 17:33:17 +0530677 format == AUDIO_FORMAT_WMA_PRO ||
Naresh Tanniru928f0862017-04-07 16:44:23 -0700678 format == AUDIO_FORMAT_APTX ||
679 format == AUDIO_FORMAT_IEC61937)
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -0800680 return true;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700681
682 return false;
683}
684
Haynes Mathew George5beddd42016-06-27 18:33:40 -0700685static inline bool is_mmap_usecase(audio_usecase_t uc_id)
686{
687 return (uc_id == USECASE_AUDIO_RECORD_AFE_PROXY) ||
688 (uc_id == USECASE_AUDIO_PLAYBACK_AFE_PROXY);
689}
690
Avinash Vaish71a8b972014-07-24 15:36:33 +0530691static int enable_audio_route_for_voice_usecases(struct audio_device *adev,
692 struct audio_usecase *uc_info)
693{
694 struct listnode *node;
695 struct audio_usecase *usecase;
696
697 if (uc_info == NULL)
698 return -EINVAL;
699
700 /* Re-route all voice usecases on the shared backend other than the
701 specified usecase to new snd devices */
702 list_for_each(node, &adev->usecase_list) {
703 usecase = node_to_item(node, struct audio_usecase, list);
Narsinga Rao Chellae7f33c12015-01-28 15:23:34 -0800704 if ((usecase->type == VOICE_CALL) && (usecase != uc_info))
Avinash Vaish71a8b972014-07-24 15:36:33 +0530705 enable_audio_route(adev, usecase);
706 }
707 return 0;
708}
709
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +0530710static void enable_asrc_mode(struct audio_device *adev)
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +0530711{
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +0530712 ALOGV("%s", __func__);
713 audio_route_apply_and_update_path(adev->audio_route,
714 "asrc-mode");
715 adev->asrc_mode_enabled = true;
716}
717
718static void disable_asrc_mode(struct audio_device *adev)
719{
720 ALOGV("%s", __func__);
721 audio_route_reset_and_update_path(adev->audio_route,
722 "asrc-mode");
723 adev->asrc_mode_enabled = false;
724}
725
726/*
727 * - Enable ASRC mode for incoming mix path use case(Headphone backend)if Headphone
728 * 44.1 or Native DSD backends are enabled for any of current use case.
729 * e.g. 48-> + (Naitve DSD or Headphone 44.1)
730 * - Disable current mix path use case(Headphone backend) and re-enable it with
731 * ASRC mode for incoming Headphone 44.1 or Native DSD use case.
732 * e.g. Naitve DSD or Headphone 44.1 -> + 48
733 */
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530734static void check_and_set_asrc_mode(struct audio_device *adev,
735 struct audio_usecase *uc_info,
736 snd_device_t snd_device)
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +0530737{
738 ALOGV("%s snd device %d", __func__, snd_device);
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530739 int i, num_new_devices = 0;
740 snd_device_t split_new_snd_devices[SND_DEVICE_OUT_END];
741 /*
742 *Split snd device for new combo use case
743 *e.g. Headphopne 44.1-> + Ringtone (Headphone + Speaker)
744 */
745 if (platform_split_snd_device(adev->platform,
746 snd_device,
747 &num_new_devices,
748 split_new_snd_devices) == 0) {
749 for (i = 0; i < num_new_devices; i++)
750 check_and_set_asrc_mode(adev, uc_info, split_new_snd_devices[i]);
751 } else {
752 int new_backend_idx = platform_get_backend_index(snd_device);
753 if (((new_backend_idx == HEADPHONE_BACKEND) ||
754 (new_backend_idx == HEADPHONE_44_1_BACKEND) ||
755 (new_backend_idx == DSD_NATIVE_BACKEND)) &&
756 !adev->asrc_mode_enabled) {
757 struct listnode *node = NULL;
758 struct audio_usecase *uc = NULL;
759 struct stream_out *curr_out = NULL;
760 int usecase_backend_idx = DEFAULT_CODEC_BACKEND;
761 int i, num_devices, ret = 0;
762 snd_device_t split_snd_devices[SND_DEVICE_OUT_END];
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +0530763
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530764 list_for_each(node, &adev->usecase_list) {
765 uc = node_to_item(node, struct audio_usecase, list);
766 curr_out = (struct stream_out*) uc->stream.out;
767 if (curr_out && PCM_PLAYBACK == uc->type && uc != uc_info) {
768 /*
769 *Split snd device for existing combo use case
770 *e.g. Ringtone (Headphone + Speaker) + Headphopne 44.1
771 */
772 ret = platform_split_snd_device(adev->platform,
773 uc->out_snd_device,
774 &num_devices,
775 split_snd_devices);
776 if (ret < 0 || num_devices == 0) {
777 ALOGV("%s: Unable to split uc->out_snd_device: %d",__func__, uc->out_snd_device);
778 split_snd_devices[0] = uc->out_snd_device;
779 num_devices = 1;
Garmond Leung50058f62017-02-08 09:49:30 -0800780 }
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530781 for (i = 0; i < num_devices; i++) {
782 usecase_backend_idx = platform_get_backend_index(split_snd_devices[i]);
783 ALOGD("%s:snd_dev %d usecase_backend_idx %d",__func__, split_snd_devices[i],usecase_backend_idx);
784 if((new_backend_idx == HEADPHONE_BACKEND) &&
785 ((usecase_backend_idx == HEADPHONE_44_1_BACKEND) ||
786 (usecase_backend_idx == DSD_NATIVE_BACKEND))) {
787 ALOGD("%s:DSD or native stream detected enabling asrcmode in hardware",
788 __func__);
789 enable_asrc_mode(adev);
790 break;
791 } else if(((new_backend_idx == HEADPHONE_44_1_BACKEND) ||
792 (new_backend_idx == DSD_NATIVE_BACKEND)) &&
793 (usecase_backend_idx == HEADPHONE_BACKEND)) {
794 ALOGD("%s:48K stream detected, disabling and enabling it with asrcmode in hardware",
795 __func__);
796 disable_audio_route(adev, uc);
797 disable_snd_device(adev, uc->out_snd_device);
798 // Apply true-high-quality-mode if DSD or > 44.1KHz or >=24-bit
799 if (new_backend_idx == DSD_NATIVE_BACKEND)
800 audio_route_apply_and_update_path(adev->audio_route,
801 "hph-true-highquality-mode");
802 else if ((new_backend_idx == HEADPHONE_44_1_BACKEND) &&
803 (curr_out->bit_width >= 24))
804 audio_route_apply_and_update_path(adev->audio_route,
805 "hph-highquality-mode");
806 enable_asrc_mode(adev);
807 enable_snd_device(adev, uc->out_snd_device);
808 enable_audio_route(adev, uc);
809 break;
810 }
811 }
812 // reset split devices count
813 num_devices = 0;
Garmond Leung50058f62017-02-08 09:49:30 -0800814 }
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +0530815 if (adev->asrc_mode_enabled)
816 break;
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +0530817 }
818 }
819 }
820}
821
Vikram Pandurangadf59cae2017-08-03 18:04:55 -0700822#ifdef DYNAMIC_ECNS_ENABLED
823static int send_effect_enable_disable_mixer_ctl(struct audio_device *adev,
824 struct audio_effect_config effect_config,
825 unsigned int param_value)
826{
827 char mixer_ctl_name[] = "Audio Effect";
828 struct mixer_ctl *ctl;
829 long set_values[6];
830 struct stream_in *in = adev->active_input;
831
832 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
833 if (!ctl) {
834 ALOGE("%s: Could not get mixer ctl - %s",
835 __func__, mixer_ctl_name);
836 return -EINVAL;
837 }
838
839 set_values[0] = 1; //0:Rx 1:Tx
840 set_values[1] = in->app_type_cfg.app_type;
841 set_values[2] = (long)effect_config.module_id;
842 set_values[3] = (long)effect_config.instance_id;
843 set_values[4] = (long)effect_config.param_id;
844 set_values[5] = param_value;
845
846 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
847
848 return 0;
849
850}
851
852static int update_effect_param_ecns(struct audio_device *adev, unsigned int module_id,
853 int effect_type, unsigned int *param_value)
854{
855 int ret = 0;
856 struct audio_effect_config other_effect_config;
857 struct audio_usecase *usecase = NULL;
858 struct stream_in *in = adev->active_input;
859
860 usecase = get_usecase_from_list(adev, in->usecase);
861 if (!usecase)
862 return -EINVAL;
863
864 ret = platform_get_effect_config_data(usecase->in_snd_device, &other_effect_config,
865 effect_type == EFFECT_AEC ? EFFECT_NS : EFFECT_AEC);
866 if (ret < 0) {
867 ALOGE("%s Failed to get effect params %d", __func__, ret);
868 return ret;
869 }
870
871 if (module_id == other_effect_config.module_id) {
872 //Same module id for AEC/NS. Values need to be combined
873 if (((effect_type == EFFECT_AEC) && (in->enable_ns)) ||
874 ((effect_type == EFFECT_NS) && (in->enable_aec))) {
875 *param_value |= other_effect_config.param_value;
876 }
877 }
878
879 return ret;
880}
881
882static int enable_disable_effect(struct audio_device *adev, int effect_type, bool enable)
883{
884 struct audio_effect_config effect_config;
885 struct audio_usecase *usecase = NULL;
886 int ret = 0;
887 unsigned int param_value = 0;
888 struct stream_in *in = adev->active_input;
889
890 if (!in) {
891 ALOGE("%s: Invalid input stream", __func__);
892 return -EINVAL;
893 }
894
895 ALOGD("%s: effect_type:%d enable:%d", __func__, effect_type, enable);
896
897 usecase = get_usecase_from_list(adev, in->usecase);
898
899 ret = platform_get_effect_config_data(usecase->in_snd_device, &effect_config, effect_type);
900 if (ret < 0) {
901 ALOGE("%s Failed to get module id %d", __func__, ret);
902 return ret;
903 }
904 ALOGV("%s: %d %d usecase->id:%d usecase->in_snd_device:%d", __func__, effect_config.module_id,
905 in->app_type_cfg.app_type, usecase->id, usecase->in_snd_device);
906
907 if(enable)
908 param_value = effect_config.param_value;
909
910 /*Special handling for AEC & NS effects Param values need to be
911 updated if module ids are same*/
912
913 if ((effect_type == EFFECT_AEC) || (effect_type == EFFECT_NS)) {
914 ret = update_effect_param_ecns(adev, effect_config.module_id, effect_type, &param_value);
915 if (ret < 0)
916 return ret;
917 }
918
919 ret = send_effect_enable_disable_mixer_ctl(adev, effect_config, param_value);
920
921 return ret;
922}
923
924static void check_and_enable_effect(struct audio_device *adev)
925{
926
927 if (adev->active_input->enable_aec) {
928 enable_disable_effect(adev, EFFECT_AEC, true);
929 }
930
931 if (adev->active_input->enable_ns &&
932 adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
933 enable_disable_effect(adev, EFFECT_NS, true);
934 }
935}
936#else
937#define enable_disable_effect(x, y, z) ENOSYS
938#define check_and_enable_effect(x) ENOSYS
939#endif
940
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -0700941int pcm_ioctl(struct pcm *pcm, int request, ...)
942{
943 va_list ap;
944 void * arg;
945 int pcm_fd = *(int*)pcm;
946
947 va_start(ap, request);
948 arg = va_arg(ap, void *);
949 va_end(ap);
950
951 return ioctl(pcm_fd, request, arg);
952}
953
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -0700954int enable_audio_route(struct audio_device *adev,
Haynes Mathew George1376ca62014-04-24 11:55:48 -0700955 struct audio_usecase *usecase)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800956{
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700957 snd_device_t snd_device;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700958 char mixer_path[MIXER_PATH_MAX_LENGTH];
Manish Dewangan58229382017-02-02 15:48:41 +0530959 struct stream_out *out = NULL;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800960
961 if (usecase == NULL)
962 return -EINVAL;
963
964 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
965
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800966 if (usecase->type == PCM_CAPTURE)
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700967 snd_device = usecase->in_snd_device;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800968 else
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700969 snd_device = usecase->out_snd_device;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800970
Subhash Chandra Bose Naripeddy7690c562013-12-14 00:34:53 -0800971#ifdef DS1_DOLBY_DAP_ENABLED
972 audio_extn_dolby_set_dmid(adev);
973 audio_extn_dolby_set_endpoint(adev);
974#endif
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -0700975 audio_extn_dolby_ds2_set_endpoint(adev);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -0700976 audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_BUSY);
Dhananjay Kumar45b71742014-05-29 21:47:27 +0530977 audio_extn_listen_update_stream_status(usecase, LISTEN_EVENT_STREAM_BUSY);
Ben Romberger1fafdde2015-09-09 19:43:15 -0700978 audio_extn_utils_send_app_type_cfg(adev, usecase);
Dhananjay Kumar14170dd2015-08-28 13:24:16 +0530979 audio_extn_utils_send_audio_calibration(adev, usecase);
Manish Dewangan58229382017-02-02 15:48:41 +0530980 if ((usecase->type == PCM_PLAYBACK) && is_offload_usecase(usecase->id)) {
981 out = usecase->stream.out;
982 if (out && out->compr)
983 audio_extn_utils_compress_set_clk_rec_mode(usecase);
984 }
985
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -0800986 strlcpy(mixer_path, use_case_table[usecase->id], MIXER_PATH_MAX_LENGTH);
Banajit Goswami20cdd212015-09-11 01:11:30 -0700987 platform_add_backend_name(mixer_path, snd_device, usecase);
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -0700988 ALOGD("%s: apply mixer and update path: %s", __func__, mixer_path);
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -0700989 audio_route_apply_and_update_path(adev->audio_route, mixer_path);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800990 ALOGV("%s: exit", __func__);
991 return 0;
992}
993
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700994int disable_audio_route(struct audio_device *adev,
Haynes Mathew George1376ca62014-04-24 11:55:48 -0700995 struct audio_usecase *usecase)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800996{
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700997 snd_device_t snd_device;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -0700998 char mixer_path[MIXER_PATH_MAX_LENGTH];
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800999
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05301000 if (usecase == NULL || usecase->id == USECASE_INVALID)
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001001 return -EINVAL;
1002
1003 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001004 if (usecase->type == PCM_CAPTURE)
1005 snd_device = usecase->in_snd_device;
1006 else
1007 snd_device = usecase->out_snd_device;
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -08001008 strlcpy(mixer_path, use_case_table[usecase->id], MIXER_PATH_MAX_LENGTH);
Banajit Goswami20cdd212015-09-11 01:11:30 -07001009 platform_add_backend_name(mixer_path, snd_device, usecase);
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07001010 ALOGD("%s: reset and update mixer path: %s", __func__, mixer_path);
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001011 audio_route_reset_and_update_path(adev->audio_route, mixer_path);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001012 audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_FREE);
Dhananjay Kumar45b71742014-05-29 21:47:27 +05301013 audio_extn_listen_update_stream_status(usecase, LISTEN_EVENT_STREAM_FREE);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001014 ALOGV("%s: exit", __func__);
1015 return 0;
1016}
1017
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -07001018int enable_snd_device(struct audio_device *adev,
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001019 snd_device_t snd_device)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001020{
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301021 int i, num_devices = 0;
1022 snd_device_t new_snd_devices[SND_DEVICE_OUT_END];
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001023 char device_name[DEVICE_NAME_MAX_SIZE] = {0};
1024
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001025 if (snd_device < SND_DEVICE_MIN ||
1026 snd_device >= SND_DEVICE_MAX) {
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08001027 ALOGE("%s: Invalid sound device %d", __func__, snd_device);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001028 return -EINVAL;
1029 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001030
1031 adev->snd_dev_ref_cnt[snd_device]++;
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001032
1033 if(platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0 ) {
1034 ALOGE("%s: Invalid sound device returned", __func__);
1035 return -EINVAL;
1036 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001037 if (adev->snd_dev_ref_cnt[snd_device] > 1) {
Eric Laurent994a6932013-07-17 11:51:42 -07001038 ALOGV("%s: snd_device(%d: %s) is already active",
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001039 __func__, snd_device, device_name);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001040 return 0;
1041 }
1042
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301043
Gopikrishnaiah Anandane85d0462014-06-30 21:41:20 -07001044 if (audio_extn_spkr_prot_is_enabled())
1045 audio_extn_spkr_prot_calib_cancel(adev);
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -07001046
Xiaojun Sang040cc9f2015-08-03 19:38:28 +08001047 if (platform_can_enable_spkr_prot_on_device(snd_device) &&
1048 audio_extn_spkr_prot_is_enabled()) {
1049 if (platform_get_spkr_prot_acdb_id(snd_device) < 0) {
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -07001050 adev->snd_dev_ref_cnt[snd_device]--;
1051 return -EINVAL;
1052 }
Ravit Dennisaaee49c2015-02-04 21:26:22 +02001053 audio_extn_dev_arbi_acquire(snd_device);
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08001054 if (audio_extn_spkr_prot_start_processing(snd_device)) {
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -08001055 ALOGE("%s: spkr_start_processing failed", __func__);
Ravit Dennisaaee49c2015-02-04 21:26:22 +02001056 audio_extn_dev_arbi_release(snd_device);
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -08001057 return -EINVAL;
1058 }
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001059 } else if (platform_split_snd_device(adev->platform,
1060 snd_device,
1061 &num_devices,
1062 new_snd_devices) == 0) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301063 for (i = 0; i < num_devices; i++) {
1064 enable_snd_device(adev, new_snd_devices[i]);
1065 }
Vidyakumar Athota1c6419a2014-01-10 14:47:34 -08001066 } else {
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07001067 ALOGD("%s: snd_device(%d: %s)", __func__, snd_device, device_name);
Naresh Tannirucd2353e2016-08-19 00:37:25 +05301068
Preetam Singh Ranawatf1d417c2017-01-10 17:00:32 +05301069
Naresh Tannirucd2353e2016-08-19 00:37:25 +05301070 if ((SND_DEVICE_OUT_BT_A2DP == snd_device) &&
1071 (audio_extn_a2dp_start_playback() < 0)) {
1072 ALOGE(" fail to configure A2dp control path ");
1073 return -EINVAL;
1074 }
1075
Bharath Ramachandramurthy0de16782014-03-28 21:34:33 -07001076 /* due to the possibility of calibration overwrite between listen
1077 and audio, notify listen hal before audio calibration is sent */
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001078 audio_extn_sound_trigger_update_device_status(snd_device,
1079 ST_EVENT_SND_DEVICE_BUSY);
Dhananjay Kumar45b71742014-05-29 21:47:27 +05301080 audio_extn_listen_update_device_status(snd_device,
1081 LISTEN_EVENT_SND_DEVICE_BUSY);
Subhash Chandra Bose Naripeddy54274672014-03-10 14:51:02 -07001082 if (platform_get_snd_device_acdb_id(snd_device) < 0) {
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -07001083 adev->snd_dev_ref_cnt[snd_device]--;
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001084 audio_extn_sound_trigger_update_device_status(snd_device,
1085 ST_EVENT_SND_DEVICE_FREE);
Dhananjay Kumar45b71742014-05-29 21:47:27 +05301086 audio_extn_listen_update_device_status(snd_device,
1087 LISTEN_EVENT_SND_DEVICE_FREE);
Gopikrishnaiah Anandanf538cef2013-10-28 14:06:03 -07001088 return -EINVAL;
1089 }
Lior Barenboim0b61bc72014-05-13 13:01:37 +03001090 audio_extn_dev_arbi_acquire(snd_device);
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001091 audio_route_apply_and_update_path(adev->audio_route, device_name);
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301092
1093 if (SND_DEVICE_OUT_HEADPHONES == snd_device &&
1094 !adev->native_playback_enabled &&
1095 audio_is_true_native_stream_active(adev)) {
1096 ALOGD("%s: %d: napb: enabling native mode in hardware",
1097 __func__, __LINE__);
1098 audio_route_apply_and_update_path(adev->audio_route,
1099 "true-native-mode");
1100 adev->native_playback_enabled = true;
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +05301101 }
Garmond Leunge2433c32017-09-28 21:51:22 -07001102 if ((snd_device == SND_DEVICE_IN_HANDSET_6MIC) &&
1103 (audio_extn_ffv_get_stream() == adev->active_input)) {
1104 ALOGD("%s: init ec ref loopback", __func__);
1105 audio_extn_ffv_init_ec_ref_loopback(adev, snd_device);
1106 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001107 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001108 return 0;
1109}
1110
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07001111int disable_snd_device(struct audio_device *adev,
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001112 snd_device_t snd_device)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001113{
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301114 int i, num_devices = 0;
1115 snd_device_t new_snd_devices[SND_DEVICE_OUT_END];
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001116 char device_name[DEVICE_NAME_MAX_SIZE] = {0};
1117
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001118 if (snd_device < SND_DEVICE_MIN ||
1119 snd_device >= SND_DEVICE_MAX) {
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08001120 ALOGE("%s: Invalid sound device %d", __func__, snd_device);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001121 return -EINVAL;
1122 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001123 if (adev->snd_dev_ref_cnt[snd_device] <= 0) {
1124 ALOGE("%s: device ref cnt is already 0", __func__);
1125 return -EINVAL;
1126 }
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001127
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001128 adev->snd_dev_ref_cnt[snd_device]--;
Apoorv Raghuvanshi5792d4b2013-10-07 18:40:05 -07001129
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001130 if(platform_get_snd_device_name_extn(adev->platform, snd_device, device_name) < 0) {
1131 ALOGE("%s: Invalid sound device returned", __func__);
1132 return -EINVAL;
1133 }
1134
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001135 if (adev->snd_dev_ref_cnt[snd_device] == 0) {
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07001136 ALOGD("%s: snd_device(%d: %s)", __func__, snd_device, device_name);
Naresh Tanniru9d027a62015-03-13 01:32:10 +05301137
Xiaojun Sang040cc9f2015-08-03 19:38:28 +08001138 if (platform_can_enable_spkr_prot_on_device(snd_device) &&
1139 audio_extn_spkr_prot_is_enabled()) {
Anish Kumar46c7b872014-09-09 01:49:44 -07001140 audio_extn_spkr_prot_stop_processing(snd_device);
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07001141
1142 // when speaker device is disabled, reset swap.
1143 // will be renabled on usecase start
1144 platform_set_swap_channels(adev, false);
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001145 } else if (platform_split_snd_device(adev->platform,
1146 snd_device,
1147 &num_devices,
1148 new_snd_devices) == 0) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301149 for (i = 0; i < num_devices; i++) {
1150 disable_snd_device(adev, new_snd_devices[i]);
1151 }
Lior Barenboim0b61bc72014-05-13 13:01:37 +03001152 } else {
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001153 audio_route_reset_and_update_path(adev->audio_route, device_name);
Lior Barenboim0b61bc72014-05-13 13:01:37 +03001154 }
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001155
Naresh Tannirucd2353e2016-08-19 00:37:25 +05301156 if (SND_DEVICE_OUT_BT_A2DP == snd_device)
1157 audio_extn_a2dp_stop_playback();
1158
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07001159 if (snd_device == SND_DEVICE_OUT_HDMI || snd_device == SND_DEVICE_OUT_DISPLAY_PORT)
Ashish Jain81eb2a82015-05-13 10:52:34 +05301160 adev->is_channel_status_set = false;
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301161 else if (SND_DEVICE_OUT_HEADPHONES == snd_device &&
1162 adev->native_playback_enabled) {
1163 ALOGD("%s: %d: napb: disabling native mode in hardware",
1164 __func__, __LINE__);
1165 audio_route_reset_and_update_path(adev->audio_route,
1166 "true-native-mode");
1167 adev->native_playback_enabled = false;
Preetam Singh Ranawatb0c0dd72016-08-18 00:32:06 +05301168 } else if (SND_DEVICE_OUT_HEADPHONES == snd_device &&
1169 adev->asrc_mode_enabled) {
1170 ALOGD("%s: %d: disabling asrc mode in hardware", __func__, __LINE__);
Preetam Singh Ranawat6a836662016-09-08 17:04:35 +05301171 disable_asrc_mode(adev);
1172 audio_route_apply_and_update_path(adev->audio_route, "hph-lowpower-mode");
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301173 }
Garmond Leunge2433c32017-09-28 21:51:22 -07001174 if ((snd_device == SND_DEVICE_IN_HANDSET_6MIC) &&
1175 (audio_extn_ffv_get_stream() == adev->active_input)) {
1176 ALOGD("%s: deinit ec ref loopback", __func__);
1177 audio_extn_ffv_deinit_ec_ref_loopback(adev, snd_device);
1178 }
Ravit Dennisaaee49c2015-02-04 21:26:22 +02001179 audio_extn_dev_arbi_release(snd_device);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07001180 audio_extn_sound_trigger_update_device_status(snd_device,
1181 ST_EVENT_SND_DEVICE_FREE);
Dhananjay Kumar45b71742014-05-29 21:47:27 +05301182 audio_extn_listen_update_device_status(snd_device,
Kiran Kandide144c82013-11-20 15:58:32 -08001183 LISTEN_EVENT_SND_DEVICE_FREE);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001184 }
Ravi Kumar Alamanda48c921d2013-10-29 06:07:44 -07001185
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001186 return 0;
1187}
1188
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001189/*
1190 legend:
1191 uc - existing usecase
1192 new_uc - new usecase
1193 d1, d11, d2 - SND_DEVICE enums
1194 a1, a2 - corresponding ANDROID device enums
1195 B1, B2 - backend strings
1196
1197case 1
1198 uc->dev d1 (a1) B1
1199 new_uc->dev d1 (a1), d2 (a2) B1, B2
1200
1201 resolution: disable and enable uc->dev on d1
1202
1203case 2
1204 uc->dev d1 (a1) B1
1205 new_uc->dev d11 (a1) B1
1206
1207 resolution: need to switch uc since d1 and d11 are related
1208 (e.g. speaker and voice-speaker)
1209 use ANDROID_DEVICE_OUT enums to match devices since SND_DEVICE enums may vary
1210
1211case 3
1212 uc->dev d1 (a1) B1
1213 new_uc->dev d2 (a2) B2
1214
1215 resolution: no need to switch uc
1216
1217case 4
1218 uc->dev d1 (a1) B1
1219 new_uc->dev d2 (a2) B1
1220
1221 resolution: disable enable uc-dev on d2 since backends match
1222 we cannot enable two streams on two different devices if they
1223 share the same backend. e.g. if offload is on speaker device using
1224 QUAD_MI2S backend and a low-latency stream is started on voice-handset
1225 using the same backend, offload must also be switched to voice-handset.
1226
1227case 5
1228 uc->dev d1 (a1) B1
1229 new_uc->dev d1 (a1), d2 (a2) B1
1230
1231 resolution: disable enable uc-dev on d2 since backends match
1232 we cannot enable two streams on two different devices if they
1233 share the same backend.
1234
1235case 6
1236 uc->dev d1 (a1) B1
1237 new_uc->dev d2 (a1) B2
1238
1239 resolution: no need to switch
1240
1241case 7
1242 uc->dev d1 (a1), d2 (a2) B1, B2
1243 new_uc->dev d1 (a1) B1
1244
1245 resolution: no need to switch
1246
1247*/
1248static snd_device_t derive_playback_snd_device(void * platform,
1249 struct audio_usecase *uc,
1250 struct audio_usecase *new_uc,
1251 snd_device_t new_snd_device)
1252{
Siddartha Shaik31b530e2017-05-19 15:26:33 +05301253 audio_devices_t a1, a2;
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001254
1255 snd_device_t d1 = uc->out_snd_device;
1256 snd_device_t d2 = new_snd_device;
1257
Siddartha Shaik31b530e2017-05-19 15:26:33 +05301258 switch (uc->type) {
1259 case TRANSCODE_LOOPBACK :
1260 a1 = uc->stream.inout->out_config.devices;
1261 a2 = new_uc->stream.inout->out_config.devices;
1262 break;
1263 default :
1264 a1 = uc->stream.out->devices;
1265 a2 = new_uc->stream.out->devices;
1266 break;
1267 }
1268
Haynes Mathew Georgebfe8ff42016-09-22 17:38:16 -07001269 // Treat as a special case when a1 and a2 are not disjoint
1270 if ((a1 != a2) && (a1 & a2)) {
1271 snd_device_t d3[2];
1272 int num_devices = 0;
1273 int ret = platform_split_snd_device(platform,
1274 popcount(a1) > 1 ? d1 : d2,
1275 &num_devices,
1276 d3);
1277 if (ret < 0) {
1278 if (ret != -ENOSYS) {
1279 ALOGW("%s failed to split snd_device %d",
1280 __func__,
1281 popcount(a1) > 1 ? d1 : d2);
1282 }
1283 goto end;
1284 }
1285
1286 // NB: case 7 is hypothetical and isn't a practical usecase yet.
1287 // But if it does happen, we need to give priority to d2 if
1288 // the combo devices active on the existing usecase share a backend.
1289 // This is because we cannot have a usecase active on a combo device
1290 // and a new usecase requests one device in this combo pair.
1291 if (platform_check_backends_match(d3[0], d3[1])) {
1292 return d2; // case 5
1293 } else {
1294 return d1; // case 1
1295 }
1296 } else {
1297 if (platform_check_backends_match(d1, d2)) {
1298 return d2; // case 2, 4
1299 } else {
1300 return d1; // case 6, 3
1301 }
1302 }
1303
1304end:
1305 return d2; // return whatever was calculated before.
1306}
1307
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001308static void check_usecases_codec_backend(struct audio_device *adev,
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301309 struct audio_usecase *uc_info,
1310 snd_device_t snd_device)
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001311{
1312 struct listnode *node;
1313 struct audio_usecase *usecase;
1314 bool switch_device[AUDIO_USECASE_MAX];
Chaithanya Krishna Bacharaju49e7db02017-03-14 11:57:26 +05301315 snd_device_t uc_derive_snd_device;
1316 snd_device_t derive_snd_device[AUDIO_USECASE_MAX];
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001317 int i, num_uc_to_switch = 0;
kunleiz5cd52b82016-11-07 17:22:52 +08001318 int status = 0;
Naresh Tanniru9d027a62015-03-13 01:32:10 +05301319 bool force_restart_session = false;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001320 /*
1321 * This function is to make sure that all the usecases that are active on
1322 * the hardware codec backend are always routed to any one device that is
1323 * handled by the hardware codec.
1324 * For example, if low-latency and deep-buffer usecases are currently active
1325 * on speaker and out_set_parameters(headset) is received on low-latency
1326 * output, then we have to make sure deep-buffer is also switched to headset,
1327 * because of the limitation that both the devices cannot be enabled
1328 * at the same time as they share the same backend.
1329 */
Mingming Yin3ee55c62014-08-04 14:23:35 -07001330 /*
1331 * This call is to check if we need to force routing for a particular stream
1332 * If there is a backend configuration change for the device when a
1333 * new stream starts, then ADM needs to be closed and re-opened with the new
1334 * configuraion. This call check if we need to re-route all the streams
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -08001335 * associated with the backend. Touch tone + 24 bit + native playback.
Mingming Yin3ee55c62014-08-04 14:23:35 -07001336 */
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -08001337 bool force_routing = platform_check_and_set_codec_backend_cfg(adev, uc_info,
1338 snd_device);
Naresh Tanniru9d027a62015-03-13 01:32:10 +05301339 /* For a2dp device reconfigure all active sessions
1340 * with new AFE encoder format based on a2dp state
1341 */
1342 if ((SND_DEVICE_OUT_BT_A2DP == snd_device ||
1343 SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP == snd_device) &&
1344 audio_extn_a2dp_is_force_device_switch()) {
1345 force_routing = true;
1346 force_restart_session = true;
1347 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301348 ALOGD("%s:becf: force routing %d", __func__, force_routing);
1349
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001350 /* Disable all the usecases on the shared backend other than the
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -08001351 * specified usecase.
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -08001352 */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001353 for (i = 0; i < AUDIO_USECASE_MAX; i++)
1354 switch_device[i] = false;
1355
1356 list_for_each(node, &adev->usecase_list) {
1357 usecase = node_to_item(node, struct audio_usecase, list);
Apoorv Raghuvanshi21492162015-02-19 18:19:36 -08001358
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301359 ALOGD("%s:becf: (%d) check_usecases curr device: %s, usecase device:%s "
1360 "backends match %d",__func__, i,
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301361 platform_get_snd_device_name(snd_device),
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301362 platform_get_snd_device_name(usecase->out_snd_device),
1363 platform_check_backends_match(snd_device, usecase->out_snd_device));
Ashish Jain6a65b352017-03-21 17:24:40 +05301364 if ((usecase->type != PCM_CAPTURE) && (usecase != uc_info)) {
1365 uc_derive_snd_device = derive_playback_snd_device(adev->platform,
1366 usecase, uc_info, snd_device);
1367 if (((uc_derive_snd_device != usecase->out_snd_device) || force_routing) &&
1368 ((usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
1369 (usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) ||
1370 (usecase->devices & AUDIO_DEVICE_OUT_USB_DEVICE) ||
1371 (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP) ||
1372 (usecase->devices & AUDIO_DEVICE_OUT_ALL_SCO)) &&
1373 ((force_restart_session) ||
1374 (platform_check_backends_match(snd_device, usecase->out_snd_device)))) {
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301375 ALOGD("%s:becf: check_usecases (%s) is active on (%s) - disabling ..",
1376 __func__, use_case_table[usecase->id],
1377 platform_get_snd_device_name(usecase->out_snd_device));
1378 disable_audio_route(adev, usecase);
1379 switch_device[usecase->id] = true;
Chaithanya Krishna Bacharaju49e7db02017-03-14 11:57:26 +05301380 /* Enable existing usecase on derived playback device */
1381 derive_snd_device[usecase->id] = uc_derive_snd_device;
Sidipotu Ashok9f0b16e2016-04-28 13:48:28 +05301382 num_uc_to_switch++;
Ashish Jain6a65b352017-03-21 17:24:40 +05301383 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001384 }
1385 }
1386
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301387 ALOGD("%s:becf: check_usecases num.of Usecases to switch %d", __func__,
1388 num_uc_to_switch);
1389
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001390 if (num_uc_to_switch) {
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001391 /* All streams have been de-routed. Disable the device */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001392
Venkata Narendra Kumar Gutta7610e632014-04-14 23:16:38 +05301393 /* Make sure the previous devices to be disabled first and then enable the
1394 selected devices */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001395 list_for_each(node, &adev->usecase_list) {
1396 usecase = node_to_item(node, struct audio_usecase, list);
1397 if (switch_device[usecase->id]) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001398 disable_snd_device(adev, usecase->out_snd_device);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001399 }
1400 }
1401
Krishnankutty Kolathappillydc4f7572013-11-01 20:07:13 -07001402 list_for_each(node, &adev->usecase_list) {
1403 usecase = node_to_item(node, struct audio_usecase, list);
1404 if (switch_device[usecase->id]) {
Chaithanya Krishna Bacharaju49e7db02017-03-14 11:57:26 +05301405 enable_snd_device(adev, derive_snd_device[usecase->id]);
Krishnankutty Kolathappillydc4f7572013-11-01 20:07:13 -07001406 }
1407 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001408
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001409 /* Re-route all the usecases on the shared backend other than the
1410 specified usecase to new snd devices */
1411 list_for_each(node, &adev->usecase_list) {
1412 usecase = node_to_item(node, struct audio_usecase, list);
Karthik Reddy Katta3abfee22016-02-23 10:55:27 +05301413 /* Update the out_snd_device only before enabling the audio route */
1414 if (switch_device[usecase->id]) {
Chaithanya Krishna Bacharaju49e7db02017-03-14 11:57:26 +05301415 usecase->out_snd_device = derive_snd_device[usecase->id];
Karthik Reddy Katta3abfee22016-02-23 10:55:27 +05301416 if (usecase->type != VOICE_CALL) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301417 ALOGD("%s:becf: enabling usecase (%s) on (%s)", __func__,
Karthik Reddy Katta3abfee22016-02-23 10:55:27 +05301418 use_case_table[usecase->id],
1419 platform_get_snd_device_name(usecase->out_snd_device));
kunleiz5cd52b82016-11-07 17:22:52 +08001420 /* Update voc calibration before enabling VoIP route */
1421 if (usecase->type == VOIP_CALL)
1422 status = platform_switch_voice_call_device_post(adev->platform,
1423 usecase->out_snd_device,
kunleizab514ca2017-01-09 14:59:50 +08001424 platform_get_input_snd_device(adev->platform, uc_info->devices));
Avinash Vaish71a8b972014-07-24 15:36:33 +05301425 enable_audio_route(adev, usecase);
Karthik Reddy Katta3abfee22016-02-23 10:55:27 +05301426 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001427 }
1428 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001429 }
1430}
1431
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05301432static void check_usecases_capture_codec_backend(struct audio_device *adev,
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001433 struct audio_usecase *uc_info,
1434 snd_device_t snd_device)
1435{
1436 struct listnode *node;
1437 struct audio_usecase *usecase;
1438 bool switch_device[AUDIO_USECASE_MAX];
1439 int i, num_uc_to_switch = 0;
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +05301440 int backend_check_cond = AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND;
kunleiz5cd52b82016-11-07 17:22:52 +08001441 int status = 0;
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001442
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05301443 bool force_routing = platform_check_and_set_capture_codec_backend_cfg(adev, uc_info,
1444 snd_device);
1445 ALOGD("%s:becf: force routing %d", __func__, force_routing);
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +05301446
1447 /*
1448 * Make sure out devices is checked against out codec backend device and
1449 * also in devices against in codec backend. Checking out device against in
1450 * codec backend or vice versa causes issues.
1451 */
1452 if (uc_info->type == PCM_CAPTURE)
1453 backend_check_cond = AUDIO_DEVICE_IN_ALL_CODEC_BACKEND;
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001454 /*
1455 * This function is to make sure that all the active capture usecases
1456 * are always routed to the same input sound device.
1457 * For example, if audio-record and voice-call usecases are currently
1458 * active on speaker(rx) and speaker-mic (tx) and out_set_parameters(earpiece)
1459 * is received for voice call then we have to make sure that audio-record
1460 * usecase is also switched to earpiece i.e. voice-dmic-ef,
1461 * because of the limitation that two devices cannot be enabled
1462 * at the same time if they share the same backend.
1463 */
1464 for (i = 0; i < AUDIO_USECASE_MAX; i++)
1465 switch_device[i] = false;
1466
1467 list_for_each(node, &adev->usecase_list) {
1468 usecase = node_to_item(node, struct audio_usecase, list);
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +05301469 /*
1470 * TODO: Enhance below condition to handle BT sco/USB multi recording
1471 */
Shiv Maliyappanahalli80ac6282013-12-20 18:56:15 -08001472 if (usecase->type != PCM_PLAYBACK &&
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001473 usecase != uc_info &&
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05301474 (usecase->in_snd_device != snd_device || force_routing) &&
Dhanalakshmi Siddanib678a802016-12-03 11:51:41 +05301475 ((uc_info->devices & backend_check_cond) &&
Karthik Reddy Katta0d471762015-08-20 13:36:07 +05301476 (((usecase->devices & ~AUDIO_DEVICE_BIT_IN) & AUDIO_DEVICE_IN_ALL_CODEC_BACKEND) ||
Satya Krishna Pindiproli458b5a72017-03-13 15:14:24 +05301477 (usecase->type == VOIP_CALL))) &&
Anish Kumara020a7c2014-10-17 11:13:22 -07001478 (usecase->id != USECASE_AUDIO_SPKR_CALIB_TX)) {
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001479 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
1480 __func__, use_case_table[usecase->id],
Devin Kim1e5f3532013-08-09 07:48:29 -07001481 platform_get_snd_device_name(usecase->in_snd_device));
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001482 disable_audio_route(adev, usecase);
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001483 switch_device[usecase->id] = true;
1484 num_uc_to_switch++;
1485 }
1486 }
1487
1488 if (num_uc_to_switch) {
Haynes Mathew Georgeef1e3d32014-04-24 11:53:44 -07001489 /* All streams have been de-routed. Disable the device */
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001490
Venkata Narendra Kumar Gutta7610e632014-04-14 23:16:38 +05301491 /* Make sure the previous devices to be disabled first and then enable the
1492 selected devices */
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001493 list_for_each(node, &adev->usecase_list) {
1494 usecase = node_to_item(node, struct audio_usecase, list);
1495 if (switch_device[usecase->id]) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001496 disable_snd_device(adev, usecase->in_snd_device);
Shiv Maliyappanahalli80ac6282013-12-20 18:56:15 -08001497 }
1498 }
1499
1500 list_for_each(node, &adev->usecase_list) {
1501 usecase = node_to_item(node, struct audio_usecase, list);
1502 if (switch_device[usecase->id]) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07001503 enable_snd_device(adev, snd_device);
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001504 }
1505 }
1506
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001507 /* Re-route all the usecases on the shared backend other than the
1508 specified usecase to new snd devices */
1509 list_for_each(node, &adev->usecase_list) {
1510 usecase = node_to_item(node, struct audio_usecase, list);
1511 /* Update the in_snd_device only before enabling the audio route */
1512 if (switch_device[usecase->id] ) {
1513 usecase->in_snd_device = snd_device;
kunleiz5cd52b82016-11-07 17:22:52 +08001514 if (usecase->type != VOICE_CALL) {
1515 /* Update voc calibration before enabling VoIP route */
1516 if (usecase->type == VOIP_CALL)
1517 status = platform_switch_voice_call_device_post(adev->platform,
Zhou Song557e7282017-05-05 17:18:18 +08001518 platform_get_output_snd_device(adev->platform, uc_info->stream.out),
kunleiz5cd52b82016-11-07 17:22:52 +08001519 usecase->in_snd_device);
Avinash Vaish71a8b972014-07-24 15:36:33 +05301520 enable_audio_route(adev, usecase);
kunleiz5cd52b82016-11-07 17:22:52 +08001521 }
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001522 }
1523 }
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07001524 }
1525}
1526
Mingming Yin3a941d42016-02-17 18:08:05 -08001527static void reset_hdmi_sink_caps(struct stream_out *out) {
1528 int i = 0;
1529
1530 for (i = 0; i<= MAX_SUPPORTED_CHANNEL_MASKS; i++) {
1531 out->supported_channel_masks[i] = 0;
1532 }
1533 for (i = 0; i<= MAX_SUPPORTED_FORMATS; i++) {
1534 out->supported_formats[i] = 0;
1535 }
1536 for (i = 0; i<= MAX_SUPPORTED_SAMPLE_RATES; i++) {
1537 out->supported_sample_rates[i] = 0;
1538 }
1539}
1540
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001541/* must be called with hw device mutex locked */
Mingming Yin3a941d42016-02-17 18:08:05 -08001542static int read_hdmi_sink_caps(struct stream_out *out)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001543{
Mingming Yin3a941d42016-02-17 18:08:05 -08001544 int ret = 0, i = 0, j = 0;
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -07001545 int channels = platform_edid_get_max_channels(out->dev->platform);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001546
Mingming Yin3a941d42016-02-17 18:08:05 -08001547 reset_hdmi_sink_caps(out);
1548
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07001549 /* Cache ext disp type */
Garmond Leung37850ab2016-10-06 11:42:18 -07001550 if (platform_get_ext_disp_type(adev->platform) <= 0) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07001551 ALOGE("%s: Failed to query disp type, ret:%d", __func__, ret);
Garmond Leung37850ab2016-10-06 11:42:18 -07001552 return -EINVAL;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07001553 }
1554
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001555 switch (channels) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001556 case 8:
Mingming Yin3a941d42016-02-17 18:08:05 -08001557 ALOGV("%s: HDMI supports 7.1 channels", __func__);
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07001558 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_7POINT1;
Mingming Yin3a941d42016-02-17 18:08:05 -08001559 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_6POINT1;
1560 case 6:
1561 ALOGV("%s: HDMI supports 5.1 channels", __func__);
1562 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_5POINT1;
1563 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_PENTA;
1564 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_QUAD;
1565 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_SURROUND;
1566 out->supported_channel_masks[i++] = AUDIO_CHANNEL_OUT_2POINT1;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001567 break;
1568 default:
Mingming Yin3a941d42016-02-17 18:08:05 -08001569 ALOGE("invalid/nonstandard channal count[%d]",channels);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001570 ret = -ENOSYS;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001571 break;
1572 }
Mingming Yin3a941d42016-02-17 18:08:05 -08001573
1574 // check channel format caps
1575 i = 0;
1576 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_AC3)) {
1577 ALOGV(":%s HDMI supports AC3/EAC3 formats", __func__);
1578 out->supported_formats[i++] = AUDIO_FORMAT_AC3;
1579 //Adding EAC3/EAC3_JOC formats if AC3 is supported by the sink.
1580 //EAC3/EAC3_JOC will be converted to AC3 for decoding if needed
1581 out->supported_formats[i++] = AUDIO_FORMAT_E_AC3;
1582 out->supported_formats[i++] = AUDIO_FORMAT_E_AC3_JOC;
1583 }
1584
Ben Romberger1aaaf862017-04-06 17:49:46 -07001585 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_DOLBY_TRUEHD)) {
1586 ALOGV(":%s HDMI supports TRUE HD format", __func__);
1587 out->supported_formats[i++] = AUDIO_FORMAT_DOLBY_TRUEHD;
1588 }
1589
Mingming Yin3a941d42016-02-17 18:08:05 -08001590 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_DTS)) {
1591 ALOGV(":%s HDMI supports DTS format", __func__);
1592 out->supported_formats[i++] = AUDIO_FORMAT_DTS;
1593 }
1594
1595 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_DTS_HD)) {
1596 ALOGV(":%s HDMI supports DTS HD format", __func__);
1597 out->supported_formats[i++] = AUDIO_FORMAT_DTS_HD;
1598 }
1599
Naresh Tanniru928f0862017-04-07 16:44:23 -07001600 if (platform_is_edid_supported_format(out->dev->platform, AUDIO_FORMAT_IEC61937)) {
1601 ALOGV(":%s HDMI supports IEC61937 format", __func__);
1602 out->supported_formats[i++] = AUDIO_FORMAT_IEC61937;
1603 }
1604
Mingming Yin3a941d42016-02-17 18:08:05 -08001605
1606 // check sample rate caps
1607 i = 0;
1608 for (j = 0; j < MAX_SUPPORTED_SAMPLE_RATES; j++) {
1609 if (platform_is_edid_supported_sample_rate(out->dev->platform, out_hdmi_sample_rates[j])) {
1610 ALOGV(":%s HDMI supports sample rate:%d", __func__, out_hdmi_sample_rates[j]);
1611 out->supported_sample_rates[i++] = out_hdmi_sample_rates[j];
1612 }
1613 }
1614
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001615 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001616}
1617
Haynes Mathew George484e8d22017-07-31 18:55:17 -07001618static inline ssize_t read_usb_sup_sample_rates(bool is_playback __unused,
1619 uint32_t *supported_sample_rates __unused,
1620 uint32_t max_rates __unused)
1621{
1622 ssize_t count = audio_extn_usb_get_sup_sample_rates(is_playback,
1623 supported_sample_rates,
1624 max_rates);
Ashish Jain4847e9d2017-08-17 19:16:57 +05301625 ssize_t i = 0;
1626
1627 for (i=0; i<count; i++) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07001628 ALOGV("%s %s %d", __func__, is_playback ? "P" : "C",
1629 supported_sample_rates[i]);
1630 }
1631 return count;
1632}
1633
1634static inline int read_usb_sup_channel_masks(bool is_playback,
1635 audio_channel_mask_t *supported_channel_masks,
1636 uint32_t max_masks)
1637{
1638 int channels = audio_extn_usb_get_max_channels(is_playback);
1639 int channel_count;
1640 uint32_t num_masks = 0;
1641 if (channels > MAX_HIFI_CHANNEL_COUNT)
1642 channels = MAX_HIFI_CHANNEL_COUNT;
1643
1644 if (is_playback) {
1645 // For playback we never report mono because the framework always outputs stereo
1646 channel_count = DEFAULT_CHANNEL_COUNT;
1647 // audio_channel_out_mask_from_count() does return positional masks for channel counts
1648 // above 2 but we want indexed masks here. So we
1649 for ( ; channel_count <= channels && num_masks < max_masks; channel_count++) {
1650 supported_channel_masks[num_masks++] = audio_channel_out_mask_from_count(channel_count);
1651 }
1652 for ( ; channel_count <= channels && num_masks < max_masks; channel_count++) {
1653 supported_channel_masks[num_masks++] =
1654 audio_channel_mask_for_index_assignment_from_count(channel_count);
1655 }
1656 } else {
1657 // For capture we report all supported channel masks from 1 channel up.
1658 channel_count = MIN_CHANNEL_COUNT;
1659 // audio_channel_in_mask_from_count() does the right conversion to either positional or
1660 // indexed mask
1661 for ( ; channel_count <= channels && num_masks < max_masks; channel_count++) {
1662 supported_channel_masks[num_masks++] =
1663 audio_channel_in_mask_from_count(channel_count);
1664 }
1665 }
1666 ALOGV("%s: %s supported ch %d supported_channel_masks[0] %08x num_masks %d", __func__,
1667 is_playback ? "P" : "C", channels, supported_channel_masks[0], num_masks);
1668 return num_masks;
1669}
1670
1671static inline int read_usb_sup_formats(bool is_playback __unused,
1672 audio_format_t *supported_formats,
1673 uint32_t max_formats __unused)
1674{
1675 int bitwidth = audio_extn_usb_get_max_bit_width(is_playback);
1676 switch (bitwidth) {
1677 case 24:
1678 // XXX : usb.c returns 24 for s24 and s24_le?
1679 supported_formats[0] = AUDIO_FORMAT_PCM_24_BIT_PACKED;
1680 break;
1681 case 32:
1682 supported_formats[0] = AUDIO_FORMAT_PCM_32_BIT;
1683 break;
1684 case 16:
1685 default :
1686 supported_formats[0] = AUDIO_FORMAT_PCM_16_BIT;
1687 break;
1688 }
1689 ALOGV("%s: %s supported format %d", __func__,
1690 is_playback ? "P" : "C", bitwidth);
1691 return 1;
1692}
1693
1694static inline int read_usb_sup_params_and_compare(bool is_playback,
1695 audio_format_t *format,
1696 audio_format_t *supported_formats,
1697 uint32_t max_formats,
1698 audio_channel_mask_t *mask,
1699 audio_channel_mask_t *supported_channel_masks,
1700 uint32_t max_masks,
1701 uint32_t *rate,
1702 uint32_t *supported_sample_rates,
1703 uint32_t max_rates) {
1704 int ret = 0;
1705 int num_formats;
1706 int num_masks;
1707 int num_rates;
1708 int i;
1709
1710 num_formats = read_usb_sup_formats(is_playback, supported_formats,
1711 max_formats);
1712 num_masks = read_usb_sup_channel_masks(is_playback, supported_channel_masks,
1713 max_masks);
1714
1715 num_rates = read_usb_sup_sample_rates(is_playback,
1716 supported_sample_rates, max_rates);
1717
1718#define LUT(table, len, what, dflt) \
1719 for (i=0; i<len && (table[i] != what); i++); \
1720 if (i==len) { ret |= (what == dflt ? 0 : -1); what=table[0]; }
1721
1722 LUT(supported_formats, num_formats, *format, AUDIO_FORMAT_DEFAULT);
1723 LUT(supported_channel_masks, num_masks, *mask, AUDIO_CHANNEL_NONE);
1724 LUT(supported_sample_rates, num_rates, *rate, 0);
1725
1726#undef LUT
1727 return ret < 0 ? -EINVAL : 0; // HACK TBD
1728}
1729
Alexy Josephb1379942016-01-29 15:49:38 -08001730audio_usecase_t get_usecase_id_from_usecase_type(const struct audio_device *adev,
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -08001731 usecase_type_t type)
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07001732{
1733 struct audio_usecase *usecase;
1734 struct listnode *node;
1735
1736 list_for_each(node, &adev->usecase_list) {
1737 usecase = node_to_item(node, struct audio_usecase, list);
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -08001738 if (usecase->type == type) {
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07001739 ALOGV("%s: usecase id %d", __func__, usecase->id);
1740 return usecase->id;
1741 }
1742 }
1743 return USECASE_INVALID;
1744}
1745
Alexy Josephb1379942016-01-29 15:49:38 -08001746struct audio_usecase *get_usecase_from_list(const struct audio_device *adev,
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07001747 audio_usecase_t uc_id)
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001748{
1749 struct audio_usecase *usecase;
1750 struct listnode *node;
1751
1752 list_for_each(node, &adev->usecase_list) {
1753 usecase = node_to_item(node, struct audio_usecase, list);
1754 if (usecase->id == uc_id)
1755 return usecase;
1756 }
1757 return NULL;
1758}
1759
Dhananjay Kumard4833242016-10-06 22:09:12 +05301760struct stream_in *get_next_active_input(const struct audio_device *adev)
1761{
1762 struct audio_usecase *usecase;
1763 struct listnode *node;
1764
1765 list_for_each_reverse(node, &adev->usecase_list) {
1766 usecase = node_to_item(node, struct audio_usecase, list);
1767 if (usecase->type == PCM_CAPTURE)
1768 return usecase->stream.in;
1769 }
1770 return NULL;
1771}
1772
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301773/*
1774 * is a true native playback active
1775 */
1776bool audio_is_true_native_stream_active(struct audio_device *adev)
1777{
1778 bool active = false;
1779 int i = 0;
1780 struct listnode *node;
1781
1782 if (NATIVE_AUDIO_MODE_TRUE_44_1 != platform_get_native_support()) {
1783 ALOGV("%s:napb: not in true mode or non hdphones device",
1784 __func__);
1785 active = false;
1786 goto exit;
1787 }
1788
1789 list_for_each(node, &adev->usecase_list) {
1790 struct audio_usecase *uc;
1791 uc = node_to_item(node, struct audio_usecase, list);
1792 struct stream_out *curr_out =
1793 (struct stream_out*) uc->stream.out;
1794
1795 if (curr_out && PCM_PLAYBACK == uc->type) {
1796 ALOGD("%s:napb: (%d) (%s)id (%d) sr %d bw "
1797 "(%d) device %s", __func__, i++, use_case_table[uc->id],
1798 uc->id, curr_out->sample_rate,
1799 curr_out->bit_width,
1800 platform_get_snd_device_name(uc->out_snd_device));
1801
1802 if (is_offload_usecase(uc->id) &&
1803 (curr_out->sample_rate == OUTPUT_SAMPLING_RATE_44100)) {
1804 active = true;
1805 ALOGD("%s:napb:native stream detected", __func__);
1806 }
1807 }
1808 }
1809exit:
1810 return active;
1811}
1812
Xiaojun Sang785b5da2017-08-03 15:52:29 +08001813uint32_t adev_get_dsp_bit_width_enforce_mode()
1814{
1815 if (adev == NULL) {
1816 ALOGE("%s: adev is null. Disable DSP bit width enforce mode.\n", __func__);
1817 return 0;
1818 }
1819 return adev->dsp_bit_width_enforce_mode;
1820}
1821
1822static uint32_t adev_init_dsp_bit_width_enforce_mode(struct mixer *mixer)
1823{
1824 char value[PROPERTY_VALUE_MAX];
1825 int trial;
1826 uint32_t dsp_bit_width_enforce_mode = 0;
1827
1828 if (!mixer) {
1829 ALOGE("%s: adev mixer is null. cannot update DSP bitwidth.\n",
1830 __func__);
1831 return 0;
1832 }
1833
1834 if (property_get("persist.vendor.audio_hal.dsp_bit_width_enforce_mode",
1835 value, NULL) > 0) {
1836 trial = atoi(value);
1837 switch (trial) {
1838 case 16:
1839 dsp_bit_width_enforce_mode = 16;
1840 break;
1841 case 24:
1842 dsp_bit_width_enforce_mode = 24;
1843 break;
1844 case 32:
1845 dsp_bit_width_enforce_mode = 32;
1846 break;
1847 default:
1848 dsp_bit_width_enforce_mode = 0;
1849 ALOGD("%s Dynamic DSP bitwidth config is disabled.", __func__);
1850 break;
1851 }
1852 }
1853
1854 return dsp_bit_width_enforce_mode;
1855}
1856
1857static void audio_enable_asm_bit_width_enforce_mode(struct mixer *mixer,
1858 uint32_t enforce_mode,
1859 bool enable)
1860{
1861 struct mixer_ctl *ctl = NULL;
1862 const char *mixer_ctl_name = "ASM Bit Width";
1863 uint32_t asm_bit_width_mode = 0;
1864
1865 if (enforce_mode == 0) {
1866 ALOGD("%s: DSP bitwidth feature is disabled.", __func__);
1867 return;
1868 }
1869
1870 ctl = mixer_get_ctl_by_name(mixer, mixer_ctl_name);
1871 if (!ctl) {
1872 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1873 __func__, mixer_ctl_name);
1874 return;
1875 }
1876
1877 if (enable)
1878 asm_bit_width_mode = enforce_mode;
1879 else
1880 asm_bit_width_mode = 0;
1881
1882 ALOGV("%s DSP bit width feature status is %d width=%d",
1883 __func__, enable, asm_bit_width_mode);
1884 if (mixer_ctl_set_value(ctl, 0, asm_bit_width_mode) < 0)
1885 ALOGE("%s: Could not set ASM biwidth %d", __func__,
1886 asm_bit_width_mode);
1887
1888 return;
1889}
1890
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05301891/*
1892 * if native DSD playback active
1893 */
1894bool audio_is_dsd_native_stream_active(struct audio_device *adev)
1895{
1896 bool active = false;
1897 struct listnode *node = NULL;
1898 struct audio_usecase *uc = NULL;
1899 struct stream_out *curr_out = NULL;
1900
1901 list_for_each(node, &adev->usecase_list) {
1902 uc = node_to_item(node, struct audio_usecase, list);
1903 curr_out = (struct stream_out*) uc->stream.out;
1904
1905 if (curr_out && PCM_PLAYBACK == uc->type &&
1906 (DSD_NATIVE_BACKEND == platform_get_backend_index(uc->out_snd_device))) {
1907 active = true;
1908 ALOGV("%s:DSD playback is active", __func__);
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05301909 break;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05301910 }
1911 }
1912 return active;
1913}
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301914
1915static bool force_device_switch(struct audio_usecase *usecase)
1916{
1917 bool ret = false;
1918 bool is_it_true_mode = false;
1919
Aalique Grahamecbc46a22017-10-05 10:30:23 -07001920 if(usecase->stream.out == NULL) {
1921 ALOGE("%s: stream.out is NULL", __func__);
1922 return false;
1923 }
1924
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301925 if (is_offload_usecase(usecase->id) &&
Xiaojun Sang869f2012016-02-23 16:33:07 +08001926 (usecase->stream.out->sample_rate == OUTPUT_SAMPLING_RATE_44100) &&
1927 (usecase->stream.out->devices == AUDIO_DEVICE_OUT_WIRED_HEADSET ||
1928 usecase->stream.out->devices == AUDIO_DEVICE_OUT_WIRED_HEADPHONE)) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301929 is_it_true_mode = (NATIVE_AUDIO_MODE_TRUE_44_1 == platform_get_native_support()? true : false);
1930 if ((is_it_true_mode && !adev->native_playback_enabled) ||
1931 (!is_it_true_mode && adev->native_playback_enabled)){
1932 ret = true;
1933 ALOGD("napb: time to toggle native mode");
1934 }
1935 }
1936
Naresh Tanniru9d027a62015-03-13 01:32:10 +05301937 // Force all a2dp output devices to reconfigure for proper AFE encode format
Ashish Jainc597d102016-12-12 10:31:34 +05301938 //Also handle a case where in earlier a2dp start failed as A2DP stream was
1939 //in suspended state, hence try to trigger a retry when we again get a routing request.
Aalique Grahamecbc46a22017-10-05 10:30:23 -07001940 if((usecase->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
Ashish Jainc597d102016-12-12 10:31:34 +05301941 audio_extn_a2dp_is_force_device_switch()) {
Naresh Tanniru9d027a62015-03-13 01:32:10 +05301942 ALOGD("Force a2dp device switch to update new encoder config");
1943 ret = true;
1944 }
1945
Manish Dewangan671a4202017-08-18 17:30:46 +05301946 if (usecase->stream.out->stream_config_changed) {
1947 ALOGD("Force stream_config_changed to update iec61937 transmission config");
1948 return true;
1949 }
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05301950 return ret;
1951}
1952
Ashish Jain1b9b30c2017-05-18 20:57:40 +05301953bool is_btsco_device(snd_device_t out_snd_device, snd_device_t in_snd_device)
1954{
1955 bool ret=false;
1956 if ((out_snd_device == SND_DEVICE_OUT_BT_SCO ||
1957 out_snd_device == SND_DEVICE_OUT_BT_SCO_WB) ||
1958 in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB_NREC ||
1959 in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_WB ||
1960 in_snd_device == SND_DEVICE_IN_BT_SCO_MIC_NREC ||
1961 in_snd_device == SND_DEVICE_IN_BT_SCO_MIC)
1962 ret = true;
1963
1964 return ret;
1965}
1966
1967bool is_a2dp_device(snd_device_t out_snd_device)
1968{
1969 bool ret=false;
1970 if (out_snd_device == SND_DEVICE_OUT_BT_A2DP)
1971 ret = true;
1972
1973 return ret;
1974}
1975
1976bool is_bt_soc_on(struct audio_device *adev)
1977{
1978 struct mixer_ctl *ctl;
1979 char *mixer_ctl_name = "BT SOC status";
1980 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1981 bool bt_soc_status = true;
1982 if (!ctl) {
1983 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1984 __func__, mixer_ctl_name);
1985 /*This is to ensure we dont break targets which dont have the kernel change*/
1986 return true;
1987 }
1988 bt_soc_status = mixer_ctl_get_value(ctl, 0);
1989 ALOGD("BT SOC status: %d",bt_soc_status);
1990 return bt_soc_status;
1991}
1992
1993int out_standby_l(struct audio_stream *stream);
1994
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07001995int select_devices(struct audio_device *adev, audio_usecase_t uc_id)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001996{
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08001997 snd_device_t out_snd_device = SND_DEVICE_NONE;
1998 snd_device_t in_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001999 struct audio_usecase *usecase = NULL;
2000 struct audio_usecase *vc_usecase = NULL;
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08002001 struct audio_usecase *voip_usecase = NULL;
Vimal Puthanveed37b4a1c2014-01-07 16:47:47 -08002002 struct audio_usecase *hfp_usecase = NULL;
Siddartha Shaik44dd7702017-06-14 12:13:25 +05302003 struct stream_out stream_out;
Vimal Puthanveed41fcff22014-01-23 15:56:53 -08002004 audio_usecase_t hfp_ucid;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002005 int status = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002006
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302007 ALOGD("%s for use case (%s)", __func__, use_case_table[uc_id]);
2008
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002009 usecase = get_usecase_from_list(adev, uc_id);
2010 if (usecase == NULL) {
2011 ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id);
2012 return -EINVAL;
2013 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002014
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08002015 if ((usecase->type == VOICE_CALL) ||
Vimal Puthanveed5b4d3f12013-11-05 15:57:39 -08002016 (usecase->type == VOIP_CALL) ||
2017 (usecase->type == PCM_HFP_CALL)) {
Aditya Bavanaribdda2f22016-10-19 15:02:05 +05302018 if(usecase->stream.out == NULL) {
2019 ALOGE("%s: stream.out is NULL", __func__);
2020 return -EINVAL;
2021 }
Eric Laurentb23d5282013-05-14 15:27:20 -07002022 out_snd_device = platform_get_output_snd_device(adev->platform,
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -08002023 usecase->stream.out);
Eric Laurentb23d5282013-05-14 15:27:20 -07002024 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002025 usecase->devices = usecase->stream.out->devices;
Siddartha Shaik31b530e2017-05-19 15:26:33 +05302026 } else if (usecase->type == TRANSCODE_LOOPBACK ) {
2027 if (usecase->stream.inout == NULL) {
2028 ALOGE("%s: stream.inout is NULL", __func__);
2029 return -EINVAL;
2030 }
Siddartha Shaik44dd7702017-06-14 12:13:25 +05302031 stream_out.devices = usecase->stream.inout->out_config.devices;
2032 stream_out.sample_rate = usecase->stream.inout->out_config.sample_rate;
2033 stream_out.format = usecase->stream.inout->out_config.format;
2034 stream_out.channel_mask = usecase->stream.inout->out_config.channel_mask;
2035 out_snd_device = platform_get_output_snd_device(adev->platform,
2036 &stream_out);
2037 in_snd_device = platform_get_input_snd_device(adev->platform, AUDIO_DEVICE_NONE);
Siddartha Shaik31b530e2017-05-19 15:26:33 +05302038 usecase->devices = (out_snd_device | in_snd_device);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002039 } else {
2040 /*
2041 * If the voice call is active, use the sound devices of voice call usecase
2042 * so that it would not result any device switch. All the usecases will
2043 * be switched to new device when select_devices() is called for voice call
2044 * usecase. This is to avoid switching devices for voice call when
2045 * check_usecases_codec_backend() is called below.
Alexy Joseph79dfa3c2016-04-20 18:44:56 -07002046 * choose voice call device only if the use case device is
2047 * also using the codec backend
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002048 */
Shiv Maliyappanahallibb4cf0b2016-01-21 11:30:06 -08002049 if (voice_is_in_call(adev) && adev->mode != AUDIO_MODE_NORMAL) {
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07002050 vc_usecase = get_usecase_from_list(adev,
Narsinga Rao Chellaf928a982015-03-06 14:57:35 -08002051 get_usecase_id_from_usecase_type(adev, VOICE_CALL));
Alexy Josephdbcddf22016-05-16 17:54:09 -07002052 if ((vc_usecase) && (((vc_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) &&
2053 (usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND)) ||
Preetam Singh Ranawat097cb1f2016-07-19 13:49:04 +05302054 ((vc_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) &&
2055 (usecase->devices & AUDIO_DEVICE_IN_ALL_CODEC_BACKEND)) ||
Alexy Josephdbcddf22016-05-16 17:54:09 -07002056 (usecase->devices == AUDIO_DEVICE_IN_VOICE_CALL))) {
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002057 in_snd_device = vc_usecase->in_snd_device;
2058 out_snd_device = vc_usecase->out_snd_device;
2059 }
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08002060 } else if (voice_extn_compress_voip_is_active(adev)) {
yidongh02ef86f2017-04-21 15:36:04 +08002061 bool out_snd_device_backend_match = true;
yidongh47785a82017-05-08 19:29:29 +08002062 voip_usecase = get_usecase_from_list(adev, USECASE_COMPRESS_VOIP_CALL);
yidongh6261d8e2017-05-15 17:04:02 +08002063 if ((voip_usecase != NULL) &&
2064 (usecase->type == PCM_PLAYBACK) &&
2065 (usecase->stream.out != NULL)) {
yidongh02ef86f2017-04-21 15:36:04 +08002066 out_snd_device_backend_match = platform_check_backends_match(
2067 voip_usecase->out_snd_device,
2068 platform_get_output_snd_device(
2069 adev->platform,
2070 usecase->stream.out));
2071 }
Mingming Yin2d8aa2e2014-08-14 00:00:51 -07002072 if ((voip_usecase) && ((voip_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) &&
Zhou Song0154bf12016-08-04 10:48:16 +08002073 ((usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
2074 ((usecase->devices & ~AUDIO_DEVICE_BIT_IN) & AUDIO_DEVICE_IN_ALL_CODEC_BACKEND)) &&
yidongh02ef86f2017-04-21 15:36:04 +08002075 out_snd_device_backend_match &&
Mingming Yin2d8aa2e2014-08-14 00:00:51 -07002076 (voip_usecase->stream.out != adev->primary_output))) {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08002077 in_snd_device = voip_usecase->in_snd_device;
2078 out_snd_device = voip_usecase->out_snd_device;
2079 }
Vimal Puthanveed37b4a1c2014-01-07 16:47:47 -08002080 } else if (audio_extn_hfp_is_active(adev)) {
Vimal Puthanveed41fcff22014-01-23 15:56:53 -08002081 hfp_ucid = audio_extn_hfp_get_usecase();
2082 hfp_usecase = get_usecase_from_list(adev, hfp_ucid);
Mingming Yin2d8aa2e2014-08-14 00:00:51 -07002083 if ((hfp_usecase) && (hfp_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND)) {
Vimal Puthanveed37b4a1c2014-01-07 16:47:47 -08002084 in_snd_device = hfp_usecase->in_snd_device;
2085 out_snd_device = hfp_usecase->out_snd_device;
2086 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002087 }
2088 if (usecase->type == PCM_PLAYBACK) {
Aditya Bavanaribdda2f22016-10-19 15:02:05 +05302089 if (usecase->stream.out == NULL) {
2090 ALOGE("%s: stream.out is NULL", __func__);
2091 return -EINVAL;
2092 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002093 usecase->devices = usecase->stream.out->devices;
2094 in_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002095 if (out_snd_device == SND_DEVICE_NONE) {
Eric Laurentb23d5282013-05-14 15:27:20 -07002096 out_snd_device = platform_get_output_snd_device(adev->platform,
Apoorv Raghuvanshif59bb222015-02-18 12:23:23 -08002097 usecase->stream.out);
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002098 if (usecase->stream.out == adev->primary_output &&
2099 adev->active_input &&
Ravi Kumar Alamandad1c85bb2014-11-17 18:36:24 -08002100 out_snd_device != usecase->out_snd_device) {
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002101 select_devices(adev, adev->active_input->usecase);
2102 }
2103 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002104 } else if (usecase->type == PCM_CAPTURE) {
Aditya Bavanaribdda2f22016-10-19 15:02:05 +05302105 if (usecase->stream.in == NULL) {
2106 ALOGE("%s: stream.in is NULL", __func__);
2107 return -EINVAL;
2108 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002109 usecase->devices = usecase->stream.in->device;
2110 out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002111 if (in_snd_device == SND_DEVICE_NONE) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002112 audio_devices_t out_device = AUDIO_DEVICE_NONE;
Leena Winterrowd3c8fbae2016-01-12 15:05:53 -08002113 if (adev->active_input &&
2114 (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
Karthik Reddy Kattaf621ec72014-11-21 16:37:38 +05302115 (adev->mode == AUDIO_MODE_IN_COMMUNICATION &&
2116 adev->active_input->source == AUDIO_SOURCE_MIC)) &&
2117 adev->primary_output && !adev->primary_output->standby) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002118 out_device = adev->primary_output->devices;
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -07002119 platform_set_echo_reference(adev, false, AUDIO_DEVICE_NONE);
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002120 } else if (usecase->id == USECASE_AUDIO_RECORD_AFE_PROXY) {
2121 out_device = AUDIO_DEVICE_OUT_TELEPHONY_TX;
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002122 }
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002123 in_snd_device = platform_get_input_snd_device(adev->platform, out_device);
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07002124 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002125 }
2126 }
2127
2128 if (out_snd_device == usecase->out_snd_device &&
2129 in_snd_device == usecase->in_snd_device) {
Sidipotu Ashoke6f78cb2015-11-05 14:42:20 +05302130
2131 if (!force_device_switch(usecase))
2132 return 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002133 }
2134
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302135 if ((is_btsco_device(out_snd_device,in_snd_device) && !adev->bt_sco_on) ||
2136 (is_a2dp_device(out_snd_device) && !audio_extn_a2dp_is_ready())) {
2137 ALOGD("SCO/A2DP is selected but they are not connected/ready hence dont route");
2138 return 0;
2139 }
2140
sangwoobc677242013-08-08 16:53:43 +09002141 ALOGD("%s: out_snd_device(%d: %s) in_snd_device(%d: %s)", __func__,
Eric Laurentb23d5282013-05-14 15:27:20 -07002142 out_snd_device, platform_get_snd_device_name(out_snd_device),
2143 in_snd_device, platform_get_snd_device_name(in_snd_device));
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08002144
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002145 /*
2146 * Limitation: While in call, to do a device switch we need to disable
2147 * and enable both RX and TX devices though one of them is same as current
2148 * device.
2149 */
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -07002150 if ((usecase->type == VOICE_CALL) &&
2151 (usecase->in_snd_device != SND_DEVICE_NONE) &&
2152 (usecase->out_snd_device != SND_DEVICE_NONE)) {
Eric Laurentb23d5282013-05-14 15:27:20 -07002153 status = platform_switch_voice_call_device_pre(adev->platform);
Narsinga Rao Chella116142b2015-08-14 18:00:08 -07002154 }
2155
2156 if (((usecase->type == VOICE_CALL) ||
2157 (usecase->type == VOIP_CALL)) &&
2158 (usecase->out_snd_device != SND_DEVICE_NONE)) {
2159 /* Disable sidetone only if voice/voip call already exists */
2160 if (voice_is_call_state_active(adev) ||
2161 voice_extn_compress_voip_is_started(adev))
Bhalchandra Gajare45fee282015-06-09 22:23:45 -07002162 voice_set_sidetone(adev, usecase->out_snd_device, false);
Vidyakumar Athotaea269c62016-10-31 09:05:59 -07002163
2164 /* Disable aanc only if voice call exists */
2165 if (voice_is_call_state_active(adev))
2166 voice_check_and_update_aanc_path(adev, usecase->out_snd_device, false);
Ravi Kumar Alamanda610e8cc2013-02-12 01:42:38 -08002167 }
2168
Zhou Songc66eb7e2017-08-08 18:29:07 +08002169 if ((out_snd_device == SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP) &&
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05302170 (!audio_extn_a2dp_is_ready())) {
2171 ALOGW("%s: A2DP profile is not ready, routing to speaker only", __func__);
Zhou Songc66eb7e2017-08-08 18:29:07 +08002172 out_snd_device = SND_DEVICE_OUT_SPEAKER;
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05302173 }
2174
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002175 /* Disable current sound devices */
2176 if (usecase->out_snd_device != SND_DEVICE_NONE) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002177 disable_audio_route(adev, usecase);
2178 disable_snd_device(adev, usecase->out_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002179 }
2180
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002181 if (usecase->in_snd_device != SND_DEVICE_NONE) {
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002182 disable_audio_route(adev, usecase);
2183 disable_snd_device(adev, usecase->in_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002184 }
2185
Vidyakumar Athota545dbd32013-11-13 17:30:53 -08002186 /* Applicable only on the targets that has external modem.
2187 * New device information should be sent to modem before enabling
2188 * the devices to reduce in-call device switch time.
2189 */
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -07002190 if ((usecase->type == VOICE_CALL) &&
2191 (usecase->in_snd_device != SND_DEVICE_NONE) &&
2192 (usecase->out_snd_device != SND_DEVICE_NONE)) {
Vidyakumar Athota545dbd32013-11-13 17:30:53 -08002193 status = platform_switch_voice_call_enable_device_config(adev->platform,
2194 out_snd_device,
2195 in_snd_device);
Vidyakumar Athota21b3bb92014-04-25 11:08:08 -07002196 }
Vidyakumar Athota545dbd32013-11-13 17:30:53 -08002197
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002198 /* Enable new sound devices */
2199 if (out_snd_device != SND_DEVICE_NONE) {
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08002200 check_usecases_codec_backend(adev, usecase, out_snd_device);
Preetam Singh Ranawat43eac682017-03-07 18:19:02 +05302201 if (platform_check_codec_asrc_support(adev->platform))
2202 check_and_set_asrc_mode(adev, usecase, out_snd_device);
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002203 enable_snd_device(adev, out_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002204 }
2205
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07002206 if (in_snd_device != SND_DEVICE_NONE) {
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05302207 check_usecases_capture_codec_backend(adev, usecase, in_snd_device);
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002208 enable_snd_device(adev, in_snd_device);
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -07002209 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002210
Avinash Vaish71a8b972014-07-24 15:36:33 +05302211 if (usecase->type == VOICE_CALL || usecase->type == VOIP_CALL) {
Eric Laurentb23d5282013-05-14 15:27:20 -07002212 status = platform_switch_voice_call_device_post(adev->platform,
2213 out_snd_device,
2214 in_snd_device);
Avinash Vaish71a8b972014-07-24 15:36:33 +05302215 enable_audio_route_for_voice_usecases(adev, usecase);
2216 }
Ravi Kumar Alamanda610e8cc2013-02-12 01:42:38 -08002217
sangwoo170731f2013-06-08 15:36:36 +09002218 usecase->in_snd_device = in_snd_device;
2219 usecase->out_snd_device = out_snd_device;
2220
Dhananjay Kumard6d32152016-10-13 16:11:03 +05302221 audio_extn_utils_update_stream_app_type_cfg_for_usecase(adev,
2222 usecase);
Preetam Singh Ranawata4a37d82014-09-25 16:56:38 +05302223 if (usecase->type == PCM_PLAYBACK) {
Weiyin Jiang6f4c8062016-11-23 15:30:29 +08002224 if ((24 == usecase->stream.out->bit_width) &&
2225 (usecase->stream.out->devices & AUDIO_DEVICE_OUT_SPEAKER)) {
2226 usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
2227 } else if ((out_snd_device == SND_DEVICE_OUT_HDMI ||
2228 out_snd_device == SND_DEVICE_OUT_USB_HEADSET ||
2229 out_snd_device == SND_DEVICE_OUT_DISPLAY_PORT) &&
2230 (usecase->stream.out->sample_rate >= OUTPUT_SAMPLING_RATE_44100)) {
2231 /*
2232 * To best utlize DSP, check if the stream sample rate is supported/multiple of
2233 * configured device sample rate, if not update the COPP rate to be equal to the
2234 * device sample rate, else open COPP at stream sample rate
2235 */
2236 platform_check_and_update_copp_sample_rate(adev->platform, out_snd_device,
2237 usecase->stream.out->sample_rate,
2238 &usecase->stream.out->app_type_cfg.sample_rate);
Ashish Jain4826f6c2017-02-06 13:33:20 +05302239 } else if (((out_snd_device != SND_DEVICE_OUT_HEADPHONES_44_1 &&
2240 !audio_is_true_native_stream_active(adev)) &&
Weiyin Jiang6f4c8062016-11-23 15:30:29 +08002241 usecase->stream.out->sample_rate == OUTPUT_SAMPLING_RATE_44100) ||
2242 (usecase->stream.out->sample_rate < OUTPUT_SAMPLING_RATE_44100)) {
2243 usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
2244 }
2245
Weiyin Jiangaa80acd2016-09-21 16:42:11 +08002246 /* Notify device change info to effect clients registered */
Weiyin Jiang6f4c8062016-11-23 15:30:29 +08002247 pthread_mutex_unlock(&adev->lock);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +08002248 audio_extn_gef_notify_device_config(
2249 usecase->stream.out->devices,
2250 usecase->stream.out->channel_mask,
Weiyin Jiang6f4c8062016-11-23 15:30:29 +08002251 usecase->stream.out->app_type_cfg.sample_rate,
Weiyin Jiangaa80acd2016-09-21 16:42:11 +08002252 platform_get_snd_device_acdb_id(usecase->out_snd_device));
Weiyin Jiang6f4c8062016-11-23 15:30:29 +08002253 pthread_mutex_lock(&adev->lock);
Preetam Singh Ranawata4a37d82014-09-25 16:56:38 +05302254 }
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002255 enable_audio_route(adev, usecase);
sangwoo170731f2013-06-08 15:36:36 +09002256
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07002257 /* If input stream is already running then effect needs to be
2258 applied on the new input device that's being enabled here. */
2259 if ((in_snd_device != SND_DEVICE_NONE) && (!adev->active_input->standby))
2260 check_and_enable_effect(adev);
2261
Vidyakumar Athota493f2892016-08-14 11:56:55 -07002262 if (usecase->type == VOICE_CALL || usecase->type == VOIP_CALL) {
Vidyakumar Athotaea269c62016-10-31 09:05:59 -07002263 /* Enable aanc only if voice call exists */
2264 if (voice_is_call_state_active(adev))
2265 voice_check_and_update_aanc_path(adev, out_snd_device, true);
2266
Vidyakumar Athota493f2892016-08-14 11:56:55 -07002267 /* Enable sidetone only if other voice/voip call already exists */
2268 if (voice_is_call_state_active(adev) ||
2269 voice_extn_compress_voip_is_started(adev))
2270 voice_set_sidetone(adev, out_snd_device, true);
2271 }
2272
Vidyakumar Athota1fd21792013-11-15 14:50:57 -08002273 /* Applicable only on the targets that has external modem.
2274 * Enable device command should be sent to modem only after
2275 * enabling voice call mixer controls
2276 */
Vidyakumar Athota339342f2014-07-01 15:30:57 -07002277 if (usecase->type == VOICE_CALL)
Vidyakumar Athota1fd21792013-11-15 14:50:57 -08002278 status = platform_switch_voice_call_usecase_route_post(adev->platform,
2279 out_snd_device,
2280 in_snd_device);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302281
2282 if (is_btsco_device(out_snd_device, in_snd_device) || is_a2dp_device(out_snd_device)) {
2283
2284 if (usecase->type == VOIP_CALL) {
2285 if (adev->active_input != NULL &&
2286 !adev->active_input->standby) {
2287 if (is_bt_soc_on(adev) == false){
2288 ALOGD("BT SCO MIC disconnected while in connection");
2289 if (adev->active_input->pcm != NULL)
2290 pcm_stop(adev->active_input->pcm);
2291 }
2292 }
2293 if ((usecase->stream.out != NULL) && (usecase->stream.out != adev->primary_output)
2294 && usecase->stream.out->started) {
2295 if (is_bt_soc_on(adev) == false) {
2296 ALOGD("BT SCO/A2DP disconnected while in connection");
2297 out_standby_l(&usecase->stream.out->stream.common);
2298 }
2299 }
2300 } else if ((usecase->stream.out != NULL) &&
2301 !(usecase->stream.out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
2302 usecase->stream.out->started) {
2303 if (is_bt_soc_on(adev) == false) {
2304 ALOGD("BT SCO/A2dp disconnected while in connection");
2305 out_standby_l(&usecase->stream.out->stream.common);
2306 }
2307 }
2308 }
2309
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05302310 ALOGD("%s: done",__func__);
2311
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002312 return status;
2313}
2314
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002315static int stop_input_stream(struct stream_in *in)
2316{
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05302317 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002318 struct audio_usecase *uc_info;
2319 struct audio_device *adev = in->dev;
2320
Eric Laurent994a6932013-07-17 11:51:42 -07002321 ALOGV("%s: enter: usecase(%d: %s)", __func__,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002322 in->usecase, use_case_table[in->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002323 uc_info = get_usecase_from_list(adev, in->usecase);
2324 if (uc_info == NULL) {
2325 ALOGE("%s: Could not find the usecase (%d) in the list",
2326 __func__, in->usecase);
2327 return -EINVAL;
2328 }
2329
Vidyakumar Athota2850d532013-11-19 16:02:12 -08002330 /* Close in-call recording streams */
2331 voice_check_and_stop_incall_rec_usecase(adev, in);
2332
Eric Laurent150dbfe2013-02-27 14:31:02 -08002333 /* 1. Disable stream specific mixer controls */
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002334 disable_audio_route(adev, uc_info);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002335
2336 /* 2. Disable the tx device */
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002337 disable_snd_device(adev, uc_info->in_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002338
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08002339 list_remove(&uc_info->list);
2340 free(uc_info);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002341
Aalique Grahame2e9b2e42016-12-07 12:43:48 -08002342 adev->active_input = get_next_active_input(adev);
2343
Eric Laurent994a6932013-07-17 11:51:42 -07002344 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002345 return ret;
2346}
2347
2348int start_input_stream(struct stream_in *in)
2349{
2350 /* 1. Enable output device and stream routing controls */
Eric Laurentc8400632013-02-14 19:04:54 -08002351 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002352 struct audio_usecase *uc_info;
2353 struct audio_device *adev = in->dev;
Garmond Leunge2433c32017-09-28 21:51:22 -07002354 struct pcm_config config = in->config;
Garmond Leung438932f2017-10-04 19:35:18 -07002355 int usecase = platform_update_usecase_from_source(in->source,in->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002356
Mingming Yin2664a5b2015-09-03 10:53:11 -07002357 if (get_usecase_from_list(adev, usecase) == NULL)
2358 in->usecase = usecase;
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05302359 ALOGD("%s: enter: stream(%p)usecase(%d: %s)",
2360 __func__, &in->stream, in->usecase, use_case_table[in->usecase]);
Shiv Maliyappanahallida107642013-10-17 11:16:13 -07002361
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05302362 if (CARD_STATUS_OFFLINE == in->card_status||
2363 CARD_STATUS_OFFLINE == adev->card_status) {
2364 ALOGW("in->card_status or adev->card_status offline, try again");
Dhanalakshmi Siddani4d57e992014-07-17 16:37:51 +05302365 ret = -EIO;
Naresh Tanniru4c630392014-05-12 01:05:52 +05302366 goto error_config;
2367 }
Naresh Tanniru4c630392014-05-12 01:05:52 +05302368
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302369 if (audio_is_bluetooth_sco_device(in->device)) {
2370 if (!adev->bt_sco_on) {
2371 ALOGE("%s: SCO profile is not ready, return error", __func__);
2372 ret = -EIO;
2373 goto error_config;
2374 }
2375 }
2376
Shiv Maliyappanahallida107642013-10-17 11:16:13 -07002377 /* Check if source matches incall recording usecase criteria */
2378 ret = voice_check_and_set_incall_rec_usecase(adev, in);
2379 if (ret)
2380 goto error_config;
2381 else
Mingming Yin2664a5b2015-09-03 10:53:11 -07002382 ALOGV("%s: usecase(%d)", __func__, in->usecase);
2383
2384 if (get_usecase_from_list(adev, in->usecase) != NULL) {
2385 ALOGE("%s: use case assigned already in use, stream(%p)usecase(%d: %s)",
2386 __func__, &in->stream, in->usecase, use_case_table[in->usecase]);
Zhou Song4e0704d2016-04-20 13:00:14 +08002387 return -EINVAL;
Mingming Yin2664a5b2015-09-03 10:53:11 -07002388 }
Shiv Maliyappanahallida107642013-10-17 11:16:13 -07002389
Eric Laurentb23d5282013-05-14 15:27:20 -07002390 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002391 if (in->pcm_device_id < 0) {
2392 ALOGE("%s: Could not find PCM device id for the usecase(%d)",
2393 __func__, in->usecase);
Eric Laurentc8400632013-02-14 19:04:54 -08002394 ret = -EINVAL;
2395 goto error_config;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002396 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002397
2398 adev->active_input = in;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002399 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07002400
2401 if (!uc_info) {
2402 ret = -ENOMEM;
2403 goto error_config;
2404 }
2405
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002406 uc_info->id = in->usecase;
2407 uc_info->type = PCM_CAPTURE;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08002408 uc_info->stream.in = in;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002409 uc_info->devices = in->device;
2410 uc_info->in_snd_device = SND_DEVICE_NONE;
2411 uc_info->out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002412
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08002413 list_add_tail(&adev->usecase_list, &uc_info->list);
Sudheer Papothifa9d2282015-09-17 01:53:25 +05302414 audio_extn_perf_lock_acquire(&adev->perf_lock_handle, 0,
2415 adev->perf_lock_opts,
2416 adev->perf_lock_opts_size);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002417 select_devices(adev, in->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002418
Haynes Mathew George16081042017-05-31 17:16:49 -07002419 if (audio_extn_cin_attached_usecase(in->usecase)) {
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05302420 ret = audio_extn_cin_start_input_stream(in);
2421 if (ret)
2422 goto error_open;
2423 else
2424 goto done_open;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002425 }
2426
Haynes Mathew George16081042017-05-31 17:16:49 -07002427 if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002428 if (in->pcm == NULL || !pcm_is_ready(in->pcm)) {
Haynes Mathew George16081042017-05-31 17:16:49 -07002429 ALOGE("%s: pcm stream not ready", __func__);
2430 goto error_open;
2431 }
2432 ret = pcm_start(in->pcm);
2433 if (ret < 0) {
2434 ALOGE("%s: MMAP pcm_start failed ret %d", __func__, ret);
2435 goto error_open;
2436 }
2437 } else {
2438 unsigned int flags = PCM_IN | PCM_MONOTONIC;
2439 unsigned int pcm_open_retry_count = 0;
2440
2441 if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY) {
2442 flags |= PCM_MMAP | PCM_NOIRQ;
2443 pcm_open_retry_count = PROXY_OPEN_RETRY_COUNT;
2444 } else if (in->realtime) {
2445 flags |= PCM_MMAP | PCM_NOIRQ;
2446 }
2447
Garmond Leunge2433c32017-09-28 21:51:22 -07002448 if (audio_extn_ffv_get_stream() == in) {
2449 ALOGD("%s: ffv stream, update pcm config", __func__);
2450 audio_extn_ffv_update_pcm_config(&config);
2451 }
Haynes Mathew George16081042017-05-31 17:16:49 -07002452 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
2453 __func__, adev->snd_card, in->pcm_device_id, in->config.channels);
2454
2455 while (1) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07002456 ATRACE_BEGIN("pcm_in_open");
Haynes Mathew George16081042017-05-31 17:16:49 -07002457 in->pcm = pcm_open(adev->snd_card, in->pcm_device_id,
Garmond Leung438932f2017-10-04 19:35:18 -07002458 flags, &config);
Haynes Mathew George380745d2017-10-04 15:27:45 -07002459 ATRACE_END();
Haynes Mathew George16081042017-05-31 17:16:49 -07002460 if (in->pcm == NULL || !pcm_is_ready(in->pcm)) {
2461 ALOGE("%s: %s", __func__, pcm_get_error(in->pcm));
2462 if (in->pcm != NULL) {
2463 pcm_close(in->pcm);
2464 in->pcm = NULL;
2465 }
2466 if (pcm_open_retry_count-- == 0) {
2467 ret = -EIO;
2468 goto error_open;
2469 }
2470 usleep(PROXY_OPEN_WAIT_TIME * 1000);
2471 continue;
2472 }
2473 break;
2474 }
2475
2476 ALOGV("%s: pcm_prepare", __func__);
Haynes Mathew George380745d2017-10-04 15:27:45 -07002477 ATRACE_BEGIN("pcm_in_prepare");
Haynes Mathew George16081042017-05-31 17:16:49 -07002478 ret = pcm_prepare(in->pcm);
Haynes Mathew George380745d2017-10-04 15:27:45 -07002479 ATRACE_END();
Haynes Mathew George16081042017-05-31 17:16:49 -07002480 if (ret < 0) {
2481 ALOGE("%s: pcm_prepare returned %d", __func__, ret);
2482 pcm_close(in->pcm);
2483 in->pcm = NULL;
2484 goto error_open;
2485 }
2486 register_in_stream(in);
2487 if (in->realtime) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07002488 ATRACE_BEGIN("pcm_in_start");
Haynes Mathew George16081042017-05-31 17:16:49 -07002489 ret = pcm_start(in->pcm);
Haynes Mathew George380745d2017-10-04 15:27:45 -07002490 ATRACE_END();
Haynes Mathew George16081042017-05-31 17:16:49 -07002491 if (ret < 0) {
2492 ALOGE("%s: RT pcm_start failed ret %d", __func__, ret);
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002493 pcm_close(in->pcm);
2494 in->pcm = NULL;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002495 goto error_open;
2496 }
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002497 }
Haynes Mathew George5beddd42016-06-27 18:33:40 -07002498 }
2499
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07002500 check_and_enable_effect(adev);
2501
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05302502done_open:
Sudheer Papothifa9d2282015-09-17 01:53:25 +05302503 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07002504 ALOGD("%s: exit", __func__);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07002505
Eric Laurentc8400632013-02-14 19:04:54 -08002506 return ret;
2507
2508error_open:
Sudheer Papothifa9d2282015-09-17 01:53:25 +05302509 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002510 stop_input_stream(in);
Eric Laurentc8400632013-02-14 19:04:54 -08002511error_config:
Dhananjay Kumard4833242016-10-06 22:09:12 +05302512 adev->active_input = get_next_active_input(adev);
Laxminath Kasam2cb4b752015-09-24 03:59:15 +05302513 /*
2514 * sleep 50ms to allow sufficient time for kernel
2515 * drivers to recover incases like SSR.
2516 */
2517 usleep(50000);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002518 ALOGD("%s: exit: status(%d)", __func__, ret);
Eric Laurentc8400632013-02-14 19:04:54 -08002519
2520 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002521}
2522
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07002523void lock_input_stream(struct stream_in *in)
2524{
2525 pthread_mutex_lock(&in->pre_lock);
2526 pthread_mutex_lock(&in->lock);
2527 pthread_mutex_unlock(&in->pre_lock);
2528}
2529
2530void lock_output_stream(struct stream_out *out)
2531{
2532 pthread_mutex_lock(&out->pre_lock);
2533 pthread_mutex_lock(&out->lock);
2534 pthread_mutex_unlock(&out->pre_lock);
2535}
2536
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002537/* must be called with out->lock locked */
2538static int send_offload_cmd_l(struct stream_out* out, int command)
2539{
2540 struct offload_cmd *cmd = (struct offload_cmd *)calloc(1, sizeof(struct offload_cmd));
2541
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07002542 if (!cmd) {
2543 ALOGE("failed to allocate mem for command 0x%x", command);
2544 return -ENOMEM;
2545 }
2546
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002547 ALOGVV("%s %d", __func__, command);
2548
2549 cmd->cmd = command;
2550 list_add_tail(&out->offload_cmd_list, &cmd->node);
2551 pthread_cond_signal(&out->offload_cond);
2552 return 0;
2553}
2554
2555/* must be called iwth out->lock locked */
2556static void stop_compressed_output_l(struct stream_out *out)
2557{
2558 out->offload_state = OFFLOAD_STATE_IDLE;
2559 out->playback_started = 0;
Haynes Mathew George352f27b2013-07-26 00:00:15 -07002560 out->send_new_metadata = 1;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002561 if (out->compr != NULL) {
2562 compress_stop(out->compr);
2563 while (out->offload_thread_blocked) {
2564 pthread_cond_wait(&out->cond, &out->lock);
2565 }
2566 }
2567}
2568
Varun Balaraje49253e2017-07-06 19:48:56 +05302569bool is_interactive_usecase(audio_usecase_t uc_id)
2570{
2571 unsigned int i;
2572 for (i = 0; i < sizeof(interactive_usecases)/sizeof(interactive_usecases[0]); i++) {
2573 if (uc_id == interactive_usecases[i])
2574 return true;
2575 }
2576 return false;
2577}
2578
2579static audio_usecase_t get_interactive_usecase(struct audio_device *adev)
2580{
2581 audio_usecase_t ret_uc = USECASE_INVALID;
2582 unsigned int intract_uc_index;
2583 unsigned int num_usecase = sizeof(interactive_usecases)/sizeof(interactive_usecases[0]);
2584
2585 ALOGV("%s: num_usecase: %d", __func__, num_usecase);
2586 for (intract_uc_index = 0; intract_uc_index < num_usecase; intract_uc_index++) {
2587 if (!(adev->interactive_usecase_state & (0x1 << intract_uc_index))) {
2588 adev->interactive_usecase_state |= 0x1 << intract_uc_index;
2589 ret_uc = interactive_usecases[intract_uc_index];
2590 break;
2591 }
2592 }
2593
2594 ALOGV("%s: Interactive usecase is %d", __func__, ret_uc);
2595 return ret_uc;
2596}
2597
2598static void free_interactive_usecase(struct audio_device *adev,
2599 audio_usecase_t uc_id)
2600{
2601 unsigned int interact_uc_index;
2602 unsigned int num_usecase = sizeof(interactive_usecases)/sizeof(interactive_usecases[0]);
2603
2604 for (interact_uc_index = 0; interact_uc_index < num_usecase; interact_uc_index++) {
2605 if (interactive_usecases[interact_uc_index] == uc_id) {
2606 adev->interactive_usecase_state &= ~(0x1 << interact_uc_index);
2607 break;
2608 }
2609 }
2610 ALOGV("%s: free Interactive usecase %d", __func__, uc_id);
2611}
2612
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07002613bool is_offload_usecase(audio_usecase_t uc_id)
2614{
2615 unsigned int i;
2616 for (i = 0; i < sizeof(offload_usecases)/sizeof(offload_usecases[0]); i++) {
2617 if (uc_id == offload_usecases[i])
2618 return true;
2619 }
2620 return false;
2621}
2622
Dhananjay Kumarac341582017-02-23 23:42:25 +05302623static audio_usecase_t get_offload_usecase(struct audio_device *adev, bool is_compress)
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07002624{
vivek mehta446c3962015-09-14 10:57:35 -07002625 audio_usecase_t ret_uc = USECASE_INVALID;
2626 unsigned int offload_uc_index;
Alexy Josephb1379942016-01-29 15:49:38 -08002627 unsigned int num_usecase = sizeof(offload_usecases)/sizeof(offload_usecases[0]);
vivek mehta446c3962015-09-14 10:57:35 -07002628 if (!adev->multi_offload_enable) {
Dhananjay Kumarac341582017-02-23 23:42:25 +05302629 if (!is_compress)
vivek mehta446c3962015-09-14 10:57:35 -07002630 ret_uc = USECASE_AUDIO_PLAYBACK_OFFLOAD2;
2631 else
2632 ret_uc = USECASE_AUDIO_PLAYBACK_OFFLOAD;
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07002633
vivek mehta446c3962015-09-14 10:57:35 -07002634 pthread_mutex_lock(&adev->lock);
2635 if (get_usecase_from_list(adev, ret_uc) != NULL)
2636 ret_uc = USECASE_INVALID;
2637 pthread_mutex_unlock(&adev->lock);
2638
2639 return ret_uc;
2640 }
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07002641
2642 ALOGV("%s: num_usecase: %d", __func__, num_usecase);
vivek mehta446c3962015-09-14 10:57:35 -07002643 for (offload_uc_index = 0; offload_uc_index < num_usecase; offload_uc_index++) {
2644 if (!(adev->offload_usecases_state & (0x1 << offload_uc_index))) {
2645 adev->offload_usecases_state |= 0x1 << offload_uc_index;
2646 ret_uc = offload_usecases[offload_uc_index];
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07002647 break;
2648 }
2649 }
vivek mehta446c3962015-09-14 10:57:35 -07002650
2651 ALOGV("%s: offload usecase is %d", __func__, ret_uc);
2652 return ret_uc;
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07002653}
2654
2655static void free_offload_usecase(struct audio_device *adev,
2656 audio_usecase_t uc_id)
2657{
vivek mehta446c3962015-09-14 10:57:35 -07002658 unsigned int offload_uc_index;
Alexy Josephb1379942016-01-29 15:49:38 -08002659 unsigned int num_usecase = sizeof(offload_usecases)/sizeof(offload_usecases[0]);
vivek mehta446c3962015-09-14 10:57:35 -07002660
2661 if (!adev->multi_offload_enable)
2662 return;
2663
2664 for (offload_uc_index = 0; offload_uc_index < num_usecase; offload_uc_index++) {
2665 if (offload_usecases[offload_uc_index] == uc_id) {
2666 adev->offload_usecases_state &= ~(0x1 << offload_uc_index);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07002667 break;
2668 }
2669 }
2670 ALOGV("%s: free offload usecase %d", __func__, uc_id);
2671}
2672
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002673static void *offload_thread_loop(void *context)
2674{
2675 struct stream_out *out = (struct stream_out *) context;
2676 struct listnode *item;
Krishnankutty Kolathappillyd4f1d132014-01-06 18:33:58 -08002677 int ret = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002678
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002679 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
2680 set_sched_policy(0, SP_FOREGROUND);
2681 prctl(PR_SET_NAME, (unsigned long)"Offload Callback", 0, 0, 0);
2682
2683 ALOGV("%s", __func__);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07002684 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002685 for (;;) {
2686 struct offload_cmd *cmd = NULL;
2687 stream_callback_event_t event;
2688 bool send_callback = false;
2689
2690 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
2691 __func__, list_empty(&out->offload_cmd_list),
2692 out->offload_state);
2693 if (list_empty(&out->offload_cmd_list)) {
2694 ALOGV("%s SLEEPING", __func__);
2695 pthread_cond_wait(&out->offload_cond, &out->lock);
2696 ALOGV("%s RUNNING", __func__);
2697 continue;
2698 }
2699
2700 item = list_head(&out->offload_cmd_list);
2701 cmd = node_to_item(item, struct offload_cmd, node);
2702 list_remove(item);
2703
2704 ALOGVV("%s STATE %d CMD %d out->compr %p",
2705 __func__, out->offload_state, cmd->cmd, out->compr);
2706
2707 if (cmd->cmd == OFFLOAD_CMD_EXIT) {
2708 free(cmd);
2709 break;
2710 }
2711
2712 if (out->compr == NULL) {
2713 ALOGE("%s: Compress handle is NULL", __func__);
Haynes Mathew Georgea9abb202016-06-02 14:13:20 -07002714 free(cmd);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002715 pthread_cond_signal(&out->cond);
2716 continue;
2717 }
2718 out->offload_thread_blocked = true;
2719 pthread_mutex_unlock(&out->lock);
2720 send_callback = false;
2721 switch(cmd->cmd) {
2722 case OFFLOAD_CMD_WAIT_FOR_BUFFER:
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07002723 ALOGD("copl(%p):calling compress_wait", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002724 compress_wait(out->compr, -1);
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07002725 ALOGD("copl(%p):out of compress_wait", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002726 send_callback = true;
2727 event = STREAM_CBK_EVENT_WRITE_READY;
2728 break;
2729 case OFFLOAD_CMD_PARTIAL_DRAIN:
Krishnankutty Kolathappillyd4f1d132014-01-06 18:33:58 -08002730 ret = compress_next_track(out->compr);
Sidipotu Ashok55820562014-02-10 16:16:38 +05302731 if(ret == 0) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07002732 ALOGD("copl(%p):calling compress_partial_drain", out);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05302733 ret = compress_partial_drain(out->compr);
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07002734 ALOGD("copl(%p):out of compress_partial_drain", out);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05302735 if (ret < 0)
2736 ret = -errno;
Sidipotu Ashok55820562014-02-10 16:16:38 +05302737 }
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05302738 else if (ret == -ETIMEDOUT)
Krishnankutty Kolathappillyd4f1d132014-01-06 18:33:58 -08002739 compress_drain(out->compr);
2740 else
2741 ALOGE("%s: Next track returned error %d",__func__, ret);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05302742 if (ret != -ENETRESET) {
2743 send_callback = true;
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05302744 pthread_mutex_lock(&out->lock);
2745 out->send_new_metadata = 1;
2746 out->send_next_track_params = true;
2747 pthread_mutex_unlock(&out->lock);
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05302748 event = STREAM_CBK_EVENT_DRAIN_READY;
2749 ALOGV("copl(%p):send drain callback, ret %d", out, ret);
2750 } else
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05302751 ALOGI("%s: Block drain ready event during SSR", __func__);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002752 break;
2753 case OFFLOAD_CMD_DRAIN:
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07002754 ALOGD("copl(%p):calling compress_drain", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002755 compress_drain(out->compr);
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07002756 ALOGD("copl(%p):calling compress_drain", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002757 send_callback = true;
2758 event = STREAM_CBK_EVENT_DRAIN_READY;
2759 break;
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05302760 case OFFLOAD_CMD_ERROR:
2761 ALOGD("copl(%p): sending error callback to AF", out);
2762 send_callback = true;
2763 event = STREAM_CBK_EVENT_ERROR;
2764 break;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002765 default:
2766 ALOGE("%s unknown command received: %d", __func__, cmd->cmd);
2767 break;
2768 }
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07002769 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002770 out->offload_thread_blocked = false;
2771 pthread_cond_signal(&out->cond);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08002772 if (send_callback && out->client_callback) {
2773 ALOGVV("%s: sending client_callback event %d", __func__, event);
2774 out->client_callback(event, NULL, out->client_cookie);
Eric Laurent6e895242013-09-05 16:10:57 -07002775 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002776 free(cmd);
2777 }
2778
2779 pthread_cond_signal(&out->cond);
2780 while (!list_empty(&out->offload_cmd_list)) {
2781 item = list_head(&out->offload_cmd_list);
2782 list_remove(item);
2783 free(node_to_item(item, struct offload_cmd, node));
2784 }
2785 pthread_mutex_unlock(&out->lock);
2786
2787 return NULL;
2788}
2789
2790static int create_offload_callback_thread(struct stream_out *out)
2791{
2792 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
2793 list_init(&out->offload_cmd_list);
2794 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
2795 offload_thread_loop, out);
2796 return 0;
2797}
2798
2799static int destroy_offload_callback_thread(struct stream_out *out)
2800{
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07002801 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07002802 stop_compressed_output_l(out);
2803 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
2804
2805 pthread_mutex_unlock(&out->lock);
2806 pthread_join(out->offload_thread, (void **) NULL);
2807 pthread_cond_destroy(&out->offload_cond);
2808
2809 return 0;
2810}
2811
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002812static int stop_output_stream(struct stream_out *out)
2813{
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05302814 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002815 struct audio_usecase *uc_info;
2816 struct audio_device *adev = out->dev;
2817
Eric Laurent994a6932013-07-17 11:51:42 -07002818 ALOGV("%s: enter: usecase(%d: %s)", __func__,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002819 out->usecase, use_case_table[out->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002820 uc_info = get_usecase_from_list(adev, out->usecase);
2821 if (uc_info == NULL) {
2822 ALOGE("%s: Could not find the usecase (%d) in the list",
2823 __func__, out->usecase);
2824 return -EINVAL;
2825 }
2826
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07002827 if (is_offload_usecase(out->usecase) &&
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05302828 !(audio_extn_passthru_is_passthrough_stream(out))) {
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08002829 if (adev->visualizer_stop_output != NULL)
2830 adev->visualizer_stop_output(out->handle, out->pcm_device_id);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08002831
2832 audio_extn_dts_remove_state_notifier_node(out->usecase);
2833
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08002834 if (adev->offload_effects_stop_output != NULL)
2835 adev->offload_effects_stop_output(out->handle, out->pcm_device_id);
2836 }
Eric Laurentc4aef752013-09-12 17:45:53 -07002837
Eric Laurent150dbfe2013-02-27 14:31:02 -08002838 /* 1. Get and set stream specific mixer controls */
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002839 disable_audio_route(adev, uc_info);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002840
2841 /* 2. Disable the rx device */
Haynes Mathew George1376ca62014-04-24 11:55:48 -07002842 disable_snd_device(adev, uc_info->out_snd_device);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002843
Xiaojun Sang785b5da2017-08-03 15:52:29 +08002844 if (is_offload_usecase(out->usecase)) {
2845 audio_enable_asm_bit_width_enforce_mode(adev->mixer,
2846 adev->dsp_bit_width_enforce_mode,
2847 false);
2848 }
2849
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08002850 list_remove(&uc_info->list);
2851 free(uc_info);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302852 out->started = 0;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07002853 if (is_offload_usecase(out->usecase) &&
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05302854 (audio_extn_passthru_is_passthrough_stream(out))) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07002855 ALOGV("Disable passthrough , reset mixer to pcm");
2856 /* NO_PASSTHROUGH */
2857 out->compr_config.codec->compr_passthr = 0;
Mingming Yin21854652016-04-13 11:54:02 -07002858 audio_extn_passthru_on_stop(out);
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07002859 audio_extn_dolby_set_dap_bypass(adev, DAP_STATE_ON);
2860 }
Eric Laurent07eeafd2013-10-06 12:52:49 -07002861
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05302862 /* Must be called after removing the usecase from list */
2863 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
Ashish Jaind84fd6a2016-07-27 12:33:25 +05302864 audio_extn_keep_alive_start();
2865
Manish Dewangan21a850a2017-08-14 12:03:55 +05302866 if (out->ip_hdlr_handle) {
Naresh Tanniru85819452017-05-04 18:55:45 -07002867 ret = audio_extn_ip_hdlr_intf_close(out->ip_hdlr_handle, true, out);
2868 if (ret < 0)
2869 ALOGE("%s: audio_extn_ip_hdlr_intf_close failed %d",__func__, ret);
2870 }
2871
Eric Laurent994a6932013-07-17 11:51:42 -07002872 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002873 return ret;
2874}
2875
2876int start_output_stream(struct stream_out *out)
2877{
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002878 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002879 struct audio_usecase *uc_info;
2880 struct audio_device *adev = out->dev;
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08002881 char mixer_ctl_name[128];
2882 struct mixer_ctl *ctl = NULL;
2883 char* perf_mode[] = {"ULL", "ULL_PP", "LL"};
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05302884 bool a2dp_combo = false;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002885
Haynes Mathew George380745d2017-10-04 15:27:45 -07002886 ATRACE_BEGIN("start_output_stream");
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07002887 if ((out->usecase < 0) || (out->usecase >= AUDIO_USECASE_MAX)) {
2888 ret = -EINVAL;
2889 goto error_config;
2890 }
2891
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05302892 ALOGD("%s: enter: stream(%p)usecase(%d: %s) devices(%#x)",
2893 __func__, &out->stream, out->usecase, use_case_table[out->usecase],
2894 out->devices);
Naresh Tanniru4c630392014-05-12 01:05:52 +05302895
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05302896 if (CARD_STATUS_OFFLINE == out->card_status ||
2897 CARD_STATUS_OFFLINE == adev->card_status) {
2898 ALOGW("out->card_status or adev->card_status offline, try again");
Dhanalakshmi Siddani4d57e992014-07-17 16:37:51 +05302899 ret = -EIO;
Naresh Tanniru4c630392014-05-12 01:05:52 +05302900 goto error_config;
2901 }
Naresh Tanniru4c630392014-05-12 01:05:52 +05302902
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05302903 if (out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
2904 if (!audio_extn_a2dp_is_ready()) {
2905 if (out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05302906 a2dp_combo = true;
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05302907 } else {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05302908 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
2909 ALOGE("%s: A2DP profile is not ready, return error", __func__);
2910 ret = -EAGAIN;
2911 goto error_config;
2912 }
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05302913 }
2914 }
2915 }
Ashish Jain1b9b30c2017-05-18 20:57:40 +05302916 if (out->devices & AUDIO_DEVICE_OUT_ALL_SCO) {
2917 if (!adev->bt_sco_on) {
2918 if (out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
2919 //combo usecase just by pass a2dp
2920 ALOGW("%s: SCO is not connected, route it to speaker", __func__);
2921 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
2922 } else {
2923 ALOGE("%s: SCO profile is not ready, return error", __func__);
2924 ret = -EAGAIN;
2925 goto error_config;
2926 }
2927 }
2928 }
2929
Eric Laurentb23d5282013-05-14 15:27:20 -07002930 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002931 if (out->pcm_device_id < 0) {
2932 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
2933 __func__, out->pcm_device_id, out->usecase);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08002934 ret = -EINVAL;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07002935 goto error_open;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002936 }
2937
2938 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07002939
2940 if (!uc_info) {
2941 ret = -ENOMEM;
2942 goto error_config;
2943 }
2944
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002945 uc_info->id = out->usecase;
2946 uc_info->type = PCM_PLAYBACK;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08002947 uc_info->stream.out = out;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002948 uc_info->devices = out->devices;
2949 uc_info->in_snd_device = SND_DEVICE_NONE;
2950 uc_info->out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08002951 list_add_tail(&adev->usecase_list, &uc_info->list);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002952
Sudheer Papothifa9d2282015-09-17 01:53:25 +05302953 audio_extn_perf_lock_acquire(&adev->perf_lock_handle, 0,
2954 adev->perf_lock_opts,
2955 adev->perf_lock_opts_size);
Ashish Jaind84fd6a2016-07-27 12:33:25 +05302956
2957 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
2958 audio_extn_keep_alive_stop();
2959 if (audio_extn_passthru_is_enabled() &&
2960 audio_extn_passthru_is_passthrough_stream(out)) {
2961 audio_extn_passthru_on_start(out);
Ashish Jaind84fd6a2016-07-27 12:33:25 +05302962 }
2963 }
2964
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05302965 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
2966 (!audio_extn_a2dp_is_ready())) {
2967 if (!a2dp_combo) {
2968 check_a2dp_restore_l(adev, out, false);
2969 } else {
2970 audio_devices_t dev = out->devices;
2971 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
2972 select_devices(adev, out->usecase);
2973 out->devices = dev;
2974 }
2975 } else {
2976 select_devices(adev, out->usecase);
2977 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002978
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002979 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d) format(%#x)",
2980 __func__, adev->snd_card, out->pcm_device_id, out->config.format);
Haynes Mathew George16081042017-05-31 17:16:49 -07002981
2982 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2983 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
2984 ALOGE("%s: pcm stream not ready", __func__);
2985 goto error_open;
2986 }
2987 ret = pcm_start(out->pcm);
2988 if (ret < 0) {
2989 ALOGE("%s: MMAP pcm_start failed ret %d", __func__, ret);
2990 goto error_open;
2991 }
2992 } else if (!is_offload_usecase(out->usecase)) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07002993 unsigned int flags = PCM_OUT;
2994 unsigned int pcm_open_retry_count = 0;
2995 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
2996 flags |= PCM_MMAP | PCM_NOIRQ;
2997 pcm_open_retry_count = PROXY_OPEN_RETRY_COUNT;
Haynes Mathew George5beddd42016-06-27 18:33:40 -07002998 } else if (out->realtime) {
2999 flags |= PCM_MMAP | PCM_NOIRQ;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003000 } else
3001 flags |= PCM_MONOTONIC;
3002
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08003003 if ((adev->vr_audio_mode_enabled) &&
3004 (out->flags & AUDIO_OUTPUT_FLAG_RAW)) {
3005 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
3006 "PCM_Dev %d Topology", out->pcm_device_id);
3007 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
3008 if (!ctl) {
3009 ALOGI("%s: Could not get ctl for mixer cmd might be ULL - %s",
3010 __func__, mixer_ctl_name);
3011 } else {
3012 //if success use ULLPP
3013 ALOGI("%s: mixer ctrl %s succeeded setting up ULL for %d",
3014 __func__, mixer_ctl_name, out->pcm_device_id);
3015 //There is a still a possibility that some sessions
3016 // that request for FAST|RAW when 3D audio is active
3017 //can go through ULLPP. Ideally we expects apps to
3018 //listen to audio focus and stop concurrent playback
3019 //Also, we will look for mode flag (voice_in_communication)
3020 //before enabling the realtime flag.
3021 mixer_ctl_set_enum_by_string(ctl, perf_mode[1]);
3022 }
3023 }
3024
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003025 while (1) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07003026 ATRACE_BEGIN("pcm_open");
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003027 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
3028 flags, &out->config);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003029 ATRACE_END();
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003030 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
3031 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
3032 if (out->pcm != NULL) {
3033 pcm_close(out->pcm);
3034 out->pcm = NULL;
3035 }
3036 if (pcm_open_retry_count-- == 0) {
3037 ret = -EIO;
3038 goto error_open;
3039 }
3040 usleep(PROXY_OPEN_WAIT_TIME * 1000);
3041 continue;
3042 }
3043 break;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003044 }
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07003045
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07003046 ALOGV("%s: pcm_prepare", __func__);
3047 if (pcm_is_ready(out->pcm)) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07003048 ATRACE_BEGIN("pcm_prepare");
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07003049 ret = pcm_prepare(out->pcm);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003050 ATRACE_END();
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07003051 if (ret < 0) {
3052 ALOGE("%s: pcm_prepare returned %d", __func__, ret);
3053 pcm_close(out->pcm);
3054 out->pcm = NULL;
3055 goto error_open;
3056 }
3057 }
Divya Narayanan Poojary2c429012017-04-20 16:37:20 +05303058 platform_set_stream_channel_map(adev->platform, out->channel_mask,
Naresh Tanniru29bce4e2017-04-27 17:54:30 +05303059 out->pcm_device_id, &out->channel_map_param.channel_map[0]);
Zhou Song2b8f28f2017-09-11 10:51:38 +08003060 // apply volume for voip playback after path is set up
3061 if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP)
3062 out_set_voip_volume(&out->stream, out->volume_l, out->volume_r);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003063 } else {
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07003064 platform_set_stream_channel_map(adev->platform, out->channel_mask,
Naresh Tanniru29bce4e2017-04-27 17:54:30 +05303065 out->pcm_device_id, &out->channel_map_param.channel_map[0]);
Xiaojun Sang785b5da2017-08-03 15:52:29 +08003066 audio_enable_asm_bit_width_enforce_mode(adev->mixer,
3067 adev->dsp_bit_width_enforce_mode,
3068 true);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003069 out->pcm = NULL;
Haynes Mathew George380745d2017-10-04 15:27:45 -07003070 ATRACE_BEGIN("compress_open");
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -08003071 out->compr = compress_open(adev->snd_card,
3072 out->pcm_device_id,
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003073 COMPRESS_IN, &out->compr_config);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003074 ATRACE_END();
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003075 if (out->compr && !is_compress_ready(out->compr)) {
3076 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
3077 compress_close(out->compr);
3078 out->compr = NULL;
3079 ret = -EIO;
3080 goto error_open;
3081 }
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05303082 /* compress_open sends params of the track, so reset the flag here */
3083 out->is_compr_metadata_avail = false;
3084
Ben Rombergerd771a7c2017-02-22 18:05:17 -08003085 if (out->client_callback)
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003086 compress_nonblock(out->compr, out->non_blocking);
Eric Laurentc4aef752013-09-12 17:45:53 -07003087
Fred Oh3f43e742015-03-04 18:42:34 -08003088 /* Since small bufs uses blocking writes, a write will be blocked
3089 for the default max poll time (20s) in the event of an SSR.
3090 Reduce the poll time to observe and deal with SSR faster.
3091 */
Ashish Jain5106d362016-05-11 19:23:33 +05303092 if (!out->non_blocking) {
Fred Oh3f43e742015-03-04 18:42:34 -08003093 compress_set_max_poll_wait(out->compr, 1000);
3094 }
3095
Manish Dewangan69426c82017-01-30 17:35:36 +05303096 audio_extn_utils_compress_set_render_mode(out);
Manish Dewangan58229382017-02-02 15:48:41 +05303097 audio_extn_utils_compress_set_clk_rec_mode(uc_info);
Manish Dewangan69426c82017-01-30 17:35:36 +05303098
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08003099 audio_extn_dts_create_state_notifier_node(out->usecase);
3100 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
3101 popcount(out->channel_mask),
3102 out->playback_started);
3103
Subhash Chandra Bose Naripeddy7690c562013-12-14 00:34:53 -08003104#ifdef DS1_DOLBY_DDP_ENABLED
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05303105 if (audio_extn_utils_is_dolby_format(out->format))
Subhash Chandra Bose Naripeddy7690c562013-12-14 00:34:53 -08003106 audio_extn_dolby_send_ddp_endp_params(adev);
3107#endif
Preetam Singh Ranawatd18d8832017-02-08 17:34:54 +05303108 if (!(audio_extn_passthru_is_passthrough_stream(out)) &&
3109 (out->sample_rate != 176400 && out->sample_rate <= 192000)) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003110 if (adev->visualizer_start_output != NULL)
3111 adev->visualizer_start_output(out->handle, out->pcm_device_id);
3112 if (adev->offload_effects_start_output != NULL)
Ashish Jain5106d362016-05-11 19:23:33 +05303113 adev->offload_effects_start_output(out->handle, out->pcm_device_id, adev->mixer);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08003114 audio_extn_check_and_set_dts_hpx_state(adev);
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003115 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003116 }
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003117
3118 if (ret == 0) {
3119 register_out_stream(out);
3120 if (out->realtime) {
Aniket Kumar Lataf9f246e2017-09-15 15:20:16 -07003121 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
3122 ALOGE("%s: pcm stream not ready", __func__);
3123 goto error_open;
3124 }
Haynes Mathew George380745d2017-10-04 15:27:45 -07003125 ATRACE_BEGIN("pcm_start");
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003126 ret = pcm_start(out->pcm);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003127 ATRACE_END();
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003128 if (ret < 0)
3129 goto error_open;
3130 }
3131 }
3132
Sudheer Papothifa9d2282015-09-17 01:53:25 +05303133 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Ravi Kumar Alamandac7d9bef2015-09-30 22:27:26 -07003134 ALOGD("%s: exit", __func__);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07003135
Manish Dewangan21a850a2017-08-14 12:03:55 +05303136 if (out->ip_hdlr_handle) {
Vidyakumar Athota6d655882017-05-22 18:26:24 -07003137 ret = audio_extn_ip_hdlr_intf_open(out->ip_hdlr_handle, true, out, out->usecase);
Naresh Tanniru85819452017-05-04 18:55:45 -07003138 if (ret < 0)
3139 ALOGE("%s: audio_extn_ip_hdlr_intf_open failed %d",__func__, ret);
3140 }
3141
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07003142 // consider a scenario where on pause lower layers are tear down.
3143 // so on resume, swap mixer control need to be sent only when
3144 // backend is active, hence rather than sending from enable device
3145 // sending it from start of streamtream
3146
3147 platform_set_swap_channels(adev, true);
3148
Haynes Mathew George380745d2017-10-04 15:27:45 -07003149 ATRACE_END();
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003150 return ret;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003151error_open:
Sudheer Papothifa9d2282015-09-17 01:53:25 +05303152 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003153 stop_output_stream(out);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08003154error_config:
Laxminath Kasam2cb4b752015-09-24 03:59:15 +05303155 /*
3156 * sleep 50ms to allow sufficient time for kernel
3157 * drivers to recover incases like SSR.
3158 */
3159 usleep(50000);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003160 ATRACE_END();
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08003161 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003162}
3163
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003164static int check_input_parameters(uint32_t sample_rate,
3165 audio_format_t format,
3166 int channel_count)
3167{
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003168 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003169
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05303170 if (((format != AUDIO_FORMAT_PCM_16_BIT) && (format != AUDIO_FORMAT_PCM_8_24_BIT) &&
3171 (format != AUDIO_FORMAT_PCM_24_BIT_PACKED) && (format != AUDIO_FORMAT_PCM_32_BIT) &&
3172 (format != AUDIO_FORMAT_PCM_FLOAT)) &&
Mingming Yine62d7842013-10-25 16:26:03 -07003173 !voice_extn_compress_voip_is_format_supported(format) &&
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003174 !audio_extn_compr_cap_format_supported(format))
3175 ret = -EINVAL;
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003176
3177 switch (channel_count) {
3178 case 1:
3179 case 2:
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +05303180 case 3:
3181 case 4:
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003182 case 6:
3183 break;
3184 default:
3185 ret = -EINVAL;
3186 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003187
3188 switch (sample_rate) {
3189 case 8000:
3190 case 11025:
3191 case 12000:
3192 case 16000:
3193 case 22050:
3194 case 24000:
3195 case 32000:
3196 case 44100:
3197 case 48000:
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05303198 case 96000:
3199 case 192000:
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003200 break;
3201 default:
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003202 ret = -EINVAL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003203 }
3204
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08003205 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003206}
3207
3208static size_t get_input_buffer_size(uint32_t sample_rate,
3209 audio_format_t format,
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07003210 int channel_count,
3211 bool is_low_latency)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003212{
3213 size_t size = 0;
3214
Ravi Kumar Alamanda33d33062013-06-11 14:40:01 -07003215 if (check_input_parameters(sample_rate, format, channel_count) != 0)
3216 return 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003217
Ravi Kumar Alamanda33d33062013-06-11 14:40:01 -07003218 size = (sample_rate * AUDIO_CAPTURE_PERIOD_DURATION_MSEC) / 1000;
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07003219 if (is_low_latency)
3220 size = configured_low_latency_capture_period_size;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05303221
3222 size *= audio_bytes_per_sample(format) * channel_count;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003223
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07003224 /* make sure the size is multiple of 32 bytes
3225 * At 48 kHz mono 16-bit PCM:
3226 * 5.000 ms = 240 frames = 15*16*1*2 = 480, a whole multiple of 32 (15)
3227 * 3.333 ms = 160 frames = 10*16*1*2 = 320, a whole multiple of 32 (10)
3228 */
3229 size += 0x1f;
3230 size &= ~0x1f;
Ravi Kumar Alamanda33d33062013-06-11 14:40:01 -07003231
3232 return size;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003233}
3234
Ashish Jain058165c2016-09-28 23:18:48 +05303235static size_t get_output_period_size(uint32_t sample_rate,
3236 audio_format_t format,
3237 int channel_count,
3238 int duration /*in millisecs*/)
3239{
3240 size_t size = 0;
3241 uint32_t bytes_per_sample = audio_bytes_per_sample(format);
3242
3243 if ((duration == 0) || (sample_rate == 0) ||
3244 (bytes_per_sample == 0) || (channel_count == 0)) {
3245 ALOGW("Invalid config duration %d sr %d bps %d ch %d", duration, sample_rate,
3246 bytes_per_sample, channel_count);
3247 return -EINVAL;
3248 }
3249
3250 size = (sample_rate *
3251 duration *
3252 bytes_per_sample *
3253 channel_count) / 1000;
3254 /*
3255 * To have same PCM samples for all channels, the buffer size requires to
3256 * be multiple of (number of channels * bytes per sample)
3257 * For writes to succeed, the buffer must be written at address which is multiple of 32
3258 */
3259 size = ALIGN(size, (bytes_per_sample * channel_count * 32));
3260
3261 return (size/(channel_count * bytes_per_sample));
3262}
3263
Ashish Jain5106d362016-05-11 19:23:33 +05303264static uint64_t get_actual_pcm_frames_rendered(struct stream_out *out)
3265{
3266 uint64_t actual_frames_rendered = 0;
3267 size_t kernel_buffer_size = out->compr_config.fragment_size * out->compr_config.fragments;
3268
3269 /* This adjustment accounts for buffering after app processor.
3270 * It is based on estimated DSP latency per use case, rather than exact.
3271 */
3272 int64_t platform_latency = platform_render_latency(out->usecase) *
3273 out->sample_rate / 1000000LL;
3274
3275 /* not querying actual state of buffering in kernel as it would involve an ioctl call
3276 * which then needs protection, this causes delay in TS query for pcm_offload usecase
3277 * hence only estimate.
3278 */
3279 int64_t signed_frames = out->written - kernel_buffer_size;
3280
3281 signed_frames = signed_frames / (audio_bytes_per_sample(out->format) * popcount(out->channel_mask)) - platform_latency;
3282
3283 if (signed_frames > 0)
3284 actual_frames_rendered = signed_frames;
3285
3286 ALOGVV("%s signed frames %lld out_written %lld kernel_buffer_size %d"
3287 "bytes/sample %zu channel count %d", __func__,(long long int)signed_frames,
3288 (long long int)out->written, (int)kernel_buffer_size,
3289 audio_bytes_per_sample(out->compr_config.codec->format),
3290 popcount(out->channel_mask));
3291
3292 return actual_frames_rendered;
3293}
3294
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003295static uint32_t out_get_sample_rate(const struct audio_stream *stream)
3296{
3297 struct stream_out *out = (struct stream_out *)stream;
3298
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003299 return out->sample_rate;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003300}
3301
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07003302static int out_set_sample_rate(struct audio_stream *stream __unused,
3303 uint32_t rate __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003304{
3305 return -ENOSYS;
3306}
3307
3308static size_t out_get_buffer_size(const struct audio_stream *stream)
3309{
3310 struct stream_out *out = (struct stream_out *)stream;
3311
Varun Balaraje49253e2017-07-06 19:48:56 +05303312 if (is_interactive_usecase(out->usecase)) {
Sri Karri27279e12017-08-07 16:05:20 +05303313 return out->config.period_size * out->config.period_count;
Varun Balaraje49253e2017-07-06 19:48:56 +05303314 } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Naresh Tanniruee3499a2017-01-05 14:05:35 +05303315 if (out->flags & AUDIO_OUTPUT_FLAG_TIMESTAMP)
3316 return out->compr_config.fragment_size - sizeof(struct snd_codec_metadata);
3317 else
3318 return out->compr_config.fragment_size;
3319 } else if(out->usecase == USECASE_COMPRESS_VOIP_CALL)
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08003320 return voice_extn_compress_voip_out_get_buffer_size(out);
Vikram Panduranga93f080e2017-06-07 18:16:14 -07003321 else if(out->usecase == USECASE_AUDIO_PLAYBACK_VOIP)
3322 return VOIP_IO_BUF_SIZE(out->config.rate, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE);
Dhananjay Kumarac341582017-02-23 23:42:25 +05303323 else if (is_offload_usecase(out->usecase) &&
3324 out->flags == AUDIO_OUTPUT_FLAG_DIRECT)
Ashish Jain83a6cc22016-06-28 14:34:17 +05303325 return out->hal_fragment_size;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003326
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003327 return out->config.period_size * out->af_period_multiplier *
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07003328 audio_stream_out_frame_size((const struct audio_stream_out *)stream);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003329}
3330
3331static uint32_t out_get_channels(const struct audio_stream *stream)
3332{
3333 struct stream_out *out = (struct stream_out *)stream;
3334
3335 return out->channel_mask;
3336}
3337
3338static audio_format_t out_get_format(const struct audio_stream *stream)
3339{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003340 struct stream_out *out = (struct stream_out *)stream;
3341
3342 return out->format;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003343}
3344
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07003345static int out_set_format(struct audio_stream *stream __unused,
3346 audio_format_t format __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003347{
3348 return -ENOSYS;
3349}
3350
3351static int out_standby(struct audio_stream *stream)
3352{
3353 struct stream_out *out = (struct stream_out *)stream;
3354 struct audio_device *adev = out->dev;
Haynes Mathew George16081042017-05-31 17:16:49 -07003355 bool do_stop = true;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003356
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05303357 ALOGD("%s: enter: stream (%p) usecase(%d: %s)", __func__,
3358 stream, out->usecase, use_case_table[out->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003359
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07003360 lock_output_stream(out);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003361 if (!out->standby) {
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07003362 if (adev->adm_deregister_stream)
3363 adev->adm_deregister_stream(adev->adm_data, out->handle);
3364
Haynes Mathew George7fce0a52016-06-23 18:22:27 -07003365 if (is_offload_usecase(out->usecase))
3366 stop_compressed_output_l(out);
3367
Ravi Kumar Alamanda8bba9e92013-11-11 21:09:07 -08003368 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003369 out->standby = true;
Zhou Songa8895042016-07-05 17:54:22 +08003370 if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
3371 voice_extn_compress_voip_close_output_stream(stream);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05303372 out->started = 0;
Zhou Songa8895042016-07-05 17:54:22 +08003373 pthread_mutex_unlock(&adev->lock);
3374 pthread_mutex_unlock(&out->lock);
3375 ALOGD("VOIP output entered standby");
3376 return 0;
3377 } else if (!is_offload_usecase(out->usecase)) {
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003378 if (out->pcm) {
3379 pcm_close(out->pcm);
3380 out->pcm = NULL;
3381 }
Haynes Mathew George16081042017-05-31 17:16:49 -07003382 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
3383 do_stop = out->playback_started;
3384 out->playback_started = false;
3385 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003386 } else {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07003387 ALOGD("copl(%p):standby", out);
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05303388 out->send_next_track_params = false;
3389 out->is_compr_metadata_avail = false;
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003390 out->gapless_mdata.encoder_delay = 0;
3391 out->gapless_mdata.encoder_padding = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07003392 if (out->compr != NULL) {
3393 compress_close(out->compr);
3394 out->compr = NULL;
3395 }
Eric Laurent150dbfe2013-02-27 14:31:02 -08003396 }
Haynes Mathew George16081042017-05-31 17:16:49 -07003397 if (do_stop) {
3398 stop_output_stream(out);
3399 }
Eric Laurent150dbfe2013-02-27 14:31:02 -08003400 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003401 }
3402 pthread_mutex_unlock(&out->lock);
Ashish Jainbbce4322016-02-16 13:25:27 +05303403 ALOGD("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003404 return 0;
3405}
3406
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05303407static int out_on_error(struct audio_stream *stream)
3408{
3409 struct stream_out *out = (struct stream_out *)stream;
3410 bool do_standby = false;
3411
3412 lock_output_stream(out);
3413 if (!out->standby) {
3414 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
3415 stop_compressed_output_l(out);
3416 send_offload_cmd_l(out, OFFLOAD_CMD_ERROR);
3417 } else
3418 do_standby = true;
3419 }
3420 pthread_mutex_unlock(&out->lock);
3421
3422 if (do_standby)
3423 return out_standby(&out->stream.common);
3424
3425 return 0;
3426}
3427
Ashish Jain1b9b30c2017-05-18 20:57:40 +05303428/*
3429 *standby implementation without locks, assumes that the callee already
3430 *has taken adev and out lock.
3431 */
3432int out_standby_l(struct audio_stream *stream)
3433{
3434 struct stream_out *out = (struct stream_out *)stream;
3435 struct audio_device *adev = out->dev;
3436
3437 ALOGD("%s: enter: stream (%p) usecase(%d: %s)", __func__,
3438 stream, out->usecase, use_case_table[out->usecase]);
3439
3440 if (!out->standby) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07003441 ATRACE_BEGIN("out_standby_l");
Ashish Jain1b9b30c2017-05-18 20:57:40 +05303442 if (adev->adm_deregister_stream)
3443 adev->adm_deregister_stream(adev->adm_data, out->handle);
3444
3445 if (is_offload_usecase(out->usecase))
3446 stop_compressed_output_l(out);
3447
3448 out->standby = true;
3449 if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
3450 voice_extn_compress_voip_close_output_stream(stream);
3451 out->started = 0;
3452 ALOGD("VOIP output entered standby");
Haynes Mathew George380745d2017-10-04 15:27:45 -07003453 ATRACE_END();
Ashish Jain1b9b30c2017-05-18 20:57:40 +05303454 return 0;
3455 } else if (!is_offload_usecase(out->usecase)) {
3456 if (out->pcm) {
3457 pcm_close(out->pcm);
3458 out->pcm = NULL;
3459 }
3460 } else {
3461 ALOGD("copl(%p):standby", out);
3462 out->send_next_track_params = false;
3463 out->is_compr_metadata_avail = false;
3464 out->gapless_mdata.encoder_delay = 0;
3465 out->gapless_mdata.encoder_padding = 0;
3466 if (out->compr != NULL) {
3467 compress_close(out->compr);
3468 out->compr = NULL;
3469 }
3470 }
3471 stop_output_stream(out);
Haynes Mathew George380745d2017-10-04 15:27:45 -07003472 ATRACE_END();
Ashish Jain1b9b30c2017-05-18 20:57:40 +05303473 }
3474 ALOGD("%s: exit", __func__);
3475 return 0;
3476}
3477
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07003478static int out_dump(const struct audio_stream *stream __unused,
3479 int fd __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003480{
3481 return 0;
3482}
3483
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003484static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms)
3485{
3486 int ret = 0;
3487 char value[32];
ApurupaPattapu2e084df2013-12-18 15:47:59 -08003488
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003489 if (!out || !parms) {
Krishnankutty Kolathappillyeb78be72013-12-15 12:03:07 -08003490 ALOGE("%s: return invalid ",__func__);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003491 return -EINVAL;
3492 }
3493
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +05303494 ret = audio_extn_parse_compress_metadata(out, parms);
Weiyin Jiang18ac4e92015-03-15 15:03:40 +08003495
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003496 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES, value, sizeof(value));
3497 if (ret >= 0) {
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +05303498 out->gapless_mdata.encoder_delay = atoi(value); //whats a good limit check?
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003499 }
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003500 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES, value, sizeof(value));
3501 if (ret >= 0) {
Satya Krishna Pindiproli70471602015-04-24 19:12:43 +05303502 out->gapless_mdata.encoder_padding = atoi(value);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003503 }
3504
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003505 ALOGV("%s new encoder delay %u and padding %u", __func__,
3506 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
3507
3508 return 0;
3509}
3510
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003511static bool output_drives_call(struct audio_device *adev, struct stream_out *out)
3512{
3513 return out == adev->primary_output || out == adev->voice_tx_output;
3514}
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003515
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05303516// note: this call is safe only if the stream_cb is
3517// removed first in close_output_stream (as is done now).
3518static void out_snd_mon_cb(void * stream, struct str_parms * parms)
3519{
3520 if (!stream || !parms)
3521 return;
3522
3523 struct stream_out *out = (struct stream_out *)stream;
3524 struct audio_device *adev = out->dev;
3525
3526 card_status_t status;
3527 int card;
3528 if (parse_snd_card_status(parms, &card, &status) < 0)
3529 return;
3530
3531 pthread_mutex_lock(&adev->lock);
3532 bool valid_cb = (card == adev->snd_card);
3533 pthread_mutex_unlock(&adev->lock);
3534
3535 if (!valid_cb)
3536 return;
3537
3538 lock_output_stream(out);
3539 if (out->card_status != status)
3540 out->card_status = status;
3541 pthread_mutex_unlock(&out->lock);
3542
3543 ALOGI("out_snd_mon_cb for card %d usecase %s, status %s", card,
3544 use_case_table[out->usecase],
3545 status == CARD_STATUS_OFFLINE ? "offline" : "online");
3546
3547 if (status == CARD_STATUS_OFFLINE)
3548 out_on_error(stream);
3549
3550 return;
3551}
3552
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003553static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
3554{
3555 struct stream_out *out = (struct stream_out *)stream;
3556 struct audio_device *adev = out->dev;
3557 struct str_parms *parms;
3558 char value[32];
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08003559 int ret = 0, val = 0, err;
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303560 bool bypass_a2dp = false;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003561
sangwoobc677242013-08-08 16:53:43 +09003562 ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s",
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003563 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003564 parms = str_parms_create_str(kvpairs);
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05303565 if (!parms)
3566 goto error;
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08003567 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
3568 if (err >= 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003569 val = atoi(value);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07003570 lock_output_stream(out);
Eric Laurent150dbfe2013-02-27 14:31:02 -08003571 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003572
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003573 /*
Weiyin Jiang4256eeb2016-05-19 13:28:30 +08003574 * When HDMI cable is unplugged the music playback is paused and
3575 * the policy manager sends routing=0. But the audioflinger continues
3576 * to write data until standby time (3sec). As the HDMI core is
3577 * turned off, the write gets blocked.
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003578 * Avoid this by routing audio to speaker until standby.
3579 */
Weiyin Jiang4256eeb2016-05-19 13:28:30 +08003580 if ((out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL) &&
3581 (val == AUDIO_DEVICE_NONE) &&
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05303582 !audio_extn_passthru_is_passthrough_stream(out) &&
Weiyin Jiang4256eeb2016-05-19 13:28:30 +08003583 (platform_get_edid_info(adev->platform) != 0) /* HDMI disconnected */) {
3584 val = AUDIO_DEVICE_OUT_SPEAKER;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003585 }
Naresh Tanniru9d027a62015-03-13 01:32:10 +05303586 /*
3587 * When A2DP is disconnected the
3588 * music playback is paused and the policy manager sends routing=0
3589 * But the audioflingercontinues to write data until standby time
3590 * (3sec). As BT is turned off, the write gets blocked.
3591 * Avoid this by routing audio to speaker until standby.
3592 */
Naresh Tanniruf7e9e632016-11-04 14:54:20 -07003593 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
Naresh Tanniru9d027a62015-03-13 01:32:10 +05303594 (val == AUDIO_DEVICE_NONE)) {
3595 val = AUDIO_DEVICE_OUT_SPEAKER;
3596 }
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05303597 /* To avoid a2dp to sco overlapping / BT device improper state
3598 * check with BT lib about a2dp streaming support before routing
Naresh Tanniru03f9dd52016-10-19 18:46:22 +05303599 */
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05303600 if (val & AUDIO_DEVICE_OUT_ALL_A2DP) {
3601 if (!audio_extn_a2dp_is_ready()) {
3602 if (val & AUDIO_DEVICE_OUT_SPEAKER) {
3603 //combo usecase just by pass a2dp
3604 ALOGW("%s: A2DP profile is not ready,routing to speaker only", __func__);
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303605 bypass_a2dp = true;
Preetam Singh Ranawata1849ba2017-02-06 14:10:11 +05303606 } else {
3607 ALOGE("%s: A2DP profile is not ready,ignoring routing request", __func__);
3608 /* update device to a2dp and don't route as BT returned error
3609 * However it is still possible a2dp routing called because
3610 * of current active device disconnection (like wired headset)
3611 */
3612 out->devices = val;
3613 pthread_mutex_unlock(&out->lock);
3614 pthread_mutex_unlock(&adev->lock);
3615 goto error;
3616 }
3617 }
Naresh Tanniru03f9dd52016-10-19 18:46:22 +05303618 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003619 /*
3620 * select_devices() call below switches all the usecases on the same
3621 * backend to the new device. Refer to check_usecases_codec_backend() in
3622 * the select_devices(). But how do we undo this?
3623 *
3624 * For example, music playback is active on headset (deep-buffer usecase)
3625 * and if we go to ringtones and select a ringtone, low-latency usecase
3626 * will be started on headset+speaker. As we can't enable headset+speaker
3627 * and headset devices at the same time, select_devices() switches the music
3628 * playback to headset+speaker while starting low-lateny usecase for ringtone.
3629 * So when the ringtone playback is completed, how do we undo the same?
3630 *
3631 * We are relying on the out_set_parameters() call on deep-buffer output,
3632 * once the ringtone playback is ended.
3633 * NOTE: We should not check if the current devices are same as new devices.
3634 * Because select_devices() must be called to switch back the music
3635 * playback to headset.
3636 */
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08003637 if (val != 0) {
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003638 audio_devices_t new_dev = val;
3639 bool same_dev = out->devices == new_dev;
3640 out->devices = new_dev;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07003641
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -07003642 if (output_drives_call(adev, out)) {
kunleiz61b9c2e2017-11-01 13:47:23 +08003643 if (!voice_is_call_state_active(adev)) {
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -07003644 if (adev->mode == AUDIO_MODE_IN_CALL) {
3645 adev->current_call_output = out;
3646 ret = voice_start_call(adev);
3647 }
3648 } else {
3649 adev->current_call_output = out;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07003650 voice_update_devices_for_all_voice_usecases(adev);
Ravi Kumar Alamandabe149392014-10-20 17:07:43 -07003651 }
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08003652 }
Shiv Maliyappanahalli6b32c4c2015-11-04 18:10:20 -08003653
3654 if (!out->standby) {
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003655 if (!same_dev) {
3656 ALOGV("update routing change");
Sudheer Papothi80266982016-08-16 02:36:18 +05303657 audio_extn_perf_lock_acquire(&adev->perf_lock_handle, 0,
3658 adev->perf_lock_opts,
3659 adev->perf_lock_opts_size);
Haynes Mathew George822b5492016-07-01 16:57:24 -07003660 if (adev->adm_on_routing_change)
3661 adev->adm_on_routing_change(adev->adm_data,
3662 out->handle);
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003663 }
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303664 if (!bypass_a2dp) {
3665 select_devices(adev, out->usecase);
3666 } else {
3667 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
3668 select_devices(adev, out->usecase);
3669 out->devices = new_dev;
3670 }
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07003671
3672 if (!same_dev) {
3673 // on device switch force swap, lower functions will make sure
3674 // to check if swap is allowed or not.
3675 platform_set_swap_channels(adev, true);
Sudheer Papothi80266982016-08-16 02:36:18 +05303676 audio_extn_perf_lock_release(&adev->perf_lock_handle);
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07003677 }
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303678 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
3679 out->a2dp_compress_mute &&
Zhou Songc66eb7e2017-08-08 18:29:07 +08003680 (!(out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) || audio_extn_a2dp_is_ready())) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05303681 pthread_mutex_lock(&out->compr_mute_lock);
3682 out->a2dp_compress_mute = false;
3683 out_set_compr_volume(&out->stream, out->volume_l, out->volume_r);
3684 pthread_mutex_unlock(&out->compr_mute_lock);
3685 }
3686
Shiv Maliyappanahalli6b32c4c2015-11-04 18:10:20 -08003687 }
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08003688 }
3689
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003690 pthread_mutex_unlock(&adev->lock);
Eric Laurent150dbfe2013-02-27 14:31:02 -08003691 pthread_mutex_unlock(&out->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003692 }
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07003693
3694 if (out == adev->primary_output) {
3695 pthread_mutex_lock(&adev->lock);
3696 audio_extn_set_parameters(adev, parms);
3697 pthread_mutex_unlock(&adev->lock);
3698 }
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07003699 if (is_offload_usecase(out->usecase)) {
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07003700 lock_output_stream(out);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003701 parse_compress_metadata(out, parms);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08003702
3703 audio_extn_dts_create_state_notifier_node(out->usecase);
3704 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
3705 popcount(out->channel_mask),
3706 out->playback_started);
3707
Krishnankutty Kolathappillyeb78be72013-12-15 12:03:07 -08003708 pthread_mutex_unlock(&out->lock);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07003709 }
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07003710
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05303711 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_PROFILE, value, sizeof(value));
3712 if (err >= 0) {
3713 strlcpy(out->profile, value, sizeof(out->profile));
3714 ALOGV("updating stream profile with value '%s'", out->profile);
3715 lock_output_stream(out);
3716 audio_extn_utils_update_stream_output_app_type_cfg(adev->platform,
3717 &adev->streams_output_cfg_list,
Aalique Grahame65780b52017-09-27 14:59:56 -07003718 out->devices, out->flags, out->hal_op_format,
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05303719 out->sample_rate, out->bit_width,
3720 out->channel_mask, out->profile,
3721 &out->app_type_cfg);
3722 pthread_mutex_unlock(&out->lock);
3723 }
3724
Alexy Joseph98988832017-01-13 14:56:59 -08003725 //suspend, resume handling block
Aniket Kumar Lata932f4872017-11-06 18:29:44 -08003726 //remove QOS only if vendor.audio.hal.dynamic.qos.config.supported is set to true
3727 // and vendor.audio.hal.output.suspend.supported is set to true
3728 if (out->hal_output_suspend_supported && out->dynamic_pm_qos_config_supported) {
Alexy Joseph98988832017-01-13 14:56:59 -08003729 //check suspend parameter only for low latency and if the property
3730 //is enabled
3731 if (str_parms_get_str(parms, "suspend_playback", value, sizeof(value)) >= 0) {
3732 ALOGI("%s: got suspend_playback %s", __func__, value);
3733 lock_output_stream(out);
3734 if (!strncmp(value, "false", 5)) {
3735 //suspend_playback=false is supposed to set QOS value back to 75%
3736 //the mixer control sent with value Enable will achieve that
3737 ret = audio_route_apply_and_update_path(adev->audio_route, out->pm_qos_mixer_path);
3738 } else if (!strncmp (value, "true", 4)) {
3739 //suspend_playback=true is supposed to remove QOS value
3740 //resetting the mixer control will set the default value
3741 //for the mixer control which is Disable and this removes the QOS vote
3742 ret = audio_route_reset_and_update_path(adev->audio_route, out->pm_qos_mixer_path);
3743 } else {
3744 ALOGE("%s: Wrong value sent for suspend_playback, expected true/false,"
3745 " got %s", __func__, value);
3746 ret = -1;
3747 }
3748
3749 if (ret != 0) {
3750 ALOGE("%s: %s mixer ctl failed with %d, ignore suspend/resume setparams",
3751 __func__, out->pm_qos_mixer_path, ret);
3752 }
3753
3754 pthread_mutex_unlock(&out->lock);
3755 }
3756 }
3757 //end suspend, resume handling block
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003758 str_parms_destroy(parms);
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05303759error:
Eric Laurent994a6932013-07-17 11:51:42 -07003760 ALOGV("%s: exit: code(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003761 return ret;
3762}
3763
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003764static bool stream_get_parameter_channels(struct str_parms *query,
3765 struct str_parms *reply,
3766 audio_channel_mask_t *supported_channel_masks) {
3767 int ret = -1;
3768 char value[512];
3769 bool first = true;
3770 size_t i, j;
3771
3772 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS)) {
3773 ret = 0;
3774 value[0] = '\0';
3775 i = 0;
3776 while (supported_channel_masks[i] != 0) {
3777 for (j = 0; j < ARRAY_SIZE(channels_name_to_enum_table); j++) {
3778 if (channels_name_to_enum_table[j].value == supported_channel_masks[i]) {
3779 if (!first)
Satya Krishna Pindiprolib22ac722017-10-09 15:44:16 +05303780 strlcat(value, "|", sizeof(value));
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003781
Satya Krishna Pindiprolib22ac722017-10-09 15:44:16 +05303782 strlcat(value, channels_name_to_enum_table[j].name, sizeof(value));
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003783 first = false;
3784 break;
3785 }
3786 }
3787 i++;
3788 }
3789 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
3790 }
3791 return ret == 0;
3792}
3793
3794static bool stream_get_parameter_formats(struct str_parms *query,
3795 struct str_parms *reply,
3796 audio_format_t *supported_formats) {
3797 int ret = -1;
3798 char value[256];
3799 size_t i, j;
3800 bool first = true;
3801
3802 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS)) {
3803 ret = 0;
3804 value[0] = '\0';
3805 i = 0;
3806 while (supported_formats[i] != 0) {
3807 for (j = 0; j < ARRAY_SIZE(formats_name_to_enum_table); j++) {
3808 if (formats_name_to_enum_table[j].value == supported_formats[i]) {
3809 if (!first) {
Satya Krishna Pindiprolib22ac722017-10-09 15:44:16 +05303810 strlcat(value, "|", sizeof(value));
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003811 }
Satya Krishna Pindiprolib22ac722017-10-09 15:44:16 +05303812 strlcat(value, formats_name_to_enum_table[j].name, sizeof(value));
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003813 first = false;
3814 break;
3815 }
3816 }
3817 i++;
3818 }
3819 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_FORMATS, value);
3820 }
3821 return ret == 0;
3822}
3823
3824static bool stream_get_parameter_rates(struct str_parms *query,
3825 struct str_parms *reply,
3826 uint32_t *supported_sample_rates) {
3827
3828 int i;
3829 char value[256];
3830 int ret = -1;
3831 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES)) {
3832 ret = 0;
3833 value[0] = '\0';
3834 i=0;
3835 int cursor = 0;
3836 while (supported_sample_rates[i]) {
3837 int avail = sizeof(value) - cursor;
3838 ret = snprintf(value + cursor, avail, "%s%d",
3839 cursor > 0 ? "|" : "",
3840 supported_sample_rates[i]);
3841 if (ret < 0 || ret >= avail) {
3842 // if cursor is at the last element of the array
3843 // overwrite with \0 is duplicate work as
3844 // snprintf already put a \0 in place.
3845 // else
3846 // we had space to write the '|' at value[cursor]
3847 // (which will be overwritten) or no space to fill
3848 // the first element (=> cursor == 0)
3849 value[cursor] = '\0';
3850 break;
3851 }
3852 cursor += ret;
3853 ++i;
3854 }
3855 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES,
3856 value);
3857 }
3858 return ret >= 0;
3859}
3860
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003861static char* out_get_parameters(const struct audio_stream *stream, const char *keys)
3862{
3863 struct stream_out *out = (struct stream_out *)stream;
3864 struct str_parms *query = str_parms_create_str(keys);
Alexy Josephaee4fdd2016-01-29 13:02:07 -08003865 char *str = (char*) NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003866 char value[256];
3867 struct str_parms *reply = str_parms_create();
3868 size_t i, j;
3869 int ret;
3870 bool first = true;
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07003871
3872 if (!query || !reply) {
Alexy Josephaee4fdd2016-01-29 13:02:07 -08003873 if (reply) {
3874 str_parms_destroy(reply);
3875 }
3876 if (query) {
3877 str_parms_destroy(query);
3878 }
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07003879 ALOGE("out_get_parameters: failed to allocate mem for query or reply");
3880 return NULL;
3881 }
3882
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003883 ALOGV("%s: %s enter: keys - %s", __func__, use_case_table[out->usecase], keys);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003884 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
3885 if (ret >= 0) {
3886 value[0] = '\0';
3887 i = 0;
3888 while (out->supported_channel_masks[i] != 0) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003889 for (j = 0; j < ARRAY_SIZE(channels_name_to_enum_table); j++) {
3890 if (channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003891 if (!first) {
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -08003892 strlcat(value, "|", sizeof(value));
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003893 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003894 strlcat(value, channels_name_to_enum_table[j].name, sizeof(value));
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003895 first = false;
3896 break;
3897 }
3898 }
3899 i++;
3900 }
3901 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
3902 str = str_parms_to_str(reply);
3903 } else {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08003904 voice_extn_out_get_parameters(out, query, reply);
3905 str = str_parms_to_str(reply);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003906 }
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003907
Alexy Joseph62142aa2015-11-16 15:10:34 -08003908
3909 ret = str_parms_get_str(query, "is_direct_pcm_track", value, sizeof(value));
3910 if (ret >= 0) {
3911 value[0] = '\0';
Dhananjay Kumarac341582017-02-23 23:42:25 +05303912 if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
3913 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Alexy Joseph62142aa2015-11-16 15:10:34 -08003914 ALOGV("in direct_pcm");
Satya Krishna Pindiprolib6655542017-07-03 19:38:19 +05303915 strlcat(value, "true", sizeof(value));
Alexy Joseph62142aa2015-11-16 15:10:34 -08003916 } else {
3917 ALOGV("not in direct_pcm");
Sharad Sangle3dd5a4a2015-12-10 18:39:17 +05303918 strlcat(value, "false", sizeof(value));
Alexy Joseph62142aa2015-11-16 15:10:34 -08003919 }
3920 str_parms_add_str(reply, "is_direct_pcm_track", value);
Alexy Josephaee4fdd2016-01-29 13:02:07 -08003921 if (str)
3922 free(str);
Alexy Joseph62142aa2015-11-16 15:10:34 -08003923 str = str_parms_to_str(reply);
3924 }
3925
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003926 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS, value, sizeof(value));
3927 if (ret >= 0) {
3928 value[0] = '\0';
3929 i = 0;
3930 first = true;
3931 while (out->supported_formats[i] != 0) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003932 for (j = 0; j < ARRAY_SIZE(formats_name_to_enum_table); j++) {
3933 if (formats_name_to_enum_table[j].value == out->supported_formats[i]) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003934 if (!first) {
Apoorv Raghuvanshi8880cac2015-02-06 15:33:49 -08003935 strlcat(value, "|", sizeof(value));
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003936 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003937 strlcat(value, formats_name_to_enum_table[j].name, sizeof(value));
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003938 first = false;
3939 break;
3940 }
3941 }
3942 i++;
3943 }
3944 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_FORMATS, value);
Alexy Josephaee4fdd2016-01-29 13:02:07 -08003945 if (str)
3946 free(str);
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07003947 str = str_parms_to_str(reply);
3948 }
Mingming Yin3a941d42016-02-17 18:08:05 -08003949
3950 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES, value, sizeof(value));
3951 if (ret >= 0) {
3952 value[0] = '\0';
3953 i = 0;
3954 first = true;
3955 while (out->supported_sample_rates[i] != 0) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003956 for (j = 0; j < ARRAY_SIZE(out_sample_rates_name_to_enum_table); j++) {
3957 if (out_sample_rates_name_to_enum_table[j].value == out->supported_sample_rates[i]) {
Mingming Yin3a941d42016-02-17 18:08:05 -08003958 if (!first) {
3959 strlcat(value, "|", sizeof(value));
3960 }
Haynes Mathew George484e8d22017-07-31 18:55:17 -07003961 strlcat(value, out_sample_rates_name_to_enum_table[j].name, sizeof(value));
Mingming Yin3a941d42016-02-17 18:08:05 -08003962 first = false;
3963 break;
3964 }
3965 }
3966 i++;
3967 }
3968 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES, value);
3969 if (str)
3970 free(str);
3971 str = str_parms_to_str(reply);
3972 }
3973
Alexy Joseph98988832017-01-13 14:56:59 -08003974 if (str_parms_get_str(query, "supports_hw_suspend", value, sizeof(value)) >= 0) {
3975 //only low latency track supports suspend_resume
3976 str_parms_add_int(reply, "supports_hw_suspend",
Aniket Kumar Lata932f4872017-11-06 18:29:44 -08003977 (out->hal_output_suspend_supported));
Alexy Joseph98988832017-01-13 14:56:59 -08003978 if (str)
3979 free(str);
3980 str = str_parms_to_str(reply);
3981 }
3982
3983
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003984 str_parms_destroy(query);
3985 str_parms_destroy(reply);
Eric Laurent994a6932013-07-17 11:51:42 -07003986 ALOGV("%s: exit: returns - %s", __func__, str);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003987 return str;
3988}
3989
3990static uint32_t out_get_latency(const struct audio_stream_out *stream)
3991{
Haynes Mathew George5beddd42016-06-27 18:33:40 -07003992 uint32_t period_ms;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003993 struct stream_out *out = (struct stream_out *)stream;
Alexy Josephaa54c872014-12-03 02:46:47 -08003994 uint32_t latency = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08003995
Alexy Josephaa54c872014-12-03 02:46:47 -08003996 if (is_offload_usecase(out->usecase)) {
Manish Dewangan07de2142017-02-27 19:27:20 +05303997 lock_output_stream(out);
3998 latency = audio_extn_utils_compress_get_dsp_latency(out);
3999 pthread_mutex_unlock(&out->lock);
Haynes Mathew George16081042017-05-31 17:16:49 -07004000 } else if ((out->realtime) ||
4001 (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP)) {
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004002 // since the buffer won't be filled up faster than realtime,
4003 // return a smaller number
4004 if (out->config.rate)
4005 period_ms = (out->af_period_multiplier * out->config.period_size *
4006 1000) / (out->config.rate);
4007 else
4008 period_ms = 0;
4009 latency = period_ms + platform_render_latency(out->usecase)/1000;
Alexy Josephaa54c872014-12-03 02:46:47 -08004010 } else {
4011 latency = (out->config.period_count * out->config.period_size * 1000) /
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004012 (out->config.rate);
Alexy Josephaa54c872014-12-03 02:46:47 -08004013 }
4014
yidongh0515e042017-07-06 15:00:34 +08004015 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices)
Aniket Kumar Latad5972fa2017-02-08 13:53:48 -08004016 latency += audio_extn_a2dp_get_encoder_latency();
4017
Anish Kumar50ebcbf2014-12-09 04:01:39 +05304018 ALOGV("%s: Latency %d", __func__, latency);
Alexy Josephaa54c872014-12-03 02:46:47 -08004019 return latency;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004020}
4021
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05304022static float AmpToDb(float amplification)
4023{
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05304024 float db = DSD_VOLUME_MIN_DB;
4025 if (amplification > 0) {
4026 db = 20 * log10(amplification);
4027 if(db < DSD_VOLUME_MIN_DB)
4028 return DSD_VOLUME_MIN_DB;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05304029 }
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05304030 return db;
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05304031}
4032
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304033static int out_set_compr_volume(struct audio_stream_out *stream, float left,
4034 float right)
4035{
4036 struct stream_out *out = (struct stream_out *)stream;
Manish Dewangan338c50a2017-09-12 15:22:03 +05304037 long volume[2];
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304038 char mixer_ctl_name[128];
4039 struct audio_device *adev = out->dev;
4040 struct mixer_ctl *ctl;
4041 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
4042 PCM_PLAYBACK);
4043
4044 snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
4045 "Compress Playback %d Volume", pcm_device_id);
4046 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4047 if (!ctl) {
4048 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4049 __func__, mixer_ctl_name);
4050 return -EINVAL;
4051 }
4052 ALOGE("%s:ctl for mixer cmd - %s, left %f, right %f",
4053 __func__, mixer_ctl_name, left, right);
4054 volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX);
4055 volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX);
4056 mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
4057
4058 return 0;
4059}
4060
Zhou Song2b8f28f2017-09-11 10:51:38 +08004061static int out_set_voip_volume(struct audio_stream_out *stream, float left,
4062 float right)
4063{
4064 struct stream_out *out = (struct stream_out *)stream;
4065 char mixer_ctl_name[] = "App Type Gain";
4066 struct audio_device *adev = out->dev;
4067 struct mixer_ctl *ctl;
Manish Dewangan338c50a2017-09-12 15:22:03 +05304068 long set_values[4];
Zhou Song2b8f28f2017-09-11 10:51:38 +08004069
4070 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4071 if (!ctl) {
4072 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4073 __func__, mixer_ctl_name);
4074 return -EINVAL;
4075 }
4076
4077 set_values[0] = 0; //0: Rx Session 1:Tx Session
4078 set_values[1] = out->app_type_cfg.app_type;
Manish Dewangan338c50a2017-09-12 15:22:03 +05304079 set_values[2] = (long)(left * VOIP_PLAYBACK_VOLUME_MAX);
4080 set_values[3] = (long)(right * VOIP_PLAYBACK_VOLUME_MAX);
Zhou Song2b8f28f2017-09-11 10:51:38 +08004081
4082 mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
4083 return 0;
4084}
4085
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004086static int out_set_volume(struct audio_stream_out *stream, float left,
4087 float right)
4088{
Eric Laurenta9024de2013-04-04 09:19:12 -07004089 struct stream_out *out = (struct stream_out *)stream;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004090 int volume[2];
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304091 int ret = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004092
Eric Laurenta9024de2013-04-04 09:19:12 -07004093 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
4094 /* only take left channel into account: the API is for stereo anyway */
4095 out->muted = (left == 0.0f);
4096 return 0;
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07004097 } else if (is_offload_usecase(out->usecase)) {
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05304098 if (audio_extn_passthru_is_passthrough_stream(out)) {
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07004099 /*
4100 * Set mute or umute on HDMI passthrough stream.
4101 * Only take left channel into account.
4102 * Mute is 0 and unmute 1
4103 */
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05304104 audio_extn_passthru_set_volume(out, (left == 0.0f));
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05304105 } else if (out->format == AUDIO_FORMAT_DSD){
4106 char mixer_ctl_name[128] = "DSD Volume";
4107 struct audio_device *adev = out->dev;
4108 struct mixer_ctl *ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
4109
4110 if (!ctl) {
4111 ALOGE("%s: Could not get ctl for mixer cmd - %s",
4112 __func__, mixer_ctl_name);
4113 return -EINVAL;
4114 }
Manish Dewangan338c50a2017-09-12 15:22:03 +05304115 volume[0] = (long)(AmpToDb(left));
4116 volume[1] = (long)(AmpToDb(right));
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05304117 mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
4118 return 0;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07004119 } else {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304120 pthread_mutex_lock(&out->compr_mute_lock);
4121 ALOGE("%s: compress mute %d", __func__, out->a2dp_compress_mute);
4122 if (!out->a2dp_compress_mute)
4123 ret = out_set_compr_volume(stream, left, right);
4124 out->volume_l = left;
4125 out->volume_r = right;
4126 pthread_mutex_unlock(&out->compr_mute_lock);
4127 return ret;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004128 }
Vikram Panduranga93f080e2017-06-07 18:16:14 -07004129 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP) {
Zhou Song2b8f28f2017-09-11 10:51:38 +08004130 if (!out->standby)
4131 ret = out_set_voip_volume(stream, left, right);
4132 out->volume_l = left;
4133 out->volume_r = right;
4134 return ret;
Eric Laurenta9024de2013-04-04 09:19:12 -07004135 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004136
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004137 return -ENOSYS;
4138}
4139
Zhou Songc9672822017-08-16 16:01:39 +08004140static void update_frames_written(struct stream_out *out, size_t bytes)
4141{
4142 size_t bpf = 0;
4143
4144 if (is_offload_usecase(out->usecase) && !out->non_blocking &&
4145 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD))
4146 bpf = 1;
4147 else if (!is_offload_usecase(out->usecase))
4148 bpf = audio_bytes_per_sample(out->format) *
4149 audio_channel_count_from_out_mask(out->channel_mask);
4150 if (bpf != 0)
4151 out->written += bytes / bpf;
4152}
4153
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004154static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
4155 size_t bytes)
4156{
4157 struct stream_out *out = (struct stream_out *)stream;
4158 struct audio_device *adev = out->dev;
Eric Laurent6e895242013-09-05 16:10:57 -07004159 ssize_t ret = 0;
Satish Babu Patakokila715b1422017-08-22 14:33:21 +05304160 int channels = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004161
Haynes Mathew George380745d2017-10-04 15:27:45 -07004162 ATRACE_BEGIN("out_write");
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004163 lock_output_stream(out);
Naresh Tanniru4c630392014-05-12 01:05:52 +05304164
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304165 if (CARD_STATUS_OFFLINE == out->card_status) {
Zhou Song0b2e5dc2015-03-16 14:41:38 +08004166
Dhananjay Kumarac341582017-02-23 23:42:25 +05304167 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Ashish Jainbbce4322016-02-16 13:25:27 +05304168 /*during SSR for compress usecase we should return error to flinger*/
Naresh Tanniru80659832014-06-04 18:17:56 +05304169 ALOGD(" copl %s: sound card is not active/SSR state", __func__);
4170 pthread_mutex_unlock(&out->lock);
Haynes Mathew George380745d2017-10-04 15:27:45 -07004171 ATRACE_END();
Naresh Tanniru80659832014-06-04 18:17:56 +05304172 return -ENETRESET;
Ashish Jainbbce4322016-02-16 13:25:27 +05304173 } else {
Ashish Jainbbce4322016-02-16 13:25:27 +05304174 ALOGD(" %s: sound card is not active/SSR state", __func__);
4175 ret= -EIO;
4176 goto exit;
Naresh Tanniru4c630392014-05-12 01:05:52 +05304177 }
4178 }
4179
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05304180 if (audio_extn_passthru_should_drop_data(out)) {
Ashish Jaind84fd6a2016-07-27 12:33:25 +05304181 ALOGV(" %s : Drop data as compress passthrough session is going on", __func__);
Ashish Jaind84fd6a2016-07-27 12:33:25 +05304182 ret = -EIO;
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05304183 goto exit;
4184 }
4185
Haynes Mathew George16081042017-05-31 17:16:49 -07004186 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
4187 ret = -EINVAL;
4188 goto exit;
4189 }
4190
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05304191 if ((out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) &&
4192 !out->is_iec61937_info_available) {
4193
4194 if (!audio_extn_passthru_is_passthrough_stream(out)) {
4195 out->is_iec61937_info_available = true;
4196 } else if (audio_extn_passthru_is_enabled()) {
4197 audio_extn_passthru_update_stream_configuration(adev, out, buffer, bytes);
Manish Dewangan37864bc2017-06-09 12:28:37 +05304198 out->is_iec61937_info_available = true;
Manish Dewangan671a4202017-08-18 17:30:46 +05304199
4200 if((out->format == AUDIO_FORMAT_DTS) ||
4201 (out->format == AUDIO_FORMAT_DTS_HD)) {
4202 ret = audio_extn_passthru_update_dts_stream_configuration(out,
4203 buffer, bytes);
4204 if (ret) {
4205 if (ret != -ENOSYS) {
4206 out->is_iec61937_info_available = false;
4207 ALOGD("iec61937 transmission info not yet updated retry");
4208 }
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05304209 } else if (!out->standby) {
Manish Dewangan671a4202017-08-18 17:30:46 +05304210 /* if stream has started and after that there is
4211 * stream config change (iec transmission config)
4212 * then trigger select_device to update backend configuration.
4213 */
4214 out->stream_config_changed = true;
4215 pthread_mutex_lock(&adev->lock);
4216 select_devices(adev, out->usecase);
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05304217 if (!audio_extn_passthru_is_supported_backend_edid_cfg(adev, out)) {
4218 ret = -EINVAL;
4219 goto exit;
4220 }
Manish Dewangan671a4202017-08-18 17:30:46 +05304221 pthread_mutex_unlock(&adev->lock);
4222 out->stream_config_changed = false;
4223 out->is_iec61937_info_available = true;
4224 }
4225 }
Satish Babu Patakokila715b1422017-08-22 14:33:21 +05304226
Garmond Leung317cbf12017-09-13 16:20:50 -07004227 if ((channels < (int)audio_channel_count_from_out_mask(out->channel_mask)) &&
Satish Babu Patakokila715b1422017-08-22 14:33:21 +05304228 (out->compr_config.codec->compr_passthr == PASSTHROUGH) &&
4229 (out->is_iec61937_info_available == true)) {
4230 ALOGE("%s: ERROR: Unsupported channel config in passthrough mode", __func__);
4231 ret = -EINVAL;
4232 goto exit;
4233 }
Manish Dewangan37864bc2017-06-09 12:28:37 +05304234 }
4235 }
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304236
4237 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
4238 (audio_extn_a2dp_is_suspended())) {
4239 if (!(out->devices & AUDIO_DEVICE_OUT_SPEAKER)) {
4240 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05304241 ret = -EIO;
4242 goto exit;
4243 }
4244 }
4245 }
4246
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004247 if (out->standby) {
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07004248 out->standby = false;
Eric Laurent150dbfe2013-02-27 14:31:02 -08004249 pthread_mutex_lock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08004250 if (out->usecase == USECASE_COMPRESS_VOIP_CALL)
4251 ret = voice_extn_compress_voip_start_output_stream(out);
4252 else
4253 ret = start_output_stream(out);
Eric Laurent150dbfe2013-02-27 14:31:02 -08004254 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004255 /* ToDo: If use case is compress offload should return 0 */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004256 if (ret != 0) {
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07004257 out->standby = true;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004258 goto exit;
4259 }
Ashish Jain1b9b30c2017-05-18 20:57:40 +05304260 out->started = 1;
vivek mehtab72d08d2016-04-29 03:16:47 -07004261 if (last_known_cal_step != -1) {
4262 ALOGD("%s: retry previous failed cal level set", __func__);
4263 audio_hw_send_gain_dep_calibration(last_known_cal_step);
Preetam Singh Ranawatf4ae0222017-05-31 17:07:28 +05304264 last_known_cal_step = -1;
vivek mehtab72d08d2016-04-29 03:16:47 -07004265 }
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05304266
4267 if ((out->is_iec61937_info_available == true) &&
4268 (audio_extn_passthru_is_passthrough_stream(out))&&
4269 (!audio_extn_passthru_is_supported_backend_edid_cfg(adev, out))) {
4270 ret = -EINVAL;
4271 goto exit;
4272 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004273 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004274
Ashish Jain81eb2a82015-05-13 10:52:34 +05304275 if (adev->is_channel_status_set == false && (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)){
Alexy Josephb1379942016-01-29 15:49:38 -08004276 audio_utils_set_hdmi_channel_status(out, (void *)buffer, bytes);
Ashish Jain81eb2a82015-05-13 10:52:34 +05304277 adev->is_channel_status_set = true;
4278 }
4279
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07004280 if (is_offload_usecase(out->usecase)) {
Alexy Joseph01e54e62015-03-03 19:01:03 -08004281 ALOGVV("copl(%p): writing buffer (%zu bytes) to compress device", out, bytes);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004282 if (out->send_new_metadata) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07004283 ALOGD("copl(%p):send new gapless metadata", out);
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004284 compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
4285 out->send_new_metadata = 0;
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05304286 if (out->send_next_track_params && out->is_compr_metadata_avail) {
4287 ALOGD("copl(%p):send next track params in gapless", out);
4288 compress_set_next_track_param(out->compr, &(out->compr_config.codec->options));
4289 out->send_next_track_params = false;
4290 out->is_compr_metadata_avail = false;
4291 }
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004292 }
Dhananjay Kumarac341582017-02-23 23:42:25 +05304293 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
Ashish Jain83a6cc22016-06-28 14:34:17 +05304294 (out->convert_buffer) != NULL) {
Haynes Mathew George352f27b2013-07-26 00:00:15 -07004295
Ashish Jain83a6cc22016-06-28 14:34:17 +05304296 if ((bytes > out->hal_fragment_size)) {
Ashish Jainf1eaa582016-05-23 20:54:24 +05304297 ALOGW("Error written bytes %zu > %d (fragment_size)",
Ashish Jain83a6cc22016-06-28 14:34:17 +05304298 bytes, out->hal_fragment_size);
Ashish Jainf1eaa582016-05-23 20:54:24 +05304299 pthread_mutex_unlock(&out->lock);
Haynes Mathew George380745d2017-10-04 15:27:45 -07004300 ATRACE_END();
Ashish Jainf1eaa582016-05-23 20:54:24 +05304301 return -EINVAL;
4302 } else {
Ashish Jain83a6cc22016-06-28 14:34:17 +05304303 audio_format_t dst_format = out->hal_op_format;
4304 audio_format_t src_format = out->hal_ip_format;
Ashish Jainf1eaa582016-05-23 20:54:24 +05304305
4306 uint32_t frames = bytes / format_to_bitwidth_table[src_format];
4307 uint32_t bytes_to_write = frames * format_to_bitwidth_table[dst_format];
4308
Ashish Jain83a6cc22016-06-28 14:34:17 +05304309 memcpy_by_audio_format(out->convert_buffer,
Ashish Jainf1eaa582016-05-23 20:54:24 +05304310 dst_format,
4311 buffer,
4312 src_format,
4313 frames);
4314
Ashish Jain83a6cc22016-06-28 14:34:17 +05304315 ret = compress_write(out->compr, out->convert_buffer,
Ashish Jainf1eaa582016-05-23 20:54:24 +05304316 bytes_to_write);
4317
4318 /*Convert written bytes in audio flinger format*/
4319 if (ret > 0)
4320 ret = ((ret * format_to_bitwidth_table[out->format]) /
4321 format_to_bitwidth_table[dst_format]);
4322 }
4323 } else
4324 ret = compress_write(out->compr, buffer, bytes);
4325
Zhou Songc9672822017-08-16 16:01:39 +08004326 if ((ret < 0 || ret == (ssize_t)bytes) && !out->non_blocking)
4327 update_frames_written(out, bytes);
4328
Dhanalakshmi Siddani37ca1d62014-08-20 12:28:34 +05304329 if (ret < 0)
4330 ret = -errno;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05304331 ALOGVV("%s: writing buffer (%zu bytes) to compress device returned %zd", __func__, bytes, ret);
Ashish Jainb26edfb2016-08-25 00:10:11 +05304332 /*msg to cb thread only if non blocking write is enabled*/
4333 if (ret >= 0 && ret < (ssize_t)bytes && out->non_blocking) {
Sidipotu Ashok55820562014-02-10 16:16:38 +05304334 ALOGD("No space available in compress driver, post msg to cb thread");
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004335 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
Naresh Tanniru80659832014-06-04 18:17:56 +05304336 } else if (-ENETRESET == ret) {
4337 ALOGE("copl %s: received sound card offline state on compress write", __func__);
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304338 out->card_status = CARD_STATUS_OFFLINE;
Naresh Tanniru80659832014-06-04 18:17:56 +05304339 pthread_mutex_unlock(&out->lock);
Dhananjay Kumar1248dd82017-07-28 21:22:16 +05304340 out_on_error(&out->stream.common);
Haynes Mathew George380745d2017-10-04 15:27:45 -07004341 ATRACE_END();
Naresh Tanniru80659832014-06-04 18:17:56 +05304342 return ret;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004343 }
Ashish Jain5106d362016-05-11 19:23:33 +05304344
Dhanalakshmi Siddania6b76c72016-09-09 18:10:31 +05304345 /* Call compr start only when non-zero bytes of data is there to be rendered */
4346 if (!out->playback_started && ret > 0) {
4347 int status = compress_start(out->compr);
4348 if (status < 0) {
4349 ret = status;
4350 ALOGE("%s: compr start failed with err %d", __func__, errno);
4351 goto exit;
4352 }
Alexy Joseph7de344d2015-03-30 10:40:03 -07004353 audio_extn_dts_eagle_fade(adev, true, out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004354 out->playback_started = 1;
4355 out->offload_state = OFFLOAD_STATE_PLAYING;
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08004356
4357 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
4358 popcount(out->channel_mask),
4359 out->playback_started);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004360 }
4361 pthread_mutex_unlock(&out->lock);
Haynes Mathew George380745d2017-10-04 15:27:45 -07004362 ATRACE_END();
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004363 return ret;
4364 } else {
4365 if (out->pcm) {
4366 if (out->muted)
4367 memset((void *)buffer, 0, bytes);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07004368
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05304369 ALOGVV("%s: writing buffer (%zu bytes) to pcm device", __func__, bytes);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07004370
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004371 long ns = 0;
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07004372
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004373 if (out->config.rate)
4374 ns = pcm_bytes_to_frames(out->pcm, bytes)*1000000000LL/
4375 out->config.rate;
4376
4377 bool use_mmap = is_mmap_usecase(out->usecase) || out->realtime;
4378
4379 request_out_focus(out, ns);
4380
4381 if (use_mmap)
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07004382 ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes);
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004383 else if (out->hal_op_format != out->hal_ip_format &&
Ashish Jain83a6cc22016-06-28 14:34:17 +05304384 out->convert_buffer != NULL) {
4385
4386 memcpy_by_audio_format(out->convert_buffer,
4387 out->hal_op_format,
4388 buffer,
4389 out->hal_ip_format,
4390 out->config.period_size * out->config.channels);
4391
4392 ret = pcm_write(out->pcm, out->convert_buffer,
4393 (out->config.period_size *
4394 out->config.channels *
4395 format_to_bitwidth_table[out->hal_op_format]));
4396 } else {
Aditya Bavanarid4db8ee2017-05-29 21:08:03 +05304397 /*
4398 * To avoid underrun in DSP when the application is not pumping
4399 * data at required rate, check for the no. of bytes and ignore
4400 * pcm_write if it is less than actual buffer size.
4401 * It is a work around to a change in compress VOIP driver.
4402 */
4403 if ((out->flags & AUDIO_OUTPUT_FLAG_VOIP_RX) &&
4404 bytes < (out->config.period_size * out->config.channels *
4405 audio_bytes_per_sample(out->format))) {
4406 size_t voip_buf_size =
4407 out->config.period_size * out->config.channels *
4408 audio_bytes_per_sample(out->format);
4409 ALOGE("%s:VOIP underrun: bytes received %zu, required:%zu\n",
4410 __func__, bytes, voip_buf_size);
4411 usleep(((uint64_t)voip_buf_size - bytes) *
4412 1000000 / audio_stream_out_frame_size(stream) /
4413 out_get_sample_rate(&out->stream.common));
4414 ret = 0;
4415 } else
4416 ret = pcm_write(out->pcm, (void *)buffer, bytes);
Ashish Jain83a6cc22016-06-28 14:34:17 +05304417 }
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07004418
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004419 release_out_focus(out);
4420
Dhanalakshmi Siddani37ca1d62014-08-20 12:28:34 +05304421 if (ret < 0)
4422 ret = -errno;
Zhou Songc9672822017-08-16 16:01:39 +08004423 else if (ret > 0)
Ashish Jain83a6cc22016-06-28 14:34:17 +05304424 ret = -EINVAL;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004425 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004426 }
4427
4428exit:
Zhou Songc9672822017-08-16 16:01:39 +08004429 update_frames_written(out, bytes);
Naresh Tanniru4c630392014-05-12 01:05:52 +05304430 if (-ENETRESET == ret) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304431 out->card_status = CARD_STATUS_OFFLINE;
Naresh Tanniru4c630392014-05-12 01:05:52 +05304432 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004433 pthread_mutex_unlock(&out->lock);
4434
4435 if (ret != 0) {
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07004436 if (out->pcm)
Alexy Josephb1379942016-01-29 15:49:38 -08004437 ALOGE("%s: error %d, %s", __func__, (int)ret, pcm_get_error(out->pcm));
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05304438 if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05304439 pthread_mutex_lock(&adev->lock);
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05304440 voice_extn_compress_voip_close_output_stream(&out->stream.common);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05304441 out->started = 0;
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05304442 pthread_mutex_unlock(&adev->lock);
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05304443 out->standby = true;
4444 }
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304445 out_on_error(&out->stream.common);
Dhanalakshmi Siddania6b76c72016-09-09 18:10:31 +05304446 if (!(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD))
4447 usleep((uint64_t)bytes * 1000000 / audio_stream_out_frame_size(stream) /
4448 out_get_sample_rate(&out->stream.common));
Vidyakumar Athotaa9d3a5f2017-08-09 12:13:05 -07004449
4450 if (audio_extn_passthru_is_passthrough_stream(out)) {
Garmond Leung317cbf12017-09-13 16:20:50 -07004451 ALOGE("%s: write error, ret = %ld", __func__, ret);
Haynes Mathew George380745d2017-10-04 15:27:45 -07004452 ATRACE_END();
Vidyakumar Athotaa9d3a5f2017-08-09 12:13:05 -07004453 return ret;
4454 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004455 }
Haynes Mathew George380745d2017-10-04 15:27:45 -07004456 ATRACE_END();
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004457 return bytes;
4458}
4459
4460static int out_get_render_position(const struct audio_stream_out *stream,
4461 uint32_t *dsp_frames)
4462{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004463 struct stream_out *out = (struct stream_out *)stream;
Zhou Song32a556e2015-05-05 10:46:56 +08004464
4465 if (dsp_frames == NULL)
4466 return -EINVAL;
4467
4468 *dsp_frames = 0;
4469 if (is_offload_usecase(out->usecase)) {
Mingming Yin9e348b52014-11-19 16:18:55 -08004470 ssize_t ret = 0;
Ashish Jain5106d362016-05-11 19:23:33 +05304471
4472 /* Below piece of code is not guarded against any lock beacuse audioFliner serializes
4473 * this operation and adev_close_output_stream(where out gets reset).
4474 */
Dhananjay Kumarac341582017-02-23 23:42:25 +05304475 if (!out->non_blocking && !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Ashish Jain5106d362016-05-11 19:23:33 +05304476 *dsp_frames = get_actual_pcm_frames_rendered(out);
4477 ALOGVV("dsp_frames %d sampleRate %d",(int)*dsp_frames,out->sample_rate);
Haynes Mathew Georgeb0f5dc32017-10-06 18:35:12 -07004478 adjust_frames_for_device_delay(out, dsp_frames);
Ashish Jain5106d362016-05-11 19:23:33 +05304479 return 0;
4480 }
4481
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004482 lock_output_stream(out);
Ashish Jain5106d362016-05-11 19:23:33 +05304483 if (out->compr != NULL && out->non_blocking) {
Naresh Tanniru80659832014-06-04 18:17:56 +05304484 ret = compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004485 &out->sample_rate);
Dhanalakshmi Siddani37ca1d62014-08-20 12:28:34 +05304486 if (ret < 0)
4487 ret = -errno;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004488 ALOGVV("%s rendered frames %d sample_rate %d",
Ashish Jain5106d362016-05-11 19:23:33 +05304489 __func__, *dsp_frames, out->sample_rate);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004490 }
Naresh Tanniru80659832014-06-04 18:17:56 +05304491 if (-ENETRESET == ret) {
4492 ALOGE(" ERROR: sound card not active Unable to get time stamp from compress driver");
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304493 out->card_status = CARD_STATUS_OFFLINE;
4494 ret = -EINVAL;
Naresh Tanniru80659832014-06-04 18:17:56 +05304495 } else if(ret < 0) {
4496 ALOGE(" ERROR: Unable to get time stamp from compress driver");
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304497 ret = -EINVAL;
4498 } else if (out->card_status == CARD_STATUS_OFFLINE) {
Preetam Singh Ranawat2d0e4632015-02-02 12:40:59 +05304499 /*
4500 * Handle corner case where compress session is closed during SSR
4501 * and timestamp is queried
4502 */
4503 ALOGE(" ERROR: sound card not active, return error");
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304504 ret = -EINVAL;
Naresh Tanniru80659832014-06-04 18:17:56 +05304505 } else {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304506 ret = 0;
Haynes Mathew Georgeb0f5dc32017-10-06 18:35:12 -07004507 adjust_frames_for_device_delay(out, dsp_frames);
Naresh Tanniru80659832014-06-04 18:17:56 +05304508 }
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304509 pthread_mutex_unlock(&out->lock);
4510 return ret;
Zhou Song32a556e2015-05-05 10:46:56 +08004511 } else if (audio_is_linear_pcm(out->format)) {
4512 *dsp_frames = out->written;
Haynes Mathew Georgeb0f5dc32017-10-06 18:35:12 -07004513 adjust_frames_for_device_delay(out, dsp_frames);
Zhou Song32a556e2015-05-05 10:46:56 +08004514 return 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004515 } else
4516 return -EINVAL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004517}
4518
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07004519static int out_add_audio_effect(const struct audio_stream *stream __unused,
4520 effect_handle_t effect __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004521{
4522 return 0;
4523}
4524
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07004525static int out_remove_audio_effect(const struct audio_stream *stream __unused,
4526 effect_handle_t effect __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004527{
4528 return 0;
4529}
4530
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07004531static int out_get_next_write_timestamp(const struct audio_stream_out *stream __unused,
4532 int64_t *timestamp __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004533{
Satya Krishna Pindiprolib6655542017-07-03 19:38:19 +05304534 return -ENOSYS;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004535}
4536
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07004537static int out_get_presentation_position(const struct audio_stream_out *stream,
4538 uint64_t *frames, struct timespec *timestamp)
4539{
4540 struct stream_out *out = (struct stream_out *)stream;
4541 int ret = -1;
Eric Laurent949a0892013-09-20 09:20:13 -07004542 unsigned long dsp_frames;
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07004543
Ashish Jain5106d362016-05-11 19:23:33 +05304544 /* below piece of code is not guarded against any lock because audioFliner serializes
4545 * this operation and adev_close_output_stream( where out gets reset).
4546 */
4547 if (is_offload_usecase(out->usecase) && !out->non_blocking &&
Dhananjay Kumarac341582017-02-23 23:42:25 +05304548 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Ashish Jain5106d362016-05-11 19:23:33 +05304549 *frames = get_actual_pcm_frames_rendered(out);
4550 /* this is the best we can do */
4551 clock_gettime(CLOCK_MONOTONIC, timestamp);
4552 ALOGVV("frames %lld playedat %lld",(long long int)*frames,
4553 timestamp->tv_sec * 1000000LL + timestamp->tv_nsec / 1000);
4554 return 0;
4555 }
4556
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004557 lock_output_stream(out);
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07004558
Ashish Jain5106d362016-05-11 19:23:33 +05304559 if (is_offload_usecase(out->usecase) && out->compr != NULL && out->non_blocking) {
4560 ret = compress_get_tstamp(out->compr, &dsp_frames,
4561 &out->sample_rate);
yidongh0515e042017-07-06 15:00:34 +08004562 // Adjustment accounts for A2dp encoder latency with offload usecases
4563 // Note: Encoder latency is returned in ms.
4564 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
4565 unsigned long offset =
4566 (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
4567 dsp_frames = (dsp_frames > offset) ? (dsp_frames - offset) : 0;
4568 }
Ashish Jain5106d362016-05-11 19:23:33 +05304569 ALOGVV("%s rendered frames %ld sample_rate %d",
4570 __func__, dsp_frames, out->sample_rate);
4571 *frames = dsp_frames;
4572 if (ret < 0)
4573 ret = -errno;
4574 if (-ENETRESET == ret) {
4575 ALOGE(" ERROR: sound card not active Unable to get time stamp from compress driver");
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304576 out->card_status = CARD_STATUS_OFFLINE;
Ashish Jain5106d362016-05-11 19:23:33 +05304577 ret = -EINVAL;
4578 } else
4579 ret = 0;
4580 /* this is the best we can do */
4581 clock_gettime(CLOCK_MONOTONIC, timestamp);
Eric Laurent949a0892013-09-20 09:20:13 -07004582 } else {
4583 if (out->pcm) {
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07004584 unsigned int avail;
Eric Laurent949a0892013-09-20 09:20:13 -07004585 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
4586 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
Eric Laurent949a0892013-09-20 09:20:13 -07004587 int64_t signed_frames = out->written - kernel_buffer_size + avail;
Haynes Mathew George7ff216f2013-09-11 19:51:41 -07004588 // This adjustment accounts for buffering after app processor.
4589 // It is based on estimated DSP latency per use case, rather than exact.
4590 signed_frames -=
4591 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
4592
Aniket Kumar Lataff613152017-07-18 18:19:21 -07004593 // Adjustment accounts for A2dp encoder latency with non offload usecases
4594 // Note: Encoder latency is returned in ms, while platform_render_latency in us.
4595 if (AUDIO_DEVICE_OUT_ALL_A2DP & out->devices) {
4596 signed_frames -=
4597 (audio_extn_a2dp_get_encoder_latency() * out->sample_rate / 1000);
4598 }
4599
Eric Laurent949a0892013-09-20 09:20:13 -07004600 // It would be unusual for this value to be negative, but check just in case ...
4601 if (signed_frames >= 0) {
4602 *frames = signed_frames;
4603 ret = 0;
4604 }
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07004605 }
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304606 } else if (out->card_status == CARD_STATUS_OFFLINE) {
Ashish Jainbbce4322016-02-16 13:25:27 +05304607 *frames = out->written;
4608 clock_gettime(CLOCK_MONOTONIC, timestamp);
4609 ret = 0;
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07004610 }
4611 }
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07004612 pthread_mutex_unlock(&out->lock);
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07004613 return ret;
4614}
4615
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004616static int out_set_callback(struct audio_stream_out *stream,
4617 stream_callback_t callback, void *cookie)
4618{
4619 struct stream_out *out = (struct stream_out *)stream;
Ben Rombergerd771a7c2017-02-22 18:05:17 -08004620 int ret;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004621
4622 ALOGV("%s", __func__);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004623 lock_output_stream(out);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08004624 out->client_callback = callback;
4625 out->client_cookie = cookie;
4626 if (out->adsp_hdlr_stream_handle) {
4627 ret = audio_extn_adsp_hdlr_stream_set_callback(
4628 out->adsp_hdlr_stream_handle,
4629 callback,
4630 cookie);
4631 if (ret)
4632 ALOGW("%s:adsp hdlr callback registration failed %d",
4633 __func__, ret);
4634 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004635 pthread_mutex_unlock(&out->lock);
4636 return 0;
4637}
4638
4639static int out_pause(struct audio_stream_out* stream)
4640{
4641 struct stream_out *out = (struct stream_out *)stream;
4642 int status = -ENOSYS;
4643 ALOGV("%s", __func__);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07004644 if (is_offload_usecase(out->usecase)) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07004645 ALOGD("copl(%p):pause compress driver", out);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004646 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004647 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304648 if (out->card_status != CARD_STATUS_OFFLINE)
Naresh Tanniru80659832014-06-04 18:17:56 +05304649 status = compress_pause(out->compr);
4650
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004651 out->offload_state = OFFLOAD_STATE_PAUSED;
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08004652
Mingming Yin21854652016-04-13 11:54:02 -07004653 if (audio_extn_passthru_is_active()) {
4654 ALOGV("offload use case, pause passthru");
4655 audio_extn_passthru_on_pause(out);
4656 }
4657
Dhanalakshmi Siddani79415e72015-03-23 11:54:47 +05304658 audio_extn_dts_eagle_fade(adev, false, out);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08004659 audio_extn_dts_notify_playback_state(out->usecase, 0,
4660 out->sample_rate, popcount(out->channel_mask),
4661 0);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004662 }
4663 pthread_mutex_unlock(&out->lock);
4664 }
4665 return status;
4666}
4667
4668static int out_resume(struct audio_stream_out* stream)
4669{
4670 struct stream_out *out = (struct stream_out *)stream;
4671 int status = -ENOSYS;
4672 ALOGV("%s", __func__);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07004673 if (is_offload_usecase(out->usecase)) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07004674 ALOGD("copl(%p):resume compress driver", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004675 status = 0;
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004676 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004677 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05304678 if (out->card_status != CARD_STATUS_OFFLINE) {
Naresh Tanniru80659832014-06-04 18:17:56 +05304679 status = compress_resume(out->compr);
Mingming Yin21854652016-04-13 11:54:02 -07004680 }
4681 if (!status) {
4682 out->offload_state = OFFLOAD_STATE_PLAYING;
4683 }
Dhanalakshmi Siddani79415e72015-03-23 11:54:47 +05304684 audio_extn_dts_eagle_fade(adev, true, out);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08004685 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
4686 popcount(out->channel_mask), 1);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004687 }
4688 pthread_mutex_unlock(&out->lock);
4689 }
4690 return status;
4691}
4692
4693static int out_drain(struct audio_stream_out* stream, audio_drain_type_t type )
4694{
4695 struct stream_out *out = (struct stream_out *)stream;
4696 int status = -ENOSYS;
4697 ALOGV("%s", __func__);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07004698 if (is_offload_usecase(out->usecase)) {
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004699 lock_output_stream(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004700 if (type == AUDIO_DRAIN_EARLY_NOTIFY)
4701 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
4702 else
4703 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
4704 pthread_mutex_unlock(&out->lock);
4705 }
4706 return status;
4707}
4708
4709static int out_flush(struct audio_stream_out* stream)
4710{
4711 struct stream_out *out = (struct stream_out *)stream;
4712 ALOGV("%s", __func__);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07004713 if (is_offload_usecase(out->usecase)) {
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07004714 ALOGD("copl(%p):calling compress flush", out);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004715 lock_output_stream(out);
Haynes Mathew Georgeafe54d82016-09-21 14:39:19 -07004716 if (out->offload_state == OFFLOAD_STATE_PAUSED) {
4717 stop_compressed_output_l(out);
Haynes Mathew Georgeafe54d82016-09-21 14:39:19 -07004718 } else {
4719 ALOGW("%s called in invalid state %d", __func__, out->offload_state);
4720 }
Weiyin Jiang547e4152017-09-14 17:24:18 +08004721 out->written = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004722 pthread_mutex_unlock(&out->lock);
Apoorv Raghuvanshi44bd9172014-05-28 14:50:07 -07004723 ALOGD("copl(%p):out of compress flush", out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07004724 return 0;
4725 }
4726 return -ENOSYS;
4727}
4728
Haynes Mathew George16081042017-05-31 17:16:49 -07004729static int out_stop(const struct audio_stream_out* stream)
4730{
4731 struct stream_out *out = (struct stream_out *)stream;
4732 struct audio_device *adev = out->dev;
4733 int ret = -ENOSYS;
4734
4735 ALOGV("%s", __func__);
4736 pthread_mutex_lock(&adev->lock);
4737 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP && !out->standby &&
4738 out->playback_started && out->pcm != NULL) {
4739 pcm_stop(out->pcm);
4740 ret = stop_output_stream(out);
4741 out->playback_started = false;
4742 }
4743 pthread_mutex_unlock(&adev->lock);
4744 return ret;
4745}
4746
4747static int out_start(const struct audio_stream_out* stream)
4748{
4749 struct stream_out *out = (struct stream_out *)stream;
4750 struct audio_device *adev = out->dev;
4751 int ret = -ENOSYS;
4752
4753 ALOGV("%s", __func__);
4754 pthread_mutex_lock(&adev->lock);
4755 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP && !out->standby &&
4756 !out->playback_started && out->pcm != NULL) {
4757 ret = start_output_stream(out);
4758 if (ret == 0) {
4759 out->playback_started = true;
4760 }
4761 }
4762 pthread_mutex_unlock(&adev->lock);
4763 return ret;
4764}
4765
4766/*
4767 * Modify config->period_count based on min_size_frames
4768 */
4769static void adjust_mmap_period_count(struct pcm_config *config, int32_t min_size_frames)
4770{
4771 int periodCountRequested = (min_size_frames + config->period_size - 1)
4772 / config->period_size;
4773 int periodCount = MMAP_PERIOD_COUNT_MIN;
4774
4775 ALOGV("%s original config.period_size = %d config.period_count = %d",
4776 __func__, config->period_size, config->period_count);
4777
4778 while (periodCount < periodCountRequested && (periodCount * 2) < MMAP_PERIOD_COUNT_MAX) {
4779 periodCount *= 2;
4780 }
4781 config->period_count = periodCount;
4782
4783 ALOGV("%s requested config.period_count = %d", __func__, config->period_count);
4784}
4785
4786static int out_create_mmap_buffer(const struct audio_stream_out *stream,
4787 int32_t min_size_frames,
4788 struct audio_mmap_buffer_info *info)
4789{
4790 struct stream_out *out = (struct stream_out *)stream;
4791 struct audio_device *adev = out->dev;
4792 int ret = 0;
Aalique Grahame1f123102017-10-12 10:38:32 -07004793 unsigned int offset1 = 0;
4794 unsigned int frames1 = 0;
Haynes Mathew George16081042017-05-31 17:16:49 -07004795 const char *step = "";
Haynes Mathew Georgeef514882017-05-01 17:46:23 -07004796 uint32_t mmap_size;
Haynes Mathew George16081042017-05-31 17:16:49 -07004797
4798 ALOGV("%s", __func__);
4799 pthread_mutex_lock(&adev->lock);
4800
4801 if (info == NULL || min_size_frames == 0) {
4802 ALOGE("%s: info = %p, min_size_frames = %d", __func__, info, min_size_frames);
4803 ret = -EINVAL;
4804 goto exit;
4805 }
4806 if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP || !out->standby) {
4807 ALOGE("%s: usecase = %d, standby = %d", __func__, out->usecase, out->standby);
4808 ret = -ENOSYS;
4809 goto exit;
4810 }
4811 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
4812 if (out->pcm_device_id < 0) {
4813 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
4814 __func__, out->pcm_device_id, out->usecase);
4815 ret = -EINVAL;
4816 goto exit;
4817 }
4818
4819 adjust_mmap_period_count(&out->config, min_size_frames);
4820
4821 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
4822 __func__, adev->snd_card, out->pcm_device_id, out->config.channels);
4823 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id,
4824 (PCM_OUT | PCM_MMAP | PCM_NOIRQ | PCM_MONOTONIC), &out->config);
4825 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) {
4826 step = "open";
4827 ret = -ENODEV;
4828 goto exit;
4829 }
4830 ret = pcm_mmap_begin(out->pcm, &info->shared_memory_address, &offset1, &frames1);
4831 if (ret < 0) {
4832 step = "begin";
4833 goto exit;
4834 }
4835 info->buffer_size_frames = pcm_get_buffer_size(out->pcm);
4836 info->burst_size_frames = out->config.period_size;
Haynes Mathew Georgeef514882017-05-01 17:46:23 -07004837 ret = platform_get_mmap_data_fd(adev->platform,
4838 out->pcm_device_id, 0 /*playback*/,
4839 &info->shared_memory_fd,
4840 &mmap_size);
4841 if (ret < 0) {
4842 step = "get_mmap_fd";
4843 goto exit;
4844 }
Haynes Mathew George16081042017-05-31 17:16:49 -07004845 memset(info->shared_memory_address, 0, pcm_frames_to_bytes(out->pcm,
Haynes Mathew Georgeef514882017-05-01 17:46:23 -07004846 info->buffer_size_frames));
Haynes Mathew George16081042017-05-31 17:16:49 -07004847
4848 ret = pcm_mmap_commit(out->pcm, 0, MMAP_PERIOD_SIZE);
4849 if (ret < 0) {
4850 step = "commit";
4851 goto exit;
4852 }
4853
4854 out->standby = false;
4855 ret = 0;
4856
4857 ALOGV("%s: got mmap buffer address %p info->buffer_size_frames %d",
4858 __func__, info->shared_memory_address, info->buffer_size_frames);
4859
4860exit:
4861 if (ret != 0) {
4862 if (out->pcm == NULL) {
4863 ALOGE("%s: %s - %d", __func__, step, ret);
4864 } else {
4865 ALOGE("%s: %s %s", __func__, step, pcm_get_error(out->pcm));
4866 pcm_close(out->pcm);
4867 out->pcm = NULL;
4868 }
4869 }
4870 pthread_mutex_unlock(&adev->lock);
4871 return ret;
4872}
4873
4874static int out_get_mmap_position(const struct audio_stream_out *stream,
4875 struct audio_mmap_position *position)
4876{
4877 struct stream_out *out = (struct stream_out *)stream;
4878 ALOGVV("%s", __func__);
4879 if (position == NULL) {
4880 return -EINVAL;
4881 }
4882 if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP) {
4883 return -ENOSYS;
4884 }
4885 if (out->pcm == NULL) {
4886 return -ENOSYS;
4887 }
4888
4889 struct timespec ts = { 0, 0 };
4890 int ret = pcm_mmap_get_hw_ptr(out->pcm, (unsigned int *)&position->position_frames, &ts);
4891 if (ret < 0) {
4892 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
4893 return ret;
4894 }
4895 position->time_nanoseconds = ts.tv_sec*1000000000L + ts.tv_nsec;
4896 return 0;
4897}
4898
4899
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004900/** audio_stream_in implementation **/
4901static uint32_t in_get_sample_rate(const struct audio_stream *stream)
4902{
4903 struct stream_in *in = (struct stream_in *)stream;
4904
4905 return in->config.rate;
4906}
4907
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07004908static int in_set_sample_rate(struct audio_stream *stream __unused,
4909 uint32_t rate __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004910{
4911 return -ENOSYS;
4912}
4913
4914static size_t in_get_buffer_size(const struct audio_stream *stream)
4915{
4916 struct stream_in *in = (struct stream_in *)stream;
4917
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08004918 if(in->usecase == USECASE_COMPRESS_VOIP_CALL)
4919 return voice_extn_compress_voip_in_get_buffer_size(in);
Vikram Panduranga93f080e2017-06-07 18:16:14 -07004920 else if(in->usecase == USECASE_AUDIO_RECORD_VOIP)
4921 return VOIP_IO_BUF_SIZE(in->config.rate, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE);
Mingming Yine62d7842013-10-25 16:26:03 -07004922 else if(audio_extn_compr_cap_usecase_supported(in->usecase))
4923 return audio_extn_compr_cap_get_buffer_size(in->config.format);
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05304924 else if(audio_extn_cin_attached_usecase(in->usecase))
4925 return audio_extn_cin_get_buffer_size(in);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08004926
Haynes Mathew George5beddd42016-06-27 18:33:40 -07004927 return in->config.period_size * in->af_period_multiplier *
4928 audio_stream_in_frame_size((const struct audio_stream_in *)stream);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004929}
4930
4931static uint32_t in_get_channels(const struct audio_stream *stream)
4932{
4933 struct stream_in *in = (struct stream_in *)stream;
4934
4935 return in->channel_mask;
4936}
4937
4938static audio_format_t in_get_format(const struct audio_stream *stream)
4939{
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08004940 struct stream_in *in = (struct stream_in *)stream;
4941
4942 return in->format;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004943}
4944
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07004945static int in_set_format(struct audio_stream *stream __unused,
4946 audio_format_t format __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004947{
4948 return -ENOSYS;
4949}
4950
4951static int in_standby(struct audio_stream *stream)
4952{
4953 struct stream_in *in = (struct stream_in *)stream;
4954 struct audio_device *adev = in->dev;
4955 int status = 0;
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05304956 ALOGD("%s: enter: stream (%p) usecase(%d: %s)", __func__,
4957 stream, in->usecase, use_case_table[in->usecase]);
Haynes Mathew George16081042017-05-31 17:16:49 -07004958 bool do_stop = true;
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05304959
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07004960 lock_input_stream(in);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07004961 if (!in->standby && in->is_st_session) {
4962 ALOGD("%s: sound trigger pcm stop lab", __func__);
4963 audio_extn_sound_trigger_stop_lab(in);
4964 in->standby = 1;
4965 }
4966
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004967 if (!in->standby) {
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07004968 if (adev->adm_deregister_stream)
4969 adev->adm_deregister_stream(adev->adm_data, in->capture_handle);
4970
Ravi Kumar Alamanda8bba9e92013-11-11 21:09:07 -08004971 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004972 in->standby = true;
Zhou Songa8895042016-07-05 17:54:22 +08004973 if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
kunleizbecba2d2017-09-07 13:37:16 +08004974 do_stop = false;
Zhou Songa8895042016-07-05 17:54:22 +08004975 voice_extn_compress_voip_close_input_stream(stream);
4976 ALOGD("VOIP input entered standby");
Haynes Mathew George16081042017-05-31 17:16:49 -07004977 } else if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
4978 do_stop = in->capture_started;
4979 in->capture_started = false;
Zhou Songa8895042016-07-05 17:54:22 +08004980 } else {
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05304981 if (audio_extn_cin_attached_usecase(in->usecase))
4982 audio_extn_cin_stop_input_stream(in);
kunleizbecba2d2017-09-07 13:37:16 +08004983 }
4984
4985 if (do_stop) {
Zhou Songa8895042016-07-05 17:54:22 +08004986 if (in->pcm) {
Haynes Mathew George380745d2017-10-04 15:27:45 -07004987 ATRACE_BEGIN("pcm_in_close");
Zhou Songa8895042016-07-05 17:54:22 +08004988 pcm_close(in->pcm);
Haynes Mathew George380745d2017-10-04 15:27:45 -07004989 ATRACE_END();
Zhou Songa8895042016-07-05 17:54:22 +08004990 in->pcm = NULL;
4991 }
4992 status = stop_input_stream(in);
Eric Laurent150dbfe2013-02-27 14:31:02 -08004993 }
Eric Laurent150dbfe2013-02-27 14:31:02 -08004994 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004995 }
4996 pthread_mutex_unlock(&in->lock);
Eric Laurent994a6932013-07-17 11:51:42 -07004997 ALOGV("%s: exit: status(%d)", __func__, status);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08004998 return status;
4999}
5000
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07005001static int in_dump(const struct audio_stream *stream __unused,
5002 int fd __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005003{
5004 return 0;
5005}
5006
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305007static void in_snd_mon_cb(void * stream, struct str_parms * parms)
5008{
5009 if (!stream || !parms)
5010 return;
5011
5012 struct stream_in *in = (struct stream_in *)stream;
5013 struct audio_device *adev = in->dev;
5014
5015 card_status_t status;
5016 int card;
5017 if (parse_snd_card_status(parms, &card, &status) < 0)
5018 return;
5019
5020 pthread_mutex_lock(&adev->lock);
5021 bool valid_cb = (card == adev->snd_card);
5022 pthread_mutex_unlock(&adev->lock);
5023
5024 if (!valid_cb)
5025 return;
5026
5027 lock_input_stream(in);
5028 if (in->card_status != status)
5029 in->card_status = status;
5030 pthread_mutex_unlock(&in->lock);
5031
5032 ALOGW("in_snd_mon_cb for card %d usecase %s, status %s", card,
5033 use_case_table[in->usecase],
5034 status == CARD_STATUS_OFFLINE ? "offline" : "online");
5035
5036 // a better solution would be to report error back to AF and let
5037 // it put the stream to standby
5038 if (status == CARD_STATUS_OFFLINE)
5039 in_standby(&in->stream.common);
5040
5041 return;
5042}
5043
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005044static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
5045{
5046 struct stream_in *in = (struct stream_in *)stream;
5047 struct audio_device *adev = in->dev;
5048 struct str_parms *parms;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005049 char value[32];
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08005050 int ret = 0, val = 0, err;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005051
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05305052 ALOGD("%s: enter: kvpairs=%s", __func__, kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005053 parms = str_parms_create_str(kvpairs);
5054
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05305055 if (!parms)
5056 goto error;
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005057 lock_input_stream(in);
Eric Laurent150dbfe2013-02-27 14:31:02 -08005058 pthread_mutex_lock(&adev->lock);
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08005059
5060 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
5061 if (err >= 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005062 val = atoi(value);
5063 /* no audio source uses val == 0 */
5064 if ((in->source != val) && (val != 0)) {
5065 in->source = val;
Narsinga Rao Chella2a99dea2014-01-24 15:33:23 -08005066 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) &&
5067 (in->dev->mode == AUDIO_MODE_IN_COMMUNICATION) &&
5068 (voice_extn_compress_voip_is_format_supported(in->format)) &&
Shiv Maliyappanahallie66aba22016-01-27 16:08:57 -08005069 (in->config.rate == 8000 || in->config.rate == 16000 ||
5070 in->config.rate == 32000 || in->config.rate == 48000 ) &&
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07005071 (audio_channel_count_from_in_mask(in->channel_mask) == 1)) {
Narsinga Rao Chella7d5a3e82014-02-04 16:23:52 -08005072 err = voice_extn_compress_voip_open_input_stream(in);
5073 if (err != 0) {
Narsinga Rao Chella2a99dea2014-01-24 15:33:23 -08005074 ALOGE("%s: Compress voip input cannot be opened, error:%d",
Narsinga Rao Chella7d5a3e82014-02-04 16:23:52 -08005075 __func__, err);
Narsinga Rao Chella2a99dea2014-01-24 15:33:23 -08005076 }
5077 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005078 }
5079 }
5080
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08005081 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
5082 if (err >= 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005083 val = atoi(value);
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07005084 if (((int)in->device != val) && (val != 0)) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005085 in->device = val;
5086 /* If recording is in progress, change the tx device to new device */
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005087 if (!in->standby && !in->is_st_session) {
5088 ALOGV("update input routing change");
Haynes Mathew George822b5492016-07-01 16:57:24 -07005089 if (adev->adm_on_routing_change)
5090 adev->adm_on_routing_change(adev->adm_data,
5091 in->capture_handle);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07005092 ret = select_devices(adev, in->usecase);
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005093 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005094 }
5095 }
5096
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05305097 err = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_PROFILE, value, sizeof(value));
5098 if (err >= 0) {
5099 strlcpy(in->profile, value, sizeof(in->profile));
5100 ALOGV("updating stream profile with value '%s'", in->profile);
5101 audio_extn_utils_update_stream_input_app_type_cfg(adev->platform,
5102 &adev->streams_input_cfg_list,
5103 in->device, in->flags, in->format,
5104 in->sample_rate, in->bit_width,
5105 in->profile, &in->app_type_cfg);
5106 }
5107
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005108 pthread_mutex_unlock(&adev->lock);
Eric Laurent150dbfe2013-02-27 14:31:02 -08005109 pthread_mutex_unlock(&in->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005110
5111 str_parms_destroy(parms);
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05305112error:
Eric Laurent994a6932013-07-17 11:51:42 -07005113 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005114 return ret;
5115}
5116
5117static char* in_get_parameters(const struct audio_stream *stream,
5118 const char *keys)
5119{
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08005120 struct stream_in *in = (struct stream_in *)stream;
5121 struct str_parms *query = str_parms_create_str(keys);
5122 char *str;
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08005123 struct str_parms *reply = str_parms_create();
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07005124
5125 if (!query || !reply) {
Alexy Josephaee4fdd2016-01-29 13:02:07 -08005126 if (reply) {
5127 str_parms_destroy(reply);
5128 }
5129 if (query) {
5130 str_parms_destroy(query);
5131 }
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07005132 ALOGE("in_get_parameters: failed to create query or reply");
5133 return NULL;
5134 }
5135
Haynes Mathew George484e8d22017-07-31 18:55:17 -07005136 ALOGV("%s: enter: keys - %s %s ", __func__, use_case_table[in->usecase], keys);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08005137
5138 voice_extn_in_get_parameters(in, query, reply);
5139
Haynes Mathew George484e8d22017-07-31 18:55:17 -07005140 stream_get_parameter_channels(query, reply,
5141 &in->supported_channel_masks[0]);
5142 stream_get_parameter_formats(query, reply,
5143 &in->supported_formats[0]);
5144 stream_get_parameter_rates(query, reply,
5145 &in->supported_sample_rates[0]);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08005146 str = str_parms_to_str(reply);
5147 str_parms_destroy(query);
5148 str_parms_destroy(reply);
5149
5150 ALOGV("%s: exit: returns - %s", __func__, str);
5151 return str;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005152}
5153
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07005154static int in_set_gain(struct audio_stream_in *stream __unused,
5155 float gain __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005156{
5157 return 0;
5158}
5159
5160static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
5161 size_t bytes)
5162{
5163 struct stream_in *in = (struct stream_in *)stream;
5164 struct audio_device *adev = in->dev;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05305165 int ret = -1;
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05305166 size_t bytes_read = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005167
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005168 lock_input_stream(in);
Naresh Tanniru4c630392014-05-12 01:05:52 +05305169
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07005170 if (in->is_st_session) {
5171 ALOGVV(" %s: reading on st session bytes=%zu", __func__, bytes);
5172 /* Read from sound trigger HAL */
5173 audio_extn_sound_trigger_read(in, buffer, bytes);
5174 pthread_mutex_unlock(&in->lock);
5175 return bytes;
5176 }
5177
Haynes Mathew George16081042017-05-31 17:16:49 -07005178 if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
5179 ret = -ENOSYS;
5180 goto exit;
5181 }
5182
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005183 if (in->standby) {
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07005184 pthread_mutex_lock(&adev->lock);
5185 if (in->usecase == USECASE_COMPRESS_VOIP_CALL)
5186 ret = voice_extn_compress_voip_start_input_stream(in);
5187 else
5188 ret = start_input_stream(in);
5189 pthread_mutex_unlock(&adev->lock);
5190 if (ret != 0) {
5191 goto exit;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005192 }
5193 in->standby = 0;
5194 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005195
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005196 // what's the duration requested by the client?
5197 long ns = 0;
5198
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05305199 if (in->pcm && in->config.rate)
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005200 ns = pcm_bytes_to_frames(in->pcm, bytes)*1000000000LL/
5201 in->config.rate;
5202
5203 request_in_focus(in, ns);
5204 bool use_mmap = is_mmap_usecase(in->usecase) || in->realtime;
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07005205
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05305206 if (audio_extn_cin_attached_usecase(in->usecase)) {
5207 ret = audio_extn_cin_read(in, buffer, bytes, &bytes_read);
5208 } else if (in->pcm) {
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05305209 if (audio_extn_ssr_get_stream() == in) {
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07005210 ret = audio_extn_ssr_read(stream, buffer, bytes);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05305211 } else if (audio_extn_compr_cap_usecase_supported(in->usecase)) {
Mingming Yine62d7842013-10-25 16:26:03 -07005212 ret = audio_extn_compr_cap_read(in, buffer, bytes);
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005213 } else if (use_mmap) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07005214 ret = pcm_mmap_read(in->pcm, buffer, bytes);
Garmond Leunge2433c32017-09-28 21:51:22 -07005215 } else if (audio_extn_ffv_get_stream() == in) {
5216 ret = audio_extn_ffv_read(stream, buffer, bytes);
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05305217 } else {
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07005218 ret = pcm_read(in->pcm, buffer, bytes);
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05305219 /* data from DSP comes in 24_8 format, convert it to 8_24 */
5220 if (!ret && bytes > 0 && (in->format == AUDIO_FORMAT_PCM_8_24_BIT)) {
5221 if (audio_extn_utils_convert_format_24_8_to_8_24(buffer, bytes)
5222 != bytes) {
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05305223 ret = -EINVAL;
5224 goto exit;
5225 }
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05305226 } else if (ret < 0) {
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05305227 ret = -errno;
5228 }
5229 }
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05305230 /* bytes read is always set to bytes for non compress usecases */
5231 bytes_read = bytes;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005232 }
5233
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005234 release_in_focus(in);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07005235
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005236 /*
5237 * Instead of writing zeroes here, we could trust the hardware
5238 * to always provide zeroes when muted.
5239 */
Pavan Chikkala63964842014-12-04 10:48:28 +05305240 if (ret == 0 && voice_get_mic_mute(adev) && !voice_is_in_call_rec_stream(in) &&
5241 in->usecase != USECASE_AUDIO_RECORD_AFE_PROXY)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005242 memset(buffer, 0, bytes);
5243
5244exit:
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07005245 if (-ENETRESET == ret)
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305246 in->card_status = CARD_STATUS_OFFLINE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005247 pthread_mutex_unlock(&in->lock);
5248
5249 if (ret != 0) {
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05305250 if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05305251 pthread_mutex_lock(&adev->lock);
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05305252 voice_extn_compress_voip_close_input_stream(&in->stream.common);
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05305253 pthread_mutex_unlock(&adev->lock);
Venkata Narendra Kumar Guttabc9c9ca2014-06-25 20:38:03 +05305254 in->standby = true;
5255 }
Sharad Sangled17c9122017-03-20 15:58:52 +05305256 if (!audio_extn_cin_attached_usecase(in->usecase)) {
5257 bytes_read = bytes;
5258 memset(buffer, 0, bytes);
5259 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005260 in_standby(&in->stream.common);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07005261 ALOGV("%s: read failed status %d- sleeping for buffer duration", __func__, ret);
Ashish Jainbbce4322016-02-16 13:25:27 +05305262 usleep((uint64_t)bytes * 1000000 / audio_stream_in_frame_size(stream) /
Naresh Tanniru4c630392014-05-12 01:05:52 +05305263 in_get_sample_rate(&in->stream.common));
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005264 }
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05305265 return bytes_read;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005266}
5267
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07005268static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005269{
5270 return 0;
5271}
5272
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005273static int add_remove_audio_effect(const struct audio_stream *stream,
5274 effect_handle_t effect,
5275 bool enable)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005276{
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005277 struct stream_in *in = (struct stream_in *)stream;
5278 int status = 0;
5279 effect_descriptor_t desc;
5280
5281 status = (*effect)->get_descriptor(effect, &desc);
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07005282 ALOGV("%s: status %d in->standby %d enable:%d", __func__, status, in->standby, enable);
5283
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005284 if (status != 0)
5285 return status;
5286
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005287 lock_input_stream(in);
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005288 pthread_mutex_lock(&in->dev->lock);
5289 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) &&
5290 in->enable_aec != enable &&
5291 (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) {
5292 in->enable_aec = enable;
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07005293 if (!in->standby) {
5294 if (enable_disable_effect(in->dev, EFFECT_AEC, enable) == ENOSYS)
5295 select_devices(in->dev, in->usecase);
5296 }
5297
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005298 }
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -08005299 if (in->enable_ns != enable &&
5300 (memcmp(&desc.type, FX_IID_NS, sizeof(effect_uuid_t)) == 0)) {
5301 in->enable_ns = enable;
Vikram Pandurangadf59cae2017-08-03 18:04:55 -07005302 if (!in->standby) {
5303 if (in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
5304 if (enable_disable_effect(in->dev, EFFECT_NS, enable) == ENOSYS)
5305 select_devices(in->dev, in->usecase);
5306 } else
5307 select_devices(in->dev, in->usecase);
5308 }
Ravi Kumar Alamanda198185e2013-11-07 15:42:19 -08005309 }
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005310 pthread_mutex_unlock(&in->dev->lock);
5311 pthread_mutex_unlock(&in->lock);
5312
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005313 return 0;
5314}
5315
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005316static int in_add_audio_effect(const struct audio_stream *stream,
5317 effect_handle_t effect)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005318{
Eric Laurent994a6932013-07-17 11:51:42 -07005319 ALOGV("%s: effect %p", __func__, effect);
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005320 return add_remove_audio_effect(stream, effect, true);
5321}
5322
5323static int in_remove_audio_effect(const struct audio_stream *stream,
5324 effect_handle_t effect)
5325{
Eric Laurent994a6932013-07-17 11:51:42 -07005326 ALOGV("%s: effect %p", __func__, effect);
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07005327 return add_remove_audio_effect(stream, effect, false);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005328}
5329
Haynes Mathew George16081042017-05-31 17:16:49 -07005330static int in_stop(const struct audio_stream_in* stream)
5331{
5332 struct stream_in *in = (struct stream_in *)stream;
5333 struct audio_device *adev = in->dev;
5334
5335 int ret = -ENOSYS;
5336 ALOGV("%s", __func__);
5337 pthread_mutex_lock(&adev->lock);
5338 if (in->usecase == USECASE_AUDIO_RECORD_MMAP && !in->standby &&
5339 in->capture_started && in->pcm != NULL) {
5340 pcm_stop(in->pcm);
5341 ret = stop_input_stream(in);
5342 in->capture_started = false;
5343 }
5344 pthread_mutex_unlock(&adev->lock);
5345 return ret;
5346}
5347
5348static int in_start(const struct audio_stream_in* stream)
5349{
5350 struct stream_in *in = (struct stream_in *)stream;
5351 struct audio_device *adev = in->dev;
5352 int ret = -ENOSYS;
5353
5354 ALOGV("%s in %p", __func__, in);
5355 pthread_mutex_lock(&adev->lock);
5356 if (in->usecase == USECASE_AUDIO_RECORD_MMAP && !in->standby &&
5357 !in->capture_started && in->pcm != NULL) {
5358 if (!in->capture_started) {
5359 ret = start_input_stream(in);
5360 if (ret == 0) {
5361 in->capture_started = true;
5362 }
5363 }
5364 }
5365 pthread_mutex_unlock(&adev->lock);
5366 return ret;
5367}
5368
5369static int in_create_mmap_buffer(const struct audio_stream_in *stream,
5370 int32_t min_size_frames,
5371 struct audio_mmap_buffer_info *info)
5372{
5373 struct stream_in *in = (struct stream_in *)stream;
5374 struct audio_device *adev = in->dev;
5375 int ret = 0;
Aniket Kumar Lataf9f246e2017-09-15 15:20:16 -07005376 unsigned int offset1 = 0;
5377 unsigned int frames1 = 0;
Haynes Mathew George16081042017-05-31 17:16:49 -07005378 const char *step = "";
5379
5380 pthread_mutex_lock(&adev->lock);
5381 ALOGV("%s in %p", __func__, in);
5382
5383 if (info == NULL || min_size_frames == 0) {
5384 ALOGE("%s invalid argument info %p min_size_frames %d", __func__, info, min_size_frames);
5385 ret = -EINVAL;
5386 goto exit;
5387 }
5388 if (in->usecase != USECASE_AUDIO_RECORD_MMAP || !in->standby) {
5389 ALOGE("%s: usecase = %d, standby = %d", __func__, in->usecase, in->standby);
5390 ALOGV("%s in %p", __func__, in);
5391 ret = -ENOSYS;
5392 goto exit;
5393 }
5394 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
5395 if (in->pcm_device_id < 0) {
5396 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
5397 __func__, in->pcm_device_id, in->usecase);
5398 ret = -EINVAL;
5399 goto exit;
5400 }
5401
5402 adjust_mmap_period_count(&in->config, min_size_frames);
5403
5404 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
5405 __func__, adev->snd_card, in->pcm_device_id, in->config.channels);
5406 in->pcm = pcm_open(adev->snd_card, in->pcm_device_id,
5407 (PCM_IN | PCM_MMAP | PCM_NOIRQ | PCM_MONOTONIC), &in->config);
5408 if (in->pcm == NULL || !pcm_is_ready(in->pcm)) {
5409 step = "open";
5410 ret = -ENODEV;
5411 goto exit;
5412 }
5413
5414 ret = pcm_mmap_begin(in->pcm, &info->shared_memory_address, &offset1, &frames1);
5415 if (ret < 0) {
5416 step = "begin";
5417 goto exit;
5418 }
5419 info->buffer_size_frames = pcm_get_buffer_size(in->pcm);
5420 info->burst_size_frames = in->config.period_size;
5421 info->shared_memory_fd = pcm_get_poll_fd(in->pcm);
5422
5423 memset(info->shared_memory_address, 0, pcm_frames_to_bytes(in->pcm,
5424 info->buffer_size_frames));
5425
5426 ret = pcm_mmap_commit(in->pcm, 0, MMAP_PERIOD_SIZE);
5427 if (ret < 0) {
5428 step = "commit";
5429 goto exit;
5430 }
5431
5432 in->standby = false;
5433 ret = 0;
5434
5435 ALOGV("%s: got mmap buffer address %p info->buffer_size_frames %d",
5436 __func__, info->shared_memory_address, info->buffer_size_frames);
5437
5438exit:
5439 if (ret != 0) {
5440 if (in->pcm == NULL) {
5441 ALOGE("%s: %s - %d", __func__, step, ret);
5442 } else {
5443 ALOGE("%s: %s %s", __func__, step, pcm_get_error(in->pcm));
5444 pcm_close(in->pcm);
5445 in->pcm = NULL;
5446 }
5447 }
5448 pthread_mutex_unlock(&adev->lock);
5449 return ret;
5450}
5451
5452static int in_get_mmap_position(const struct audio_stream_in *stream,
5453 struct audio_mmap_position *position)
5454{
5455 struct stream_in *in = (struct stream_in *)stream;
5456 ALOGVV("%s", __func__);
5457 if (position == NULL) {
5458 return -EINVAL;
5459 }
5460 if (in->usecase != USECASE_AUDIO_RECORD_MMAP) {
5461 return -ENOSYS;
5462 }
5463 if (in->pcm == NULL) {
5464 return -ENOSYS;
5465 }
5466 struct timespec ts = { 0, 0 };
5467 int ret = pcm_mmap_get_hw_ptr(in->pcm, (unsigned int *)&position->position_frames, &ts);
5468 if (ret < 0) {
5469 ALOGE("%s: %s", __func__, pcm_get_error(in->pcm));
5470 return ret;
5471 }
5472 position->time_nanoseconds = ts.tv_sec*1000000000L + ts.tv_nsec;
5473 return 0;
5474}
5475
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05305476int adev_open_output_stream(struct audio_hw_device *dev,
Haynes Mathew George16081042017-05-31 17:16:49 -07005477 audio_io_handle_t handle,
5478 audio_devices_t devices,
5479 audio_output_flags_t flags,
5480 struct audio_config *config,
5481 struct audio_stream_out **stream_out,
5482 const char *address __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005483{
5484 struct audio_device *adev = (struct audio_device *)dev;
5485 struct stream_out *out;
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05305486 int ret = 0;
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -07005487 audio_format_t format;
Ben Rombergerd771a7c2017-02-22 18:05:17 -08005488 struct adsp_hdlr_stream_cfg hdlr_stream_cfg;
Manish Dewangan21a850a2017-08-14 12:03:55 +05305489 bool is_direct_passthough = false;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07005490 bool is_hdmi = devices & AUDIO_DEVICE_OUT_AUX_DIGITAL;
5491 bool is_usb_dev = audio_is_usb_out_device(devices) &&
5492 (devices != AUDIO_DEVICE_OUT_USB_ACCESSORY);
5493 bool direct_dev = is_hdmi || is_usb_dev;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005494
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005495 *stream_out = NULL;
Naresh Tanniru80659832014-06-04 18:17:56 +05305496
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005497 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
5498
Mingming Yin3a941d42016-02-17 18:08:05 -08005499 ALOGD("%s: enter: format(%#x) sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)\
5500 stream_handle(%p)", __func__, config->format, config->sample_rate, config->channel_mask,
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05305501 devices, flags, &out->stream);
5502
5503
Haynes Mathew Georgeb9012ab2013-12-10 13:44:56 -08005504 if (!out) {
5505 return -ENOMEM;
5506 }
5507
Haynes Mathew George204045b2015-02-25 20:32:03 -08005508 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07005509 pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL);
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305510 pthread_mutex_init(&out->compr_mute_lock, (const pthread_mutexattr_t *) NULL);
Haynes Mathew George204045b2015-02-25 20:32:03 -08005511 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
5512
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005513 if (devices == AUDIO_DEVICE_NONE)
5514 devices = AUDIO_DEVICE_OUT_SPEAKER;
5515
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005516 out->flags = flags;
5517 out->devices = devices;
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -07005518 out->dev = adev;
Aalique Grahame65780b52017-09-27 14:59:56 -07005519 out->hal_op_format = out->hal_ip_format = format = out->format = config->format;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005520 out->sample_rate = config->sample_rate;
Sachin Mohan Gadag3d09acd2017-06-19 12:43:44 +05305521 out->channel_mask = config->channel_mask;
Ramjee Singh5857aeb2017-08-03 19:18:50 +05305522 if (out->channel_mask == AUDIO_CHANNEL_NONE)
5523 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
5524 else
5525 out->supported_channel_masks[0] = out->channel_mask;
Eric Laurentc4aef752013-09-12 17:45:53 -07005526 out->handle = handle;
Mingming Yin3ee55c62014-08-04 14:23:35 -07005527 out->bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Alexy Josephaa54c872014-12-03 02:46:47 -08005528 out->non_blocking = 0;
Ashish Jain83a6cc22016-06-28 14:34:17 +05305529 out->convert_buffer = NULL;
Ashish Jain1b9b30c2017-05-18 20:57:40 +05305530 out->started = 0;
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05305531 out->a2dp_compress_mute = false;
Aniket Kumar Lata932f4872017-11-06 18:29:44 -08005532 out->hal_output_suspend_supported = 0;
5533 out->dynamic_pm_qos_config_supported = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005534
Nikhil Laturkar26b690b2017-07-25 11:06:14 +05305535 if ((flags & AUDIO_OUTPUT_FLAG_BD) &&
Ben Romberger6c4d3812017-06-13 17:46:45 -07005536 (property_get_bool("audio.matrix.limiter.enable", false)))
5537 platform_set_device_params(out, DEVICE_PARAM_LIMITER_ID, 1);
5538
Haynes Mathew George484e8d22017-07-31 18:55:17 -07005539 if (audio_is_linear_pcm(out->format) &&
5540 out->flags == AUDIO_OUTPUT_FLAG_NONE && direct_dev) {
5541 pthread_mutex_lock(&adev->lock);
5542 if (is_hdmi) {
5543 ALOGV("AUDIO_DEVICE_OUT_AUX_DIGITAL and DIRECT|OFFLOAD, check hdmi caps");
5544 ret = read_hdmi_sink_caps(out);
5545 } else if (is_usb_dev) {
5546 ret = read_usb_sup_params_and_compare(true /*is_playback*/,
5547 &config->format,
5548 &out->supported_formats[0],
5549 MAX_SUPPORTED_FORMATS,
5550 &config->channel_mask,
5551 &out->supported_channel_masks[0],
5552 MAX_SUPPORTED_CHANNEL_MASKS,
5553 &config->sample_rate,
5554 &out->supported_sample_rates[0],
5555 MAX_SUPPORTED_SAMPLE_RATES);
5556 ALOGV("plugged dev USB ret %d", ret);
5557 } else {
5558 ret = -1;
5559 }
5560 pthread_mutex_unlock(&adev->lock);
5561 if (ret != 0) {
Mingming Yin3a941d42016-02-17 18:08:05 -08005562 if (ret == -ENOSYS) {
5563 /* ignore and go with default */
5564 ret = 0;
5565 } else {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07005566 ALOGE("error reading direct dev sink caps");
Mingming Yin3a941d42016-02-17 18:08:05 -08005567 goto error_open;
5568 }
5569 }
5570 }
5571
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005572 /* Init use case and pcm_config */
Vikram Pandurangafa3128d2017-10-16 16:57:22 -07005573#ifndef COMPRESS_VOIP_ENABLED
Vikram Panduranga93f080e2017-06-07 18:16:14 -07005574 if (out->flags == (AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_VOIP_RX) &&
5575 (out->sample_rate == 8000 || out->sample_rate == 16000 ||
5576 out->sample_rate == 32000 || out->sample_rate == 48000)) {
5577 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_MONO;
5578 out->channel_mask = AUDIO_CHANNEL_OUT_MONO;
5579 out->usecase = USECASE_AUDIO_PLAYBACK_VOIP;
5580
5581 out->config = default_pcm_config_voip_copp;
5582 out->config.period_size = VOIP_IO_BUF_SIZE(out->sample_rate, DEFAULT_VOIP_BUF_DURATION_MS, DEFAULT_VOIP_BIT_DEPTH_BYTE)/2;
5583 out->config.rate = out->sample_rate;
5584
5585#else
Preetam Singh Ranawat319b1cd2017-10-12 10:46:30 +05305586 if ((out->dev->mode == AUDIO_MODE_IN_COMMUNICATION || voice_extn_compress_voip_is_active(out->dev)) &&
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08005587 (out->flags == (AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_VOIP_RX)) &&
Narsinga Rao Chella1eceff82013-12-02 19:25:28 -08005588 (voice_extn_compress_voip_is_config_supported(config))) {
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08005589 ret = voice_extn_compress_voip_open_output_stream(out);
5590 if (ret != 0) {
5591 ALOGE("%s: Compress voip output cannot be opened, error:%d",
5592 __func__, ret);
5593 goto error_open;
5594 }
Vikram Panduranga93f080e2017-06-07 18:16:14 -07005595#endif
Haynes Mathew George484e8d22017-07-31 18:55:17 -07005596 } else if (audio_is_linear_pcm(out->format) &&
5597 out->flags == AUDIO_OUTPUT_FLAG_NONE && is_usb_dev) {
5598 out->channel_mask = config->channel_mask;
5599 out->sample_rate = config->sample_rate;
5600 out->format = config->format;
5601 out->usecase = USECASE_AUDIO_PLAYBACK_HIFI;
5602 // does this change?
5603 out->config = is_hdmi ? pcm_config_hdmi_multi : pcm_config_hifi;
5604 out->config.rate = config->sample_rate;
5605 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
5606 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels *
5607 audio_bytes_per_sample(config->format));
5608 out->config.format = pcm_format_from_audio_format(out->format);
vivek mehta0ea887a2015-08-26 14:01:20 -07005609 } else if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) ||
Dhananjay Kumarac341582017-02-23 23:42:25 +05305610 (out->flags == AUDIO_OUTPUT_FLAG_DIRECT)) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05305611 pthread_mutex_lock(&adev->lock);
5612 bool offline = (adev->card_status == CARD_STATUS_OFFLINE);
5613 pthread_mutex_unlock(&adev->lock);
5614
5615 // reject offload during card offline to allow
5616 // fallback to s/w paths
5617 if (offline) {
5618 ret = -ENODEV;
5619 goto error_open;
5620 }
vivek mehta0ea887a2015-08-26 14:01:20 -07005621
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005622 if (config->offload_info.version != AUDIO_INFO_INITIALIZER.version ||
5623 config->offload_info.size != AUDIO_INFO_INITIALIZER.size) {
5624 ALOGE("%s: Unsupported Offload information", __func__);
5625 ret = -EINVAL;
5626 goto error_open;
5627 }
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07005628
Atul Khare3fa6e542017-08-09 00:56:17 +05305629 if (config->offload_info.format == 0)
5630 config->offload_info.format = config->format;
5631 if (config->offload_info.sample_rate == 0)
5632 config->offload_info.sample_rate = config->sample_rate;
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07005633
Mingming Yin90310102013-11-13 16:57:00 -08005634 if (!is_supported_format(config->offload_info.format) &&
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305635 !audio_extn_passthru_is_supported_format(config->offload_info.format)) {
vivek mehta0ea887a2015-08-26 14:01:20 -07005636 ALOGE("%s: Unsupported audio format %x " , __func__, config->offload_info.format);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005637 ret = -EINVAL;
5638 goto error_open;
5639 }
5640
Ben Romberger0f8c87b2017-05-24 17:41:11 -07005641 /* TrueHD only supported for 48k multiples (48k, 96k, 192k) */
5642 if ((config->offload_info.format == AUDIO_FORMAT_DOLBY_TRUEHD) &&
5643 (audio_extn_passthru_is_passthrough_stream(out)) &&
5644 !((config->sample_rate == 48000) ||
5645 (config->sample_rate == 96000) ||
5646 (config->sample_rate == 192000))) {
5647 ALOGE("%s: Unsupported sample rate %d for audio format %x",
5648 __func__, config->sample_rate, config->offload_info.format);
5649 ret = -EINVAL;
5650 goto error_open;
5651 }
5652
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005653 out->compr_config.codec = (struct snd_codec *)
5654 calloc(1, sizeof(struct snd_codec));
5655
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07005656 if (!out->compr_config.codec) {
5657 ret = -ENOMEM;
5658 goto error_open;
5659 }
5660
Dhananjay Kumarac341582017-02-23 23:42:25 +05305661 out->stream.pause = out_pause;
5662 out->stream.resume = out_resume;
5663 out->stream.flush = out_flush;
Ashish Jain4847e9d2017-08-17 19:16:57 +05305664 out->stream.set_callback = out_set_callback;
Dhananjay Kumarac341582017-02-23 23:42:25 +05305665 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
Mingming Yin21d60472015-09-30 13:56:25 -07005666 out->stream.drain = out_drain;
Dhananjay Kumarac341582017-02-23 23:42:25 +05305667 out->usecase = get_offload_usecase(adev, true /* is_compress */);
vivek mehta446c3962015-09-14 10:57:35 -07005668 ALOGV("Compress Offload usecase .. usecase selected %d", out->usecase);
Dhananjay Kumarac341582017-02-23 23:42:25 +05305669 } else {
5670 out->usecase = get_offload_usecase(adev, false /* is_compress */);
5671 ALOGV("non-offload DIRECT_usecase ... usecase selected %d ", out->usecase);
vivek mehta0ea887a2015-08-26 14:01:20 -07005672 }
vivek mehta446c3962015-09-14 10:57:35 -07005673
5674 if (out->usecase == USECASE_INVALID) {
Mingming Yin3a941d42016-02-17 18:08:05 -08005675 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL &&
5676 config->format == 0 && config->sample_rate == 0 &&
5677 config->channel_mask == 0) {
Mingming Yin21854652016-04-13 11:54:02 -07005678 ALOGI("%s dummy open to query sink capability",__func__);
Mingming Yin3a941d42016-02-17 18:08:05 -08005679 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
5680 } else {
5681 ALOGE("%s, Max allowed OFFLOAD usecase reached ... ", __func__);
5682 ret = -EEXIST;
5683 goto error_open;
5684 }
vivek mehta446c3962015-09-14 10:57:35 -07005685 }
5686
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005687 if (config->offload_info.channel_mask)
5688 out->channel_mask = config->offload_info.channel_mask;
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -08005689 else if (config->channel_mask) {
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005690 out->channel_mask = config->channel_mask;
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -08005691 config->offload_info.channel_mask = config->channel_mask;
Haynes Mathew Georgea99f7532016-08-24 16:01:21 -07005692 } else {
Dhananjay Kumarac341582017-02-23 23:42:25 +05305693 ALOGE("out->channel_mask not set for OFFLOAD/DIRECT usecase");
Haynes Mathew Georgea99f7532016-08-24 16:01:21 -07005694 ret = -EINVAL;
5695 goto error_open;
ApurupaPattapuc6a3a9e2014-01-10 14:46:02 -08005696 }
Haynes Mathew Georgea99f7532016-08-24 16:01:21 -07005697
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -07005698 format = out->format = config->offload_info.format;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005699 out->sample_rate = config->offload_info.sample_rate;
5700
Mingming Yin3ee55c62014-08-04 14:23:35 -07005701 out->bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005702
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305703 out->compr_config.codec->id = get_snd_codec_id(config->offload_info.format);
Satish Babu Patakokila5933e972017-08-24 12:22:08 +05305704 if (audio_extn_utils_is_dolby_format(config->offload_info.format)) {
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305705 audio_extn_dolby_send_ddp_endp_params(adev);
5706 audio_extn_dolby_set_dmid(adev);
5707 }
vivek mehta0ea887a2015-08-26 14:01:20 -07005708
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005709 out->compr_config.codec->sample_rate =
Ravi Kumar Alamandab91bff32014-11-14 12:05:54 -08005710 config->offload_info.sample_rate;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005711 out->compr_config.codec->bit_rate =
5712 config->offload_info.bit_rate;
5713 out->compr_config.codec->ch_in =
Dhanalakshmi Siddania15c6792016-08-10 15:33:53 +05305714 audio_channel_count_from_out_mask(out->channel_mask);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005715 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
Satish Babu Patakokilaa395a9e2016-11-01 12:18:49 +05305716 /* Update bit width only for non passthrough usecases.
5717 * For passthrough usecases, the output will always be opened @16 bit
5718 */
5719 if (!audio_extn_passthru_is_passthrough_stream(out))
5720 out->bit_width = AUDIO_OUTPUT_BIT_WIDTH;
Naresh Tanniruee3499a2017-01-05 14:05:35 +05305721
5722 if (out->flags & AUDIO_OUTPUT_FLAG_TIMESTAMP)
5723 out->compr_config.codec->flags |= COMPRESSED_TIMESTAMP_FLAG;
5724 ALOGVV("%s : out->compr_config.codec->flags -> (%#x) ", __func__, out->compr_config.codec->flags);
5725
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07005726 /*TODO: Do we need to change it for passthrough */
5727 out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_RAW;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005728
Manish Dewangana6fc5442015-08-24 20:30:31 +05305729 if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC)
5730 out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_RAW;
Arun Kumar Dasari3b174182016-12-27 13:01:14 +05305731 else if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC_ADTS)
Manish Dewangana6fc5442015-08-24 20:30:31 +05305732 out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_MP4ADTS;
Arun Kumar Dasari3b174182016-12-27 13:01:14 +05305733 else if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC_LATM)
5734 out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_MP4LATM;
Ashish Jainf1eaa582016-05-23 20:54:24 +05305735
5736 if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) ==
5737 AUDIO_FORMAT_PCM) {
5738
5739 /*Based on platform support, configure appropriate alsa format for corresponding
5740 *hal input format.
5741 */
5742 out->compr_config.codec->format = hal_format_to_alsa(
5743 config->offload_info.format);
5744
Ashish Jain83a6cc22016-06-28 14:34:17 +05305745 out->hal_op_format = alsa_format_to_hal(
Ashish Jainf1eaa582016-05-23 20:54:24 +05305746 out->compr_config.codec->format);
Ashish Jain83a6cc22016-06-28 14:34:17 +05305747 out->hal_ip_format = out->format;
Ashish Jainf1eaa582016-05-23 20:54:24 +05305748
Dhananjay Kumarac341582017-02-23 23:42:25 +05305749 /*for direct non-compress playback populate bit_width based on selected alsa format as
Ashish Jainf1eaa582016-05-23 20:54:24 +05305750 *hal input format and alsa format might differ based on platform support.
5751 */
5752 out->bit_width = audio_bytes_per_sample(
Ashish Jain83a6cc22016-06-28 14:34:17 +05305753 out->hal_op_format) << 3;
Ashish Jainf1eaa582016-05-23 20:54:24 +05305754
5755 out->compr_config.fragments = DIRECT_PCM_NUM_FRAGMENTS;
5756
5757 /* Check if alsa session is configured with the same format as HAL input format,
5758 * if not then derive correct fragment size needed to accomodate the
5759 * conversion of HAL input format to alsa format.
5760 */
5761 audio_extn_utils_update_direct_pcm_fragment_size(out);
5762
5763 /*if hal input and output fragment size is different this indicates HAL input format is
5764 *not same as the alsa format
5765 */
Ashish Jain83a6cc22016-06-28 14:34:17 +05305766 if (out->hal_fragment_size != out->compr_config.fragment_size) {
Ashish Jainf1eaa582016-05-23 20:54:24 +05305767 /*Allocate a buffer to convert input data to the alsa configured format.
5768 *size of convert buffer is equal to the size required to hold one fragment size
5769 *worth of pcm data, this is because flinger does not write more than fragment_size
5770 */
Ashish Jain83a6cc22016-06-28 14:34:17 +05305771 out->convert_buffer = calloc(1,out->compr_config.fragment_size);
5772 if (out->convert_buffer == NULL){
Ashish Jainf1eaa582016-05-23 20:54:24 +05305773 ALOGE("Allocation failed for convert buffer for size %d", out->compr_config.fragment_size);
5774 ret = -ENOMEM;
5775 goto error_open;
5776 }
5777 }
5778 } else if (audio_extn_passthru_is_passthrough_stream(out)) {
5779 out->compr_config.fragment_size =
5780 audio_extn_passthru_get_buffer_size(&config->offload_info);
5781 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
5782 } else {
5783 out->compr_config.fragment_size =
5784 platform_get_compress_offload_buffer_size(&config->offload_info);
5785 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
5786 }
Mingming Yin3ee55c62014-08-04 14:23:35 -07005787
Naresh Tanniruee3499a2017-01-05 14:05:35 +05305788 if (out->flags & AUDIO_OUTPUT_FLAG_TIMESTAMP) {
5789 out->compr_config.fragment_size += sizeof(struct snd_codec_metadata);
5790 }
Amit Shekhar6f461b12014-08-01 14:52:58 -07005791 if (config->offload_info.format == AUDIO_FORMAT_FLAC)
Satya Krishna Pindiproli5d82d012015-08-12 18:21:25 +05305792 out->compr_config.codec->options.flac_dec.sample_size = AUDIO_OUTPUT_BIT_WIDTH;
Mingming Yin3ee55c62014-08-04 14:23:35 -07005793
Dhanalakshmi Siddani18737932016-11-29 17:33:17 +05305794 if (config->offload_info.format == AUDIO_FORMAT_APTX) {
5795 audio_extn_send_aptx_dec_bt_addr_to_dsp(out);
5796 }
5797
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005798 if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING)
5799 out->non_blocking = 1;
Haynes Mathew George352f27b2013-07-26 00:00:15 -07005800
Manish Dewangan69426c82017-01-30 17:35:36 +05305801 if ((flags & AUDIO_OUTPUT_FLAG_TIMESTAMP) &&
5802 (flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC)) {
5803 out->render_mode = RENDER_MODE_AUDIO_STC_MASTER;
5804 } else if(flags & AUDIO_OUTPUT_FLAG_TIMESTAMP) {
5805 out->render_mode = RENDER_MODE_AUDIO_MASTER;
5806 } else {
5807 out->render_mode = RENDER_MODE_AUDIO_NO_TIMESTAMP;
5808 }
Alexy Josephaa54c872014-12-03 02:46:47 -08005809
Naresh Tanniru29bce4e2017-04-27 17:54:30 +05305810 memset(&out->channel_map_param, 0,
5811 sizeof(struct audio_out_channel_map_param));
5812
Haynes Mathew George352f27b2013-07-26 00:00:15 -07005813 out->send_new_metadata = 1;
Chaithanya Krishna Bacharajua70cb6a2015-07-24 14:15:05 +05305814 out->send_next_track_params = false;
5815 out->is_compr_metadata_avail = false;
Haynes Mathew Georgeb9012ab2013-12-10 13:44:56 -08005816 out->offload_state = OFFLOAD_STATE_IDLE;
5817 out->playback_started = 0;
5818
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08005819 audio_extn_dts_create_state_notifier_node(out->usecase);
5820
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07005821 ALOGV("%s: offloaded output offload_info version %04x bit rate %d",
5822 __func__, config->offload_info.version,
5823 config->offload_info.bit_rate);
Ashish Jain5106d362016-05-11 19:23:33 +05305824
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05305825 /* Check if DSD audio format is supported in codec
5826 * and there is no active native DSD use case
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05305827 */
5828
5829 if ((config->format == AUDIO_FORMAT_DSD) &&
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05305830 (!platform_check_codec_dsd_support(adev->platform) ||
5831 audio_is_dsd_native_stream_active(adev))) {
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05305832 ret = -EINVAL;
5833 goto error_open;
5834 }
5835
Ashish Jain5106d362016-05-11 19:23:33 +05305836 /* Disable gapless if any of the following is true
5837 * passthrough playback
5838 * AV playback
Dhananjay Kumarac341582017-02-23 23:42:25 +05305839 * non compressed Direct playback
Ashish Jain5106d362016-05-11 19:23:33 +05305840 */
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305841 if (audio_extn_passthru_is_passthrough_stream(out) ||
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05305842 (config->format == AUDIO_FORMAT_DSD) ||
Naresh Tanniru928f0862017-04-07 16:44:23 -07005843 (config->format == AUDIO_FORMAT_IEC61937) ||
Preetam Singh Ranawatf5fbdd62016-09-29 18:38:31 +05305844 config->offload_info.has_video ||
Dhananjay Kumarac341582017-02-23 23:42:25 +05305845 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) {
Ashish Jain5106d362016-05-11 19:23:33 +05305846 check_and_set_gapless_mode(adev, false);
5847 } else
5848 check_and_set_gapless_mode(adev, true);
Mingming Yin21854652016-04-13 11:54:02 -07005849
Satish Babu Patakokila1caa1b72016-05-24 13:47:08 +05305850 if (audio_extn_passthru_is_passthrough_stream(out)) {
Mingming Yin21854652016-04-13 11:54:02 -07005851 out->flags |= AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH;
5852 }
Preetam Singh Ranawatcb6212e2016-07-19 18:33:53 +05305853 if (config->format == AUDIO_FORMAT_DSD) {
5854 out->flags |= AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH;
5855 out->compr_config.codec->compr_passthr = PASSTHROUGH_DSD;
5856 }
Aalique Grahame0359a1f2016-09-08 16:54:22 -07005857
5858 create_offload_callback_thread(out);
5859
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -07005860 } else if (out->flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) {
Satya Krishna Pindiprolif1cd92b2016-04-14 19:05:23 +05305861 ret = voice_extn_check_and_set_incall_music_usecase(adev, out);
Shiv Maliyappanahallif3b9a422013-10-22 16:38:08 -07005862 if (ret != 0) {
5863 ALOGE("%s: Incall music delivery usecase cannot be set error:%d",
5864 __func__, ret);
5865 goto error_open;
5866 }
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07005867 } else if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) {
5868 if (config->sample_rate == 0)
5869 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
5870 if (config->sample_rate != 48000 && config->sample_rate != 16000 &&
5871 config->sample_rate != 8000) {
5872 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
5873 ret = -EINVAL;
5874 goto error_open;
5875 }
5876 out->sample_rate = config->sample_rate;
5877 out->config.rate = config->sample_rate;
5878 if (config->format == AUDIO_FORMAT_DEFAULT)
5879 config->format = AUDIO_FORMAT_PCM_16_BIT;
5880 if (config->format != AUDIO_FORMAT_PCM_16_BIT) {
5881 config->format = AUDIO_FORMAT_PCM_16_BIT;
5882 ret = -EINVAL;
5883 goto error_open;
5884 }
5885 out->format = config->format;
5886 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
5887 out->config = pcm_config_afe_proxy_playback;
5888 adev->voice_tx_output = out;
Ravi Kumar Alamanda8f715d92013-11-01 20:37:38 -07005889 } else {
Ashish Jain058165c2016-09-28 23:18:48 +05305890 unsigned int channels = 0;
5891 /*Update config params to default if not set by the caller*/
5892 if (config->sample_rate == 0)
5893 config->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
5894 if (config->channel_mask == AUDIO_CHANNEL_NONE)
5895 config->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
5896 if (config->format == AUDIO_FORMAT_DEFAULT)
5897 config->format = AUDIO_FORMAT_PCM_16_BIT;
5898
5899 channels = audio_channel_count_from_out_mask(out->channel_mask);
5900
Varun Balaraje49253e2017-07-06 19:48:56 +05305901 if (out->flags & AUDIO_OUTPUT_FLAG_INTERACTIVE) {
5902 out->usecase = get_interactive_usecase(adev);
5903 out->config = pcm_config_low_latency;
5904 } else if (out->flags & AUDIO_OUTPUT_FLAG_RAW) {
Ashish Jain83a6cc22016-06-28 14:34:17 +05305905 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
Haynes Mathew George5beddd42016-06-27 18:33:40 -07005906 out->realtime = may_use_noirq_mode(adev, USECASE_AUDIO_PLAYBACK_ULL,
5907 out->flags);
5908 out->config = out->realtime ? pcm_config_rt : pcm_config_low_latency;
Haynes Mathew George16081042017-05-31 17:16:49 -07005909 } else if (out->flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
5910 out->usecase = USECASE_AUDIO_PLAYBACK_MMAP;
5911 out->config = pcm_config_mmap_playback;
5912 out->stream.start = out_start;
5913 out->stream.stop = out_stop;
5914 out->stream.create_mmap_buffer = out_create_mmap_buffer;
5915 out->stream.get_mmap_position = out_get_mmap_position;
Ashish Jain83a6cc22016-06-28 14:34:17 +05305916 } else if (out->flags & AUDIO_OUTPUT_FLAG_FAST) {
5917 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
Aniket Kumar Lata932f4872017-11-06 18:29:44 -08005918 out->hal_output_suspend_supported =
5919 property_get_bool("vendor.audio.hal.output.suspend.supported", false);
5920 out->dynamic_pm_qos_config_supported =
5921 property_get_bool("vendor.audio.hal.dynamic.qos.config.supported", false);
5922 if (!out->dynamic_pm_qos_config_supported) {
Alexy Joseph98988832017-01-13 14:56:59 -08005923 ALOGI("%s: dynamic qos voting not enabled for platform", __func__);
5924 } else {
5925 ALOGI("%s: dynamic qos voting enabled for platform", __func__);
5926 //the mixer path will be a string similar to "low-latency-playback resume"
5927 strlcpy(out->pm_qos_mixer_path, use_case_table[out->usecase], MAX_MIXER_PATH_LEN);
5928 strlcat(out->pm_qos_mixer_path,
5929 " resume", MAX_MIXER_PATH_LEN);
5930 ALOGI("%s: created %s pm_qos_mixer_path" , __func__,
5931 out->pm_qos_mixer_path);
5932 }
Ashish Jain83a6cc22016-06-28 14:34:17 +05305933 out->config = pcm_config_low_latency;
5934 } else if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
5935 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
5936 out->config = pcm_config_deep_buffer;
Ashish Jain058165c2016-09-28 23:18:48 +05305937 out->config.period_size = get_output_period_size(config->sample_rate, out->format,
5938 channels, DEEP_BUFFER_OUTPUT_PERIOD_DURATION);
5939 if (out->config.period_size <= 0) {
5940 ALOGE("Invalid configuration period size is not valid");
5941 ret = -EINVAL;
5942 goto error_open;
5943 }
Ashish Jain83a6cc22016-06-28 14:34:17 +05305944 } else {
5945 /* primary path is the default path selected if no other outputs are available/suitable */
5946 out->usecase = USECASE_AUDIO_PLAYBACK_PRIMARY;
5947 out->config = PCM_CONFIG_AUDIO_PLAYBACK_PRIMARY;
5948 }
5949 out->hal_ip_format = format = out->format;
5950 out->config.format = hal_format_to_pcm(out->hal_ip_format);
5951 out->hal_op_format = pcm_format_to_hal(out->config.format);
5952 out->bit_width = format_to_bitwidth_table[out->hal_op_format] << 3;
5953 out->config.rate = config->sample_rate;
Ravi Kumar Alamanda8f715d92013-11-01 20:37:38 -07005954 out->sample_rate = out->config.rate;
Ashish Jain058165c2016-09-28 23:18:48 +05305955 out->config.channels = channels;
Ashish Jain83a6cc22016-06-28 14:34:17 +05305956 if (out->hal_ip_format != out->hal_op_format) {
5957 uint32_t buffer_size = out->config.period_size *
5958 format_to_bitwidth_table[out->hal_op_format] *
5959 out->config.channels;
5960 out->convert_buffer = calloc(1, buffer_size);
5961 if (out->convert_buffer == NULL){
5962 ALOGE("Allocation failed for convert buffer for size %d",
5963 out->compr_config.fragment_size);
5964 ret = -ENOMEM;
5965 goto error_open;
5966 }
5967 ALOGD("Convert buffer allocated of size %d", buffer_size);
5968 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005969 }
5970
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08005971 ALOGV("%s devices:%d, format:%x, out->sample_rate:%d,out->bit_width:%d out->format:%d out->flags:%x, flags: %x usecase %d",
5972 __func__, devices, format, out->sample_rate, out->bit_width, out->format, out->flags, flags, out->usecase);
Ashish Jain83a6cc22016-06-28 14:34:17 +05305973
Pradnya Chaphekar80a8cfb2014-10-20 16:17:01 -07005974 /* TODO remove this hardcoding and check why width is zero*/
5975 if (out->bit_width == 0)
5976 out->bit_width = 16;
Dhananjay Kumard6d32152016-10-13 16:11:03 +05305977 audio_extn_utils_update_stream_output_app_type_cfg(adev->platform,
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -07005978 &adev->streams_output_cfg_list,
Aalique Grahame65780b52017-09-27 14:59:56 -07005979 devices, out->flags, out->hal_op_format, out->sample_rate,
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05305980 out->bit_width, out->channel_mask, out->profile,
Manish Dewangan837dc462015-05-27 10:17:41 +05305981 &out->app_type_cfg);
Haynes Mathew Georgebf143712013-12-03 13:02:53 -08005982 if ((out->usecase == USECASE_AUDIO_PLAYBACK_PRIMARY) ||
5983 (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
5984 /* Ensure the default output is not selected twice */
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08005985 if(adev->primary_output == NULL)
5986 adev->primary_output = out;
5987 else {
5988 ALOGE("%s: Primary output is already opened", __func__);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07005989 ret = -EEXIST;
5990 goto error_open;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08005991 }
5992 }
5993
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005994 /* Check if this usecase is already existing */
5995 pthread_mutex_lock(&adev->lock);
Narsinga Rao Chella7ce05352014-04-17 20:00:41 -07005996 if ((get_usecase_from_list(adev, out->usecase) != NULL) &&
5997 (out->usecase != USECASE_COMPRESS_VOIP_CALL)) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005998 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08005999 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07006000 ret = -EEXIST;
6001 goto error_open;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006002 }
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08006003
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006004 pthread_mutex_unlock(&adev->lock);
6005
6006 out->stream.common.get_sample_rate = out_get_sample_rate;
6007 out->stream.common.set_sample_rate = out_set_sample_rate;
6008 out->stream.common.get_buffer_size = out_get_buffer_size;
6009 out->stream.common.get_channels = out_get_channels;
6010 out->stream.common.get_format = out_get_format;
6011 out->stream.common.set_format = out_set_format;
6012 out->stream.common.standby = out_standby;
6013 out->stream.common.dump = out_dump;
6014 out->stream.common.set_parameters = out_set_parameters;
6015 out->stream.common.get_parameters = out_get_parameters;
6016 out->stream.common.add_audio_effect = out_add_audio_effect;
6017 out->stream.common.remove_audio_effect = out_remove_audio_effect;
6018 out->stream.get_latency = out_get_latency;
6019 out->stream.set_volume = out_set_volume;
6020 out->stream.write = out_write;
6021 out->stream.get_render_position = out_get_render_position;
6022 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07006023 out->stream.get_presentation_position = out_get_presentation_position;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006024
Haynes Mathew George16081042017-05-31 17:16:49 -07006025 if (out->realtime)
6026 out->af_period_multiplier = af_period_multiplier;
6027 else
6028 out->af_period_multiplier = 1;
6029
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006030 out->standby = 1;
Eric Laurenta9024de2013-04-04 09:19:12 -07006031 /* out->muted = false; by calloc() */
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07006032 /* out->written = 0; by calloc() */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006033
6034 config->format = out->stream.common.get_format(&out->stream.common);
6035 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
6036 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
6037
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306038 /*
6039 By locking output stream before registering, we allow the callback
6040 to update stream's state only after stream's initial state is set to
6041 adev state.
6042 */
6043 lock_output_stream(out);
6044 audio_extn_snd_mon_register_listener(out, out_snd_mon_cb);
6045 pthread_mutex_lock(&adev->lock);
6046 out->card_status = adev->card_status;
6047 pthread_mutex_unlock(&adev->lock);
6048 pthread_mutex_unlock(&out->lock);
6049
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006050 *stream_out = &out->stream;
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05306051 ALOGD("%s: Stream (%p) picks up usecase (%s)", __func__, &out->stream,
vivek mehta0ea887a2015-08-26 14:01:20 -07006052 use_case_table[out->usecase]);
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08006053
6054 if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
6055 audio_extn_dts_notify_playback_state(out->usecase, 0, out->sample_rate,
6056 popcount(out->channel_mask), out->playback_started);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08006057 /* setup a channel for client <--> adsp communication for stream events */
Manish Dewangan21a850a2017-08-14 12:03:55 +05306058 is_direct_passthough = audio_extn_passthru_is_direct_passthrough(out);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08006059 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) ||
Naresh Tanniru85819452017-05-04 18:55:45 -07006060 (out->flags & AUDIO_OUTPUT_FLAG_DIRECT_PCM) ||
Manish Dewangan21a850a2017-08-14 12:03:55 +05306061 (audio_extn_ip_hdlr_intf_supported(config->format, is_direct_passthough, false))) {
Ben Rombergerd771a7c2017-02-22 18:05:17 -08006062 hdlr_stream_cfg.pcm_device_id = platform_get_pcm_device_id(
6063 out->usecase, PCM_PLAYBACK);
6064 hdlr_stream_cfg.flags = out->flags;
6065 hdlr_stream_cfg.type = PCM_PLAYBACK;
6066 ret = audio_extn_adsp_hdlr_stream_open(&out->adsp_hdlr_stream_handle,
6067 &hdlr_stream_cfg);
6068 if (ret) {
6069 ALOGE("%s: adsp_hdlr_stream_open failed %d",__func__, ret);
6070 out->adsp_hdlr_stream_handle = NULL;
6071 }
6072 }
Manish Dewangan21a850a2017-08-14 12:03:55 +05306073 if (audio_extn_ip_hdlr_intf_supported(config->format, is_direct_passthough, false)) {
Vidyakumar Athota2062f912017-06-27 14:46:15 -07006074 ret = audio_extn_ip_hdlr_intf_init(&out->ip_hdlr_handle, NULL, NULL, adev, out->usecase);
Naresh Tanniru85819452017-05-04 18:55:45 -07006075 if (ret < 0) {
6076 ALOGE("%s: audio_extn_ip_hdlr_intf_init failed %d",__func__, ret);
6077 out->ip_hdlr_handle = NULL;
6078 }
6079 }
Eric Laurent994a6932013-07-17 11:51:42 -07006080 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006081 return 0;
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07006082
6083error_open:
Ashish Jain83a6cc22016-06-28 14:34:17 +05306084 if (out->convert_buffer)
6085 free(out->convert_buffer);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07006086 free(out);
6087 *stream_out = NULL;
6088 ALOGD("%s: exit: ret %d", __func__, ret);
6089 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006090}
6091
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05306092void adev_close_output_stream(struct audio_hw_device *dev __unused,
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006093 struct audio_stream_out *stream)
6094{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07006095 struct stream_out *out = (struct stream_out *)stream;
6096 struct audio_device *adev = out->dev;
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006097 int ret = 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07006098
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006099 ALOGD("%s: enter:stream_handle(%s)",__func__, use_case_table[out->usecase]);
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05306100
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306101 // must deregister from sndmonitor first to prevent races
6102 // between the callback and close_stream
6103 audio_extn_snd_mon_unregister_listener(out);
6104
Ben Rombergerd771a7c2017-02-22 18:05:17 -08006105 /* close adsp hdrl session before standby */
6106 if (out->adsp_hdlr_stream_handle) {
6107 ret = audio_extn_adsp_hdlr_stream_close(out->adsp_hdlr_stream_handle);
6108 if (ret)
6109 ALOGE("%s: adsp_hdlr_stream_close failed %d",__func__, ret);
6110 out->adsp_hdlr_stream_handle = NULL;
6111 }
6112
Manish Dewangan21a850a2017-08-14 12:03:55 +05306113 if (out->ip_hdlr_handle) {
Naresh Tanniru85819452017-05-04 18:55:45 -07006114 audio_extn_ip_hdlr_intf_deinit(out->ip_hdlr_handle);
6115 out->ip_hdlr_handle = NULL;
6116 }
6117
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006118 if (out->usecase == USECASE_COMPRESS_VOIP_CALL) {
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05306119 pthread_mutex_lock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006120 ret = voice_extn_compress_voip_close_output_stream(&stream->common);
Ashish Jain1b9b30c2017-05-18 20:57:40 +05306121 out->started = 0;
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05306122 pthread_mutex_unlock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006123 if(ret != 0)
6124 ALOGE("%s: Compress voip output cannot be closed, error:%d",
6125 __func__, ret);
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006126 } else
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006127 out_standby(&stream->common);
6128
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07006129 if (is_offload_usecase(out->usecase)) {
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08006130 audio_extn_dts_remove_state_notifier_node(out->usecase);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07006131 destroy_offload_callback_thread(out);
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07006132 free_offload_usecase(adev, out->usecase);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07006133 if (out->compr_config.codec != NULL)
6134 free(out->compr_config.codec);
6135 }
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07006136
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05306137 out->a2dp_compress_mute = false;
6138
Varun Balaraje49253e2017-07-06 19:48:56 +05306139 if (is_interactive_usecase(out->usecase))
6140 free_interactive_usecase(adev, out->usecase);
6141
Ashish Jain83a6cc22016-06-28 14:34:17 +05306142 if (out->convert_buffer != NULL) {
6143 free(out->convert_buffer);
6144 out->convert_buffer = NULL;
6145 }
6146
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07006147 if (adev->voice_tx_output == out)
6148 adev->voice_tx_output = NULL;
6149
Dhanalakshmi Siddani6c3d0992017-01-16 16:52:33 +05306150 if (adev->primary_output == out)
6151 adev->primary_output = NULL;
6152
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07006153 pthread_cond_destroy(&out->cond);
6154 pthread_mutex_destroy(&out->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006155 free(stream);
Eric Laurent994a6932013-07-17 11:51:42 -07006156 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006157}
6158
6159static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
6160{
6161 struct audio_device *adev = (struct audio_device *)dev;
6162 struct str_parms *parms;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006163 char value[32];
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07006164 int val;
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006165 int ret;
6166 int status = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006167
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08006168 ALOGD("%s: enter: %s", __func__, kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006169 parms = str_parms_create_str(kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006170
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05306171 if (!parms)
6172 goto error;
Naresh Tanniru4c630392014-05-12 01:05:52 +05306173
Ashish Jain1b9b30c2017-05-18 20:57:40 +05306174 ret = str_parms_get_str(parms, "BT_SCO", value, sizeof(value));
6175 if (ret >= 0) {
6176 /* When set to false, HAL should disable EC and NS */
6177 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
6178 adev->bt_sco_on = true;
6179 else
6180 adev->bt_sco_on = false;
6181 }
6182
Naresh Tanniru4c630392014-05-12 01:05:52 +05306183 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006184 status = voice_set_parameters(adev, parms);
6185 if (status != 0)
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08006186 goto done;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006187
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006188 status = platform_set_parameters(adev->platform, parms);
6189 if (status != 0)
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08006190 goto done;
6191
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006192 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
6193 if (ret >= 0) {
Vicky Sehrawate240e5d2014-08-12 17:17:04 -07006194 /* When set to false, HAL should disable EC and NS */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006195 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
6196 adev->bluetooth_nrec = true;
6197 else
6198 adev->bluetooth_nrec = false;
6199 }
6200
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006201 ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
6202 if (ret >= 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006203 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
6204 adev->screen_off = false;
6205 else
6206 adev->screen_off = true;
6207 }
6208
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006209 ret = str_parms_get_int(parms, "rotation", &val);
6210 if (ret >= 0) {
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07006211 bool reverse_speakers = false;
6212 switch(val) {
6213 // FIXME: note that the code below assumes that the speakers are in the correct placement
6214 // relative to the user when the device is rotated 90deg from its default rotation. This
6215 // assumption is device-specific, not platform-specific like this code.
6216 case 270:
6217 reverse_speakers = true;
6218 break;
6219 case 0:
6220 case 90:
6221 case 180:
6222 break;
6223 default:
6224 ALOGE("%s: unexpected rotation of %d", __func__, val);
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006225 status = -EINVAL;
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07006226 }
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006227 if (status == 0) {
Vignesh Kulothungan3b5fae52017-09-25 12:16:30 -07006228 // check and set swap
6229 // - check if orientation changed and speaker active
6230 // - set rotation and cache the rotation value
6231 platform_check_and_set_swap_lr_channels(adev, reverse_speakers);
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07006232 }
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07006233 }
6234
Mingming Yin514a8bc2014-07-29 15:22:21 -07006235 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_SCO_WB, value, sizeof(value));
6236 if (ret >= 0) {
6237 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
6238 adev->bt_wb_speech_enabled = true;
6239 else
6240 adev->bt_wb_speech_enabled = false;
6241 }
6242
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07006243 ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_CONNECT, value, sizeof(value));
6244 if (ret >= 0) {
6245 val = atoi(value);
Zhou Song681350a2017-10-19 16:28:42 +08006246 if (audio_is_output_device(val) &&
6247 (val & AUDIO_DEVICE_OUT_AUX_DIGITAL)) {
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07006248 ALOGV("cache new ext disp type and edid");
6249 ret = platform_get_ext_disp_type(adev->platform);
6250 if (ret < 0) {
6251 ALOGE("%s: Failed to query disp type, ret:%d", __func__, ret);
Weiyin Jiangf50ce4e2016-10-13 14:22:03 +08006252 status = ret;
6253 goto done;
Shiv Maliyappanahallic0656402016-09-03 14:13:26 -07006254 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07006255 platform_cache_edid(adev->platform);
Zhou Song6f862822017-11-06 17:27:57 +08006256 } else if (((audio_devices_t)val == AUDIO_DEVICE_OUT_USB_DEVICE) ||
6257 ((audio_devices_t)val == AUDIO_DEVICE_IN_USB_DEVICE)) {
vivek mehta344576a2016-04-12 18:56:03 -07006258 /*
6259 * Do not allow AFE proxy port usage by WFD source when USB headset is connected.
6260 * Per AudioPolicyManager, USB device is higher priority than WFD.
6261 * For Voice call over USB headset, voice call audio is routed to AFE proxy ports.
6262 * If WFD use case occupies AFE proxy, it may result unintended behavior while
6263 * starting voice call on USB
6264 */
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08006265 ret = str_parms_get_str(parms, "card", value, sizeof(value));
6266 if (ret >= 0) {
Zhou Song681350a2017-10-19 16:28:42 +08006267 if (audio_is_output_device(val))
6268 audio_extn_usb_add_device(AUDIO_DEVICE_OUT_USB_DEVICE, atoi(value));
6269 else
6270 audio_extn_usb_add_device(AUDIO_DEVICE_IN_USB_DEVICE, atoi(value));
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08006271 }
Zhou Song6f862822017-11-06 17:27:57 +08006272 if (!audio_extn_usb_is_tunnel_supported()) {
6273 ALOGV("detected USB connect .. disable proxy");
6274 adev->allow_afe_proxy_usage = false;
6275 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07006276 }
6277 }
6278
6279 ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_DISCONNECT, value, sizeof(value));
6280 if (ret >= 0) {
6281 val = atoi(value);
Garmond Leunge3b6d482016-10-25 16:48:01 -07006282 /*
6283 * The HDMI / Displayport disconnect handling has been moved to
6284 * audio extension to ensure that its parameters are not
6285 * invalidated prior to updating sysfs of the disconnect event
6286 * Invalidate will be handled by audio_extn_ext_disp_set_parameters()
6287 */
Zhou Song6f862822017-11-06 17:27:57 +08006288 if (((audio_devices_t)val == AUDIO_DEVICE_OUT_USB_DEVICE) ||
6289 ((audio_devices_t)val == AUDIO_DEVICE_IN_USB_DEVICE)) {
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08006290 ret = str_parms_get_str(parms, "card", value, sizeof(value));
6291 if (ret >= 0) {
Zhou Song681350a2017-10-19 16:28:42 +08006292 if (audio_is_output_device(val))
6293 audio_extn_usb_remove_device(AUDIO_DEVICE_OUT_USB_DEVICE, atoi(value));
6294 else
6295 audio_extn_usb_remove_device(AUDIO_DEVICE_IN_USB_DEVICE, atoi(value));
Kuirong Wanga9f7cee2016-03-07 11:21:52 -08006296 }
Zhou Song6f862822017-11-06 17:27:57 +08006297 if (!audio_extn_usb_is_tunnel_supported()) {
6298 ALOGV("detected USB disconnect .. enable proxy");
6299 adev->allow_afe_proxy_usage = true;
6300 }
Pradnya Chaphekar4403bd72014-09-09 09:50:01 -07006301 }
6302 }
6303
Naresh Tanniru9d027a62015-03-13 01:32:10 +05306304 ret = str_parms_get_str(parms,"reconfigA2dp", value, sizeof(value));
6305 if (ret >= 0) {
6306 struct audio_usecase *usecase;
6307 struct listnode *node;
6308 list_for_each(node, &adev->usecase_list) {
6309 usecase = node_to_item(node, struct audio_usecase, list);
6310 if ((usecase->type == PCM_PLAYBACK) &&
Naresh Tanniruf7e9e632016-11-04 14:54:20 -07006311 (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP)){
Naresh Tanniru9d027a62015-03-13 01:32:10 +05306312 ALOGD("reconfigure a2dp... forcing device switch");
Weiyin Jiang425180d2017-06-05 16:40:23 +08006313
6314 pthread_mutex_unlock(&adev->lock);
Naresh Tannirucd2353e2016-08-19 00:37:25 +05306315 lock_output_stream(usecase->stream.out);
Weiyin Jiang425180d2017-06-05 16:40:23 +08006316 pthread_mutex_lock(&adev->lock);
Naresh Tannirucd2353e2016-08-19 00:37:25 +05306317 audio_extn_a2dp_set_handoff_mode(true);
Naresh Tanniru9d027a62015-03-13 01:32:10 +05306318 //force device switch to re configure encoder
6319 select_devices(adev, usecase->id);
Naresh Tannirucd2353e2016-08-19 00:37:25 +05306320 audio_extn_a2dp_set_handoff_mode(false);
6321 pthread_mutex_unlock(&usecase->stream.out->lock);
Naresh Tanniru9d027a62015-03-13 01:32:10 +05306322 break;
6323 }
6324 }
6325 }
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08006326
6327 //handle vr audio setparam
6328 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VR_AUDIO_MODE,
6329 value, sizeof(value));
6330 if (ret >= 0) {
6331 ALOGI("Setting vr mode to be %s", value);
6332 if (!strncmp(value, "true", 4)) {
6333 adev->vr_audio_mode_enabled = true;
6334 ALOGI("Setting vr mode to true");
6335 } else if (!strncmp(value, "false", 5)) {
6336 adev->vr_audio_mode_enabled = false;
6337 ALOGI("Setting vr mode to false");
6338 } else {
6339 ALOGI("wrong vr mode set");
6340 }
6341 }
6342
Naresh Tannirucd2353e2016-08-19 00:37:25 +05306343 audio_extn_set_parameters(adev, parms);
Shiv Maliyappanahalli3e064fd2013-12-16 15:54:40 -08006344done:
6345 str_parms_destroy(parms);
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08006346 pthread_mutex_unlock(&adev->lock);
Preetam Singh Ranawata5f32b42014-09-23 12:12:47 +05306347error:
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006348 ALOGV("%s: exit with code(%d)", __func__, status);
6349 return status;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006350}
6351
6352static char* adev_get_parameters(const struct audio_hw_device *dev,
6353 const char *keys)
6354{
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07006355 struct audio_device *adev = (struct audio_device *)dev;
6356 struct str_parms *reply = str_parms_create();
6357 struct str_parms *query = str_parms_create_str(keys);
6358 char *str;
Naresh Tannirud7205b62014-06-20 02:54:48 +05306359 char value[256] = {0};
6360 int ret = 0;
6361
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07006362 if (!query || !reply) {
Alexy Josephaee4fdd2016-01-29 13:02:07 -08006363 if (reply) {
6364 str_parms_destroy(reply);
6365 }
6366 if (query) {
6367 str_parms_destroy(query);
6368 }
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07006369 ALOGE("adev_get_parameters: failed to create query or reply");
6370 return NULL;
6371 }
6372
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08006373 //handle vr audio getparam
6374
6375 ret = str_parms_get_str(query,
6376 AUDIO_PARAMETER_KEY_VR_AUDIO_MODE,
6377 value, sizeof(value));
6378
6379 if (ret >= 0) {
6380 bool vr_audio_enabled = false;
6381 pthread_mutex_lock(&adev->lock);
6382 vr_audio_enabled = adev->vr_audio_mode_enabled;
6383 pthread_mutex_unlock(&adev->lock);
6384
6385 ALOGI("getting vr mode to %d", vr_audio_enabled);
6386
6387 if (vr_audio_enabled) {
6388 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VR_AUDIO_MODE,
6389 "true");
6390 goto exit;
6391 } else {
6392 str_parms_add_str(reply, AUDIO_PARAMETER_KEY_VR_AUDIO_MODE,
6393 "false");
6394 goto exit;
6395 }
6396 }
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07006397
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08006398 pthread_mutex_lock(&adev->lock);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07006399 audio_extn_get_parameters(adev, query, reply);
Shiv Maliyappanahallif9308492013-12-12 12:18:09 -08006400 voice_get_parameters(adev, query, reply);
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07006401 platform_get_parameters(adev->platform, query, reply);
Naresh Tanniru80659832014-06-04 18:17:56 +05306402 pthread_mutex_unlock(&adev->lock);
6403
Naresh Tannirud7205b62014-06-20 02:54:48 +05306404exit:
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07006405 str = str_parms_to_str(reply);
6406 str_parms_destroy(query);
6407 str_parms_destroy(reply);
6408
6409 ALOGV("%s: exit: returns - %s", __func__, str);
6410 return str;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006411}
6412
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006413static int adev_init_check(const struct audio_hw_device *dev __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006414{
6415 return 0;
6416}
6417
6418static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
6419{
Haynes Mathew George5191a852013-09-11 14:19:36 -07006420 int ret;
6421 struct audio_device *adev = (struct audio_device *)dev;
6422 pthread_mutex_lock(&adev->lock);
6423 /* cache volume */
Shruthi Krishnaace10852013-10-25 14:32:12 -07006424 ret = voice_set_volume(adev, volume);
Haynes Mathew George5191a852013-09-11 14:19:36 -07006425 pthread_mutex_unlock(&adev->lock);
6426 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006427}
6428
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006429static int adev_set_master_volume(struct audio_hw_device *dev __unused,
6430 float volume __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006431{
6432 return -ENOSYS;
6433}
6434
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006435static int adev_get_master_volume(struct audio_hw_device *dev __unused,
6436 float *volume __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006437{
6438 return -ENOSYS;
6439}
6440
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006441static int adev_set_master_mute(struct audio_hw_device *dev __unused,
6442 bool muted __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006443{
6444 return -ENOSYS;
6445}
6446
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006447static int adev_get_master_mute(struct audio_hw_device *dev __unused,
6448 bool *muted __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006449{
6450 return -ENOSYS;
6451}
6452
6453static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
6454{
6455 struct audio_device *adev = (struct audio_device *)dev;
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07006456
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006457 pthread_mutex_lock(&adev->lock);
6458 if (adev->mode != mode) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07006459 ALOGD("%s: mode %d\n", __func__, mode);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006460 adev->mode = mode;
Shiv Maliyappanahallibb4cf0b2016-01-21 11:30:06 -08006461 if ((mode == AUDIO_MODE_NORMAL) && voice_is_in_call(adev)) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07006462 voice_stop_call(adev);
Banajit Goswami20cdd212015-09-11 01:11:30 -07006463 platform_set_gsm_mode(adev->platform, false);
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07006464 adev->current_call_output = NULL;
6465 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006466 }
6467 pthread_mutex_unlock(&adev->lock);
6468 return 0;
6469}
6470
6471static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
6472{
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08006473 int ret;
6474
6475 pthread_mutex_lock(&adev->lock);
Vidyakumar Athota2850d532013-11-19 16:02:12 -08006476 ALOGD("%s state %d\n", __func__, state);
Shiv Maliyappanahalli3bb73582013-11-05 12:49:15 -08006477 ret = voice_set_mic_mute((struct audio_device *)dev, state);
6478 pthread_mutex_unlock(&adev->lock);
6479
6480 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006481}
6482
6483static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
6484{
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07006485 *state = voice_get_mic_mute((struct audio_device *)dev);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006486 return 0;
6487}
6488
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006489static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev __unused,
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006490 const struct audio_config *config)
6491{
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006492 int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006493
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07006494 return get_input_buffer_size(config->sample_rate, config->format, channel_count,
6495 false /* is_low_latency: since we don't know, be conservative */);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006496}
6497
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006498static bool adev_input_allow_hifi_record(struct audio_device *adev,
6499 audio_devices_t devices,
6500 audio_input_flags_t flags,
6501 audio_source_t source) {
6502 const bool allowed = true;
6503
6504 if (!audio_is_usb_in_device(devices))
6505 return !allowed;
6506
6507 switch (flags) {
6508 case AUDIO_INPUT_FLAG_NONE:
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006509 break;
Haynes Mathew George59862182017-10-24 16:23:57 -07006510 case AUDIO_INPUT_FLAG_FAST: // disallow hifi record for FAST as
6511 // it affects RTD numbers over USB
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006512 default:
6513 return !allowed;
6514 }
6515
6516 switch (source) {
6517 case AUDIO_SOURCE_DEFAULT:
6518 case AUDIO_SOURCE_MIC:
6519 case AUDIO_SOURCE_UNPROCESSED:
6520 break;
6521 default:
6522 return !allowed;
6523 }
6524
6525 switch (adev->mode) {
6526 case 0:
6527 break;
6528 default:
6529 return !allowed;
6530 }
6531
6532 return allowed;
6533}
6534
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006535static int adev_open_input_stream(struct audio_hw_device *dev,
Bharath Ramachandramurthy76d20892015-04-27 15:47:55 -07006536 audio_io_handle_t handle,
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006537 audio_devices_t devices,
6538 struct audio_config *config,
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006539 struct audio_stream_in **stream_in,
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306540 audio_input_flags_t flags,
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006541 const char *address __unused,
Vidyakumar Athota5c398212015-03-31 21:53:21 -07006542 audio_source_t source)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006543{
6544 struct audio_device *adev = (struct audio_device *)dev;
6545 struct stream_in *in;
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08006546 int ret = 0, buffer_size, frame_size;
Ravi Kumar Alamandac3bc0812014-09-08 15:34:32 -07006547 int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07006548 bool is_low_latency = false;
Divya Narayanan Poojary45f19192016-09-30 18:52:13 +05306549 bool channel_mask_updated = false;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006550 bool is_usb_dev = audio_is_usb_in_device(devices);
6551 bool may_use_hifi_record = adev_input_allow_hifi_record(adev,
6552 devices,
6553 flags,
6554 source);
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05306555
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006556 *stream_in = NULL;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006557
6558 if (!(is_usb_dev && may_use_hifi_record)) {
6559 if (config->sample_rate == 0)
6560 config->sample_rate = 48000;
6561 if (config->channel_mask == AUDIO_CHANNEL_NONE)
6562 config->channel_mask = AUDIO_CHANNEL_IN_MONO;
6563 if (config->format == AUDIO_FORMAT_DEFAULT)
6564 config->format = AUDIO_FORMAT_PCM_16_BIT;
6565
6566 channel_count = audio_channel_count_from_in_mask(config->channel_mask);
6567
6568 if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0)
6569 return -EINVAL;
Chaithanya Krishna Bacharaju9955b162016-05-25 16:25:53 +05306570 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006571
6572 in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07006573
6574 if (!in) {
6575 ALOGE("failed to allocate input stream");
6576 return -ENOMEM;
6577 }
6578
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05306579 ALOGD("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x)\
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05306580 stream_handle(%p) io_handle(%d) source(%d) format %x",__func__, config->sample_rate,
6581 config->channel_mask, devices, &in->stream, handle, source, config->format);
Ravi Kumar Alamanda40703102014-04-24 10:34:41 -07006582 pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL);
Shiv Maliyappanahalli736d4ce2015-09-28 15:23:06 -07006583 pthread_mutex_init(&in->pre_lock, (const pthread_mutexattr_t *) NULL);
Ravi Kumar Alamanda40703102014-04-24 10:34:41 -07006584
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006585 in->stream.common.get_sample_rate = in_get_sample_rate;
6586 in->stream.common.set_sample_rate = in_set_sample_rate;
6587 in->stream.common.get_buffer_size = in_get_buffer_size;
6588 in->stream.common.get_channels = in_get_channels;
6589 in->stream.common.get_format = in_get_format;
6590 in->stream.common.set_format = in_set_format;
6591 in->stream.common.standby = in_standby;
6592 in->stream.common.dump = in_dump;
6593 in->stream.common.set_parameters = in_set_parameters;
6594 in->stream.common.get_parameters = in_get_parameters;
6595 in->stream.common.add_audio_effect = in_add_audio_effect;
6596 in->stream.common.remove_audio_effect = in_remove_audio_effect;
6597 in->stream.set_gain = in_set_gain;
6598 in->stream.read = in_read;
6599 in->stream.get_input_frames_lost = in_get_input_frames_lost;
6600
6601 in->device = devices;
Vidyakumar Athota5c398212015-03-31 21:53:21 -07006602 in->source = source;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006603 in->dev = adev;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006604 in->standby = 1;
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07006605 in->capture_handle = handle;
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07006606 in->flags = flags;
Haynes Mathew George46740472017-10-27 18:40:12 -07006607 in->bit_width = 16;
6608 in->af_period_multiplier = 1;
6609
6610 /* Update config params with the requested sample rate and channels */
6611 if ((in->device == AUDIO_DEVICE_IN_TELEPHONY_RX) &&
6612 (adev->mode != AUDIO_MODE_IN_CALL)) {
6613 ret = -EINVAL;
6614 goto err_open;
6615 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006616
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306617 /* restrict 24 bit capture for unprocessed source only
6618 * for other sources if 24 bit requested reject 24 and set 16 bit capture only
6619 */
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006620 if (is_usb_dev && may_use_hifi_record) {
6621 /* HiFi record selects an appropriate format, channel, rate combo
6622 depending on sink capabilities*/
6623 ret = read_usb_sup_params_and_compare(false /*is_playback*/,
6624 &config->format,
6625 &in->supported_formats[0],
6626 MAX_SUPPORTED_FORMATS,
6627 &config->channel_mask,
6628 &in->supported_channel_masks[0],
6629 MAX_SUPPORTED_CHANNEL_MASKS,
6630 &config->sample_rate,
6631 &in->supported_sample_rates[0],
6632 MAX_SUPPORTED_SAMPLE_RATES);
6633 if (ret != 0) {
6634 ret = -EINVAL;
6635 goto err_open;
6636 }
6637 channel_count = audio_channel_count_from_in_mask(config->channel_mask);
Haynes Mathew George46740472017-10-27 18:40:12 -07006638 }
6639
6640 if (config->format == AUDIO_FORMAT_DEFAULT) {
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306641 config->format = AUDIO_FORMAT_PCM_16_BIT;
6642 } else if ((config->format == AUDIO_FORMAT_PCM_FLOAT) ||
6643 (config->format == AUDIO_FORMAT_PCM_32_BIT) ||
6644 (config->format == AUDIO_FORMAT_PCM_24_BIT_PACKED) ||
6645 (config->format == AUDIO_FORMAT_PCM_8_24_BIT)) {
6646 bool ret_error = false;
6647 in->bit_width = 24;
6648 /* 24 bit is restricted to UNPROCESSED source only,also format supported
6649 from HAL is 24_packed and 8_24
6650 *> In case of UNPROCESSED source, for 24 bit, if format requested is other than
6651 24_packed return error indicating supported format is 24_packed
6652 *> In case of any other source requesting 24 bit or float return error
6653 indicating format supported is 16 bit only.
6654
6655 on error flinger will retry with supported format passed
6656 */
6657 if ((source != AUDIO_SOURCE_UNPROCESSED) &&
6658 (source != AUDIO_SOURCE_CAMCORDER)) {
6659 config->format = AUDIO_FORMAT_PCM_16_BIT;
6660 if (config->sample_rate > 48000)
6661 config->sample_rate = 48000;
6662 ret_error = true;
Haynes Mathew George46740472017-10-27 18:40:12 -07006663 } else if (!(config->format == AUDIO_FORMAT_PCM_24_BIT_PACKED ||
6664 config->format == AUDIO_FORMAT_PCM_8_24_BIT)) {
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306665 config->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
6666 ret_error = true;
6667 }
6668
6669 if (ret_error) {
6670 ret = -EINVAL;
6671 goto err_open;
6672 }
6673 }
6674
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006675 in->channel_mask = config->channel_mask;
6676 in->format = config->format;
6677
6678 in->usecase = USECASE_AUDIO_RECORD;
6679 if (config->sample_rate == LOW_LATENCY_CAPTURE_SAMPLE_RATE &&
6680 (flags & AUDIO_INPUT_FLAG_FAST) != 0) {
6681 is_low_latency = true;
6682#if LOW_LATENCY_CAPTURE_USE_CASE
6683 in->usecase = USECASE_AUDIO_RECORD_LOW_LATENCY;
6684#endif
6685 in->realtime = may_use_noirq_mode(adev, in->usecase, in->flags);
6686 }
6687
6688 if ((config->sample_rate == LOW_LATENCY_CAPTURE_SAMPLE_RATE) &&
6689 ((in->flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0)) {
6690 in->realtime = 0;
6691 in->usecase = USECASE_AUDIO_RECORD_MMAP;
6692 in->config = pcm_config_mmap_capture;
Haynes Mathew George46740472017-10-27 18:40:12 -07006693 in->config.format = pcm_format_from_audio_format(config->format);
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006694 in->stream.start = in_start;
6695 in->stream.stop = in_stop;
6696 in->stream.create_mmap_buffer = in_create_mmap_buffer;
6697 in->stream.get_mmap_position = in_get_mmap_position;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006698 ALOGV("%s: USECASE_AUDIO_RECORD_MMAP", __func__);
6699 } else if (in->realtime) {
6700 in->config = pcm_config_audio_capture_rt;
Haynes Mathew George46740472017-10-27 18:40:12 -07006701 in->config.format = pcm_format_from_audio_format(config->format);
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006702 in->sample_rate = in->config.rate;
6703 in->af_period_multiplier = af_period_multiplier;
Haynes Mathew George46740472017-10-27 18:40:12 -07006704 } else if (is_usb_dev && may_use_hifi_record) {
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006705 in->usecase = USECASE_AUDIO_RECORD_HIFI;
6706 in->config = pcm_config_audio_capture;
6707 frame_size = audio_stream_in_frame_size(&in->stream);
6708 buffer_size = get_input_buffer_size(config->sample_rate,
6709 config->format,
6710 channel_count,
6711 false /*is_low_latency*/);
6712 in->config.period_size = buffer_size / frame_size;
6713 in->config.rate = config->sample_rate;
Haynes Mathew George484e8d22017-07-31 18:55:17 -07006714 in->config.format = pcm_format_from_audio_format(config->format);
6715 in->config.channels = channel_count;
6716 } else if ((in->device == AUDIO_DEVICE_IN_TELEPHONY_RX) ||
Dhanalakshmi Siddani0b1488e2016-09-06 12:58:42 +05306717 (in->device == AUDIO_DEVICE_IN_PROXY)) {
Ravi Kumar Alamanda060bc5a2014-09-05 13:51:35 -07006718 if (config->sample_rate == 0)
6719 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
6720 if (config->sample_rate != 48000 && config->sample_rate != 16000 &&
6721 config->sample_rate != 8000) {
6722 config->sample_rate = AFE_PROXY_SAMPLING_RATE;
6723 ret = -EINVAL;
6724 goto err_open;
6725 }
6726 if (config->format == AUDIO_FORMAT_DEFAULT)
6727 config->format = AUDIO_FORMAT_PCM_16_BIT;
6728 if (config->format != AUDIO_FORMAT_PCM_16_BIT) {
6729 config->format = AUDIO_FORMAT_PCM_16_BIT;
6730 ret = -EINVAL;
6731 goto err_open;
6732 }
6733
6734 in->usecase = USECASE_AUDIO_RECORD_AFE_PROXY;
6735 in->config = pcm_config_afe_proxy_record;
6736 in->config.channels = channel_count;
6737 in->config.rate = config->sample_rate;
Manish Dewanganba9fcfa2016-03-24 16:20:06 +05306738 in->sample_rate = config->sample_rate;
Divya Narayanan Poojary45f19192016-09-30 18:52:13 +05306739 } else if (!audio_extn_check_and_set_multichannel_usecase(adev,
6740 in, config, &channel_mask_updated)) {
6741 if (channel_mask_updated == true) {
6742 ALOGD("%s: return error to retry with updated channel mask (%#x)",
6743 __func__, config->channel_mask);
6744 ret = -EINVAL;
6745 goto err_open;
6746 }
Garmond Leunge2433c32017-09-28 21:51:22 -07006747 ALOGD("%s: created multi-channel session succesfully",__func__);
Mingming Yine62d7842013-10-25 16:26:03 -07006748 } else if (audio_extn_compr_cap_enabled() &&
Narsinga Rao Chella2a99dea2014-01-24 15:33:23 -08006749 audio_extn_compr_cap_format_supported(config->format) &&
6750 (in->dev->mode != AUDIO_MODE_IN_COMMUNICATION)) {
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006751 audio_extn_compr_cap_init(in);
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306752 } else if (audio_extn_cin_applicable_stream(in)) {
6753 ret = audio_extn_cin_configure_input_stream(in);
6754 if (ret)
6755 goto err_open;
Haynes Mathew George46740472017-10-27 18:40:12 -07006756 } else if (in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
6757 bool valid_rate = (config->sample_rate == 8000 ||
6758 config->sample_rate == 16000 ||
6759 config->sample_rate == 32000 ||
6760 config->sample_rate == 48000);
6761 bool valid_ch = audio_channel_count_from_in_mask(in->channel_mask) == 1;
6762 //XXX needed for voice_extn_compress_voip_open_input_stream
6763 in->config.rate = config->sample_rate;
Vikram Panduranga93f080e2017-06-07 18:16:14 -07006764#ifndef COMPRESS_VOIP_ENABLED
Haynes Mathew George46740472017-10-27 18:40:12 -07006765 if (valid_rate && valid_ch) {
Vikram Panduranga93f080e2017-06-07 18:16:14 -07006766 in->usecase = USECASE_AUDIO_RECORD_VOIP;
6767 in->config = default_pcm_config_voip_copp;
Haynes Mathew George46740472017-10-27 18:40:12 -07006768 in->config.period_size = VOIP_IO_BUF_SIZE(in->sample_rate,
6769 DEFAULT_VOIP_BUF_DURATION_MS,
6770 DEFAULT_VOIP_BIT_DEPTH_BYTE)/2;
Vidyakumar Athota5c398212015-03-31 21:53:21 -07006771 }
Haynes Mathew George46740472017-10-27 18:40:12 -07006772#else
6773 if ((in->dev->mode == AUDIO_MODE_IN_COMMUNICATION ||
6774 voice_extn_compress_voip_is_active(in->dev)) &&
6775 (voice_extn_compress_voip_is_format_supported(in->format)) &&
6776 valid_rate && valid_ch) {
6777 voice_extn_compress_voip_open_input_stream(in);
6778 }
6779#endif
6780 else {
6781 ALOGE("%s AUDIO_SOURCE_VOICE_COMMUNICATION invalid args", __func__);
6782 ret = -EINVAL;
6783 if (!valid_ch) config->channel_mask = 1;
6784 if (!valid_rate) config->sample_rate = 48000;
6785 goto err_open;
6786 }
6787 // update back to whatever was overwritten
6788 in->config.rate = config->sample_rate;
6789 in->sample_rate = config->sample_rate;
6790 } else {
6791 in->config = pcm_config_audio_capture;
6792 in->config.rate = config->sample_rate;
6793 in->config.format = pcm_format_from_audio_format(config->format);
6794 in->config.channels = channel_count;
6795 in->sample_rate = config->sample_rate;
6796 in->format = config->format;
6797 frame_size = audio_stream_in_frame_size(&in->stream);
6798 buffer_size = get_input_buffer_size(config->sample_rate,
6799 config->format,
6800 channel_count,
6801 is_low_latency);
6802 in->config.period_size = buffer_size / frame_size;
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07006803 }
Dhananjay Kumard6d32152016-10-13 16:11:03 +05306804 audio_extn_utils_update_stream_input_app_type_cfg(adev->platform,
6805 &adev->streams_input_cfg_list,
6806 devices, flags, in->format, in->sample_rate,
Dhananjay Kumar4d91c1a2016-12-01 23:27:29 +05306807 in->bit_width, in->profile, &in->app_type_cfg);
Dhananjay Kumard6d32152016-10-13 16:11:03 +05306808
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07006809 /* This stream could be for sound trigger lab,
6810 get sound trigger pcm if present */
6811 audio_extn_sound_trigger_check_and_get_session(in);
6812
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306813 lock_input_stream(in);
6814 audio_extn_snd_mon_register_listener(in, in_snd_mon_cb);
6815 pthread_mutex_lock(&adev->lock);
6816 in->card_status = adev->card_status;
6817 pthread_mutex_unlock(&adev->lock);
6818 pthread_mutex_unlock(&in->lock);
6819
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006820 *stream_in = &in->stream;
Eric Laurent994a6932013-07-17 11:51:42 -07006821 ALOGV("%s: exit", __func__);
Ravi Kumar Alamandafae42112013-11-07 23:31:54 -08006822 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006823
6824err_open:
6825 free(in);
6826 *stream_in = NULL;
6827 return ret;
6828}
6829
6830static void adev_close_input_stream(struct audio_hw_device *dev,
6831 struct audio_stream_in *stream)
6832{
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006833 int ret;
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07006834 struct stream_in *in = (struct stream_in *)stream;
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006835 struct audio_device *adev = (struct audio_device *)dev;
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05306836
Sidipotu Ashokf43018c2014-05-02 16:21:50 +05306837 ALOGD("%s: enter:stream_handle(%p)",__func__, in);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08006838
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306839 // must deregister from sndmonitor first to prevent races
6840 // between the callback and close_stream
6841 audio_extn_snd_mon_unregister_listener(stream);
6842
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +05306843 /* Disable echo reference while closing input stream */
Apoorv Raghuvanshi924b3022015-07-06 15:07:14 -07006844 platform_set_echo_reference(adev, false, AUDIO_DEVICE_NONE);
Venkata Narendra Kumar Gutta1bbbf542014-09-04 19:11:25 +05306845
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006846 if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05306847 pthread_mutex_lock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006848 ret = voice_extn_compress_voip_close_input_stream(&stream->common);
Venkata Narendra Kumar Gutta91812142014-08-11 18:20:49 +05306849 pthread_mutex_unlock(&adev->lock);
Narsinga Rao Chella05573b72013-11-15 15:21:40 -08006850 if (ret != 0)
6851 ALOGE("%s: Compress voip input cannot be closed, error:%d",
6852 __func__, ret);
6853 } else
6854 in_standby(&stream->common);
6855
Shiv Maliyappanahalli5a10aea2015-07-02 10:36:23 -07006856 if (audio_extn_ssr_get_stream() == in) {
Apoorv Raghuvanshi6178a3f2013-10-19 12:38:54 -07006857 audio_extn_ssr_deinit();
6858 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006859
Garmond Leunge2433c32017-09-28 21:51:22 -07006860 if (audio_extn_ffv_get_stream() == in) {
6861 audio_extn_ffv_stream_deinit();
6862 }
6863
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306864 if (audio_extn_compr_cap_enabled() &&
Mingming Yine62d7842013-10-25 16:26:03 -07006865 audio_extn_compr_cap_format_supported(in->config.format))
6866 audio_extn_compr_cap_deinit();
Dhanalakshmi Siddani74cf00b2016-12-02 13:55:57 +05306867
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306868 if (audio_extn_cin_attached_usecase(in->usecase))
6869 audio_extn_cin_close_input_stream(in);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07006870
Mingming Yinfd7607b2016-01-22 12:48:44 -08006871 if (in->is_st_session) {
6872 ALOGV("%s: sound trigger pcm stop lab", __func__);
6873 audio_extn_sound_trigger_stop_lab(in);
6874 }
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07006875 free(stream);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006876 return;
6877}
6878
Siddartha Shaik31b530e2017-05-19 15:26:33 +05306879int adev_create_audio_patch(struct audio_hw_device *dev,
6880 unsigned int num_sources,
6881 const struct audio_port_config *sources,
6882 unsigned int num_sinks,
6883 const struct audio_port_config *sinks,
6884 audio_patch_handle_t *handle)
6885{
6886
6887
6888 return audio_extn_hw_loopback_create_audio_patch(dev,
6889 num_sources,
6890 sources,
6891 num_sinks,
6892 sinks,
6893 handle);
6894
6895}
6896
6897int adev_release_audio_patch(struct audio_hw_device *dev,
6898 audio_patch_handle_t handle)
6899{
6900 return audio_extn_hw_loopback_release_audio_patch(dev, handle);
6901}
6902
6903int adev_get_audio_port(struct audio_hw_device *dev, struct audio_port *config)
6904{
6905 return audio_extn_hw_loopback_get_audio_port(dev, config);
6906}
6907
6908int adev_set_audio_port_config(struct audio_hw_device *dev,
6909 const struct audio_port_config *config)
6910{
6911 return audio_extn_hw_loopback_set_audio_port_config(dev, config);
6912}
6913
Ravi Kumar Alamandabdf14162014-09-05 16:14:17 -07006914static int adev_dump(const audio_hw_device_t *device __unused,
6915 int fd __unused)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006916{
6917 return 0;
6918}
6919
6920static int adev_close(hw_device_t *device)
6921{
6922 struct audio_device *adev = (struct audio_device *)device;
Kiran Kandi910e1862013-10-29 13:29:42 -07006923
6924 if (!adev)
6925 return 0;
6926
6927 pthread_mutex_lock(&adev_init_lock);
6928
6929 if ((--audio_device_ref_count) == 0) {
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306930 audio_extn_snd_mon_unregister_listener(adev);
Ravi Kumar Alamanda8fa6b192014-09-09 16:06:42 -07006931 audio_extn_sound_trigger_deinit(adev);
Kiran Kandide144c82013-11-20 15:58:32 -08006932 audio_extn_listen_deinit(adev);
Dhananjay Kumard6d32152016-10-13 16:11:03 +05306933 audio_extn_utils_release_streams_cfg_lists(
6934 &adev->streams_output_cfg_list,
6935 &adev->streams_input_cfg_list);
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05306936 if (audio_extn_qaf_is_enabled())
6937 audio_extn_qaf_deinit();
Kiran Kandi910e1862013-10-29 13:29:42 -07006938 audio_route_free(adev->audio_route);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +08006939 audio_extn_gef_deinit();
Kiran Kandi910e1862013-10-29 13:29:42 -07006940 free(adev->snd_dev_ref_cnt);
6941 platform_deinit(adev->platform);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07006942 if (adev->adm_deinit)
6943 adev->adm_deinit(adev->adm_data);
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05306944 qahwi_deinit(device);
Ben Rombergerd771a7c2017-02-22 18:05:17 -08006945 audio_extn_adsp_hdlr_deinit();
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306946 audio_extn_snd_mon_deinit();
Siddartha Shaik44dd7702017-06-14 12:13:25 +05306947 audio_extn_hw_loopback_deinit(adev);
Garmond Leunge2433c32017-09-28 21:51:22 -07006948 audio_extn_ffv_deinit();
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +05306949 if (adev->device_cfg_params) {
6950 free(adev->device_cfg_params);
6951 adev->device_cfg_params = NULL;
6952 }
Kiran Kandi910e1862013-10-29 13:29:42 -07006953 free(device);
6954 adev = NULL;
6955 }
6956 pthread_mutex_unlock(&adev_init_lock);
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07006957
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08006958 return 0;
6959}
6960
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07006961/* This returns 1 if the input parameter looks at all plausible as a low latency period size,
6962 * or 0 otherwise. A return value of 1 doesn't mean the value is guaranteed to work,
6963 * just that it _might_ work.
6964 */
6965static int period_size_is_plausible_for_low_latency(int period_size)
6966{
6967 switch (period_size) {
6968 case 160:
Ravi Kumar Alamanda474de5a2015-06-25 20:08:01 -07006969 case 192:
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07006970 case 240:
6971 case 320:
6972 case 480:
6973 return 1;
6974 default:
6975 return 0;
6976 }
6977}
6978
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05306979static void adev_snd_mon_cb(void *cookie, struct str_parms *parms)
6980{
6981 bool is_snd_card_status = false;
6982 bool is_ext_device_status = false;
6983 char value[32];
6984 int card = -1;
6985 card_status_t status;
6986
6987 if (cookie != adev || !parms)
6988 return;
6989
6990 if (!parse_snd_card_status(parms, &card, &status)) {
6991 is_snd_card_status = true;
6992 } else if (0 < str_parms_get_str(parms, "ext_audio_device", value, sizeof(value))) {
6993 is_ext_device_status = true;
6994 } else {
6995 // not a valid event
6996 return;
6997 }
6998
6999 pthread_mutex_lock(&adev->lock);
7000 if (card == adev->snd_card || is_ext_device_status) {
7001 if (is_snd_card_status && adev->card_status != status) {
7002 adev->card_status = status;
7003 platform_snd_card_update(adev->platform, status);
7004 audio_extn_fm_set_parameters(adev, parms);
7005 } else if (is_ext_device_status) {
7006 platform_set_parameters(adev->platform, parms);
7007 }
7008 }
7009 pthread_mutex_unlock(&adev->lock);
7010 return;
7011}
7012
Chaithanya Krishna Bacharaju69d2e4c2017-05-26 18:22:46 +05307013/* out and adev lock held */
7014static int check_a2dp_restore_l(struct audio_device *adev, struct stream_out *out, bool restore)
7015{
7016 struct audio_usecase *uc_info;
7017 float left_p;
7018 float right_p;
7019 audio_devices_t devices;
7020
7021 uc_info = get_usecase_from_list(adev, out->usecase);
7022 if (uc_info == NULL) {
7023 ALOGE("%s: Could not find the usecase (%d) in the list",
7024 __func__, out->usecase);
7025 return -EINVAL;
7026 }
7027
7028 ALOGD("%s: enter: usecase(%d: %s)", __func__,
7029 out->usecase, use_case_table[out->usecase]);
7030
7031 if (restore) {
7032 // restore A2DP device for active usecases and unmute if required
7033 if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
7034 (uc_info->out_snd_device != SND_DEVICE_OUT_BT_A2DP)) {
7035 ALOGD("%s: restoring A2dp and unmuting stream", __func__);
7036 select_devices(adev, uc_info->id);
7037 pthread_mutex_lock(&out->compr_mute_lock);
7038 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
7039 (out->a2dp_compress_mute)) {
7040 out->a2dp_compress_mute = false;
7041 out_set_compr_volume(&out->stream, out->volume_l, out->volume_r);
7042 }
7043 pthread_mutex_unlock(&out->compr_mute_lock);
7044 }
7045 } else {
7046 // mute compress stream if suspended
7047 pthread_mutex_lock(&out->compr_mute_lock);
7048 if ((out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
7049 (!out->a2dp_compress_mute)) {
7050 if (!out->standby) {
7051 ALOGD("%s: selecting speaker and muting stream", __func__);
7052 devices = out->devices;
7053 out->devices = AUDIO_DEVICE_OUT_SPEAKER;
7054 left_p = out->volume_l;
7055 right_p = out->volume_r;
7056 if (out->offload_state == OFFLOAD_STATE_PLAYING)
7057 compress_pause(out->compr);
7058 out_set_compr_volume(&out->stream, (float)0, (float)0);
7059 out->a2dp_compress_mute = true;
7060 select_devices(adev, out->usecase);
7061 if (out->offload_state == OFFLOAD_STATE_PLAYING)
7062 compress_resume(out->compr);
7063 out->devices = devices;
7064 out->volume_l = left_p;
7065 out->volume_r = right_p;
7066 }
7067 }
7068 pthread_mutex_unlock(&out->compr_mute_lock);
7069 }
7070 ALOGV("%s: exit", __func__);
7071 return 0;
7072}
7073
7074int check_a2dp_restore(struct audio_device *adev, struct stream_out *out, bool restore)
7075{
7076 int ret = 0;
7077
7078 lock_output_stream(out);
7079 pthread_mutex_lock(&adev->lock);
7080
7081 ret = check_a2dp_restore_l(adev, out, restore);
7082
7083 pthread_mutex_unlock(&adev->lock);
7084 pthread_mutex_unlock(&out->lock);
7085 return ret;
7086}
7087
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007088static int adev_open(const hw_module_t *module, const char *name,
7089 hw_device_t **device)
7090{
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05307091 int ret;
7092
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08007093 ALOGD("%s: enter", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007094 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL;
7095
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07007096 pthread_mutex_lock(&adev_init_lock);
Kiran Kandi910e1862013-10-29 13:29:42 -07007097 if (audio_device_ref_count != 0){
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07007098 *device = &adev->device.common;
Kiran Kandi910e1862013-10-29 13:29:42 -07007099 audio_device_ref_count++;
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07007100 ALOGD("%s: returning existing instance of adev", __func__);
7101 ALOGD("%s: exit", __func__);
7102 pthread_mutex_unlock(&adev_init_lock);
7103 return 0;
7104 }
7105
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007106 adev = calloc(1, sizeof(struct audio_device));
7107
Haynes Mathew Georgeb51ceb12014-06-30 13:56:18 -07007108 if (!adev) {
7109 pthread_mutex_unlock(&adev_init_lock);
7110 return -ENOMEM;
7111 }
7112
Ravi Kumar Alamanda40703102014-04-24 10:34:41 -07007113 pthread_mutex_init(&adev->lock, (const pthread_mutexattr_t *) NULL);
7114
Revathi Uddaraju1eac8b02017-05-18 17:13:33 +05307115#ifdef DYNAMIC_LOG_ENABLED
7116 register_for_dynamic_logging("hal");
7117#endif
7118
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007119 adev->device.common.tag = HARDWARE_DEVICE_TAG;
7120 adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
7121 adev->device.common.module = (struct hw_module_t *)module;
7122 adev->device.common.close = adev_close;
7123
7124 adev->device.init_check = adev_init_check;
7125 adev->device.set_voice_volume = adev_set_voice_volume;
7126 adev->device.set_master_volume = adev_set_master_volume;
7127 adev->device.get_master_volume = adev_get_master_volume;
7128 adev->device.set_master_mute = adev_set_master_mute;
7129 adev->device.get_master_mute = adev_get_master_mute;
7130 adev->device.set_mode = adev_set_mode;
7131 adev->device.set_mic_mute = adev_set_mic_mute;
7132 adev->device.get_mic_mute = adev_get_mic_mute;
7133 adev->device.set_parameters = adev_set_parameters;
7134 adev->device.get_parameters = adev_get_parameters;
7135 adev->device.get_input_buffer_size = adev_get_input_buffer_size;
7136 adev->device.open_output_stream = adev_open_output_stream;
7137 adev->device.close_output_stream = adev_close_output_stream;
7138 adev->device.open_input_stream = adev_open_input_stream;
7139 adev->device.close_input_stream = adev_close_input_stream;
Siddartha Shaik31b530e2017-05-19 15:26:33 +05307140 adev->device.create_audio_patch = adev_create_audio_patch;
7141 adev->device.release_audio_patch = adev_release_audio_patch;
7142 adev->device.get_audio_port = adev_get_audio_port;
7143 adev->device.set_audio_port_config = adev_set_audio_port_config;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007144 adev->device.dump = adev_dump;
7145
7146 /* Set the default route before the PCM stream is opened */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007147 adev->mode = AUDIO_MODE_NORMAL;
Eric Laurentc8400632013-02-14 19:04:54 -08007148 adev->active_input = NULL;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08007149 adev->primary_output = NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007150 adev->out_device = AUDIO_DEVICE_NONE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007151 adev->bluetooth_nrec = true;
Ravi Kumar Alamandaf9967042013-02-14 19:35:14 -08007152 adev->acdb_settings = TTY_MODE_OFF;
vivek mehta344576a2016-04-12 18:56:03 -07007153 adev->allow_afe_proxy_usage = true;
Ashish Jain1b9b30c2017-05-18 20:57:40 +05307154 adev->bt_sco_on = false;
Eric Laurent07eeafd2013-10-06 12:52:49 -07007155 /* adev->cur_hdmi_channels = 0; by calloc() */
Eric Laurentb23d5282013-05-14 15:27:20 -07007156 adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int));
Shiv Maliyappanahalli34b585f2013-10-01 15:49:05 -07007157 voice_init(adev);
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08007158 list_init(&adev->usecase_list);
Krishnankutty Kolathappilly0b2de1c2014-02-14 14:45:49 -08007159 adev->cur_wfd_channels = 2;
Subhash Chandra Bose Naripeddy16ff4f82014-04-01 21:03:10 -07007160 adev->offload_usecases_state = 0;
Ashish Jain81eb2a82015-05-13 10:52:34 +05307161 adev->is_channel_status_set = false;
Sudheer Papothifa9d2282015-09-17 01:53:25 +05307162 adev->perf_lock_opts[0] = 0x101;
7163 adev->perf_lock_opts[1] = 0x20E;
7164 adev->perf_lock_opts_size = 2;
Xiaojun Sang785b5da2017-08-03 15:52:29 +08007165 adev->dsp_bit_width_enforce_mode = 0;
Naresh Tanniru4c630392014-05-12 01:05:52 +05307166
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007167 /* Loads platform specific libraries dynamically */
Eric Laurentb23d5282013-05-14 15:27:20 -07007168 adev->platform = platform_init(adev);
7169 if (!adev->platform) {
7170 free(adev->snd_dev_ref_cnt);
7171 free(adev);
7172 ALOGE("%s: Failed to init platform data, aborting.", __func__);
7173 *device = NULL;
Apoorv Raghuvanshi6e57d7e2013-12-16 16:02:45 -08007174 pthread_mutex_unlock(&adev_init_lock);
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05307175 pthread_mutex_destroy(&adev->lock);
Eric Laurentb23d5282013-05-14 15:27:20 -07007176 return -EINVAL;
7177 }
Eric Laurentc4aef752013-09-12 17:45:53 -07007178
Lakshman Chaluvaraju22ba9f12016-09-12 11:42:10 +05307179 if (audio_extn_qaf_is_enabled()) {
7180 ret = audio_extn_qaf_init(adev);
7181 if (ret < 0) {
7182 free(adev);
7183 ALOGE("%s: Failed to init platform data, aborting.", __func__);
7184 *device = NULL;
7185 pthread_mutex_unlock(&adev_init_lock);
7186 pthread_mutex_destroy(&adev->lock);
7187 return ret;
7188 }
7189
7190 adev->device.open_output_stream = audio_extn_qaf_open_output_stream;
7191 adev->device.close_output_stream = audio_extn_qaf_close_output_stream;
7192 }
7193
Eric Laurentc4aef752013-09-12 17:45:53 -07007194 if (access(VISUALIZER_LIBRARY_PATH, R_OK) == 0) {
7195 adev->visualizer_lib = dlopen(VISUALIZER_LIBRARY_PATH, RTLD_NOW);
7196 if (adev->visualizer_lib == NULL) {
7197 ALOGE("%s: DLOPEN failed for %s", __func__, VISUALIZER_LIBRARY_PATH);
7198 } else {
7199 ALOGV("%s: DLOPEN successful for %s", __func__, VISUALIZER_LIBRARY_PATH);
7200 adev->visualizer_start_output =
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08007201 (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib,
Eric Laurentc4aef752013-09-12 17:45:53 -07007202 "visualizer_hal_start_output");
7203 adev->visualizer_stop_output =
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08007204 (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib,
Eric Laurentc4aef752013-09-12 17:45:53 -07007205 "visualizer_hal_stop_output");
7206 }
7207 }
Dhanalakshmi Siddani21be3ac2016-12-29 14:31:08 +05307208 audio_extn_init(adev);
Apoorv Raghuvanshi84fa2fe2013-12-04 11:57:47 -08007209 audio_extn_listen_init(adev, adev->snd_card);
Weiyin Jiangaa80acd2016-09-21 16:42:11 +08007210 audio_extn_gef_init(adev);
Siddartha Shaik44dd7702017-06-14 12:13:25 +05307211 audio_extn_hw_loopback_init(adev);
Garmond Leunge2433c32017-09-28 21:51:22 -07007212 audio_extn_ffv_init(adev);
Eric Laurentc4aef752013-09-12 17:45:53 -07007213
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08007214 if (access(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, R_OK) == 0) {
7215 adev->offload_effects_lib = dlopen(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, RTLD_NOW);
7216 if (adev->offload_effects_lib == NULL) {
7217 ALOGE("%s: DLOPEN failed for %s", __func__,
7218 OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH);
7219 } else {
7220 ALOGV("%s: DLOPEN successful for %s", __func__,
7221 OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH);
7222 adev->offload_effects_start_output =
Ashish Jain5106d362016-05-11 19:23:33 +05307223 (int (*)(audio_io_handle_t, int, struct mixer *))dlsym(adev->offload_effects_lib,
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08007224 "offload_effects_bundle_hal_start_output");
7225 adev->offload_effects_stop_output =
7226 (int (*)(audio_io_handle_t, int))dlsym(adev->offload_effects_lib,
7227 "offload_effects_bundle_hal_stop_output");
Jitendra Naruka1b6513f2014-11-22 19:34:13 -08007228 adev->offload_effects_set_hpx_state =
7229 (int (*)(bool))dlsym(adev->offload_effects_lib,
7230 "offload_effects_bundle_set_hpx_state");
Dhananjay Kumard68883d2015-09-04 13:39:26 +05307231 adev->offload_effects_get_parameters =
7232 (void (*)(struct str_parms *, struct str_parms *))
7233 dlsym(adev->offload_effects_lib,
7234 "offload_effects_bundle_get_parameters");
7235 adev->offload_effects_set_parameters =
7236 (void (*)(struct str_parms *))dlsym(adev->offload_effects_lib,
7237 "offload_effects_bundle_set_parameters");
Subhash Chandra Bose Naripeddy1d089162013-11-13 13:31:50 -08007238 }
7239 }
7240
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07007241 if (access(ADM_LIBRARY_PATH, R_OK) == 0) {
7242 adev->adm_lib = dlopen(ADM_LIBRARY_PATH, RTLD_NOW);
7243 if (adev->adm_lib == NULL) {
7244 ALOGE("%s: DLOPEN failed for %s", __func__, ADM_LIBRARY_PATH);
7245 } else {
7246 ALOGV("%s: DLOPEN successful for %s", __func__, ADM_LIBRARY_PATH);
7247 adev->adm_init = (adm_init_t)
7248 dlsym(adev->adm_lib, "adm_init");
7249 adev->adm_deinit = (adm_deinit_t)
7250 dlsym(adev->adm_lib, "adm_deinit");
7251 adev->adm_register_input_stream = (adm_register_input_stream_t)
7252 dlsym(adev->adm_lib, "adm_register_input_stream");
7253 adev->adm_register_output_stream = (adm_register_output_stream_t)
7254 dlsym(adev->adm_lib, "adm_register_output_stream");
7255 adev->adm_deregister_stream = (adm_deregister_stream_t)
7256 dlsym(adev->adm_lib, "adm_deregister_stream");
7257 adev->adm_request_focus = (adm_request_focus_t)
7258 dlsym(adev->adm_lib, "adm_request_focus");
7259 adev->adm_abandon_focus = (adm_abandon_focus_t)
7260 dlsym(adev->adm_lib, "adm_abandon_focus");
Haynes Mathew George5beddd42016-06-27 18:33:40 -07007261 adev->adm_set_config = (adm_set_config_t)
7262 dlsym(adev->adm_lib, "adm_set_config");
7263 adev->adm_request_focus_v2 = (adm_request_focus_v2_t)
7264 dlsym(adev->adm_lib, "adm_request_focus_v2");
7265 adev->adm_is_noirq_avail = (adm_is_noirq_avail_t)
7266 dlsym(adev->adm_lib, "adm_is_noirq_avail");
7267 adev->adm_on_routing_change = (adm_on_routing_change_t)
7268 dlsym(adev->adm_lib, "adm_on_routing_change");
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07007269 }
7270 }
7271
Mingming Yin514a8bc2014-07-29 15:22:21 -07007272 adev->bt_wb_speech_enabled = false;
Alexy Joseph5e4ccbc2017-02-21 14:20:12 -08007273 //initialize this to false for now,
7274 //this will be set to true through set param
7275 adev->vr_audio_mode_enabled = false;
Mingming Yin514a8bc2014-07-29 15:22:21 -07007276
Pradnya Chaphekar8a9dcd82014-09-09 09:49:10 -07007277 audio_extn_ds2_enable(adev);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007278 *device = &adev->device.common;
Xiaojun Sang785b5da2017-08-03 15:52:29 +08007279 adev->dsp_bit_width_enforce_mode =
7280 adev_init_dsp_bit_width_enforce_mode(adev->mixer);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007281
Dhananjay Kumard6d32152016-10-13 16:11:03 +05307282 audio_extn_utils_update_streams_cfg_lists(adev->platform, adev->mixer,
7283 &adev->streams_output_cfg_list,
7284 &adev->streams_input_cfg_list);
Subhash Chandra Bose Naripeddy19dc03b2014-03-10 14:43:05 -07007285
Kiran Kandi910e1862013-10-29 13:29:42 -07007286 audio_device_ref_count++;
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07007287
7288 char value[PROPERTY_VALUE_MAX];
7289 int trial;
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -07007290 if (property_get("vendor.audio_hal.period_size", value, NULL) > 0) {
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07007291 trial = atoi(value);
7292 if (period_size_is_plausible_for_low_latency(trial)) {
7293 pcm_config_low_latency.period_size = trial;
7294 pcm_config_low_latency.start_threshold = trial / 4;
7295 pcm_config_low_latency.avail_min = trial / 4;
7296 configured_low_latency_capture_period_size = trial;
7297 }
7298 }
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -07007299 if (property_get("vendor.audio_hal.in_period_size", value, NULL) > 0) {
Ravi Kumar Alamandadc9bb152014-09-08 15:59:58 -07007300 trial = atoi(value);
7301 if (period_size_is_plausible_for_low_latency(trial)) {
7302 configured_low_latency_capture_period_size = trial;
7303 }
7304 }
7305
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -07007306 if (property_get("vendor.audio_hal.period_multiplier", value, NULL) > 0) {
Haynes Mathew George5beddd42016-06-27 18:33:40 -07007307 af_period_multiplier = atoi(value);
7308 if (af_period_multiplier < 0)
7309 af_period_multiplier = 2;
7310 else if (af_period_multiplier > 4)
7311 af_period_multiplier = 4;
7312
7313 ALOGV("new period_multiplier = %d", af_period_multiplier);
7314 }
7315
Aniket Kumar Lata8fc67e62017-05-02 12:33:46 -07007316 adev->multi_offload_enable = property_get_bool("vendor.audio.offload.multiple.enabled", false);
Apoorv Raghuvanshi6e262842013-10-06 14:39:35 -07007317 pthread_mutex_unlock(&adev_init_lock);
7318
Ravi Kumar Alamanda8a0f9772015-06-15 10:35:19 -07007319 if (adev->adm_init)
7320 adev->adm_data = adev->adm_init();
7321
Dhananjay Kumaree4d2002016-10-25 18:02:58 +05307322 qahwi_init(*device);
Sudheer Papothifa9d2282015-09-17 01:53:25 +05307323 audio_extn_perf_lock_init();
Ben Rombergerd771a7c2017-02-22 18:05:17 -08007324 audio_extn_adsp_hdlr_init(adev->mixer);
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05307325
7326 audio_extn_snd_mon_init();
7327 pthread_mutex_lock(&adev->lock);
7328 audio_extn_snd_mon_register_listener(adev, adev_snd_mon_cb);
7329 adev->card_status = CARD_STATUS_ONLINE;
7330 pthread_mutex_unlock(&adev->lock);
7331 audio_extn_sound_trigger_init(adev); /* dependent on snd_mon_init() */
Satish Babu Patakokilac3c5d432017-07-04 22:48:59 +05307332 /* Allocate memory for Device config params */
7333 adev->device_cfg_params = (struct audio_device_config_param*)
7334 calloc(platform_get_max_codec_backend(),
7335 sizeof(struct audio_device_config_param));
7336 if (adev->device_cfg_params == NULL)
7337 ALOGE("%s: Memory allocation failed for Device config params", __func__);
Dhananjay Kumare6293dd2017-05-25 17:25:30 +05307338
Eric Laurent994a6932013-07-17 11:51:42 -07007339 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007340 return 0;
7341}
7342
7343static struct hw_module_methods_t hal_module_methods = {
7344 .open = adev_open,
7345};
7346
7347struct audio_module HAL_MODULE_INFO_SYM = {
7348 .common = {
7349 .tag = HARDWARE_MODULE_TAG,
7350 .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
7351 .hal_api_version = HARDWARE_HAL_API_VERSION,
7352 .id = AUDIO_HARDWARE_MODULE_ID,
7353 .name = "QCOM Audio HAL",
Duy Truongfae19622013-11-24 02:17:54 -08007354 .author = "The Linux Foundation",
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08007355 .methods = &hal_module_methods,
7356 },
7357};