From 7757a73f785b4452d0865bb904e1871431ee4a9e Mon Sep 17 00:00:00 2001
From: Xiaojun Sang <xsang@codeaurora.org>
Date: Fri, 3 Jul 2020 10:14:49 +0800
Subject: [PATCH 1/2] asoc: uapi: add definition for generic decoder in
 techpack

Add structure and format definition for ALAC, APE, APTX, DSD,
AAC, FLAC, VORBIS and WMA.

Change-Id: Ide8027cf06c8c2f55f34d8a1b5b1b84e05851113
Signed-off-by: Xiaojun Sang <xsang@codeaurora.org>
---
 .../audio/sound/audio_compressed_formats.h    | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 include/uapi/audio/sound/audio_compressed_formats.h

diff --git a/include/uapi/audio/sound/audio_compressed_formats.h b/include/uapi/audio/sound/audio_compressed_formats.h
new file mode 100644
index 000000000000..29c4a1ce6545
--- /dev/null
+++ b/include/uapi/audio/sound/audio_compressed_formats.h
@@ -0,0 +1,90 @@
+#ifndef __AUDIO_COMPRESSED_FORMATS_H
+#define __AUDIO_COMPRESSED_FORMATS_H
+
+#include <linux/types.h>
+
+#define AUDIO_COMP_FORMAT_ALAC 0x1
+#define AUDIO_COMP_FORMAT_APE 0x2
+#define AUDIO_COMP_FORMAT_APTX 0x3
+#define AUDIO_COMP_FORMAT_DSD 0x4
+#define AUDIO_COMP_FORMAT_FLAC 0x5
+#define AUDIO_COMP_FORMAT_VORBIS 0x6
+#define AUDIO_COMP_FORMAT_WMA 0x7
+#define AUDIO_COMP_FORMAT_WMA_PRO 0x8
+
+#define SND_COMPRESS_DEC_HDR
+struct snd_generic_dec_aac {
+	__u16 audio_obj_type;
+	__u16 pce_bits_size;
+} __attribute__((packed, aligned(4)));
+
+struct snd_generic_dec_flac {
+	__u16 sample_size;
+	__u16 min_blk_size;
+	__u16 max_blk_size;
+	__u16 min_frame_size;
+	__u16 max_frame_size;
+} __attribute__((packed, aligned(4)));
+
+struct snd_generic_dec_alac {
+	__u32 frame_length;
+	__u8 compatible_version;
+	__u8 bit_depth;
+	__u8 pb;
+	__u8 mb;
+	__u8 kb;
+	__u8 num_channels;
+	__u16 max_run;
+	__u32 max_frame_bytes;
+	__u32 avg_bit_rate;
+	__u32 sample_rate;
+	__u32 channel_layout_tag;
+} __attribute__((packed, aligned(4)));
+
+struct snd_generic_dec_ape {
+	__u16 compatible_version;
+	__u16 compression_level;
+	__u32 format_flags;
+	__u32 blocks_per_frame;
+	__u32 final_frame_blocks;
+	__u32 total_frames;
+	__u16 bits_per_sample;
+	__u16 num_channels;
+	__u32 sample_rate;
+	__u32 seek_table_present;
+} __attribute__((packed, aligned(4)));
+
+struct snd_generic_dec_wma {
+	__u32 super_block_align;
+	__u32 bits_per_sample;
+	__u32 channelmask;
+	__u32 encodeopt;
+	__u32 encodeopt1;
+	__u32 encodeopt2;
+	__u32 avg_bit_rate;
+} __attribute__((packed, aligned(4)));
+
+#define SND_DEC_WMA_EXTENTED_SUPPORT
+
+struct snd_generic_dec_aptx {
+	__u32 lap;
+	__u32 uap;
+	__u32 nap;
+} __attribute__((packed, aligned(4)));
+
+struct snd_generic_dec_vorbis {
+	__u32 bit_stream_fmt;
+} __attribute__((packed, aligned(4)));
+
+/** struct snd_generic_dec_dsd - codec for DSD format
+ * @blk_size - dsd channel block size
+ */
+struct snd_generic_dec_dsd {
+	__u32 blk_size;
+} __attribute__((packed, aligned(4)));
+
+struct snd_generic_dec_amrwb_plus {
+	__u32 bit_stream_fmt;
+} __attribute__((packed, aligned(4)));
+
+#endif

