path: root/hal/audio_extn/hw_loopback.c

/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above
*       copyright notice, this list of conditions and the following
*       disclaimer in the documentation and/or other materials provided
*       with the distribution.
*     * Neither the name of The Linux Foundation nor the names of its
*       contributors may be used to endorse or promote products derived
*       from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#define LOG_TAG "audio_hw_loopback"
/*#define LOG_NDEBUG 0*/
/*#define VERY_VERY_VERBOSE_LOGGING*/
#ifdef VERY_VERY_VERBOSE_LOGGING
#define ALOGVV ALOGV
#else
#define ALOGVV(a...) do { } while(0)
#endif

#define MAX_NUM_PATCHES 1
#define MAX_NUM_HW_LOOPBACK_PATCHES 1
#define PATCH_HANDLE_INVALID 0xFFFF
#define MAX_SOURCE_PORTS_PER_PATCH 1
#define MAX_SINK_PORTS_PER_PATCH 1
#define HW_LOOPBACK_RX_VOLUME     "Trans Loopback RX Volume"
#define HW_LOOPBACK_RX_UNITY_GAIN 0x2000

#include <math.h>
#include <stdlib.h>
#include <pthread.h>
#include <errno.h>
#include <dlfcn.h>
#include <sys/resource.h>
#include <sys/prctl.h>
#include <cutils/atomic.h>
#include <cutils/properties.h>
#include <cutils/str_parms.h>
#include <cutils/sched_policy.h>
#include <log/log.h>
#include "audio_utils/primitives.h"
#include "audio_hw.h"
#include "platform_api.h"
#include <platform.h>
#include <system/thread_defs.h>
#include "audio_extn.h"
#include <sound/compress_params.h>
#include <sound/compress_offload.h>
#include <system/audio.h>

typedef enum patch_state {
    PATCH_INACTIVE,// Patch is not created yet
    PATCH_CREATED, // Patch created but not in running state yet, probably due
                   // to lack of proper port config
    PATCH_RUNNING, // Patch in running state, moves to this state when patch
                   // created and proper port config is available
} patch_state_t;

typedef struct loopback_patch {
    audio_patch_handle_t patch_handle_id;            /* patch unique ID */
    struct audio_port_config loopback_source;        /* Source port config */
    struct audio_port_config loopback_sink;          /* Sink port config */
    struct compress *source_stream;                  /* Source stream */
    struct compress *sink_stream;                    /* Sink stream */
    struct stream_inout patch_stream;                /* InOut type stream */
    patch_state_t patch_state;                       /* Patch operation state */
} loopback_patch_t;

typedef struct patch_db_struct {
    int32_t num_patches;
    loopback_patch_t loopback_patch[MAX_NUM_PATCHES];
} patch_db_t;

typedef struct audio_loopback {
    struct audio_device *adev;
    patch_db_t patch_db;
    audio_usecase_t uc_id_rx;
    audio_usecase_t uc_id_tx;
    usecase_type_t  uc_type_rx;
    usecase_type_t  uc_type_tx;
    pthread_mutex_t lock;
} audio_loopback_t;

typedef struct port_info {
    audio_port_handle_t      id;                /* port unique ID */
    audio_port_role_t        role;              /* sink or source */
    audio_port_type_t        type;              /* device, mix ... */
} port_info_t;

/* Audio loopback module struct */
static audio_loopback_t *audio_loopback_mod = NULL;

uint32_t format_to_bitwidth(audio_format_t format)
{
    switch (format) {
        case AUDIO_FORMAT_PCM_16_BIT:
            return 16;
        case AUDIO_FORMAT_PCM_8_BIT:
            return 8;
        case AUDIO_FORMAT_PCM_32_BIT:
            return 32;
        case AUDIO_FORMAT_PCM_8_24_BIT:
            return 32;
        case AUDIO_FORMAT_PCM_24_BIT_PACKED:
            return 24;
        default:
            return 16;
    }
}

/* Set loopback volume : for mute implementation */
static int hw_loopback_set_volume(struct audio_device *adev, int value)
{
    int32_t ret = 0;
    struct mixer_ctl *ctl;
    char mixer_ctl_name[MAX_LENGTH_MIXER_CONTROL_IN_INT];
    snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
            "Transcode Loopback Rx Volume");

    ALOGD("%s: (%d)\n", __func__, value);

    ALOGD("%s: Setting HW loopback volume to %d \n", __func__, value);
    ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
    if (!ctl) {
        ALOGE("%s: Could not get ctl for mixer cmd - %s",
              __func__, mixer_ctl_name);
        return -EINVAL;
    }

    if(mixer_ctl_set_value(ctl, 0, value) < 0) {
        ALOGE("%s: Couldn't set HW Loopback Volume: [%d]", __func__, value);
        return -EINVAL;
    }

    ALOGV("%s: exit", __func__);
    return ret;
}

/* Initialize patch database */
int init_patch_database(patch_db_t* patch_db)
{
    int patch_init_rc = 0, patch_num=0;
    patch_db->num_patches = 0;
    for (patch_num=0;patch_num < MAX_NUM_PATCHES;patch_num++) {
        patch_db->loopback_patch[patch_num].patch_handle_id = (int32_t)
        PATCH_HANDLE_INVALID;
    }
    return patch_init_rc;
}

