hal/audio_extn/passthru.c

/*
* Copyright (c) 2014-2018, 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 "passthru"
/*#define LOG_NDEBUG 0*/
#include <stdlib.h>
#include <cutils/atomic.h>
#include <cutils/str_parms.h>
#include <cutils/log.h>
#include <unistd.h>
#include "audio_hw.h"
#include "audio_extn.h"
#include "platform_api.h"
#include <platform.h>
#include <cutils/properties.h>

#include "sound/compress_params.h"

#ifdef DYNAMIC_LOG_ENABLED
#include <log_xml_parser.h>
#define LOG_MASK HAL_MOD_FILE_PASSTH
#include <log_utils.h>
#endif
/*
 * Offload buffer size for compress passthrough
 */

#ifdef DTSHD_PARSER_ENABLED
#include "audio_parsers.h"

/* list of all supported DTS transmission sample rates */
static const int dts_transmission_sample_rates[] = {
    44100, 48000, 88200, 96000, 176400, 192000
};

 /*
 * for DTSHD stream one frame size can be upto 36kb and to extract iec61937
 * info for parsing usecase  minimum one frame needs to be sent to dts parser
 */
#define MAX_COMPRESS_PASSTHROUGH_FRAGMENT_SIZE (36 * 1024)
#else
#define MAX_COMPRESS_PASSTHROUGH_FRAGMENT_SIZE (8 * 1024)
#endif

#define MIN_COMPRESS_PASSTHROUGH_FRAGMENT_SIZE (2 * 1024)

#define DDP_COMPRESS_PASSTHROUGH_FRAGMENT_SIZE (10 * 1024)

static const audio_format_t audio_passthru_formats[] = {
    AUDIO_FORMAT_AC3,
    AUDIO_FORMAT_E_AC3,
    AUDIO_FORMAT_E_AC3_JOC,
    AUDIO_FORMAT_DTS,
    AUDIO_FORMAT_DTS_HD,
    AUDIO_FORMAT_DOLBY_TRUEHD,
    AUDIO_FORMAT_IEC61937
};

/*
 * This atomic var is incremented/decremented by the offload stream to notify
 * other pcm playback streams that a pass thru session is about to start or has
 * finished. This hint can be used by the other streams to move to standby or
 * start calling pcm_write respectively.
 * This behavior is necessary as the DSP backend can only be configured to one
 * of PCM or compressed.
 */
static volatile int32_t compress_passthru_active;

