blob: 404f17c8faa5c9b0a6b132cbdaf539a2ca90c478 [file] [log] [blame]
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "audio_hw_primary"
18/*#define LOG_NDEBUG 0*/
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070019/*#define VERY_VERY_VERBOSE_LOGGING*/
20#ifdef VERY_VERY_VERBOSE_LOGGING
21#define ALOGVV ALOGV
22#else
23#define ALOGVV(a...) do { } while(0)
24#endif
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080025
26#include <errno.h>
27#include <pthread.h>
28#include <stdint.h>
29#include <sys/time.h>
30#include <stdlib.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080031#include <math.h>
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070032#include <sys/resource.h>
33#include <sys/prctl.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080034
35#include <cutils/log.h>
36#include <cutils/str_parms.h>
37#include <cutils/properties.h>
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070038#include <cutils/atomic.h>
39#include <cutils/sched_policy.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080040
Eric Laurentb23d5282013-05-14 15:27:20 -070041#include <hardware/audio_effect.h>
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070042#include <system/thread_defs.h>
Eric Laurentb23d5282013-05-14 15:27:20 -070043#include <audio_effects/effect_aec.h>
44#include <audio_effects/effect_ns.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080045#include "audio_hw.h"
Eric Laurentb23d5282013-05-14 15:27:20 -070046#include "platform_api.h"
47#include <platform.h>
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -080048
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -070049#include "sound/compress_params.h"
50
51#define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024)
52#define COMPRESS_OFFLOAD_NUM_FRAGMENTS 4
53/* ToDo: Check and update a proper value in msec */
54#define COMPRESS_OFFLOAD_PLAYBACK_LATENCY 96
55#define COMPRESS_PLAYBACK_VOLUME_MAX 0x2000
56
Eric Laurentb23d5282013-05-14 15:27:20 -070057struct pcm_config pcm_config_deep_buffer = {
58 .channels = 2,
59 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
60 .period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE,
61 .period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT,
62 .format = PCM_FORMAT_S16_LE,
63 .start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
64 .stop_threshold = INT_MAX,
65 .avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
66};
67
68struct pcm_config pcm_config_low_latency = {
69 .channels = 2,
70 .rate = DEFAULT_OUTPUT_SAMPLING_RATE,
71 .period_size = LOW_LATENCY_OUTPUT_PERIOD_SIZE,
72 .period_count = LOW_LATENCY_OUTPUT_PERIOD_COUNT,
73 .format = PCM_FORMAT_S16_LE,
74 .start_threshold = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
75 .stop_threshold = INT_MAX,
76 .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
77};
78
79struct pcm_config pcm_config_hdmi_multi = {
80 .channels = HDMI_MULTI_DEFAULT_CHANNEL_COUNT, /* changed when the stream is opened */
81 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, /* changed when the stream is opened */
82 .period_size = HDMI_MULTI_PERIOD_SIZE,
83 .period_count = HDMI_MULTI_PERIOD_COUNT,
84 .format = PCM_FORMAT_S16_LE,
85 .start_threshold = 0,
86 .stop_threshold = INT_MAX,
87 .avail_min = 0,
88};
89
90struct pcm_config pcm_config_audio_capture = {
91 .channels = 2,
Eric Laurentb23d5282013-05-14 15:27:20 -070092 .period_count = AUDIO_CAPTURE_PERIOD_COUNT,
93 .format = PCM_FORMAT_S16_LE,
94};
95
96struct pcm_config pcm_config_voice_call = {
97 .channels = 1,
98 .rate = 8000,
99 .period_size = 160,
100 .period_count = 2,
101 .format = PCM_FORMAT_S16_LE,
102};
103
104static const char * const use_case_table[AUDIO_USECASE_MAX] = {
105 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = "deep-buffer-playback",
106 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = "low-latency-playback",
107 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = "multi-channel-playback",
108 [USECASE_AUDIO_RECORD] = "audio-record",
109 [USECASE_AUDIO_RECORD_LOW_LATENCY] = "low-latency-record",
110 [USECASE_VOICE_CALL] = "voice-call",
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700111 [USECASE_AUDIO_PLAYBACK_OFFLOAD] = "compress-offload-playback",
Eric Laurentb23d5282013-05-14 15:27:20 -0700112};
113
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800114
115#define STRING_TO_ENUM(string) { #string, string }
116
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800117struct string_to_enum {
118 const char *name;
119 uint32_t value;
120};
121
122static const struct string_to_enum out_channels_name_to_enum_table[] = {
123 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO),
124 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
125 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
126};
127
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700128static bool is_supported_format(audio_format_t format)
129{
130 if (format == AUDIO_FORMAT_MP3 /*||
131 format == AUDIO_FORMAT_AAC */)
132 return true;
133
134 return false;
135}
136
137static int get_snd_codec_id(audio_format_t format)
138{
139 int id = 0;
140
141 switch (format) {
142 case AUDIO_FORMAT_MP3:
143 id = SND_AUDIOCODEC_MP3;
144 break;
145 case AUDIO_FORMAT_AAC:
146 id = SND_AUDIOCODEC_AAC;
147 break;
148 default:
149 ALOGE("%s: Unsupported audio format", __func__);
150 }
151
152 return id;
153}
Ravi Kumar Alamandaf9967042013-02-14 19:35:14 -0800154
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700155static int enable_audio_route(struct audio_device *adev,
156 struct audio_usecase *usecase,
157 bool update_mixer)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800158{
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700159 snd_device_t snd_device;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800160 char mixer_path[50];
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800161
162 if (usecase == NULL)
163 return -EINVAL;
164
165 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
166
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800167 if (usecase->type == PCM_CAPTURE)
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700168 snd_device = usecase->in_snd_device;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800169 else
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700170 snd_device = usecase->out_snd_device;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800171
172 strcpy(mixer_path, use_case_table[usecase->id]);
Eric Laurentb23d5282013-05-14 15:27:20 -0700173 platform_add_backend_name(mixer_path, snd_device);
Eric Laurent994a6932013-07-17 11:51:42 -0700174 ALOGV("%s: apply mixer path: %s", __func__, mixer_path);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700175 audio_route_apply_path(adev->audio_route, mixer_path);
176 if (update_mixer)
177 audio_route_update_mixer(adev->audio_route);
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800178
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800179 ALOGV("%s: exit", __func__);
180 return 0;
181}
182
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700183static int disable_audio_route(struct audio_device *adev,
184 struct audio_usecase *usecase,
185 bool update_mixer)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800186{
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700187 snd_device_t snd_device;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800188 char mixer_path[50];
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800189
190 if (usecase == NULL)
191 return -EINVAL;
192
193 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700194 if (usecase->type == PCM_CAPTURE)
195 snd_device = usecase->in_snd_device;
196 else
197 snd_device = usecase->out_snd_device;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800198 strcpy(mixer_path, use_case_table[usecase->id]);
Eric Laurentb23d5282013-05-14 15:27:20 -0700199 platform_add_backend_name(mixer_path, snd_device);
Eric Laurent994a6932013-07-17 11:51:42 -0700200 ALOGV("%s: reset mixer path: %s", __func__, mixer_path);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700201 audio_route_reset_path(adev->audio_route, mixer_path);
202 if (update_mixer)
203 audio_route_update_mixer(adev->audio_route);
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800204
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800205 ALOGV("%s: exit", __func__);
206 return 0;
207}
208
209static int enable_snd_device(struct audio_device *adev,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700210 snd_device_t snd_device,
211 bool update_mixer)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800212{
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800213 if (snd_device < SND_DEVICE_MIN ||
214 snd_device >= SND_DEVICE_MAX) {
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800215 ALOGE("%s: Invalid sound device %d", __func__, snd_device);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800216 return -EINVAL;
217 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700218
219 adev->snd_dev_ref_cnt[snd_device]++;
220 if (adev->snd_dev_ref_cnt[snd_device] > 1) {
Eric Laurent994a6932013-07-17 11:51:42 -0700221 ALOGV("%s: snd_device(%d: %s) is already active",
Eric Laurentb23d5282013-05-14 15:27:20 -0700222 __func__, snd_device, platform_get_snd_device_name(snd_device));
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700223 return 0;
224 }
225
Eric Laurentb23d5282013-05-14 15:27:20 -0700226 if (platform_send_audio_calibration(adev->platform, snd_device) < 0) {
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700227 adev->snd_dev_ref_cnt[snd_device]--;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800228 return -EINVAL;
229 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800230
Eric Laurent994a6932013-07-17 11:51:42 -0700231 ALOGV("%s: snd_device(%d: %s)", __func__,
Eric Laurentb23d5282013-05-14 15:27:20 -0700232 snd_device, platform_get_snd_device_name(snd_device));
233 audio_route_apply_path(adev->audio_route, platform_get_snd_device_name(snd_device));
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700234 if (update_mixer)
235 audio_route_update_mixer(adev->audio_route);
236
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800237 return 0;
238}
239
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700240static int disable_snd_device(struct audio_device *adev,
241 snd_device_t snd_device,
242 bool update_mixer)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800243{
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800244 if (snd_device < SND_DEVICE_MIN ||
245 snd_device >= SND_DEVICE_MAX) {
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800246 ALOGE("%s: Invalid sound device %d", __func__, snd_device);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800247 return -EINVAL;
248 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700249 if (adev->snd_dev_ref_cnt[snd_device] <= 0) {
250 ALOGE("%s: device ref cnt is already 0", __func__);
251 return -EINVAL;
252 }
253 adev->snd_dev_ref_cnt[snd_device]--;
254 if (adev->snd_dev_ref_cnt[snd_device] == 0) {
Eric Laurent994a6932013-07-17 11:51:42 -0700255 ALOGV("%s: snd_device(%d: %s)", __func__,
Eric Laurentb23d5282013-05-14 15:27:20 -0700256 snd_device, platform_get_snd_device_name(snd_device));
257 audio_route_reset_path(adev->audio_route, platform_get_snd_device_name(snd_device));
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700258 if (update_mixer)
259 audio_route_update_mixer(adev->audio_route);
260 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800261 return 0;
262}
263
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700264static void check_usecases_codec_backend(struct audio_device *adev,
265 struct audio_usecase *uc_info,
266 snd_device_t snd_device)
267{
268 struct listnode *node;
269 struct audio_usecase *usecase;
270 bool switch_device[AUDIO_USECASE_MAX];
271 int i, num_uc_to_switch = 0;
272
273 /*
274 * This function is to make sure that all the usecases that are active on
275 * the hardware codec backend are always routed to any one device that is
276 * handled by the hardware codec.
277 * For example, if low-latency and deep-buffer usecases are currently active
278 * on speaker and out_set_parameters(headset) is received on low-latency
279 * output, then we have to make sure deep-buffer is also switched to headset,
280 * because of the limitation that both the devices cannot be enabled
281 * at the same time as they share the same backend.
282 */
283 /* Disable all the usecases on the shared backend other than the
284 specified usecase */
285 for (i = 0; i < AUDIO_USECASE_MAX; i++)
286 switch_device[i] = false;
287
288 list_for_each(node, &adev->usecase_list) {
289 usecase = node_to_item(node, struct audio_usecase, list);
290 if (usecase->type != PCM_CAPTURE &&
291 usecase != uc_info &&
292 usecase->out_snd_device != snd_device &&
293 usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) {
294 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
295 __func__, use_case_table[usecase->id],
Eric Laurentb23d5282013-05-14 15:27:20 -0700296 platform_get_snd_device_name(usecase->out_snd_device));
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700297 disable_audio_route(adev, usecase, false);
298 switch_device[usecase->id] = true;
299 num_uc_to_switch++;
300 }
301 }
302
303 if (num_uc_to_switch) {
304 /* Make sure all the streams are de-routed before disabling the device */
305 audio_route_update_mixer(adev->audio_route);
306
307 list_for_each(node, &adev->usecase_list) {
308 usecase = node_to_item(node, struct audio_usecase, list);
309 if (switch_device[usecase->id]) {
310 disable_snd_device(adev, usecase->out_snd_device, false);
311 enable_snd_device(adev, snd_device, false);
312 }
313 }
314
315 /* Make sure new snd device is enabled before re-routing the streams */
316 audio_route_update_mixer(adev->audio_route);
317
318 /* Re-route all the usecases on the shared backend other than the
319 specified usecase to new snd devices */
320 list_for_each(node, &adev->usecase_list) {
321 usecase = node_to_item(node, struct audio_usecase, list);
322 /* Update the out_snd_device only before enabling the audio route */
323 if (switch_device[usecase->id] ) {
324 usecase->out_snd_device = snd_device;
325 enable_audio_route(adev, usecase, false);
326 }
327 }
328
329 audio_route_update_mixer(adev->audio_route);
330 }
331}
332
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -0700333static void check_and_route_capture_usecases(struct audio_device *adev,
334 struct audio_usecase *uc_info,
335 snd_device_t snd_device)
336{
337 struct listnode *node;
338 struct audio_usecase *usecase;
339 bool switch_device[AUDIO_USECASE_MAX];
340 int i, num_uc_to_switch = 0;
341
342 /*
343 * This function is to make sure that all the active capture usecases
344 * are always routed to the same input sound device.
345 * For example, if audio-record and voice-call usecases are currently
346 * active on speaker(rx) and speaker-mic (tx) and out_set_parameters(earpiece)
347 * is received for voice call then we have to make sure that audio-record
348 * usecase is also switched to earpiece i.e. voice-dmic-ef,
349 * because of the limitation that two devices cannot be enabled
350 * at the same time if they share the same backend.
351 */
352 for (i = 0; i < AUDIO_USECASE_MAX; i++)
353 switch_device[i] = false;
354
355 list_for_each(node, &adev->usecase_list) {
356 usecase = node_to_item(node, struct audio_usecase, list);
357 if (usecase->type != PCM_PLAYBACK &&
358 usecase != uc_info &&
359 usecase->in_snd_device != snd_device) {
360 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
361 __func__, use_case_table[usecase->id],
Devin Kim1e5f3532013-08-09 07:48:29 -0700362 platform_get_snd_device_name(usecase->in_snd_device));
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -0700363 disable_audio_route(adev, usecase, false);
364 switch_device[usecase->id] = true;
365 num_uc_to_switch++;
366 }
367 }
368
369 if (num_uc_to_switch) {
370 /* Make sure all the streams are de-routed before disabling the device */
371 audio_route_update_mixer(adev->audio_route);
372
373 list_for_each(node, &adev->usecase_list) {
374 usecase = node_to_item(node, struct audio_usecase, list);
375 if (switch_device[usecase->id]) {
376 disable_snd_device(adev, usecase->in_snd_device, false);
377 enable_snd_device(adev, snd_device, false);
378 }
379 }
380
381 /* Make sure new snd device is enabled before re-routing the streams */
382 audio_route_update_mixer(adev->audio_route);
383
384 /* Re-route all the usecases on the shared backend other than the
385 specified usecase to new snd devices */
386 list_for_each(node, &adev->usecase_list) {
387 usecase = node_to_item(node, struct audio_usecase, list);
388 /* Update the in_snd_device only before enabling the audio route */
389 if (switch_device[usecase->id] ) {
390 usecase->in_snd_device = snd_device;
391 enable_audio_route(adev, usecase, false);
392 }
393 }
394
395 audio_route_update_mixer(adev->audio_route);
396 }
397}
398
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800399
400/* must be called with hw device mutex locked */
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -0700401static int read_hdmi_channel_masks(struct stream_out *out)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800402{
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -0700403 int ret = 0;
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -0700404 int channels = platform_edid_get_max_channels(out->dev->platform);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800405
406 switch (channels) {
407 /*
408 * Do not handle stereo output in Multi-channel cases
409 * Stereo case is handled in normal playback path
410 */
411 case 6:
412 ALOGV("%s: HDMI supports 5.1", __func__);
413 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
414 break;
415 case 8:
416 ALOGV("%s: HDMI supports 5.1 and 7.1 channels", __func__);
417 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1;
418 out->supported_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1;
419 break;
420 default:
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -0700421 ALOGE("HDMI does not support multi channel playback");
422 ret = -ENOSYS;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800423 break;
424 }
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -0700425 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800426}
427
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700428static struct audio_usecase *get_usecase_from_list(struct audio_device *adev,
429 audio_usecase_t uc_id)
430{
431 struct audio_usecase *usecase;
432 struct listnode *node;
433
434 list_for_each(node, &adev->usecase_list) {
435 usecase = node_to_item(node, struct audio_usecase, list);
436 if (usecase->id == uc_id)
437 return usecase;
438 }
439 return NULL;
440}
441
442static int select_devices(struct audio_device *adev,
443 audio_usecase_t uc_id)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800444{
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800445 snd_device_t out_snd_device = SND_DEVICE_NONE;
446 snd_device_t in_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700447 struct audio_usecase *usecase = NULL;
448 struct audio_usecase *vc_usecase = NULL;
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800449 struct listnode *node;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700450 int status = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800451
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700452 usecase = get_usecase_from_list(adev, uc_id);
453 if (usecase == NULL) {
454 ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id);
455 return -EINVAL;
456 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800457
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700458 if (usecase->type == VOICE_CALL) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700459 out_snd_device = platform_get_output_snd_device(adev->platform,
460 usecase->stream.out->devices);
461 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700462 usecase->devices = usecase->stream.out->devices;
463 } else {
464 /*
465 * If the voice call is active, use the sound devices of voice call usecase
466 * so that it would not result any device switch. All the usecases will
467 * be switched to new device when select_devices() is called for voice call
468 * usecase. This is to avoid switching devices for voice call when
469 * check_usecases_codec_backend() is called below.
470 */
471 if (adev->in_call) {
472 vc_usecase = get_usecase_from_list(adev, USECASE_VOICE_CALL);
473 if (vc_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) {
474 in_snd_device = vc_usecase->in_snd_device;
475 out_snd_device = vc_usecase->out_snd_device;
476 }
477 }
478 if (usecase->type == PCM_PLAYBACK) {
479 usecase->devices = usecase->stream.out->devices;
480 in_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -0700481 if (out_snd_device == SND_DEVICE_NONE) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700482 out_snd_device = platform_get_output_snd_device(adev->platform,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700483 usecase->stream.out->devices);
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -0700484 if (usecase->stream.out == adev->primary_output &&
485 adev->active_input &&
486 adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
487 select_devices(adev, adev->active_input->usecase);
488 }
489 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700490 } else if (usecase->type == PCM_CAPTURE) {
491 usecase->devices = usecase->stream.in->device;
492 out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -0700493 if (in_snd_device == SND_DEVICE_NONE) {
494 if (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION &&
495 adev->primary_output && !adev->primary_output->standby) {
Eric Laurentb23d5282013-05-14 15:27:20 -0700496 in_snd_device = platform_get_input_snd_device(adev->platform,
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -0700497 adev->primary_output->devices);
498 } else {
Eric Laurentb23d5282013-05-14 15:27:20 -0700499 in_snd_device = platform_get_input_snd_device(adev->platform,
500 AUDIO_DEVICE_NONE);
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -0700501 }
502 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700503 }
504 }
505
506 if (out_snd_device == usecase->out_snd_device &&
507 in_snd_device == usecase->in_snd_device) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800508 return 0;
509 }
510
sangwoobc677242013-08-08 16:53:43 +0900511 ALOGD("%s: out_snd_device(%d: %s) in_snd_device(%d: %s)", __func__,
Eric Laurentb23d5282013-05-14 15:27:20 -0700512 out_snd_device, platform_get_snd_device_name(out_snd_device),
513 in_snd_device, platform_get_snd_device_name(in_snd_device));
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800514
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800515 /*
516 * Limitation: While in call, to do a device switch we need to disable
517 * and enable both RX and TX devices though one of them is same as current
518 * device.
519 */
Eric Laurentb23d5282013-05-14 15:27:20 -0700520 if (usecase->type == VOICE_CALL) {
521 status = platform_switch_voice_call_device_pre(adev->platform);
Ravi Kumar Alamanda610e8cc2013-02-12 01:42:38 -0800522 }
523
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700524 /* Disable current sound devices */
525 if (usecase->out_snd_device != SND_DEVICE_NONE) {
526 disable_audio_route(adev, usecase, true);
527 disable_snd_device(adev, usecase->out_snd_device, false);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800528 }
529
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700530 if (usecase->in_snd_device != SND_DEVICE_NONE) {
531 disable_audio_route(adev, usecase, true);
532 disable_snd_device(adev, usecase->in_snd_device, false);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800533 }
534
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700535 /* Enable new sound devices */
536 if (out_snd_device != SND_DEVICE_NONE) {
537 if (usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND)
538 check_usecases_codec_backend(adev, usecase, out_snd_device);
539 enable_snd_device(adev, out_snd_device, false);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800540 }
541
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -0700542 if (in_snd_device != SND_DEVICE_NONE) {
543 check_and_route_capture_usecases(adev, usecase, in_snd_device);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700544 enable_snd_device(adev, in_snd_device, false);
Ravi Kumar Alamandac4ba7432013-06-05 14:11:39 -0700545 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700546
Eric Laurentb23d5282013-05-14 15:27:20 -0700547 if (usecase->type == VOICE_CALL)
548 status = platform_switch_voice_call_device_post(adev->platform,
549 out_snd_device,
550 in_snd_device);
Ravi Kumar Alamanda610e8cc2013-02-12 01:42:38 -0800551
sangwoo170731f2013-06-08 15:36:36 +0900552 audio_route_update_mixer(adev->audio_route);
553
554 usecase->in_snd_device = in_snd_device;
555 usecase->out_snd_device = out_snd_device;
556
557 enable_audio_route(adev, usecase, true);
558
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800559 return status;
560}
561
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800562static int stop_input_stream(struct stream_in *in)
563{
564 int i, ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800565 struct audio_usecase *uc_info;
566 struct audio_device *adev = in->dev;
567
Eric Laurentc8400632013-02-14 19:04:54 -0800568 adev->active_input = NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800569
Eric Laurent994a6932013-07-17 11:51:42 -0700570 ALOGV("%s: enter: usecase(%d: %s)", __func__,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700571 in->usecase, use_case_table[in->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800572 uc_info = get_usecase_from_list(adev, in->usecase);
573 if (uc_info == NULL) {
574 ALOGE("%s: Could not find the usecase (%d) in the list",
575 __func__, in->usecase);
576 return -EINVAL;
577 }
578
Eric Laurent150dbfe2013-02-27 14:31:02 -0800579 /* 1. Disable stream specific mixer controls */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700580 disable_audio_route(adev, uc_info, true);
581
582 /* 2. Disable the tx device */
583 disable_snd_device(adev, uc_info->in_snd_device, true);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800584
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800585 list_remove(&uc_info->list);
586 free(uc_info);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800587
Eric Laurent994a6932013-07-17 11:51:42 -0700588 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800589 return ret;
590}
591
592int start_input_stream(struct stream_in *in)
593{
594 /* 1. Enable output device and stream routing controls */
Eric Laurentc8400632013-02-14 19:04:54 -0800595 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800596 struct audio_usecase *uc_info;
597 struct audio_device *adev = in->dev;
598
Eric Laurent994a6932013-07-17 11:51:42 -0700599 ALOGV("%s: enter: usecase(%d)", __func__, in->usecase);
Eric Laurentb23d5282013-05-14 15:27:20 -0700600 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800601 if (in->pcm_device_id < 0) {
602 ALOGE("%s: Could not find PCM device id for the usecase(%d)",
603 __func__, in->usecase);
Eric Laurentc8400632013-02-14 19:04:54 -0800604 ret = -EINVAL;
605 goto error_config;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800606 }
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700607
608 adev->active_input = in;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800609 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
610 uc_info->id = in->usecase;
611 uc_info->type = PCM_CAPTURE;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800612 uc_info->stream.in = in;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700613 uc_info->devices = in->device;
614 uc_info->in_snd_device = SND_DEVICE_NONE;
615 uc_info->out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800616
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800617 list_add_tail(&adev->usecase_list, &uc_info->list);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700618 select_devices(adev, in->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800619
Eric Laurentc8400632013-02-14 19:04:54 -0800620 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d",
621 __func__, SOUND_CARD, in->pcm_device_id, in->config.channels);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800622 in->pcm = pcm_open(SOUND_CARD, in->pcm_device_id,
623 PCM_IN, &in->config);
624 if (in->pcm && !pcm_is_ready(in->pcm)) {
625 ALOGE("%s: %s", __func__, pcm_get_error(in->pcm));
626 pcm_close(in->pcm);
627 in->pcm = NULL;
Eric Laurentc8400632013-02-14 19:04:54 -0800628 ret = -EIO;
629 goto error_open;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800630 }
Eric Laurent994a6932013-07-17 11:51:42 -0700631 ALOGV("%s: exit", __func__);
Eric Laurentc8400632013-02-14 19:04:54 -0800632 return ret;
633
634error_open:
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800635 stop_input_stream(in);
Eric Laurentc8400632013-02-14 19:04:54 -0800636
637error_config:
638 adev->active_input = NULL;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700639 ALOGD("%s: exit: status(%d)", __func__, ret);
Eric Laurentc8400632013-02-14 19:04:54 -0800640
641 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800642}
643
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700644/* must be called with out->lock locked */
645static int send_offload_cmd_l(struct stream_out* out, int command)
646{
647 struct offload_cmd *cmd = (struct offload_cmd *)calloc(1, sizeof(struct offload_cmd));
648
649 ALOGVV("%s %d", __func__, command);
650
651 cmd->cmd = command;
652 list_add_tail(&out->offload_cmd_list, &cmd->node);
653 pthread_cond_signal(&out->offload_cond);
654 return 0;
655}
656
657/* must be called iwth out->lock locked */
658static void stop_compressed_output_l(struct stream_out *out)
659{
660 out->offload_state = OFFLOAD_STATE_IDLE;
661 out->playback_started = 0;
662 if (out->compr != NULL) {
663 compress_stop(out->compr);
664 while (out->offload_thread_blocked) {
665 pthread_cond_wait(&out->cond, &out->lock);
666 }
667 }
668}
669
670static void *offload_thread_loop(void *context)
671{
672 struct stream_out *out = (struct stream_out *) context;
673 struct listnode *item;
674
675 out->offload_state = OFFLOAD_STATE_IDLE;
676 out->playback_started = 0;
677
678 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
679 set_sched_policy(0, SP_FOREGROUND);
680 prctl(PR_SET_NAME, (unsigned long)"Offload Callback", 0, 0, 0);
681
682 ALOGV("%s", __func__);
683 pthread_mutex_lock(&out->lock);
684 for (;;) {
685 struct offload_cmd *cmd = NULL;
686 stream_callback_event_t event;
687 bool send_callback = false;
688
689 ALOGVV("%s offload_cmd_list %d out->offload_state %d",
690 __func__, list_empty(&out->offload_cmd_list),
691 out->offload_state);
692 if (list_empty(&out->offload_cmd_list)) {
693 ALOGV("%s SLEEPING", __func__);
694 pthread_cond_wait(&out->offload_cond, &out->lock);
695 ALOGV("%s RUNNING", __func__);
696 continue;
697 }
698
699 item = list_head(&out->offload_cmd_list);
700 cmd = node_to_item(item, struct offload_cmd, node);
701 list_remove(item);
702
703 ALOGVV("%s STATE %d CMD %d out->compr %p",
704 __func__, out->offload_state, cmd->cmd, out->compr);
705
706 if (cmd->cmd == OFFLOAD_CMD_EXIT) {
707 free(cmd);
708 break;
709 }
710
711 if (out->compr == NULL) {
712 ALOGE("%s: Compress handle is NULL", __func__);
713 pthread_cond_signal(&out->cond);
714 continue;
715 }
716 out->offload_thread_blocked = true;
717 pthread_mutex_unlock(&out->lock);
718 send_callback = false;
719 switch(cmd->cmd) {
720 case OFFLOAD_CMD_WAIT_FOR_BUFFER:
721 compress_wait(out->compr, -1);
722 send_callback = true;
723 event = STREAM_CBK_EVENT_WRITE_READY;
724 break;
725 case OFFLOAD_CMD_PARTIAL_DRAIN:
726 compress_drain(out->compr);
727//FIXME compress_partial_drain(out->compr);
728 send_callback = true;
729 event = STREAM_CBK_EVENT_DRAIN_READY;
730 break;
731 case OFFLOAD_CMD_DRAIN:
732 compress_drain(out->compr);
733 send_callback = true;
734 event = STREAM_CBK_EVENT_DRAIN_READY;
735 break;
736 default:
737 ALOGE("%s unknown command received: %d", __func__, cmd->cmd);
738 break;
739 }
740 pthread_mutex_lock(&out->lock);
741 out->offload_thread_blocked = false;
742 pthread_cond_signal(&out->cond);
Eric Laurent6e895242013-09-05 16:10:57 -0700743 if (send_callback) {
744 if (event == STREAM_CBK_EVENT_DRAIN_READY)
745 stop_compressed_output_l(out);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700746 out->offload_callback(event, NULL, out->offload_cookie);
Eric Laurent6e895242013-09-05 16:10:57 -0700747 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700748 free(cmd);
749 }
750
751 pthread_cond_signal(&out->cond);
752 while (!list_empty(&out->offload_cmd_list)) {
753 item = list_head(&out->offload_cmd_list);
754 list_remove(item);
755 free(node_to_item(item, struct offload_cmd, node));
756 }
757 pthread_mutex_unlock(&out->lock);
758
759 return NULL;
760}
761
762static int create_offload_callback_thread(struct stream_out *out)
763{
764 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL);
765 list_init(&out->offload_cmd_list);
766 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL,
767 offload_thread_loop, out);
768 return 0;
769}
770
771static int destroy_offload_callback_thread(struct stream_out *out)
772{
773 pthread_mutex_lock(&out->lock);
774 stop_compressed_output_l(out);
775 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT);
776
777 pthread_mutex_unlock(&out->lock);
778 pthread_join(out->offload_thread, (void **) NULL);
779 pthread_cond_destroy(&out->offload_cond);
780
781 return 0;
782}
783
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800784static int stop_output_stream(struct stream_out *out)
785{
786 int i, ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800787 struct audio_usecase *uc_info;
788 struct audio_device *adev = out->dev;
789
Eric Laurent994a6932013-07-17 11:51:42 -0700790 ALOGV("%s: enter: usecase(%d: %s)", __func__,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700791 out->usecase, use_case_table[out->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800792 uc_info = get_usecase_from_list(adev, out->usecase);
793 if (uc_info == NULL) {
794 ALOGE("%s: Could not find the usecase (%d) in the list",
795 __func__, out->usecase);
796 return -EINVAL;
797 }
798
Eric Laurent150dbfe2013-02-27 14:31:02 -0800799 /* 1. Get and set stream specific mixer controls */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700800 disable_audio_route(adev, uc_info, true);
801
802 /* 2. Disable the rx device */
803 disable_snd_device(adev, uc_info->out_snd_device, true);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800804
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800805 list_remove(&uc_info->list);
806 free(uc_info);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800807
Eric Laurent994a6932013-07-17 11:51:42 -0700808 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800809 return ret;
810}
811
812int start_output_stream(struct stream_out *out)
813{
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800814 int ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800815 struct audio_usecase *uc_info;
816 struct audio_device *adev = out->dev;
817
Eric Laurent994a6932013-07-17 11:51:42 -0700818 ALOGV("%s: enter: usecase(%d: %s) devices(%#x)",
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700819 __func__, out->usecase, use_case_table[out->usecase], out->devices);
Eric Laurentb23d5282013-05-14 15:27:20 -0700820 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800821 if (out->pcm_device_id < 0) {
822 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
823 __func__, out->pcm_device_id, out->usecase);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800824 ret = -EINVAL;
825 goto error_config;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800826 }
827
828 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
829 uc_info->id = out->usecase;
830 uc_info->type = PCM_PLAYBACK;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800831 uc_info->stream.out = out;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700832 uc_info->devices = out->devices;
833 uc_info->in_snd_device = SND_DEVICE_NONE;
834 uc_info->out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800835
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800836 list_add_tail(&adev->usecase_list, &uc_info->list);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800837
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700838 select_devices(adev, out->usecase);
839
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800840 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d)",
841 __func__, 0, out->pcm_device_id);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700842 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
843 out->pcm = pcm_open(SOUND_CARD, out->pcm_device_id,
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -0700844 PCM_OUT | PCM_MONOTONIC, &out->config);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700845 if (out->pcm && !pcm_is_ready(out->pcm)) {
846 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm));
847 pcm_close(out->pcm);
848 out->pcm = NULL;
849 ret = -EIO;
850 goto error_open;
851 }
852 } else {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800853 out->pcm = NULL;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700854 out->compr = compress_open(SOUND_CARD, out->pcm_device_id,
855 COMPRESS_IN, &out->compr_config);
856 if (out->compr && !is_compress_ready(out->compr)) {
857 ALOGE("%s: %s", __func__, compress_get_error(out->compr));
858 compress_close(out->compr);
859 out->compr = NULL;
860 ret = -EIO;
861 goto error_open;
862 }
863 if (out->offload_callback)
864 compress_nonblock(out->compr, out->non_blocking);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800865 }
Eric Laurent994a6932013-07-17 11:51:42 -0700866 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800867 return 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -0700868error_open:
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800869 stop_output_stream(out);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800870error_config:
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800871 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800872}
873
874static int stop_voice_call(struct audio_device *adev)
875{
876 int i, ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800877 struct audio_usecase *uc_info;
878
Eric Laurent994a6932013-07-17 11:51:42 -0700879 ALOGV("%s: enter", __func__);
Ravi Kumar Alamanda8b9c5c82013-02-20 16:59:34 -0800880 adev->in_call = false;
Eric Laurentb23d5282013-05-14 15:27:20 -0700881
882 ret = platform_stop_voice_call(adev->platform);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800883
884 /* 1. Close the PCM devices */
885 if (adev->voice_call_rx) {
886 pcm_close(adev->voice_call_rx);
887 adev->voice_call_rx = NULL;
888 }
889 if (adev->voice_call_tx) {
890 pcm_close(adev->voice_call_tx);
891 adev->voice_call_tx = NULL;
892 }
893
894 uc_info = get_usecase_from_list(adev, USECASE_VOICE_CALL);
895 if (uc_info == NULL) {
896 ALOGE("%s: Could not find the usecase (%d) in the list",
897 __func__, USECASE_VOICE_CALL);
898 return -EINVAL;
899 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800900
901 /* 2. Get and set stream specific mixer controls */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700902 disable_audio_route(adev, uc_info, true);
903
904 /* 3. Disable the rx and tx devices */
905 disable_snd_device(adev, uc_info->out_snd_device, false);
906 disable_snd_device(adev, uc_info->in_snd_device, true);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800907
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800908 list_remove(&uc_info->list);
909 free(uc_info);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800910
Eric Laurent994a6932013-07-17 11:51:42 -0700911 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800912 return ret;
913}
914
915static int start_voice_call(struct audio_device *adev)
916{
917 int i, ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800918 struct audio_usecase *uc_info;
919 int pcm_dev_rx_id, pcm_dev_tx_id;
920
Eric Laurent994a6932013-07-17 11:51:42 -0700921 ALOGV("%s: enter", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800922
923 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
924 uc_info->id = USECASE_VOICE_CALL;
925 uc_info->type = VOICE_CALL;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -0800926 uc_info->stream.out = adev->primary_output;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700927 uc_info->devices = adev->primary_output->devices;
928 uc_info->in_snd_device = SND_DEVICE_NONE;
929 uc_info->out_snd_device = SND_DEVICE_NONE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800930
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -0800931 list_add_tail(&adev->usecase_list, &uc_info->list);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800932
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -0700933 select_devices(adev, USECASE_VOICE_CALL);
934
Eric Laurentb23d5282013-05-14 15:27:20 -0700935 pcm_dev_rx_id = platform_get_pcm_device_id(uc_info->id, PCM_PLAYBACK);
936 pcm_dev_tx_id = platform_get_pcm_device_id(uc_info->id, PCM_CAPTURE);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800937
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800938 if (pcm_dev_rx_id < 0 || pcm_dev_tx_id < 0) {
939 ALOGE("%s: Invalid PCM devices (rx: %d tx: %d) for the usecase(%d)",
940 __func__, pcm_dev_rx_id, pcm_dev_tx_id, uc_info->id);
Ravi Kumar Alamanda8b9c5c82013-02-20 16:59:34 -0800941 ret = -EIO;
942 goto error_start_voice;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800943 }
944
Ravi Kumar Alamanda8b9c5c82013-02-20 16:59:34 -0800945 ALOGV("%s: Opening PCM playback device card_id(%d) device_id(%d)",
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800946 __func__, SOUND_CARD, pcm_dev_rx_id);
947 adev->voice_call_rx = pcm_open(SOUND_CARD,
948 pcm_dev_rx_id,
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -0700949 PCM_OUT | PCM_MONOTONIC, &pcm_config_voice_call);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800950 if (adev->voice_call_rx && !pcm_is_ready(adev->voice_call_rx)) {
951 ALOGE("%s: %s", __func__, pcm_get_error(adev->voice_call_rx));
Ravi Kumar Alamanda8b9c5c82013-02-20 16:59:34 -0800952 ret = -EIO;
953 goto error_start_voice;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800954 }
955
Ravi Kumar Alamanda8b9c5c82013-02-20 16:59:34 -0800956 ALOGV("%s: Opening PCM capture device card_id(%d) device_id(%d)",
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800957 __func__, SOUND_CARD, pcm_dev_tx_id);
958 adev->voice_call_tx = pcm_open(SOUND_CARD,
959 pcm_dev_tx_id,
960 PCM_IN, &pcm_config_voice_call);
961 if (adev->voice_call_tx && !pcm_is_ready(adev->voice_call_tx)) {
962 ALOGE("%s: %s", __func__, pcm_get_error(adev->voice_call_tx));
Ravi Kumar Alamanda8b9c5c82013-02-20 16:59:34 -0800963 ret = -EIO;
964 goto error_start_voice;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800965 }
966 pcm_start(adev->voice_call_rx);
967 pcm_start(adev->voice_call_tx);
968
Eric Laurentb23d5282013-05-14 15:27:20 -0700969 ret = platform_start_voice_call(adev->platform);
970 if (ret < 0) {
971 ALOGE("%s: platform_start_voice_call error %d\n", __func__, ret);
972 goto error_start_voice;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800973 }
974
975 adev->in_call = true;
Ravi Kumar Alamanda8b9c5c82013-02-20 16:59:34 -0800976 return 0;
977
978error_start_voice:
979 stop_voice_call(adev);
980
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -0800981 ALOGD("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -0800982 return ret;
983}
984
985static int check_input_parameters(uint32_t sample_rate,
986 audio_format_t format,
987 int channel_count)
988{
989 if (format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL;
990
991 if ((channel_count < 1) || (channel_count > 2)) return -EINVAL;
992
993 switch (sample_rate) {
994 case 8000:
995 case 11025:
996 case 12000:
997 case 16000:
998 case 22050:
999 case 24000:
1000 case 32000:
1001 case 44100:
1002 case 48000:
1003 break;
1004 default:
1005 return -EINVAL;
1006 }
1007
1008 return 0;
1009}
1010
1011static size_t get_input_buffer_size(uint32_t sample_rate,
1012 audio_format_t format,
1013 int channel_count)
1014{
1015 size_t size = 0;
1016
Ravi Kumar Alamanda33d33062013-06-11 14:40:01 -07001017 if (check_input_parameters(sample_rate, format, channel_count) != 0)
1018 return 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001019
Ravi Kumar Alamanda33d33062013-06-11 14:40:01 -07001020 size = (sample_rate * AUDIO_CAPTURE_PERIOD_DURATION_MSEC) / 1000;
1021 /* ToDo: should use frame_size computed based on the format and
1022 channel_count here. */
1023 size *= sizeof(short) * channel_count;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001024
Ravi Kumar Alamanda33d33062013-06-11 14:40:01 -07001025 /* make sure the size is multiple of 64 */
1026 size += 0x3f;
1027 size &= ~0x3f;
1028
1029 return size;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001030}
1031
1032static uint32_t out_get_sample_rate(const struct audio_stream *stream)
1033{
1034 struct stream_out *out = (struct stream_out *)stream;
1035
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001036 return out->sample_rate;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001037}
1038
1039static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
1040{
1041 return -ENOSYS;
1042}
1043
1044static size_t out_get_buffer_size(const struct audio_stream *stream)
1045{
1046 struct stream_out *out = (struct stream_out *)stream;
1047
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001048 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1049 return out->compr_config.fragment_size;
1050 }
1051
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001052 return out->config.period_size * audio_stream_frame_size(stream);
1053}
1054
1055static uint32_t out_get_channels(const struct audio_stream *stream)
1056{
1057 struct stream_out *out = (struct stream_out *)stream;
1058
1059 return out->channel_mask;
1060}
1061
1062static audio_format_t out_get_format(const struct audio_stream *stream)
1063{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001064 struct stream_out *out = (struct stream_out *)stream;
1065
1066 return out->format;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001067}
1068
1069static int out_set_format(struct audio_stream *stream, audio_format_t format)
1070{
1071 return -ENOSYS;
1072}
1073
1074static int out_standby(struct audio_stream *stream)
1075{
1076 struct stream_out *out = (struct stream_out *)stream;
1077 struct audio_device *adev = out->dev;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001078
Eric Laurent994a6932013-07-17 11:51:42 -07001079 ALOGV("%s: enter: usecase(%d: %s)", __func__,
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001080 out->usecase, use_case_table[out->usecase]);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001081
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001082 pthread_mutex_lock(&out->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001083 if (!out->standby) {
1084 out->standby = true;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001085 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1086 if (out->pcm) {
1087 pcm_close(out->pcm);
1088 out->pcm = NULL;
1089 }
1090 } else {
1091 stop_compressed_output_l(out);
1092 if (out->compr != NULL) {
1093 compress_close(out->compr);
1094 out->compr = NULL;
1095 }
Eric Laurent150dbfe2013-02-27 14:31:02 -08001096 }
1097 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001098 stop_output_stream(out);
Eric Laurent150dbfe2013-02-27 14:31:02 -08001099 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001100 }
1101 pthread_mutex_unlock(&out->lock);
Eric Laurent994a6932013-07-17 11:51:42 -07001102 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001103 return 0;
1104}
1105
1106static int out_dump(const struct audio_stream *stream, int fd)
1107{
1108 return 0;
1109}
1110
1111static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
1112{
1113 struct stream_out *out = (struct stream_out *)stream;
1114 struct audio_device *adev = out->dev;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001115 struct audio_usecase *usecase;
1116 struct listnode *node;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001117 struct str_parms *parms;
1118 char value[32];
1119 int ret, val = 0;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001120 bool select_new_device = false;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001121
sangwoobc677242013-08-08 16:53:43 +09001122 ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s",
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001123 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001124 parms = str_parms_create_str(kvpairs);
1125 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
1126 if (ret >= 0) {
1127 val = atoi(value);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001128 pthread_mutex_lock(&out->lock);
Eric Laurent150dbfe2013-02-27 14:31:02 -08001129 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001130
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001131 /*
1132 * When HDMI cable is unplugged the music playback is paused and
1133 * the policy manager sends routing=0. But the audioflinger
1134 * continues to write data until standby time (3sec).
1135 * As the HDMI core is turned off, the write gets blocked.
1136 * Avoid this by routing audio to speaker until standby.
1137 */
1138 if (out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL &&
1139 val == AUDIO_DEVICE_NONE) {
1140 val = AUDIO_DEVICE_OUT_SPEAKER;
1141 }
1142
1143 /*
1144 * select_devices() call below switches all the usecases on the same
1145 * backend to the new device. Refer to check_usecases_codec_backend() in
1146 * the select_devices(). But how do we undo this?
1147 *
1148 * For example, music playback is active on headset (deep-buffer usecase)
1149 * and if we go to ringtones and select a ringtone, low-latency usecase
1150 * will be started on headset+speaker. As we can't enable headset+speaker
1151 * and headset devices at the same time, select_devices() switches the music
1152 * playback to headset+speaker while starting low-lateny usecase for ringtone.
1153 * So when the ringtone playback is completed, how do we undo the same?
1154 *
1155 * We are relying on the out_set_parameters() call on deep-buffer output,
1156 * once the ringtone playback is ended.
1157 * NOTE: We should not check if the current devices are same as new devices.
1158 * Because select_devices() must be called to switch back the music
1159 * playback to headset.
1160 */
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001161 if (val != 0) {
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001162 out->devices = val;
1163
1164 if (!out->standby)
1165 select_devices(adev, out->usecase);
1166
1167 if ((adev->mode == AUDIO_MODE_IN_CALL) && !adev->in_call &&
1168 (out == adev->primary_output)) {
1169 start_voice_call(adev);
1170 } else if ((adev->mode == AUDIO_MODE_IN_CALL) && adev->in_call &&
1171 (out == adev->primary_output)) {
1172 select_devices(adev, USECASE_VOICE_CALL);
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001173 }
1174 }
1175
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001176 if ((adev->mode != AUDIO_MODE_IN_CALL) && adev->in_call &&
1177 (out == adev->primary_output)) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001178 stop_voice_call(adev);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001179 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001180
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001181 pthread_mutex_unlock(&adev->lock);
Eric Laurent150dbfe2013-02-27 14:31:02 -08001182 pthread_mutex_unlock(&out->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001183 }
1184 str_parms_destroy(parms);
Eric Laurent994a6932013-07-17 11:51:42 -07001185 ALOGV("%s: exit: code(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001186 return ret;
1187}
1188
1189static char* out_get_parameters(const struct audio_stream *stream, const char *keys)
1190{
1191 struct stream_out *out = (struct stream_out *)stream;
1192 struct str_parms *query = str_parms_create_str(keys);
1193 char *str;
1194 char value[256];
1195 struct str_parms *reply = str_parms_create();
1196 size_t i, j;
1197 int ret;
1198 bool first = true;
Eric Laurent994a6932013-07-17 11:51:42 -07001199 ALOGV("%s: enter: keys - %s", __func__, keys);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001200 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
1201 if (ret >= 0) {
1202 value[0] = '\0';
1203 i = 0;
1204 while (out->supported_channel_masks[i] != 0) {
1205 for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) {
1206 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
1207 if (!first) {
1208 strcat(value, "|");
1209 }
1210 strcat(value, out_channels_name_to_enum_table[j].name);
1211 first = false;
1212 break;
1213 }
1214 }
1215 i++;
1216 }
1217 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
1218 str = str_parms_to_str(reply);
1219 } else {
1220 str = strdup(keys);
1221 }
1222 str_parms_destroy(query);
1223 str_parms_destroy(reply);
Eric Laurent994a6932013-07-17 11:51:42 -07001224 ALOGV("%s: exit: returns - %s", __func__, str);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001225 return str;
1226}
1227
1228static uint32_t out_get_latency(const struct audio_stream_out *stream)
1229{
1230 struct stream_out *out = (struct stream_out *)stream;
1231
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001232 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
1233 return COMPRESS_OFFLOAD_PLAYBACK_LATENCY;
1234
1235 return (out->config.period_count * out->config.period_size * 1000) /
1236 (out->config.rate);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001237}
1238
1239static int out_set_volume(struct audio_stream_out *stream, float left,
1240 float right)
1241{
Eric Laurenta9024de2013-04-04 09:19:12 -07001242 struct stream_out *out = (struct stream_out *)stream;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001243 int volume[2];
1244
Eric Laurenta9024de2013-04-04 09:19:12 -07001245 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
1246 /* only take left channel into account: the API is for stereo anyway */
1247 out->muted = (left == 0.0f);
1248 return 0;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001249 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1250 const char *mixer_ctl_name = "Compress Playback Volume";
1251 struct audio_device *adev = out->dev;
1252 struct mixer_ctl *ctl;
1253
1254 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1255 if (!ctl) {
1256 ALOGE("%s: Could not get ctl for mixer cmd - %s",
1257 __func__, mixer_ctl_name);
1258 return -EINVAL;
1259 }
1260 volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX);
1261 volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX);
1262 mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
1263 return 0;
Eric Laurenta9024de2013-04-04 09:19:12 -07001264 }
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001265
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001266 return -ENOSYS;
1267}
1268
1269static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
1270 size_t bytes)
1271{
1272 struct stream_out *out = (struct stream_out *)stream;
1273 struct audio_device *adev = out->dev;
Eric Laurent6e895242013-09-05 16:10:57 -07001274 ssize_t ret = 0;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001275
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001276 pthread_mutex_lock(&out->lock);
1277 if (out->standby) {
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07001278 out->standby = false;
Eric Laurent150dbfe2013-02-27 14:31:02 -08001279 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001280 ret = start_output_stream(out);
Eric Laurent150dbfe2013-02-27 14:31:02 -08001281 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001282 /* ToDo: If use case is compress offload should return 0 */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001283 if (ret != 0) {
Ravi Kumar Alamanda59d296d2013-05-02 11:25:27 -07001284 out->standby = true;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001285 goto exit;
1286 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001287 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001288
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001289 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1290 ret = compress_write(out->compr, buffer, bytes);
Eric Laurent6e895242013-09-05 16:10:57 -07001291 ALOGVV("%s: writing buffer (%d bytes) to pcm device returned %d", __func__, bytes, ret);
1292 if (ret >= 0 && ret < (ssize_t)bytes) {
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001293 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
1294 }
1295 if (!out->playback_started) {
1296 compress_start(out->compr);
1297 out->playback_started = 1;
1298 out->offload_state = OFFLOAD_STATE_PLAYING;
1299 }
1300 pthread_mutex_unlock(&out->lock);
1301 return ret;
1302 } else {
1303 if (out->pcm) {
1304 if (out->muted)
1305 memset((void *)buffer, 0, bytes);
1306 ALOGVV("%s: writing buffer (%d bytes) to pcm device", __func__, bytes);
1307 ret = pcm_write(out->pcm, (void *)buffer, bytes);
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07001308 if (ret == 0)
1309 out->written += bytes / (out->config.channels * sizeof(short));
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001310 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001311 }
1312
1313exit:
1314 pthread_mutex_unlock(&out->lock);
1315
1316 if (ret != 0) {
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001317 if (out->pcm)
1318 ALOGE("%s: error %d - %s", __func__, ret, pcm_get_error(out->pcm));
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001319 out_standby(&out->stream.common);
1320 usleep(bytes * 1000000 / audio_stream_frame_size(&out->stream.common) /
1321 out_get_sample_rate(&out->stream.common));
1322 }
1323 return bytes;
1324}
1325
1326static int out_get_render_position(const struct audio_stream_out *stream,
1327 uint32_t *dsp_frames)
1328{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001329 struct stream_out *out = (struct stream_out *)stream;
1330 *dsp_frames = 0;
1331 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
1332 pthread_mutex_lock(&out->lock);
1333 if (out->compr != NULL) {
1334 compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
1335 &out->sample_rate);
1336 ALOGVV("%s rendered frames %d sample_rate %d",
1337 __func__, *dsp_frames, out->sample_rate);
1338 }
1339 pthread_mutex_unlock(&out->lock);
1340 return 0;
1341 } else
1342 return -EINVAL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001343}
1344
1345static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
1346{
1347 return 0;
1348}
1349
1350static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
1351{
1352 return 0;
1353}
1354
1355static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
1356 int64_t *timestamp)
1357{
1358 return -EINVAL;
1359}
1360
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07001361static int out_get_presentation_position(const struct audio_stream_out *stream,
1362 uint64_t *frames, struct timespec *timestamp)
1363{
1364 struct stream_out *out = (struct stream_out *)stream;
1365 int ret = -1;
1366
1367 pthread_mutex_lock(&out->lock);
1368
1369 if (out->pcm) {
1370 size_t avail;
1371 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
1372 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
1373 // FIXME This calculation is incorrect if there is buffering after app processor
1374 int64_t signed_frames = out->written - kernel_buffer_size + avail;
1375 // It would be unusual for this value to be negative, but check just in case ...
1376 if (signed_frames >= 0) {
1377 *frames = signed_frames;
1378 ret = 0;
1379 }
1380 }
1381 }
1382
1383 pthread_mutex_unlock(&out->lock);
1384
1385 return ret;
1386}
1387
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001388static int out_set_callback(struct audio_stream_out *stream,
1389 stream_callback_t callback, void *cookie)
1390{
1391 struct stream_out *out = (struct stream_out *)stream;
1392
1393 ALOGV("%s", __func__);
1394 pthread_mutex_lock(&out->lock);
1395 out->offload_callback = callback;
1396 out->offload_cookie = cookie;
1397 pthread_mutex_unlock(&out->lock);
1398 return 0;
1399}
1400
1401static int out_pause(struct audio_stream_out* stream)
1402{
1403 struct stream_out *out = (struct stream_out *)stream;
1404 int status = -ENOSYS;
1405 ALOGV("%s", __func__);
1406 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1407 pthread_mutex_lock(&out->lock);
1408 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
1409 status = compress_pause(out->compr);
1410 out->offload_state = OFFLOAD_STATE_PAUSED;
1411 }
1412 pthread_mutex_unlock(&out->lock);
1413 }
1414 return status;
1415}
1416
1417static int out_resume(struct audio_stream_out* stream)
1418{
1419 struct stream_out *out = (struct stream_out *)stream;
1420 int status = -ENOSYS;
1421 ALOGV("%s", __func__);
1422 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1423 status = 0;
1424 pthread_mutex_lock(&out->lock);
1425 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
1426 status = compress_resume(out->compr);
1427 out->offload_state = OFFLOAD_STATE_PLAYING;
1428 }
1429 pthread_mutex_unlock(&out->lock);
1430 }
1431 return status;
1432}
1433
1434static int out_drain(struct audio_stream_out* stream, audio_drain_type_t type )
1435{
1436 struct stream_out *out = (struct stream_out *)stream;
1437 int status = -ENOSYS;
1438 ALOGV("%s", __func__);
1439 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1440 pthread_mutex_lock(&out->lock);
1441 if (type == AUDIO_DRAIN_EARLY_NOTIFY)
1442 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
1443 else
1444 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
1445 pthread_mutex_unlock(&out->lock);
1446 }
1447 return status;
1448}
1449
1450static int out_flush(struct audio_stream_out* stream)
1451{
1452 struct stream_out *out = (struct stream_out *)stream;
1453 ALOGV("%s", __func__);
1454 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1455 pthread_mutex_lock(&out->lock);
1456 stop_compressed_output_l(out);
1457 pthread_mutex_unlock(&out->lock);
1458 return 0;
1459 }
1460 return -ENOSYS;
1461}
1462
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001463/** audio_stream_in implementation **/
1464static uint32_t in_get_sample_rate(const struct audio_stream *stream)
1465{
1466 struct stream_in *in = (struct stream_in *)stream;
1467
1468 return in->config.rate;
1469}
1470
1471static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
1472{
1473 return -ENOSYS;
1474}
1475
1476static size_t in_get_buffer_size(const struct audio_stream *stream)
1477{
1478 struct stream_in *in = (struct stream_in *)stream;
1479
1480 return in->config.period_size * audio_stream_frame_size(stream);
1481}
1482
1483static uint32_t in_get_channels(const struct audio_stream *stream)
1484{
1485 struct stream_in *in = (struct stream_in *)stream;
1486
1487 return in->channel_mask;
1488}
1489
1490static audio_format_t in_get_format(const struct audio_stream *stream)
1491{
1492 return AUDIO_FORMAT_PCM_16_BIT;
1493}
1494
1495static int in_set_format(struct audio_stream *stream, audio_format_t format)
1496{
1497 return -ENOSYS;
1498}
1499
1500static int in_standby(struct audio_stream *stream)
1501{
1502 struct stream_in *in = (struct stream_in *)stream;
1503 struct audio_device *adev = in->dev;
1504 int status = 0;
Eric Laurent994a6932013-07-17 11:51:42 -07001505 ALOGV("%s: enter", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001506 pthread_mutex_lock(&in->lock);
1507 if (!in->standby) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001508 in->standby = true;
Eric Laurent150dbfe2013-02-27 14:31:02 -08001509 if (in->pcm) {
1510 pcm_close(in->pcm);
1511 in->pcm = NULL;
1512 }
1513 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001514 status = stop_input_stream(in);
Eric Laurent150dbfe2013-02-27 14:31:02 -08001515 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001516 }
1517 pthread_mutex_unlock(&in->lock);
Eric Laurent994a6932013-07-17 11:51:42 -07001518 ALOGV("%s: exit: status(%d)", __func__, status);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001519 return status;
1520}
1521
1522static int in_dump(const struct audio_stream *stream, int fd)
1523{
1524 return 0;
1525}
1526
1527static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
1528{
1529 struct stream_in *in = (struct stream_in *)stream;
1530 struct audio_device *adev = in->dev;
1531 struct str_parms *parms;
1532 char *str;
1533 char value[32];
1534 int ret, val = 0;
1535
Eric Laurent994a6932013-07-17 11:51:42 -07001536 ALOGV("%s: enter: kvpairs=%s", __func__, kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001537 parms = str_parms_create_str(kvpairs);
1538
1539 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
1540
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001541 pthread_mutex_lock(&in->lock);
Eric Laurent150dbfe2013-02-27 14:31:02 -08001542 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001543 if (ret >= 0) {
1544 val = atoi(value);
1545 /* no audio source uses val == 0 */
1546 if ((in->source != val) && (val != 0)) {
1547 in->source = val;
1548 }
1549 }
1550
1551 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
1552 if (ret >= 0) {
1553 val = atoi(value);
1554 if ((in->device != val) && (val != 0)) {
1555 in->device = val;
1556 /* If recording is in progress, change the tx device to new device */
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001557 if (!in->standby)
1558 ret = select_devices(adev, in->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001559 }
1560 }
1561
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001562 pthread_mutex_unlock(&adev->lock);
Eric Laurent150dbfe2013-02-27 14:31:02 -08001563 pthread_mutex_unlock(&in->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001564
1565 str_parms_destroy(parms);
Eric Laurent994a6932013-07-17 11:51:42 -07001566 ALOGV("%s: exit: status(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001567 return ret;
1568}
1569
1570static char* in_get_parameters(const struct audio_stream *stream,
1571 const char *keys)
1572{
1573 return strdup("");
1574}
1575
1576static int in_set_gain(struct audio_stream_in *stream, float gain)
1577{
1578 return 0;
1579}
1580
1581static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
1582 size_t bytes)
1583{
1584 struct stream_in *in = (struct stream_in *)stream;
1585 struct audio_device *adev = in->dev;
1586 int i, ret = -1;
1587
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001588 pthread_mutex_lock(&in->lock);
1589 if (in->standby) {
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001590 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001591 ret = start_input_stream(in);
Eric Laurent150dbfe2013-02-27 14:31:02 -08001592 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001593 if (ret != 0) {
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001594 goto exit;
1595 }
1596 in->standby = 0;
1597 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001598
1599 if (in->pcm) {
1600 ret = pcm_read(in->pcm, buffer, bytes);
1601 }
1602
1603 /*
1604 * Instead of writing zeroes here, we could trust the hardware
1605 * to always provide zeroes when muted.
1606 */
1607 if (ret == 0 && adev->mic_mute)
1608 memset(buffer, 0, bytes);
1609
1610exit:
1611 pthread_mutex_unlock(&in->lock);
1612
1613 if (ret != 0) {
1614 in_standby(&in->stream.common);
1615 ALOGV("%s: read failed - sleeping for buffer duration", __func__);
1616 usleep(bytes * 1000000 / audio_stream_frame_size(&in->stream.common) /
1617 in_get_sample_rate(&in->stream.common));
1618 }
1619 return bytes;
1620}
1621
1622static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
1623{
1624 return 0;
1625}
1626
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07001627static int add_remove_audio_effect(const struct audio_stream *stream,
1628 effect_handle_t effect,
1629 bool enable)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001630{
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07001631 struct stream_in *in = (struct stream_in *)stream;
1632 int status = 0;
1633 effect_descriptor_t desc;
1634
1635 status = (*effect)->get_descriptor(effect, &desc);
1636 if (status != 0)
1637 return status;
1638
1639 pthread_mutex_lock(&in->lock);
1640 pthread_mutex_lock(&in->dev->lock);
1641 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) &&
1642 in->enable_aec != enable &&
1643 (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) {
1644 in->enable_aec = enable;
1645 if (!in->standby)
1646 select_devices(in->dev, in->usecase);
1647 }
1648 pthread_mutex_unlock(&in->dev->lock);
1649 pthread_mutex_unlock(&in->lock);
1650
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001651 return 0;
1652}
1653
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07001654static int in_add_audio_effect(const struct audio_stream *stream,
1655 effect_handle_t effect)
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001656{
Eric Laurent994a6932013-07-17 11:51:42 -07001657 ALOGV("%s: effect %p", __func__, effect);
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07001658 return add_remove_audio_effect(stream, effect, true);
1659}
1660
1661static int in_remove_audio_effect(const struct audio_stream *stream,
1662 effect_handle_t effect)
1663{
Eric Laurent994a6932013-07-17 11:51:42 -07001664 ALOGV("%s: effect %p", __func__, effect);
Ravi Kumar Alamandaf70ffb42013-04-16 15:55:53 -07001665 return add_remove_audio_effect(stream, effect, false);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001666}
1667
1668static int adev_open_output_stream(struct audio_hw_device *dev,
1669 audio_io_handle_t handle,
1670 audio_devices_t devices,
1671 audio_output_flags_t flags,
1672 struct audio_config *config,
1673 struct audio_stream_out **stream_out)
1674{
1675 struct audio_device *adev = (struct audio_device *)dev;
1676 struct stream_out *out;
1677 int i, ret;
1678
Eric Laurent994a6932013-07-17 11:51:42 -07001679 ALOGV("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)",
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001680 __func__, config->sample_rate, config->channel_mask, devices, flags);
1681 *stream_out = NULL;
1682 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
1683
1684 if (devices == AUDIO_DEVICE_NONE)
1685 devices = AUDIO_DEVICE_OUT_SPEAKER;
1686
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001687 out->flags = flags;
1688 out->devices = devices;
Haynes Mathew George47cd4cb2013-07-19 11:58:50 -07001689 out->dev = adev;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001690 out->format = config->format;
1691 out->sample_rate = config->sample_rate;
1692 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1693 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001694
1695 /* Init use case and pcm_config */
1696 if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
1697 out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001698 pthread_mutex_lock(&adev->lock);
1699 ret = read_hdmi_channel_masks(out);
1700 pthread_mutex_unlock(&adev->lock);
1701 if (ret != 0) {
1702 /* If HDMI does not support multi channel playback, set the default */
1703 out->config.channels = popcount(out->channel_mask);
Eric Laurentb23d5282013-05-14 15:27:20 -07001704 platform_set_hdmi_channels(adev->platform, out->config.channels);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001705 goto error_open;
1706 }
1707
1708 if (config->sample_rate == 0)
1709 config->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
1710 if (config->channel_mask == 0)
1711 config->channel_mask = AUDIO_CHANNEL_OUT_5POINT1;
1712
1713 out->channel_mask = config->channel_mask;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001714 out->sample_rate = config->sample_rate;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001715 out->usecase = USECASE_AUDIO_PLAYBACK_MULTI_CH;
1716 out->config = pcm_config_hdmi_multi;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001717 out->config.rate = config->sample_rate;
1718 out->config.channels = popcount(out->channel_mask);
1719 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels * 2);
Eric Laurentb23d5282013-05-14 15:27:20 -07001720 platform_set_hdmi_channels(adev->platform, out->config.channels);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001721 } else if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
1722 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
1723 out->config = pcm_config_deep_buffer;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001724 out->sample_rate = out->config.rate;
1725 } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
1726 if (config->offload_info.version != AUDIO_INFO_INITIALIZER.version ||
1727 config->offload_info.size != AUDIO_INFO_INITIALIZER.size) {
1728 ALOGE("%s: Unsupported Offload information", __func__);
1729 ret = -EINVAL;
1730 goto error_open;
1731 }
1732 if (!is_supported_format(config->offload_info.format)) {
1733 ALOGE("%s: Unsupported audio format", __func__);
1734 ret = -EINVAL;
1735 goto error_open;
1736 }
1737
1738 out->compr_config.codec = (struct snd_codec *)
1739 calloc(1, sizeof(struct snd_codec));
1740
1741 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
1742 if (config->offload_info.channel_mask)
1743 out->channel_mask = config->offload_info.channel_mask;
1744 else if (config->channel_mask)
1745 out->channel_mask = config->channel_mask;
1746 out->format = config->offload_info.format;
1747 out->sample_rate = config->offload_info.sample_rate;
1748
1749 out->stream.set_callback = out_set_callback;
1750 out->stream.pause = out_pause;
1751 out->stream.resume = out_resume;
1752 out->stream.drain = out_drain;
1753 out->stream.flush = out_flush;
1754
1755 out->compr_config.codec->id =
1756 get_snd_codec_id(config->offload_info.format);
1757 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
1758 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
1759 out->compr_config.codec->sample_rate =
1760 compress_get_alsa_rate(config->offload_info.sample_rate);
1761 out->compr_config.codec->bit_rate =
1762 config->offload_info.bit_rate;
1763 out->compr_config.codec->ch_in =
1764 popcount(config->channel_mask);
1765 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
1766
1767 if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING)
1768 out->non_blocking = 1;
1769 create_offload_callback_thread(out);
1770 ALOGV("%s: offloaded output offload_info version %04x bit rate %d",
1771 __func__, config->offload_info.version,
1772 config->offload_info.bit_rate);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001773 } else {
1774 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
1775 out->config = pcm_config_low_latency;
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001776 out->sample_rate = out->config.rate;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001777 }
1778
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001779 if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) {
1780 if(adev->primary_output == NULL)
1781 adev->primary_output = out;
1782 else {
1783 ALOGE("%s: Primary output is already opened", __func__);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001784 ret = -EEXIST;
1785 goto error_open;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08001786 }
1787 }
1788
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001789 /* Check if this usecase is already existing */
1790 pthread_mutex_lock(&adev->lock);
1791 if (get_usecase_from_list(adev, out->usecase) != NULL) {
1792 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001793 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001794 ret = -EEXIST;
1795 goto error_open;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001796 }
1797 pthread_mutex_unlock(&adev->lock);
1798
1799 out->stream.common.get_sample_rate = out_get_sample_rate;
1800 out->stream.common.set_sample_rate = out_set_sample_rate;
1801 out->stream.common.get_buffer_size = out_get_buffer_size;
1802 out->stream.common.get_channels = out_get_channels;
1803 out->stream.common.get_format = out_get_format;
1804 out->stream.common.set_format = out_set_format;
1805 out->stream.common.standby = out_standby;
1806 out->stream.common.dump = out_dump;
1807 out->stream.common.set_parameters = out_set_parameters;
1808 out->stream.common.get_parameters = out_get_parameters;
1809 out->stream.common.add_audio_effect = out_add_audio_effect;
1810 out->stream.common.remove_audio_effect = out_remove_audio_effect;
1811 out->stream.get_latency = out_get_latency;
1812 out->stream.set_volume = out_set_volume;
1813 out->stream.write = out_write;
1814 out->stream.get_render_position = out_get_render_position;
1815 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07001816 out->stream.get_presentation_position = out_get_presentation_position;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001817
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001818 out->standby = 1;
Eric Laurenta9024de2013-04-04 09:19:12 -07001819 /* out->muted = false; by calloc() */
Glenn Kasten2ccd7ba2013-09-10 09:04:31 -07001820 /* out->written = 0; by calloc() */
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001821
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001822 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
1823 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
1824
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001825 config->format = out->stream.common.get_format(&out->stream.common);
1826 config->channel_mask = out->stream.common.get_channels(&out->stream.common);
1827 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
1828
1829 *stream_out = &out->stream;
Eric Laurent994a6932013-07-17 11:51:42 -07001830 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001831 return 0;
Ravi Kumar Alamandab1995062013-03-21 23:18:20 -07001832
1833error_open:
1834 free(out);
1835 *stream_out = NULL;
1836 ALOGD("%s: exit: ret %d", __func__, ret);
1837 return ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001838}
1839
1840static void adev_close_output_stream(struct audio_hw_device *dev,
1841 struct audio_stream_out *stream)
1842{
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001843 struct stream_out *out = (struct stream_out *)stream;
1844 struct audio_device *adev = out->dev;
1845
Eric Laurent994a6932013-07-17 11:51:42 -07001846 ALOGV("%s: enter", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001847 out_standby(&stream->common);
Ravi Kumar Alamanda4e02e552013-07-17 15:22:04 -07001848 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1849 destroy_offload_callback_thread(out);
1850
1851 if (out->compr_config.codec != NULL)
1852 free(out->compr_config.codec);
1853 }
1854 pthread_cond_destroy(&out->cond);
1855 pthread_mutex_destroy(&out->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001856 free(stream);
Eric Laurent994a6932013-07-17 11:51:42 -07001857 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001858}
1859
1860static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
1861{
1862 struct audio_device *adev = (struct audio_device *)dev;
1863 struct str_parms *parms;
1864 char *str;
1865 char value[32];
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07001866 int val;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001867 int ret;
1868
Eric Laurent994a6932013-07-17 11:51:42 -07001869 ALOGV("%s: enter: %s", __func__, kvpairs);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001870
1871 parms = str_parms_create_str(kvpairs);
1872 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value));
1873 if (ret >= 0) {
1874 int tty_mode;
1875
1876 if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0)
1877 tty_mode = TTY_MODE_OFF;
1878 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0)
1879 tty_mode = TTY_MODE_VCO;
1880 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0)
1881 tty_mode = TTY_MODE_HCO;
1882 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0)
1883 tty_mode = TTY_MODE_FULL;
1884 else
1885 return -EINVAL;
1886
1887 pthread_mutex_lock(&adev->lock);
1888 if (tty_mode != adev->tty_mode) {
1889 adev->tty_mode = tty_mode;
Ravi Kumar Alamandaf9967042013-02-14 19:35:14 -08001890 adev->acdb_settings = (adev->acdb_settings & TTY_MODE_CLEAR) | tty_mode;
1891 if (adev->in_call)
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07001892 select_devices(adev, USECASE_VOICE_CALL);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001893 }
1894 pthread_mutex_unlock(&adev->lock);
1895 }
1896
1897 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
1898 if (ret >= 0) {
1899 /* When set to false, HAL should disable EC and NS
1900 * But it is currently not supported.
1901 */
1902 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
1903 adev->bluetooth_nrec = true;
1904 else
1905 adev->bluetooth_nrec = false;
1906 }
1907
1908 ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
1909 if (ret >= 0) {
1910 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
1911 adev->screen_off = false;
1912 else
1913 adev->screen_off = true;
1914 }
1915
Jean-Michel Trivic56336b2013-05-24 16:55:17 -07001916 ret = str_parms_get_int(parms, "rotation", &val);
1917 if (ret >= 0) {
1918 bool reverse_speakers = false;
1919 switch(val) {
1920 // FIXME: note that the code below assumes that the speakers are in the correct placement
1921 // relative to the user when the device is rotated 90deg from its default rotation. This
1922 // assumption is device-specific, not platform-specific like this code.
1923 case 270:
1924 reverse_speakers = true;
1925 break;
1926 case 0:
1927 case 90:
1928 case 180:
1929 break;
1930 default:
1931 ALOGE("%s: unexpected rotation of %d", __func__, val);
1932 }
1933 pthread_mutex_lock(&adev->lock);
1934 if (adev->speaker_lr_swap != reverse_speakers) {
1935 adev->speaker_lr_swap = reverse_speakers;
1936 // only update the selected device if there is active pcm playback
1937 struct audio_usecase *usecase;
1938 struct listnode *node;
1939 list_for_each(node, &adev->usecase_list) {
1940 usecase = node_to_item(node, struct audio_usecase, list);
1941 if (usecase->type == PCM_PLAYBACK) {
1942 select_devices(adev, usecase->id);
1943 break;
1944 }
1945 }
1946 }
1947 pthread_mutex_unlock(&adev->lock);
1948 }
1949
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001950 str_parms_destroy(parms);
Eric Laurent994a6932013-07-17 11:51:42 -07001951 ALOGV("%s: exit with code(%d)", __func__, ret);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001952 return ret;
1953}
1954
1955static char* adev_get_parameters(const struct audio_hw_device *dev,
1956 const char *keys)
1957{
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001958 return strdup("");
1959}
1960
1961static int adev_init_check(const struct audio_hw_device *dev)
1962{
1963 return 0;
1964}
1965
1966static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
1967{
1968 struct audio_device *adev = (struct audio_device *)dev;
1969 int vol, err = 0;
1970
1971 pthread_mutex_lock(&adev->lock);
1972 adev->voice_volume = volume;
1973 if (adev->mode == AUDIO_MODE_IN_CALL) {
1974 if (volume < 0.0) {
1975 volume = 0.0;
1976 } else if (volume > 1.0) {
1977 volume = 1.0;
1978 }
1979
1980 vol = lrint(volume * 100.0);
1981
1982 // Voice volume levels from android are mapped to driver volume levels as follows.
1983 // 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
1984 // So adjust the volume to get the correct volume index in driver
1985 vol = 100 - vol;
Eric Laurentb23d5282013-05-14 15:27:20 -07001986
1987 err = platform_set_voice_volume(adev->platform, vol);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08001988 }
1989 pthread_mutex_unlock(&adev->lock);
1990 return err;
1991}
1992
1993static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
1994{
1995 return -ENOSYS;
1996}
1997
1998static int adev_get_master_volume(struct audio_hw_device *dev,
1999 float *volume)
2000{
2001 return -ENOSYS;
2002}
2003
2004static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
2005{
2006 return -ENOSYS;
2007}
2008
2009static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
2010{
2011 return -ENOSYS;
2012}
2013
2014static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
2015{
2016 struct audio_device *adev = (struct audio_device *)dev;
2017
2018 pthread_mutex_lock(&adev->lock);
2019 if (adev->mode != mode) {
2020 adev->mode = mode;
2021 }
2022 pthread_mutex_unlock(&adev->lock);
2023 return 0;
2024}
2025
2026static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
2027{
2028 struct audio_device *adev = (struct audio_device *)dev;
2029 int err = 0;
2030
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002031 pthread_mutex_lock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002032 adev->mic_mute = state;
Eric Laurentb23d5282013-05-14 15:27:20 -07002033
2034 err = platform_set_mic_mute(adev->platform, state);
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002035 pthread_mutex_unlock(&adev->lock);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002036 return err;
2037}
2038
2039static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
2040{
2041 struct audio_device *adev = (struct audio_device *)dev;
2042
2043 *state = adev->mic_mute;
2044
2045 return 0;
2046}
2047
2048static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
2049 const struct audio_config *config)
2050{
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002051 int channel_count = popcount(config->channel_mask);
2052
2053 return get_input_buffer_size(config->sample_rate, config->format, channel_count);
2054}
2055
2056static int adev_open_input_stream(struct audio_hw_device *dev,
2057 audio_io_handle_t handle,
2058 audio_devices_t devices,
2059 struct audio_config *config,
2060 struct audio_stream_in **stream_in)
2061{
2062 struct audio_device *adev = (struct audio_device *)dev;
2063 struct stream_in *in;
2064 int ret, buffer_size, frame_size;
2065 int channel_count = popcount(config->channel_mask);
2066
Eric Laurent994a6932013-07-17 11:51:42 -07002067 ALOGV("%s: enter", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002068 *stream_in = NULL;
2069 if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0)
2070 return -EINVAL;
2071
2072 in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
2073
2074 in->stream.common.get_sample_rate = in_get_sample_rate;
2075 in->stream.common.set_sample_rate = in_set_sample_rate;
2076 in->stream.common.get_buffer_size = in_get_buffer_size;
2077 in->stream.common.get_channels = in_get_channels;
2078 in->stream.common.get_format = in_get_format;
2079 in->stream.common.set_format = in_set_format;
2080 in->stream.common.standby = in_standby;
2081 in->stream.common.dump = in_dump;
2082 in->stream.common.set_parameters = in_set_parameters;
2083 in->stream.common.get_parameters = in_get_parameters;
2084 in->stream.common.add_audio_effect = in_add_audio_effect;
2085 in->stream.common.remove_audio_effect = in_remove_audio_effect;
2086 in->stream.set_gain = in_set_gain;
2087 in->stream.read = in_read;
2088 in->stream.get_input_frames_lost = in_get_input_frames_lost;
2089
2090 in->device = devices;
2091 in->source = AUDIO_SOURCE_DEFAULT;
2092 in->dev = adev;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002093 in->standby = 1;
2094 in->channel_mask = config->channel_mask;
2095
2096 /* Update config params with the requested sample rate and channels */
2097 in->usecase = USECASE_AUDIO_RECORD;
2098 in->config = pcm_config_audio_capture;
2099 in->config.channels = channel_count;
2100 in->config.rate = config->sample_rate;
2101
2102 frame_size = audio_stream_frame_size((struct audio_stream *)in);
2103 buffer_size = get_input_buffer_size(config->sample_rate,
2104 config->format,
2105 channel_count);
2106 in->config.period_size = buffer_size / frame_size;
2107
2108 *stream_in = &in->stream;
Eric Laurent994a6932013-07-17 11:51:42 -07002109 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002110 return 0;
2111
2112err_open:
2113 free(in);
2114 *stream_in = NULL;
2115 return ret;
2116}
2117
2118static void adev_close_input_stream(struct audio_hw_device *dev,
2119 struct audio_stream_in *stream)
2120{
Eric Laurent994a6932013-07-17 11:51:42 -07002121 ALOGV("%s", __func__);
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08002122
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002123 in_standby(&stream->common);
2124 free(stream);
2125
2126 return;
2127}
2128
2129static int adev_dump(const audio_hw_device_t *device, int fd)
2130{
2131 return 0;
2132}
2133
2134static int adev_close(hw_device_t *device)
2135{
2136 struct audio_device *adev = (struct audio_device *)device;
2137 audio_route_free(adev->audio_route);
Eric Laurentb23d5282013-05-14 15:27:20 -07002138 free(adev->snd_dev_ref_cnt);
2139 platform_deinit(adev->platform);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002140 free(device);
2141 return 0;
2142}
2143
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002144static int adev_open(const hw_module_t *module, const char *name,
2145 hw_device_t **device)
2146{
2147 struct audio_device *adev;
Ravi Kumar Alamanda71c84b72013-03-10 23:50:28 -07002148 int i, ret;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002149
Ravi Kumar Alamanda75d924d2013-02-20 21:30:08 -08002150 ALOGD("%s: enter", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002151 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL;
2152
2153 adev = calloc(1, sizeof(struct audio_device));
2154
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002155 adev->device.common.tag = HARDWARE_DEVICE_TAG;
2156 adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
2157 adev->device.common.module = (struct hw_module_t *)module;
2158 adev->device.common.close = adev_close;
2159
2160 adev->device.init_check = adev_init_check;
2161 adev->device.set_voice_volume = adev_set_voice_volume;
2162 adev->device.set_master_volume = adev_set_master_volume;
2163 adev->device.get_master_volume = adev_get_master_volume;
2164 adev->device.set_master_mute = adev_set_master_mute;
2165 adev->device.get_master_mute = adev_get_master_mute;
2166 adev->device.set_mode = adev_set_mode;
2167 adev->device.set_mic_mute = adev_set_mic_mute;
2168 adev->device.get_mic_mute = adev_get_mic_mute;
2169 adev->device.set_parameters = adev_set_parameters;
2170 adev->device.get_parameters = adev_get_parameters;
2171 adev->device.get_input_buffer_size = adev_get_input_buffer_size;
2172 adev->device.open_output_stream = adev_open_output_stream;
2173 adev->device.close_output_stream = adev_close_output_stream;
2174 adev->device.open_input_stream = adev_open_input_stream;
2175 adev->device.close_input_stream = adev_close_input_stream;
2176 adev->device.dump = adev_dump;
2177
2178 /* Set the default route before the PCM stream is opened */
2179 pthread_mutex_lock(&adev->lock);
2180 adev->mode = AUDIO_MODE_NORMAL;
Eric Laurentc8400632013-02-14 19:04:54 -08002181 adev->active_input = NULL;
Ravi Kumar Alamanda096c87f2013-02-28 20:54:57 -08002182 adev->primary_output = NULL;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002183 adev->out_device = AUDIO_DEVICE_NONE;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002184 adev->voice_call_rx = NULL;
2185 adev->voice_call_tx = NULL;
2186 adev->voice_volume = 1.0f;
2187 adev->tty_mode = TTY_MODE_OFF;
2188 adev->bluetooth_nrec = true;
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002189 adev->in_call = false;
Ravi Kumar Alamandaf9967042013-02-14 19:35:14 -08002190 adev->acdb_settings = TTY_MODE_OFF;
Eric Laurentb23d5282013-05-14 15:27:20 -07002191 adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int));
Ravi Kumar Alamanda3b1816c2013-02-27 23:01:21 -08002192 list_init(&adev->usecase_list);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002193 pthread_mutex_unlock(&adev->lock);
2194
2195 /* Loads platform specific libraries dynamically */
Eric Laurentb23d5282013-05-14 15:27:20 -07002196 adev->platform = platform_init(adev);
2197 if (!adev->platform) {
2198 free(adev->snd_dev_ref_cnt);
2199 free(adev);
2200 ALOGE("%s: Failed to init platform data, aborting.", __func__);
2201 *device = NULL;
2202 return -EINVAL;
2203 }
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002204 *device = &adev->device.common;
2205
Eric Laurent994a6932013-07-17 11:51:42 -07002206 ALOGV("%s: exit", __func__);
Ravi Kumar Alamanda2dfba2b2013-01-17 16:50:22 -08002207 return 0;
2208}
2209
2210static struct hw_module_methods_t hal_module_methods = {
2211 .open = adev_open,
2212};
2213
2214struct audio_module HAL_MODULE_INFO_SYM = {
2215 .common = {
2216 .tag = HARDWARE_MODULE_TAG,
2217 .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
2218 .hal_api_version = HARDWARE_HAL_API_VERSION,
2219 .id = AUDIO_HARDWARE_MODULE_ID,
2220 .name = "QCOM Audio HAL",
2221 .author = "Code Aurora Forum",
2222 .methods = &hal_module_methods,
2223 },
2224};