Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7047160e authored by Satya Krishna Pindiproli's avatar Satya Krishna Pindiproli
Browse files

hal: add support to offload VORBIS, ALAC and APE formats 

Send ALAC and APE specific data to DSP as part of the metadata
to support playback of ALAC and APE clips in offload mode.

Force vorbis offload run in transcoded bit stream mode.

Also move parsing of WMA and FLAC metadata to audio_extn.c
from audio_hw.c.

Change-Id: Ideccadff93d4c06e649cd535b8870e45ba26eaea
parent a42bbe79

hal/Android.mk

+23 −1
Original line number Diff line number Diff line
@@ -161,7 +161,29 @@ ifeq ($(strip $(AUDIO_FEATURE_ENABLED_MULTIPLE_TUNNEL)), true) 
endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_EXTN_FLAC_DECODER)),true)

    LOCAL_CFLAGS += -DQTI_FLAC_DECODER

    LOCAL_CFLAGS += -DFLAC_OFFLOAD_ENABLED

    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_VORBIS_OFFLOAD)),true)

    LOCAL_CFLAGS += -DVORBIS_OFFLOAD_ENABLED

    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED



endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_WMA_OFFLOAD)),true)

    LOCAL_CFLAGS += -DWMA_OFFLOAD_ENABLED

    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_ALAC_OFFLOAD)),true)

    LOCAL_CFLAGS += -DALAC_OFFLOAD_ENABLED

    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_APE_OFFLOAD)),true)

    LOCAL_CFLAGS += -DAPE_OFFLOAD_ENABLED

    LOCAL_CFLAGS += -DCOMPRESS_METADATA_NEEDED

endif



ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PCM_OFFLOAD_24)),true)

hal/audio_extn/audio_defs.h

+25 −1
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2014, The Linux Foundation. All rights reserved.

 * Copyright (c) 2014-2015, 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
@@ -48,6 +48,30 @@ 
#define AUDIO_OFFLOAD_CODEC_FLAC_MIN_FRAME_SIZE "music_offload_flac_min_frame_size"

#define AUDIO_OFFLOAD_CODEC_FLAC_MAX_FRAME_SIZE "music_offload_flac_max_frame_size"



#define AUDIO_OFFLOAD_CODEC_ALAC_FRAME_LENGTH "music_offload_alac_frame_length"

#define AUDIO_OFFLOAD_CODEC_ALAC_COMPATIBLE_VERSION "music_offload_alac_compatible_version"

#define AUDIO_OFFLOAD_CODEC_ALAC_BIT_DEPTH "music_offload_alac_bit_depth"

#define AUDIO_OFFLOAD_CODEC_ALAC_PB "music_offload_alac_pb"

#define AUDIO_OFFLOAD_CODEC_ALAC_MB "music_offload_alac_mb"

#define AUDIO_OFFLOAD_CODEC_ALAC_KB "music_offload_alac_kb"

#define AUDIO_OFFLOAD_CODEC_ALAC_NUM_CHANNELS "music_offload_alac_num_channels"

#define AUDIO_OFFLOAD_CODEC_ALAC_MAX_RUN "music_offload_alac_max_run"

#define AUDIO_OFFLOAD_CODEC_ALAC_MAX_FRAME_BYTES "music_offload_alac_max_frame_bytes"

#define AUDIO_OFFLOAD_CODEC_ALAC_AVG_BIT_RATE "music_offload_alac_avg_bit_rate"

#define AUDIO_OFFLOAD_CODEC_ALAC_SAMPLING_RATE "music_offload_alac_sampling_rate"

#define AUDIO_OFFLOAD_CODEC_ALAC_CHANNEL_LAYOUT_TAG "music_offload_alac_channel_layout_tag"



#define AUDIO_OFFLOAD_CODEC_APE_COMPATIBLE_VERSION "music_offload_ape_compatible_version"

#define AUDIO_OFFLOAD_CODEC_APE_COMPRESSION_LEVEL "music_offload_ape_compression_level"

#define AUDIO_OFFLOAD_CODEC_APE_FORMAT_FLAGS "music_offload_ape_format_flags"

#define AUDIO_OFFLOAD_CODEC_APE_BLOCKS_PER_FRAME "music_offload_ape_blocks_per_frame"

#define AUDIO_OFFLOAD_CODEC_APE_FINAL_FRAME_BLOCKS "music_offload_ape_final_frame_blocks"

#define AUDIO_OFFLOAD_CODEC_APE_TOTAL_FRAMES "music_offload_ape_total_frames"

#define AUDIO_OFFLOAD_CODEC_APE_BITS_PER_SAMPLE "music_offload_ape_bits_per_sample"

#define AUDIO_OFFLOAD_CODEC_APE_NUM_CHANNELS "music_offload_ape_num_channels"

