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

Commit 97337c62 authored by Myles Watson's avatar Myles Watson
Browse files

PDL: Add Dynamic Audio Buffer VSCs 

https://source.android.com/docs/core/connect/bluetooth/hci_requirements

Add support for the GD Controller to parse the commands.  Add
Tests for v103.

Bug: 301661850
Bug: 319152618
Test: atest bluetooth_test_gd_unit
Flag: EXEMPT, No logical change
Change-Id: I604298524d03f76a9be8cc159016b0871a58f8ee
parent d48cd4ac

system/gd/hci/controller.cc

+167 −50
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include "hci/event_checkers.h"

#include "hci/hci_layer.h"

#include "hci_controller_generated.h"

#include "os/log.h"

#include "os/metrics.h"

#include "os/system_properties.h"

#include "sysprops/sysprops_module.h"
@@ -196,9 +197,16 @@ struct Controller::impl { 
    // Skip vendor capabilities check if configured.

    if (os::GetSystemPropertyBool(

            kPropertyVendorCapabilitiesEnabled, kDefaultVendorCapabilitiesEnabled)) {

      // More commands can be enqueued from le_get_vendor_capabilities_handler

      std::promise<void> vendor_promise;

      auto vendor_future = vendor_promise.get_future();

      hci_->EnqueueCommand(

          LeGetVendorCapabilitiesBuilder::Create(),

          handler->BindOnceOn(this, &Controller::impl::le_get_vendor_capabilities_handler));

          handler->BindOnceOn(

              this,

              &Controller::impl::le_get_vendor_capabilities_handler,

              std::move(vendor_promise)));

      vendor_future.wait();

    } else {

      vendor_capabilities_.is_supported_ = 0x00;

    }
