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

Commit ed6c24fe authored by Pavlin Radoslavov's avatar Pavlin Radoslavov
Browse files

Format A2DP-related code with clang-format 

clang-format -style=file -i stack/a2dp/a2dp_* stack/include/a2dp_* \
        btif/include/btif_a2dp* btif/src/btif_a2dp*

Test: top-level compilation and running A2DP
Change-Id: I66f0a047192b783ac0147def480754daf617dd8d
parent abecd059

system/btif/src/btif_a2dp.cc

+71 −79
Original line number Diff line number Diff line
@@ -24,18 +24,16 @@ 
#include "audio_a2dp_hw.h"

#include "bt_common.h"

#include "bta_av_api.h"

#include "btif_av.h"

#include "btif_a2dp.h"

#include "btif_a2dp_control.h"

#include "btif_a2dp_sink.h"

#include "btif_a2dp_source.h"

#include "btif_av.h"

#include "btif_util.h"

#include "osi/include/log.h"



void btif_a2dp_on_idle(void)

{

    APPL_TRACE_EVENT("## ON A2DP IDLE ## peer_sep = %d",

                     btif_av_get_peer_sep());

void btif_a2dp_on_idle(void) {

  APPL_TRACE_EVENT("## ON A2DP IDLE ## peer_sep = %d", btif_av_get_peer_sep());

  if (btif_av_get_peer_sep() == AVDT_TSEP_SNK) {

    btif_a2dp_source_on_idle();

  } else if (btif_av_get_peer_sep() == AVDT_TSEP_SRC) {
@@ -43,8 +41,7 @@ void btif_a2dp_on_idle(void) 
  }

}



bool btif_a2dp_on_started(tBTA_AV_START *p_av_start, bool pending_start)

{

bool btif_a2dp_on_started(tBTA_AV_START* p_av_start, bool pending_start) {

  bool ack = false;



  APPL_TRACE_EVENT("## ON A2DP STARTED ##");
@@ -72,16 +69,15 @@ bool btif_a2dp_on_started(tBTA_AV_START *p_av_start, bool pending_start) 
      /* media task is autostarted upon a2dp audiopath connection */

    }

  } else if (pending_start) {

        APPL_TRACE_WARNING("%s: A2DP start request failed: status = %d",

                           __func__, p_av_start->status);

    APPL_TRACE_WARNING("%s: A2DP start request failed: status = %d", __func__,

                       p_av_start->status);

    btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);

    ack = true;

  }

  return ack;

}



void btif_a2dp_on_stopped(tBTA_AV_SUSPEND *p_av_suspend)

