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

Commit 6701fe04 authored by Henri Chataing's avatar Henri Chataing
Browse files

system/stack: Modify A2dpCodecConfig::setCodecConfig to return tA2DP_STATUS 

The exact status code will be required to respond accurately
to remote AVDTP SetConfiguration requests

Bug: 336232163
Test: m com.android.btservices
Flag: EXEMPT, no logical change
Change-Id: Iddb282d5355be8ab7891bc151edc2cb0e485114d
parent 3bb63109

system/stack/a2dp/a2dp_aac.cc

+9 −4
Original line number Original line Diff line number Diff line
@@ -930,7 +930,8 @@ static bool select_audio_channel_mode(const btav_a2dp_codec_config_t* p_codec_au 
  return false;

  return false;

}

}





bool A2dpCodecConfigAacBase::setCodecConfig(const uint8_t* p_peer_codec_info, bool is_capability,

tA2DP_STATUS A2dpCodecConfigAacBase::setCodecConfig(const uint8_t* p_peer_codec_info,

                                                    bool is_capability,

                                                    uint8_t* p_result_codec_config) {

                                                    uint8_t* p_result_codec_config) {

  std::lock_guard<std::recursive_mutex> lock(codec_mutex_);

  std::lock_guard<std::recursive_mutex> lock(codec_mutex_);

  tA2DP_AAC_CIE peer_info_cie;

  tA2DP_AAC_CIE peer_info_cie;
@@ -1094,6 +1095,7 @@ bool A2dpCodecConfigAacBase::setCodecConfig(const uint8_t* p_peer_codec_info, bo 
            "cannot match sample frequency: source caps = 0x{:x} peer info = "

            "cannot match sample frequency: source caps = 0x{:x} peer info = "

            "0x{:x}",

            "0x{:x}",

            p_a2dp_aac_caps->sampleRate, peer_info_cie.sampleRate);

            p_a2dp_aac_caps->sampleRate, peer_info_cie.sampleRate);

    status = A2DP_NOT_SUPPORTED_SAMPLING_FREQUENCY;

    goto fail;

    goto fail;

  }

  }
@@ -1168,6 +1170,7 @@ bool A2dpCodecConfigAacBase::setCodecConfig(const uint8_t* p_peer_codec_info, bo 
            "cannot match bits per sample: default = 0x{:x} user preference = "

            "cannot match bits per sample: default = 0x{:x} user preference = "

            "0x{:x}",

            "0x{:x}",

            a2dp_aac_default_config.bits_per_sample, codec_user_config_.bits_per_sample);

            a2dp_aac_default_config.bits_per_sample, codec_user_config_.bits_per_sample);

    status = A2DP_NOT_SUPPORTED_BIT_RATE;

    goto fail;

    goto fail;

  }

  }
@@ -1239,6 +1242,7 @@ bool A2dpCodecConfigAacBase::setCodecConfig(const uint8_t* p_peer_codec_info, bo 
  if (codec_config_.channel_mode == BTAV_A2DP_CODEC_CHANNEL_MODE_NONE) {

  if (codec_config_.channel_mode == BTAV_A2DP_CODEC_CHANNEL_MODE_NONE) {

    log::error("cannot match channel mode: source caps = 0x{:x} peer info = 0x{:x}",

    log::error("cannot match channel mode: source caps = 0x{:x} peer info = 0x{:x}",

               p_a2dp_aac_caps->channelMode, peer_info_cie.channelMode);

               p_a2dp_aac_caps->channelMode, peer_info_cie.channelMode);

    status = A2DP_NOT_SUPPORTED_CHANNEL_MODE;

    goto fail;

    goto fail;

  }

  }
@@ -1286,6 +1290,7 @@ bool A2dpCodecConfigAacBase::setCodecConfig(const uint8_t* p_peer_codec_info, bo 
  }

  }





  if (!A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, p_result_codec_config)) {

  if (!A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, p_result_codec_config)) {

    status = AVDTP_UNSUPPORTED_CONFIGURATION;

    goto fail;

    goto fail;

  }

  }
@@ -1302,7 +1307,7 @@ bool A2dpCodecConfigAacBase::setCodecConfig(const uint8_t* p_peer_codec_info, bo 
  }

  }

  log::assert_that(A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, ota_codec_config_),

  log::assert_that(A2DP_BuildInfoAac(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, ota_codec_config_),

                   "Failed to build media codec capabilities");

                   "Failed to build media codec capabilities");

  return true;

  return A2DP_SUCCESS;





