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

Commit 3e6ec10a authored by Pavlin Radoslavov's avatar Pavlin Radoslavov
Browse files

Removed the feeding_init call from tA2DP_ENCODER_INTERFACE 

The feeding_init call is not used anymore - it has been superseded
by the newer A2dpCodecs.setCodecAudioConfig() mechanism.

Also, moved aptx_init_framing_params() and aptx_hd_init_framing_params()
calls to the corresponding encoder_update functions.

Test: A2DP streaming to Bluetooth headsets
Change-Id: I52f42b4701d04fe2ddb8f115bb9cd57fe38e2b38
parent b72cdd60

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,