bool is_supported_sink_device(audio_devices_t sink_device_mask)
{
    if((sink_device_mask & AUDIO_DEVICE_OUT_SPEAKER) ||
       (sink_device_mask & AUDIO_DEVICE_OUT_WIRED_HEADSET) ||
       (sink_device_mask & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) ||
       (sink_device_mask & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) ||
       (sink_device_mask & AUDIO_DEVICE_OUT_LINE)) {
           return true;
       }
    return false;
}

/* Get patch type based on source and sink ports configuration */
/* Only ports of type 'DEVICE' are supported */
audio_patch_handle_t get_loopback_patch_type(loopback_patch_t*  loopback_patch)
{
    bool is_source_supported = false, is_sink_supported = false;
    audio_devices_t source_device = loopback_patch->loopback_source.ext.device.type;
    audio_devices_t sink_device = loopback_patch->loopback_sink.ext.device.type;

    source_device &= ~AUDIO_DEVICE_BIT_IN;

    if (loopback_patch->patch_handle_id != PATCH_HANDLE_INVALID) {
        ALOGE("%s, Patch handle already exists", __func__);
        return loopback_patch->patch_handle_id;
    }

    if (loopback_patch->loopback_source.role == AUDIO_PORT_ROLE_SOURCE) {
        switch (loopback_patch->loopback_source.type) {
            case AUDIO_PORT_TYPE_DEVICE :
                if ((loopback_patch->loopback_source.config_mask & AUDIO_PORT_CONFIG_FORMAT)) {
                    if ((source_device & AUDIO_DEVICE_IN_HDMI) ||
                        (source_device & AUDIO_DEVICE_IN_SPDIF) ||
                        (source_device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) ||
                        (source_device & AUDIO_DEVICE_IN_HDMI_ARC)) {

                       switch (loopback_patch->loopback_source.format) {
                           case AUDIO_FORMAT_PCM:
                           case AUDIO_FORMAT_PCM_16_BIT:
                           case AUDIO_FORMAT_PCM_8_24_BIT:
                           case AUDIO_FORMAT_PCM_24_BIT_PACKED:
                           case AUDIO_FORMAT_IEC61937:
                           case AUDIO_FORMAT_AC3:
                           case AUDIO_FORMAT_E_AC3:
                           case AUDIO_FORMAT_AAC_LATM_LC:
                           case AUDIO_FORMAT_AAC_LATM_HE_V1:
                           case AUDIO_FORMAT_AAC_LATM_HE_V2:
                           case AUDIO_FORMAT_SBC:
                              is_source_supported = true;
                           break;
                       }
                    } else if (source_device & AUDIO_DEVICE_IN_LINE) {
                       is_source_supported = true;
                    }
                }
            break;
            default :
                //Unsupported as of now, need to extend for other source types
                break;
        }
    }

    if (loopback_patch->loopback_sink.role == AUDIO_PORT_ROLE_SINK) {
        switch (loopback_patch->loopback_sink.type) {
        case AUDIO_PORT_TYPE_DEVICE :
            if ((loopback_patch->loopback_sink.config_mask &
                AUDIO_PORT_CONFIG_FORMAT) &&
                (is_supported_sink_device(loopback_patch->loopback_sink.ext.device.type))) {
                    switch (loopback_patch->loopback_sink.format) {
                    case AUDIO_FORMAT_PCM:
                    case AUDIO_FORMAT_PCM_16_BIT:
                    case AUDIO_FORMAT_PCM_32_BIT:
                    case AUDIO_FORMAT_PCM_8_24_BIT:
                    case AUDIO_FORMAT_PCM_24_BIT_PACKED:
                        is_sink_supported = true;
                        break;
                    default:
                        break;
                    }
            } else {
                ALOGE("%s, Unsupported sink port device %d", __func__,loopback_patch->loopback_sink.ext.device.type);
            }
            break;
        default :
            //Unsupported as of now, need to extend for other sink types
            break;
        }
    }
    if (is_source_supported && is_sink_supported) {
        return AUDIO_DEVICE_BIT_IN | source_device | sink_device;
    }
    ALOGE("%s, Unsupported source or sink port config", __func__);
    return loopback_patch->patch_handle_id;
}

