Merge "hal: add support to offload VORBIS, ALAC and APE formats" (b87c2eea) · Commits · e / os / android_hardware_qcom_audio

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),