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

Commit 6ef59ed2 authored by Henri Chataing's avatar Henri Chataing Committed by Gerrit Code Review
Browse files

Merge "stack/a2dp: De-duplicate identical helper functions" into main

parents be3d2e85 3a539036

system/stack/a2dp/a2dp_aac.cc

+7 −29
Original line number Diff line number Diff line
@@ -253,31 +253,7 @@ static tA2DP_STATUS A2DP_ParseInfoAac(tA2DP_AAC_CIE* p_ie, const uint8_t* p_code 
  return A2DP_SUCCESS;

}



bool A2DP_IsSourceCodecValidAac(const uint8_t* p_codec_info) {

  tA2DP_AAC_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */

  return (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||

         (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);

}



bool A2DP_IsSinkCodecValidAac(const uint8_t* p_codec_info) {

  tA2DP_AAC_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */

  return (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||

         (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);

}



bool A2DP_IsPeerSourceCodecValidAac(const uint8_t* p_codec_info) {

  tA2DP_AAC_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */

  return (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||

         (A2DP_ParseInfoAac(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);

}



bool A2DP_IsPeerSinkCodecValidAac(const uint8_t* p_codec_info) {

bool A2DP_IsCodecValidAac(const uint8_t* p_codec_info) {

  tA2DP_AAC_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */
@@ -671,16 +647,18 @@ std::string A2DP_CodecInfoStringAac(const uint8_t* p_codec_info) { 
  return res.str();

}



const tA2DP_ENCODER_INTERFACE* A2DP_GetEncoderInterfaceAac(const uint8_t* p_codec_info) {

  if (!A2DP_IsSourceCodecValidAac(p_codec_info)) {

const tA2DP_ENCODER_INTERFACE* A2DP_GetEncoderInterfaceAac(

    const uint8_t* p_codec_info) {

  if (!A2DP_IsCodecValidAac(p_codec_info)) {

    return NULL;

  }



  return &a2dp_encoder_interface_aac;

}



const tA2DP_DECODER_INTERFACE* A2DP_GetDecoderInterfaceAac(const uint8_t* p_codec_info) {

  if (!A2DP_IsSinkCodecValidAac(p_codec_info)) {

const tA2DP_DECODER_INTERFACE* A2DP_GetDecoderInterfaceAac(

    const uint8_t* p_codec_info) {

  if (!A2DP_IsCodecValidAac(p_codec_info)) {

    return NULL;

  }

system/stack/a2dp/a2dp_codec_config.cc

+8 −8
Original line number Diff line number Diff line
@@ -1058,10 +1058,10 @@ bool A2DP_IsSourceCodecValid(const uint8_t* p_codec_info) { 


  switch (codec_type) {

    case A2DP_MEDIA_CT_SBC:

      return A2DP_IsSourceCodecValidSbc(p_codec_info);

      return A2DP_IsCodecValidSbc(p_codec_info);

#if !defined(EXCLUDE_NONSTANDARD_CODECS)

    case A2DP_MEDIA_CT_AAC:

      return A2DP_IsSourceCodecValidAac(p_codec_info);

      return A2DP_IsCodecValidAac(p_codec_info);

    case A2DP_MEDIA_CT_NON_A2DP:

      return A2DP_IsVendorSourceCodecValid(p_codec_info);

#endif
@@ -1077,10 +1077,10 @@ bool A2DP_IsSinkCodecValid(const uint8_t* p_codec_info) { 


  switch (codec_type) {

    case A2DP_MEDIA_CT_SBC:

      return A2DP_IsSinkCodecValidSbc(p_codec_info);

      return A2DP_IsCodecValidSbc(p_codec_info);

#if !defined(EXCLUDE_NONSTANDARD_CODECS)

    case A2DP_MEDIA_CT_AAC:

      return A2DP_IsSinkCodecValidAac(p_codec_info);

      return A2DP_IsCodecValidAac(p_codec_info);

    case A2DP_MEDIA_CT_NON_A2DP:

      return A2DP_IsVendorSinkCodecValid(p_codec_info);

#endif
@@ -1096,10 +1096,10 @@ bool A2DP_IsPeerSourceCodecValid(const uint8_t* p_codec_info) { 


  switch (codec_type) {

    case A2DP_MEDIA_CT_SBC:

      return A2DP_IsPeerSourceCodecValidSbc(p_codec_info);

      return A2DP_IsCodecValidSbc(p_codec_info);

#if !defined(EXCLUDE_NONSTANDARD_CODECS)

    case A2DP_MEDIA_CT_AAC:

      return A2DP_IsPeerSourceCodecValidAac(p_codec_info);

      return A2DP_IsCodecValidAac(p_codec_info);

    case A2DP_MEDIA_CT_NON_A2DP:

      return A2DP_IsVendorPeerSourceCodecValid(p_codec_info);

#endif
@@ -1115,10 +1115,10 @@ bool A2DP_IsPeerSinkCodecValid(const uint8_t* p_codec_info) { 


  switch (codec_type) {

    case A2DP_MEDIA_CT_SBC:

      return A2DP_IsPeerSinkCodecValidSbc(p_codec_info);

      return A2DP_IsCodecValidSbc(p_codec_info);

#if !defined(EXCLUDE_NONSTANDARD_CODECS)

    case A2DP_MEDIA_CT_AAC:

      return A2DP_IsPeerSinkCodecValidAac(p_codec_info);

      return A2DP_IsCodecValidAac(p_codec_info);

    case A2DP_MEDIA_CT_NON_A2DP:

      return A2DP_IsVendorPeerSinkCodecValid(p_codec_info);

#endif

system/stack/a2dp/a2dp_sbc.cc

+13 −33
Original line number Diff line number Diff line
@@ -302,31 +302,7 @@ UNUSED_ATTR static void A2DP_ParseMplHeaderSbc(uint8_t* p_src, bool* p_frag, boo 


const char* A2DP_CodecNameSbc(const uint8_t* /* p_codec_info */) { return "SBC"; }



bool A2DP_IsSourceCodecValidSbc(const uint8_t* p_codec_info) {

  tA2DP_SBC_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */

  return (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||

         (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);

}



bool A2DP_IsSinkCodecValidSbc(const uint8_t* p_codec_info) {

  tA2DP_SBC_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */

  return (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||

         (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);

}



bool A2DP_IsPeerSourceCodecValidSbc(const uint8_t* p_codec_info) {

  tA2DP_SBC_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */

  return (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||

         (A2DP_ParseInfoSbc(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);

}



bool A2DP_IsPeerSinkCodecValidSbc(const uint8_t* p_codec_info) {

bool A2DP_IsCodecValidSbc(const uint8_t* p_codec_info) {

  tA2DP_SBC_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */
@@ -789,16 +765,18 @@ std::string A2DP_CodecInfoStringSbc(const uint8_t* p_codec_info) { 
  return res.str();

}



const tA2DP_ENCODER_INTERFACE* A2DP_GetEncoderInterfaceSbc(const uint8_t* p_codec_info) {

  if (!A2DP_IsSourceCodecValidSbc(p_codec_info)) {

const tA2DP_ENCODER_INTERFACE* A2DP_GetEncoderInterfaceSbc(

    const uint8_t* p_codec_info) {

  if (!A2DP_IsCodecValidSbc(p_codec_info)) {

    return NULL;

  }



  return &a2dp_encoder_interface_sbc;

}



const tA2DP_DECODER_INTERFACE* A2DP_GetDecoderInterfaceSbc(const uint8_t* p_codec_info) {

  if (!A2DP_IsSinkCodecValidSbc(p_codec_info)) {

const tA2DP_DECODER_INTERFACE* A2DP_GetDecoderInterfaceSbc(

    const uint8_t* p_codec_info) {

  if (!A2DP_IsCodecValidSbc(p_codec_info)) {

    return NULL;

  }
@@ -1108,12 +1086,14 @@ bool A2dpCodecConfigSbcBase::setCodecConfig(const uint8_t* p_peer_codec_info, bo 
  // capability.

  if (is_capability) {

    if (is_source_) {

      if (A2DP_IsPeerSinkCodecValidSbc(ota_codec_peer_config_)) {

        status = A2DP_ParseInfoSbc(&peer_info_cie, ota_codec_peer_config_, false);

      if (A2DP_IsCodecValidSbc(ota_codec_peer_config_)) {

        status =

            A2DP_ParseInfoSbc(&peer_info_cie, ota_codec_peer_config_, false);

      }

    } else {

      if (A2DP_IsPeerSourceCodecValidSbc(ota_codec_peer_config_)) {

        status = A2DP_ParseInfoSbc(&peer_info_cie, ota_codec_peer_config_, false);

      if (A2DP_IsCodecValidSbc(ota_codec_peer_config_)) {

        status =

            A2DP_ParseInfoSbc(&peer_info_cie, ota_codec_peer_config_, false);

      }

    }

    if (status != A2DP_SUCCESS) {

system/stack/a2dp/a2dp_vendor.cc

+20 −16
Original line number Diff line number Diff line
@@ -34,23 +34,25 @@ bool A2DP_IsVendorSourceCodecValid(const uint8_t* p_codec_info) { 
  uint16_t codec_id = A2DP_VendorCodecGetCodecId(p_codec_info);



  // Check for aptX

  if (vendor_id == A2DP_APTX_VENDOR_ID && codec_id == A2DP_APTX_CODEC_ID_BLUETOOTH) {

    return A2DP_IsVendorSourceCodecValidAptx(p_codec_info);

  if (vendor_id == A2DP_APTX_VENDOR_ID &&

      codec_id == A2DP_APTX_CODEC_ID_BLUETOOTH) {

    return A2DP_IsCodecValidAptx(p_codec_info);

  }



  // Check for aptX-HD

  if (vendor_id == A2DP_APTX_HD_VENDOR_ID && codec_id == A2DP_APTX_HD_CODEC_ID_BLUETOOTH) {

    return A2DP_IsVendorSourceCodecValidAptxHd(p_codec_info);

  if (vendor_id == A2DP_APTX_HD_VENDOR_ID &&

      codec_id == A2DP_APTX_HD_CODEC_ID_BLUETOOTH) {

    return A2DP_IsCodecValidAptxHd(p_codec_info);

  }



  // Check for LDAC

  if (vendor_id == A2DP_LDAC_VENDOR_ID && codec_id == A2DP_LDAC_CODEC_ID) {

    return A2DP_IsVendorSourceCodecValidLdac(p_codec_info);

    return A2DP_IsCodecValidLdac(p_codec_info);

  }



  // Check for Opus

  if (vendor_id == A2DP_OPUS_VENDOR_ID && codec_id == A2DP_OPUS_CODEC_ID) {

    return A2DP_IsVendorSourceCodecValidOpus(p_codec_info);

    return A2DP_IsCodecValidOpus(p_codec_info);

  }



  // Add checks based on <vendor_id, codec_id>
@@ -67,12 +69,12 @@ bool A2DP_IsVendorSinkCodecValid(const uint8_t* p_codec_info) { 


  // Check for LDAC

  if (vendor_id == A2DP_LDAC_VENDOR_ID && codec_id == A2DP_LDAC_CODEC_ID) {

    return A2DP_IsVendorSinkCodecValidLdac(p_codec_info);

    return A2DP_IsCodecValidLdac(p_codec_info);

  }



  // Check for Opus

  if (vendor_id == A2DP_OPUS_VENDOR_ID && codec_id == A2DP_OPUS_CODEC_ID) {

    return A2DP_IsVendorSinkCodecValidOpus(p_codec_info);

    return A2DP_IsCodecValidOpus(p_codec_info);

  }



  return false;
@@ -87,12 +89,12 @@ bool A2DP_IsVendorPeerSourceCodecValid(const uint8_t* p_codec_info) { 


  // Check for LDAC

  if (vendor_id == A2DP_LDAC_VENDOR_ID && codec_id == A2DP_LDAC_CODEC_ID) {

    return A2DP_IsVendorPeerSourceCodecValidLdac(p_codec_info);

    return A2DP_IsCodecValidLdac(p_codec_info);

  }



  // Check for Opus

  if (vendor_id == A2DP_OPUS_VENDOR_ID && codec_id == A2DP_OPUS_CODEC_ID) {

    return A2DP_IsVendorPeerSourceCodecValidOpus(p_codec_info);

    return A2DP_IsCodecValidOpus(p_codec_info);

  }



  return false;
@@ -103,23 +105,25 @@ bool A2DP_IsVendorPeerSinkCodecValid(const uint8_t* p_codec_info) { 
  uint16_t codec_id = A2DP_VendorCodecGetCodecId(p_codec_info);



  // Check for aptX

  if (vendor_id == A2DP_APTX_VENDOR_ID && codec_id == A2DP_APTX_CODEC_ID_BLUETOOTH) {

    return A2DP_IsVendorPeerSinkCodecValidAptx(p_codec_info);

  if (vendor_id == A2DP_APTX_VENDOR_ID &&

      codec_id == A2DP_APTX_CODEC_ID_BLUETOOTH) {

    return A2DP_IsCodecValidAptx(p_codec_info);

  }



  // Check for aptX-HD

  if (vendor_id == A2DP_APTX_HD_VENDOR_ID && codec_id == A2DP_APTX_HD_CODEC_ID_BLUETOOTH) {

    return A2DP_IsVendorPeerSinkCodecValidAptxHd(p_codec_info);

  if (vendor_id == A2DP_APTX_HD_VENDOR_ID &&

      codec_id == A2DP_APTX_HD_CODEC_ID_BLUETOOTH) {

    return A2DP_IsCodecValidAptxHd(p_codec_info);

  }



  // Check for LDAC

  if (vendor_id == A2DP_LDAC_VENDOR_ID && codec_id == A2DP_LDAC_CODEC_ID) {

    return A2DP_IsVendorPeerSinkCodecValidLdac(p_codec_info);

    return A2DP_IsCodecValidLdac(p_codec_info);

  }



  // Check for Opus

  if (vendor_id == A2DP_OPUS_VENDOR_ID && codec_id == A2DP_OPUS_CODEC_ID) {

    return A2DP_IsVendorPeerSinkCodecValidOpus(p_codec_info);

    return A2DP_IsCodecValidOpus(p_codec_info);

  }



  // Add checks based on <vendor_id, codec_id>

system/stack/a2dp/a2dp_vendor_aptx.cc

+4 −11
Original line number Diff line number Diff line
@@ -177,15 +177,7 @@ static tA2DP_STATUS A2DP_ParseInfoAptx(tA2DP_APTX_CIE* p_ie, const uint8_t* p_co 
  return A2DP_SUCCESS;

}



bool A2DP_IsVendorSourceCodecValidAptx(const uint8_t* p_codec_info) {

  tA2DP_APTX_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */

  return (A2DP_ParseInfoAptx(&cfg_cie, p_codec_info, false) == A2DP_SUCCESS) ||

         (A2DP_ParseInfoAptx(&cfg_cie, p_codec_info, true) == A2DP_SUCCESS);

}



bool A2DP_IsVendorPeerSinkCodecValidAptx(const uint8_t* p_codec_info) {

bool A2DP_IsCodecValidAptx(const uint8_t* p_codec_info) {

  tA2DP_APTX_CIE cfg_cie;



  /* Use a liberal check when parsing the codec info */
@@ -385,8 +377,9 @@ std::string A2DP_VendorCodecInfoStringAptx(const uint8_t* p_codec_info) { 
  return res.str();

}



const tA2DP_ENCODER_INTERFACE* A2DP_VendorGetEncoderInterfaceAptx(const uint8_t* p_codec_info) {

  if (!A2DP_IsVendorSourceCodecValidAptx(p_codec_info)) {

const tA2DP_ENCODER_INTERFACE* A2DP_VendorGetEncoderInterfaceAptx(

    const uint8_t* p_codec_info) {

  if (!A2DP_IsCodecValidAptx(p_codec_info)) {

    return NULL;

  }