/* Releases an existing loopback session */
/* Conditions : Session setup goes bad or actual session teardown */
int32_t release_loopback_session(loopback_patch_t *active_loopback_patch)
{
    int32_t ret = 0;
    struct audio_usecase *uc_info_rx, *uc_info_tx;
    struct audio_device *adev = audio_loopback_mod->adev;
    struct stream_inout *inout =  &active_loopback_patch->patch_stream;
    struct audio_port_config *source_patch_config = &active_loopback_patch->
                                                    loopback_source;
    int32_t pcm_dev_asm_rx_id = platform_get_pcm_device_id(USECASE_AUDIO_TRANSCODE_LOOPBACK_RX,
                                                           PCM_PLAYBACK);

    /* Close the PCM devices */
    if (active_loopback_patch->source_stream) {
        compress_close(active_loopback_patch->source_stream);
        active_loopback_patch->source_stream = NULL;
    } else {
        ALOGE("%s: Failed to close loopback stream in capture path",
            __func__);
    }
    if (active_loopback_patch->sink_stream) {
        compress_close(active_loopback_patch->sink_stream);
        active_loopback_patch->sink_stream = NULL;
    } else {
        ALOGE("%s: Failed to close loopback stream in playback path",
            __func__);
    }

    uc_info_tx = get_usecase_from_list(adev, audio_loopback_mod->uc_id_tx);
    if (uc_info_tx == NULL) {
        ALOGE("%s: Could not find the loopback usecase (%d) in the list",
            __func__, active_loopback_patch->patch_handle_id);
        return -EINVAL;
    }

    disable_audio_route(adev, uc_info_tx);

    /* Disable tx device */
    disable_snd_device(adev, uc_info_tx->in_snd_device);

    /* Reset backend device to default state */
    platform_invalidate_backend_config(adev->platform,uc_info_tx->in_snd_device);

    list_remove(&uc_info_tx->list);
    free(uc_info_tx);

    uc_info_rx = get_usecase_from_list(adev, audio_loopback_mod->uc_id_rx);
    if (uc_info_rx == NULL) {
        ALOGE("%s: Could not find the loopback usecase (%d) in the list",
            __func__, active_loopback_patch->patch_handle_id);
        return -EINVAL;
    }

    if (adev->offload_effects_stop_output != NULL)
            adev->offload_effects_stop_output(active_loopback_patch->patch_handle_id, pcm_dev_asm_rx_id);

    active_loopback_patch->patch_state = PATCH_INACTIVE;

    /* Get and set stream specific mixer controls */
    disable_audio_route(adev, uc_info_rx);

    /* Disable the rx device */
    disable_snd_device(adev, uc_info_rx->out_snd_device);

    list_remove(&uc_info_rx->list);
    free(uc_info_rx);

    if (inout->ip_hdlr_handle) {
        ret = audio_extn_ip_hdlr_intf_close(inout->ip_hdlr_handle, true, inout);
        if (ret < 0)
            ALOGE("%s: audio_extn_ip_hdlr_intf_close failed %d",__func__, ret);
    }

    /* close adsp hdrl session before standby */
    if (inout->adsp_hdlr_stream_handle) {
        ret = audio_extn_adsp_hdlr_stream_close(inout->adsp_hdlr_stream_handle);
        if (ret)
            ALOGE("%s: adsp_hdlr_stream_close failed %d",__func__, ret);
        inout->adsp_hdlr_stream_handle = NULL;
    }

    if (inout->ip_hdlr_handle) {
        audio_extn_ip_hdlr_intf_deinit(inout->ip_hdlr_handle);
        inout->ip_hdlr_handle = NULL;
    }

    ALOGD("%s: Release loopback session exit: status(%d)", __func__, ret);
    return ret;
}

/* Callback funtion called in the case of failures */
int loopback_stream_cb(stream_callback_event_t event, void *param, void *cookie)
{
    if (event == AUDIO_EXTN_STREAM_CBK_EVENT_ERROR) {
        pthread_mutex_lock(&audio_loopback_mod->lock);
        release_loopback_session(cookie);
        audio_loopback_mod->patch_db.num_patches--;
        pthread_mutex_unlock(&audio_loopback_mod->lock);
    }
    return 0;
}

#ifdef SNDRV_COMPRESS_RENDER_WINDOW
static loopback_patch_t *get_active_loopback_patch(audio_patch_handle_t handle)
{
    int n = 0;
    int patch_index = -1;
    loopback_patch_t *active_loopback_patch = NULL;

    for (n=0; n < MAX_NUM_PATCHES; n++) {
        if (audio_loopback_mod->patch_db.num_patches > 0) {
            if (audio_loopback_mod->patch_db.loopback_patch[n].patch_handle_id == handle) {
                patch_index = n;
                break;
            }
        } else {
            ALOGE("%s, No active audio loopback patch", __func__);
            return active_loopback_patch;
        }
    }

    if ((patch_index > -1) && (patch_index < MAX_NUM_PATCHES))
        active_loopback_patch = &(audio_loopback_mod->patch_db.loopback_patch[
                                patch_index]);
    else
        ALOGE("%s, Requested Patch handle does not exist", __func__);

    return active_loopback_patch;
}

int audio_extn_hw_loopback_set_render_window(audio_patch_handle_t handle,
                      struct audio_out_render_window_param *render_window)
{
    struct snd_compr_metadata metadata = {0};
    int ret = 0;
    loopback_patch_t *active_loopback_patch = get_active_loopback_patch(handle);

    if (active_loopback_patch == NULL) {
        ALOGE("%s: Invalid patch handle", __func__);
        ret = -EINVAL;
        goto exit;
    }

    if (render_window == NULL) {
        ALOGE("%s: Invalid render_window", __func__);
        ret = -EINVAL;
        goto exit;
    }

    metadata.key = SNDRV_COMPRESS_RENDER_WINDOW;
    /*render window start value */
    metadata.value[0] = 0xFFFFFFFF & render_window->render_ws; /* lsb */
    metadata.value[1] = \
            (0xFFFFFFFF00000000 & render_window->render_ws) >> 32; /* msb*/
    /*render window end value */
    metadata.value[2] = 0xFFFFFFFF & render_window->render_we; /* lsb */
    metadata.value[3] = \
            (0xFFFFFFFF00000000 & render_window->render_we) >> 32; /* msb*/