#define AUDIO_OFFLOAD_CODEC_APE_SAMPLE_RATE "music_offload_ape_sample_rate"

#define AUDIO_OFFLOAD_CODEC_APE_SEEK_TABLE_PRESENT "music_offload_seek_table_present"



/* Query handle fm parameter*/

#define AUDIO_PARAMETER_KEY_HANDLE_FM "handle_fm"

hal/audio_extn/audio_extn.c

+236 −0
Original line number Diff line number Diff line
@@ -51,6 +51,8 @@ 
#include "platform_api.h"

#include "edid.h"



#include "sound/compress_params.h"



#define MAX_SLEEP_RETRY 100

#define WIFI_INIT_WAIT_SLEEP 50
@@ -667,6 +669,240 @@ void audio_extn_get_parameters(const struct audio_device *adev, 
    free(kv_pairs);

}



#ifndef COMPRESS_METADATA_NEEDED

#define audio_extn_parse_compress_metadata(out, parms) (0)

#else

int audio_extn_parse_compress_metadata(struct stream_out *out,

                                       struct str_parms *parms)

{

    int ret = 0;

    char value[32];



    if (out->format == AUDIO_FORMAT_FLAC) {

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MIN_BLK_SIZE, value, sizeof(value));

        if (ret >= 0) {

            out->gapless_mdata.min_blk_size =

            out->compr_config.codec->options.flac_dec.min_blk_size = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MAX_BLK_SIZE, value, sizeof(value));

        if (ret >= 0) {

            out->gapless_mdata.max_blk_size =

            out->compr_config.codec->options.flac_dec.max_blk_size = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MIN_FRAME_SIZE, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.flac_dec.min_frame_size = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MAX_FRAME_SIZE, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.flac_dec.max_frame_size = atoi(value);

            out->send_new_metadata = 1;

        }

        ALOGV("FLAC metadata: min_blk_size %d, max_blk_size %d min_frame_size %d max_frame_size %d",

              out->compr_config.codec->options.flac_dec.min_blk_size,

              out->compr_config.codec->options.flac_dec.max_blk_size,

              out->compr_config.codec->options.flac_dec.min_frame_size,

              out->compr_config.codec->options.flac_dec.max_frame_size);

    }



    else if (out->format == AUDIO_FORMAT_ALAC) {

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_FRAME_LENGTH, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.frame_length = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_COMPATIBLE_VERSION, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.compatible_version = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_BIT_DEPTH, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.bit_depth = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_PB, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.pb = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_MB, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.mb = atoi(value);

            out->send_new_metadata = 1;

        }



        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_KB, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.kb = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_NUM_CHANNELS, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.num_channels = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_MAX_RUN, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.max_run = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_MAX_FRAME_BYTES, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.max_frame_bytes = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_AVG_BIT_RATE, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.avg_bit_rate = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_SAMPLING_RATE, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.sample_rate = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_CHANNEL_LAYOUT_TAG, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.alac.channel_layout_tag = atoi(value);

            out->send_new_metadata = 1;

        }

        ALOGV("ALAC CSD values: frameLength %d bitDepth %d numChannels %d"

                " maxFrameBytes %d, avgBitRate %d, sampleRate %d",

                out->compr_config.codec->options.alac.frame_length,

                out->compr_config.codec->options.alac.bit_depth,

                out->compr_config.codec->options.alac.num_channels,

                out->compr_config.codec->options.alac.max_frame_bytes,

                out->compr_config.codec->options.alac.avg_bit_rate,

                out->compr_config.codec->options.alac.sample_rate);

    }



    else if (out->format == AUDIO_FORMAT_APE) {

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_COMPATIBLE_VERSION, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.compatible_version = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_COMPRESSION_LEVEL, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.compression_level = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_FORMAT_FLAGS, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.format_flags = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_BLOCKS_PER_FRAME, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.blocks_per_frame = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_FINAL_FRAME_BLOCKS, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.final_frame_blocks = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_TOTAL_FRAMES, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.total_frames = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_BITS_PER_SAMPLE, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.bits_per_sample = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_NUM_CHANNELS, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.num_channels = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_SAMPLE_RATE, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.sample_rate = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_SEEK_TABLE_PRESENT, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.ape.seek_table_present = atoi(value);

            out->send_new_metadata = 1;

        }

        ALOGV("APE CSD values: compatibleVersion %d compressionLevel %d"

                " formatFlags %d blocksPerFrame %d finalFrameBlocks %d"

                " totalFrames %d bitsPerSample %d numChannels %d"

                " sampleRate %d seekTablePresent %d",

                out->compr_config.codec->options.ape.compatible_version,

                out->compr_config.codec->options.ape.compression_level,

                out->compr_config.codec->options.ape.format_flags,

                out->compr_config.codec->options.ape.blocks_per_frame,

                out->compr_config.codec->options.ape.final_frame_blocks,

                out->compr_config.codec->options.ape.total_frames,

                out->compr_config.codec->options.ape.bits_per_sample,

                out->compr_config.codec->options.ape.num_channels,

                out->compr_config.codec->options.ape.sample_rate,

                out->compr_config.codec->options.ape.seek_table_present);

    }



    else if (out->format == AUDIO_FORMAT_VORBIS) {

        // transcoded bitstream mode

        out->compr_config.codec->options.vorbis_dec.bit_stream_fmt = 1;

        out->send_new_metadata = 1;

    }



    else if (out->format == AUDIO_FORMAT_WMA || out->format == AUDIO_FORMAT_WMA_PRO) {

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_FORMAT_TAG, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->format = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_BLOCK_ALIGN, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.wma.super_block_align = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_BIT_PER_SAMPLE, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.wma.bits_per_sample = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_CHANNEL_MASK, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.wma.channelmask = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.wma.encodeopt = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION1, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.wma.encodeopt1 = atoi(value);

            out->send_new_metadata = 1;

        }

        ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION2, value, sizeof(value));

        if (ret >= 0) {

            out->compr_config.codec->options.wma.encodeopt2 = atoi(value);

            out->send_new_metadata = 1;

        }

        ALOGV("WMA params: fmt %x, balgn %x, sr %d, chmsk %x, encop %x, op1 %x, op2 %x",

                out->compr_config.codec->format,

                out->compr_config.codec->options.wma.super_block_align,

                out->compr_config.codec->options.wma.bits_per_sample,

                out->compr_config.codec->options.wma.channelmask,

                out->compr_config.codec->options.wma.encodeopt,

                out->compr_config.codec->options.wma.encodeopt1,

                out->compr_config.codec->options.wma.encodeopt2);

    }



    return ret;

}

