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

Commit 9eb3b6de authored by Jakub Tyszkowski's avatar Jakub Tyszkowski Committed by Łukasz Rymanowski
Browse files

LeAudio: Use LTV map in CodecConfigSetting and ase struct 

This is required to support non-generic, vendor codec parameters.

Bug: 295972694
Test: atest --host bluetooth_le_audio_test bluetooth_le_audio_client_test bluetooth_test_broadcaster bluetooth_test_broadcaster_state_machine bluetooth_le_audio_codec_manager_test
Change-Id: Id53618053205fa39f94e76883d77a397c61b18cd
parent f900cb78

system/audio_hal_interface/aidl/le_audio_software_aidl.cc

+39 −22
Original line number Diff line number Diff line
@@ -492,22 +492,31 @@ bool hal_ucast_capability_to_stack_format( 
          octets_per_frame_map.end() ||

      audio_location_map.find(supported_channel) == audio_location_map.end()) {

    LOG(ERROR) << __func__ << ": Failed to convert HAL format to stack format"

               << "\nsample rate = " << sample_rate_hz

               << "\nframe duration = " << frame_duration_us

               << "\nsample rate hz = " << sample_rate_hz

               << "\nframe duration us = " << frame_duration_us

               << "\noctets per frame= " << octets_per_frame

               << "\naudio location = " << toString(supported_channel);

               << "\nsupported channel = " << toString(supported_channel)

               << "\nchannel count per device = " << channel_count

               << "\ndevice count = " << hal_capability.deviceCount;



    return false;

  }



  stack_capability = {

      .id = ::le_audio::set_configurations::LeAudioCodecIdLc3,

      .config = LeAudioCoreCodecConfig(

          {.sampling_frequency = sampling_freq_map[sample_rate_hz],

           .frame_duration = frame_duration_map[frame_duration_us],

           .audio_channel_allocation = audio_location_map[supported_channel],

           .octets_per_codec_frame = octets_per_frame_map[octets_per_frame],

           .channel_count = static_cast<uint8_t>(channel_count)})};

  stack_capability.id = ::le_audio::set_configurations::LeAudioCodecIdLc3;

  stack_capability.channel_count_per_iso_stream = channel_count;



  stack_capability.params.Add(

      ::le_audio::codec_spec_conf::kLeAudioLtvTypeSamplingFreq,

      sampling_freq_map[sample_rate_hz]);

  stack_capability.params.Add(

      ::le_audio::codec_spec_conf::kLeAudioLtvTypeFrameDuration,

      frame_duration_map[frame_duration_us]);

  stack_capability.params.Add(

      ::le_audio::codec_spec_conf::kLeAudioLtvTypeAudioChannelAllocation,

      audio_location_map[supported_channel]);

  stack_capability.params.Add(

      ::le_audio::codec_spec_conf::kLeAudioLtvTypeOctetsPerCodecFrame,

      octets_per_frame_map[octets_per_frame]);

  return true;

}
@@ -546,22 +555,30 @@ bool hal_bcast_capability_to_stack_format( 
      audio_location_map.find(supported_channel) == audio_location_map.end()) {

    LOG(WARNING) << __func__

                 << " : Failed to convert HAL format to stack format"

                 << "\nsample rate = " << sample_rate_hz

                 << "\nframe duration = " << frame_duration_us

                 << "\nsample rate hz = " << sample_rate_hz

                 << "\nframe duration us = " << frame_duration_us

                 << "\noctets per frame= " << octets_per_frame

                 << "\naudio location = " << toString(supported_channel);

                 << "\nsupported channel = " << toString(supported_channel)

                 << "\nchannel count per stream = " << channel_count;



    return false;

  }



  stack_capability = {

      .id = ::le_audio::set_configurations::LeAudioCodecIdLc3,

      .config = LeAudioCoreCodecConfig(

          {.sampling_frequency = sampling_freq_map[sample_rate_hz],

           .frame_duration = frame_duration_map[frame_duration_us],

           .audio_channel_allocation = audio_location_map[supported_channel],

           .octets_per_codec_frame = octets_per_frame_map[octets_per_frame],

           .channel_count = static_cast<uint8_t>(channel_count)})};

  stack_capability.id = ::le_audio::set_configurations::LeAudioCodecIdLc3;

  stack_capability.channel_count_per_iso_stream = channel_count;



  stack_capability.params.Add(

      ::le_audio::codec_spec_conf::kLeAudioLtvTypeSamplingFreq,

      sampling_freq_map[sample_rate_hz]);

  stack_capability.params.Add(

      ::le_audio::codec_spec_conf::kLeAudioLtvTypeFrameDuration,

      frame_duration_map[frame_duration_us]);

  stack_capability.params.Add(

      ::le_audio::codec_spec_conf::kLeAudioLtvTypeAudioChannelAllocation,

      audio_location_map[supported_channel]);

  stack_capability.params.Add(

      ::le_audio::codec_spec_conf::kLeAudioLtvTypeOctetsPerCodecFrame,

      octets_per_frame_map[octets_per_frame]);

  return true;

}