    ret = compress_set_metadata(active_loopback_patch->sink_stream, &metadata);

exit:
    return ret;
}
#else
int audio_extn_hw_loopback_set_render_window(struct audio_hw_device *dev,
                      audio_patch_handle_t handle __unused,
                      struct audio_out_render_window_param *render_window __unused)
{
    ALOGD("%s:: configuring render window not supported", __func__);
    return 0;
}
#endif

#if defined SNDRV_COMPRESS_LATENCY_MODE
static void transcode_loopback_util_set_latency_mode(
                             loopback_patch_t *active_loopback_patch,
                             uint32_t latency_mode)
{
    struct snd_compr_metadata metadata;

    metadata.key = SNDRV_COMPRESS_LATENCY_MODE;
    metadata.value[0] = latency_mode;
    ALOGV("%s: Setting latency mode %d",__func__, latency_mode);
    compress_set_metadata(active_loopback_patch->source_stream,&metadata);
}
#else
static void transcode_loopback_util_set_latency_mode(
                            loopback_patch_t *active_loopback_patch __unused,
                            uint32_t latency_mode __unused)
{
    ALOGD("%s:: Latency mode configuration not supported", __func__);
}
#endif

/* Create a loopback session based on active loopback patch selected */
int create_loopback_session(loopback_patch_t *active_loopback_patch)
{
    int32_t ret = 0, bits_per_sample;
    struct audio_usecase *uc_info_rx, *uc_info_tx;
    int32_t pcm_dev_asm_rx_id, pcm_dev_asm_tx_id;
    char dummy_write_buf[64];
    struct audio_device *adev = audio_loopback_mod->adev;
    struct compr_config source_config, sink_config;
    struct snd_codec codec;
    struct audio_port_config *source_patch_config = &active_loopback_patch->
                                                    loopback_source;
    struct audio_port_config *sink_patch_config = &active_loopback_patch->
                                                    loopback_sink;
    struct stream_inout *inout =  &active_loopback_patch->patch_stream;
    struct adsp_hdlr_stream_cfg hdlr_stream_cfg;
    struct stream_in loopback_source_stream;
    char prop_value[PROPERTY_VALUE_MAX] = {0};

    ALOGD("%s: Create loopback session begin", __func__);

    uc_info_rx = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));

    if (!uc_info_rx) {
        ALOGE("%s: Failure to open loopback session", __func__);
        return -ENOMEM;
    }

    uc_info_tx = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));

    if (!uc_info_tx) {
        free(uc_info_rx);
        ALOGE("%s: Failure to open loopback session", __func__);
        return -ENOMEM;
    }

    uc_info_rx->id = USECASE_AUDIO_TRANSCODE_LOOPBACK_RX;
    uc_info_rx->type = audio_loopback_mod->uc_type_rx;
    uc_info_rx->stream.inout = &active_loopback_patch->patch_stream;
    list_init(&uc_info_rx->device_list);
    assign_devices(&uc_info_rx->device_list,
                   &active_loopback_patch->patch_stream.out_config.device_list);
    uc_info_rx->in_snd_device = SND_DEVICE_NONE;
    uc_info_rx->out_snd_device = SND_DEVICE_NONE;


    uc_info_tx->id = USECASE_AUDIO_TRANSCODE_LOOPBACK_TX;
    uc_info_tx->type = audio_loopback_mod->uc_type_tx;
    uc_info_tx->stream.inout = &active_loopback_patch->patch_stream;
    list_init(&uc_info_tx->device_list);
    assign_devices(&uc_info_tx->device_list,
                   &active_loopback_patch->patch_stream.in_config.device_list);
    uc_info_tx->in_snd_device = SND_DEVICE_NONE;
    uc_info_tx->out_snd_device = SND_DEVICE_NONE;

    list_add_tail(&adev->usecase_list, &uc_info_rx->list);
    list_add_tail(&adev->usecase_list, &uc_info_tx->list);

    loopback_source_stream.source = AUDIO_SOURCE_UNPROCESSED;
    loopback_source_stream.device = inout->in_config.devices;
    loopback_source_stream.channel_mask = inout->in_config.channel_mask;
    loopback_source_stream.bit_width = inout->in_config.bit_width;
    loopback_source_stream.sample_rate = inout->in_config.sample_rate;
    loopback_source_stream.format = inout->in_config.format;

    memcpy(&loopback_source_stream.usecase, uc_info_rx,
           sizeof(struct audio_usecase));
    select_devices(adev, uc_info_rx->id);
    select_devices(adev, uc_info_tx->id);

    pcm_dev_asm_rx_id = platform_get_pcm_device_id(uc_info_rx->id, PCM_PLAYBACK);
    pcm_dev_asm_tx_id = platform_get_pcm_device_id(uc_info_tx->id, PCM_CAPTURE);

    if (pcm_dev_asm_rx_id < 0 || pcm_dev_asm_tx_id < 0 ) {
        ALOGE("%s: Invalid PCM devices (asm: rx %d tx %d) for the RX usecase(%d), TX usecase(%d)",
            __func__, pcm_dev_asm_rx_id, pcm_dev_asm_tx_id, uc_info_rx->id, uc_info_tx->id);
        ret = -EIO;
        goto exit;
    }

    ALOGD("%s: LOOPBACK PCM devices (rx: %d tx: %d) RX usecase(%d) TX usecase(%d)",
        __func__, pcm_dev_asm_rx_id, pcm_dev_asm_tx_id, uc_info_rx->id, uc_info_tx->id);

    /* setup a channel for client <--> adsp communication for stream events */
    inout->dev = adev;
    inout->client_callback = loopback_stream_cb;
    inout->client_cookie = active_loopback_patch;
    hdlr_stream_cfg.pcm_device_id = pcm_dev_asm_rx_id;
    hdlr_stream_cfg.flags = 0;
    hdlr_stream_cfg.type = PCM_PLAYBACK;
    ret = audio_extn_adsp_hdlr_stream_open(&inout->adsp_hdlr_stream_handle,
            &hdlr_stream_cfg);
    if (ret) {
        ALOGE("%s: adsp_hdlr_stream_open failed %d", __func__, ret);
        inout->adsp_hdlr_stream_handle = NULL;
        goto exit;
    }
    if (audio_extn_ip_hdlr_intf_supported(source_patch_config->format,false, true) ||
        audio_extn_ip_hdlr_intf_supported_for_copp(adev->platform)) {
        ret = audio_extn_ip_hdlr_intf_init(&inout->ip_hdlr_handle, NULL, NULL, adev,
                                           USECASE_AUDIO_TRANSCODE_LOOPBACK_RX);
        if (ret < 0) {
            ALOGE("%s: audio_extn_ip_hdlr_intf_init failed %d", __func__, ret);
            inout->ip_hdlr_handle = NULL;
            goto exit;
        }
    }

    if (source_patch_config->format == AUDIO_FORMAT_IEC61937) {
        // This is needed to set a known format to DSP and handle
        // any format change via ADSP event
        codec.id = AUDIO_FORMAT_AC3;
    }

    /* Set config for compress stream open in capture path */
    codec.id = get_snd_codec_id(source_patch_config->format);
    codec.ch_in = audio_channel_count_from_out_mask(source_patch_config->
                                                    channel_mask);
    codec.ch_out = 2; // Irrelevant for loopback case in this direction
    codec.sample_rate = source_patch_config->sample_rate;
    codec.format = hal_format_to_alsa(source_patch_config->format);
    source_config.fragment_size = 1024;
    source_config.fragments = 1;
    source_config.codec = &codec;

    /* Open compress stream in capture path */
    active_loopback_patch->source_stream = compress_open(adev->snd_card,
                        pcm_dev_asm_tx_id, COMPRESS_OUT, &source_config);
    if (active_loopback_patch->source_stream && !is_compress_ready(
        active_loopback_patch->source_stream)) {
        ALOGE("%s: %s", __func__, compress_get_error(active_loopback_patch->
        source_stream));
        active_loopback_patch->source_stream = NULL;
        ret = -EIO;
        goto exit;
    } else if (active_loopback_patch->source_stream == NULL) {
        ALOGE("%s: Failure to open loopback stream in capture path", __func__);
        ret = -EINVAL;
        goto exit;
    }

    /* Set config for compress stream open in playback path */
    codec.id = get_snd_codec_id(sink_patch_config->format);
    codec.ch_in = 2; // Irrelevant for loopback case in this direction
    codec.ch_out = audio_channel_count_from_out_mask(sink_patch_config->
                                                     channel_mask);
    codec.sample_rate = sink_patch_config->sample_rate;
    codec.format = hal_format_to_alsa(sink_patch_config->format);
    sink_config.fragment_size = 1024;
    sink_config.fragments = 1;
    sink_config.codec = &codec;

    /* Do not alter the location of sending latency mode property */
    /* Mode set on any stream but before both streams are open */
    if(property_get("vendor.audio.transcode.latency.mode", prop_value, "")) {
        uint32_t latency_mode = atoi(prop_value);
        transcode_loopback_util_set_latency_mode(active_loopback_patch,
                                                 latency_mode);
    }

    /* Open compress stream in playback path */
    active_loopback_patch->sink_stream = compress_open(adev->snd_card,
                         pcm_dev_asm_rx_id, COMPRESS_IN, &sink_config);
    if (active_loopback_patch->sink_stream && !is_compress_ready(
        active_loopback_patch->sink_stream)) {
        ALOGE("%s: %s", __func__, compress_get_error(active_loopback_patch->
                sink_stream));
        active_loopback_patch->sink_stream = NULL;
        ret = -EIO;
        goto exit;
    } else if (active_loopback_patch->sink_stream == NULL) {
        ALOGE("%s: Failure to open loopback stream in playback path", __func__);
        ret = -EINVAL;
        goto exit;
    }

    active_loopback_patch->patch_state = PATCH_CREATED;

    if (compress_start(active_loopback_patch->source_stream) < 0) {
        ALOGE("%s: Failure to start loopback stream in capture path",
        __func__);
        ret = -EINVAL;
        goto exit;
    }

    /* Dummy compress_write to ensure compress_start does not fail */
    compress_write(active_loopback_patch->sink_stream, dummy_write_buf, 64);
    if (compress_start(active_loopback_patch->sink_stream) < 0) {
        ALOGE("%s: Cannot start loopback stream in playback path",
                __func__);
        ret = -EINVAL;
        goto exit;
    }
    if (inout->ip_hdlr_handle) {
        ret = audio_extn_ip_hdlr_intf_open(inout->ip_hdlr_handle, true, inout,
                                           USECASE_AUDIO_TRANSCODE_LOOPBACK_RX);
        if (ret < 0) {
            ALOGE("%s: audio_extn_ip_hdlr_intf_open failed %d",__func__, ret);
            goto exit;
        }
    }

    /* Move patch state to running, now that session is set up */
    active_loopback_patch->patch_state = PATCH_RUNNING;
    ALOGD("%s: Create loopback session end: status(%d)", __func__, ret);

    if (adev->offload_effects_start_output != NULL)
        adev->offload_effects_start_output(active_loopback_patch->patch_handle_id,
                                           pcm_dev_asm_rx_id, adev->mixer);

    return ret;