#ifdef DTSHD_PARSER_ENABLED
int audio_extn_passthru_update_dts_stream_configuration(struct stream_out *out,
        const void *buffer, size_t bytes)
{
    struct audio_parser_codec_info codec_info;
    struct dtshd_iec61937_info dtshd_tr_info;
    int i;
    int ret;
    bool is_valid_transmission_rate = false;
    bool is_valid_transmission_channels = false;

    if (!out) {
        ALOGE("Invalid session");
        return -EINVAL;
    }

    if ((out->format != AUDIO_FORMAT_DTS) &&
        (out->format != AUDIO_FORMAT_DTS_HD)) {
        ALOGE("Non DTS format %d", out->format);
        return -EINVAL;
    }

    if (!buffer || bytes <= 0) {
        ALOGD("Invalid buffer %p size %d skipping dts stream conf update",
                buffer, bytes);
        out->sample_rate = 48000;
        out->compr_config.codec->sample_rate = out->sample_rate;
        out->compr_config.codec->ch_in = 2;
        out->channel_mask = audio_channel_out_mask_from_count(2);
        return -EINVAL;
    }

    /* codec format is AUDIO_PARSER_CODEC_DTSHD for both DTS and DTSHD as
     *  DTSHD parser can support both DTS and DTSHD
     */
    memset(&codec_info, 0, sizeof(struct audio_parser_codec_info));
    memset(&dtshd_tr_info, 0, sizeof(struct dtshd_iec61937_info));

    init_audio_parser((unsigned char *)buffer, bytes, AUDIO_PARSER_CODEC_DTSHD);
    codec_info.codec_type = AUDIO_PARSER_CODEC_DTSHD;
    if (!(ret = get_iec61937_info(&codec_info))) {
        dtshd_tr_info = codec_info.codec_config.dtshd_tr_info;
        ALOGD("dts new sample rate %d and channels %d\n",
               dtshd_tr_info.sample_rate,
               dtshd_tr_info.num_channels);
        for (i = 0; i < sizeof(dts_transmission_sample_rates); i++) {
            if (dts_transmission_sample_rates[i] ==
                    dtshd_tr_info.sample_rate) {
                out->sample_rate = dtshd_tr_info.sample_rate;
                out->compr_config.codec->sample_rate = out->sample_rate;
                is_valid_transmission_rate = true;
                break;
            }
        }
        /* DTS transmission channels should be 2 or 8*/
        if ((dtshd_tr_info.num_channels == 2) ||
                (dtshd_tr_info.num_channels == 8)) {
            out->compr_config.codec->ch_in = dtshd_tr_info.num_channels;
            out->channel_mask = audio_channel_out_mask_from_count
                (dtshd_tr_info.num_channels);
            is_valid_transmission_channels = true;
        }
    } else {
        ALOGE("%s:: get_iec61937_info failed %d", __func__, ret);
    }

    if (!is_valid_transmission_rate) {
        ALOGE("%s:: Invalid dts transmission rate %d\n using default sample rate 48000",
               dtshd_tr_info.sample_rate);
        out->sample_rate = 48000;
        out->compr_config.codec->sample_rate = out->sample_rate;
    }

    if (!is_valid_transmission_channels) {
        ALOGE("%s:: Invalid transmission channels %d using default transmission"
              " channels as 2", __func__, dtshd_tr_info.num_channels);
        out->compr_config.codec->ch_in = 2;
        out->channel_mask = audio_channel_out_mask_from_count(2);
    }
    return 0;
}
#else
int audio_extn_passthru_update_dts_stream_configuration(
                        struct stream_out *out __unused,
                        const void *buffer __unused,
                        size_t bytes __unused)
{
    return -ENOSYS;
}
#endif

int audio_extn_passthru_get_channel_count(struct stream_out *out)
{
    int channel_count = DEFAULT_HDMI_OUT_CHANNELS;

    if (!out) {
        ALOGE("%s:: Invalid param out %p", __func__, out);
        return -EINVAL;
    }

    if (!audio_extn_passthru_is_supported_format(out->format)) {
        ALOGE("%s:: not a passthrough format %d", __func__, out->format);
        return -EINVAL;
    }

    switch(out->format) {
    case AUDIO_FORMAT_DOLBY_TRUEHD:
       channel_count = 8;
       break;
    case AUDIO_FORMAT_DTS:
    case AUDIO_FORMAT_DTS_HD:
#ifdef DTSHD_PARSER_ENABLED
       /* taken channel count from parser*/
       channel_count = audio_channel_count_from_out_mask(out->channel_mask);
#endif
       break;
    case AUDIO_FORMAT_IEC61937:
       channel_count = audio_channel_count_from_out_mask(out->channel_mask);
   default:
       break;
   }

   ALOGE("%s: pass through channel count %d\n", __func__, channel_count);
   return channel_count;
}

bool audio_extn_passthru_is_supported_format(audio_format_t format)
{
    int32_t num_passthru_formats = sizeof(audio_passthru_formats) /
                                    sizeof(audio_passthru_formats[0]);
    int32_t i;

    for (i = 0; i < num_passthru_formats; i++) {
        if (format == audio_passthru_formats[i]) {
            ALOGD("%s : pass through format is true", __func__);
            return true;
        }
    }
    ALOGD("%s : pass through format is false", __func__);
    return false;
}

/*
 * must be called with stream lock held
 * This function decides based on some rules whether the data
 * coming on stream out must be rendered or dropped.
 */
