standardise on formatting

.clang-format

@@ -0,0 +1,5 @@
+---
+BasedOnStyle: Chromium
+UseTab: Never
+
+...

main/CMakeLists.txt

@@ -1,5 +1,12 @@
-idf_component_register(
+idf_component_register(SRCS
-  SRCS "gay-ipod-fw.cpp" "dac.cpp" "gpio-expander.cpp" "battery.cpp" "storage.cpp" "i2c.cpp"
+                       "gay-ipod-fw.cpp"
-  INCLUDE_DIRS "."
+                       "dac.cpp"
-  REQUIRES "esp_adc_cal" "fatfs" "audio_pipeline" "audio_stream" "result"
+                       "gpio-expander.cpp"
-)
+                       "battery.cpp"
+                       "storage.cpp"
+                       "i2c.cpp" INCLUDE_DIRS "." REQUIRES
+                       "esp_adc_cal"
+                       "fatfs"
+                       "audio_pipeline"
+                       "audio_stream"
+                       "result")

main/battery.cpp

@@ -11,8 +11,8 @@ static esp_adc_cal_characteristics_t calibration;
 esp_err_t init_adc(void) {
   // Calibration should already be fused into the chip from the factory, so
   // we should only need to read it back out again.
-  esp_adc_cal_characterize(
+  esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, 0,
-      ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, 0, &calibration);
+                           &calibration);
 
   // Max battery voltage should be a little over 2V due to our divider, so
   // we need the max attenuation to properly handle the full range.

main/dac.cpp

@@ -1,13 +1,13 @@
 #include "dac.h"
 
-#include "esp_err.h"
+#include <cstdint>
-#include "i2c.h"
-#include "esp_log.h"
 #include "assert.h"
 #include "driver/i2c.h"
+#include "esp_err.h"
+#include "esp_log.h"
 #include "gpio-expander.h"
 #include "hal/i2c_types.h"