exit:
    ALOGE("%s: Problem in Loopback session creation: \
            status(%d), releasing session ", __func__, ret);
    release_loopback_session(active_loopback_patch);
    return ret;
}

void update_patch_stream_config(struct stream_config *stream_cfg ,
                                struct audio_port_config *port_cfg)
{
    stream_cfg->sample_rate = port_cfg->sample_rate;
    stream_cfg->channel_mask = port_cfg->channel_mask;
    stream_cfg->format = port_cfg->format;
    reassign_device_list(&stream_cfg->device_list, port_cfg->ext.device.type, "");
    stream_cfg->bit_width = format_to_bitwidth(port_cfg->format);
}
/* API to create audio patch */
int audio_extn_hw_loopback_create_audio_patch(struct audio_hw_device *dev,
                                     unsigned int num_sources,
                                     const struct audio_port_config *sources,
                                     unsigned int num_sinks,
                                     const struct audio_port_config *sinks,
                                     audio_patch_handle_t *handle)
{
    int status = 0;
    audio_patch_handle_t loopback_patch_id = 0x0;
    loopback_patch_t loopback_patch, *active_loopback_patch = NULL;

    ALOGV("%s : Create audio patch begin", __func__);

    if ((audio_loopback_mod == NULL) || (dev == NULL)) {
        ALOGE("%s, Loopback module not initialized orInvalid device", __func__);
        status = -EINVAL;
        return status;
    }

    pthread_mutex_lock(&audio_loopback_mod->lock);
    if (audio_loopback_mod->patch_db.num_patches >= MAX_NUM_PATCHES ) {
        ALOGE("%s, Exhausted maximum possible patches per device", __func__);
        status = -EINVAL;
        goto exit_create_patch;
    }

    /* Port configuration check & validation */
    if (num_sources > MAX_SOURCE_PORTS_PER_PATCH ||
        num_sinks > MAX_SINK_PORTS_PER_PATCH) {
        ALOGE("%s, Unsupported patch configuration, sources %d sinks %d ",
                __func__, num_sources, num_sources);
        status = -EINVAL;
        goto exit_create_patch;
    }

    /* Use an empty patch from patch database and initialze */
    active_loopback_patch = &(audio_loopback_mod->patch_db.loopback_patch[
                                audio_loopback_mod->patch_db.num_patches]);

    memset(active_loopback_patch, 0, sizeof(loopback_patch_t));

    active_loopback_patch->patch_handle_id = PATCH_HANDLE_INVALID;
    active_loopback_patch->patch_state = PATCH_INACTIVE;
    active_loopback_patch->patch_stream.ip_hdlr_handle = NULL;
    active_loopback_patch->patch_stream.adsp_hdlr_stream_handle = NULL;
    memcpy(&active_loopback_patch->loopback_source, &sources[0], sizeof(struct
    audio_port_config));
    memcpy(&active_loopback_patch->loopback_sink, &sinks[0], sizeof(struct
    audio_port_config));

    /* Get loopback patch type based on source and sink ports configuration */
    loopback_patch_id = get_loopback_patch_type(active_loopback_patch);

    if (loopback_patch_id == PATCH_HANDLE_INVALID) {
        ALOGE("%s, Unsupported patch type", __func__);
        status = -EINVAL;
        goto exit_create_patch;
    }

    update_patch_stream_config(&active_loopback_patch->patch_stream.in_config,
                                &active_loopback_patch->loopback_source);
    update_patch_stream_config(&active_loopback_patch->patch_stream.out_config,
                                &active_loopback_patch->loopback_sink);
    // Lock patch database, create patch handle and add patch handle to the list

    active_loopback_patch->patch_handle_id = loopback_patch_id;

    /* Is usecase transcode loopback? If yes, invoke loopback driver */
    if ((active_loopback_patch->loopback_source.type == AUDIO_PORT_TYPE_DEVICE)
       &&
       (active_loopback_patch->loopback_sink.type == AUDIO_PORT_TYPE_DEVICE)) {
        status = create_loopback_session(active_loopback_patch);
        if (status != 0)
            goto exit_create_patch;
    }

    // Create callback thread to listen to events from HW data path

    /* Fill unique handle ID generated based on active loopback patch */
    *handle = audio_loopback_mod->patch_db.loopback_patch[audio_loopback_mod->
                                        patch_db.num_patches].patch_handle_id;
    audio_loopback_mod->patch_db.num_patches++;

exit_create_patch :
    ALOGV("%s : Create audio patch end, status(%d)", __func__, status);
    pthread_mutex_unlock(&audio_loopback_mod->lock);
    return status;
}