{

void btif_a2dp_on_stopped(tBTA_AV_SUSPEND* p_av_suspend) {

  APPL_TRACE_EVENT("## ON A2DP STOPPED ##");



  if (btif_av_get_peer_sep() == AVDT_TSEP_SRC) {
@@ -92,8 +88,7 @@ void btif_a2dp_on_stopped(tBTA_AV_SUSPEND *p_av_suspend) 
  btif_a2dp_source_on_stopped(p_av_suspend);

}



void btif_a2dp_on_suspended(tBTA_AV_SUSPEND *p_av_suspend)

{

void btif_a2dp_on_suspended(tBTA_AV_SUSPEND* p_av_suspend) {

  APPL_TRACE_EVENT("## ON A2DP SUSPENDED ##");

  if (btif_av_get_peer_sep() == AVDT_TSEP_SRC) {

    btif_a2dp_sink_on_suspended(p_av_suspend);
@@ -102,8 +97,7 @@ void btif_a2dp_on_suspended(tBTA_AV_SUSPEND *p_av_suspend) 
  }

}



void btif_a2dp_on_offload_started(tBTA_AV_STATUS status)

{

void btif_a2dp_on_offload_started(tBTA_AV_STATUS status) {

  tA2DP_CTRL_ACK ack;

  APPL_TRACE_EVENT("%s status %d", __func__, status);
@@ -123,14 +117,12 @@ void btif_a2dp_on_offload_started(tBTA_AV_STATUS status) 
  btif_a2dp_command_ack(ack);

}



void btif_debug_a2dp_dump(int fd)

{

void btif_debug_a2dp_dump(int fd) {

  btif_a2dp_source_debug_dump(fd);

  btif_a2dp_sink_debug_dump(fd);

}



void btif_update_a2dp_metrics(void)

{

void btif_update_a2dp_metrics(void) {

  btif_a2dp_source_update_metrics();

  btif_a2dp_sink_update_metrics();

}

system/btif/src/btif_a2dp_control.cc

+210 −221
Original line number Diff line number Diff line
@@ -41,20 +41,17 @@ static void btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event); 
/* We can have max one command pending */

static tA2DP_CTRL_CMD a2dp_cmd_pending = A2DP_CTRL_CMD_NONE;



void btif_a2dp_control_init(void)

{

void btif_a2dp_control_init(void) {

  UIPC_Init(NULL);

  UIPC_Open(UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb);

}



void btif_a2dp_control_cleanup(void)

{

void btif_a2dp_control_cleanup(void) {

  /* This calls blocks until UIPC is fully closed */

  UIPC_Close(UIPC_CH_ID_ALL);

}



static void btif_a2dp_recv_ctrl_data(void)

{

static void btif_a2dp_recv_ctrl_data(void) {

  tA2DP_CTRL_CMD cmd = A2DP_CTRL_CMD_NONE;

  int n;
@@ -76,8 +73,7 @@ static void btif_a2dp_recv_ctrl_data(void) 
    case A2DP_CTRL_CMD_CHECK_READY:

      if (btif_a2dp_source_media_task_is_shutting_down()) {

        APPL_TRACE_WARNING("%s: A2DP command %s while media task shutting down",

                                   __func__,

                                   audio_a2dp_hw_dump_ctrl_event(cmd));

                           __func__, audio_a2dp_hw_dump_ctrl_event(cmd));

        btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);

        return;

      }
@@ -87,8 +83,7 @@ static void btif_a2dp_recv_ctrl_data(void) 
        btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);

      } else {

        APPL_TRACE_WARNING("%s: A2DP command %s while AV stream is not ready",

                                   __func__,

                                   audio_a2dp_hw_dump_ctrl_event(cmd));

                           __func__, audio_a2dp_hw_dump_ctrl_event(cmd));

        btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);

      }

      break;
@@ -106,8 +101,7 @@ static void btif_a2dp_recv_ctrl_data(void) 


      if (btif_a2dp_source_is_streaming()) {

        APPL_TRACE_WARNING("%s: A2DP command %s while source is streaming",

                                   __func__,

                                   audio_a2dp_hw_dump_ctrl_event(cmd));

                           __func__, audio_a2dp_hw_dump_ctrl_event(cmd));

        btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);

        break;

      }
@@ -172,11 +166,9 @@ static void btif_a2dp_recv_ctrl_data(void) 
      uint8_t channel_count = btif_a2dp_sink_get_channel_count();



      btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);

            UIPC_Send(UIPC_CH_ID_AV_CTRL, 0,

                      reinterpret_cast<uint8_t *>(&sample_rate),

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, reinterpret_cast<uint8_t*>(&sample_rate),

                sizeof(sample_rate));

            UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &channel_count,

                      sizeof(channel_count));

      UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &channel_count, sizeof(channel_count));

      break;

    }
@@ -193,8 +185,8 @@ static void btif_a2dp_recv_ctrl_data(void) 
                   audio_a2dp_hw_dump_ctrl_event(cmd));

}



static void btif_a2dp_ctrl_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, tUIPC_EVENT event)

{

static void btif_a2dp_ctrl_cb(UNUSED_ATTR tUIPC_CH_ID ch_id,

                              tUIPC_EVENT event) {

  APPL_TRACE_DEBUG("A2DP-CTRL-CHANNEL EVENT %s", dump_uipc_event(event));



  switch (event) {
@@ -217,10 +209,9 @@ static void btif_a2dp_ctrl_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, tUIPC_EVENT event) 
  }

}



static void btif_a2dp_data_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, tUIPC_EVENT event)