bool audio_extn_passthru_should_drop_data(struct stream_out * out)
{
    /*Drop data only
     *stream is routed to HDMI and
     *stream has PCM format or
     *if a compress offload (DSP decode) session
     */
    if ((out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) &&
        (((out->format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM) ||
        ((out->compr_config.codec != NULL) && (out->compr_config.codec->compr_passthr == LEGACY_PCM)))) {
        if (android_atomic_acquire_load(&compress_passthru_active) > 0) {
            ALOGI("drop data as pass thru is active");
            return true;
        }
    }

    return false;
}

/* called with adev lock held */
void audio_extn_passthru_on_start(struct stream_out * out)
{

    uint64_t max_period_us = 0;
    uint64_t temp;
    struct audio_usecase * usecase;
    struct listnode *node;
    struct stream_out * o;
    struct audio_device *adev = out->dev;

    if (android_atomic_acquire_load(&compress_passthru_active) > 0) {
        ALOGI("pass thru is already active");
        return;
    }

    ALOGV("inc pass thru count to notify other streams");
    android_atomic_inc(&compress_passthru_active);

    while (true) {
        /* find max period time among active playback use cases */
        list_for_each(node, &adev->usecase_list) {
            usecase = node_to_item(node, struct audio_usecase, list);
            if (usecase->type == PCM_PLAYBACK &&
                usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
                o = usecase->stream.out;
                temp = o->config.period_size * 1000000LL / o->sample_rate;
                if (temp > max_period_us)
                    max_period_us = temp;
            }
        }

        if (max_period_us) {
            pthread_mutex_unlock(&adev->lock);
            usleep(2*max_period_us);
            max_period_us = 0;
            pthread_mutex_lock(&adev->lock);
        } else
            break;
    }
}

/* called with adev lock held */
void audio_extn_passthru_on_stop(struct stream_out * out)
{
    if (android_atomic_acquire_load(&compress_passthru_active) > 0) {
        /*
         * its possible the count is already zero if pause was called before
         * stop output stream
         */
        android_atomic_dec(&compress_passthru_active);
    }

    if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
        ALOGD("%s: passthru on aux digital, start keep alive", __func__);
        audio_extn_keep_alive_start(KEEP_ALIVE_OUT_HDMI);
    }
}

void audio_extn_passthru_on_pause(struct stream_out * out __unused)
{
    if (android_atomic_acquire_load(&compress_passthru_active) == 0)
        return;
}

int audio_extn_passthru_set_parameters(struct audio_device *adev __unused,
                                       struct str_parms *parms)
{
    char value[32];
    int ret;
    ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_CONNECT, value, sizeof(value));
    if (ret >= 0) {
        int val = atoi(value);
        if (val & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
            if (!audio_extn_passthru_is_active()) {
                ALOGV("%s: start keep alive on aux digital", __func__);
                audio_extn_keep_alive_start(KEEP_ALIVE_OUT_HDMI);
            }
        }
    }

    ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_DISCONNECT, value,
                            sizeof(value));
    if (ret >= 0) {
        int val = atoi(value);
        if (val & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
            ALOGV("%s: stop keep_alive on aux digital on device", __func__);
            audio_extn_keep_alive_stop(KEEP_ALIVE_OUT_HDMI);
        }
    }
    return 0;
}

bool audio_extn_passthru_is_active()
{
    return android_atomic_acquire_load(&compress_passthru_active) > 0;
}

bool audio_extn_passthru_is_enabled() { return true; }

void audio_extn_passthru_init(struct audio_device *adev __unused)
{
}

bool audio_extn_passthru_should_standby(struct stream_out * out __unused)
{
    return true;
}

bool audio_extn_passthru_is_convert_supported(struct audio_device *adev,
                                                 struct stream_out *out)
{

    bool convert = false;
    switch (out->format) {
    case AUDIO_FORMAT_E_AC3:
    case AUDIO_FORMAT_E_AC3_JOC:
        if (!platform_is_edid_supported_format(adev->platform,
                                               out->format)) {
            if (platform_is_edid_supported_format(adev->platform,
                                                  AUDIO_FORMAT_AC3)) {
                ALOGD("%s:PASSTHROUGH_CONVERT supported", __func__);
                convert = true;
            }
        }
        break;
    default:
        ALOGD("%s: PASSTHROUGH_CONVERT not supported for format 0x%x",
              __func__, out->format);
        break;
    }
    ALOGD("%s: convert %d", __func__, convert);
    return convert;
}