-#include <cstdint>
+#include "i2c.h"
 
 namespace gay_ipod {
 
@@ -20,7 +20,8 @@ AudioDac::AudioDac(GpioExpander *gpio) {
 AudioDac::~AudioDac(){};
 
 esp_err_t AudioDac::Start() {
-  bool is_booted = WaitForPowerState([](bool booted, PowerState state){ return booted; });
+  bool is_booted =
+      WaitForPowerState([](bool booted, PowerState state) { return booted; });
   if (!is_booted) {
     ESP_LOGE(TAG, "Timed out waiting for boot");
     return ESP_ERR_TIMEOUT;
@@ -30,7 +31,8 @@ esp_err_t AudioDac::Start() {
   WriteVolume(100);
 
   WaitForPowerState([](bool booted, PowerState state) {
-      return state == WAIT_FOR_CP || state == RAMP_UP || state == RUN || state == STANDBY;
+    return state == WAIT_FOR_CP || state == RAMP_UP || state == RUN ||
+           state == STANDBY;
   });
 
   return ESP_OK;
@@ -45,8 +47,7 @@ std::pair<bool, AudioDac::PowerState> AudioDac::ReadPowerState() {
   uint8_t result = 0;
 
   I2CTransaction transaction;
-  transaction
+  transaction.start()
-    .start()
       .write_addr(kPCM5122Address, I2C_MASTER_WRITE)
       .write_ack(DSP_BOOT_POWER_STATE)
       .start()
@@ -61,7 +62,8 @@ std::pair<bool, AudioDac::PowerState> AudioDac::ReadPowerState() {
   return std::pair(is_booted, detail);
 }
 
-bool AudioDac::WaitForPowerState(std::function<bool(bool,AudioDac::PowerState)> predicate) {
+bool AudioDac::WaitForPowerState(
+    std::function<bool(bool, AudioDac::PowerState)> predicate) {
   bool has_matched = false;
   for (int i = 0; i < 10; i++) {
     std::pair<bool, PowerState> result = ReadPowerState();
@@ -69,7 +71,8 @@ bool AudioDac::WaitForPowerState(std::function<bool(bool,AudioDac::PowerState)>
     if (has_matched) {
       break;
     } else {
-      ESP_LOGI(TAG, "Waiting for power state (was %d %x)", result.first, (uint8_t) result.second);
+      ESP_LOGI(TAG, "Waiting for power state (was %d %x)", result.first,
+               (uint8_t)result.second);
       vTaskDelay(pdMS_TO_TICKS(1));
     }
   }
@@ -78,8 +81,7 @@ bool AudioDac::WaitForPowerState(std::function<bool(bool,AudioDac::PowerState)>
 
 void AudioDac::WriteRegister(Register reg, uint8_t val) {
   I2CTransaction transaction;
-    transaction
+  transaction.start()
-      .start()
       .write_addr(kPCM5122Address, I2C_MASTER_WRITE)
       .write_ack(reg, val)
       .stop();

main/dac.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "esp_err.h"
-#include "gpio-expander.h"
 #include <stdint.h>
 #include <functional>
+#include "esp_err.h"
+#include "gpio-expander.h"
 
 namespace gay_ipod {
 

main/gay-ipod-fw.cpp

@@ -1,6 +1,6 @@
-#include <cstdint>
-#include <stdio.h>
 #include <dirent.h>
+#include <stdio.h>
+#include <cstdint>
 
 #include "battery.h"
 #include "dac.h"
@@ -21,9 +21,9 @@
 #include "hal/spi_types.h"
 #include "storage.h"
 
+#include "audio_common.h"
 #include "audio_element.h"
 #include "audio_pipeline.h"
-#include "audio_common.h"
 #include "fatfs_stream.h"
 #include "i2s_stream.h"
 #include "mp3_decoder.h"
@@ -53,7 +53,8 @@ esp_err_t init_i2c(void) {
       .scl_io_num = I2C_SCL_IO,
       .sda_pullup_en = GPIO_PULLUP_ENABLE,
       .scl_pullup_en = GPIO_PULLUP_ENABLE,
-    .master = {
+      .master =
+          {
               .clk_speed = I2C_CLOCK_HZ,
           },
       // No requirements for the clock.
@@ -93,8 +94,7 @@ esp_err_t init_spi(void) {
   return ESP_OK;
 }
 
-extern "C" void app_main(void)
+extern "C" void app_main(void) {
-{
   ESP_LOGI(TAG, "Initialising peripherals");
 
   ESP_ERROR_CHECK(gpio_install_isr_service(ESP_INTR_FLAG_LOWMED));
@@ -153,12 +153,14 @@ extern "C" void app_main(void)
   audio_pipeline_handle_t pipeline;
   audio_element_handle_t fatfs_stream_reader, i2s_stream_writer, audio_decoder;
 
-  audio_pipeline_cfg_t pipeline_config = audio_pipeline_cfg_t(DEFAULT_AUDIO_PIPELINE_CONFIG());
+  audio_pipeline_cfg_t pipeline_config =
+      audio_pipeline_cfg_t(DEFAULT_AUDIO_PIPELINE_CONFIG());
   pipeline = audio_pipeline_init(&pipeline_config);
   assert(pipeline != NULL);
   ESP_LOGI(TAG, "Made pipeline okay.");
 
-  fatfs_stream_cfg_t fatfs_stream_config = fatfs_stream_cfg_t(FATFS_STREAM_CFG_DEFAULT());
+  fatfs_stream_cfg_t fatfs_stream_config =
+      fatfs_stream_cfg_t(FATFS_STREAM_CFG_DEFAULT());
   fatfs_stream_config.type = AUDIO_STREAM_READER;
   fatfs_stream_reader = fatfs_stream_init(&fatfs_stream_config);
   assert(fatfs_stream_reader != NULL);
@@ -185,19 +187,17 @@ extern "C" void app_main(void)
   assert(i2s_stream_writer != NULL);
   ESP_LOGI(TAG, "Made i2s stream okay.");
 
-
   ESP_LOGI(TAG, "Init i2s pins");
-  i2s_pin_config_t pin_config = {
+  i2s_pin_config_t pin_config = {.mck_io_num = GPIO_NUM_0,
-    .mck_io_num = GPIO_NUM_0,
                                  .bck_io_num = GPIO_NUM_26,
                                  .ws_io_num = GPIO_NUM_27,
                                  .data_out_num = GPIO_NUM_5,
-    .data_in_num = I2S_PIN_NO_CHANGE
+                                 .data_in_num = I2S_PIN_NO_CHANGE};
-  };
 
   ESP_ERROR_CHECK(i2s_set_pin(port, &pin_config));
 
-  mp3_decoder_cfg_t decoder_config = mp3_decoder_cfg_t(DEFAULT_MP3_DECODER_CONFIG());
+  mp3_decoder_cfg_t decoder_config =
+      mp3_decoder_cfg_t(DEFAULT_MP3_DECODER_CONFIG());
   audio_decoder = mp3_decoder_init(&decoder_config);
   assert(audio_decoder != NULL);
   ESP_LOGI(TAG, "Made mp3 decoder okay.");

main/gpio-expander.cpp

@@ -76,15 +76,11 @@ GpioExpander::SpiLock GpioExpander::AcquireSpiBus(ChipSelect cs) {
 
 GpioExpander::SpiLock::SpiLock(GpioExpander& gpio, ChipSelect cs)
     : lock_(gpio.cs_mutex_), gpio_(gpio), cs_(cs) {
-  gpio_.with([&](auto& gpio) {
+  gpio_.with([&](auto& gpio) { gpio.set_pin(cs_, 0); });
-      gpio.set_pin(cs_, 0);
-  });
 }
 
 GpioExpander::SpiLock::~SpiLock() {
-  gpio_.with([&](auto& gpio) {
+  gpio_.with([&](auto& gpio) { gpio.set_pin(cs_, 1); });
-      gpio.set_pin(cs_, 1);
-  });
 }
 
 }  // namespace gay_ipod

main/gpio-expander.h

@@ -1,16 +1,16 @@
 #pragma once
 
+#include <stdint.h>
 #include <atomic>
 #include <functional>
 #include <mutex>
-#include <stdint.h>
 #include <tuple>
 #include <utility>
 
+#include "driver/i2c.h"
 #include "esp_check.h"
-#include "esp_log.h"
 #include "esp_err.h"
-#include "driver/i2c.h"
+#include "esp_log.h"
 #include "freertos/FreeRTOS.h"
 
 namespace gay_ipod {
@@ -61,9 +61,7 @@ class GpioExpander {
    * Convenience mehod for packing the port a and b bytes into a single 16 bit
    * value.
    */
-    static uint16_t pack(uint8_t a, uint8_t b) {
+  static uint16_t pack(uint8_t a, uint8_t b) { return ((uint16_t)b) << 8 | a; }
-      return ((uint16_t) b) << 8 | a;
-    }
 
   /*
    * Convenience mehod for unpacking the result of `pack` back into two single
@@ -174,6 +172,7 @@ class GpioExpander {
     ~SpiLock();
 
     SpiLock(const SpiLock&) = delete;
+
    private:
     std::scoped_lock<std::mutex> lock_;
     GpioExpander& gpio_;

main/i2c.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <cstdint>
 #include "driver/i2c.h"
 #include "hal/i2c_types.h"
-#include <cstdint>
 
 namespace gay_ipod {
 
@@ -73,6 +73,7 @@ class I2CTransaction {
   // reference instead.
   I2CTransaction(const I2CTransaction&) = delete;
   I2CTransaction& operator=(const I2CTransaction&) = delete;
+
  private:
   i2c_cmd_handle_t handle_;
 };

main/storage.cpp

@@ -49,7 +49,8 @@ SdStorage::Error SdStorage::Acquire(void) {
   // with our own that acquires the CS mutex for the duration of the SPI
   // transaction.
   auto src = host_.do_transaction;
-  sdspi::do_transaction_wrapper = [=](sdspi_dev_handle_t handle, sdmmc_command_t *cmd) -> esp_err_t {
+  sdspi::do_transaction_wrapper = [=](sdspi_dev_handle_t handle,
+                                      sdmmc_command_t* cmd) -> esp_err_t {
     auto lock = gpio_->AcquireSpiBus(GpioExpander::SD_CARD);
     return src(handle, cmd);
   };

main/storage.h

@@ -12,12 +12,14 @@ namespace gay_ipod {
 // pointer.
 namespace sdspi {
 // Holds a lambda created by SdStorage.
-  static std::function<esp_err_t(sdspi_dev_handle_t,sdmmc_command_t*)> do_transaction_wrapper;
+static std::function<esp_err_t(sdspi_dev_handle_t, sdmmc_command_t*)>
+    do_transaction_wrapper;
 
 // Fits the required function pointer signature, but just delegates to the
 // wrapper function. Does that make this the wrapper? Who knows.
 __attribute__((unused))  // (gcc incorrectly thinks this is unused)
-  static esp_err_t do_transaction(sdspi_dev_handle_t handle, sdmmc_command_t *cmdinfo) {
+static esp_err_t
+do_transaction(sdspi_dev_handle_t handle, sdmmc_command_t* cmdinfo) {
   return do_transaction_wrapper(handle, cmdinfo);
 }
 }  // namespace sdspi