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

Commit be4b9e52 authored by Łukasz Rymanowski's avatar Łukasz Rymanowski
Browse files

leaudio: Return early if there is no updated context 

This patch, also does minor changes around logs moving it to gd style

Bug: 232898053
Test: atest BluetoothInstrumentationTests
Test: atest bluetooth_le_audio_test bluetooth_le_audio_client_test
Change-Id: I1f3645a82fa2df1276cb1a53d2794dc793678d1a
parent b9581da9

system/bta/le_audio/devices.cc

+52 −40
Original line number Diff line number Diff line
@@ -548,8 +548,8 @@ uint16_t LeAudioDeviceGroup::GetRemoteDelay(uint8_t direction) { 


/* This method returns AudioContext value if support for any type has changed */

std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap(void) {

  DLOG(INFO) << __func__ << " group id: " << group_id_ << " active contexts: "

             << loghex(active_contexts_mask_.to_ulong());

  LOG_DEBUG(" group id: %d, active contexts: 0x%04lx", group_id_,

            active_contexts_mask_.to_ulong());

  return UpdateActiveContextsMap(active_contexts_mask_);

}
@@ -559,10 +559,19 @@ std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap( 
  AudioContexts contexts = 0x0000;

  bool active_contexts_has_been_modified = false;



  if (update_contexts.none()) {

    LOG_DEBUG("No context updated");

    return contexts;

  }



  for (LeAudioContextType ctx_type : types::kLeAudioContextAllTypesArray) {

    AudioContexts type_set = static_cast<uint16_t>(ctx_type);



    LOG_DEBUG("Taking context: %s, 0x%04lx",

              bluetooth::common::ToString(ctx_type).c_str(),

              update_contexts.to_ulong());

    if ((type_set & update_contexts).none()) {

      LOG_INFO("Configuration not in updated context %s",

               bluetooth::common::ToString(ctx_type).c_str());

      /* Fill context bitset for possible returned value if updated */

      if (active_context_to_configuration_map.count(ctx_type) > 0)

        contexts |= type_set;
@@ -572,9 +581,11 @@ std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap( 


    auto new_conf = FindFirstSupportedConfiguration(ctx_type);



    bool ctx_previously_not_supported =

        (active_context_to_configuration_map.count(ctx_type) == 0 ||

         active_context_to_configuration_map[ctx_type] == nullptr);

    /* Check if support for context type has changed */

    if (active_context_to_configuration_map.count(ctx_type) == 0 ||

        active_context_to_configuration_map[ctx_type] == nullptr) {

    if (ctx_previously_not_supported) {

      /* Current configuration for context type is empty */

      if (new_conf == nullptr) {

        /* Configuration remains empty */
@@ -601,12 +612,14 @@ std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap( 
      }

    }



    LOG(INFO) << __func__ << ", updated context: " << loghex(int(ctx_type))

              << ", "

              << (active_context_to_configuration_map[ctx_type] != nullptr

                      ? active_context_to_configuration_map[ctx_type]->name

                      : "empty")

              << " -> " << (new_conf != nullptr ? new_conf->name : "empty");

    LOG_INFO(

        "updated context: %s, %s -> %s",

        bluetooth::common::ToString(ctx_type).c_str(),

        (ctx_previously_not_supported

             ? "empty"

             : active_context_to_configuration_map[ctx_type]->name.c_str()),

        (new_conf != nullptr ? new_conf->name.c_str() : "empty"));



    active_context_to_configuration_map[ctx_type] = new_conf;

  }
@@ -741,10 +754,9 @@ bool LeAudioDeviceGroup::IsConfigurationSupported( 
    types::LeAudioContextType context_type) {

  if (!set_configurations::check_if_may_cover_scenario(

          audio_set_conf, NumOfConnected(context_type))) {

    DLOG(INFO) << __func__ << " cannot cover scenario "

               << static_cast<int>(context_type)

               << " size of for context type: "

               << +NumOfConnected(context_type);

    LOG_DEBUG(" cannot cover scenario  %s: size of for context type %d",

              bluetooth::common::ToString(context_type).c_str(),

              +NumOfConnected(context_type));

    return false;

  }
@@ -756,11 +768,9 @@ bool LeAudioDeviceGroup::IsConfigurationSupported( 
   * 3) ASEs should be filled according to performance profile.

   */

  for (const auto& ent : (*audio_set_conf).confs) {

    DLOG(INFO) << __func__

               << " Looking for configuration: " << audio_set_conf->name

               << " - "

               << (ent.direction == types::kLeAudioDirectionSink ? "snk"

                                                                 : "src");

    LOG_DEBUG(" Looking for configuration: %s - %s",

              audio_set_conf->name.c_str(),

              (ent.direction == types::kLeAudioDirectionSink ? "snk" : "src"));



    uint8_t required_device_cnt = ent.device_cnt;

    uint8_t max_required_ase_per_dev =
@@ -768,10 +778,11 @@ bool LeAudioDeviceGroup::IsConfigurationSupported( 
    uint8_t active_ase_num = 0;

    auto strategy = ent.strategy;



    DLOG(INFO) << __func__ << " Number of devices: " << +required_device_cnt

               << " number of ASEs: " << +ent.ase_cnt

               << " Max ASE per device: " << +max_required_ase_per_dev

               << " strategy: " << static_cast<int>(strategy);

    LOG_DEBUG(

        " Number of devices: %d, number of ASEs: %d,  Max ASE per device: %d "

        "strategy: %d",

        +required_device_cnt, +ent.ase_cnt, +max_required_ase_per_dev,

        static_cast<int>(strategy));



    for (auto* device = GetFirstDeviceWithActiveContext(context_type);

         device != nullptr && required_device_cnt > 0;
@@ -803,8 +814,8 @@ bool LeAudioDeviceGroup::IsConfigurationSupported( 
              strategy, audio_locations,

              std::get<LeAudioLc3Config>(ent.codec.config).GetChannelCount(),

              device->GetLc3SupportedChannelCount(ent.direction))) {

        DLOG(INFO) << __func__ << " insufficient device audio allocation: "

                   << audio_locations;

        LOG_DEBUG(" insufficient device audio allocation: %lu",

                  audio_locations.to_ulong());

        continue;

      }
@@ -822,13 +833,13 @@ bool LeAudioDeviceGroup::IsConfigurationSupported( 


    if (required_device_cnt > 0) {

      /* Don't left any active devices if requirements are not met */

      DLOG(INFO) << __func__ << " could not configure all the devices";

      LOG_DEBUG(" could not configure all the devices");

      return false;

    }

  }



  DLOG(INFO) << "Choosed ASE Configuration for group: " << this->group_id_

             << " configuration: " << audio_set_conf->name;

  LOG_DEBUG("Chosen ASE Configuration for group: %d, configuration: %s",

            this->group_id_, audio_set_conf->name.c_str());

  return true;

}
@@ -1202,13 +1213,14 @@ LeAudioDeviceGroup::FindFirstSupportedConfiguration( 
  const set_configurations::AudioSetConfigurations* confs =

      AudioSetConfigurationProvider::Get()->GetConfigurations(context_type);



  DLOG(INFO) << __func__ << " context type: " << (int)context_type

             << " number of connected devices: " << NumOfConnected();

  LOG_DEBUG("context type: %s,  number of connected devices: %d",

            bluetooth::common::ToString(context_type).c_str(),

            +NumOfConnected());



  /* Filter out device set for all scenarios */

  if (!set_configurations::check_if_may_cover_scenario(confs,

                                                       NumOfConnected())) {

    LOG(ERROR) << __func__ << ", group is unable to cover scenario";

    LOG_ERROR(", group is unable to cover scenario");

    return nullptr;

  }
@@ -1216,7 +1228,7 @@ LeAudioDeviceGroup::FindFirstSupportedConfiguration( 


  for (const auto& conf : *confs) {

    if (IsConfigurationSupported(conf, context_type)) {

      DLOG(INFO) << __func__ << " found: " << conf->name;

      LOG_DEBUG("found: %s", conf->name.c_str());

      return conf;

    }

  }
@@ -1653,7 +1665,7 @@ LeAudioDevice::GetCodecConfigurationSupportedPac( 
      direction == types::kLeAudioDirectionSink ? snk_pacs_ : src_pacs_;



  if (pacs.size() == 0) {

    LOG(ERROR) << __func__ << " missing PAC for direction " << +direction;

    LOG_ERROR("missing PAC for direction %d", direction);

    return nullptr;

  }
@@ -1735,12 +1747,12 @@ AudioContexts LeAudioDevice::SetAvailableContexts(AudioContexts snk_contexts, 
  updated_contexts = snk_contexts ^ avail_snk_contexts_;

  updated_contexts |= src_contexts ^ avail_src_contexts_;



  DLOG(INFO) << __func__

             << "\n\t avail_snk_contexts_: " << avail_snk_contexts_.to_string()

             << "\n\t avail_src_contexts_: " << avail_src_contexts_.to_string()

             << "\n\t snk_contexts:" << snk_contexts.to_string()

             << "\n\t src_contexts: " << src_contexts.to_string()

             << "\n\t updated_contexts: " << updated_contexts.to_string();

  LOG_DEBUG(

      "\n\t avail_snk_contexts_: %s \n\t avail_src_contexts_: %s  \n\t "

      "snk_contexts: %s \n\t src_contexts: %s \n\t updated_contexts: %s",

      avail_snk_contexts_.to_string().c_str(),

      avail_src_contexts_.to_string().c_str(), snk_contexts.to_string().c_str(),

      src_contexts.to_string().c_str(), updated_contexts.to_string().c_str());



  avail_snk_contexts_ = snk_contexts;

  avail_src_contexts_ = src_contexts;

system/bta/le_audio/le_audio_types.cc

+41 −34
Original line number Diff line number Diff line
@@ -104,27 +104,33 @@ static bool IsCodecConfigurationSupported(const types::LeAudioLtvMap& pacs, 
  auto req = reqs.Find(codec_spec_conf::kLeAudioCodecLC3TypeSamplingFreq);

  auto pac = pacs.Find(codec_spec_caps::kLeAudioCodecLC3TypeSamplingFreq);

  if (!req || !pac) {

    DLOG(ERROR) << __func__ << ", lack of sampling frequency fields";

    LOG_DEBUG(", lack of sampling frequency fields");

    return false;

  }



  u8_req_val = VEC_UINT8_TO_UINT8(req.value());

  u16_pac_val = VEC_UINT8_TO_UINT16(pac.value());



  /* TODO: Integrate with codec capabilities */

  if (!(u16_pac_val &

        codec_spec_caps::SamplingFreqConfig2Capability(u8_req_val))) {

    /*

     * Note: Requirements are in the codec configuration specification which

   * are values coming from BAP Appendix A1.2.1

     * are values coming from Assigned Numbers: Codec_Specific_Configuration

     */

  DLOG(INFO) << __func__ << " Req:SamplFreq=" << loghex(u8_req_val);

  /* NOTE: Below is Codec specific cababilities comes form BAP Appendix A A1.1.1

   * Note this is a bitfield

    LOG_DEBUG(

        " Req:SamplFreq= 0x%04x (Assigned Numbers: "

        "Codec_Specific_Configuration)",

        u8_req_val);

    /* NOTE: Below is Codec specific cababilities comes from Assigned Numbers:

     * Codec_Specific_Capabilities

     */

  DLOG(INFO) << __func__ << " Pac:SamplFreq=" << loghex(u16_pac_val);

    LOG_DEBUG(

        " Pac:SamplFreq= 0x%04x  (Assigned numbers: "

        "Codec_Specific_Capabilities - bitfield)",

        u16_pac_val);



  /* TODO: Integrate with codec capabilities */

  if (!(u16_pac_val &

        codec_spec_caps::SamplingFreqConfig2Capability(u8_req_val))) {

    DLOG(ERROR) << __func__ << ", sampling frequency not supported";

    LOG_DEBUG(", sampling frequency not supported");

    return false;

  }
@@ -132,20 +138,20 @@ static bool IsCodecConfigurationSupported(const types::LeAudioLtvMap& pacs, 
  req = reqs.Find(codec_spec_conf::kLeAudioCodecLC3TypeFrameDuration);

  pac = pacs.Find(codec_spec_caps::kLeAudioCodecLC3TypeFrameDuration);

  if (!req || !pac) {

    DLOG(ERROR) << __func__ << ", lack of frame duration fields";

    LOG_DEBUG(", lack of frame duration fields");

    return false;

  }



  u8_req_val = VEC_UINT8_TO_UINT8(req.value());

  u8_pac_val = VEC_UINT8_TO_UINT8(pac.value());

  DLOG(INFO) << __func__ << " Req:FrameDur=" << loghex(u8_req_val);

  DLOG(INFO) << __func__ << " Pac:FrameDur=" << loghex(u8_pac_val);



  if ((u8_req_val != codec_spec_conf::kLeAudioCodecLC3FrameDur7500us &&

       u8_req_val != codec_spec_conf::kLeAudioCodecLC3FrameDur10000us) ||

      !(u8_pac_val &

        (codec_spec_caps::FrameDurationConfig2Capability(u8_req_val)))) {

    DLOG(ERROR) << __func__ << ", frame duration not supported";

    LOG_DEBUG(" Req:FrameDur=0x%04x", u8_req_val);

    LOG_DEBUG(" Pac:FrameDur=0x%04x", u8_pac_val);

    LOG_DEBUG(", frame duration not supported");

    return false;

  }
@@ -162,15 +168,16 @@ static bool IsCodecConfigurationSupported(const types::LeAudioLtvMap& pacs, 
   * the Unicast Server supports mandatory one channel.

   */

  if (!pac) {

    DLOG(WARNING) << __func__ << ", no Audio_Channel_Counts field in PAC";

    LOG_DEBUG(", no Audio_Channel_Counts field in PAC, using default 0x01");

    u8_pac_val = 0x01;

  } else {

    u8_pac_val = VEC_UINT8_TO_UINT8(pac.value());

  }



  DLOG(INFO) << __func__ << " Pac:AudioChanCnt=" << loghex(u8_pac_val);

  if (!((1 << (required_audio_chan_num - 1)) & u8_pac_val)) {

    DLOG(ERROR) << __func__ << ", channel count warning";

    LOG_DEBUG(" Req:AudioChanCnt=0x%04x", 1 << (required_audio_chan_num - 1));

    LOG_DEBUG(" Pac:AudioChanCnt=0x%04x", u8_pac_val);

    LOG_DEBUG(", channel count warning");

    return false;

  }
@@ -179,26 +186,26 @@ static bool IsCodecConfigurationSupported(const types::LeAudioLtvMap& pacs, 
  pac = pacs.Find(codec_spec_caps::kLeAudioCodecLC3TypeOctetPerFrame);



  if (!req || !pac) {

    DLOG(ERROR) << __func__ << ", lack of octet per frame fields";

    LOG_DEBUG(", lack of octet per frame fields");

    return false;

  }



  u16_req_val = VEC_UINT8_TO_UINT16(req.value());

  DLOG(INFO) << __func__ << " Req:OctetsPerFrame=" << int(u16_req_val);



  /* Minimal value 0-1 byte */

  u16_pac_val = VEC_UINT8_TO_UINT16(pac.value());

  DLOG(INFO) << __func__ << " Pac:MinOctetsPerFrame=" << int(u16_pac_val);

  if (u16_req_val < u16_pac_val) {

    DLOG(ERROR) << __func__ << ", octet per frame below minimum";

    LOG_DEBUG(" Req:OctetsPerFrame=%d", int(u16_req_val));

    LOG_DEBUG(" Pac:MinOctetsPerFrame=%d", int(u16_pac_val));

    LOG_DEBUG(", octet per frame below minimum");

    return false;

  }



  /* Maximal value 2-3 byte */

  u16_pac_val = OFF_VEC_UINT8_TO_UINT16(pac.value(), 2);

  DLOG(INFO) << __func__ << " Pac:MaxOctetsPerFrame=" << int(u16_pac_val);

  if (u16_req_val > u16_pac_val) {

    DLOG(ERROR) << __func__ << ", octet per frame above maximum";

    LOG_DEBUG(" Req:MaxOctetsPerFrame=%d", int(u16_req_val));

    LOG_DEBUG(" Pac:MaxOctetsPerFrame=%d", int(u16_pac_val));

    LOG_DEBUG(", octet per frame above maximum");

    return false;

  }
@@ -212,7 +219,7 @@ bool IsCodecCapabilitySettingSupported( 


  if (codec_id != pac.codec_id) return false;



  DLOG(INFO) << __func__ << ": Settings for format " << +codec_id.coding_format;

  LOG_DEBUG(": Settings for format: 0x%02x ", codec_id.coding_format);



  switch (codec_id.coding_format) {

    case kLeAudioCodingFormatLC3:
@@ -229,7 +236,7 @@ uint32_t CodecCapabilitySetting::GetConfigSamplingFrequency() const { 
    case kLeAudioCodingFormatLC3:

      return std::get<types::LeAudioLc3Config>(config).GetSamplingFrequencyHz();

    default:

      DLOG(WARNING) << __func__ << ", invalid codec id";

      LOG_WARN(", invalid codec id: 0x%02x", id.coding_format);

      return 0;

  }

};
@@ -239,7 +246,7 @@ uint32_t CodecCapabilitySetting::GetConfigDataIntervalUs() const { 
    case kLeAudioCodingFormatLC3:

      return std::get<types::LeAudioLc3Config>(config).GetFrameDurationUs();

    default:

      DLOG(WARNING) << __func__ << ", invalid codec id";

      LOG_WARN(", invalid codec id: 0x%02x", id.coding_format);

      return 0;

  }

};
@@ -250,7 +257,7 @@ uint8_t CodecCapabilitySetting::GetConfigBitsPerSample() const { 
      /* XXX LC3 supports 16, 24, 32 */

      return 16;

    default:

      DLOG(WARNING) << __func__ << ", invalid codec id";

      LOG_WARN(", invalid codec id: 0x%02x", id.coding_format);

      return 0;

  }

};
@@ -258,12 +265,12 @@ uint8_t CodecCapabilitySetting::GetConfigBitsPerSample() const { 
uint8_t CodecCapabilitySetting::GetConfigChannelCount() const {

  switch (id.coding_format) {

    case kLeAudioCodingFormatLC3:

      DLOG(INFO) << __func__ << ", count = "

                 << static_cast<int>(std::get<types::LeAudioLc3Config>(config)

                                         .channel_count);

      LOG_DEBUG("count = %d",

                static_cast<int>(

                    std::get<types::LeAudioLc3Config>(config).channel_count));

      return std::get<types::LeAudioLc3Config>(config).channel_count;

    default:

      DLOG(WARNING) << __func__ << ", invalid codec id";

      LOG_WARN(", invalid codec id: 0x%02x", id.coding_format);

      return 0;

  }

}