From d7e26a7538aed818605e26417ef1de3b25a71a04 Mon Sep 17 00:00:00 2001
From: Xiaojun Sang <xsang@codeaurora.org>
Date: Mon, 29 Jun 2020 21:40:40 +0800
Subject: [PATCH 2/2] asoc: adapt to new compressed format header

snd_enc_generic structure is used to pass the decoder type
and configuration. Reserved[0] contains the decoder type
and reserve[1] onwards the decoder configuration. Adapt
decoder parsing logic accordingly.

Change-Id: Icc0bf27e026e0144e8356abddf7646a6d34e645c
Signed-off-by: Xiaojun Sang <xsang@codeaurora.org>
---
 asoc/msm-compress-q6-v2.c | 262 ++++++++++++++++++++------------------
 1 file changed, 137 insertions(+), 125 deletions(-)

diff --git a/asoc/msm-compress-q6-v2.c b/asoc/msm-compress-q6-v2.c
index c2d8271f10d2..3e66b48a0d91 100644
--- a/asoc/msm-compress-q6-v2.c
+++ b/asoc/msm-compress-q6-v2.c
@@ -21,6 +21,7 @@
 #include <sound/control.h>
 #include <sound/pcm_params.h>
 #include <audio/sound/audio_effects.h>
+#include <audio/sound/audio_compressed_formats.h>
 #include <asm/dma.h>
 #include <linux/dma-mapping.h>
 #include <audio/linux/msm_audio.h>