bool audio_extn_passthru_is_passt_supported(struct audio_device *adev,
                                         struct stream_out *out)
{
    bool passt = false;
    switch (out->format) {
    case AUDIO_FORMAT_E_AC3:
    case AUDIO_FORMAT_DTS_HD:
    case AUDIO_FORMAT_DOLBY_TRUEHD:
        if (platform_is_edid_supported_format(adev->platform, out->format)) {
            ALOGV("%s:PASSTHROUGH supported for format %x",
                   __func__, out->format);
            passt = true;
        }
        break;
    case AUDIO_FORMAT_AC3:
        if (platform_is_edid_supported_format(adev->platform, AUDIO_FORMAT_AC3)
            || platform_is_edid_supported_format(adev->platform,
            AUDIO_FORMAT_E_AC3)) {
            ALOGV("%s:PASSTHROUGH supported for format %x",
                   __func__, out->format);
            passt = true;
        }
        break;
    case AUDIO_FORMAT_E_AC3_JOC:
         /* Check for DDP capability in edid for JOC contents.*/
         if (platform_is_edid_supported_format(adev->platform,
             AUDIO_FORMAT_E_AC3)) {
             ALOGV("%s:PASSTHROUGH supported for format %x",
                   __func__, out->format);
             passt = true;
         }
         break;
    case AUDIO_FORMAT_DTS:
        if (platform_is_edid_supported_format(adev->platform, AUDIO_FORMAT_DTS)
            || platform_is_edid_supported_format(adev->platform,
            AUDIO_FORMAT_DTS_HD)) {
            ALOGV("%s:PASSTHROUGH supported for format %x",
                   __func__, out->format);
            passt = true;
        }
        break;
    default:
        ALOGV("%s:Passthrough not supported", __func__);
    }
    return passt;
}

void audio_extn_passthru_update_stream_configuration(
        struct audio_device *adev, struct stream_out *out,
        const void *buffer __unused, size_t bytes __unused)
{
    if(out->compr_config.codec != NULL) {
        if (audio_extn_passthru_is_passt_supported(adev, out)) {
            ALOGV("%s:PASSTHROUGH", __func__);
            out->compr_config.codec->compr_passthr = PASSTHROUGH;
        } else if (audio_extn_passthru_is_convert_supported(adev, out)) {
            ALOGV("%s:PASSTHROUGH CONVERT", __func__);
            out->compr_config.codec->compr_passthr = PASSTHROUGH_CONVERT;
        } else if (out->format == AUDIO_FORMAT_IEC61937) {
            ALOGV("%s:PASSTHROUGH IEC61937", __func__);
            out->compr_config.codec->compr_passthr = PASSTHROUGH_IEC61937;
        } else {
            ALOGV("%s:NO PASSTHROUGH", __func__);
            out->compr_config.codec->compr_passthr = LEGACY_PCM;
       }
    }
}

bool audio_extn_passthru_is_passthrough_stream(struct stream_out *out)
{
    //check passthrough system property
    if (!property_get_bool("vendor.audio.offload.passthrough", false)) {
        return false;
    }

    //check supported device, currently only on HDMI.
    if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
        //passthrough flag
        if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH)
            return true;
        //direct flag, check supported formats.
        if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT) {
            if (audio_extn_passthru_is_supported_format(out->format)) {
                if (platform_is_edid_supported_format(out->dev->platform,
                        out->format)) {
                    ALOGV("%s : return true",__func__);
                    return true;
                } else if (audio_extn_utils_is_dolby_format(out->format) &&
                            platform_is_edid_supported_format(out->dev->platform,
                                AUDIO_FORMAT_AC3)){
                    //return true for EAC3/EAC3_JOC formats
                    //if sink supports only AC3
                    ALOGV("%s : return true",__func__);
                    return true;
                }
            }
        }
    }
    ALOGV("%s : return false",__func__);
    return false;
}