/* API to release audio patch */
int audio_extn_hw_loopback_release_audio_patch(struct audio_hw_device *dev,
                                             audio_patch_handle_t handle)
{
    int status = 0, n=0, patch_index=-1;
    bool patch_found = false;
    loopback_patch_t *active_loopback_patch = NULL;
    ALOGV("%s audio_extn_hw_loopback_release_audio_patch begin %d", __func__, __LINE__);

    if ((audio_loopback_mod == NULL) || (dev == NULL)) {
        ALOGE("%s, Invalid device", __func__);
        status = -1;
        return status;
    }

    pthread_mutex_lock(&audio_loopback_mod->lock);

    for (n=0;n < MAX_NUM_PATCHES;n++) {
        if (audio_loopback_mod->patch_db.loopback_patch[n].patch_handle_id ==
           handle) {
            patch_found = true;
            patch_index = n;
            break;
        }
    }

    if (patch_found && (audio_loopback_mod->patch_db.num_patches > 0)) {
        active_loopback_patch = &(audio_loopback_mod->patch_db.loopback_patch[
                                patch_index]);
        status = release_loopback_session(active_loopback_patch);
        audio_loopback_mod->patch_db.num_patches--;
    } else {
        ALOGE("%s, Requested Patch handle does not exist", __func__);
        status = -1;
    }
    pthread_mutex_unlock(&audio_loopback_mod->lock);

    ALOGV("%s audio_extn_hw_loopback_release_audio_patch done, status(%d)", __func__,
    status);
    return status;
}

