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

Commit 18283fd4 authored by Pavlin Radoslavov's avatar Pavlin Radoslavov Committed by android-build-merger
Browse files

Add a mechanism to configure the default A2DP codec priorities am: a1475251 

am: 05749ea9

Change-Id: I987518130278e2ef51f828cffdfc13cb3a3dc275
parents fab674d1 05749ea9

system/btif/co/bta_av_co.cc

+3 −2
Original line number Diff line number Diff line
@@ -1260,7 +1260,8 @@ A2dpCodecConfig* bta_av_get_a2dp_current_codec(void) { 
  return current_codec;

}



void bta_av_co_init(void) {

void bta_av_co_init(

    const std::vector<btav_a2dp_codec_config_t>& codec_priorities) {

  APPL_TRACE_DEBUG("%s", __func__);



  /* Reset the control block */
@@ -1275,7 +1276,7 @@ void bta_av_co_init(void) { 
  /* Reset the current config */

  /* Protect access to bta_av_co_cb.codec_config */

  mutex_global_lock();

  bta_av_co_cb.codecs = new A2dpCodecs();

  bta_av_co_cb.codecs = new A2dpCodecs(codec_priorities);

  bta_av_co_cb.codecs->init();

  A2DP_InitDefaultCodec(bta_av_co_cb.codec_config);

  mutex_global_unlock();

system/btif/include/btif_av_co.h

+3 −1
Original line number Diff line number Diff line
@@ -51,7 +51,9 @@ bool bta_av_co_set_codec_audio_config( 
    const btav_a2dp_codec_config_t& codec_audio_config);



// Initializes the control block.

void bta_av_co_init(void);

// |codec_priorities| contains the A2DP Source codec priorities to use.

void bta_av_co_init(

    const std::vector<btav_a2dp_codec_config_t>& codec_priorities);



// Gets the initialized A2DP codecs.

// Returns a pointer to the |A2dpCodecs| object with the initialized A2DP

system/btif/src/btif_av.cc

+8 −3
Original line number Diff line number Diff line
@@ -78,6 +78,7 @@ typedef struct { 
  uint8_t flags;

  tBTA_AV_EDR edr;

  uint8_t peer_sep; /* sep type of peer device */

  std::vector<btav_a2dp_codec_config_t> codec_priorities;

} btif_av_cb_t;



typedef struct {
@@ -96,7 +97,8 @@ typedef struct { 
 *****************************************************************************/

static btav_source_callbacks_t* bt_av_src_callbacks = NULL;

static btav_sink_callbacks_t* bt_av_sink_callbacks = NULL;

static btif_av_cb_t btif_av_cb = {0, {{0}}, 0, 0, 0, 0};

static btif_av_cb_t btif_av_cb = {

    0, {{0}}, 0, 0, 0, 0, std::vector<btav_a2dp_codec_config_t>()};

static alarm_t* av_open_on_rc_timer = NULL;



/* both interface and media task needs to be ready to alloc incoming request */
@@ -336,7 +338,7 @@ static bool btif_av_state_idle_handler(btif_sm_event_t event, void* p_data) { 
      memset(&btif_av_cb.peer_bda, 0, sizeof(bt_bdaddr_t));

      btif_av_cb.flags = 0;

      btif_av_cb.edr = 0;

      bta_av_co_init();

      bta_av_co_init(btif_av_cb.codec_priorities);

      btif_a2dp_on_idle();

      break;
@@ -1262,9 +1264,12 @@ bt_status_t btif_av_init(int service_id) { 
 *

 ******************************************************************************/



static bt_status_t init_src(btav_source_callbacks_t* callbacks) {

static bt_status_t init_src(

    btav_source_callbacks_t* callbacks,

    std::vector<btav_a2dp_codec_config_t> codec_priorities) {

  BTIF_TRACE_EVENT("%s()", __func__);



  btif_av_cb.codec_priorities = codec_priorities;

  bt_status_t status = btif_av_init(BTA_A2DP_SOURCE_SERVICE_ID);

  if (status == BT_STATUS_SUCCESS) bt_av_src_callbacks = callbacks;

system/stack/a2dp/a2dp_aac.cc

+3 −2
Original line number Diff line number Diff line
@@ -649,8 +649,9 @@ UNUSED_ATTR static void build_codec_config(const tA2DP_AAC_CIE& config_cie, 
  }

}



A2dpCodecConfigAac::A2dpCodecConfigAac()

    : A2dpCodecConfig(BTAV_A2DP_CODEC_INDEX_SOURCE_AAC, "AAC") {

A2dpCodecConfigAac::A2dpCodecConfigAac(

    btav_a2dp_codec_priority_t codec_priority)

    : A2dpCodecConfig(BTAV_A2DP_CODEC_INDEX_SOURCE_AAC, "AAC", codec_priority) {

  // Compute the local capability

  if (a2dp_aac_caps.sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) {

    codec_local_capability_.sample_rate |= BTAV_A2DP_CODEC_SAMPLE_RATE_44100;

system/stack/a2dp/a2dp_codec_config.cc

+54 −15
Original line number Diff line number Diff line
@@ -48,9 +48,12 @@ static void init_btav_a2dp_codec_config( 
}



A2dpCodecConfig::A2dpCodecConfig(btav_a2dp_codec_index_t codec_index,

                                 const std::string& name)

    : codec_index_(codec_index), name_(name) {

  setDefaultCodecPriority();

                                 const std::string& name,

                                 btav_a2dp_codec_priority_t codec_priority)

    : codec_index_(codec_index),

      name_(name),

      default_codec_priority_(codec_priority) {

  setCodecPriority(codec_priority);



  init_btav_a2dp_codec_config(&codec_config_, codec_index_, codecPriority());

  init_btav_a2dp_codec_config(&codec_capability_, codec_index_,
@@ -82,34 +85,39 @@ void A2dpCodecConfig::setCodecPriority( 
}



void A2dpCodecConfig::setDefaultCodecPriority() {

  if (default_codec_priority_ != BTAV_A2DP_CODEC_PRIORITY_DEFAULT) {

    codec_priority_ = default_codec_priority_;

  } else {

    // Compute the default codec priority

  uint32_t priority = 1000 * codec_index_ + 1;

    uint32_t priority = 1000 * (codec_index_ + 1) + 1;

    codec_priority_ = static_cast<btav_a2dp_codec_priority_t>(priority);

  }

}



A2dpCodecConfig* A2dpCodecConfig::createCodec(

    btav_a2dp_codec_index_t codec_index) {

    btav_a2dp_codec_index_t codec_index,

    btav_a2dp_codec_priority_t codec_priority) {

  LOG_DEBUG(LOG_TAG, "%s: codec %s", __func__, A2DP_CodecIndexStr(codec_index));



  A2dpCodecConfig* codec_config = nullptr;

  switch (codec_index) {

    case BTAV_A2DP_CODEC_INDEX_SOURCE_SBC:

      codec_config = new A2dpCodecConfigSbc();

      codec_config = new A2dpCodecConfigSbc(codec_priority);

      break;

    case BTAV_A2DP_CODEC_INDEX_SINK_SBC:

      codec_config = new A2dpCodecConfigSbcSink();

      codec_config = new A2dpCodecConfigSbcSink(codec_priority);

      break;

    case BTAV_A2DP_CODEC_INDEX_SOURCE_AAC:

      codec_config = new A2dpCodecConfigAac();

      codec_config = new A2dpCodecConfigAac(codec_priority);

      break;

    case BTAV_A2DP_CODEC_INDEX_SOURCE_APTX:

      codec_config = new A2dpCodecConfigAptx();

      codec_config = new A2dpCodecConfigAptx(codec_priority);

      break;

    case BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD:

      codec_config = new A2dpCodecConfigAptxHd();

      codec_config = new A2dpCodecConfigAptxHd(codec_priority);

      break;

    case BTAV_A2DP_CODEC_INDEX_SOURCE_LDAC:

      codec_config = new A2dpCodecConfigLdac();

      codec_config = new A2dpCodecConfigLdac(codec_priority);

      break;

    // Add a switch statement for each vendor-specific codec

    case BTAV_A2DP_CODEC_INDEX_MAX:
@@ -287,13 +295,23 @@ static bool compare_codec_priority(const A2dpCodecConfig* lhs, 
  return (lhs->codecIndex() > rhs->codecIndex());

}



A2dpCodecs::A2dpCodecs() : current_codec_config_(nullptr) {}

A2dpCodecs::A2dpCodecs(

    const std::vector<btav_a2dp_codec_config_t>& codec_priorities)

    : current_codec_config_(nullptr) {

  for (auto config : codec_priorities) {

    codec_priorities_.insert(

        std::make_pair(config.codec_type, config.codec_priority));

  }

}



A2dpCodecs::~A2dpCodecs() {

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

  for (const auto& iter : indexed_codecs_) {

    delete iter.second;

  }

  for (const auto& iter : disabled_codecs_) {

    delete iter.second;

  }

  lock.unlock();

}
@@ -304,9 +322,30 @@ bool A2dpCodecs::init() { 
  for (int i = BTAV_A2DP_CODEC_INDEX_MIN; i < BTAV_A2DP_CODEC_INDEX_MAX; i++) {

    btav_a2dp_codec_index_t codec_index =

        static_cast<btav_a2dp_codec_index_t>(i);

    A2dpCodecConfig* codec_config = A2dpCodecConfig::createCodec(codec_index);



    // Select the codec priority if explicitly configured

    btav_a2dp_codec_priority_t codec_priority =

        BTAV_A2DP_CODEC_PRIORITY_DEFAULT;

    auto cp_iter = codec_priorities_.find(codec_index);

    if (cp_iter != codec_priorities_.end()) {

      codec_priority = cp_iter->second;

    }



    A2dpCodecConfig* codec_config =

        A2dpCodecConfig::createCodec(codec_index, codec_priority);

    if (codec_config == nullptr) continue;



    if (codec_priority != BTAV_A2DP_CODEC_PRIORITY_DEFAULT) {

      LOG_INFO(LOG_TAG, "%s: updated %s codec priority to %d", __func__,

               codec_config->name().c_str(), codec_priority);

    }



    // Test if the codec is disabled

    if (codec_config->codecPriority() == BTAV_A2DP_CODEC_PRIORITY_DISABLED) {

      disabled_codecs_.insert(std::make_pair(codec_index, codec_config));

      continue;

    }



    indexed_codecs_.insert(std::make_pair(codec_index, codec_config));



    if (codec_index < BTAV_A2DP_CODEC_INDEX_SOURCE_MAX) {