{

    APPL_TRACE_DEBUG("BTIF MEDIA (A2DP-DATA) EVENT %s",

                     dump_uipc_event(event));

static void btif_a2dp_data_cb(UNUSED_ATTR tUIPC_CH_ID ch_id,

                              tUIPC_EVENT event) {

  APPL_TRACE_DEBUG("BTIF MEDIA (A2DP-DATA) EVENT %s", dump_uipc_event(event));



  switch (event) {

    case UIPC_OPEN_EVT:
@@ -228,8 +219,7 @@ static void btif_a2dp_data_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, tUIPC_EVENT event) 
       * Read directly from media task from here on (keep callback for

       * connection events.

       */

            UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REG_REMOVE_ACTIVE_READSET,

                       NULL);

      UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REG_REMOVE_ACTIVE_READSET, NULL);

      UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_SET_READ_POLL_TMO,

                 reinterpret_cast<void*>(A2DP_DATA_READ_POLL_MS));
@@ -264,8 +254,7 @@ static void btif_a2dp_data_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, tUIPC_EVENT event) 
  }

}



void btif_a2dp_command_ack(tA2DP_CTRL_ACK status)

{

void btif_a2dp_command_ack(tA2DP_CTRL_ACK status) {

  uint8_t ack = status;



  APPL_TRACE_EVENT("## a2dp ack : %s, status %d ##",

system/btif/src/btif_a2dp_sink.cc

+398 −429
Original line number Diff line number Diff line
@@ -21,10 +21,6 @@ 


#include <string.h>



#include "osi/include/fixed_queue.h"

#include "osi/include/osi.h"

#include "osi/include/log.h"

#include "osi/include/thread.h"

#include "bt_common.h"

#include "btif_a2dp.h"

#include "btif_a2dp_sink.h"
@@ -32,11 +28,14 @@ 
#include "btif_av_co.h"

#include "btif_avrcp_audio_track.h"

#include "btif_util.h"

#include "osi/include/fixed_queue.h"

#include "osi/include/log.h"

#include "osi/include/osi.h"

#include "osi/include/thread.h"



#include "oi_codec_sbc.h"

#include "oi_status.h"





/**

 * The receiving queue buffer size.

 */
@@ -98,8 +97,10 @@ static tBTIF_A2DP_SINK_CB btif_a2dp_sink_cb; 
static int btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_OFF;



static OI_CODEC_SBC_DECODER_CONTEXT btif_a2dp_sink_context;

static OI_UINT32 btif_a2dp_sink_context_data[CODEC_DATA_WORDS(2, SBC_CODEC_FAST_FILTER_BUFFERS)];

static OI_INT16 btif_a2dp_sink_pcm_data[15 * SBC_MAX_SAMPLES_PER_FRAME * SBC_MAX_CHANNELS];

static OI_UINT32 btif_a2dp_sink_context_data[CODEC_DATA_WORDS(

    2, SBC_CODEC_FAST_FILTER_BUFFERS)];

static OI_INT16

    btif_a2dp_sink_pcm_data[15 * SBC_MAX_SAMPLES_PER_FRAME * SBC_MAX_CHANNELS];



static void btif_a2dp_sink_startup_delayed(void* context);

static void btif_a2dp_sink_shutdown_delayed(void* context);
@@ -114,13 +115,12 @@ static void btif_a2dp_sink_handle_inc_media(tBT_SBC_HDR *p_msg); 
static void btif_a2dp_sink_decoder_update_event(

    tBTIF_MEDIA_SINK_DECODER_UPDATE* p_buf);

static void btif_a2dp_sink_clear_track_event(void);

static void btif_a2dp_sink_set_focus_state_event(btif_a2dp_sink_focus_state_t state);

static void btif_a2dp_sink_set_focus_state_event(

    btif_a2dp_sink_focus_state_t state);

static void btif_a2dp_sink_audio_rx_flush_event(void);

static void btif_a2dp_sink_clear_track_event_req(void);





UNUSED_ATTR static const char *dump_media_event(uint16_t event)

{

UNUSED_ATTR static const char* dump_media_event(uint16_t event) {

  switch (event) {

    CASE_RETURN_STR(BTIF_MEDIA_SINK_DECODER_UPDATE)

    CASE_RETURN_STR(BTIF_MEDIA_SINK_CLEAR_TRACK)
@@ -132,8 +132,7 @@ UNUSED_ATTR static const char *dump_media_event(uint16_t event) 
  return "UNKNOWN A2DP SINK EVENT";

}



bool btif_a2dp_sink_startup(void)

{

bool btif_a2dp_sink_startup(void) {

  if (btif_a2dp_sink_state != BTIF_A2DP_SINK_STATE_OFF) {

    APPL_TRACE_ERROR("%s: A2DP Sink media task already running", __func__);

    return false;
@@ -157,27 +156,26 @@ bool btif_a2dp_sink_startup(void) 
  btif_a2dp_sink_cb.rx_audio_queue = fixed_queue_new(SIZE_MAX);



  btif_a2dp_sink_cb.cmd_msg_queue = fixed_queue_new(SIZE_MAX);

    fixed_queue_register_dequeue(btif_a2dp_sink_cb.cmd_msg_queue,

  fixed_queue_register_dequeue(

      btif_a2dp_sink_cb.cmd_msg_queue,

      thread_get_reactor(btif_a2dp_sink_cb.worker_thread),

      btif_a2dp_sink_command_ready, NULL);



  APPL_TRACE_EVENT("## A2DP SINK MEDIA THREAD STARTED ##");



  /* Schedule the rest of the startup operations */

    thread_post(btif_a2dp_sink_cb.worker_thread,

                btif_a2dp_sink_startup_delayed, NULL);

  thread_post(btif_a2dp_sink_cb.worker_thread, btif_a2dp_sink_startup_delayed,

              NULL);



  return true;

}



static void btif_a2dp_sink_startup_delayed(UNUSED_ATTR void *context)

{

static void btif_a2dp_sink_startup_delayed(UNUSED_ATTR void* context) {

  raise_priority_a2dp(TASK_HIGH_MEDIA);

  btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_RUNNING;

}



void btif_a2dp_sink_shutdown(void)

{

void btif_a2dp_sink_shutdown(void) {

  if ((btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) ||

      (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_SHUTTING_DOWN)) {

    return;
@@ -195,33 +193,29 @@ void btif_a2dp_sink_shutdown(void) 
  // Exit the thread

  fixed_queue_free(btif_a2dp_sink_cb.cmd_msg_queue, NULL);

  btif_a2dp_sink_cb.cmd_msg_queue = NULL;

    thread_post(btif_a2dp_sink_cb.worker_thread,

                btif_a2dp_sink_shutdown_delayed, NULL);

  thread_post(btif_a2dp_sink_cb.worker_thread, btif_a2dp_sink_shutdown_delayed,

              NULL);

  thread_free(btif_a2dp_sink_cb.worker_thread);

  btif_a2dp_sink_cb.worker_thread = NULL;

}



static void btif_a2dp_sink_shutdown_delayed(UNUSED_ATTR void *context)

{

static void btif_a2dp_sink_shutdown_delayed(UNUSED_ATTR void* context) {

  fixed_queue_free(btif_a2dp_sink_cb.rx_audio_queue, NULL);

  btif_a2dp_sink_cb.rx_audio_queue = NULL;



  btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_OFF;

}



uint32_t btif_a2dp_sink_get_sample_rate(void)

{

uint32_t btif_a2dp_sink_get_sample_rate(void) {

  return btif_a2dp_sink_cb.sample_rate;

}



uint8_t btif_a2dp_sink_get_channel_count(void)

{

uint8_t btif_a2dp_sink_get_channel_count(void) {

  return btif_a2dp_sink_cb.channel_count;

}



static void btif_a2dp_sink_command_ready(fixed_queue_t* queue,

                                         UNUSED_ATTR void *context)

{

                                         UNUSED_ATTR void* context) {

  BT_HDR* p_msg = (BT_HDR*)fixed_queue_dequeue(queue);



  LOG_VERBOSE(LOG_TAG, "%s: event %d %s", __func__, p_msg->event,
@@ -245,20 +239,18 @@ static void btif_a2dp_sink_command_ready(fixed_queue_t *queue, 
      btif_a2dp_sink_audio_rx_flush_event();

      break;

    default:

        APPL_TRACE_ERROR("ERROR in %s unknown event %d",

                         __func__, p_msg->event);

      APPL_TRACE_ERROR("ERROR in %s unknown event %d", __func__, p_msg->event);

      break;

  }



  osi_free(p_msg);

    LOG_VERBOSE(LOG_TAG, "%s: %s DONE",

                __func__, dump_media_event(p_msg->event));

  LOG_VERBOSE(LOG_TAG, "%s: %s DONE", __func__, dump_media_event(p_msg->event));

}



void btif_a2dp_sink_update_decoder(const uint8_t *p_codec_info)

{

void btif_a2dp_sink_update_decoder(const uint8_t* p_codec_info) {

  tBTIF_MEDIA_SINK_DECODER_UPDATE* p_buf =

        reinterpret_cast<tBTIF_MEDIA_SINK_DECODER_UPDATE *>(osi_malloc(sizeof(tBTIF_MEDIA_SINK_DECODER_UPDATE)));

      reinterpret_cast<tBTIF_MEDIA_SINK_DECODER_UPDATE*>(

          osi_malloc(sizeof(tBTIF_MEDIA_SINK_DECODER_UPDATE)));



  APPL_TRACE_EVENT("%s: p_codec_info[%x:%x:%x:%x:%x:%x]", __func__,

                   p_codec_info[1], p_codec_info[2], p_codec_info[3],
@@ -270,29 +262,22 @@ void btif_a2dp_sink_update_decoder(const uint8_t *p_codec_info) 
  fixed_queue_enqueue(btif_a2dp_sink_cb.cmd_msg_queue, p_buf);

}



void btif_a2dp_sink_on_idle(void)

{

    if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF)

        return;

void btif_a2dp_sink_on_idle(void) {

  if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;



  btif_a2dp_sink_audio_handle_stop_decoding();

  btif_a2dp_sink_clear_track_event_req();

  APPL_TRACE_DEBUG("Stopped BT track");

}





void btif_a2dp_sink_on_stopped(UNUSED_ATTR tBTA_AV_SUSPEND *p_av_suspend)

{

    if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF)

        return;

void btif_a2dp_sink_on_stopped(UNUSED_ATTR tBTA_AV_SUSPEND* p_av_suspend) {

  if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;



  btif_a2dp_sink_audio_handle_stop_decoding();

}



void btif_a2dp_sink_on_suspended(UNUSED_ATTR tBTA_AV_SUSPEND *p_av_suspend)

{

    if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF)

        return;

void btif_a2dp_sink_on_suspended(UNUSED_ATTR tBTA_AV_SUSPEND* p_av_suspend) {

  if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;



  btif_a2dp_sink_audio_handle_stop_decoding();

}
@@ -313,8 +298,7 @@ static void btif_decode_alarm_cb(UNUSED_ATTR void *context) { 
  }

}



static void btif_a2dp_sink_clear_track_event(void)

{

static void btif_a2dp_sink_clear_track_event(void) {

  APPL_TRACE_DEBUG("%s", __func__);



  BtifAvrcpAudioTrackStop(btif_a2dp_sink_cb.audio_track);
@@ -337,12 +321,12 @@ static void btif_a2dp_sink_audio_handle_start_decoding(void) { 
            btif_decode_alarm_cb, NULL);

}



static void btif_a2dp_sink_handle_inc_media(tBT_SBC_HDR *p_msg)

{

static void btif_a2dp_sink_handle_inc_media(tBT_SBC_HDR* p_msg) {

  uint8_t* sbc_start_frame = ((uint8_t*)(p_msg + 1) + p_msg->offset + 1);

  int count;

  uint32_t pcmBytes, availPcmBytes;

    OI_INT16 *pcmDataPointer = btif_a2dp_sink_pcm_data; /* Will be overwritten on next packet receipt */

  OI_INT16* pcmDataPointer =

      btif_a2dp_sink_pcm_data; /* Will be overwritten on next packet receipt */

  OI_STATUS status;

  int num_sbc_frames = p_msg->num_frames_to_be_processed;

  uint32_t sbc_frame_len = p_msg->len - 1;
@@ -354,15 +338,14 @@ static void btif_a2dp_sink_handle_inc_media(tBT_SBC_HDR *p_msg) 
    return;

  }



    APPL_TRACE_DEBUG("%s Number of SBC frames %d, frame_len %d",

                     __func__, num_sbc_frames, sbc_frame_len);

  APPL_TRACE_DEBUG("%s Number of SBC frames %d, frame_len %d", __func__,

                   num_sbc_frames, sbc_frame_len);



  for (count = 0; count < num_sbc_frames && sbc_frame_len != 0; count++) {

    pcmBytes = availPcmBytes;

        status = OI_CODEC_SBC_DecodeFrame(&btif_a2dp_sink_context,

                                          (const OI_BYTE **)&sbc_start_frame,

                                          (OI_UINT32 *)&sbc_frame_len,

                                          (OI_INT16 *)pcmDataPointer,

    status = OI_CODEC_SBC_DecodeFrame(

        &btif_a2dp_sink_context, (const OI_BYTE**)&sbc_start_frame,

        (OI_UINT32*)&sbc_frame_len, (OI_INT16*)pcmDataPointer,

        (OI_UINT32*)&pcmBytes);

    if (!OI_SUCCESS(status)) {

      APPL_TRACE_ERROR("%s: Decoding failure: %d", __func__, status);
@@ -374,13 +357,12 @@ static void btif_a2dp_sink_handle_inc_media(tBT_SBC_HDR *p_msg) 
    p_msg->len = sbc_frame_len + 1;

  }



    BtifAvrcpAudioTrackWriteData(btif_a2dp_sink_cb.audio_track,

                                 (void *)btif_a2dp_sink_pcm_data,

  BtifAvrcpAudioTrackWriteData(

      btif_a2dp_sink_cb.audio_track, (void*)btif_a2dp_sink_pcm_data,

      (sizeof(btif_a2dp_sink_pcm_data) - availPcmBytes));

}



static void btif_a2dp_sink_avk_handle_timer(UNUSED_ATTR void *context)

{

static void btif_a2dp_sink_avk_handle_timer(UNUSED_ATTR void* context) {

  tBT_SBC_HDR* p_msg;

  int num_sbc_frames;

  int num_frames_to_process;
@@ -406,9 +388,9 @@ static void btif_a2dp_sink_avk_handle_timer(UNUSED_ATTR void *context) 
  APPL_TRACE_DEBUG(" Process Frames + ");



  do {

        p_msg = (tBT_SBC_HDR *)fixed_queue_try_peek_first(btif_a2dp_sink_cb.rx_audio_queue);

        if (p_msg == NULL)

            return;

    p_msg = (tBT_SBC_HDR*)fixed_queue_try_peek_first(

        btif_a2dp_sink_cb.rx_audio_queue);

    if (p_msg == NULL) return;

    /* Number of frames in queue packets */

    num_sbc_frames = p_msg->num_frames_to_be_processed;

    APPL_TRACE_DEBUG("Frames left in topmost packet %d", num_sbc_frames);
@@ -428,7 +410,8 @@ static void btif_a2dp_sink_avk_handle_timer(UNUSED_ATTR void *context) 
    }

    /* Queue packet has less frames */

    btif_a2dp_sink_handle_inc_media(p_msg);

        p_msg = (tBT_SBC_HDR *)fixed_queue_try_dequeue(btif_a2dp_sink_cb.rx_audio_queue);

    p_msg =

        (tBT_SBC_HDR*)fixed_queue_try_dequeue(btif_a2dp_sink_cb.rx_audio_queue);

    if (p_msg == NULL) {

      APPL_TRACE_ERROR("Insufficient data in queue");

      break;
@@ -442,14 +425,12 @@ static void btif_a2dp_sink_avk_handle_timer(UNUSED_ATTR void *context) 
}



/* when true media task discards any rx frames */

void btif_a2dp_sink_set_rx_flush(bool enable)

{

void btif_a2dp_sink_set_rx_flush(bool enable) {

  APPL_TRACE_EVENT("## DROP RX %d ##", enable);

  btif_a2dp_sink_cb.rx_flush = enable;

}



static void btif_a2dp_sink_audio_rx_flush_event(void)

{

static void btif_a2dp_sink_audio_rx_flush_event(void) {

  /* Flush all received SBC buffers (encoded) */

  APPL_TRACE_DEBUG("%s", __func__);
@@ -457,13 +438,13 @@ static void btif_a2dp_sink_audio_rx_flush_event(void) 
}



static void btif_a2dp_sink_decoder_update_event(

    tBTIF_MEDIA_SINK_DECODER_UPDATE *p_buf)

{

    tBTIF_MEDIA_SINK_DECODER_UPDATE* p_buf) {

  OI_STATUS status;



  APPL_TRACE_DEBUG("%s: p_codec_info[%x:%x:%x:%x:%x:%x]", __func__,

            p_buf->codec_info[1], p_buf->codec_info[2], p_buf->codec_info[3],

            p_buf->codec_info[4], p_buf->codec_info[5], p_buf->codec_info[6]);

                   p_buf->codec_info[1], p_buf->codec_info[2],

                   p_buf->codec_info[3], p_buf->codec_info[4],

                   p_buf->codec_info[5], p_buf->codec_info[6]);



  int sample_rate = A2DP_GetTrackFrequency(p_buf->codec_info);

  if (sample_rate == -1) {
@@ -485,26 +466,24 @@ static void btif_a2dp_sink_decoder_update_event( 


  btif_a2dp_sink_cb.rx_flush = false;

  APPL_TRACE_DEBUG("Reset to Sink role");

    status = OI_CODEC_SBC_DecoderReset(&btif_a2dp_sink_context,

                                       btif_a2dp_sink_context_data,

                                       sizeof(btif_a2dp_sink_context_data),

                                       2, 2, false);

  status = OI_CODEC_SBC_DecoderReset(

      &btif_a2dp_sink_context, btif_a2dp_sink_context_data,

      sizeof(btif_a2dp_sink_context_data), 2, 2, false);

  if (!OI_SUCCESS(status)) {

    APPL_TRACE_ERROR("OI_CODEC_SBC_DecoderReset failed with error code %d",

                     status);

  }



  APPL_TRACE_DEBUG("%s: A2dpSink: SBC create track", __func__);

    btif_a2dp_sink_cb.audio_track = BtifAvrcpAudioTrackCreate(sample_rate,

                                                              channel_type);

  btif_a2dp_sink_cb.audio_track =

      BtifAvrcpAudioTrackCreate(sample_rate, channel_type);

  if (btif_a2dp_sink_cb.audio_track == NULL) {

    APPL_TRACE_ERROR("%s: A2dpSink: Track creation failed!!!", __func__);

    return;

  }



    btif_a2dp_sink_cb.frames_to_process =

        A2DP_GetSinkFramesCountToProcess(BTIF_SINK_MEDIA_TIME_TICK_MS,

                                        p_buf->codec_info);

  btif_a2dp_sink_cb.frames_to_process = A2DP_GetSinkFramesCountToProcess(

      BTIF_SINK_MEDIA_TIME_TICK_MS, p_buf->codec_info);

  APPL_TRACE_DEBUG("Frames to be processed in 20 ms %d",

                   btif_a2dp_sink_cb.frames_to_process);

  if (btif_a2dp_sink_cb.frames_to_process == 0) {
@@ -512,8 +491,7 @@ static void btif_a2dp_sink_decoder_update_event( 
  }

}



uint8_t btif_a2dp_sink_enqueue_buf(BT_HDR *p_pkt)

{

uint8_t btif_a2dp_sink_enqueue_buf(BT_HDR* p_pkt) {

  if (btif_a2dp_sink_cb.rx_flush) /* Flush enabled, do not enqueue */

    return fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue);
@@ -526,10 +504,8 @@ uint8_t btif_a2dp_sink_enqueue_buf(BT_HDR *p_pkt) 


  BTIF_TRACE_VERBOSE("%s +", __func__);

  /* Allocate and queue this buffer */

    tBT_SBC_HDR *p_msg =

      reinterpret_cast<tBT_SBC_HDR *>(osi_malloc(sizeof(tBT_SBC_HDR) +

                                                 p_pkt->offset +

                                                 p_pkt->len));

  tBT_SBC_HDR* p_msg = reinterpret_cast<tBT_SBC_HDR*>(

      osi_malloc(sizeof(tBT_SBC_HDR) + p_pkt->offset + p_pkt->len));

  memcpy((uint8_t*)(p_msg + 1), (uint8_t*)(p_pkt + 1) + p_pkt->offset,

         p_pkt->len);

  p_msg->num_frames_to_be_processed =
@@ -537,9 +513,8 @@ uint8_t btif_a2dp_sink_enqueue_buf(BT_HDR *p_pkt) 
  p_msg->len = p_pkt->len;

  p_msg->offset = 0;

  p_msg->layer_specific = p_pkt->layer_specific;

    BTIF_TRACE_VERBOSE("%s: frames to process %d, len %d",

                       __func__, p_msg->num_frames_to_be_processed,

                       p_msg->len);

  BTIF_TRACE_VERBOSE("%s: frames to process %d, len %d", __func__,

                     p_msg->num_frames_to_be_processed, p_msg->len);

  fixed_queue_enqueue(btif_a2dp_sink_cb.rx_audio_queue, p_msg);

  if (fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue) ==

      MAX_A2DP_DELAYED_START_FRAME_COUNT) {
@@ -550,8 +525,7 @@ uint8_t btif_a2dp_sink_enqueue_buf(BT_HDR *p_pkt) 
  return fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue);

}



void btif_a2dp_sink_audio_rx_flush_req(void)

{

void btif_a2dp_sink_audio_rx_flush_req(void) {

  if (fixed_queue_is_empty(btif_a2dp_sink_cb.rx_audio_queue)) {

    /* Queue is already empty */

    return;
@@ -562,20 +536,18 @@ void btif_a2dp_sink_audio_rx_flush_req(void) 
  fixed_queue_enqueue(btif_a2dp_sink_cb.cmd_msg_queue, p_buf);

}



void btif_a2dp_sink_debug_dump(UNUSED_ATTR int fd)

{

void btif_a2dp_sink_debug_dump(UNUSED_ATTR int fd) {

  // Nothing to do

}



void btif_a2dp_sink_update_metrics(void)

{

void btif_a2dp_sink_update_metrics(void) {

  // Nothing to do

}



void btif_a2dp_sink_set_focus_state_req(btif_a2dp_sink_focus_state_t state)

{

void btif_a2dp_sink_set_focus_state_req(btif_a2dp_sink_focus_state_t state) {

  tBTIF_MEDIA_SINK_FOCUS_UPDATE* p_buf =

        reinterpret_cast<tBTIF_MEDIA_SINK_FOCUS_UPDATE *>(osi_malloc(sizeof(tBTIF_MEDIA_SINK_FOCUS_UPDATE)));

      reinterpret_cast<tBTIF_MEDIA_SINK_FOCUS_UPDATE*>(

          osi_malloc(sizeof(tBTIF_MEDIA_SINK_FOCUS_UPDATE)));



  APPL_TRACE_EVENT("%s", __func__);
@@ -584,22 +556,19 @@ void btif_a2dp_sink_set_focus_state_req(btif_a2dp_sink_focus_state_t state) 
  fixed_queue_enqueue(btif_a2dp_sink_cb.cmd_msg_queue, p_buf);

}



static void btif_a2dp_sink_set_focus_state_event(btif_a2dp_sink_focus_state_t state)

{

    if (!btif_av_is_connected())

        return;

static void btif_a2dp_sink_set_focus_state_event(

    btif_a2dp_sink_focus_state_t state) {

  if (!btif_av_is_connected()) return;

  APPL_TRACE_DEBUG("%s: setting focus state to %d", __func__, state);

  btif_a2dp_sink_cb.rx_focus_state = state;

}



void btif_a2dp_sink_set_audio_track_gain(float gain)

{

void btif_a2dp_sink_set_audio_track_gain(float gain) {

  APPL_TRACE_DEBUG("%s set gain to %f", __func__, gain);

  BtifAvrcpSetAudioTrackGain(btif_a2dp_sink_cb.audio_track, gain);

}



static void btif_a2dp_sink_clear_track_event_req(void)

{

static void btif_a2dp_sink_clear_track_event_req(void) {

  BT_HDR* p_buf = reinterpret_cast<BT_HDR*>(osi_malloc(sizeof(BT_HDR)));



  p_buf->event = BTIF_MEDIA_SINK_CLEAR_TRACK;

system/btif/src/btif_a2dp_source.cc

+776 −767

File changed.

Preview size limit exceeded, changes collapsed.

system/stack/a2dp/a2dp_api.cc

+518 −605

File changed.

Preview size limit exceeded, changes collapsed.