@@ -191,7 +192,7 @@ struct msm_compr_audio {
 
 const u32 compr_codecs[] = {
 	SND_AUDIOCODEC_AC3, SND_AUDIOCODEC_EAC3, SND_AUDIOCODEC_DTS,
-	SND_AUDIOCODEC_DSD, SND_AUDIOCODEC_TRUEHD, SND_AUDIOCODEC_IEC61937};
+	SND_AUDIOCODEC_TRUEHD, SND_AUDIOCODEC_IEC61937};
 
 struct query_audio_effect {
 	uint32_t mod_id;
@@ -1101,24 +1102,62 @@ static void populate_codec_list(struct msm_compr_audio *prtd)
 			COMPR_PLAYBACK_MIN_NUM_FRAGMENTS;
 	prtd->compr_cap.max_fragments =
 			COMPR_PLAYBACK_MAX_NUM_FRAGMENTS;
-	prtd->compr_cap.num_codecs = 17;
+	prtd->compr_cap.num_codecs = 10;
 	prtd->compr_cap.codecs[0] = SND_AUDIOCODEC_MP3;
 	prtd->compr_cap.codecs[1] = SND_AUDIOCODEC_AAC;
 	prtd->compr_cap.codecs[2] = SND_AUDIOCODEC_AC3;
 	prtd->compr_cap.codecs[3] = SND_AUDIOCODEC_EAC3;
 	prtd->compr_cap.codecs[4] = SND_AUDIOCODEC_MP2;
 	prtd->compr_cap.codecs[5] = SND_AUDIOCODEC_PCM;
-	prtd->compr_cap.codecs[6] = SND_AUDIOCODEC_WMA;
-	prtd->compr_cap.codecs[7] = SND_AUDIOCODEC_WMA_PRO;
-	prtd->compr_cap.codecs[8] = SND_AUDIOCODEC_FLAC;
-	prtd->compr_cap.codecs[9] = SND_AUDIOCODEC_VORBIS;
-	prtd->compr_cap.codecs[10] = SND_AUDIOCODEC_ALAC;
-	prtd->compr_cap.codecs[11] = SND_AUDIOCODEC_APE;
-	prtd->compr_cap.codecs[12] = SND_AUDIOCODEC_DTS;
-	prtd->compr_cap.codecs[13] = SND_AUDIOCODEC_DSD;
-	prtd->compr_cap.codecs[14] = SND_AUDIOCODEC_APTX;
-	prtd->compr_cap.codecs[15] = SND_AUDIOCODEC_TRUEHD;
-	prtd->compr_cap.codecs[16] = SND_AUDIOCODEC_IEC61937;
+	prtd->compr_cap.codecs[6] = SND_AUDIOCODEC_DTS;
+	prtd->compr_cap.codecs[7] = SND_AUDIOCODEC_TRUEHD;
+	prtd->compr_cap.codecs[8] = SND_AUDIOCODEC_IEC61937;
+	prtd->compr_cap.codecs[9] = SND_AUDIOCODEC_BESPOKE;
+}
+
+static int msm_compr_get_decoder_format(struct msm_compr_audio *prtd,
+	int *frame_sz, bool *is_format_gapless)
+{
+	int ret = 0;
+	__s32 *gdec;
+
+	pr_debug("%s: generic format = %x", __func__,
+		prtd->codec_param.codec.options.generic.reserved[0]);
+
+	switch(prtd->codec_param.codec.options.generic.reserved[0]) {
+	case AUDIO_COMP_FORMAT_ALAC:
+		ret = FORMAT_ALAC;
+		break;
+	case AUDIO_COMP_FORMAT_APE:
+		ret = FORMAT_APE;
+		break;
+	case AUDIO_COMP_FORMAT_APTX:
+		ret = FORMAT_APTX;
+		break;
+	case AUDIO_COMP_FORMAT_DSD:
+		ret = FORMAT_DSD;
+		break;
+	case AUDIO_COMP_FORMAT_FLAC:
+		ret = FORMAT_FLAC;
+		*is_format_gapless = true;
+		gdec = &(prtd->codec_param.codec.options.generic.reserved[1]);
+		*frame_sz = ((struct snd_generic_dec_flac *)gdec)->min_blk_size;
+		break;
+	case AUDIO_COMP_FORMAT_VORBIS:
+		ret = FORMAT_VORBIS;
+		break;
+	case AUDIO_COMP_FORMAT_WMA:
+		ret = FORMAT_WMA_V9;
+		break;
+	case AUDIO_COMP_FORMAT_WMA_PRO:
+		ret = FORMAT_WMA_V10PRO;
+		break;
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	return ret;
 }
 
 static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
@@ -1147,6 +1186,7 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
 	bool use_default_chmap = true;
 	char *chmap = NULL;
 	uint16_t sample_word_size;
+	__s32 *gdec;
 
 	pr_debug("%s: use_gapless_codec_options %d\n",
 			__func__, use_gapless_codec_options);
@@ -1262,12 +1302,17 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
 		wma_cfg.format_tag = prtd->codec_param.codec.format;
 		wma_cfg.ch_cfg = prtd->codec_param.codec.ch_in;
 		wma_cfg.sample_rate = prtd->sample_rate;
-		wma_cfg.avg_bytes_per_sec = codec_options->wma_dec.avg_bit_rate/8;
-		wma_cfg.block_align = codec_options->wma_dec.super_block_align;
+		gdec = &(codec_options->generic.reserved[1]);
+		wma_cfg.avg_bytes_per_sec =
+			((struct snd_generic_dec_wma *)gdec)->avg_bit_rate/8;
+		wma_cfg.block_align =
+			((struct snd_generic_dec_wma *)gdec)->super_block_align;
 		wma_cfg.valid_bits_per_sample =
-			codec_options->wma_dec.bits_per_sample;
-		wma_cfg.ch_mask = codec_options->wma_dec.channelmask;
-		wma_cfg.encode_opt = codec_options->wma_dec.encodeopt;
+			((struct snd_generic_dec_wma *)gdec)->bits_per_sample;
+		wma_cfg.ch_mask =
+			((struct snd_generic_dec_wma *)gdec)->channelmask;
+		wma_cfg.encode_opt =
+			((struct snd_generic_dec_wma *)gdec)->encodeopt;
 		ret = q6asm_media_format_block_wma(prtd->audio_client,
 					&wma_cfg, stream_id);
 		if (ret < 0)
@@ -1279,14 +1324,21 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
 		wma_pro_cfg.format_tag = prtd->codec_param.codec.format;
 		wma_pro_cfg.ch_cfg = prtd->codec_param.codec.ch_in;
 		wma_pro_cfg.sample_rate = prtd->sample_rate;
-		wma_cfg.avg_bytes_per_sec = codec_options->wma_dec.avg_bit_rate/8;
-		wma_pro_cfg.block_align = codec_options->wma_dec.super_block_align;
+		gdec = &(codec_options->generic.reserved[1]);
+		wma_cfg.avg_bytes_per_sec =
+			((struct snd_generic_dec_wma *)gdec)->avg_bit_rate/8;
+		wma_pro_cfg.block_align =
+			((struct snd_generic_dec_wma *)gdec)->super_block_align;
 		wma_pro_cfg.valid_bits_per_sample =
-			codec_options->wma_dec.bits_per_sample;
-		wma_pro_cfg.ch_mask = codec_options->wma_dec.channelmask;
-		wma_pro_cfg.encode_opt = codec_options->wma_dec.encodeopt;
-		wma_pro_cfg.adv_encode_opt = codec_options->wma_dec.encodeopt1;
-		wma_pro_cfg.adv_encode_opt2 = codec_options->wma_dec.encodeopt2;
+			((struct snd_generic_dec_wma *)gdec)->bits_per_sample;
+		wma_pro_cfg.ch_mask =
+			((struct snd_generic_dec_wma *)gdec)->channelmask;
+		wma_pro_cfg.encode_opt =
+			((struct snd_generic_dec_wma *)gdec)->encodeopt;
+		wma_pro_cfg.adv_encode_opt =
+			((struct snd_generic_dec_wma *)gdec)->encodeopt1;
+		wma_pro_cfg.adv_encode_opt2 =
+			((struct snd_generic_dec_wma *)gdec)->encodeopt2;
 		ret = q6asm_media_format_block_wmapro(prtd->audio_client,
 				&wma_pro_cfg, stream_id);
 		if (ret < 0)
@@ -1301,53 +1353,59 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
 		flac_cfg.ch_cfg = prtd->num_channels;
 		flac_cfg.sample_rate = prtd->sample_rate;
 		flac_cfg.stream_info_present = 1;
-		flac_cfg.sample_size = codec_options->flac_dec.sample_size;
-		flac_cfg.min_blk_size = codec_options->flac_dec.min_blk_size;
-		flac_cfg.max_blk_size = codec_options->flac_dec.max_blk_size;
+		gdec = &(codec_options->generic.reserved[1]);
+		flac_cfg.sample_size =
+			((struct snd_generic_dec_flac *)gdec)->sample_size;
+		flac_cfg.min_blk_size =
+			((struct snd_generic_dec_flac *)gdec)->min_blk_size;
+		flac_cfg.max_blk_size =
+			((struct snd_generic_dec_flac *)gdec)->max_blk_size;
 		flac_cfg.max_frame_size =
-			codec_options->flac_dec.max_frame_size;
+			((struct snd_generic_dec_flac *)gdec)->max_frame_size;
 		flac_cfg.min_frame_size =
-			codec_options->flac_dec.min_frame_size;
-
+			((struct snd_generic_dec_flac *)gdec)->min_frame_size;
 		ret = q6asm_stream_media_format_block_flac(prtd->audio_client,
 							&flac_cfg, stream_id);
 		if (ret < 0)
 			pr_err("%s: CMD Format block failed ret %d\n",
 				__func__, ret);
-
 		break;
 	case FORMAT_VORBIS:
 		pr_debug("%s: SND_AUDIOCODEC_VORBIS\n", __func__);
 		memset(&vorbis_cfg, 0x0, sizeof(struct asm_vorbis_cfg));
+		gdec = &(codec_options->generic.reserved[1]);
 		vorbis_cfg.bit_stream_fmt =
-			codec_options->vorbis_dec.bit_stream_fmt;
-
+			((struct snd_generic_dec_vorbis *)gdec)->bit_stream_fmt;
 		ret = q6asm_stream_media_format_block_vorbis(
 					prtd->audio_client, &vorbis_cfg,
 					stream_id);
 		if (ret < 0)
 			pr_err("%s: CMD Format block failed ret %d\n",
 					__func__, ret);
-
 		break;
 	case FORMAT_ALAC:
 		pr_debug("%s: SND_AUDIOCODEC_ALAC\n", __func__);
 		memset(&alac_cfg, 0x0, sizeof(struct asm_alac_cfg));
 		alac_cfg.num_channels = prtd->num_channels;
 		alac_cfg.sample_rate = prtd->sample_rate;
-		alac_cfg.frame_length = codec_options->alac.frame_length;
+		gdec = &(codec_options->generic.reserved[1]);
+		alac_cfg.frame_length =
+			((struct snd_generic_dec_alac *)gdec)->frame_length;
 		alac_cfg.compatible_version =
-			codec_options->alac.compatible_version;
-		alac_cfg.bit_depth = codec_options->alac.bit_depth;
-		alac_cfg.pb = codec_options->alac.pb;
-		alac_cfg.mb = codec_options->alac.mb;
-		alac_cfg.kb = codec_options->alac.kb;
-		alac_cfg.max_run = codec_options->alac.max_run;
-		alac_cfg.max_frame_bytes = codec_options->alac.max_frame_bytes;
-		alac_cfg.avg_bit_rate = codec_options->alac.avg_bit_rate;
+		((struct snd_generic_dec_alac *)gdec)->compatible_version;
+		alac_cfg.bit_depth =
+			((struct snd_generic_dec_alac *)gdec)->bit_depth;
+		alac_cfg.pb = ((struct snd_generic_dec_alac *)gdec)->pb;
+		alac_cfg.mb = ((struct snd_generic_dec_alac *)gdec)->mb;
+		alac_cfg.kb = ((struct snd_generic_dec_alac *)gdec)->kb;
+		alac_cfg.max_run =
+			((struct snd_generic_dec_alac *)gdec)->max_run;
+		alac_cfg.max_frame_bytes =
+			((struct snd_generic_dec_alac *)gdec)->max_frame_bytes;
+		alac_cfg.avg_bit_rate =
+			((struct snd_generic_dec_alac *)gdec)->avg_bit_rate;
 		alac_cfg.channel_layout_tag =
-			codec_options->alac.channel_layout_tag;
-
+		((struct snd_generic_dec_alac *)gdec)->channel_layout_tag;
 		ret = q6asm_media_format_block_alac(prtd->audio_client,
 							&alac_cfg, stream_id);
 		if (ret < 0)
@@ -1359,22 +1417,25 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
 		memset(&ape_cfg, 0x0, sizeof(struct asm_ape_cfg));
 		ape_cfg.num_channels = prtd->num_channels;
 		ape_cfg.sample_rate = prtd->sample_rate;
+		gdec = &(codec_options->generic.reserved[1]);
 		ape_cfg.compatible_version =
-			codec_options->ape.compatible_version;
+		((struct snd_generic_dec_ape *)gdec)->compatible_version;
 		ape_cfg.compression_level =
-			codec_options->ape.compression_level;
-		ape_cfg.format_flags = codec_options->ape.format_flags;
-		ape_cfg.blocks_per_frame = codec_options->ape.blocks_per_frame;
+		((struct snd_generic_dec_ape *)gdec)->compression_level;
+		ape_cfg.format_flags =
+		((struct snd_generic_dec_ape *)gdec)->format_flags;
+		ape_cfg.blocks_per_frame =
+		((struct snd_generic_dec_ape *)gdec)->blocks_per_frame;
 		ape_cfg.final_frame_blocks =
-			codec_options->ape.final_frame_blocks;
-		ape_cfg.total_frames = codec_options->ape.total_frames;
-		ape_cfg.bits_per_sample = codec_options->ape.bits_per_sample;
+		((struct snd_generic_dec_ape *)gdec)->final_frame_blocks;
+		ape_cfg.total_frames =
+		((struct snd_generic_dec_ape *)gdec)->total_frames;
+		ape_cfg.bits_per_sample =
+		((struct snd_generic_dec_ape *)gdec)->bits_per_sample;
 		ape_cfg.seek_table_present =
-			codec_options->ape.seek_table_present;
-
+		((struct snd_generic_dec_ape *)gdec)->seek_table_present;
 		ret = q6asm_media_format_block_ape(prtd->audio_client,
 							&ape_cfg, stream_id);
-
 		if (ret < 0)
 			pr_err("%s: CMD Format block failed ret %d\n",
 					__func__, ret);
@@ -1391,10 +1452,11 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
 		dsd_cfg.num_version = 0;
 		dsd_cfg.is_bitwise_big_endian = 1;
 		dsd_cfg.dsd_channel_block_size = 1;
-
-		if (codec_options->dsd_dec.blk_size == DSD_BLOCK_SIZE_4)
+		gdec = &(codec_options->generic.reserved[1]);
+		if (((struct snd_generic_dec_dsd *)gdec)->blk_size ==
+							DSD_BLOCK_SIZE_4)
 			dsd_cfg.dsd_channel_block_size =
-				codec_options->dsd_dec.blk_size;
+				((struct snd_generic_dec_dsd *)gdec)->blk_size;
 
 		ret = q6asm_media_format_block_dsd(prtd->audio_client,
 						   &dsd_cfg, stream_id);
@@ -1423,9 +1485,13 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
 							prtd->sample_rate,
 							stream_id);
 		if (ret >= 0) {
-			aptx_cfg.nap = codec_options->aptx_dec.nap;
-			aptx_cfg.uap = codec_options->aptx_dec.uap;
-			aptx_cfg.lap = codec_options->aptx_dec.lap;
+			gdec = &(codec_options->generic.reserved[1]);
+			aptx_cfg.nap =
+				((struct snd_generic_dec_aptx *)gdec)->nap;
+			aptx_cfg.uap =
+				((struct snd_generic_dec_aptx *)gdec)->uap;
+			aptx_cfg.lap =
+				((struct snd_generic_dec_aptx *)gdec)->lap;
 			q6asm_set_aptx_dec_bt_addr(prtd->audio_client,
 							&aptx_cfg);
 		} else {
@@ -1444,9 +1510,10 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
 	case FORMAT_AMR_WB_PLUS:
 		pr_debug("SND_AUDIOCODEC_AMRWBPLUS\n");
 		memset(&amrwbplus_cfg, 0x0, sizeof(struct asm_amrwbplus_cfg));
+		gdec = &(codec_options->generic.reserved[1]);
 		amrwbplus_cfg.amr_frame_fmt =
-			codec_options->amrwbplus.bit_stream_fmt;
-		ret =  q6asm_media_format_block_amrwbplus(
+		((struct snd_generic_dec_amrwb_plus *)gdec)->bit_stream_fmt;
+		ret = q6asm_media_format_block_amrwbplus(
 				prtd->audio_client,
 				&amrwbplus_cfg);
 		if (ret < 0)
@@ -2335,48 +2402,6 @@ static int msm_compr_set_params(struct snd_compr_stream *cstream,
 		break;
 	}
 
-	case SND_AUDIOCODEC_WMA: {
-		pr_debug("SND_AUDIOCODEC_WMA\n");
-		prtd->codec = FORMAT_WMA_V9;
-		break;
-	}
-
-	case SND_AUDIOCODEC_WMA_PRO: {
-		pr_debug("SND_AUDIOCODEC_WMA_PRO\n");
-		prtd->codec = FORMAT_WMA_V10PRO;
-		break;
-	}
-
-	case SND_AUDIOCODEC_FLAC: {
-		pr_debug("%s: SND_AUDIOCODEC_FLAC\n", __func__);
-		prtd->codec = FORMAT_FLAC;
-		/*
-		 * DSP bufferring is based on blk size,
-		 * consider mininum buffering to rule out any false wait
-		 */
-		frame_sz =
-			prtd->codec_param.codec.options.flac_dec.min_blk_size;
-		is_format_gapless = true;
-		break;
-	}
-
-	case SND_AUDIOCODEC_VORBIS: {
-		pr_debug("%s: SND_AUDIOCODEC_VORBIS\n", __func__);
-		prtd->codec = FORMAT_VORBIS;
-		break;
-	}
-
-	case SND_AUDIOCODEC_ALAC: {
-		pr_debug("%s: SND_AUDIOCODEC_ALAC\n", __func__);
-		prtd->codec = FORMAT_ALAC;
-		break;
-	}
-
-	case SND_AUDIOCODEC_APE: {
-		pr_debug("%s: SND_AUDIOCODEC_APE\n", __func__);
-		prtd->codec = FORMAT_APE;
-		break;
-	}
 
 	case SND_AUDIOCODEC_DTS: {
 		pr_debug("%s: SND_AUDIOCODEC_DTS\n", __func__);
@@ -2384,12 +2409,6 @@ static int msm_compr_set_params(struct snd_compr_stream *cstream,
 		break;
 	}
 
-	case SND_AUDIOCODEC_DSD: {
-		pr_debug("%s: SND_AUDIOCODEC_DSD\n", __func__);
-		prtd->codec = FORMAT_DSD;
-		break;
-	}
-
 	case SND_AUDIOCODEC_TRUEHD: {
 		pr_debug("%s: SND_AUDIOCODEC_TRUEHD\n", __func__);
 		prtd->codec = FORMAT_TRUEHD;
@@ -2402,15 +2421,13 @@ static int msm_compr_set_params(struct snd_compr_stream *cstream,
 		break;
 	}
 
-	case SND_AUDIOCODEC_APTX: {
-		pr_debug("%s: SND_AUDIOCODEC_APTX\n", __func__);
-		prtd->codec = FORMAT_APTX;
-		break;
-	}
-
 	case SND_AUDIOCODEC_BESPOKE: {
 		pr_debug("%s: SND_AUDIOCODEC_BESPOKE\n", __func__);
-		prtd->codec = FORMAT_BESPOKE;
+		ret = msm_compr_get_decoder_format(prtd, &frame_sz,
+						&is_format_gapless);
+		if (ret < 0)
+			return ret;
+		prtd->codec = ret;
 		break;
 	}
 
@@ -3350,15 +3367,10 @@ static int msm_compr_get_codec_caps(struct snd_compr_stream *cstream,
 		break;
 	case SND_AUDIOCODEC_AC3:
 	case SND_AUDIOCODEC_EAC3:
-	case SND_AUDIOCODEC_FLAC:
-	case SND_AUDIOCODEC_VORBIS:
-	case SND_AUDIOCODEC_ALAC:
-	case SND_AUDIOCODEC_APE:
 	case SND_AUDIOCODEC_DTS:
-	case SND_AUDIOCODEC_DSD:
 	case SND_AUDIOCODEC_TRUEHD:
 	case SND_AUDIOCODEC_IEC61937:
-	case SND_AUDIOCODEC_APTX:
+	case SND_AUDIOCODEC_BESPOKE:
 		break;
 	default:
 		pr_err("%s: Unsupported audio codec %d\n",