fail:

fail:

  // Restore the internal state

  // Restore the internal state
@@ -1315,7 +1320,7 @@ fail: 
  memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability,

  memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability,

         sizeof(ota_codec_peer_capability_));

         sizeof(ota_codec_peer_capability_));

  memcpy(ota_codec_peer_config_, saved_ota_codec_peer_config, sizeof(ota_codec_peer_config_));

  memcpy(ota_codec_peer_config_, saved_ota_codec_peer_config, sizeof(ota_codec_peer_config_));

  return false;

  return status;

}

}





bool A2dpCodecConfigAacBase::setPeerCodecCapabilities(const uint8_t* p_peer_codec_capabilities) {

bool A2dpCodecConfigAacBase::setPeerCodecCapabilities(const uint8_t* p_peer_codec_capabilities) {

system/stack/a2dp/a2dp_codec_config.cc

+6 −4
Original line number Original line Diff line number Diff line
@@ -351,8 +351,8 @@ bool A2dpCodecConfig::setCodecUserConfig(const btav_a2dp_codec_config_t& codec_u 
  codec_user_config_ = codec_user_config;

  codec_user_config_ = codec_user_config;

  btav_a2dp_codec_config_t saved_codec_audio_config = codec_audio_config_;

  btav_a2dp_codec_config_t saved_codec_audio_config = codec_audio_config_;

  codec_audio_config_ = codec_audio_config;

  codec_audio_config_ = codec_audio_config;

  bool success = setCodecConfig(p_peer_codec_info, is_capability, p_result_codec_config);

  auto status = setCodecConfig(p_peer_codec_info, is_capability, p_result_codec_config);

  if (!success) {

  if (status != A2DP_SUCCESS) {

    // Restore the local copy of the user and audio config

    // Restore the local copy of the user and audio config

    codec_user_config_ = saved_codec_user_config;

    codec_user_config_ = saved_codec_user_config;

    codec_audio_config_ = saved_codec_audio_config;

    codec_audio_config_ = saved_codec_audio_config;
@@ -723,7 +723,8 @@ bool A2dpCodecs::setCodecConfig(const uint8_t* p_peer_codec_info, bool is_capabi 
  if (a2dp_codec_config == nullptr) {

  if (a2dp_codec_config == nullptr) {

    return false;

    return false;

  }

  }

  if (!a2dp_codec_config->setCodecConfig(p_peer_codec_info, is_capability, p_result_codec_config)) {

  if (a2dp_codec_config->setCodecConfig(p_peer_codec_info, is_capability, p_result_codec_config) !=

      A2DP_SUCCESS) {

    return false;

    return false;

  }

  }

  if (select_current_codec) {

  if (select_current_codec) {
@@ -739,7 +740,8 @@ bool A2dpCodecs::setSinkCodecConfig(const uint8_t* p_peer_codec_info, bool is_ca 
  if (a2dp_codec_config == nullptr) {

  if (a2dp_codec_config == nullptr) {

    return false;

    return false;

  }

  }

  if (!a2dp_codec_config->setCodecConfig(p_peer_codec_info, is_capability, p_result_codec_config)) {

  if (a2dp_codec_config->setCodecConfig(p_peer_codec_info, is_capability, p_result_codec_config) !=

      A2DP_SUCCESS) {

    return false;

    return false;

  }

  }

  if (select_current_codec) {

  if (select_current_codec) {

system/stack/a2dp/a2dp_ext.cc

+5 −4
Original line number Original line Diff line number Diff line
@@ -44,7 +44,8 @@ A2dpCodecConfigExt::A2dpCodecConfigExt(btav_a2dp_codec_index_t codec_index, bool 
  codec_selectable_capability_ = codec_capability_;

  codec_selectable_capability_ = codec_capability_;

}

}





bool A2dpCodecConfigExt::setCodecConfig(const uint8_t* p_peer_codec_info, bool is_capability,

tA2DP_STATUS A2dpCodecConfigExt::setCodecConfig(const uint8_t* p_peer_codec_info,

                                                bool is_capability,

                                                uint8_t* p_result_codec_config) {

                                                uint8_t* p_result_codec_config) {

  // Call get_a2dp_config to recompute best capabilities.

  // Call get_a2dp_config to recompute best capabilities.

  // This method need to update codec_capability_, codec_config_,

  // This method need to update codec_capability_, codec_config_,
@@ -61,14 +62,14 @@ bool A2dpCodecConfigExt::setCodecConfig(const uint8_t* p_peer_codec_info, bool i 
          codec_user_config_);

          codec_user_config_);

  if (!result.has_value()) {

  if (!result.has_value()) {

    log::error("Failed to set a configuration for {}", name_);

    log::error("Failed to set a configuration for {}", name_);

    return false;

    return AVDTP_UNSUPPORTED_CONFIGURATION;

  }

  }





  memcpy(ota_codec_config_, result->codec_config, sizeof(ota_codec_config_));

  memcpy(ota_codec_config_, result->codec_config, sizeof(ota_codec_config_));

  codec_config_ = result->codec_parameters;

  codec_config_ = result->codec_parameters;

  codec_capability_ = result->codec_parameters;

  codec_capability_ = result->codec_parameters;

  vendor_specific_parameters_ = result->vendor_specific_parameters;

  vendor_specific_parameters_ = result->vendor_specific_parameters;

  return true;

  return A2DP_SUCCESS;

}

}





bool A2dpCodecConfigExt::setPeerCodecCapabilities(const uint8_t* p_peer_codec_capabilities) {

bool A2dpCodecConfigExt::setPeerCodecCapabilities(const uint8_t* p_peer_codec_capabilities) {

system/stack/a2dp/a2dp_sbc.cc

+5 −4
Original line number Original line Diff line number Diff line
@@ -966,7 +966,8 @@ static bool select_audio_channel_mode(const btav_a2dp_codec_config_t* p_codec_au 
  return false;

  return false;

}

}





bool A2dpCodecConfigSbcBase::setCodecConfig(const uint8_t* p_peer_codec_info, bool is_capability,

tA2DP_STATUS A2dpCodecConfigSbcBase::setCodecConfig(const uint8_t* p_peer_codec_info,

                                                    bool is_capability,

                                                    uint8_t* p_result_codec_config) {

                                                    uint8_t* p_result_codec_config) {

  std::lock_guard<std::recursive_mutex> lock(codec_mutex_);

  std::lock_guard<std::recursive_mutex> lock(codec_mutex_);

  tA2DP_SBC_CIE peer_info_cie;

  tA2DP_SBC_CIE peer_info_cie;
@@ -1342,7 +1343,7 @@ bool A2dpCodecConfigSbcBase::setCodecConfig(const uint8_t* p_peer_codec_info, bo 
  }

  }

  log::assert_that(A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, ota_codec_config_),

  log::assert_that(A2DP_BuildInfoSbc(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, ota_codec_config_),

                   "Failed to build media codec capabilities");

                   "Failed to build media codec capabilities");

  return true;

  return A2DP_SUCCESS;





fail:

fail:

  // Restore the internal state

  // Restore the internal state
@@ -1355,7 +1356,7 @@ fail: 
  memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability,

  memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability,

         sizeof(ota_codec_peer_capability_));

         sizeof(ota_codec_peer_capability_));

  memcpy(ota_codec_peer_config_, saved_ota_codec_peer_config, sizeof(ota_codec_peer_config_));

  memcpy(ota_codec_peer_config_, saved_ota_codec_peer_config, sizeof(ota_codec_peer_config_));

  return false;

  return status;

}

}





bool A2dpCodecConfigSbcBase::setPeerCodecCapabilities(const uint8_t* p_peer_codec_capabilities) {

bool A2dpCodecConfigSbcBase::setPeerCodecCapabilities(const uint8_t* p_peer_codec_capabilities) {

system/stack/a2dp/a2dp_vendor_aptx.cc

+9 −4
Original line number Original line Diff line number Diff line
@@ -531,7 +531,8 @@ static bool select_audio_channel_mode(const btav_a2dp_codec_config_t* p_codec_au 
  return false;

  return false;

}

}





bool A2dpCodecConfigAptx::setCodecConfig(const uint8_t* p_peer_codec_info, bool is_capability,

tA2DP_STATUS A2dpCodecConfigAptx::setCodecConfig(const uint8_t* p_peer_codec_info,

                                                 bool is_capability,

                                                 uint8_t* p_result_codec_config) {

                                                 uint8_t* p_result_codec_config) {

  std::lock_guard<std::recursive_mutex> lock(codec_mutex_);

  std::lock_guard<std::recursive_mutex> lock(codec_mutex_);

  tA2DP_APTX_CIE peer_info_cie;

  tA2DP_APTX_CIE peer_info_cie;
@@ -643,6 +644,7 @@ bool A2dpCodecConfigAptx::setCodecConfig(const uint8_t* p_peer_codec_info, bool 
  if (codec_config_.sample_rate == BTAV_A2DP_CODEC_SAMPLE_RATE_NONE) {

  if (codec_config_.sample_rate == BTAV_A2DP_CODEC_SAMPLE_RATE_NONE) {

    log::error("cannot match sample frequency: local caps = 0x{:x} peer info = 0x{:x}",

    log::error("cannot match sample frequency: local caps = 0x{:x} peer info = 0x{:x}",

               a2dp_aptx_source_caps.sampleRate, peer_info_cie.sampleRate);

               a2dp_aptx_source_caps.sampleRate, peer_info_cie.sampleRate);

    status = A2DP_NOT_SUPPORTED_SAMPLING_FREQUENCY;

    goto fail;

    goto fail;

  }

  }
@@ -696,6 +698,7 @@ bool A2dpCodecConfigAptx::setCodecConfig(const uint8_t* p_peer_codec_info, bool 
  if (codec_config_.bits_per_sample == BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE) {

  if (codec_config_.bits_per_sample == BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE) {

    log::error("cannot match bits per sample: user preference = 0x{:x}",

    log::error("cannot match bits per sample: user preference = 0x{:x}",

               codec_user_config_.bits_per_sample);

               codec_user_config_.bits_per_sample);

    status = A2DP_NOT_SUPPORTED_BIT_RATE;

    goto fail;

    goto fail;

  }

  }
@@ -767,6 +770,7 @@ bool A2dpCodecConfigAptx::setCodecConfig(const uint8_t* p_peer_codec_info, bool 
  if (codec_config_.channel_mode == BTAV_A2DP_CODEC_CHANNEL_MODE_NONE) {

  if (codec_config_.channel_mode == BTAV_A2DP_CODEC_CHANNEL_MODE_NONE) {

    log::error("cannot match channel mode: local caps = 0x{:x} peer info = 0x{:x}",

    log::error("cannot match channel mode: local caps = 0x{:x} peer info = 0x{:x}",

               a2dp_aptx_source_caps.channelMode, peer_info_cie.channelMode);

               a2dp_aptx_source_caps.channelMode, peer_info_cie.channelMode);

    status = A2DP_NOT_SUPPORTED_CHANNEL_MODE;

    goto fail;

    goto fail;

  }

  }
@@ -777,6 +781,7 @@ bool A2dpCodecConfigAptx::setCodecConfig(const uint8_t* p_peer_codec_info, bool 
  result_config_cie.future2 = a2dp_aptx_source_caps.future2 & peer_info_cie.future2;

  result_config_cie.future2 = a2dp_aptx_source_caps.future2 & peer_info_cie.future2;





  if (!A2DP_BuildInfoAptx(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, p_result_codec_config)) {

  if (!A2DP_BuildInfoAptx(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, p_result_codec_config)) {

    status = AVDTP_UNSUPPORTED_CONFIGURATION;

    goto fail;

    goto fail;

  }

  }
@@ -810,7 +815,7 @@ bool A2dpCodecConfigAptx::setCodecConfig(const uint8_t* p_peer_codec_info, bool 
  log::assert_that(A2DP_BuildInfoAptx(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, ota_codec_config_),

  log::assert_that(A2DP_BuildInfoAptx(AVDT_MEDIA_TYPE_AUDIO, &result_config_cie, ota_codec_config_),

                   "Failed to build media codec capabilities");

                   "Failed to build media codec capabilities");





  return true;

  return A2DP_SUCCESS;





fail:

fail:

  // Restore the internal state

  // Restore the internal state
@@ -823,7 +828,7 @@ fail: 
  memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability,

  memcpy(ota_codec_peer_capability_, saved_ota_codec_peer_capability,

         sizeof(ota_codec_peer_capability_));

         sizeof(ota_codec_peer_capability_));

  memcpy(ota_codec_peer_config_, saved_ota_codec_peer_config, sizeof(ota_codec_peer_config_));

  memcpy(ota_codec_peer_config_, saved_ota_codec_peer_config, sizeof(ota_codec_peer_config_));

  return false;

  return status;

}

}





bool A2dpCodecConfigAptx::setPeerCodecCapabilities(const uint8_t* p_peer_codec_capabilities) {

bool A2dpCodecConfigAptx::setPeerCodecCapabilities(const uint8_t* p_peer_codec_capabilities) {