/* Find port config from patch database based on port info */
struct audio_port_config* get_port_from_patch_db(port_info_t *port,
                               patch_db_t *audio_patch_db, int *patch_num)
{
    int n=0, patch_index=-1;
    struct audio_port_config *cur_port=NULL;

    if (port->role == AUDIO_PORT_ROLE_SOURCE) {
        for (n=0;n < audio_patch_db->num_patches;n++) {
            cur_port = &(audio_patch_db->loopback_patch[n].loopback_source);
            if ((cur_port->id == port->id) && (cur_port->type == port->type) && (
               cur_port->role == port->role)) {
                patch_index = n;
                break;
            }
        }
    } else if (port->role == AUDIO_PORT_ROLE_SINK) {
        for (n=0;n < audio_patch_db->num_patches;n++) {
            cur_port = &(audio_patch_db->loopback_patch[n].loopback_sink);
            if ((cur_port->id == port->id) && (cur_port->type == port->type) && (
               cur_port->role == port->role)) {
                patch_index = n;
                break;
            }
        }
    }
    *patch_num = patch_index;
    return cur_port;
}

/* API to get port config based on port unique ID */
int audio_extn_hw_loopback_get_audio_port(struct audio_hw_device *dev,
                                    struct audio_port *port_in)
{
    int status = 0, n=0, patch_num=-1;
    port_info_t port_info;
    struct audio_port_config *port_out=NULL;
    ALOGV("%s %d", __func__, __LINE__);

    if ((audio_loopback_mod == NULL) || (dev == NULL)) {
        ALOGE("%s, Invalid device", __func__);
        status = -1;
        return status;
    }

    pthread_mutex_lock(&audio_loopback_mod->lock);

    port_info.id = port_in->id;
    port_info.role = port_in->role;              /* sink or source */
    port_info.type = port_in->type;              /* device, mix ... */
    port_out = get_port_from_patch_db(&port_info, &audio_loopback_mod->patch_db,
                                      &patch_num);
    if (port_out == NULL) {
        ALOGE("%s, Unable to find a valid matching port in patch \
        database,exiting", __func__);
        status = -EINVAL;
        return status;
    }

    /* Fill port output properties before returning the port */
    memcpy(&port_in->active_config,port_out, sizeof(struct audio_port_config));

    /* Multiple fields are not valid for loopback extension usecases, TODO :
    enhance for all patch handler cases. */
    port_in->num_sample_rates = 1;
    port_in->sample_rates[0] = port_out->sample_rate;
    port_in->num_channel_masks = 1;
    port_in->channel_masks[0] = port_out->channel_mask;
    port_in->num_formats = 1;
    port_in->formats[0] = port_out->format;
    port_in->num_gains = 1;

    pthread_mutex_unlock(&audio_loopback_mod->lock);
    return status;
}