@@ -531,7 +539,8 @@ struct Controller::impl { 
    le_periodic_advertiser_list_size_ = complete_view.GetPeriodicAdvertiserListSize();

  }



  void le_get_vendor_capabilities_handler(CommandCompleteView view) {

  void le_get_vendor_capabilities_handler(

      std::promise<void> vendor_promise, CommandCompleteView view) {

    auto complete_view = LeGetVendorCapabilitiesCompleteView::Create(view);



    vendor_capabilities_.is_supported_ = 0x00;
@@ -551,7 +560,10 @@ struct Controller::impl { 
    vendor_capabilities_.a2dp_source_offload_capability_mask_ = 0x00;

    vendor_capabilities_.bluetooth_quality_report_support_ = 0x00;



    if (complete_view.IsValid()) {

    if (!complete_view.IsValid()) {

      vendor_promise.set_value();

      return;

    }

    vendor_capabilities_.is_supported_ = 0x01;



    // v0.55
@@ -559,20 +571,25 @@ struct Controller::impl { 
    vendor_capabilities_.max_advt_instances_ = base_vendor_capabilities.max_advt_instances_;

    vendor_capabilities_.offloaded_resolution_of_private_address_ =

        base_vendor_capabilities.offloaded_resolution_of_private_address_;

      vendor_capabilities_.total_scan_results_storage_ = base_vendor_capabilities.total_scan_results_storage_;

    vendor_capabilities_.total_scan_results_storage_ =

        base_vendor_capabilities.total_scan_results_storage_;

    vendor_capabilities_.max_irk_list_sz_ = base_vendor_capabilities.max_irk_list_sz_;

    vendor_capabilities_.filtering_support_ = base_vendor_capabilities.filtering_support_;

    vendor_capabilities_.max_filter_ = base_vendor_capabilities.max_filter_;

      vendor_capabilities_.activity_energy_info_support_ = base_vendor_capabilities.activity_energy_info_support_;

    vendor_capabilities_.activity_energy_info_support_ =

        base_vendor_capabilities.activity_energy_info_support_;



    if (complete_view.GetPayload().size() == 0) {

      vendor_capabilities_.version_supported_ = 55;

      vendor_promise.set_value();

      return;

    }



    // v0.95

    auto v95 = LeGetVendorCapabilitiesComplete095View::Create(complete_view);

    if (!v95.IsValid()) {

        LOG_ERROR("invalid data for hci requirements v0.95");

      LOG_INFO("invalid data for hci requirements v0.95");

      vendor_promise.set_value();

      return;

    }

    vendor_capabilities_.version_supported_ = v95.GetVersionSupported();
@@ -580,29 +597,108 @@ struct Controller::impl { 
    vendor_capabilities_.extended_scan_support_ = v95.GetExtendedScanSupport();

    vendor_capabilities_.debug_logging_supported_ = v95.GetDebugLoggingSupported();

    if (vendor_capabilities_.version_supported_ <= 95 || complete_view.GetPayload().size() == 0) {

      vendor_promise.set_value();

      return;

    }



    // v0.96

    auto v96 = LeGetVendorCapabilitiesComplete096View::Create(v95);

    if (!v96.IsValid()) {

        LOG_ERROR("invalid data for hci requirements v0.96");

      LOG_INFO("invalid data for hci requirements v0.96");

      vendor_promise.set_value();

      return;

    }

      vendor_capabilities_.le_address_generation_offloading_support_ = v96.GetLeAddressGenerationOffloadingSupport();

    vendor_capabilities_.le_address_generation_offloading_support_ =

        v96.GetLeAddressGenerationOffloadingSupport();

    if (vendor_capabilities_.version_supported_ <= 96 || complete_view.GetPayload().size() == 0) {

      vendor_promise.set_value();

      return;

    }



    // v0.98

    auto v98 = LeGetVendorCapabilitiesComplete098View::Create(v96);

    if (!v98.IsValid()) {

        LOG_ERROR("invalid data for hci requirements v0.98");

      LOG_INFO("invalid data for hci requirements v0.98");

      vendor_promise.set_value();

      return;

    }

      vendor_capabilities_.a2dp_source_offload_capability_mask_ = v98.GetA2dpSourceOffloadCapabilityMask();

    vendor_capabilities_.a2dp_source_offload_capability_mask_ =

        v98.GetA2dpSourceOffloadCapabilityMask();

    vendor_capabilities_.bluetooth_quality_report_support_ = v98.GetBluetoothQualityReportSupport();



    // v1.03

    auto v103 = LeGetVendorCapabilitiesComplete103View::Create(v98);

    if (!v103.IsValid()) {

      LOG_INFO("invalid data for hci requirements v1.03");

      vendor_promise.set_value();

      return;

    }

    vendor_capabilities_.dynamic_audio_buffer_support_ = v103.GetDynamicAudioBufferSupport();



    if (vendor_capabilities_.dynamic_audio_buffer_support_ == 0) {

      vendor_promise.set_value();

      return;

    }

    hci_->EnqueueCommand(

        DabGetAudioBufferTimeCapabilityBuilder::Create(),

        module_.GetHandler()->BindOnceOn(

            this,

            &Controller::impl::le_get_dynamic_audio_buffer_support_handler,

            std::move(vendor_promise)));

  }



  void le_get_dynamic_audio_buffer_support_handler(

      std::promise<void> vendor_promise, CommandCompleteView view) {

    vendor_promise.set_value();

    auto dab_complete_view = DynamicAudioBufferCompleteView::Create(view);

    if (!dab_complete_view.IsValid()) {

      LOG_WARN("Invalid command complete");

      return;

    }



    if (dab_complete_view.GetStatus() != ErrorCode::SUCCESS) {

      LOG_WARN("Unexpected error code %s", ErrorCodeText(dab_complete_view.GetStatus()).c_str());

      return;

    }



    auto complete_view = DabGetAudioBufferTimeCapabilityCompleteView::Create(dab_complete_view);

    if (!complete_view.IsValid()) {

      LOG_WARN("Invalid get complete");

      return;

    }

    dab_supported_codecs_ = complete_view.GetAudioCodecTypeSupported();

    dab_codec_capabilities_ = complete_view.GetAudioCodecCapabilities();

  }



  void set_controller_dab_audio_buffer_time_complete(CommandCompleteView complete) {

    auto dab_complete = DynamicAudioBufferCompleteView::Create(complete);

    if (!dab_complete.IsValid()) {

      LOG_WARN("Invalid command complete");

      return;

    }



    if (dab_complete.GetStatus() != ErrorCode::SUCCESS) {

      LOG_WARN("Unexpected return code %s", ErrorCodeText(dab_complete.GetStatus()).c_str());

      return;

    }



    auto dab_set_complete = DabSetAudioBufferTimeCompleteView::Create(dab_complete);



    if (!dab_set_complete.IsValid()) {

      LOG_WARN("Invalid set complete");

      return;

    }



    LOG_INFO(

        "Configured Media Tx Buffer, time returned = %d",

        dab_set_complete.GetCurrentBufferTimeMs());

  }



  void set_controller_dab_audio_buffer_time(uint16_t buffer_time_ms) {

    hci_->EnqueueCommand(

        DabSetAudioBufferTimeBuilder::Create(buffer_time_ms),

        module_.GetHandler()->BindOnceOn(

            this, &Controller::impl::set_controller_dab_audio_buffer_time_complete));

  }



  void set_event_mask(uint64_t event_mask) {
@@ -1033,6 +1129,8 @@ struct Controller::impl { 
        return vendor_capabilities_.a2dp_source_offload_capability_mask_ != 0x00;

      case OpCode::CONTROLLER_BQR:

        return vendor_capabilities_.bluetooth_quality_report_support_ == 0x01;

      case OpCode::DYNAMIC_AUDIO_BUFFER:

        return vendor_capabilities_.dynamic_audio_buffer_support_ > 0x00;

      // Before MSFT extension is fully supported, return false for the following MSFT_OPCODE_XXXX for now.

      case OpCode::MSFT_OPCODE_INTEL:

        return false;
@@ -1095,6 +1193,8 @@ struct Controller::impl { 
  uint8_t le_number_supported_advertising_sets_{};

  uint8_t le_periodic_advertiser_list_size_{};

  VendorCapabilities vendor_capabilities_{};

  uint32_t dab_supported_codecs_{};

  std::array<DynamicAudioBufferCodecCapability, 32> dab_codec_capabilities_{};

};  // namespace hci



Controller::Controller() : impl_(std::make_unique<impl>(*this)) {}
@@ -1365,6 +1465,23 @@ Controller::VendorCapabilities Controller::GetVendorCapabilities() const { 
  return impl_->vendor_capabilities_;

}



uint32_t Controller::GetDabSupportedCodecs() const {

  return impl_->dab_supported_codecs_;

}



const std::array<DynamicAudioBufferCodecCapability, 32>& Controller::GetDabCodecCapabilities()

    const {

  return impl_->dab_codec_capabilities_;

}



void Controller::SetDabAudioBufferTime(uint16_t buffer_time_ms) {

  if (impl_->vendor_capabilities_.dynamic_audio_buffer_support_ == 0) {

    LOG_WARN("Dynamic Audio Buffer not supported");

    return;

  }

  impl_->set_controller_dab_audio_buffer_time(buffer_time_ms);

}



uint8_t Controller::GetLePeriodicAdvertiserListSize() const {

  return impl_->le_periodic_advertiser_list_size_;

}

system/gd/hci/controller.h

+6 −0
Original line number Diff line number Diff line
@@ -203,10 +203,16 @@ class Controller : public Module { 
    uint8_t le_address_generation_offloading_support_;

    uint32_t a2dp_source_offload_capability_mask_;

    uint8_t bluetooth_quality_report_support_;

    uint32_t dynamic_audio_buffer_support_;

  };



  virtual VendorCapabilities GetVendorCapabilities() const;



  virtual uint32_t GetDabSupportedCodecs() const;

  virtual const std::array<DynamicAudioBufferCodecCapability, 32>& GetDabCodecCapabilities() const;



  virtual void SetDabAudioBufferTime(uint16_t buffer_time_ms);



  virtual bool IsSupported(OpCode op_code) const;



  static const ModuleFactory Factory;

system/gd/hci/controller_test.cc

+113 −17
Original line number Diff line number Diff line
@@ -49,6 +49,8 @@ constexpr uint16_t kCredits1 = 0x78; 
constexpr uint16_t kHandle2 = 0x456;

constexpr uint16_t kCredits2 = 0x9a;

constexpr uint64_t kRandomNumber = 0x123456789abcdef0;

/*sbc_supported= 1, aac_supported= 1, aptx_supported= 0, aptx_hd_supported= 0, ldac_supported= 1 */

constexpr uint32_t kDynamicAudioBufferSupport = 0x13;

uint16_t feature_spec_version = 55;

constexpr char title[] = "hci_controller_test";
@@ -171,7 +173,8 @@ class HciLayerFakeForController : public HciLayerFake { 
        event_builder =

            LeReadNumberOfSupportedAdvertisingSetsCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, 0xF0);

      } break;

      case (OpCode::LE_GET_VENDOR_CAPABILITIES): {

      case (OpCode::LE_GET_VENDOR_CAPABILITIES):

        if (vendor_capabilities_ == nullptr) {

          BaseVendorCapabilities base_vendor_capabilities;

          base_vendor_capabilities.max_advt_instances_ = 0x10;

          base_vendor_capabilities.offloaded_resolution_of_private_address_ = 0x01;
@@ -183,12 +186,37 @@ class HciLayerFakeForController : public HciLayerFake { 


          auto payload = std::make_unique<RawBuilder>();

          if (feature_spec_version > 55) {

          std::vector<uint8_t> payload_bytes = {0x20, 0x00, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00};

            std::vector<uint8_t> payload_bytes = {

                0x20, 0x00, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00};

            payload->AddOctets2(feature_spec_version);

            payload->AddOctets(payload_bytes);

          }

          event_builder = LeGetVendorCapabilitiesCompleteBuilder::Create(

              num_packets, ErrorCode::SUCCESS, base_vendor_capabilities, std::move(payload));

        } else {

          event_builder = std::move(vendor_capabilities_);

          vendor_capabilities_.reset();

        }

        break;

      case (OpCode::DYNAMIC_AUDIO_BUFFER): {

        auto dab_command =

            DynamicAudioBufferView::CreateOptional(VendorCommandView::Create(command));

        if (dab_command->GetDabCommand() == DabCommand::GET_AUDIO_BUFFER_TIME_CAPABILITY) {

          std::array<DynamicAudioBufferCodecCapability, 32> capabilities{};

          capabilities[0] =

              DynamicAudioBufferCodecCapability(0x123, 0x103, 0x1234);  // sbc_capabilities

          capabilities[1] =

              DynamicAudioBufferCodecCapability(0x223, 0x123, 0x2340);  // aac_capabilities

          capabilities[4] =

              DynamicAudioBufferCodecCapability(0x323, 0x223, 0x3456);  // ldac_capabilities

          event_builder = DabGetAudioBufferTimeCapabilityCompleteBuilder::Create(

              1, ErrorCode::SUCCESS, kDynamicAudioBufferSupport, capabilities);

        } else {

          auto set_command = DabSetAudioBufferTimeView::CreateOptional(*dab_command);

          dynamic_audio_buffer_time = set_command->GetBufferTimeMs();

          event_builder = DabSetAudioBufferTimeCompleteBuilder::Create(

              1, ErrorCode::SUCCESS, dynamic_audio_buffer_time);

        }

      } break;

      case (OpCode::SET_EVENT_MASK): {

        auto view = SetEventMaskView::Create(command);
@@ -240,12 +268,14 @@ class HciLayerFakeForController : public HciLayerFake { 
    IncomingEvent(NumberOfCompletedPacketsBuilder::Create(completed_packets));

  }



  std::unique_ptr<EventBuilder> vendor_capabilities_ = nullptr;

  constexpr static uint16_t acl_data_packet_length = 1024;

  constexpr static uint8_t synchronous_data_packet_length = 60;

  constexpr static uint16_t total_num_acl_data_packets = 10;

  constexpr static uint16_t total_num_synchronous_data_packets = 12;

  uint64_t event_mask = 0;

  uint64_t le_event_mask = 0;

  uint16_t dynamic_audio_buffer_time = 0;

};



class ControllerTest : public ::testing::Test {
@@ -254,6 +284,8 @@ class ControllerTest : public ::testing::Test { 
    feature_spec_version = feature_spec_version_;

    bluetooth::common::InitFlags::SetAllForTesting();

    test_hci_layer_ = new HciLayerFakeForController;

    test_hci_layer_->vendor_capabilities_ = std::move(vendor_capabilities_);

    vendor_capabilities_.reset();

    fake_registry_.InjectTestModule(&HciLayer::Factory, test_hci_layer_);

    client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);

    fake_registry_.Start<Controller>(&thread_);
@@ -270,6 +302,7 @@ class ControllerTest : public ::testing::Test { 
  Controller* controller_ = nullptr;

  os::Handler* client_handler_ = nullptr;

  uint16_t feature_spec_version_ = 98;

  std::unique_ptr<EventBuilder> vendor_capabilities_ = nullptr;

};

}  // namespace
@@ -297,6 +330,35 @@ class Controller096Test : public ControllerTest { 
  }

};



class Controller103Test : public ControllerTest {

 protected:

  void SetUp() override {

    feature_spec_version_ = 0x100 + 0x03;

    BaseVendorCapabilities base_vendor_capabilities;

    base_vendor_capabilities.max_advt_instances_ = 0x10;

    base_vendor_capabilities.offloaded_resolution_of_private_address_ = 0x01;

    base_vendor_capabilities.total_scan_results_storage_ = 0x2800;

    base_vendor_capabilities.max_irk_list_sz_ = 0x20;

    base_vendor_capabilities.filtering_support_ = 0x01;

    base_vendor_capabilities.max_filter_ = 0x10;

    base_vendor_capabilities.activity_energy_info_support_ = 0x01;

    vendor_capabilities_ = LeGetVendorCapabilitiesComplete103Builder::Create(

        1,

        ErrorCode::SUCCESS,

        base_vendor_capabilities,

        feature_spec_version_,

        0x102,

        /*extended_scan_support=*/1,

        /*debug_logging_supported=*/1,

        /*le_address_generation_offloading_support=*/0,

        /*a2dp_source_offload_capability_mask=*/0x4,

        /*bluetooth_quality_report_support=*/1,

        kDynamicAudioBufferSupport,

        std::make_unique<RawBuilder>());

    ControllerTest::SetUp();

  }

};



TEST_F(ControllerTest, startup_teardown) {}



TEST_F(ControllerTest, read_controller_info) {
@@ -430,6 +492,40 @@ TEST_F(ControllerTest, feature_spec_version_098_test) { 
  ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));

}



TEST_F(ControllerTest, feature_spec_version_098_no_dab_test) {

  ASSERT_FALSE(controller_->IsSupported(OpCode::DYNAMIC_AUDIO_BUFFER));

}



TEST_F(ControllerTest, set_dynamic_audio_buffer_time) {

  controller_->SetDabAudioBufferTime(123);

  thread_.GetReactor()->WaitForIdle(std::chrono::seconds(1));

  ASSERT_EQ(0, test_hci_layer_->dynamic_audio_buffer_time);

}



TEST_F(Controller103Test, feature_spec_version_103_dab_test) {

  ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 0x100 + 3);

  ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));

  ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));

  ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));

  ASSERT_TRUE(controller_->IsSupported(OpCode::DYNAMIC_AUDIO_BUFFER));

  ASSERT_EQ(controller_->GetDabSupportedCodecs(), kDynamicAudioBufferSupport);

  for (size_t bit = 0; bit < 32; bit++) {

    if (kDynamicAudioBufferSupport & (1u << bit)) {

      ASSERT_GT(controller_->GetDabCodecCapabilities()[bit].maximum_time_ms_, 0) << " bit " << bit;

    } else {

      ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].maximum_time_ms_, 0);

      ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].minimum_time_ms_, 0);

      ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].default_time_ms_, 0);

    }

  }

}



