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

Commit 1a55e21f authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "Decrese the default verbosity for A2DP codec info logs"

parents ab379fcf f461b10f

system/stack/a2dp/a2dp_aac.cc

+34 −34
Original line number Original line Diff line number Diff line
@@ -244,16 +244,16 @@ static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilityAac( 




  /* verify that each parameter is in range */

  /* verify that each parameter is in range */





  LOG_DEBUG(LOG_TAG, "%s: Object Type peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: Object Type peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.objectType, p_cap->objectType);

              cfg_cie.objectType, p_cap->objectType);

  LOG_DEBUG(LOG_TAG, "%s: Sample Rate peer: %u, capability %u", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: Sample Rate peer: %u, capability %u", __func__,

              cfg_cie.sampleRate, p_cap->sampleRate);

              cfg_cie.sampleRate, p_cap->sampleRate);

  LOG_DEBUG(LOG_TAG, "%s: Channel Mode peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: Channel Mode peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.channelMode, p_cap->channelMode);

              cfg_cie.channelMode, p_cap->channelMode);

  LOG_DEBUG(

  LOG_VERBOSE(

      LOG_TAG, "%s: Variable Bit Rate Support peer: 0x%x, capability 0x%x",

      LOG_TAG, "%s: Variable Bit Rate Support peer: 0x%x, capability 0x%x",

      __func__, cfg_cie.variableBitRateSupport, p_cap->variableBitRateSupport);

      __func__, cfg_cie.variableBitRateSupport, p_cap->variableBitRateSupport);

  LOG_DEBUG(LOG_TAG, "%s: Bit Rate peer: %u, capability %u", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: Bit Rate peer: %u, capability %u", __func__,

              cfg_cie.bitRate, p_cap->bitRate);

              cfg_cie.bitRate, p_cap->bitRate);





  /* Object Type */

  /* Object Type */