#endif



#ifdef AUXPCM_BT_ENABLED

int32_t audio_extn_read_xml(struct audio_device *adev, uint32_t mixer_card,

                            const char* mixer_xml_path,

hal/audio_extn/audio_extn.h

+22 −6
Original line number Diff line number Diff line
@@ -69,12 +69,28 @@ 
#define AUDIO_DEVICE_IN_FM_RX_A2DP (AUDIO_DEVICE_BIT_IN | 0x10000)

#endif



#ifndef QTI_FLAC_DECODER

#define AUDIO_FORMAT_FLAC 0x19000000UL

#define AUDIO_OFFLOAD_CODEC_FLAC_MIN_BLK_SIZE "music_offload_flac_min_blk_size"

#define AUDIO_OFFLOAD_CODEC_FLAC_MAX_BLK_SIZE "music_offload_flac_max_blk_size"

#define AUDIO_OFFLOAD_CODEC_FLAC_MIN_FRAME_SIZE "music_offload_flac_min_frame_size"

#define AUDIO_OFFLOAD_CODEC_FLAC_MAX_FRAME_SIZE "music_offload_flac_max_frame_size"

#ifndef FLAC_OFFLOAD_ENABLED

#define AUDIO_FORMAT_FLAC 0x1D000000UL

#endif



#ifndef WMA_OFFLOAD_ENABLED

#define AUDIO_FORMAT_WMA 0x13000000UL

#define AUDIO_FORMAT_WMAPRO 0x14000000UL

#endif



#ifndef ALAC_OFFLOAD_ENABLED

#define AUDIO_FORMAT_ALAC 0x1F000000UL

#endif



#ifndef APE_OFFLOAD_ENABLED

#define AUDIO_FORMAT_APE 0x20000000UL

#endif



#ifndef COMPRESS_METADATA_NEEDED

#define audio_extn_parse_compress_metadata(out, parms) (0)

#else

int audio_extn_parse_compress_metadata(struct stream_out *out,

                                       struct str_parms *parms);

#endif



#ifdef PCM_OFFLOAD_ENABLED_24

hal/audio_extn/utils.c

+2 −0
Original line number Diff line number Diff line
@@ -100,6 +100,8 @@ const struct string_to_enum s_format_name_to_enum_table[] = { 
    STRING_TO_ENUM(AUDIO_FORMAT_PCM_16_BIT_OFFLOAD),

    STRING_TO_ENUM(AUDIO_FORMAT_PCM_24_BIT_OFFLOAD),

    STRING_TO_ENUM(AUDIO_FORMAT_FLAC),

    STRING_TO_ENUM(AUDIO_FORMAT_ALAC),

    STRING_TO_ENUM(AUDIO_FORMAT_APE),

    STRING_TO_ENUM(AUDIO_FORMAT_E_AC3_JOC),

    STRING_TO_ENUM(AUDIO_FORMAT_AAC_LC),

    STRING_TO_ENUM(AUDIO_FORMAT_AAC_HE_V1),