TEST_F(Controller103Test, set_dynamic_audio_buffer_time) {

  controller_->SetDabAudioBufferTime(123);

  thread_.GetReactor()->WaitForIdle(std::chrono::seconds(1));

  ASSERT_EQ(123, test_hci_layer_->dynamic_audio_buffer_time);

}



std::promise<void> credits1_set;

std::promise<void> credits2_set;

system/pdl/hci/hci_packets.pdl

+67 −2
Original line number Diff line number Diff line
@@ -456,6 +456,7 @@ enum OpCode : 16 { 
  CONTROLLER_DEBUG_INFO = 0xFD5B,

  CONTROLLER_A2DP_OPCODE = 0xFD5D,

  CONTROLLER_BQR = 0xFD5E,

  DYNAMIC_AUDIO_BUFFER = 0xFD5F,

  // MSFT_OPCODE_xxxx below are needed for the tests.

  MSFT_OPCODE_MEDIATEK = 0xFD30,

  MSFT_OPCODE_QUALCOMM = 0xFD70,
@@ -5311,7 +5312,17 @@ packet LeGetVendorCapabilitiesComplete096 : LeGetVendorCapabilitiesComplete095 { 


packet LeGetVendorCapabilitiesComplete098 : LeGetVendorCapabilitiesComplete096 {

  a2dp_source_offload_capability_mask: 32,

  bluetooth_quality_report_support: 8

  bluetooth_quality_report_support: 8,

  _payload_,

}



packet LeGetVendorCapabilitiesComplete103 : LeGetVendorCapabilitiesComplete098 {

  dynamic_audio_buffer_support : 32,

  _payload_,

}



test LeGetVendorCapabilitiesComplete103 {

  "\x0e\x1c\x01\x53\xfd\x00\x10\x01\x00\x28\x00\x01\x3e\x01\x03\x01\x14\x00\x01\x01\x00\x23\x00\x00\x00\x01\x23\x00\x00\x00",

}



enum SubOcf : 8 {
@@ -5780,6 +5791,60 @@ test ControllerBqrComplete { 
  "\x0e\x08\x01\x5e\xfd\x00\x1f\x00\x07\x00",

}



enum DabCommand : 8 {

  GET_AUDIO_BUFFER_TIME_CAPABILITY = 0x01,

  SET_AUDIO_BUFFER_TIME = 0x02,

}



packet DynamicAudioBuffer : VendorCommand (op_code = DYNAMIC_AUDIO_BUFFER) {

  dab_command : DabCommand,

  _body_,

}



packet DynamicAudioBufferComplete : CommandComplete (command_op_code = DYNAMIC_AUDIO_BUFFER) {

  status : ErrorCode,

  dab_command : DabCommand,

  _body_,

}



packet DabGetAudioBufferTimeCapability : DynamicAudioBuffer (dab_command = GET_AUDIO_BUFFER_TIME_CAPABILITY) {

}



test DabGetAudioBufferTimeCapability {

  "\x5f\xfd\x01\x01",

}



struct DynamicAudioBufferCodecCapability {

  default_time_ms : 16,

  maximum_time_ms : 16,

  minimum_time_ms : 16,

}



packet DabGetAudioBufferTimeCapabilityComplete : DynamicAudioBufferComplete (dab_command = GET_AUDIO_BUFFER_TIME_CAPABILITY) {

  audio_codec_type_supported : 32,

  audio_codec_capabilities : DynamicAudioBufferCodecCapability[32],

}



test DabGetAudioBufferTimeCapabilityComplete {

  "\x0e\xc9\x01\x5f\xfd\x00\x01\x03\x00\x00\x00\xf4\x01\xf4\x01\x64\x00\xf4\x01\xf4\x01\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",

}



packet DabSetAudioBufferTime : DynamicAudioBuffer(dab_command = SET_AUDIO_BUFFER_TIME) {

  buffer_time_ms : 16, // Requested audio buffer time for the currently used codec.

}



test DabSetAudioBufferTime {

  "\x5f\xfd\x03\x02\x23\x01",

}



packet DabSetAudioBufferTimeComplete : DynamicAudioBufferComplete (dab_command = SET_AUDIO_BUFFER_TIME) {

  current_buffer_time_ms : 16,

}



test DabSetAudioBufferTimeComplete {

  "\x0e\x07\x01\x5f\xfd\x00\x02\x23\x01",

}



// HCI Event Packets



packet InquiryComplete : Event (event_code = INQUIRY_COMPLETE) {