@@ -533,7 +533,7 @@ bool A2DP_DumpCodecInfoAac(const uint8_t* p_codec_info) { 
  tA2DP_STATUS a2dp_status;

  tA2DP_STATUS a2dp_status;

  tA2DP_AAC_CIE aac_cie;

  tA2DP_AAC_CIE aac_cie;





  LOG_DEBUG(LOG_TAG, "%s", __func__);

  LOG_VERBOSE(LOG_TAG, "%s", __func__);





  a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, true);

  a2dp_status = A2DP_ParseInfoAac(&aac_cie, p_codec_info, true);

  if (a2dp_status != A2DP_SUCCESS) {

  if (a2dp_status != A2DP_SUCCESS) {
@@ -541,70 +541,70 @@ bool A2DP_DumpCodecInfoAac(const uint8_t* p_codec_info) { 
    return false;

    return false;

  }

  }





  LOG_DEBUG(LOG_TAG, "\tobjectType: 0x%x", aac_cie.objectType);

  LOG_VERBOSE(LOG_TAG, "\tobjectType: 0x%x", aac_cie.objectType);

  if (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG2_LC) {

  if (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG2_LC) {

    LOG_DEBUG(LOG_TAG, "\tobjectType: (MPEG-2 AAC LC)");

    LOG_VERBOSE(LOG_TAG, "\tobjectType: (MPEG-2 AAC LC)");

  }

  }

  if (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_LC) {

  if (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_LC) {

    LOG_DEBUG(LOG_TAG, "\tobjectType: (MPEG-4 AAC LC)");

    LOG_VERBOSE(LOG_TAG, "\tobjectType: (MPEG-4 AAC LC)");

  }

  }

  if (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_LTP) {

  if (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_LTP) {

    LOG_DEBUG(LOG_TAG, "\tobjectType: (MPEG-4 AAC LTP)");

    LOG_VERBOSE(LOG_TAG, "\tobjectType: (MPEG-4 AAC LTP)");

  }

  }

  if (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE) {

  if (aac_cie.objectType & A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE) {

    LOG_DEBUG(LOG_TAG, "\tobjectType: (MPEG-4 AAC Scalable)");

    LOG_VERBOSE(LOG_TAG, "\tobjectType: (MPEG-4 AAC Scalable)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tsamp_freq: 0x%x", aac_cie.sampleRate);

  LOG_VERBOSE(LOG_TAG, "\tsamp_freq: 0x%x", aac_cie.sampleRate);

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_8000) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_8000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (8000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (8000)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_11025) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_11025) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (11025)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (11025)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_12000) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_12000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (12000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (12000)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_16000) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_16000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (16000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (16000)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_22050) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_22050) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (22050)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (22050)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_24000) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_24000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (24000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (24000)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_32000) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_32000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (32000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (32000)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_44100) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (44100)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (44100)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_48000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (48000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (48000)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_64000) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_64000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (64000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (64000)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_88200) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (88200)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (88200)");

  }

  }

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) {

  if (aac_cie.sampleRate & A2DP_AAC_SAMPLING_FREQ_96000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (96000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (96000)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tch_mode: 0x%x", aac_cie.channelMode);

  LOG_VERBOSE(LOG_TAG, "\tch_mode: 0x%x", aac_cie.channelMode);

  if (aac_cie.channelMode == A2DP_AAC_CHANNEL_MODE_MONO) {

  if (aac_cie.channelMode == A2DP_AAC_CHANNEL_MODE_MONO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Mono)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Mono)");

  }

  }

  if (aac_cie.channelMode == A2DP_AAC_CHANNEL_MODE_STEREO) {

  if (aac_cie.channelMode == A2DP_AAC_CHANNEL_MODE_STEREO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Stereo)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Stereo)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tvariableBitRateSupport: %s",

  LOG_VERBOSE(LOG_TAG, "\tvariableBitRateSupport: %s",

              (aac_cie.variableBitRateSupport != 0) ? "true" : "false");

              (aac_cie.variableBitRateSupport != 0) ? "true" : "false");





  LOG_DEBUG(LOG_TAG, "\tbitRate: %u", aac_cie.bitRate);

  LOG_VERBOSE(LOG_TAG, "\tbitRate: %u", aac_cie.bitRate);





  return true;

  return true;

}

}

system/stack/a2dp/a2dp_sbc.cc

+38 −38
Original line number Original line Diff line number Diff line
@@ -334,19 +334,19 @@ static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilitySbc( 




  /* verify that each parameter is in range */

  /* verify that each parameter is in range */





  LOG_DEBUG(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.samp_freq, p_cap->samp_freq);

              cfg_cie.samp_freq, p_cap->samp_freq);

  LOG_DEBUG(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.ch_mode, p_cap->ch_mode);

              cfg_cie.ch_mode, p_cap->ch_mode);

  LOG_DEBUG(LOG_TAG, "%s: BLOCK_LEN peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: BLOCK_LEN peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.block_len, p_cap->block_len);

              cfg_cie.block_len, p_cap->block_len);

  LOG_DEBUG(LOG_TAG, "%s: SUB_BAND peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: SUB_BAND peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.num_subbands, p_cap->num_subbands);

              cfg_cie.num_subbands, p_cap->num_subbands);

  LOG_DEBUG(LOG_TAG, "%s: ALLOC_METHOD peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: ALLOC_METHOD peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.alloc_method, p_cap->alloc_method);

              cfg_cie.alloc_method, p_cap->alloc_method);

  LOG_DEBUG(LOG_TAG, "%s: MIN_BitPool peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: MIN_BitPool peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.min_bitpool, p_cap->min_bitpool);

              cfg_cie.min_bitpool, p_cap->min_bitpool);

  LOG_DEBUG(LOG_TAG, "%s: MAX_BitPool peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: MAX_BitPool peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.max_bitpool, p_cap->max_bitpool);

              cfg_cie.max_bitpool, p_cap->max_bitpool);





  /* sampling frequency */

  /* sampling frequency */
