dereference
/
android_hardware_qcom_audio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android_hardware_qcom_audio/hal/audio_extn/hw_loopback.c

1039 lines
39 KiB
C
Raw Blame History

/*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink