Removed the feeding_init call from tA2DP_ENCODER_INTERFACE (1796c8a6) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/a2dp/a2dp_sbc.cc

+7 −4

Original line number	Diff line number	Diff line
		@@ -87,10 +87,13 @@ const tA2DP_SBC_CIE a2dp_sbc_default_config = {
		};

		static const tA2DP_ENCODER_INTERFACE a2dp_encoder_interface_sbc = {
		a2dp_sbc_encoder_init, a2dp_sbc_encoder_cleanup,
		a2dp_sbc_feeding_init, a2dp_sbc_feeding_reset,
		a2dp_sbc_feeding_flush, a2dp_sbc_get_encoder_interval_ms,
		a2dp_sbc_send_frames, a2dp_sbc_debug_codec_dump};
		a2dp_sbc_encoder_init,
		a2dp_sbc_encoder_cleanup,
		a2dp_sbc_feeding_reset,
		a2dp_sbc_feeding_flush,
		a2dp_sbc_get_encoder_interval_ms,
		a2dp_sbc_send_frames,
		a2dp_sbc_debug_codec_dump};

		static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilitySbc(
		const tA2DP_SBC_CIE* p_cap, const uint8_t* p_codec_info,

system/stack/a2dp/a2dp_sbc_encoder.cc

+7 −67

Original line number	Diff line number	Diff line
		@@ -217,12 +217,14 @@ static void a2dp_sbc_encoder_update(uint16_t peer_mtu,
		max_bitpool = A2DP_GetMaxBitpoolSbc(p_codec_info);

		// The feeding parameters
		a2dp_sbc_encoder_cb.feeding_params.sample_rate =
		A2DP_GetTrackSampleRateSbc(p_codec_info);
		a2dp_sbc_encoder_cb.feeding_params.bits_per_sample =
		tA2DP_FEEDING_PARAMS* p_feeding_params = &a2dp_sbc_encoder_cb.feeding_params;
		p_feeding_params->sample_rate = A2DP_GetTrackSampleRateSbc(p_codec_info);
		p_feeding_params->bits_per_sample =
		A2DP_GetTrackBitsPerSampleSbc(p_codec_info);
		a2dp_sbc_encoder_cb.feeding_params.channel_count =
		A2DP_GetTrackChannelCountSbc(p_codec_info);
		p_feeding_params->channel_count = A2DP_GetTrackChannelCountSbc(p_codec_info);
		LOG_DEBUG(LOG_TAG, "%s: sample_rate=%u bits_per_sample=%u channel_count=%u",
		__func__, p_feeding_params->sample_rate,
		p_feeding_params->bits_per_sample, p_feeding_params->channel_count);

		// The codec parameters
		p_encoder_params->s16ChannelMode = A2DP_GetChannelModeCodeSbc(p_codec_info);
		@@ -378,68 +380,6 @@ void a2dp_sbc_encoder_cleanup(void) {
		memset(&a2dp_sbc_encoder_cb, 0, sizeof(a2dp_sbc_encoder_cb));
		}

		void a2dp_sbc_feeding_init(const tA2DP_FEEDING_PARAMS* p_feeding_params) {
		SBC_ENC_PARAMS* p_encoder_params = &a2dp_sbc_encoder_cb.sbc_encoder_params;
		bool reconfig_needed = false;

		LOG_DEBUG(
		LOG_TAG,
		"%s: PCM feeding: sample_rate:%d bits_per_sample:%d channel_count:%d",
		__func__, p_feeding_params->sample_rate,
		p_feeding_params->bits_per_sample, p_feeding_params->channel_count);

		/* Save the feeding information */
		memcpy(&a2dp_sbc_encoder_cb.feeding_params, p_feeding_params,
		sizeof(tA2DP_FEEDING_PARAMS));

		/* Check the PCM feeding sample_rate */
		switch (p_feeding_params->sample_rate) {
		case 8000:
		case 12000:
		case 16000:
		case 24000:
		case 32000:
		case 48000:
		/* For these sample_rate the AV connection must be 48000 */
		if (p_encoder_params->s16SamplingFreq != SBC_sf48000) {
		/* Reconfiguration needed at 48000 */
		LOG_DEBUG(LOG_TAG, "%s: SBC Reconfiguration needed at 48000", __func__);
		p_encoder_params->s16SamplingFreq = SBC_sf48000;
		reconfig_needed = true;
		}
		break;

		case 11025:
		case 22050:
		case 44100:
		/* For these sample_rate the AV connection must be 44100 */
		if (p_encoder_params->s16SamplingFreq != SBC_sf44100) {
		/* Reconfiguration needed at 44100 */
		LOG_DEBUG(LOG_TAG, "%s: SBC Reconfiguration needed at 44100", __func__);
		p_encoder_params->s16SamplingFreq = SBC_sf44100;
		reconfig_needed = true;
		}
		break;
		default:
		LOG_DEBUG(LOG_TAG, "%s: Feeding PCM sample_rate %u is not supported",
		__func__, p_feeding_params->sample_rate);
		break;
		}

		if (reconfig_needed) {
		LOG_DEBUG(
		LOG_TAG,
		"%s: mtu %d ch mode %d, nbsubd %d, nb %d, alloc %d, rate %d, freq %d",
		__func__, a2dp_sbc_encoder_cb.TxAaMtuSize,
		p_encoder_params->s16ChannelMode, p_encoder_params->s16NumOfSubBands,
		p_encoder_params->s16NumOfBlocks, p_encoder_params->s16AllocationMethod,
		p_encoder_params->u16BitRate, p_encoder_params->s16SamplingFreq);
		SBC_Encoder_Init(p_encoder_params);
		} else {
		LOG_DEBUG(LOG_TAG, "%s: no SBC reconfig needed", __func__);
		}
		}

		void a2dp_sbc_feeding_reset(void) {
		/* By default, just clear the entire state */
		memset(&a2dp_sbc_encoder_cb.feeding_state, 0,

system/stack/a2dp/a2dp_vendor_aptx.cc

+7 −4

Original line number	Diff line number	Diff line
		@@ -70,10 +70,13 @@ static const tA2DP_APTX_CIE a2dp_aptx_default_config = {
		};

		static const tA2DP_ENCODER_INTERFACE a2dp_encoder_interface_aptx = {
		a2dp_vendor_aptx_encoder_init, a2dp_vendor_aptx_encoder_cleanup,
		a2dp_vendor_aptx_feeding_init, a2dp_vendor_aptx_feeding_reset,
		a2dp_vendor_aptx_feeding_flush, a2dp_vendor_aptx_get_encoder_interval_ms,
		a2dp_vendor_aptx_send_frames, a2dp_vendor_aptx_debug_codec_dump};
		a2dp_vendor_aptx_encoder_init,
		a2dp_vendor_aptx_encoder_cleanup,
		a2dp_vendor_aptx_feeding_reset,
		a2dp_vendor_aptx_feeding_flush,
		a2dp_vendor_aptx_get_encoder_interval_ms,
		a2dp_vendor_aptx_send_frames,
		a2dp_vendor_aptx_debug_codec_dump};

		UNUSED_ATTR static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilityAptx(
		const tA2DP_APTX_CIE* p_cap, const uint8_t* p_codec_info,

system/stack/a2dp/a2dp_vendor_aptx_encoder.cc

+9 −90

Original line number	Diff line number	Diff line
		@@ -206,7 +206,6 @@ void a2dp_vendor_aptx_encoder_init(
		a2dp_vendor_aptx_encoder_update(a2dp_aptx_encoder_cb.peer_mtu,
		a2dp_codec_config, &restart_input,
		&restart_output, &config_updated);
		aptx_init_framing_params(&a2dp_aptx_encoder_cb.framing_params);
		}

		bool A2dpCodecConfigAptx::updateEncoderUserConfig(
		@@ -254,103 +253,23 @@ static void a2dp_vendor_aptx_encoder_update(uint16_t peer_mtu,
		const uint8_t* p_codec_info = codec_info;

		// The feeding parameters
		a2dp_aptx_encoder_cb.feeding_params.sample_rate =
		tA2DP_FEEDING_PARAMS* p_feeding_params = &a2dp_aptx_encoder_cb.feeding_params;
		p_feeding_params->sample_rate =
		A2DP_VendorGetTrackSampleRateAptx(p_codec_info);
		a2dp_aptx_encoder_cb.feeding_params.bits_per_sample =
		p_feeding_params->bits_per_sample =
		A2DP_VendorGetTrackBitsPerSampleAptx(p_codec_info);
		a2dp_aptx_encoder_cb.feeding_params.channel_count =
		p_feeding_params->channel_count =
		A2DP_VendorGetTrackChannelCountAptx(p_codec_info);
		}

		void a2dp_vendor_aptx_encoder_cleanup(void) {
		osi_free(a2dp_aptx_encoder_cb.aptx_encoder_state);
		memset(&a2dp_aptx_encoder_cb, 0, sizeof(a2dp_aptx_encoder_cb));
		}

		void a2dp_vendor_aptx_feeding_init(
		const tA2DP_FEEDING_PARAMS* p_feeding_params) {
		LOG_DEBUG(LOG_TAG,
		"%s: PCM feeding: sample_rate:%d bits_per_sample:%d "
		"channel_count:%d",
		LOG_DEBUG(LOG_TAG, "%s: sample_rate=%u bits_per_sample=%u channel_count=%u",
		__func__, p_feeding_params->sample_rate,
		p_feeding_params->bits_per_sample, p_feeding_params->channel_count);

		// Check the PCM feeding sample_rate
		switch (p_feeding_params->sample_rate) {
		case 44100:
		case 48000:
		break;
		default:
		LOG_WARN(LOG_TAG, "%s: feeding PCM sample_rate %u is not supported",
		__func__, p_feeding_params->sample_rate);
		return;
		}

		// Check the bits per sample
		switch (p_feeding_params->bits_per_sample) {
		case 16:
		break;
		default:
		LOG_WARN(LOG_TAG, "%s: feeding PCM bits_per_sample %u is not supported",
		__func__, p_feeding_params->bits_per_sample);
		return;
		}

		// Check the number of channels
		switch (p_feeding_params->channel_count) {
		case 1: // Mono
		case 2: // Stereo
		break;
		default:
		LOG_WARN(LOG_TAG, "%s: feeding PCM channel_count %u is not supported",
		__func__, p_feeding_params->channel_count);
		return;
		}

		bool reconfig_needed = false;
		if (a2dp_aptx_encoder_cb.feeding_params.sample_rate !=
		p_feeding_params->sample_rate) {
		LOG_DEBUG(LOG_TAG,
		"%s: codec reconfiguration: feeding PCM sample_rate "
		"from %u to %u",
		__func__, a2dp_aptx_encoder_cb.feeding_params.sample_rate,
		p_feeding_params->sample_rate);
		reconfig_needed = true;
		a2dp_aptx_encoder_cb.feeding_params.sample_rate =
		p_feeding_params->sample_rate;
		}
		if (a2dp_aptx_encoder_cb.feeding_params.bits_per_sample !=
		p_feeding_params->bits_per_sample) {
		LOG_DEBUG(LOG_TAG,
		"%s: aptX reconfiguration needed: "
		"feeding PCM bits_per_sample from %u to %u",
		__func__, a2dp_aptx_encoder_cb.feeding_params.bits_per_sample,
		p_feeding_params->bits_per_sample);
		a2dp_aptx_encoder_cb.feeding_params.bits_per_sample =
		p_feeding_params->bits_per_sample;
		reconfig_needed = true;
		}
		if (a2dp_aptx_encoder_cb.feeding_params.channel_count !=
		p_feeding_params->channel_count) {
		LOG_DEBUG(LOG_TAG,
		"%s: aptX reconfiguration needed: "
		"feeding PCM channel_count from %u to %u",
		__func__, a2dp_aptx_encoder_cb.feeding_params.channel_count,
		p_feeding_params->channel_count);
		a2dp_aptx_encoder_cb.feeding_params.channel_count =
		p_feeding_params->channel_count;
		reconfig_needed = true;
		}

		if (reconfig_needed) {
		LOG_DEBUG(LOG_TAG, "%s: sample_rate=%u bits_per_sample=%u channel_count=%u",
		__func__, p_feeding_params->sample_rate,
		p_feeding_params->bits_per_sample,
		p_feeding_params->channel_count);
		aptx_init_framing_params(&a2dp_aptx_encoder_cb.framing_params);
		} else {
		LOG_DEBUG(LOG_TAG, "%s: no aptX reconfiguration needed", __func__);
		}

		void a2dp_vendor_aptx_encoder_cleanup(void) {
		osi_free(a2dp_aptx_encoder_cb.aptx_encoder_state);
		memset(&a2dp_aptx_encoder_cb, 0, sizeof(a2dp_aptx_encoder_cb));
		}

		//

system/stack/a2dp/a2dp_vendor_aptx_hd.cc

+0 −1

Original line number	Diff line number	Diff line
		@@ -79,7 +79,6 @@ static const tA2DP_APTX_HD_CIE a2dp_aptx_hd_default_config = {
		static const tA2DP_ENCODER_INTERFACE a2dp_encoder_interface_aptx_hd = {
		a2dp_vendor_aptx_hd_encoder_init,
		a2dp_vendor_aptx_hd_encoder_cleanup,
		a2dp_vendor_aptx_hd_feeding_init,
		a2dp_vendor_aptx_hd_feeding_reset,
		a2dp_vendor_aptx_hd_feeding_flush,
		a2dp_vendor_aptx_hd_get_encoder_interval_ms,