@@ -871,7 +871,7 @@ bool A2DP_DumpCodecInfoSbc(const uint8_t* p_codec_info) { 
  tA2DP_STATUS a2dp_status;

  tA2DP_STATUS a2dp_status;

  tA2DP_SBC_CIE sbc_cie;

  tA2DP_SBC_CIE sbc_cie;





  LOG_DEBUG(LOG_TAG, "%s", __func__);

  LOG_VERBOSE(LOG_TAG, "%s", __func__);





  a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, true);

  a2dp_status = A2DP_ParseInfoSbc(&sbc_cie, p_codec_info, true);

  if (a2dp_status != A2DP_SUCCESS) {

  if (a2dp_status != A2DP_SUCCESS) {
@@ -879,65 +879,65 @@ bool A2DP_DumpCodecInfoSbc(const uint8_t* p_codec_info) { 
    return false;

    return false;

  }

  }





  LOG_DEBUG(LOG_TAG, "\tsamp_freq: 0x%x", sbc_cie.samp_freq);

  LOG_VERBOSE(LOG_TAG, "\tsamp_freq: 0x%x", sbc_cie.samp_freq);

  if (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_16) {

  if (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_16) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (16000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (16000)");

  }

  }

  if (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_32) {

  if (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_32) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (32000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (32000)");

  }

  }

  if (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_44) {

  if (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_44) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (44100)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (44100)");

  }

  }

  if (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_48) {

  if (sbc_cie.samp_freq & A2DP_SBC_IE_SAMP_FREQ_48) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (48000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (48000)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tch_mode: 0x%x", sbc_cie.ch_mode);

  LOG_VERBOSE(LOG_TAG, "\tch_mode: 0x%x", sbc_cie.ch_mode);

  if (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_MONO) {

  if (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_MONO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Mono)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Mono)");

  }

  }

  if (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_DUAL) {

  if (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_DUAL) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Dual)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Dual)");

  }

  }

  if (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_STEREO) {

  if (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_STEREO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Stereo)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Stereo)");

  }

  }

  if (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_JOINT) {

  if (sbc_cie.ch_mode & A2DP_SBC_IE_CH_MD_JOINT) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Joint)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Joint)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tblock_len: 0x%x", sbc_cie.block_len);

  LOG_VERBOSE(LOG_TAG, "\tblock_len: 0x%x", sbc_cie.block_len);

  if (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_4) {

  if (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_4) {

    LOG_DEBUG(LOG_TAG, "\tblock_len: (4)");

    LOG_VERBOSE(LOG_TAG, "\tblock_len: (4)");

  }

  }

  if (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_8) {

  if (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_8) {

    LOG_DEBUG(LOG_TAG, "\tblock_len: (8)");

    LOG_VERBOSE(LOG_TAG, "\tblock_len: (8)");

  }

  }

  if (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_12) {

  if (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_12) {

    LOG_DEBUG(LOG_TAG, "\tblock_len: (12)");

    LOG_VERBOSE(LOG_TAG, "\tblock_len: (12)");

  }

  }

  if (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_16) {

  if (sbc_cie.block_len & A2DP_SBC_IE_BLOCKS_16) {

    LOG_DEBUG(LOG_TAG, "\tblock_len: (16)");

    LOG_VERBOSE(LOG_TAG, "\tblock_len: (16)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tnum_subbands: 0x%x", sbc_cie.num_subbands);

  LOG_VERBOSE(LOG_TAG, "\tnum_subbands: 0x%x", sbc_cie.num_subbands);

  if (sbc_cie.num_subbands & A2DP_SBC_IE_SUBBAND_4) {

  if (sbc_cie.num_subbands & A2DP_SBC_IE_SUBBAND_4) {

    LOG_DEBUG(LOG_TAG, "\tnum_subbands: (4)");

    LOG_VERBOSE(LOG_TAG, "\tnum_subbands: (4)");

  }

  }

  if (sbc_cie.num_subbands & A2DP_SBC_IE_SUBBAND_8) {

  if (sbc_cie.num_subbands & A2DP_SBC_IE_SUBBAND_8) {

    LOG_DEBUG(LOG_TAG, "\tnum_subbands: (8)");

    LOG_VERBOSE(LOG_TAG, "\tnum_subbands: (8)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\talloc_method: 0x%x)", sbc_cie.alloc_method);

  LOG_VERBOSE(LOG_TAG, "\talloc_method: 0x%x)", sbc_cie.alloc_method);

  if (sbc_cie.alloc_method & A2DP_SBC_IE_ALLOC_MD_S) {

  if (sbc_cie.alloc_method & A2DP_SBC_IE_ALLOC_MD_S) {

    LOG_DEBUG(LOG_TAG, "\talloc_method: (SNR)");

    LOG_VERBOSE(LOG_TAG, "\talloc_method: (SNR)");

  }

  }

  if (sbc_cie.alloc_method & A2DP_SBC_IE_ALLOC_MD_L) {

  if (sbc_cie.alloc_method & A2DP_SBC_IE_ALLOC_MD_L) {

    LOG_DEBUG(LOG_TAG, "\talloc_method: (Loundess)");

    LOG_VERBOSE(LOG_TAG, "\talloc_method: (Loundess)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tBit pool Min:%d Max:%d", sbc_cie.min_bitpool,

  LOG_VERBOSE(LOG_TAG, "\tBit pool Min:%d Max:%d", sbc_cie.min_bitpool,

              sbc_cie.max_bitpool);

              sbc_cie.max_bitpool);





  return true;

  return true;

system/stack/a2dp/a2dp_vendor_aptx.cc

+11 −11
Original line number Original line Diff line number Diff line
@@ -204,9 +204,9 @@ static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilityAptx( 




  /* verify that each parameter is in range */

  /* verify that each parameter is in range */





  LOG_DEBUG(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.sampleRate, p_cap->sampleRate);

              cfg_cie.sampleRate, p_cap->sampleRate);

  LOG_DEBUG(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.channelMode, p_cap->channelMode);

              cfg_cie.channelMode, p_cap->channelMode);





  /* sampling frequency */

  /* sampling frequency */
@@ -336,7 +336,7 @@ bool A2DP_VendorDumpCodecInfoAptx(const uint8_t* p_codec_info) { 
  tA2DP_STATUS a2dp_status;

  tA2DP_STATUS a2dp_status;

  tA2DP_APTX_CIE aptx_cie;

  tA2DP_APTX_CIE aptx_cie;





  LOG_DEBUG(LOG_TAG, "%s", __func__);

  LOG_VERBOSE(LOG_TAG, "%s", __func__);





  a2dp_status = A2DP_ParseInfoAptx(&aptx_cie, p_codec_info, true);

  a2dp_status = A2DP_ParseInfoAptx(&aptx_cie, p_codec_info, true);

  if (a2dp_status != A2DP_SUCCESS) {

  if (a2dp_status != A2DP_SUCCESS) {
@@ -344,20 +344,20 @@ bool A2DP_VendorDumpCodecInfoAptx(const uint8_t* p_codec_info) { 
    return false;

    return false;

  }

  }





  LOG_DEBUG(LOG_TAG, "\tsamp_freq: 0x%x", aptx_cie.sampleRate);

  LOG_VERBOSE(LOG_TAG, "\tsamp_freq: 0x%x", aptx_cie.sampleRate);

  if (aptx_cie.sampleRate & A2DP_APTX_SAMPLERATE_44100) {

  if (aptx_cie.sampleRate & A2DP_APTX_SAMPLERATE_44100) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (44100)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (44100)");

  }

  }

  if (aptx_cie.sampleRate & A2DP_APTX_SAMPLERATE_48000) {

  if (aptx_cie.sampleRate & A2DP_APTX_SAMPLERATE_48000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (48000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (48000)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tch_mode: 0x%x", aptx_cie.channelMode);

  LOG_VERBOSE(LOG_TAG, "\tch_mode: 0x%x", aptx_cie.channelMode);

  if (aptx_cie.channelMode & A2DP_APTX_CHANNELS_MONO) {

  if (aptx_cie.channelMode & A2DP_APTX_CHANNELS_MONO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Mono)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Mono)");

  }

  }

  if (aptx_cie.channelMode & A2DP_APTX_CHANNELS_STEREO) {

  if (aptx_cie.channelMode & A2DP_APTX_CHANNELS_STEREO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Stereo)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Stereo)");

  }

  }





  return true;

  return true;

system/stack/a2dp/a2dp_vendor_aptx_hd.cc

+11 −11
Original line number Original line Diff line number Diff line
@@ -222,9 +222,9 @@ static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilityAptxHd( 




  /* verify that each parameter is in range */

  /* verify that each parameter is in range */





  LOG_DEBUG(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.sampleRate, p_cap->sampleRate);

              cfg_cie.sampleRate, p_cap->sampleRate);

  LOG_DEBUG(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.channelMode, p_cap->channelMode);

              cfg_cie.channelMode, p_cap->channelMode);





  /* sampling frequency */

  /* sampling frequency */
@@ -352,7 +352,7 @@ bool A2DP_VendorDumpCodecInfoAptxHd(const uint8_t* p_codec_info) { 
  tA2DP_STATUS a2dp_status;

  tA2DP_STATUS a2dp_status;

  tA2DP_APTX_HD_CIE aptx_hd_cie;

  tA2DP_APTX_HD_CIE aptx_hd_cie;





  LOG_DEBUG(LOG_TAG, "%s", __func__);

  LOG_VERBOSE(LOG_TAG, "%s", __func__);





  a2dp_status = A2DP_ParseInfoAptxHd(&aptx_hd_cie, p_codec_info, true);

  a2dp_status = A2DP_ParseInfoAptxHd(&aptx_hd_cie, p_codec_info, true);

  if (a2dp_status != A2DP_SUCCESS) {

  if (a2dp_status != A2DP_SUCCESS) {
@@ -361,20 +361,20 @@ bool A2DP_VendorDumpCodecInfoAptxHd(const uint8_t* p_codec_info) { 
    return false;

    return false;

  }

  }





  LOG_DEBUG(LOG_TAG, "\tsamp_freq: 0x%x", aptx_hd_cie.sampleRate);

  LOG_VERBOSE(LOG_TAG, "\tsamp_freq: 0x%x", aptx_hd_cie.sampleRate);

  if (aptx_hd_cie.sampleRate & A2DP_APTX_HD_SAMPLERATE_44100) {

  if (aptx_hd_cie.sampleRate & A2DP_APTX_HD_SAMPLERATE_44100) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (44100)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (44100)");

  }

  }

  if (aptx_hd_cie.sampleRate & A2DP_APTX_HD_SAMPLERATE_48000) {

  if (aptx_hd_cie.sampleRate & A2DP_APTX_HD_SAMPLERATE_48000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (48000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (48000)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tch_mode: 0x%x", aptx_hd_cie.channelMode);

  LOG_VERBOSE(LOG_TAG, "\tch_mode: 0x%x", aptx_hd_cie.channelMode);

  if (aptx_hd_cie.channelMode & A2DP_APTX_HD_CHANNELS_MONO) {

  if (aptx_hd_cie.channelMode & A2DP_APTX_HD_CHANNELS_MONO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Mono)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Mono)");

  }

  }

  if (aptx_hd_cie.channelMode & A2DP_APTX_HD_CHANNELS_STEREO) {

  if (aptx_hd_cie.channelMode & A2DP_APTX_HD_CHANNELS_STEREO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Stereo)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Stereo)");

  }

  }





  return true;

  return true;

system/stack/a2dp/a2dp_vendor_ldac.cc

+16 −16
Original line number Original line Diff line number Diff line
@@ -230,9 +230,9 @@ static tA2DP_STATUS A2DP_CodecInfoMatchesCapabilityLdac( 




  /* verify that each parameter is in range */

  /* verify that each parameter is in range */





  LOG_DEBUG(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: FREQ peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.sampleRate, p_cap->sampleRate);

              cfg_cie.sampleRate, p_cap->sampleRate);

  LOG_DEBUG(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,

  LOG_VERBOSE(LOG_TAG, "%s: CH_MODE peer: 0x%x, capability 0x%x", __func__,

              cfg_cie.channelMode, p_cap->channelMode);

              cfg_cie.channelMode, p_cap->channelMode);





  /* sampling frequency */

  /* sampling frequency */
@@ -402,7 +402,7 @@ bool A2DP_VendorDumpCodecInfoLdac(const uint8_t* p_codec_info) { 
  tA2DP_STATUS a2dp_status;

  tA2DP_STATUS a2dp_status;

  tA2DP_LDAC_CIE ldac_cie;

  tA2DP_LDAC_CIE ldac_cie;





  LOG_DEBUG(LOG_TAG, "%s", __func__);

  LOG_VERBOSE(LOG_TAG, "%s", __func__);





  a2dp_status = A2DP_ParseInfoLdac(&ldac_cie, p_codec_info, true);

  a2dp_status = A2DP_ParseInfoLdac(&ldac_cie, p_codec_info, true);

  if (a2dp_status != A2DP_SUCCESS) {

  if (a2dp_status != A2DP_SUCCESS) {
@@ -410,35 +410,35 @@ bool A2DP_VendorDumpCodecInfoLdac(const uint8_t* p_codec_info) { 
    return false;

    return false;

  }

  }





  LOG_DEBUG(LOG_TAG, "\tsamp_freq: 0x%x", ldac_cie.sampleRate);

  LOG_VERBOSE(LOG_TAG, "\tsamp_freq: 0x%x", ldac_cie.sampleRate);

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_44100) {

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_44100) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (44100)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (44100)");

  }

  }

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_48000) {

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_48000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (48000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (48000)");

  }

  }

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_88200) {

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_88200) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (88200)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (88200)");

  }

  }

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_96000) {

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_96000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (96000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (96000)");

  }

  }

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_176400) {

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_176400) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (176400)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (176400)");

  }

  }

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_192000) {

  if (ldac_cie.sampleRate & A2DP_LDAC_SAMPLING_FREQ_192000) {

    LOG_DEBUG(LOG_TAG, "\tsamp_freq: (192000)");

    LOG_VERBOSE(LOG_TAG, "\tsamp_freq: (192000)");

  }

  }





  LOG_DEBUG(LOG_TAG, "\tch_mode: 0x%x", ldac_cie.channelMode);

  LOG_VERBOSE(LOG_TAG, "\tch_mode: 0x%x", ldac_cie.channelMode);

  if (ldac_cie.channelMode & A2DP_LDAC_CHANNEL_MODE_MONO) {

  if (ldac_cie.channelMode & A2DP_LDAC_CHANNEL_MODE_MONO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Mono)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Mono)");

  }

  }

  if (ldac_cie.channelMode & A2DP_LDAC_CHANNEL_MODE_DUAL) {

  if (ldac_cie.channelMode & A2DP_LDAC_CHANNEL_MODE_DUAL) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Dual)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Dual)");

  }

  }

  if (ldac_cie.channelMode & A2DP_LDAC_CHANNEL_MODE_STEREO) {

  if (ldac_cie.channelMode & A2DP_LDAC_CHANNEL_MODE_STEREO) {

    LOG_DEBUG(LOG_TAG, "\tch_mode: (Stereo)");

    LOG_VERBOSE(LOG_TAG, "\tch_mode: (Stereo)");

  }

  }





  return true;

  return true;