bool audio_extn_passthru_is_direct_passthrough(struct stream_out *out)
{
    if (((out != NULL) && audio_extn_passthru_is_passthrough_stream(out)) &&
          !audio_extn_passthru_is_convert_supported(out->dev, out))
        return true;
    else
        return false;
}

int audio_extn_passthru_get_buffer_size(audio_offload_info_t* info)
{
    uint32_t fragment_size = MIN_COMPRESS_PASSTHROUGH_FRAGMENT_SIZE;
    char value[PROPERTY_VALUE_MAX] = {0};

    if (((info->format == AUDIO_FORMAT_DOLBY_TRUEHD) ||
            (info->format == AUDIO_FORMAT_IEC61937)) &&
            property_get("vendor.audio.truehd.buffer.size.kb", value, "") &&
            atoi(value)) {
        fragment_size = atoi(value) * 1024;
        goto done;
    } else if ((info->format == AUDIO_FORMAT_DTS) ||
               (info->format == AUDIO_FORMAT_DTS_HD)) {
        fragment_size = MAX_COMPRESS_PASSTHROUGH_FRAGMENT_SIZE;
        goto done;
    } else if (info->format == AUDIO_FORMAT_E_AC3) {
        fragment_size = DDP_COMPRESS_PASSTHROUGH_FRAGMENT_SIZE;
        if(property_get("vendor.audio.ddp.buffer.size.kb", value, "") &&
                atoi(value)) {
            fragment_size = atoi(value) * 1024;
        }
        goto done;
    }
done:
    return fragment_size;

}

int audio_extn_passthru_set_volume(struct stream_out *out,  int mute)
{
    return platform_set_device_params(out, DEVICE_PARAM_MUTE_ID, mute);
}

int audio_extn_passthru_set_latency(struct stream_out *out, int latency)
{
    return platform_set_device_params(out, DEVICE_PARAM_LATENCY_ID, latency);
}

bool audio_extn_passthru_is_supported_backend_edid_cfg(struct audio_device *adev,
                                                   struct stream_out *out)
{
    struct audio_backend_cfg backend_cfg;
    backend_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
    backend_cfg.channels = CODEC_BACKEND_DEFAULT_CHANNELS;
    backend_cfg.bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH;
    backend_cfg.format = AUDIO_FORMAT_PCM_16_BIT;
    backend_cfg.passthrough_enabled = false;

    snd_device_t out_snd_device = SND_DEVICE_NONE;
    int max_edid_channels = platform_edid_get_max_channels(out->dev->platform);

    out_snd_device = platform_get_output_snd_device(adev->platform, out);

    if (platform_get_codec_backend_cfg(adev, out_snd_device, &backend_cfg)) {
        ALOGE("%s: ERROR: Unable to get current backend config!!!", __func__);
        return false;
    }

    ALOGV("%s:becf: afe: bitwidth %d, samplerate %d channels %d format %d"
          ", device (%s)", __func__,  backend_cfg.bit_width,
          backend_cfg.sample_rate, backend_cfg.channels, backend_cfg.format,
          platform_get_snd_device_name(out_snd_device));

    /* Check if the channels are supported */
    if (max_edid_channels < (int)backend_cfg.channels) {

        ALOGE("%s: ERROR: Unsupported channels in passthru mode!!!"
              " max_edid_channels - %d backend_channels - %d",
              __func__, max_edid_channels, backend_cfg.channels);
        return false;
    }

    /* Check if the sample rate supported */
    if (!platform_is_edid_supported_sample_rate(adev->platform,
                                       backend_cfg.sample_rate)) {

        ALOGE("%s: ERROR: Unsupported sample rate in passthru mode!!!"
              " backend_samplerate - %d",
              __func__, backend_cfg.sample_rate);
        return false;
    }

    return true;
}