audio: update examples

Signed-off-by: HiFiPhile <[email protected]>

1 files changed, 104 insertions, 157 deletions

diff --git a/examples/device/uac2_speaker_fb/src/main.c b/examples/device/uac2_speaker_fb/src/main.c
index ea5a2941d..12425b919 100644
--- a/examples/device/uac2_speaker_fb/src/main.c
+++ b/examples/device/uac2_speaker_fb/src/main.c
@@ -27,12 +27,12 @@
 #include <string.h>
 
 #include "bsp/board_api.h"
+#include "common_types.h"
 #include "tusb.h"
 #include "usb_descriptors.h"
-#include "common_types.h"
 
 #ifdef CFG_QUIRK_OS_GUESSING
-#include "quirk_os_guessing.h"
+  #include "quirk_os_guessing.h"
 #endif
 
 //--------------------------------------------------------------------+
@@ -41,14 +41,14 @@
 
 // List of supported sample rates
 #if defined(__RX__)
-  const uint32_t sample_rates[] = {44100, 48000};
+const uint32_t sample_rates[] = {44100, 48000};
 #else
-  const uint32_t sample_rates[] = {44100, 48000, 88200, 96000};
+const uint32_t sample_rates[] = {44100, 48000, 88200, 96000};
 #endif
 
-uint32_t current_sample_rate  = 44100;
+uint32_t current_sample_rate = 44100;
 
-#define N_SAMPLE_RATES  TU_ARRAY_SIZE(sample_rates)
+#define N_SAMPLE_RATES TU_ARRAY_SIZE(sample_rates)
 
 /* Blink pattern
  * - 25 ms   : streaming data
@@ -56,16 +56,14 @@ uint32_t current_sample_rate  = 44100;
  * - 1000 ms : device mounted
  * - 2500 ms : device is suspended
  */