/* API to set port config based on port unique ID */
int audio_extn_hw_loopback_set_audio_port_config(struct audio_hw_device *dev,
                                        const struct audio_port_config *config)
{
    int status = 0, n=0, patch_num=-1;
    port_info_t port_info;
    struct audio_port_config *port_out=NULL;
    struct audio_device *adev = audio_loopback_mod->adev;
    int loopback_gain = HW_LOOPBACK_RX_UNITY_GAIN;

    ALOGV("%s %d", __func__, __LINE__);

    if ((audio_loopback_mod == NULL) || (dev == NULL)) {
        ALOGE("%s, Invalid device", __func__);
        status = -EINVAL;
        return status;
    }

    pthread_mutex_lock(&audio_loopback_mod->lock);

    port_info.id = config->id;
    port_info.role = config->role;              /* sink or source */
    port_info.type = config->type;              /* device, mix  */
    port_out = get_port_from_patch_db(&port_info, &audio_loopback_mod->patch_db
                                    , &patch_num);

    if (port_out == NULL) {
        ALOGE("%s, Unable to find a valid matching port in patch \
        database,exiting", __func__);
        status = -EINVAL;
        goto exit_set_port_config;
    }

    port_out->config_mask |= config->config_mask;
    if(config->config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK)
        port_out->channel_mask = config->channel_mask;
    if(config->config_mask & AUDIO_PORT_CONFIG_FORMAT)
        port_out->format = config->format;
    if(config->config_mask & AUDIO_PORT_CONFIG_GAIN)
        port_out->gain = config->gain;
    if(config->config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE)
        port_out->sample_rate = config->sample_rate;

    /* Convert gain in millibels to ratio and convert to Q13 */
    loopback_gain = pow(10, (float)((float)port_out->gain.values[0]/2000)) *
                       (1 << 13);
    ALOGV("%s, Port config gain_in_mbells: %d, gain_in_q13 : %d", __func__,
          port_out->gain.values[0], loopback_gain);
    if((port_out->config_mask & AUDIO_PORT_CONFIG_GAIN) &&
        port_out->gain.mode == AUDIO_GAIN_MODE_JOINT ) {
        status = hw_loopback_set_volume(adev, loopback_gain);
        if (status) {
            ALOGE("%s, Error setting loopback gain config: status %d",
                  __func__, status);
        }
    } else {
        ALOGE("%s, Unsupported port config ,exiting", __func__);
        status = -EINVAL;
    }

    /* Currently, port config is not used for anything,
    need to restart session    */
exit_set_port_config:
    pthread_mutex_unlock(&audio_loopback_mod->lock);
    return status;
}

/* Loopback extension initialization, part of hal init sequence */
int audio_extn_hw_loopback_init(struct audio_device *adev)
{
    ALOGV("%s Audio loopback extension initializing", __func__);
    int ret = 0, size = 0;

    if (audio_loopback_mod != NULL) {
        pthread_mutex_lock(&audio_loopback_mod->lock);
        if (audio_loopback_mod->adev == adev) {
            ALOGV("%s %d : Audio loopback module already exists", __func__,
                    __LINE__);
        } else {
            ALOGV("%s %d : Audio loopback module called for invalid device",
                    __func__, __LINE__);
            ret = -EINVAL;
        }
        goto loopback_done;
    }
    audio_loopback_mod = malloc(sizeof(struct audio_loopback));
    if (audio_loopback_mod == NULL) {
        ALOGE("%s, out of memory", __func__);
        ret = -ENOMEM;
        goto loopback_done;
    }

    pthread_mutex_init(&audio_loopback_mod->lock,
                        (const pthread_mutexattr_t *)NULL);
    pthread_mutex_lock(&audio_loopback_mod->lock);
    audio_loopback_mod->adev = adev;

    ret = init_patch_database(&audio_loopback_mod->patch_db);

    audio_loopback_mod->uc_id_rx = USECASE_AUDIO_TRANSCODE_LOOPBACK_RX;
    audio_loopback_mod->uc_id_tx = USECASE_AUDIO_TRANSCODE_LOOPBACK_TX;
    audio_loopback_mod->uc_type_rx = TRANSCODE_LOOPBACK_RX;
    audio_loopback_mod->uc_type_tx = TRANSCODE_LOOPBACK_TX;

loopback_done:
    if (ret != 0) {
        if (audio_loopback_mod != NULL) {
            pthread_mutex_unlock(&audio_loopback_mod->lock);
            pthread_mutex_destroy(&audio_loopback_mod->lock);
            free(audio_loopback_mod);
            audio_loopback_mod = NULL;
        }
    } else {
        pthread_mutex_unlock(&audio_loopback_mod->lock);
    }
    ALOGV("%s Audio loopback extension initialized", __func__);
    return ret;
}

void audio_extn_hw_loopback_deinit(struct audio_device *adev)
{
    ALOGV("%s Audio loopback extension de-initializing", __func__);

    if (audio_loopback_mod == NULL) {
        ALOGE("%s, loopback module NULL, cannot deinitialize", __func__);
        return;
    }
    pthread_mutex_lock(&audio_loopback_mod->lock);

    if (audio_loopback_mod->adev == adev) {
        if (audio_loopback_mod != NULL) {
            pthread_mutex_unlock(&audio_loopback_mod->lock);
            pthread_mutex_destroy(&audio_loopback_mod->lock);
            free(audio_loopback_mod);
            audio_loopback_mod = NULL;
        }
        return;
    } else {
        ALOGE("%s, loopback module not valid, cannot deinitialize", __func__);
    }
    pthread_mutex_unlock(&audio_loopback_mod->lock);
    return;
}