system/bta/le_audio/codec_manager.cc

+10 −7
Original line number Diff line number Diff line
@@ -188,10 +188,12 @@ struct codec_manager_impl { 
        continue;

      }

      auto& adsp_config = adsp_audio_set_conf.confs[0];



      const types::LeAudioCoreCodecConfig core_config =

          std::get<types::LeAudioCoreCodecConfig>(adsp_config.codec.config);

          adsp_config.codec.params.GetAsCoreCodecConfig();

      le_audio::broadcast_offload_config broadcast_config;

      broadcast_config.stream_map.resize(core_config.channel_count);

      broadcast_config.stream_map.resize(

          core_config.GetChannelCountPerIsoStream());

      broadcast_config.bits_per_sample =

          LeAudioCodecConfiguration::kBitsPerSample16;

      broadcast_config.sampling_rate = core_config.GetSamplingFrequencyHz();
@@ -385,22 +387,23 @@ struct codec_manager_impl { 
  }



  bool IsLc3ConfigMatched(

      const set_configurations::CodecConfigSetting& adsp_config,

      const set_configurations::CodecConfigSetting& target_config) {

      const set_configurations::CodecConfigSetting& target_config,

      const set_configurations::CodecConfigSetting& adsp_config) {

    if (adsp_config.id.coding_format != types::kLeAudioCodingFormatLC3 ||

        target_config.id.coding_format != types::kLeAudioCodingFormatLC3) {

      return false;

    }



    const types::LeAudioCoreCodecConfig adsp_lc3_config =

        std::get<types::LeAudioCoreCodecConfig>(adsp_config.config);

        adsp_config.params.GetAsCoreCodecConfig();

    const types::LeAudioCoreCodecConfig target_lc3_config =

        std::get<types::LeAudioCoreCodecConfig>(target_config.config);

        target_config.params.GetAsCoreCodecConfig();



    if (adsp_lc3_config.sampling_frequency !=

            target_lc3_config.sampling_frequency ||

        adsp_lc3_config.frame_duration != target_lc3_config.frame_duration ||

        adsp_lc3_config.channel_count != target_lc3_config.channel_count ||

        adsp_config.GetChannelCountPerIsoStream() !=

            target_config.GetChannelCountPerIsoStream() ||

        adsp_lc3_config.octets_per_codec_frame !=

            target_lc3_config.octets_per_codec_frame) {

      return false;

system/bta/le_audio/device_groups.cc

+45 −46
Original line number Diff line number Diff line
@@ -449,7 +449,7 @@ uint32_t LeAudioDeviceGroup::GetSduInterval(uint8_t direction) const { 
    struct ase* ase = leAudioDevice->GetFirstActiveAseByDirection(direction);

    if (!ase) continue;



    return ase->codec_config.GetFrameDurationUs();

    return ase->codec_config.GetAsCoreCodecConfig().GetFrameDurationUs();

  }



  return 0;
@@ -899,11 +899,12 @@ types::LeAudioConfigurationStrategy LeAudioDeviceGroup::GetGroupStrategy( 
  }



  auto device = GetFirstDevice();

  auto channel_cnt =

      device->GetLc3SupportedChannelCount(types::kLeAudioDirectionSink);

  LOG_DEBUG("Channel count for group %d is %d (device %s)", group_id_,

            channel_cnt, ADDRESS_TO_LOGGABLE_CSTR(device->address_));

  if (channel_cnt == 1) {

  auto channel_count_bitmap =

      device->GetSupportedAudioChannelCounts(types::kLeAudioDirectionSink);

  LOG_DEBUG("Supported channel counts for group %d (device %s) is %d",

            group_id_, ADDRESS_TO_LOGGABLE_CSTR(device->address_),

            channel_count_bitmap);

  if (channel_count_bitmap == 1) {

    return types::LeAudioConfigurationStrategy::STEREO_TWO_CISES_PER_DEVICE;

  }
@@ -1180,11 +1181,18 @@ void LeAudioDeviceGroup::CigConfiguration::UnassignCis( 
}



bool CheckIfStrategySupported(types::LeAudioConfigurationStrategy strategy,

                              types::AudioLocations audio_locations,

                              uint8_t requested_channel_count,

                              uint8_t channel_count_mask) {

  DLOG(INFO) << __func__ << " strategy: " << (int)strategy

             << " locations: " << +audio_locations.to_ulong();

                              const set_configurations::SetConfiguration& conf,

                              const LeAudioDevice& device) {

  /* Check direction and if audio location allows to create more cises to a

   * single device.

   */

  types::AudioLocations audio_locations =

      (conf.direction == types::kLeAudioDirectionSink)

          ? device.snk_audio_locations_

          : device.src_audio_locations_;



  LOG_DEBUG("strategy: %d, locations: %lu", (int)strategy,

            audio_locations.to_ulong());



  switch (strategy) {

    case types::LeAudioConfigurationStrategy::MONO_ONE_CIS_PER_DEVICE:
@@ -1197,22 +1205,26 @@ bool CheckIfStrategySupported(types::LeAudioConfigurationStrategy strategy, 
        return true;

      else

        return false;

    case types::LeAudioConfigurationStrategy::STEREO_ONE_CIS_PER_DEVICE:

    case types::LeAudioConfigurationStrategy::STEREO_ONE_CIS_PER_DEVICE: {

      if (!(audio_locations.to_ulong() &

            codec_spec_conf::kLeAudioLocationAnyLeft) ||

          !(audio_locations.to_ulong() &

            codec_spec_conf::kLeAudioLocationAnyRight))

        return false;



      DLOG(INFO) << __func__ << " requested chan cnt "

                 << +requested_channel_count

                 << " chan mask: " << loghex(channel_count_mask);

      auto channel_count_mask =

          device.GetSupportedAudioChannelCounts(conf.direction);

      auto requested_channel_count = conf.codec.params.GetAsCoreCodecConfig()

                                         .GetChannelCountPerIsoStream();

      LOG_DEBUG("Requested channel count: %d, supp. channel counts: %s",

                requested_channel_count, loghex(channel_count_mask).c_str());



      /* Return true if requested channel count is set in the channel count

       * mask. In the channel_count_mask, bit0 is set when 1 channel is

      /* Return true if requested channel count is set in the supported channel

       * counts. In the channel_count_mask, bit 0 is set when 1 channel is

       * supported.

       */

      return ((1 << (requested_channel_count - 1)) & channel_count_mask);

    }

    default:

      return false;

  }
@@ -1283,32 +1295,17 @@ bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported( 


      if (device->ases_.empty()) continue;



      if (!device->GetCodecConfigurationSupportedPac(ent.direction, ent.codec))

      if (!device->GetCodecConfigurationSupportedPac(ent.direction,

                                                     ent.codec)) {

        LOG_DEBUG("Insufficient PAC");

        continue;

      }



      int needed_ase = std::min(static_cast<int>(max_required_ase_per_dev),

                                static_cast<int>(ent.ase_cnt - active_ase_num));



      /* If we required more ASEs per device which means we would like to

       * create more CISes to one device, we should also check the allocation

       * if it allows us to do this.

       */



      types::AudioLocations audio_locations = 0;

      /* Check direction and if audio location allows to create more cise */

      if (ent.direction == types::kLeAudioDirectionSink)

        audio_locations = device->snk_audio_locations_;

      else

        audio_locations = device->src_audio_locations_;



      /* TODO Make it no Lc3 specific */

      if (!CheckIfStrategySupported(

              strategy, audio_locations,

              std::get<LeAudioCoreCodecConfig>(ent.codec.config)

                  .GetChannelCount(),

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

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

                  audio_locations.to_ulong());

      if (!CheckIfStrategySupported(strategy, ent, *device)) {

        LOG_DEBUG("Strategy not supported");

        continue;

      }
@@ -1519,37 +1516,37 @@ LeAudioDeviceGroup::GetCachedCodecConfigurationByDirection( 
    if (conf.direction != direction) continue;



    if (group_config.sample_rate != 0 &&

        conf.codec.GetConfigSamplingFrequency() != group_config.sample_rate) {

        conf.codec.GetSamplingFrequencyHz() != group_config.sample_rate) {

      LOG(WARNING) << __func__

                   << ", stream configuration could not be "

                      "determined (sampling frequency differs) for direction: "

                   << loghex(direction);

      return std::nullopt;

    }

    group_config.sample_rate = conf.codec.GetConfigSamplingFrequency();

    group_config.sample_rate = conf.codec.GetSamplingFrequencyHz();



    if (group_config.data_interval_us != 0 &&

        conf.codec.GetConfigDataIntervalUs() != group_config.data_interval_us) {

        conf.codec.GetDataIntervalUs() != group_config.data_interval_us) {

      LOG(WARNING) << __func__

                   << ", stream configuration could not be "

                      "determined (data interval differs) for direction: "

                   << loghex(direction);

      return std::nullopt;

    }

    group_config.data_interval_us = conf.codec.GetConfigDataIntervalUs();

    group_config.data_interval_us = conf.codec.GetDataIntervalUs();



    if (group_config.bits_per_sample != 0 &&

        conf.codec.GetConfigBitsPerSample() != group_config.bits_per_sample) {

        conf.codec.GetBitsPerSample() != group_config.bits_per_sample) {

      LOG(WARNING) << __func__

                   << ", stream configuration could not be "

                      "determined (bits per sample differs) for direction: "

                   << loghex(direction);

      return std::nullopt;

    }

    group_config.bits_per_sample = conf.codec.GetConfigBitsPerSample();

    group_config.bits_per_sample = conf.codec.GetBitsPerSample();



    group_config.num_channels +=

        conf.codec.GetConfigChannelCount() * conf.device_cnt;

        conf.codec.GetChannelCountPerIsoStream() * conf.device_cnt;

  }



  if (group_config.IsInvalid()) return std::nullopt;
@@ -1634,7 +1631,9 @@ void LeAudioDeviceGroup::RemoveCisFromStreamIfNeeded( 
              if (ases_pair.get(dir) && cis_conn_hdl == pair.first) {

                params.num_of_devices--;

                params.num_of_channels -=

                    ases_pair.get(dir)->codec_config.channel_count;

                    ases_pair.get(dir)

                        ->codec_config.GetAsCoreCodecConfig()

                        .GetChannelCountPerIsoStream();

                params.audio_channel_allocation &= ~pair.second;

              }

              return (ases_pair.get(dir) && cis_conn_hdl == pair.first);

system/bta/le_audio/devices.cc

+17 −13
Original line number Diff line number Diff line
@@ -269,24 +269,28 @@ bool LeAudioDevice::ConfigureAses( 


      ase->target_latency = ent.qos.target_latency;

      ase->codec_id = ent.codec.id;

      /* TODO: find better way to not use LC3 explicitly */

      ase->codec_config = std::get<LeAudioCoreCodecConfig>(ent.codec.config);

      ase->codec_config = ent.codec.params;



      /* Let's choose audio channel allocation if not set */

      ase->codec_config.audio_channel_allocation =

      ase->codec_config.Add(

          codec_spec_conf::kLeAudioLtvTypeAudioChannelAllocation,

          PickAudioLocation(strategy, audio_locations,

                            group_audio_locations_memo.get(ent.direction));

                            group_audio_locations_memo.get(ent.direction)));



      /* Get default value if no requirement for specific frame blocks per sdu

       */

      if (!ase->codec_config.codec_frames_blocks_per_sdu) {

        ase->codec_config.codec_frames_blocks_per_sdu =

            GetMaxCodecFramesPerSduFromPac(pac);

      if (!ase->codec_config.Find(

              codec_spec_conf::kLeAudioLtvTypeCodecFrameBlocksPerSdu)) {

        ase->codec_config.Add(

            codec_spec_conf::kLeAudioLtvTypeCodecFrameBlocksPerSdu,

            GetMaxCodecFramesPerSduFromPac(pac));

      }

      ase->max_sdu_size = codec_spec_caps::GetAudioChannelCounts(

                              *ase->codec_config.audio_channel_allocation) *

                          *ase->codec_config.octets_per_codec_frame *

                          *ase->codec_config.codec_frames_blocks_per_sdu;



      /* Recalculate Max SDU size */

      auto core_config = ent.codec.params.GetAsCoreCodecConfig();

      ase->max_sdu_size = core_config.GetChannelCountPerIsoStream() *

                          core_config.octets_per_codec_frame.value_or(0) *

                          core_config.codec_frames_blocks_per_sdu.value_or(1);



      ase->retrans_nb = ent.qos.retransmission_number;

      ase->max_transport_latency = ent.qos.max_transport_latency;
@@ -664,7 +668,7 @@ bool LeAudioDevice::HaveAnyCisConnected(void) { 
  return false;

}



uint8_t LeAudioDevice::GetLc3SupportedChannelCount(uint8_t direction) {

uint8_t LeAudioDevice::GetSupportedAudioChannelCounts(uint8_t direction) const {

  auto& pacs =

      direction == types::kLeAudioDirectionSink ? snk_pacs_ : src_pacs_;

system/bta/le_audio/devices.h

+1 −1
Original line number Diff line number Diff line
@@ -180,7 +180,7 @@ class LeAudioDevice { 
  const struct types::acs_ac_record* GetCodecConfigurationSupportedPac(

      uint8_t direction,

      const set_configurations::CodecConfigSetting& codec_capability_setting);

  uint8_t GetLc3SupportedChannelCount(uint8_t direction);

  uint8_t GetSupportedAudioChannelCounts(uint8_t direction) const;

  uint8_t GetPhyBitmask(void);

  bool ConfigureAses(

      const le_audio::set_configurations::SetConfiguration& ent,