Merge "ASoC: msm: qdsp6v2: Handle additional codec specific metadata" (a16e2273) · Commits · e / devices / android_kernel_xiaomi_markw

include/uapi/sound/compress_params.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -265,6 +265,7 @@ struct snd_enc_wma {
		__u32 encodeopt;
		__u32 encodeopt1;
		__u32 encodeopt2;
		__u32 avg_bit_rate;
		};

sound/soc/msm/qdsp6v2/msm-compress-q6-v2.c

+116 −122

Original line number	Diff line number	Diff line
		@@ -95,10 +95,9 @@ struct msm_compr_gapless_state {
		int32_t stream_opened[MAX_NUMBER_OF_STREAMS];
		uint32_t initial_samples_drop;
		uint32_t trailing_samples_drop;
		uint32_t min_blk_size;
		uint32_t max_blk_size;
		uint32_t gapless_transition;
		bool use_dsp_gapless_mode;
		union snd_codec_options codec_options;
		};

		static unsigned int supported_sample_rates[] = {
		@@ -642,7 +641,8 @@ static void populate_codec_list(struct msm_compr_audio *prtd)
		}

		static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
		int stream_id)
		int stream_id,
		bool use_gapless_codec_options)
		{
		struct snd_compr_runtime *runtime = cstream->runtime;
		struct msm_compr_audio *prtd = runtime->private_data;
		@@ -656,13 +656,26 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
		struct asm_vorbis_cfg vorbis_cfg;
		struct asm_alac_cfg alac_cfg;
		struct asm_ape_cfg ape_cfg;
		union snd_codec_options *codec_options;

		u32 cfg;
		int ret = 0;
		uint16_t bit_width = 16;
		bool use_default_chmap = true;
		char *chmap = NULL;

		pr_debug("%s: use_gapless_codec_options %d\n",
		__func__, use_gapless_codec_options);

		if (use_gapless_codec_options)
		codec_options = &(prtd->gapless_state.codec_options);
		else
		codec_options = &(prtd->codec_param.codec.options);

		if (!codec_options) {
		pr_err("%s: codec_options is NULL\n", __func__);
		return -EINVAL;
		}

		switch (prtd->codec) {
		case FORMAT_LINEAR_PCM:
		pr_debug("SND_AUDIOCODEC_PCM\n");
		@@ -717,16 +730,12 @@ 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 =
		prtd->codec_param.codec.bit_rate/8;
		wma_cfg.block_align =
		prtd->codec_param.codec.options.wma.super_block_align;
		wma_cfg.avg_bytes_per_sec = codec_options->wma.avg_bit_rate/8;
		wma_cfg.block_align = codec_options->wma.super_block_align;
		wma_cfg.valid_bits_per_sample =
		prtd->codec_param.codec.options.wma.bits_per_sample;
		wma_cfg.ch_mask =
		prtd->codec_param.codec.options.wma.channelmask;
		wma_cfg.encode_opt =
		prtd->codec_param.codec.options.wma.encodeopt;
		codec_options->wma.bits_per_sample;
		wma_cfg.ch_mask = codec_options->wma.channelmask;
		wma_cfg.encode_opt = codec_options->wma.encodeopt;
		ret = q6asm_media_format_block_wma(prtd->audio_client,
		&wma_cfg, stream_id);
		if (ret < 0)
		@@ -737,22 +746,15 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
		memset(&wma_pro_cfg, 0x0, sizeof(struct asm_wmapro_cfg));
		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_pro_cfg.avg_bytes_per_sec =
		prtd->codec_param.codec.bit_rate/8;
		wma_pro_cfg.block_align =
		prtd->codec_param.codec.options.wma.super_block_align;
		wma_pro_cfg.sample_rate = prtd->sample_rate;
		wma_cfg.avg_bytes_per_sec = codec_options->wma.avg_bit_rate/8;
		wma_pro_cfg.block_align = codec_options->wma.super_block_align;
		wma_pro_cfg.valid_bits_per_sample =
		prtd->codec_param.codec.options.wma.bits_per_sample;
		wma_pro_cfg.ch_mask =
		prtd->codec_param.codec.options.wma.channelmask;
		wma_pro_cfg.encode_opt =
		prtd->codec_param.codec.options.wma.encodeopt;
		wma_pro_cfg.adv_encode_opt =
		prtd->codec_param.codec.options.wma.encodeopt1;
		wma_pro_cfg.adv_encode_opt2 =
		prtd->codec_param.codec.options.wma.encodeopt2;
		codec_options->wma.bits_per_sample;
		wma_pro_cfg.ch_mask = codec_options->wma.channelmask;
		wma_pro_cfg.encode_opt = codec_options->wma.encodeopt;
		wma_pro_cfg.adv_encode_opt = codec_options->wma.encodeopt1;
		wma_pro_cfg.adv_encode_opt2 = codec_options->wma.encodeopt2;
		ret = q6asm_media_format_block_wmapro(prtd->audio_client,
		&wma_pro_cfg, stream_id);
		if (ret < 0)
		@@ -767,16 +769,13 @@ 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 =
		prtd->codec_param.codec.options.flac_dec.sample_size;
		flac_cfg.min_blk_size =
		prtd->codec_param.codec.options.flac_dec.min_blk_size;
		flac_cfg.max_blk_size =
		prtd->codec_param.codec.options.flac_dec.max_blk_size;
		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;
		flac_cfg.max_frame_size =
		prtd->codec_param.codec.options.flac_dec.max_frame_size;
		codec_options->flac_dec.max_frame_size;
		flac_cfg.min_frame_size =
		prtd->codec_param.codec.options.flac_dec.min_frame_size;
		codec_options->flac_dec.min_frame_size;

		ret = q6asm_stream_media_format_block_flac(prtd->audio_client,
		&flac_cfg, stream_id);
		@@ -788,8 +787,8 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
		case FORMAT_VORBIS:
		pr_debug("%s: SND_AUDIOCODEC_VORBIS\n", __func__);
		memset(&vorbis_cfg, 0x0, sizeof(struct asm_vorbis_cfg));
		cfg = prtd->codec_param.codec.options.vorbis_dec.bit_stream_fmt;
		vorbis_cfg.bit_stream_fmt = cfg;
		vorbis_cfg.bit_stream_fmt =
		codec_options->vorbis_dec.bit_stream_fmt;

		ret = q6asm_stream_media_format_block_vorbis(
		prtd->audio_client, &vorbis_cfg,
		@@ -804,22 +803,18 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
		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 =
		prtd->codec_param.codec.options.alac.frame_length;
		alac_cfg.frame_length = codec_options->alac.frame_length;
		alac_cfg.compatible_version =
		prtd->codec_param.codec.options.alac.compatible_version;
		alac_cfg.bit_depth =
		prtd->codec_param.codec.options.alac.bit_depth;
		alac_cfg.pb = prtd->codec_param.codec.options.alac.pb;
		alac_cfg.mb = prtd->codec_param.codec.options.alac.mb;
		alac_cfg.kb = prtd->codec_param.codec.options.alac.kb;
		alac_cfg.max_run = prtd->codec_param.codec.options.alac.max_run;
		alac_cfg.max_frame_bytes =
		prtd->codec_param.codec.options.alac.max_frame_bytes;
		alac_cfg.avg_bit_rate =
		prtd->codec_param.codec.options.alac.avg_bit_rate;
		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;
		alac_cfg.channel_layout_tag =
		prtd->codec_param.codec.options.alac.channel_layout_tag;
		codec_options->alac.channel_layout_tag;

		ret = q6asm_media_format_block_alac(prtd->audio_client,
		&alac_cfg, stream_id);
		@@ -833,21 +828,17 @@ static int msm_compr_send_media_format_block(struct snd_compr_stream *cstream,
		ape_cfg.num_channels = prtd->num_channels;
		ape_cfg.sample_rate = prtd->sample_rate;
		ape_cfg.compatible_version =
		prtd->codec_param.codec.options.ape.compatible_version;
		codec_options->ape.compatible_version;
		ape_cfg.compression_level =
		prtd->codec_param.codec.options.ape.compression_level;
		ape_cfg.format_flags =
		prtd->codec_param.codec.options.ape.format_flags;
		ape_cfg.blocks_per_frame =
		prtd->codec_param.codec.options.ape.blocks_per_frame;
		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;
		ape_cfg.final_frame_blocks =
		prtd->codec_param.codec.options.ape.final_frame_blocks;
		ape_cfg.total_frames =
		prtd->codec_param.codec.options.ape.total_frames;
		ape_cfg.bits_per_sample =
		prtd->codec_param.codec.options.ape.bits_per_sample;
		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;
		ape_cfg.seek_table_present =
		prtd->codec_param.codec.options.ape.seek_table_present;
		codec_options->ape.seek_table_present;

		ret = q6asm_media_format_block_ape(prtd->audio_client,
		&ape_cfg, stream_id);
		@@ -1024,7 +1015,7 @@ static int msm_compr_configure_dsp(struct snd_compr_stream *cstream)
		prtd->buffer_paddr = ac->port[dir].buf[0].phys;
		prtd->buffer_size = runtime->fragments * runtime->fragment_size;

		ret = msm_compr_send_media_format_block(cstream, ac->stream_id);
		ret = msm_compr_send_media_format_block(cstream, ac->stream_id, false);
		if (ret < 0) {
		pr_err("%s, failed to send media format block\n", __func__);
		}
		@@ -1095,8 +1086,6 @@ static int msm_compr_open(struct snd_compr_stream *cstream)
		prtd->partial_drain_delay = 0;
		prtd->next_stream = 0;
		memset(&prtd->gapless_state, 0, sizeof(struct msm_compr_gapless_state));
		prtd->gapless_state.min_blk_size = 65537;
		prtd->gapless_state.max_blk_size = 65537;
		/*
		* Update the use_dsp_gapless_mode from gapless struture with the value
		* part of platform data.
		@@ -1673,8 +1662,6 @@ static int msm_compr_trigger(struct snd_compr_stream *cstream, int cmd)
		prtd->first_buffer = 1;
		prtd->last_buffer = 0;
		prtd->gapless_state.gapless_transition = 1;
		prtd->gapless_state.min_blk_size = 65537;
		prtd->gapless_state.max_blk_size = 65537;
		prtd->marker_timestamp = 0;

		/*
		@@ -1851,7 +1838,8 @@ static int msm_compr_trigger(struct snd_compr_stream *cstream, int cmd)
		__func__);
		break;
		}
		rc = msm_compr_send_media_format_block(cstream, stream_id);
		rc = msm_compr_send_media_format_block(cstream,
		stream_id, false);
		if (rc < 0) {
		pr_err("%s, failed to send media format block\n",
		__func__);
		@@ -2124,8 +2112,6 @@ static int msm_compr_set_metadata(struct snd_compr_stream *cstream,
		{
		struct msm_compr_audio *prtd;
		struct audio_client *ac;
		struct asm_flac_cfg flac_cfg;
		int ret = 0;
		pr_debug("%s\n", __func__);

		if (!metadata \|\| !cstream)
		@@ -2149,49 +2135,56 @@ static int msm_compr_set_metadata(struct snd_compr_stream *cstream,
		} else if (metadata->key == SNDRV_COMPRESS_ENCODER_DELAY) {
		pr_debug("%s, got encoder delay %u", __func__, metadata->value[0]);
		prtd->gapless_state.initial_samples_drop = metadata->value[0];
		} else if (metadata->key == SNDRV_COMPRESS_MIN_BLK_SIZE) {
		pr_debug("%s, got min_blk_size %u",
		__func__, metadata->value[0]);
		prtd->gapless_state.min_blk_size = metadata->value[0];
		} else if (metadata->key == SNDRV_COMPRESS_MAX_BLK_SIZE) {
		pr_debug("%s, got max_blk_size %u",
		__func__, metadata->value[0]);
		prtd->gapless_state.max_blk_size = metadata->value[0];
		}

		if ((prtd->codec == FORMAT_FLAC) &&
		(prtd->gapless_state.min_blk_size >= 0) &&
		(prtd->gapless_state.min_blk_size <= FLAC_BLK_SIZE_LIMIT) &&
		(prtd->gapless_state.max_blk_size >= 0) &&
		(prtd->gapless_state.max_blk_size <= FLAC_BLK_SIZE_LIMIT)) {
		pr_debug("%s: SND_AUDIOCODEC_FLAC\n", __func__);
		memset(&flac_cfg, 0x0, sizeof(struct asm_flac_cfg));
		flac_cfg.ch_cfg = prtd->num_channels;
		flac_cfg.sample_rate = prtd->sample_rate;
		flac_cfg.stream_info_present = 1;
		flac_cfg.sample_size =
		prtd->codec_param.codec.options.flac_dec.sample_size;
		flac_cfg.min_blk_size =
		prtd->gapless_state.min_blk_size;
		flac_cfg.max_blk_size =
		prtd->gapless_state.max_blk_size;
		flac_cfg.max_frame_size =
		prtd->codec_param.codec.options.flac_dec.max_frame_size;
		flac_cfg.min_frame_size =
		prtd->codec_param.codec.options.flac_dec.min_frame_size;
		pr_debug("%s: min_blk_size %d max_blk_size %d\n",
		__func__, flac_cfg.min_blk_size, flac_cfg.max_blk_size);
		}

		ret = q6asm_stream_media_format_block_flac(ac, &flac_cfg,
		ac->stream_id);
		if (ret < 0)
		pr_err("%s: CMD Format block failed ret %d\n",
		__func__, ret);
		return 0;
		}

		static int msm_compr_set_next_track_param(struct snd_compr_stream *cstream,
		union snd_codec_options *codec_options)
		{
		struct msm_compr_audio *prtd;
		struct audio_client *ac;
		int ret = 0;

		prtd->partial_drain_delay = msm_compr_get_partial_drain_delay(
		flac_cfg.min_blk_size, prtd->sample_rate);
		if (!codec_options \|\| !cstream)
		return -EINVAL;

		prtd = cstream->runtime->private_data;
		if (!prtd \|\| !prtd->audio_client) {
		pr_err("%s: prtd or audio client is NULL\n", __func__);
		return -EINVAL;
		}
		return 0;

		ac = prtd->audio_client;

		pr_debug("%s: got codec options for codec type %u",
		__func__, prtd->codec);
		switch (prtd->codec) {
		case FORMAT_WMA_V9:
		case FORMAT_WMA_V10PRO:
		case FORMAT_FLAC:
		case FORMAT_VORBIS:
		case FORMAT_ALAC:
		case FORMAT_APE:
		memcpy(&(prtd->gapless_state.codec_options),
		codec_options,
		sizeof(union snd_codec_options));
		ret = msm_compr_send_media_format_block(cstream,
		ac->stream_id, true);
		if (ret < 0) {
		pr_err("%s: failed to send media format block\n",
		__func__);
		}
		break;

		default:
		pr_debug("%s: Ignore sending CMD Format block\n",
		__func__);
		break;
		}

		return ret;
		}

		static int msm_compr_volume_put(struct snd_kcontrol *kcontrol,
		@@ -3178,6 +3171,7 @@ static struct snd_compr_ops msm_compr_ops = {
		.pointer = msm_compr_pointer,
		.set_params = msm_compr_set_params,
		.set_metadata = msm_compr_set_metadata,
		.set_next_track_param = msm_compr_set_next_track_param,
		.ack = msm_compr_ack,
		.copy = msm_compr_copy,
		.get_caps = msm_compr_get_caps,