audio_hw.c revision a7657196b09d78ffc5d211af5771c66d416354ee 
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 (output_drives_call(adev, out)) {
1342                if (!voice_is_in_call(adev)) {
1343                    if (adev->mode == AUDIO_MODE_IN_CALL) {
1344                        adev->current_call_output = out;
1345                        ret = voice_start_call(adev);
1346                    }
1347                } else {
1348                    adev->current_call_output = out;
1349                    voice_update_devices_for_all_voice_usecases(adev);
1350                }
1351            }
1352        }
1353
1354        pthread_mutex_unlock(&adev->lock);
1355        pthread_mutex_unlock(&out->lock);
1356
1357        /*handles device and call state changes*/
1358        audio_extn_extspk_update(adev->extspk);
1359    }
1360
1361    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1362        parse_compress_metadata(out, parms);
1363    }
1364
1365    str_parms_destroy(parms);
1366    ALOGV("%s: exit: code(%d)", __func__, status);
1367    return status;
1368}
1369
1370static char* out_get_parameters(const struct audio_stream *stream, const char *keys)
1371{
1372    struct stream_out *out = (struct stream_out *)stream;
1373    struct str_parms *query = str_parms_create_str(keys);
1374    char *str;
1375    char value[256];
1376    struct str_parms *reply = str_parms_create();
1377    size_t i, j;
1378    int ret;
1379    bool first = true;
1380    ALOGV("%s: enter: keys - %s", __func__, keys);
1381    ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
1382    if (ret >= 0) {
1383        value[0] = '\0';
1384        i = 0;
1385        while (out->supported_channel_masks[i] != 0) {
1386            for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) {
1387                if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
1388                    if (!first) {
1389                        strcat(value, "|");
1390                    }
1391                    strcat(value, out_channels_name_to_enum_table[j].name);
1392                    first = false;
1393                    break;
1394                }
1395            }
1396            i++;
1397        }
1398        str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
1399        str = str_parms_to_str(reply);
1400    } else {
1401        str = strdup(keys);
1402    }
1403    str_parms_destroy(query);
1404    str_parms_destroy(reply);
1405    ALOGV("%s: exit: returns - %s", __func__, str);
1406    return str;
1407}
1408
1409static uint32_t out_get_latency(const struct audio_stream_out *stream)
1410{
1411    struct stream_out *out = (struct stream_out *)stream;
1412
1413    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
1414        return COMPRESS_OFFLOAD_PLAYBACK_LATENCY;
1415
1416    return (out->config.period_count * out->config.period_size * 1000) /
1417           (out->config.rate);
1418}
1419
1420static int out_set_volume(struct audio_stream_out *stream, float left,
1421                          float right)
1422{
1423    struct stream_out *out = (struct stream_out *)stream;
1424    int volume[2];
1425
1426    if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
1427        /* only take left channel into account: the API is for stereo anyway */
1428        out->muted = (left == 0.0f);
1429        return 0;
1430    } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1431        const char *mixer_ctl_name = "Compress Playback Volume";
1432        struct audio_device *adev = out->dev;
1433        struct mixer_ctl *ctl;
1434        ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
1435        if (!ctl) {
1436            /* try with the control based on device id */
1437            int pcm_device_id = platform_get_pcm_device_id(out->usecase,
1438                                                       PCM_PLAYBACK);
1439            char ctl_name[128] = {0};
1440            snprintf(ctl_name, sizeof(ctl_name),
1441                     "Compress Playback %d Volume", pcm_device_id);
1442            ctl = mixer_get_ctl_by_name(adev->mixer, ctl_name);
1443            if (!ctl) {
1444                ALOGE("%s: Could not get volume ctl mixer cmd", __func__);
1445                return -EINVAL;
1446            }
1447        }
1448        volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX);
1449        volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX);
1450        mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0]));
1451        return 0;
1452    }
1453
1454    return -ENOSYS;
1455}
1456
1457static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
1458                         size_t bytes)
1459{
1460    struct stream_out *out = (struct stream_out *)stream;
1461    struct audio_device *adev = out->dev;
1462    ssize_t ret = 0;
1463
1464    pthread_mutex_lock(&out->lock);
1465    if (out->standby) {
1466        out->standby = false;
1467        pthread_mutex_lock(&adev->lock);
1468        ret = start_output_stream(out);
1469        pthread_mutex_unlock(&adev->lock);
1470        /* ToDo: If use case is compress offload should return 0 */
1471        if (ret != 0) {
1472            out->standby = true;
1473            goto exit;
1474        }
1475    }
1476
1477    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1478        ALOGVV("%s: writing buffer (%d bytes) to compress device", __func__, bytes);
1479        if (out->send_new_metadata) {
1480            ALOGVV("send new gapless metadata");
1481            compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
1482            out->send_new_metadata = 0;
1483        }
1484
1485        ret = compress_write(out->compr, buffer, bytes);
1486        ALOGVV("%s: writing buffer (%d bytes) to compress device returned %d", __func__, bytes, ret);
1487        if (ret >= 0 && ret < (ssize_t)bytes) {
1488            send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER);
1489        }
1490        if (!out->playback_started) {
1491            compress_start(out->compr);
1492            out->playback_started = 1;
1493            out->offload_state = OFFLOAD_STATE_PLAYING;
1494        }
1495        pthread_mutex_unlock(&out->lock);
1496        return ret;
1497    } else {
1498        if (out->pcm) {
1499            if (out->muted)
1500                memset((void *)buffer, 0, bytes);
1501            ALOGVV("%s: writing buffer (%d bytes) to pcm device", __func__, bytes);
1502            if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
1503                ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes);
1504            }
1505            else
1506                ret = pcm_write(out->pcm, (void *)buffer, bytes);
1507            if (ret == 0)
1508                out->written += bytes / (out->config.channels * sizeof(short));
1509        }
1510    }
1511
1512exit:
1513    pthread_mutex_unlock(&out->lock);
1514
1515    if (ret != 0) {
1516        if (out->pcm)
1517            ALOGE("%s: error %d - %s", __func__, ret, pcm_get_error(out->pcm));
1518        out_standby(&out->stream.common);
1519        usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) /
1520               out_get_sample_rate(&out->stream.common));
1521    }
1522    return bytes;
1523}
1524
1525static int out_get_render_position(const struct audio_stream_out *stream,
1526                                   uint32_t *dsp_frames)
1527{
1528    struct stream_out *out = (struct stream_out *)stream;
1529    *dsp_frames = 0;
1530    if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
1531        pthread_mutex_lock(&out->lock);
1532        if (out->compr != NULL) {
1533            compress_get_tstamp(out->compr, (unsigned long *)dsp_frames,
1534                    &out->sample_rate);
1535            ALOGVV("%s rendered frames %d sample_rate %d",
1536                   __func__, *dsp_frames, out->sample_rate);
1537        }
1538        pthread_mutex_unlock(&out->lock);
1539        return 0;
1540    } else
1541        return -EINVAL;
1542}
1543
1544static int out_add_audio_effect(const struct audio_stream *stream __unused,
1545                                effect_handle_t effect __unused)
1546{
1547    return 0;
1548}
1549
1550static int out_remove_audio_effect(const struct audio_stream *stream __unused,
1551                                   effect_handle_t effect __unused)
1552{
1553    return 0;
1554}
1555
1556static int out_get_next_write_timestamp(const struct audio_stream_out *stream __unused,
1557                                        int64_t *timestamp __unused)
1558{
1559    return -EINVAL;
1560}
1561
1562static int out_get_presentation_position(const struct audio_stream_out *stream,
1563                                   uint64_t *frames, struct timespec *timestamp)
1564{
1565    struct stream_out *out = (struct stream_out *)stream;
1566    int ret = -1;
1567    unsigned long dsp_frames;
1568
1569    pthread_mutex_lock(&out->lock);
1570
1571    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1572        if (out->compr != NULL) {
1573            compress_get_tstamp(out->compr, &dsp_frames,
1574                    &out->sample_rate);
1575            ALOGVV("%s rendered frames %ld sample_rate %d",
1576                   __func__, dsp_frames, out->sample_rate);
1577            *frames = dsp_frames;
1578            ret = 0;
1579            /* this is the best we can do */
1580            clock_gettime(CLOCK_MONOTONIC, timestamp);
1581        }
1582    } else {
1583        if (out->pcm) {
1584            size_t avail;
1585            if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
1586                size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
1587                int64_t signed_frames = out->written - kernel_buffer_size + avail;
1588                // This adjustment accounts for buffering after app processor.
1589                // It is based on estimated DSP latency per use case, rather than exact.
1590                signed_frames -=
1591                    (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
1592
1593                // It would be unusual for this value to be negative, but check just in case ...
1594                if (signed_frames >= 0) {
1595                    *frames = signed_frames;
1596                    ret = 0;
1597                }
1598            }
1599        }
1600    }
1601
1602    pthread_mutex_unlock(&out->lock);
1603
1604    return ret;
1605}
1606
1607static int out_set_callback(struct audio_stream_out *stream,
1608            stream_callback_t callback, void *cookie)
1609{
1610    struct stream_out *out = (struct stream_out *)stream;
1611
1612    ALOGV("%s", __func__);
1613    pthread_mutex_lock(&out->lock);
1614    out->offload_callback = callback;
1615    out->offload_cookie = cookie;
1616    pthread_mutex_unlock(&out->lock);
1617    return 0;
1618}
1619
1620static int out_pause(struct audio_stream_out* stream)
1621{
1622    struct stream_out *out = (struct stream_out *)stream;
1623    int status = -ENOSYS;
1624    ALOGV("%s", __func__);
1625    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1626        pthread_mutex_lock(&out->lock);
1627        if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) {
1628            status = compress_pause(out->compr);
1629            out->offload_state = OFFLOAD_STATE_PAUSED;
1630        }
1631        pthread_mutex_unlock(&out->lock);
1632    }
1633    return status;
1634}
1635
1636static int out_resume(struct audio_stream_out* stream)
1637{
1638    struct stream_out *out = (struct stream_out *)stream;
1639    int status = -ENOSYS;
1640    ALOGV("%s", __func__);
1641    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1642        status = 0;
1643        pthread_mutex_lock(&out->lock);
1644        if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) {
1645            status = compress_resume(out->compr);
1646            out->offload_state = OFFLOAD_STATE_PLAYING;
1647        }
1648        pthread_mutex_unlock(&out->lock);
1649    }
1650    return status;
1651}
1652
1653static int out_drain(struct audio_stream_out* stream, audio_drain_type_t type )
1654{
1655    struct stream_out *out = (struct stream_out *)stream;
1656    int status = -ENOSYS;
1657    ALOGV("%s", __func__);
1658    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1659        pthread_mutex_lock(&out->lock);
1660        if (type == AUDIO_DRAIN_EARLY_NOTIFY)
1661            status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN);
1662        else
1663            status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN);
1664        pthread_mutex_unlock(&out->lock);
1665    }
1666    return status;
1667}
1668
1669static int out_flush(struct audio_stream_out* stream)
1670{
1671    struct stream_out *out = (struct stream_out *)stream;
1672    ALOGV("%s", __func__);
1673    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1674        pthread_mutex_lock(&out->lock);
1675        stop_compressed_output_l(out);
1676        pthread_mutex_unlock(&out->lock);
1677        return 0;
1678    }
1679    return -ENOSYS;
1680}
1681
1682/** audio_stream_in implementation **/
1683static uint32_t in_get_sample_rate(const struct audio_stream *stream)
1684{
1685    struct stream_in *in = (struct stream_in *)stream;
1686
1687    return in->config.rate;
1688}
1689
1690static int in_set_sample_rate(struct audio_stream *stream __unused, uint32_t rate __unused)
1691{
1692    return -ENOSYS;
1693}
1694
1695static size_t in_get_buffer_size(const struct audio_stream *stream)
1696{
1697    struct stream_in *in = (struct stream_in *)stream;
1698
1699    return in->config.period_size *
1700                audio_stream_in_frame_size((const struct audio_stream_in *)stream);
1701}
1702
1703static uint32_t in_get_channels(const struct audio_stream *stream)
1704{
1705    struct stream_in *in = (struct stream_in *)stream;
1706
1707    return in->channel_mask;
1708}
1709
1710static audio_format_t in_get_format(const struct audio_stream *stream __unused)
1711{
1712    return AUDIO_FORMAT_PCM_16_BIT;
1713}
1714
1715static int in_set_format(struct audio_stream *stream __unused, audio_format_t format __unused)
1716{
1717    return -ENOSYS;
1718}
1719
1720static int in_standby(struct audio_stream *stream)
1721{
1722    struct stream_in *in = (struct stream_in *)stream;
1723    struct audio_device *adev = in->dev;
1724    int status = 0;
1725    ALOGV("%s: enter", __func__);
1726    pthread_mutex_lock(&in->lock);
1727    if (!in->standby) {
1728        pthread_mutex_lock(&adev->lock);
1729        in->standby = true;
1730        if (in->pcm) {
1731            pcm_close(in->pcm);
1732            in->pcm = NULL;
1733        }
1734        status = stop_input_stream(in);
1735        pthread_mutex_unlock(&adev->lock);
1736    }
1737    pthread_mutex_unlock(&in->lock);
1738    ALOGV("%s: exit:  status(%d)", __func__, status);
1739    return status;
1740}
1741
1742static int in_dump(const struct audio_stream *stream __unused, int fd __unused)
1743{
1744    return 0;
1745}
1746
1747static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
1748{
1749    struct stream_in *in = (struct stream_in *)stream;
1750    struct audio_device *adev = in->dev;
1751    struct str_parms *parms;
1752    char *str;
1753    char value[32];
1754    int ret, val = 0;
1755    int status = 0;
1756
1757    ALOGV("%s: enter: kvpairs=%s", __func__, kvpairs);
1758    parms = str_parms_create_str(kvpairs);
1759
1760    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
1761
1762    pthread_mutex_lock(&in->lock);
1763    pthread_mutex_lock(&adev->lock);
1764    if (ret >= 0) {
1765        val = atoi(value);
1766        /* no audio source uses val == 0 */
1767        if ((in->source != val) && (val != 0)) {
1768            in->source = val;
1769        }
1770    }
1771
1772    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
1773
1774    if (ret >= 0) {
1775        val = atoi(value);
1776        if (((int)in->device != val) && (val != 0)) {
1777            in->device = val;
1778            /* If recording is in progress, change the tx device to new device */
1779            if (!in->standby)
1780                status = select_devices(adev, in->usecase);
1781        }
1782    }
1783
1784    pthread_mutex_unlock(&adev->lock);
1785    pthread_mutex_unlock(&in->lock);
1786
1787    str_parms_destroy(parms);
1788    ALOGV("%s: exit: status(%d)", __func__, status);
1789    return status;
1790}
1791
1792static char* in_get_parameters(const struct audio_stream *stream __unused,
1793                               const char *keys __unused)
1794{
1795    return strdup("");
1796}
1797
1798static int in_set_gain(struct audio_stream_in *stream __unused, float gain __unused)
1799{
1800    return 0;
1801}
1802
1803static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
1804                       size_t bytes)
1805{
1806    struct stream_in *in = (struct stream_in *)stream;
1807    struct audio_device *adev = in->dev;
1808    int i, ret = -1;
1809
1810    pthread_mutex_lock(&in->lock);
1811    if (in->standby) {
1812        pthread_mutex_lock(&adev->lock);
1813        ret = start_input_stream(in);
1814        pthread_mutex_unlock(&adev->lock);
1815        if (ret != 0) {
1816            goto exit;
1817        }
1818        in->standby = 0;
1819    }
1820
1821    if (in->pcm) {
1822        if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY) {
1823            ret = pcm_mmap_read(in->pcm, buffer, bytes);
1824        } else
1825            ret = pcm_read(in->pcm, buffer, bytes);
1826    }
1827
1828    /*
1829     * Instead of writing zeroes here, we could trust the hardware
1830     * to always provide zeroes when muted.
1831     * No need to acquire adev->lock to read mic_muted here as we don't change its state.
1832     */
1833    if (ret == 0 && adev->mic_muted && in->usecase != USECASE_AUDIO_RECORD_AFE_PROXY)
1834        memset(buffer, 0, bytes);
1835
1836exit:
1837    pthread_mutex_unlock(&in->lock);
1838
1839    if (ret != 0) {
1840        in_standby(&in->stream.common);
1841        ALOGV("%s: read failed - sleeping for buffer duration", __func__);
1842        usleep(bytes * 1000000 / audio_stream_in_frame_size(stream) /
1843               in_get_sample_rate(&in->stream.common));
1844    }
1845    return bytes;
1846}
1847
1848static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream __unused)
1849{
1850    return 0;
1851}
1852
1853static int add_remove_audio_effect(const struct audio_stream *stream,
1854                                   effect_handle_t effect,
1855                                   bool enable)
1856{
1857    struct stream_in *in = (struct stream_in *)stream;
1858    int status = 0;
1859    effect_descriptor_t desc;
1860
1861    status = (*effect)->get_descriptor(effect, &desc);
1862    if (status != 0)
1863        return status;
1864
1865    pthread_mutex_lock(&in->lock);
1866    pthread_mutex_lock(&in->dev->lock);
1867    if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) &&
1868            in->enable_aec != enable &&
1869            (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) {
1870        in->enable_aec = enable;
1871        if (!in->standby)
1872            select_devices(in->dev, in->usecase);
1873    }
1874    if (in->enable_ns != enable &&
1875            (memcmp(&desc.type, FX_IID_NS, sizeof(effect_uuid_t)) == 0)) {
1876        in->enable_ns = enable;
1877        if (!in->standby)
1878            select_devices(in->dev, in->usecase);
1879    }
1880    pthread_mutex_unlock(&in->dev->lock);
1881    pthread_mutex_unlock(&in->lock);
1882
1883    return 0;
1884}
1885
1886static int in_add_audio_effect(const struct audio_stream *stream,
1887                               effect_handle_t effect)
1888{
1889    ALOGV("%s: effect %p", __func__, effect);
1890    return add_remove_audio_effect(stream, effect, true);
1891}
1892
1893static int in_remove_audio_effect(const struct audio_stream *stream,
1894                                  effect_handle_t effect)
1895{
1896    ALOGV("%s: effect %p", __func__, effect);
1897    return add_remove_audio_effect(stream, effect, false);
1898}
1899
1900static int adev_open_output_stream(struct audio_hw_device *dev,
1901                                   audio_io_handle_t handle,
1902                                   audio_devices_t devices,
1903                                   audio_output_flags_t flags,
1904                                   struct audio_config *config,
1905                                   struct audio_stream_out **stream_out,
1906                                   const char *address __unused)
1907{
1908    struct audio_device *adev = (struct audio_device *)dev;
1909    struct stream_out *out;
1910    int i, ret;
1911
1912    ALOGV("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)",
1913          __func__, config->sample_rate, config->channel_mask, devices, flags);
1914    *stream_out = NULL;
1915    out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
1916
1917    if (devices == AUDIO_DEVICE_NONE)
1918        devices = AUDIO_DEVICE_OUT_SPEAKER;
1919
1920    out->flags = flags;
1921    out->devices = devices;
1922    out->dev = adev;
1923    out->format = config->format;
1924    out->sample_rate = config->sample_rate;
1925    out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1926    out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
1927    out->handle = handle;
1928
1929    /* Init use case and pcm_config */
1930    if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
1931            !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
1932        out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1933        pthread_mutex_lock(&adev->lock);
1934        ret = read_hdmi_channel_masks(out);
1935        pthread_mutex_unlock(&adev->lock);
1936        if (ret != 0)
1937            goto error_open;
1938
1939        if (config->sample_rate == 0)
1940            config->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
1941        if (config->channel_mask == 0)
1942            config->channel_mask = AUDIO_CHANNEL_OUT_5POINT1;
1943
1944        out->channel_mask = config->channel_mask;
1945        out->sample_rate = config->sample_rate;
1946        out->usecase = USECASE_AUDIO_PLAYBACK_MULTI_CH;
1947        out->config = pcm_config_hdmi_multi;
1948        out->config.rate = config->sample_rate;
1949        out->config.channels = audio_channel_count_from_out_mask(out->channel_mask);
1950        out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels * 2);
1951    } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
1952        if (config->offload_info.version != AUDIO_INFO_INITIALIZER.version ||
1953            config->offload_info.size != AUDIO_INFO_INITIALIZER.size) {
1954            ALOGE("%s: Unsupported Offload information", __func__);
1955            ret = -EINVAL;
1956            goto error_open;
1957        }
1958        if (!is_supported_format(config->offload_info.format)) {
1959            ALOGE("%s: Unsupported audio format", __func__);
1960            ret = -EINVAL;
1961            goto error_open;
1962        }
1963
1964        out->compr_config.codec = (struct snd_codec *)
1965                                    calloc(1, sizeof(struct snd_codec));
1966
1967        out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
1968        if (config->offload_info.channel_mask)
1969            out->channel_mask = config->offload_info.channel_mask;
1970        else if (config->channel_mask)
1971            out->channel_mask = config->channel_mask;
1972        out->format = config->offload_info.format;
1973        out->sample_rate = config->offload_info.sample_rate;
1974
1975        out->stream.set_callback = out_set_callback;
1976        out->stream.pause = out_pause;
1977        out->stream.resume = out_resume;
1978        out->stream.drain = out_drain;
1979        out->stream.flush = out_flush;
1980
1981        out->compr_config.codec->id =
1982                get_snd_codec_id(config->offload_info.format);
1983        out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE;
1984        out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS;
1985        out->compr_config.codec->sample_rate =
1986                    compress_get_alsa_rate(config->offload_info.sample_rate);
1987        out->compr_config.codec->bit_rate =
1988                    config->offload_info.bit_rate;
1989        out->compr_config.codec->ch_in =
1990                audio_channel_count_from_out_mask(config->channel_mask);
1991        out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
1992
1993        if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING)
1994            out->non_blocking = 1;
1995
1996        out->send_new_metadata = 1;
1997        create_offload_callback_thread(out);
1998        ALOGV("%s: offloaded output offload_info version %04x bit rate %d",
1999                __func__, config->offload_info.version,
2000                config->offload_info.bit_rate);
2001    } else  if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) {
2002        if (config->sample_rate == 0)
2003            config->sample_rate = AFE_PROXY_SAMPLING_RATE;
2004        if (config->sample_rate != 48000 && config->sample_rate != 16000 &&
2005                config->sample_rate != 8000) {
2006            config->sample_rate = AFE_PROXY_SAMPLING_RATE;
2007            ret = -EINVAL;
2008            goto error_open;
2009        }
2010        out->sample_rate = config->sample_rate;
2011        out->config.rate = config->sample_rate;
2012        if (config->format == AUDIO_FORMAT_DEFAULT)
2013            config->format = AUDIO_FORMAT_PCM_16_BIT;
2014        if (config->format != AUDIO_FORMAT_PCM_16_BIT) {
2015            config->format = AUDIO_FORMAT_PCM_16_BIT;
2016            ret = -EINVAL;
2017            goto error_open;
2018        }
2019        out->format = config->format;
2020        out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
2021        out->config = pcm_config_afe_proxy_playback;
2022        adev->voice_tx_output = out;
2023    } else {
2024        if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) {
2025            out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
2026            out->config = pcm_config_deep_buffer;
2027        } else {
2028            out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
2029            out->config = pcm_config_low_latency;
2030        }
2031        if (config->format != audio_format_from_pcm_format(out->config.format)) {
2032            if (k_enable_extended_precision
2033                    && pcm_params_format_test(adev->use_case_table[out->usecase],
2034                            pcm_format_from_audio_format(config->format))) {
2035                out->config.format = pcm_format_from_audio_format(config->format);
2036                /* out->format already set to config->format */
2037            } else {
2038                /* deny the externally proposed config format
2039                 * and use the one specified in audio_hw layer configuration.
2040                 * Note: out->format is returned by out->stream.common.get_format()
2041                 * and is used to set config->format in the code several lines below.
2042                 */
2043                out->format = audio_format_from_pcm_format(out->config.format);
2044            }
2045        }
2046        out->sample_rate = out->config.rate;
2047    }
2048    ALOGV("%s: Usecase(%s) config->format %#x  out->config.format %#x\n",
2049            __func__, use_case_table[out->usecase], config->format, out->config.format);
2050
2051    if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) {
2052        if (adev->primary_output == NULL)
2053            adev->primary_output = out;
2054        else {
2055            ALOGE("%s: Primary output is already opened", __func__);
2056            ret = -EEXIST;
2057            goto error_open;
2058        }
2059    }
2060
2061    /* Check if this usecase is already existing */
2062    pthread_mutex_lock(&adev->lock);
2063    if (get_usecase_from_list(adev, out->usecase) != NULL) {
2064        ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
2065        pthread_mutex_unlock(&adev->lock);
2066        ret = -EEXIST;
2067        goto error_open;
2068    }
2069    pthread_mutex_unlock(&adev->lock);
2070
2071    out->stream.common.get_sample_rate = out_get_sample_rate;
2072    out->stream.common.set_sample_rate = out_set_sample_rate;
2073    out->stream.common.get_buffer_size = out_get_buffer_size;
2074    out->stream.common.get_channels = out_get_channels;
2075    out->stream.common.get_format = out_get_format;
2076    out->stream.common.set_format = out_set_format;
2077    out->stream.common.standby = out_standby;
2078    out->stream.common.dump = out_dump;
2079    out->stream.common.set_parameters = out_set_parameters;
2080    out->stream.common.get_parameters = out_get_parameters;
2081    out->stream.common.add_audio_effect = out_add_audio_effect;
2082    out->stream.common.remove_audio_effect = out_remove_audio_effect;
2083    out->stream.get_latency = out_get_latency;
2084    out->stream.set_volume = out_set_volume;
2085    out->stream.write = out_write;
2086    out->stream.get_render_position = out_get_render_position;
2087    out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
2088    out->stream.get_presentation_position = out_get_presentation_position;
2089
2090    out->standby = 1;
2091    /* out->muted = false; by calloc() */
2092    /* out->written = 0; by calloc() */
2093
2094    pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
2095    pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
2096
2097    config->format = out->stream.common.get_format(&out->stream.common);
2098    config->channel_mask = out->stream.common.get_channels(&out->stream.common);
2099    config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
2100
2101    *stream_out = &out->stream;
2102    ALOGV("%s: exit", __func__);
2103    return 0;
2104
2105error_open:
2106    free(out);
2107    *stream_out = NULL;
2108    ALOGD("%s: exit: ret %d", __func__, ret);
2109    return ret;
2110}
2111
2112static void adev_close_output_stream(struct audio_hw_device *dev __unused,
2113                                     struct audio_stream_out *stream)
2114{
2115    struct stream_out *out = (struct stream_out *)stream;
2116    struct audio_device *adev = out->dev;
2117
2118    ALOGV("%s: enter", __func__);
2119    out_standby(&stream->common);
2120    if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2121        destroy_offload_callback_thread(out);
2122
2123        if (out->compr_config.codec != NULL)
2124            free(out->compr_config.codec);
2125    }
2126
2127    if (adev->voice_tx_output == out)
2128        adev->voice_tx_output = NULL;
2129
2130    pthread_cond_destroy(&out->cond);
2131    pthread_mutex_destroy(&out->lock);
2132    free(stream);
2133    ALOGV("%s: exit", __func__);
2134}
2135
2136static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
2137{
2138    struct audio_device *adev = (struct audio_device *)dev;
2139    struct str_parms *parms;
2140    char *str;
2141    char value[32];
2142    int val;
2143    int ret;
2144    int status = 0;
2145
2146    ALOGD("%s: enter: %s", __func__, kvpairs);
2147
2148    pthread_mutex_lock(&adev->lock);
2149
2150    parms = str_parms_create_str(kvpairs);
2151    status = voice_set_parameters(adev, parms);
2152    if (status != 0) {
2153        goto done;
2154    }
2155
2156    ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
2157    if (ret >= 0) {
2158        /* When set to false, HAL should disable EC and NS
2159         * But it is currently not supported.
2160         */
2161        if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
2162            adev->bluetooth_nrec = true;
2163        else
2164            adev->bluetooth_nrec = false;
2165    }
2166
2167    ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
2168    if (ret >= 0) {
2169        if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
2170            adev->screen_off = false;
2171        else
2172            adev->screen_off = true;
2173    }
2174
2175    ret = str_parms_get_int(parms, "rotation", &val);
2176    if (ret >= 0) {
2177        bool reverse_speakers = false;
2178        switch(val) {
2179        // FIXME: note that the code below assumes that the speakers are in the correct placement
2180        //   relative to the user when the device is rotated 90deg from its default rotation. This
2181        //   assumption is device-specific, not platform-specific like this code.
2182        case 270:
2183            reverse_speakers = true;
2184            break;
2185        case 0:
2186        case 90:
2187        case 180:
2188            break;
2189        default:
2190            ALOGE("%s: unexpected rotation of %d", __func__, val);
2191            status = -EINVAL;
2192        }
2193        if (status == 0) {
2194            if (adev->speaker_lr_swap != reverse_speakers) {
2195                adev->speaker_lr_swap = reverse_speakers;
2196                // only update the selected device if there is active pcm playback
2197                struct audio_usecase *usecase;
2198                struct listnode *node;
2199                list_for_each(node, &adev->usecase_list) {
2200                    usecase = node_to_item(node, struct audio_usecase, list);
2201                    if (usecase->type == PCM_PLAYBACK) {
2202                        select_devices(adev, usecase->id);
2203                        break;
2204                    }
2205                }
2206            }
2207        }
2208    }
2209
2210    ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_SCO_WB, value, sizeof(value));
2211    if (ret >= 0) {
2212        adev->bt_wb_speech_enabled = !strcmp(value, AUDIO_PARAMETER_VALUE_ON);
2213    }
2214
2215    audio_extn_hfp_set_parameters(adev, parms);
2216done:
2217    str_parms_destroy(parms);
2218    pthread_mutex_unlock(&adev->lock);
2219    ALOGV("%s: exit with code(%d)", __func__, status);
2220    return status;
2221}
2222
2223static char* adev_get_parameters(const struct audio_hw_device *dev,
2224                                 const char *keys)
2225{
2226    struct audio_device *adev = (struct audio_device *)dev;
2227    struct str_parms *reply = str_parms_create();
2228    struct str_parms *query = str_parms_create_str(keys);
2229    char *str;
2230
2231    pthread_mutex_lock(&adev->lock);
2232
2233    voice_get_parameters(adev, query, reply);
2234    str = str_parms_to_str(reply);
2235    str_parms_destroy(query);
2236    str_parms_destroy(reply);
2237
2238    pthread_mutex_unlock(&adev->lock);
2239    ALOGV("%s: exit: returns - %s", __func__, str);
2240    return str;
2241}
2242
2243static int adev_init_check(const struct audio_hw_device *dev __unused)
2244{
2245    return 0;
2246}
2247
2248static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
2249{
2250    int ret;
2251    struct audio_device *adev = (struct audio_device *)dev;
2252
2253    audio_extn_extspk_set_voice_vol(adev->extspk, volume);
2254
2255    pthread_mutex_lock(&adev->lock);
2256    ret = voice_set_volume(adev, volume);
2257    pthread_mutex_unlock(&adev->lock);
2258
2259    return ret;
2260}
2261
2262static int adev_set_master_volume(struct audio_hw_device *dev __unused, float volume __unused)
2263{
2264    return -ENOSYS;
2265}
2266
2267static int adev_get_master_volume(struct audio_hw_device *dev __unused,
2268                                  float *volume __unused)
2269{
2270    return -ENOSYS;
2271}
2272
2273static int adev_set_master_mute(struct audio_hw_device *dev __unused, bool muted __unused)
2274{
2275    return -ENOSYS;
2276}
2277
2278static int adev_get_master_mute(struct audio_hw_device *dev __unused, bool *muted __unused)
2279{
2280    return -ENOSYS;
2281}
2282
2283static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
2284{
2285    struct audio_device *adev = (struct audio_device *)dev;
2286
2287    pthread_mutex_lock(&adev->lock);
2288    if (adev->mode != mode) {
2289        ALOGD("%s: mode %d\n", __func__, mode);
2290        adev->mode = mode;
2291        if ((mode == AUDIO_MODE_NORMAL || mode == AUDIO_MODE_IN_COMMUNICATION) &&
2292                voice_is_in_call(adev)) {
2293            voice_stop_call(adev);
2294            adev->current_call_output = NULL;
2295        }
2296    }
2297    pthread_mutex_unlock(&adev->lock);
2298
2299    audio_extn_extspk_set_mode(adev->extspk, mode);
2300
2301    return 0;
2302}
2303
2304static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
2305{
2306    int ret;
2307    struct audio_device *adev = (struct audio_device *)dev;
2308
2309    ALOGD("%s: state %d\n", __func__, state);
2310    pthread_mutex_lock(&adev->lock);
2311    ret = voice_set_mic_mute(adev, state);
2312    adev->mic_muted = state;
2313    pthread_mutex_unlock(&adev->lock);
2314
2315    return ret;
2316}
2317
2318static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
2319{
2320    *state = voice_get_mic_mute((struct audio_device *)dev);
2321    return 0;
2322}
2323
2324static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev __unused,
2325                                         const struct audio_config *config)
2326{
2327    int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
2328
2329    return get_input_buffer_size(config->sample_rate, config->format, channel_count,
2330            false /* is_low_latency: since we don't know, be conservative */);
2331}
2332
2333static int adev_open_input_stream(struct audio_hw_device *dev,
2334                                  audio_io_handle_t handle __unused,
2335                                  audio_devices_t devices,
2336                                  struct audio_config *config,
2337                                  struct audio_stream_in **stream_in,
2338                                  audio_input_flags_t flags,
2339                                  const char *address __unused,
2340                                  audio_source_t source __unused)
2341{
2342    struct audio_device *adev = (struct audio_device *)dev;
2343    struct stream_in *in;
2344    int ret = 0, buffer_size, frame_size;
2345    int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
2346    bool is_low_latency = false;
2347
2348    ALOGV("%s: enter", __func__);
2349    *stream_in = NULL;
2350    if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0)
2351        return -EINVAL;
2352
2353    in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
2354
2355    pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL);
2356
2357    in->stream.common.get_sample_rate = in_get_sample_rate;
2358    in->stream.common.set_sample_rate = in_set_sample_rate;
2359    in->stream.common.get_buffer_size = in_get_buffer_size;
2360    in->stream.common.get_channels = in_get_channels;
2361    in->stream.common.get_format = in_get_format;
2362    in->stream.common.set_format = in_set_format;
2363    in->stream.common.standby = in_standby;
2364    in->stream.common.dump = in_dump;
2365    in->stream.common.set_parameters = in_set_parameters;
2366    in->stream.common.get_parameters = in_get_parameters;
2367    in->stream.common.add_audio_effect = in_add_audio_effect;
2368    in->stream.common.remove_audio_effect = in_remove_audio_effect;
2369    in->stream.set_gain = in_set_gain;
2370    in->stream.read = in_read;
2371    in->stream.get_input_frames_lost = in_get_input_frames_lost;
2372
2373    in->device = devices;
2374    in->source = AUDIO_SOURCE_DEFAULT;
2375    in->dev = adev;
2376    in->standby = 1;
2377    in->channel_mask = config->channel_mask;
2378
2379    /* Update config params with the requested sample rate and channels */
2380    if (in->device == AUDIO_DEVICE_IN_TELEPHONY_RX) {
2381        if (config->sample_rate == 0)
2382            config->sample_rate = AFE_PROXY_SAMPLING_RATE;
2383        if (config->sample_rate != 48000 && config->sample_rate != 16000 &&
2384                config->sample_rate != 8000) {
2385            config->sample_rate = AFE_PROXY_SAMPLING_RATE;
2386            ret = -EINVAL;
2387            goto err_open;
2388        }
2389        if (config->format == AUDIO_FORMAT_DEFAULT)
2390            config->format = AUDIO_FORMAT_PCM_16_BIT;
2391        if (config->format != AUDIO_FORMAT_PCM_16_BIT) {
2392            config->format = AUDIO_FORMAT_PCM_16_BIT;
2393            ret = -EINVAL;
2394            goto err_open;
2395        }
2396
2397        in->usecase = USECASE_AUDIO_RECORD_AFE_PROXY;
2398        in->config = pcm_config_afe_proxy_record;
2399    } else {
2400        in->usecase = USECASE_AUDIO_RECORD;
2401        if (config->sample_rate == LOW_LATENCY_CAPTURE_SAMPLE_RATE &&
2402                (flags & AUDIO_INPUT_FLAG_FAST) != 0) {
2403            is_low_latency = true;
2404#if LOW_LATENCY_CAPTURE_USE_CASE
2405            in->usecase = USECASE_AUDIO_RECORD_LOW_LATENCY;
2406#endif
2407        }
2408        in->config = pcm_config_audio_capture;
2409
2410        frame_size = audio_stream_in_frame_size(&in->stream);
2411        buffer_size = get_input_buffer_size(config->sample_rate,
2412                                            config->format,
2413                                            channel_count,
2414                                            is_low_latency);
2415        in->config.period_size = buffer_size / frame_size;
2416    }
2417    in->config.channels = channel_count;
2418    in->config.rate = config->sample_rate;
2419
2420
2421    *stream_in = &in->stream;
2422    ALOGV("%s: exit", __func__);
2423    return 0;
2424
2425err_open:
2426    free(in);
2427    *stream_in = NULL;
2428    return ret;
2429}
2430
2431static void adev_close_input_stream(struct audio_hw_device *dev __unused,
2432                                    struct audio_stream_in *stream)
2433{
2434    ALOGV("%s", __func__);
2435
2436    in_standby(&stream->common);
2437    free(stream);
2438
2439    return;
2440}
2441
2442static int adev_dump(const audio_hw_device_t *device __unused, int fd __unused)
2443{
2444    return 0;
2445}
2446
2447/* verifies input and output devices and their capabilities.
2448 *
2449 * This verification is required when enabling extended bit-depth or
2450 * sampling rates, as not all qcom products support it.
2451 *
2452 * Suitable for calling only on initialization such as adev_open().
2453 * It fills the audio_device use_case_table[] array.
2454 *
2455 * Has a side-effect that it needs to configure audio routing / devices
2456 * in order to power up the devices and read the device parameters.
2457 * It does not acquire any hw device lock. Should restore the devices
2458 * back to "normal state" upon completion.
2459 */
2460static int adev_verify_devices(struct audio_device *adev)
2461{
2462    /* enumeration is a bit difficult because one really wants to pull
2463     * the use_case, device id, etc from the hidden pcm_device_table[].
2464     * In this case there are the following use cases and device ids.
2465     *
2466     * [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {0, 0},
2467     * [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {15, 15},
2468     * [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {1, 1},
2469     * [USECASE_AUDIO_PLAYBACK_OFFLOAD] = {9, 9},
2470     * [USECASE_AUDIO_RECORD] = {0, 0},
2471     * [USECASE_AUDIO_RECORD_LOW_LATENCY] = {15, 15},
2472     * [USECASE_VOICE_CALL] = {2, 2},
2473     *
2474     * USECASE_AUDIO_PLAYBACK_OFFLOAD, USECASE_AUDIO_PLAYBACK_MULTI_CH omitted.
2475     * USECASE_VOICE_CALL omitted, but possible for either input or output.
2476     */
2477
2478    /* should be the usecases enabled in adev_open_input_stream() */
2479    static const int test_in_usecases[] = {
2480             USECASE_AUDIO_RECORD,
2481             USECASE_AUDIO_RECORD_LOW_LATENCY, /* does not appear to be used */
2482    };
2483    /* should be the usecases enabled in adev_open_output_stream()*/
2484    static const int test_out_usecases[] = {
2485            USECASE_AUDIO_PLAYBACK_DEEP_BUFFER,
2486            USECASE_AUDIO_PLAYBACK_LOW_LATENCY,
2487    };
2488    static const usecase_type_t usecase_type_by_dir[] = {
2489            PCM_PLAYBACK,
2490            PCM_CAPTURE,
2491    };
2492    static const unsigned flags_by_dir[] = {
2493            PCM_OUT,
2494            PCM_IN,
2495    };
2496
2497    size_t i;
2498    unsigned dir;
2499    const unsigned card_id = adev->snd_card;
2500    char info[512]; /* for possible debug info */
2501
2502    for (dir = 0; dir < 2; ++dir) {
2503        const usecase_type_t usecase_type = usecase_type_by_dir[dir];
2504        const unsigned flags_dir = flags_by_dir[dir];
2505        const size_t testsize =
2506                dir ? ARRAY_SIZE(test_in_usecases) : ARRAY_SIZE(test_out_usecases);
2507        const int *testcases =
2508                dir ? test_in_usecases : test_out_usecases;
2509        const audio_devices_t audio_device =
2510                dir ? AUDIO_DEVICE_IN_BUILTIN_MIC : AUDIO_DEVICE_OUT_SPEAKER;
2511
2512        for (i = 0; i < testsize; ++i) {
2513            const audio_usecase_t audio_usecase = testcases[i];
2514            int device_id;
2515            snd_device_t snd_device;
2516            struct pcm_params **pparams;
2517            struct stream_out out;
2518            struct stream_in in;
2519            struct audio_usecase uc_info;
2520            int retval;
2521
2522            pparams = &adev->use_case_table[audio_usecase];
2523            pcm_params_free(*pparams); /* can accept null input */
2524            *pparams = NULL;
2525
2526            /* find the device ID for the use case (signed, for error) */
2527            device_id = platform_get_pcm_device_id(audio_usecase, usecase_type);
2528            if (device_id < 0)
2529                continue;
2530
2531            /* prepare structures for device probing */
2532            memset(&uc_info, 0, sizeof(uc_info));
2533            uc_info.id = audio_usecase;
2534            uc_info.type = usecase_type;
2535            if (dir) {
2536                adev->active_input = &in;
2537                memset(&in, 0, sizeof(in));
2538                in.device = audio_device;
2539                in.source = AUDIO_SOURCE_VOICE_COMMUNICATION;
2540                uc_info.stream.in = &in;
2541            }  else {
2542                adev->active_input = NULL;
2543            }
2544            memset(&out, 0, sizeof(out));
2545            out.devices = audio_device; /* only field needed in select_devices */
2546            uc_info.stream.out = &out;
2547            uc_info.devices = audio_device;
2548            uc_info.in_snd_device = SND_DEVICE_NONE;
2549            uc_info.out_snd_device = SND_DEVICE_NONE;
2550            list_add_tail(&adev->usecase_list, &uc_info.list);
2551
2552            /* select device - similar to start_(in/out)put_stream() */
2553            retval = select_devices(adev, audio_usecase);
2554            if (retval >= 0) {
2555                *pparams = pcm_params_get(card_id, device_id, flags_dir);
2556#if LOG_NDEBUG == 0
2557                if (*pparams) {
2558                    ALOGV("%s: (%s) card %d  device %d", __func__,
2559                            dir ? "input" : "output", card_id, device_id);
2560                    pcm_params_to_string(*pparams, info, ARRAY_SIZE(info));
2561                    ALOGV(info); /* print parameters */
2562                } else {
2563                    ALOGV("%s: cannot locate card %d  device %d", __func__, card_id, device_id);
2564                }
2565#endif
2566            }
2567
2568            /* deselect device - similar to stop_(in/out)put_stream() */
2569            /* 1. Get and set stream specific mixer controls */
2570            retval = disable_audio_route(adev, &uc_info);
2571            /* 2. Disable the rx device */
2572            retval = disable_snd_device(adev,
2573                    dir ? uc_info.in_snd_device : uc_info.out_snd_device);
2574            list_remove(&uc_info.list);
2575        }
2576    }
2577    adev->active_input = NULL; /* restore adev state */
2578    return 0;
2579}
2580
2581static int adev_close(hw_device_t *device)
2582{
2583    size_t i;
2584    struct audio_device *adev = (struct audio_device *)device;
2585    audio_route_free(adev->audio_route);
2586    free(adev->snd_dev_ref_cnt);
2587    platform_deinit(adev->platform);
2588    audio_extn_extspk_deinit(adev->extspk);
2589    for (i = 0; i < ARRAY_SIZE(adev->use_case_table); ++i) {
2590        pcm_params_free(adev->use_case_table[i]);
2591    }
2592    free(device);
2593    return 0;
2594}
2595
2596/* This returns 1 if the input parameter looks at all plausible as a low latency period size,
2597 * or 0 otherwise.  A return value of 1 doesn't mean the value is guaranteed to work,
2598 * just that it _might_ work.
2599 */
2600static int period_size_is_plausible_for_low_latency(int period_size)
2601{
2602    switch (period_size) {
2603    case 160:
2604    case 240:
2605    case 320:
2606    case 480:
2607        return 1;
2608    default:
2609        return 0;
2610    }
2611}
2612
2613static int adev_open(const hw_module_t *module, const char *name,
2614                     hw_device_t **device)
2615{
2616    struct audio_device *adev;
2617    int i, ret;
2618
2619    ALOGD("%s: enter", __func__);
2620    if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL;
2621
2622    adev = calloc(1, sizeof(struct audio_device));
2623
2624    pthread_mutex_init(&adev->lock, (const pthread_mutexattr_t *) NULL);
2625
2626    adev->device.common.tag = HARDWARE_DEVICE_TAG;
2627    adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
2628    adev->device.common.module = (struct hw_module_t *)module;
2629    adev->device.common.close = adev_close;
2630
2631    adev->device.init_check = adev_init_check;
2632    adev->device.set_voice_volume = adev_set_voice_volume;
2633    adev->device.set_master_volume = adev_set_master_volume;
2634    adev->device.get_master_volume = adev_get_master_volume;
2635    adev->device.set_master_mute = adev_set_master_mute;
2636    adev->device.get_master_mute = adev_get_master_mute;
2637    adev->device.set_mode = adev_set_mode;
2638    adev->device.set_mic_mute = adev_set_mic_mute;
2639    adev->device.get_mic_mute = adev_get_mic_mute;
2640    adev->device.set_parameters = adev_set_parameters;
2641    adev->device.get_parameters = adev_get_parameters;
2642    adev->device.get_input_buffer_size = adev_get_input_buffer_size;
2643    adev->device.open_output_stream = adev_open_output_stream;
2644    adev->device.close_output_stream = adev_close_output_stream;
2645    adev->device.open_input_stream = adev_open_input_stream;
2646    adev->device.close_input_stream = adev_close_input_stream;
2647    adev->device.dump = adev_dump;
2648
2649    /* Set the default route before the PCM stream is opened */
2650    pthread_mutex_lock(&adev->lock);
2651    adev->mode = AUDIO_MODE_NORMAL;
2652    adev->active_input = NULL;
2653    adev->primary_output = NULL;
2654    adev->bluetooth_nrec = true;
2655    adev->acdb_settings = TTY_MODE_OFF;
2656    /* adev->cur_hdmi_channels = 0;  by calloc() */
2657    adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int));
2658    voice_init(adev);
2659    list_init(&adev->usecase_list);
2660    pthread_mutex_unlock(&adev->lock);
2661
2662    /* Loads platform specific libraries dynamically */
2663    adev->platform = platform_init(adev);
2664    if (!adev->platform) {
2665        free(adev->snd_dev_ref_cnt);
2666        free(adev);
2667        ALOGE("%s: Failed to init platform data, aborting.", __func__);
2668        *device = NULL;
2669        return -EINVAL;
2670    }
2671
2672    adev->extspk = audio_extn_extspk_init(adev);
2673
2674    if (access(VISUALIZER_LIBRARY_PATH, R_OK) == 0) {
2675        adev->visualizer_lib = dlopen(VISUALIZER_LIBRARY_PATH, RTLD_NOW);
2676        if (adev->visualizer_lib == NULL) {
2677            ALOGE("%s: DLOPEN failed for %s", __func__, VISUALIZER_LIBRARY_PATH);
2678        } else {
2679            ALOGV("%s: DLOPEN successful for %s", __func__, VISUALIZER_LIBRARY_PATH);
2680            adev->visualizer_start_output =
2681                        (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib,
2682                                                        "visualizer_hal_start_output");
2683            adev->visualizer_stop_output =
2684                        (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib,
2685                                                        "visualizer_hal_stop_output");
2686        }
2687    }
2688
2689    if (access(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, R_OK) == 0) {
2690        adev->offload_effects_lib = dlopen(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, RTLD_NOW);
2691        if (adev->offload_effects_lib == NULL) {
2692            ALOGE("%s: DLOPEN failed for %s", __func__,
2693                  OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH);
2694        } else {
2695            ALOGV("%s: DLOPEN successful for %s", __func__,
2696                  OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH);
2697            adev->offload_effects_start_output =
2698                        (int (*)(audio_io_handle_t, int))dlsym(adev->offload_effects_lib,
2699                                         "offload_effects_bundle_hal_start_output");
2700            adev->offload_effects_stop_output =
2701                        (int (*)(audio_io_handle_t, int))dlsym(adev->offload_effects_lib,
2702                                         "offload_effects_bundle_hal_stop_output");
2703        }
2704    }
2705
2706    adev->bt_wb_speech_enabled = false;
2707
2708    *device = &adev->device.common;
2709    if (k_enable_extended_precision)
2710        adev_verify_devices(adev);
2711
2712    char value[PROPERTY_VALUE_MAX];
2713    int trial;
2714    if (property_get("audio_hal.period_size", value, NULL) > 0) {
2715        trial = atoi(value);
2716        if (period_size_is_plausible_for_low_latency(trial)) {
2717            pcm_config_low_latency.period_size = trial;
2718            pcm_config_low_latency.start_threshold = trial / 4;
2719            pcm_config_low_latency.avail_min = trial / 4;
2720            configured_low_latency_capture_period_size = trial;
2721        }
2722    }
2723    if (property_get("audio_hal.in_period_size", value, NULL) > 0) {
2724        trial = atoi(value);
2725        if (period_size_is_plausible_for_low_latency(trial)) {
2726            configured_low_latency_capture_period_size = trial;
2727        }
2728    }
2729
2730    ALOGV("%s: exit", __func__);
2731    return 0;
2732}
2733
2734static struct hw_module_methods_t hal_module_methods = {
2735    .open = adev_open,
2736};
2737
2738struct audio_module HAL_MODULE_INFO_SYM = {
2739    .common = {
2740        .tag = HARDWARE_MODULE_TAG,
2741        .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
2742        .hal_api_version = HARDWARE_HAL_API_VERSION,
2743        .id = AUDIO_HARDWARE_MODULE_ID,
2744        .name = "QCOM Audio HAL",
2745        .author = "Code Aurora Forum",
2746        .methods = &hal_module_methods,
2747    },
2748};
2749