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