-enum
-{
+enum {
   BLINK_STREAMING = 25,
   BLINK_NOT_MOUNTED = 250,
   BLINK_MOUNTED = 1000,
   BLINK_SUSPENDED = 2500,
 };
 
-enum
-{
+enum {
   VOLUME_CTRL_0_DB = 0,
   VOLUME_CTRL_10_DB = 2560,
   VOLUME_CTRL_20_DB = 5120,
@@ -84,11 +82,11 @@ static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
 
 // Audio controls
 // Current states
-int8_t mute[CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1];       // +1 for master channel 0
-int16_t volume[CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1];    // +1 for master channel 0
+int8_t mute[CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1];   // +1 for master channel 0
+int16_t volume[CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1];// +1 for master channel 0
 
 // Buffer for speaker data
-uint16_t i2s_dummy_buffer[CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ/2];
+uint16_t i2s_dummy_buffer[CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ / 2];
 
 void led_blinking_task(void);
 void audio_task(void);
@@ -96,20 +94,18 @@ void audio_task(void);
 #if CFG_AUDIO_DEBUG
 void audio_debug_task(void);
 uint8_t current_alt_settings;
-uint16_t fifo_count;
-uint32_t fifo_count_avg;
+volatile uint16_t fifo_count;
+volatile uint32_t fifo_count_avg;
 #endif
 
 /*------------- MAIN -------------*/
-int main(void)
-{
+int main(void) {
   board_init();
 
   // init device stack on configured roothub port
   tusb_rhport_init_t dev_init = {
-    .role = TUSB_ROLE_DEVICE,
-    .speed = TUSB_SPEED_AUTO
-  };
+      .role = TUSB_ROLE_DEVICE,
+      .speed = TUSB_SPEED_AUTO};
   tusb_init(BOARD_TUD_RHPORT, &dev_init);
 
   if (board_init_after_tusb) {
@@ -118,9 +114,8 @@ int main(void)
 
   TU_LOG1("Speaker running\r\n");
 
-  while (1)
-  {
-    tud_task(); // TinyUSB device task
+  while (1) {
+    tud_task();// TinyUSB device task
     led_blinking_task();
 #if CFG_AUDIO_DEBUG
     audio_debug_task();
@@ -134,29 +129,25 @@ int main(void)
 //--------------------------------------------------------------------+
 
 // Invoked when device is mounted
-void tud_mount_cb(void)
-{
+void tud_mount_cb(void) {
   blink_interval_ms = BLINK_MOUNTED;
 }
 
 // Invoked when device is unmounted
-void tud_umount_cb(void)
-{
+void tud_umount_cb(void) {
   blink_interval_ms = BLINK_NOT_MOUNTED;
 }
 
 // Invoked when usb bus is suspended
 // remote_wakeup_en : if host allow us  to perform remote wakeup
 // Within 7ms, device must draw an average of current less than 2.5 mA from bus
-void tud_suspend_cb(bool remote_wakeup_en)
-{
-  (void)remote_wakeup_en;
+void tud_suspend_cb(bool remote_wakeup_en) {
+  (void) remote_wakeup_en;
   blink_interval_ms = BLINK_SUSPENDED;
 }
 
 // Invoked when usb bus is resumed
-void tud_resume_cb(void)
-{
+void tud_resume_cb(void) {
   blink_interval_ms = tud_mounted() ? BLINK_MOUNTED : BLINK_NOT_MOUNTED;
 }
 
@@ -165,43 +156,34 @@ void tud_resume_cb(void)
 //--------------------------------------------------------------------+
 
 // Helper for clock get requests
-static bool tud_audio_clock_get_request(uint8_t rhport, audio_control_request_t const *request)
-{
+static bool tud_audio_clock_get_request(uint8_t rhport, audio_control_request_t const *request) {
   TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
 
-  if (request->bControlSelector == AUDIO_CS_CTRL_SAM_FREQ)
-  {
-    if (request->bRequest == AUDIO_CS_REQ_CUR)
-    {
+  if (request->bControlSelector == AUDIO_CS_CTRL_SAM_FREQ) {
+    if (request->bRequest == AUDIO_CS_REQ_CUR) {
       TU_LOG1("Clock get current freq %lu\r\n", current_sample_rate);
 
-      audio_control_cur_4_t curf = { (int32_t) tu_htole32(current_sample_rate) };
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &curf, sizeof(curf));
-    }
-    else if (request->bRequest == AUDIO_CS_REQ_RANGE)
-    {
+      audio_control_cur_4_t curf = {(int32_t) tu_htole32(current_sample_rate)};
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &curf, sizeof(curf));
+    } else if (request->bRequest == AUDIO_CS_REQ_RANGE) {
       audio_control_range_4_n_t(N_SAMPLE_RATES) rangef =
-      {
-        .wNumSubRanges = tu_htole16(N_SAMPLE_RATES)
-      };
+          {
+              .wNumSubRanges = tu_htole16(N_SAMPLE_RATES)};
       TU_LOG1("Clock get %d freq ranges\r\n", N_SAMPLE_RATES);
-      for(uint8_t i = 0; i < N_SAMPLE_RATES; i++)
-      {
+      for (uint8_t i = 0; i < N_SAMPLE_RATES; i++) {
         rangef.subrange[i].bMin = (int32_t) sample_rates[i];
         rangef.subrange[i].bMax = (int32_t) sample_rates[i];
         rangef.subrange[i].bRes = 0;
-        TU_LOG1("Range %d (%d, %d, %d)\r\n", i, (int)rangef.subrange[i].bMin, (int)rangef.subrange[i].bMax, (int)rangef.subrange[i].bRes);
+        TU_LOG1("Range %d (%d, %d, %d)\r\n", i, (int) rangef.subrange[i].bMin, (int) rangef.subrange[i].bMax, (int) rangef.subrange[i].bRes);
       }
 
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &rangef, sizeof(rangef));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &rangef, sizeof(rangef));
     }
-  }
-  else if (request->bControlSelector == AUDIO_CS_CTRL_CLK_VALID &&
-           request->bRequest == AUDIO_CS_REQ_CUR)
-  {
-    audio_control_cur_1_t cur_valid = { .bCur = 1 };
+  } else if (request->bControlSelector == AUDIO_CS_CTRL_CLK_VALID &&
+             request->bRequest == AUDIO_CS_REQ_CUR) {
+    audio_control_cur_1_t cur_valid = {.bCur = 1};
     TU_LOG1("Clock get is valid %u\r\n", cur_valid.bCur);
-    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &cur_valid, sizeof(cur_valid));
+    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &cur_valid, sizeof(cur_valid));
   }
   TU_LOG1("Clock get request not supported, entity = %u, selector = %u, request = %u\r\n",
           request->bEntityID, request->bControlSelector, request->bRequest);
@@ -209,25 +191,21 @@ static bool tud_audio_clock_get_request(uint8_t rhport, audio_control_request_t
 }
 
 // Helper for clock set requests
-static bool tud_audio_clock_set_request(uint8_t rhport, audio_control_request_t const *request, uint8_t const *buf)
-{
-  (void)rhport;
+static bool tud_audio_clock_set_request(uint8_t rhport, audio_control_request_t const *request, uint8_t const *buf) {
+  (void) rhport;
 
   TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
   TU_VERIFY(request->bRequest == AUDIO_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO_CS_CTRL_SAM_FREQ)
-  {
+  if (request->bControlSelector == AUDIO_CS_CTRL_SAM_FREQ) {
     TU_VERIFY(request->wLength == sizeof(audio_control_cur_4_t));
 
-    current_sample_rate = (uint32_t) ((audio_control_cur_4_t const *)buf)->bCur;
+    current_sample_rate = (uint32_t) ((audio_control_cur_4_t const *) buf)->bCur;
 
     TU_LOG1("Clock set current freq: %ld\r\n", current_sample_rate);
 
     return true;
-  }
-  else
-  {
+  } else {
     TU_LOG1("Clock set request not supported, entity = %u, selector = %u, request = %u\r\n",
             request->bEntityID, request->bControlSelector, request->bRequest);
     return false;
@@ -235,33 +213,25 @@ static bool tud_audio_clock_set_request(uint8_t rhport, audio_control_request_t
 }
 
 // Helper for feature unit get requests
-static bool tud_audio_feature_unit_get_request(uint8_t rhport, audio_control_request_t const *request)
-{
+static bool tud_audio_feature_unit_get_request(uint8_t rhport, audio_control_request_t const *request) {
   TU_ASSERT(request->bEntityID == UAC2_ENTITY_FEATURE_UNIT);
 
-  if (request->bControlSelector == AUDIO_FU_CTRL_MUTE && request->bRequest == AUDIO_CS_REQ_CUR)
-  {
-    audio_control_cur_1_t mute1 = { .bCur = mute[request->bChannelNumber] };
+  if (request->bControlSelector == AUDIO_FU_CTRL_MUTE && request->bRequest == AUDIO_CS_REQ_CUR) {
+    audio_control_cur_1_t mute1 = {.bCur = mute[request->bChannelNumber]};
     TU_LOG1("Get channel %u mute %d\r\n", request->bChannelNumber, mute1.bCur);
-    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &mute1, sizeof(mute1));
-  }
-  else if (request->bControlSelector == AUDIO_FU_CTRL_VOLUME)
-  {
-    if (request->bRequest == AUDIO_CS_REQ_RANGE)
-    {
+    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &mute1, sizeof(mute1));
+  } else if (request->bControlSelector == AUDIO_FU_CTRL_VOLUME) {
+    if (request->bRequest == AUDIO_CS_REQ_RANGE) {
       audio_control_range_2_n_t(1) range_vol = {
-        .wNumSubRanges = tu_htole16(1),
-        .subrange[0] = { .bMin = tu_htole16(-VOLUME_CTRL_50_DB), tu_htole16(VOLUME_CTRL_0_DB), tu_htole16(256) }
-      };
+          .wNumSubRanges = tu_htole16(1),
+          .subrange[0] = {.bMin = tu_htole16(-VOLUME_CTRL_50_DB), tu_htole16(VOLUME_CTRL_0_DB), tu_htole16(256)}};
       TU_LOG1("Get channel %u volume range (%d, %d, %u) dB\r\n", request->bChannelNumber,
               range_vol.subrange[0].bMin / 256, range_vol.subrange[0].bMax / 256, range_vol.subrange[0].bRes / 256);
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &range_vol, sizeof(range_vol));
-    }
-    else if (request->bRequest == AUDIO_CS_REQ_CUR)
-    {
-      audio_control_cur_2_t cur_vol = { .bCur = tu_htole16(volume[request->bChannelNumber]) };
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &range_vol, sizeof(range_vol));
+    } else if (request->bRequest == AUDIO_CS_REQ_CUR) {
+      audio_control_cur_2_t cur_vol = {.bCur = tu_htole16(volume[request->bChannelNumber])};
       TU_LOG1("Get channel %u volume %d dB\r\n", request->bChannelNumber, cur_vol.bCur / 256);
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &cur_vol, sizeof(cur_vol));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &cur_vol, sizeof(cur_vol));
     }
   }
   TU_LOG1("Feature unit get request not supported, entity = %u, selector = %u, request = %u\r\n",
@@ -271,35 +241,29 @@ static bool tud_audio_feature_unit_get_request(uint8_t rhport, audio_control_req
 }
 
 // Helper for feature unit set requests
-static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio_control_request_t const *request, uint8_t const *buf)
-{
-  (void)rhport;
+static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio_control_request_t const *request, uint8_t const *buf) {
+  (void) rhport;
 
   TU_ASSERT(request->bEntityID == UAC2_ENTITY_FEATURE_UNIT);
   TU_VERIFY(request->bRequest == AUDIO_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO_FU_CTRL_MUTE)
-  {
+  if (request->bControlSelector == AUDIO_FU_CTRL_MUTE) {
     TU_VERIFY(request->wLength == sizeof(audio_control_cur_1_t));
 
-    mute[request->bChannelNumber] = ((audio_control_cur_1_t const *)buf)->bCur;
+    mute[request->bChannelNumber] = ((audio_control_cur_1_t const *) buf)->bCur;
 
     TU_LOG1("Set channel %d Mute: %d\r\n", request->bChannelNumber, mute[request->bChannelNumber]);
 
     return true;
-  }
-  else if (request->bControlSelector == AUDIO_FU_CTRL_VOLUME)
-  {
+  } else if (request->bControlSelector == AUDIO_FU_CTRL_VOLUME) {
     TU_VERIFY(request->wLength == sizeof(audio_control_cur_2_t));
 
-    volume[request->bChannelNumber] = ((audio_control_cur_2_t const *)buf)->bCur;
+    volume[request->bChannelNumber] = ((audio_control_cur_2_t const *) buf)->bCur;
 
     TU_LOG1("Set channel %d volume: %d dB\r\n", request->bChannelNumber, volume[request->bChannelNumber] / 256);
 
     return true;
-  }
-  else
-  {
+  } else {
     TU_LOG1("Feature unit set request not supported, entity = %u, selector = %u, request = %u\r\n",
             request->bEntityID, request->bControlSelector, request->bRequest);
     return false;
@@ -307,16 +271,14 @@ static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio_control_req
 }
 
 // Invoked when audio class specific get request received for an entity
-bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request)
-{
-  audio_control_request_t const *request = (audio_control_request_t const *)p_request;
+bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
+  audio_control_request_t const *request = (audio_control_request_t const *) p_request;
 
   if (request->bEntityID == UAC2_ENTITY_CLOCK)
     return tud_audio_clock_get_request(rhport, request);
   if (request->bEntityID == UAC2_ENTITY_FEATURE_UNIT)
     return tud_audio_feature_unit_get_request(rhport, request);
-  else
-  {
+  else {
     TU_LOG1("Get request not handled, entity = %d, selector = %d, request = %d\r\n",
             request->bEntityID, request->bControlSelector, request->bRequest);
   }
@@ -324,9 +286,8 @@ bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p
 }
 
 // Invoked when audio class specific set request received for an entity
-bool tud_audio_set_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t *buf)
-{
-  audio_control_request_t const *request = (audio_control_request_t const *)p_request;
+bool tud_audio_set_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t *buf) {
+  audio_control_request_t const *request = (audio_control_request_t const *) p_request;
 
   if (request->bEntityID == UAC2_ENTITY_FEATURE_UNIT)
     return tud_audio_feature_unit_set_request(rhport, request, buf);
@@ -338,28 +299,26 @@ bool tud_audio_set_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p
   return false;
 }
 
-bool tud_audio_set_itf_close_EP_cb(uint8_t rhport, tusb_control_request_t const * p_request)
-{
-  (void)rhport;
+bool tud_audio_set_itf_close_EP_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
+  (void) rhport;
 
   uint8_t const itf = tu_u16_low(tu_le16toh(p_request->wIndex));
   uint8_t const alt = tu_u16_low(tu_le16toh(p_request->wValue));
 
   if (ITF_NUM_AUDIO_STREAMING == itf && alt == 0)
-      blink_interval_ms = BLINK_MOUNTED;
+    blink_interval_ms = BLINK_MOUNTED;
 
   return true;
 }
 
-bool tud_audio_set_itf_cb(uint8_t rhport, tusb_control_request_t const * p_request)
-{
-  (void)rhport;
+bool tud_audio_set_itf_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
+  (void) rhport;
   uint8_t const itf = tu_u16_low(tu_le16toh(p_request->wIndex));
   uint8_t const alt = tu_u16_low(tu_le16toh(p_request->wValue));
 
   TU_LOG2("Set interface %d alt %d\r\n", itf, alt);
   if (ITF_NUM_AUDIO_STREAMING == itf && alt != 0)
-      blink_interval_ms = BLINK_STREAMING;
+    blink_interval_ms = BLINK_STREAMING;
 
 #if CFG_AUDIO_DEBUG
   current_alt_settings = alt;
@@ -368,37 +327,34 @@ bool tud_audio_set_itf_cb(uint8_t rhport, tusb_control_request_t const * p_reque
   return true;
 }
 
-void tud_audio_feedback_params_cb(uint8_t func_id, uint8_t alt_itf, audio_feedback_params_t* feedback_param)
-{
-  (void)func_id;
-  (void)alt_itf;
+void tud_audio_feedback_params_cb(uint8_t func_id, uint8_t alt_itf, audio_feedback_params_t *feedback_param) {
+  (void) func_id;
+  (void) alt_itf;
   // Set feedback method to fifo counting
   feedback_param->method = AUDIO_FEEDBACK_METHOD_FIFO_COUNT;
   feedback_param->sample_freq = current_sample_rate;
 }
 
 #if CFG_AUDIO_DEBUG
-bool tud_audio_rx_done_post_read_cb(uint8_t rhport, uint16_t n_bytes_received, uint8_t func_id, uint8_t ep_out, uint8_t cur_alt_setting)
-{
-  (void)rhport;
-  (void)n_bytes_received;
-  (void)func_id;
-  (void)ep_out;
-  (void)cur_alt_setting;
+bool tud_audio_rx_done_isr(uint8_t rhport, uint16_t n_bytes_received, uint8_t func_id, uint8_t ep_out, uint8_t cur_alt_setting) {
+  (void) rhport;
+  (void) n_bytes_received;
+  (void) func_id;
+  (void) ep_out;
+  (void) cur_alt_setting;
 
   fifo_count = tud_audio_available();
   // Same averaging method used in UAC2 class
-  fifo_count_avg = (uint32_t)(((uint64_t)fifo_count_avg * 63  + ((uint32_t)fifo_count << 16)) >> 6);
+  fifo_count_avg = (uint32_t) (((uint64_t) fifo_count_avg * 63 + ((uint32_t) fifo_count << 16)) >> 6);
 
   return true;
 }
 #endif
 
 #if CFG_QUIRK_OS_GUESSING
-bool tud_audio_feedback_format_correction_cb(uint8_t func_id)
-{
-  (void)func_id;
-  if(tud_speed_get() == TUSB_SPEED_FULL && quirk_os_guessing_get() == QUIRK_OS_GUESSING_OSX) {
+bool tud_audio_feedback_format_correction_cb(uint8_t func_id) {
+  (void) func_id;
+  if (tud_speed_get() == TUSB_SPEED_FULL && quirk_os_guessing_get() == QUIRK_OS_GUESSING_OSX) {
     return true;
   } else {
     return false;
@@ -409,25 +365,21 @@ bool tud_audio_feedback_format_correction_cb(uint8_t func_id)
 // AUDIO Task
 //--------------------------------------------------------------------+
 
-void audio_task(void)
-{
-  // Replace audio_task() with your I2S transmit callback.
-  // Here we simulate a callback called every 1ms.
+// This task simulates an audio transmit callback, one frame is sent every 1ms.
+// In a real application, this would be replaced with actual I2S transmit callback.
+void audio_task(void) {
   static uint32_t start_ms = 0;
   uint32_t curr_ms = board_millis();
-  if ( start_ms == curr_ms ) return; // not enough time
+  if (start_ms == curr_ms) return;// not enough time
   start_ms = curr_ms;
 
-  uint16_t length = (uint16_t) (current_sample_rate/1000 * CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_RX * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX);
+  uint16_t length = (uint16_t) (current_sample_rate / 1000 * CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_RX * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX);
 
-  if (current_sample_rate == 44100 && (curr_ms % 10 == 0))
-  {
+  if (current_sample_rate == 44100 && (curr_ms % 10 == 0)) {
     // Take one more sample every 10 cycles, to have a average reading speed of 44.1
     // This correction is not needed in real world cases
     length += CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_RX * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX;
-  } else
-  if (current_sample_rate == 88200 && (curr_ms % 5 == 0))
-  {
+  } else if (current_sample_rate == 88200 && (curr_ms % 5 == 0)) {
     // Take one more sample every 5 cycles, to have a average reading speed of 88.2
     // This correction is not needed in real world cases
     length += CFG_TUD_AUDIO_FUNC_1_N_BYTES_PER_SAMPLE_RX * CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX;
@@ -439,8 +391,7 @@ void audio_task(void)
 //--------------------------------------------------------------------+
 // BLINKING TASK
 //--------------------------------------------------------------------+
-void led_blinking_task(void)
-{
+void led_blinking_task(void) {
   static uint32_t start_ms = 0;
   static bool led_state = false;
 
@@ -457,33 +408,30 @@ void led_blinking_task(void)
 // HID interface for audio debug
 //--------------------------------------------------------------------+
 // Every 1ms, we will sent 1 debug information report
-void audio_debug_task(void)
-{
+void audio_debug_task(void) {
   static uint32_t start_ms = 0;
   uint32_t curr_ms = board_millis();
-  if ( start_ms == curr_ms ) return; // not enough time
+  if (start_ms == curr_ms) return;// not enough time
   start_ms = curr_ms;
 
   audio_debug_info_t debug_info;
-  debug_info.sample_rate    = current_sample_rate;
-  debug_info.alt_settings   = current_alt_settings;
-  debug_info.fifo_size      = CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ;
-  debug_info.fifo_count     = fifo_count;
+  debug_info.sample_rate = current_sample_rate;
+  debug_info.alt_settings = current_alt_settings;
+  debug_info.fifo_size = CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ;
+  debug_info.fifo_count = fifo_count;
   debug_info.fifo_count_avg = (uint16_t) (fifo_count_avg >> 16);
-  for (int i = 0; i < CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1; i++)
-  {
+  for (int i = 0; i < CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1; i++) {
     debug_info.mute[i] = mute[i];
     debug_info.volume[i] = volume[i];
   }
 
-  if(tud_hid_ready())
+  if (tud_hid_ready())
     tud_hid_report(0, &debug_info, sizeof(debug_info));
 }
 
 // Invoked when received GET_REPORT control request
 // Unused here
-uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
-{
+uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, uint16_t reqlen) {
   // TODO not Implemented
   (void) itf;
   (void) report_id;
@@ -496,8 +444,7 @@ uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t
 
 // Invoked when received SET_REPORT control request or
 // Unused here
-void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
-{
+void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t const *buffer, uint16_t bufsize) {
   // This example doesn't use multiple report and report ID
   (void) itf;
   (void) report_id;