Merge pull request #4362 from microDev1/code-formatting

Add code formatting and translations check

6 files changed, 106 insertions, 106 deletions

diff --git a/shared-module/audiocore/RawSample.c b/shared-module/audiocore/RawSample.c
index 316a1c69f..1f1db0a50 100644
--- a/shared-module/audiocore/RawSample.c
+++ b/shared-module/audiocore/RawSample.c
@@ -30,13 +30,13 @@
 
 #include "shared-module/audiocore/RawSample.h"
 
-void common_hal_audioio_rawsample_construct(audioio_rawsample_obj_t* self,
-                                            uint8_t* buffer,
-                                            uint32_t len,
-                                            uint8_t bytes_per_sample,
-                                            bool samples_signed,
-                                            uint8_t channel_count,
-                                            uint32_t sample_rate) {
+void common_hal_audioio_rawsample_construct(audioio_rawsample_obj_t *self,
+    uint8_t *buffer,
+    uint32_t len,
+    uint8_t bytes_per_sample,
+    bool samples_signed,
+    uint8_t channel_count,
+    uint32_t sample_rate) {
     self->buffer = buffer;
     self->bits_per_sample = bytes_per_sample * 8;
     self->samples_signed = samples_signed;
@@ -45,37 +45,37 @@ void common_hal_audioio_rawsample_construct(audioio_rawsample_obj_t* self,
     self->sample_rate = sample_rate;
 }
 
-void common_hal_audioio_rawsample_deinit(audioio_rawsample_obj_t* self) {
+void common_hal_audioio_rawsample_deinit(audioio_rawsample_obj_t *self) {
     self->buffer = NULL;
 }
-bool common_hal_audioio_rawsample_deinited(audioio_rawsample_obj_t* self) {
+bool common_hal_audioio_rawsample_deinited(audioio_rawsample_obj_t *self) {
     return self->buffer == NULL;
 }
 
-uint32_t common_hal_audioio_rawsample_get_sample_rate(audioio_rawsample_obj_t* self) {
+uint32_t common_hal_audioio_rawsample_get_sample_rate(audioio_rawsample_obj_t *self) {
     return self->sample_rate;
 }
-void common_hal_audioio_rawsample_set_sample_rate(audioio_rawsample_obj_t* self,
-                                                  uint32_t sample_rate) {
+void common_hal_audioio_rawsample_set_sample_rate(audioio_rawsample_obj_t *self,
+    uint32_t sample_rate) {
     self->sample_rate = sample_rate;
 }
-uint8_t common_hal_audioio_rawsample_get_bits_per_sample(audioio_rawsample_obj_t* self) {
+uint8_t common_hal_audioio_rawsample_get_bits_per_sample(audioio_rawsample_obj_t *self) {
     return self->bits_per_sample;
 }
-uint8_t common_hal_audioio_rawsample_get_channel_count(audioio_rawsample_obj_t* self) {
+uint8_t common_hal_audioio_rawsample_get_channel_count(audioio_rawsample_obj_t *self) {
     return self->channel_count;
 }
 
-void audioio_rawsample_reset_buffer(audioio_rawsample_obj_t* self,
-                                    bool single_channel,
-                                    uint8_t channel) {
+void audioio_rawsample_reset_buffer(audioio_rawsample_obj_t *self,
+    bool single_channel,
+    uint8_t channel) {
 }
 
-audioio_get_buffer_result_t audioio_rawsample_get_buffer(audioio_rawsample_obj_t* self,
-                                                         bool single_channel,
-                                                         uint8_t channel,
-                                                         uint8_t** buffer,
-                                                         uint32_t* buffer_length) {
+audioio_get_buffer_result_t audioio_rawsample_get_buffer(audioio_rawsample_obj_t *self,
+    bool single_channel,
+    uint8_t channel,
+    uint8_t **buffer,
+    uint32_t *buffer_length) {
     *buffer_length = self->len;
     if (single_channel) {
         *buffer = self->buffer + (channel % self->channel_count) * (self->bits_per_sample / 8);
@@ -85,9 +85,9 @@ audioio_get_buffer_result_t audioio_rawsample_get_buffer(audioio_rawsample_obj_t
     return GET_BUFFER_DONE;
 }
 
-void audioio_rawsample_get_buffer_structure(audioio_rawsample_obj_t* self, bool single_channel,
-                                            bool* single_buffer, bool* samples_signed,
-                                            uint32_t* max_buffer_length, uint8_t* spacing) {
+void audioio_rawsample_get_buffer_structure(audioio_rawsample_obj_t *self, bool single_channel,
+    bool *single_buffer, bool *samples_signed,
+    uint32_t *max_buffer_length, uint8_t *spacing) {
     *single_buffer = true;
     *samples_signed = self->samples_signed;
     *max_buffer_length = self->len;
diff --git a/shared-module/audiocore/RawSample.h b/shared-module/audiocore/RawSample.h
index 2ea8c89f4..8208b4c28 100644
--- a/shared-module/audiocore/RawSample.h
+++ b/shared-module/audiocore/RawSample.h
@@ -33,7 +33,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    uint8_t* buffer;
+    uint8_t *buffer;
     uint32_t len;
     uint8_t bits_per_sample;
     bool samples_signed;
@@ -43,16 +43,16 @@ typedef struct {
 
 
 // These are not available from Python because it may be called in an interrupt.
-void audioio_rawsample_reset_buffer(audioio_rawsample_obj_t* self,
-                                    bool single_channel,
-                                    uint8_t channel);
-audioio_get_buffer_result_t audioio_rawsample_get_buffer(audioio_rawsample_obj_t* self,
-                                                         bool single_channel,
-                                                         uint8_t channel,
-                                                         uint8_t** buffer,
-                                                         uint32_t* buffer_length); // length in bytes
-void audioio_rawsample_get_buffer_structure(audioio_rawsample_obj_t* self, bool single_channel,
-                                            bool* single_buffer, bool* samples_signed,
-                                            uint32_t* max_buffer_length, uint8_t* spacing);
+void audioio_rawsample_reset_buffer(audioio_rawsample_obj_t *self,
+    bool single_channel,
+    uint8_t channel);
+audioio_get_buffer_result_t audioio_rawsample_get_buffer(audioio_rawsample_obj_t *self,
+    bool single_channel,
+    uint8_t channel,
+    uint8_t **buffer,
+    uint32_t *buffer_length);                                                      // length in bytes
+void audioio_rawsample_get_buffer_structure(audioio_rawsample_obj_t *self, bool single_channel,
+    bool *single_buffer, bool *samples_signed,
+    uint32_t *max_buffer_length, uint8_t *spacing);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_RAWSAMPLE_H
diff --git a/shared-module/audiocore/WaveFile.c b/shared-module/audiocore/WaveFile.c
index 0248d42e2..4864004d5 100644
--- a/shared-module/audiocore/WaveFile.c
+++ b/shared-module/audiocore/WaveFile.c
@@ -45,10 +45,10 @@ struct wave_format_chunk {
     uint16_t extra_params; // Assumed to be zero below.
 };
 
-void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
-                                           pyb_file_obj_t* file,
-                                           uint8_t *buffer,
-                                           size_t buffer_size) {
+void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t *self,
+    pyb_file_obj_t *file,
+    uint8_t *buffer,
+    size_t buffer_size) {
     // Load the wave
     self->file = file;
     uint8_t chunk_header[16];
@@ -96,7 +96,7 @@ void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
         mp_raise_OSError(MP_EIO);
     }
     if (bytes_read != 4 ||
-        memcmp((uint8_t *) data_tag, "data", 4) != 0) {
+        memcmp((uint8_t *)data_tag, "data", 4) != 0) {
         mp_raise_ValueError(translate("Data chunk must follow fmt chunk"));
     }
 
@@ -122,55 +122,55 @@ void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
         if (self->buffer == NULL) {
             common_hal_audioio_wavefile_deinit(self);
             mp_raise_msg(&mp_type_MemoryError,
-                         translate("Couldn't allocate first buffer"));
+                translate("Couldn't allocate first buffer"));
         }
 
         self->second_buffer = m_malloc(self->len, false);
         if (self->second_buffer == NULL) {
             common_hal_audioio_wavefile_deinit(self);
             mp_raise_msg(&mp_type_MemoryError,
-                         translate("Couldn't allocate second buffer"));
+                translate("Couldn't allocate second buffer"));
         }
     }
 }
 
-void common_hal_audioio_wavefile_deinit(audioio_wavefile_obj_t* self) {
+void common_hal_audioio_wavefile_deinit(audioio_wavefile_obj_t *self) {
     self->buffer = NULL;
     self->second_buffer = NULL;
 }
 
-bool common_hal_audioio_wavefile_deinited(audioio_wavefile_obj_t* self) {
+bool common_hal_audioio_wavefile_deinited(audioio_wavefile_obj_t *self) {
     return self->buffer == NULL;
 }
 
-uint32_t common_hal_audioio_wavefile_get_sample_rate(audioio_wavefile_obj_t* self) {
+uint32_t common_hal_audioio_wavefile_get_sample_rate(audioio_wavefile_obj_t *self) {
     return self->sample_rate;
 }
 
-void common_hal_audioio_wavefile_set_sample_rate(audioio_wavefile_obj_t* self,
-                                                 uint32_t sample_rate) {
+void common_hal_audioio_wavefile_set_sample_rate(audioio_wavefile_obj_t *self,
+    uint32_t sample_rate) {
     self->sample_rate = sample_rate;
 }
 
-uint8_t common_hal_audioio_wavefile_get_bits_per_sample(audioio_wavefile_obj_t* self) {
+uint8_t common_hal_audioio_wavefile_get_bits_per_sample(audioio_wavefile_obj_t *self) {
     return self->bits_per_sample;
 }
 
-uint8_t common_hal_audioio_wavefile_get_channel_count(audioio_wavefile_obj_t* self) {
+uint8_t common_hal_audioio_wavefile_get_channel_count(audioio_wavefile_obj_t *self) {
     return self->channel_count;
 }
 
-bool audioio_wavefile_samples_signed(audioio_wavefile_obj_t* self) {
+bool audioio_wavefile_samples_signed(audioio_wavefile_obj_t *self) {
     return self->bits_per_sample > 8;
 }
 
-uint32_t audioio_wavefile_max_buffer_length(audioio_wavefile_obj_t* self) {
+uint32_t audioio_wavefile_max_buffer_length(audioio_wavefile_obj_t *self) {
     return 512;
 }
 
-void audioio_wavefile_reset_buffer(audioio_wavefile_obj_t* self,
-                                   bool single_channel,
-                                   uint8_t channel) {
+void audioio_wavefile_reset_buffer(audioio_wavefile_obj_t *self,
+    bool single_channel,
+    uint8_t channel) {
     if (single_channel && channel == 1) {
         return;
     }
@@ -183,11 +183,11 @@ void audioio_wavefile_reset_buffer(audioio_wavefile_obj_t* self,
     self->right_read_count = 0;
 }
 
-audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t* self,
-                                                        bool single_channel,
-                                                        uint8_t channel,
-                                                        uint8_t** buffer,
-                                                        uint32_t* buffer_length) {
+audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t *self,
+    bool single_channel,
+    uint8_t channel,
+    uint8_t **buffer,
+    uint32_t *buffer_length) {
     if (!single_channel) {
         channel = 0;
     }
@@ -226,13 +226,13 @@ audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t*
             length_read += pad;
             if (self->bits_per_sample == 8) {
                 for (uint32_t i = 0; i < pad; i++) {
-                    ((uint8_t*) (*buffer))[length_read / sizeof(uint8_t) - i - 1] = 0x80;
+                    ((uint8_t *)(*buffer))[length_read / sizeof(uint8_t) - i - 1] = 0x80;
                 }
             } else if (self->bits_per_sample == 16) {
                 // We know the buffer is aligned because we allocated it onto the heap ourselves.
                 #pragma GCC diagnostic push
                 #pragma GCC diagnostic ignored "-Wcast-align"
-                ((int16_t*) (*buffer))[length_read / sizeof(int16_t) - 1] = 0;
+                ((int16_t *)(*buffer))[length_read / sizeof(int16_t) - 1] = 0;
                 #pragma GCC diagnostic pop
             }
         }
@@ -265,9 +265,9 @@ audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t*
     return self->bytes_remaining == 0 ? GET_BUFFER_DONE : GET_BUFFER_MORE_DATA;
 }
 
-void audioio_wavefile_get_buffer_structure(audioio_wavefile_obj_t* self, bool single_channel,
-                                           bool* single_buffer, bool* samples_signed,
-                                           uint32_t* max_buffer_length, uint8_t* spacing) {
+void audioio_wavefile_get_buffer_structure(audioio_wavefile_obj_t *self, bool single_channel,
+    bool *single_buffer, bool *samples_signed,
+    uint32_t *max_buffer_length, uint8_t *spacing) {
     *single_buffer = false;
     *samples_signed = self->bits_per_sample > 8;
     *max_buffer_length = 512;
diff --git a/shared-module/audiocore/WaveFile.h b/shared-module/audiocore/WaveFile.h
index 3eecbf15c..80b2fd3a5 100644
--- a/shared-module/audiocore/WaveFile.h
+++ b/shared-module/audiocore/WaveFile.h
@@ -34,9 +34,9 @@
 
 typedef struct {
     mp_obj_base_t base;
-    uint8_t* buffer;
+    uint8_t *buffer;
     uint32_t buffer_length;
-    uint8_t* second_buffer;
+    uint8_t *second_buffer;
     uint32_t second_buffer_length;
     uint32_t file_length; // In bytes
     uint16_t data_start; // Where the data values start
@@ -48,7 +48,7 @@ typedef struct {
     uint32_t sample_rate;
 
     uint32_t len;
-    pyb_file_obj_t* file;
+    pyb_file_obj_t *file;
 
     uint32_t read_count;
     uint32_t left_read_count;
@@ -56,16 +56,16 @@ typedef struct {
 } audioio_wavefile_obj_t;
 
 // These are not available from Python because it may be called in an interrupt.
-void audioio_wavefile_reset_buffer(audioio_wavefile_obj_t* self,
-                                   bool single_channel,
-                                   uint8_t channel);
-audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t* self,
-                                                        bool single_channel,
-                                                        uint8_t channel,
-                                                        uint8_t** buffer,
-                                                        uint32_t* buffer_length); // length in bytes
-void audioio_wavefile_get_buffer_structure(audioio_wavefile_obj_t* self, bool single_channel,
-                                           bool* single_buffer, bool* samples_signed,
-                                           uint32_t* max_buffer_length, uint8_t* spacing);
+void audioio_wavefile_reset_buffer(audioio_wavefile_obj_t *self,
+    bool single_channel,
+    uint8_t channel);
+audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t *self,
+    bool single_channel,
+    uint8_t channel,
+    uint8_t **buffer,
+    uint32_t *buffer_length);                                                     // length in bytes
+void audioio_wavefile_get_buffer_structure(audioio_wavefile_obj_t *self, bool single_channel,
+    bool *single_buffer, bool *samples_signed,
+    uint32_t *max_buffer_length, uint8_t *spacing);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_WAVEFILE_H
diff --git a/shared-module/audiocore/__init__.c b/shared-module/audiocore/__init__.c
index 7bdfe460c..605eac70b 100644
--- a/shared-module/audiocore/__init__.c
+++ b/shared-module/audiocore/__init__.c
@@ -56,23 +56,23 @@ void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t
 }
 
 audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
-                                                   bool single_channel,
-                                                   uint8_t channel,
-                                                   uint8_t** buffer, uint32_t* buffer_length) {
+    bool single_channel,
+    uint8_t channel,
+    uint8_t **buffer, uint32_t *buffer_length) {
     const audiosample_p_t *proto = mp_proto_get_or_throw(MP_QSTR_protocol_audiosample, sample_obj);
     return proto->get_buffer(MP_OBJ_TO_PTR(sample_obj), single_channel, channel, buffer, buffer_length);
 }
 
 void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
-                                      bool* single_buffer, bool* samples_signed,
-                                      uint32_t* max_buffer_length, uint8_t* spacing) {
+    bool *single_buffer, bool *samples_signed,
+    uint32_t *max_buffer_length, uint8_t *spacing) {
     const audiosample_p_t *proto = mp_proto_get_or_throw(MP_QSTR_protocol_audiosample, sample_obj);
     proto->get_buffer_structure(MP_OBJ_TO_PTR(sample_obj), single_channel, single_buffer,
         samples_signed, max_buffer_length, spacing);
 }
 
 void audiosample_convert_u8m_s16s(int16_t *buffer_out, const uint8_t *buffer_in, size_t nframes) {
-    for(;nframes--;) {
+    for (; nframes--;) {
         int16_t sample = (*buffer_in++ - 0x80) << 8;
         *buffer_out++ = sample;
         *buffer_out++ = sample;
@@ -81,15 +81,15 @@ void audiosample_convert_u8m_s16s(int16_t *buffer_out, const uint8_t *buffer_in,
 
 
 void audiosample_convert_u8s_s16s(int16_t *buffer_out, const uint8_t *buffer_in, size_t nframes) {
-    size_t nsamples = 2*nframes;
-    for(;nsamples--;) {
+    size_t nsamples = 2 * nframes;
+    for (; nsamples--;) {
         int16_t sample = (*buffer_in++ - 0x80) << 8;
         *buffer_out++ = sample;
     }
 }
 
 void audiosample_convert_s8m_s16s(int16_t *buffer_out, const int8_t *buffer_in, size_t nframes) {
-    for(;nframes--;) {
+    for (; nframes--;) {
         int16_t sample = (*buffer_in++) << 8;
         *buffer_out++ = sample;
         *buffer_out++ = sample;
@@ -98,8 +98,8 @@ void audiosample_convert_s8m_s16s(int16_t *buffer_out, const int8_t *buffer_in,
 
 
 void audiosample_convert_s8s_s16s(int16_t *buffer_out, const int8_t *buffer_in, size_t nframes) {
-    size_t nsamples = 2*nframes;
-    for(;nsamples--;) {
+    size_t nsamples = 2 * nframes;
+    for (; nsamples--;) {
         int16_t sample = (*buffer_in++) << 8;
         *buffer_out++ = sample;
     }
@@ -107,7 +107,7 @@ void audiosample_convert_s8s_s16s(int16_t *buffer_out, const int8_t *buffer_in,
 
 
 void audiosample_convert_u16m_s16s(int16_t *buffer_out, const uint16_t *buffer_in, size_t nframes) {
-    for(;nframes--;) {
+    for (; nframes--;) {
         int16_t sample = *buffer_in++ - 0x8000;
         *buffer_out++ = sample;
         *buffer_out++ = sample;
@@ -116,15 +116,15 @@ void audiosample_convert_u16m_s16s(int16_t *buffer_out, const uint16_t *buffer_i
 
 
 void audiosample_convert_u16s_s16s(int16_t *buffer_out, const uint16_t *buffer_in, size_t nframes) {
-    size_t nsamples = 2*nframes;
-    for(;nsamples--;) {
+    size_t nsamples = 2 * nframes;
+    for (; nsamples--;) {
         int16_t sample = *buffer_in++ - 0x8000;
         *buffer_out++ = sample;
     }
 }
 
 void audiosample_convert_s16m_s16s(int16_t *buffer_out, const int16_t *buffer_in, size_t nframes) {
-    for(;nframes--;) {
+    for (; nframes--;) {
         int16_t sample = *buffer_in++;
         *buffer_out++ = sample;
         *buffer_out++ = sample;
diff --git a/shared-module/audiocore/__init__.h b/shared-module/audiocore/__init__.h
index ec2cf1cfa..69955a25f 100644
--- a/shared-module/audiocore/__init__.h
+++ b/shared-module/audiocore/__init__.h
@@ -43,14 +43,14 @@ typedef uint32_t (*audiosample_sample_rate_fun)(mp_obj_t);
 typedef uint8_t (*audiosample_bits_per_sample_fun)(mp_obj_t);
 typedef uint8_t (*audiosample_channel_count_fun)(mp_obj_t);
 typedef void (*audiosample_reset_buffer_fun)(mp_obj_t,
-        bool single_channel, uint8_t audio_channel);
+    bool single_channel, uint8_t audio_channel);
 typedef audioio_get_buffer_result_t (*audiosample_get_buffer_fun)(mp_obj_t,
-        bool single_channel, uint8_t channel, uint8_t** buffer,
-        uint32_t* buffer_length);
+    bool single_channel, uint8_t channel, uint8_t **buffer,
+    uint32_t *buffer_length);
 typedef void (*audiosample_get_buffer_structure_fun)(mp_obj_t,
-        bool single_channel, bool* single_buffer,
-        bool* samples_signed, uint32_t *max_buffer_length,
-        uint8_t* spacing);
+    bool single_channel, bool *single_buffer,
+    bool *samples_signed, uint32_t *max_buffer_length,
+    uint8_t *spacing);
 
 typedef struct _audiosample_p_t {
     MP_PROTOCOL_HEAD // MP_QSTR_protocol_audiosample
@@ -67,12 +67,12 @@ uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj);
 uint8_t audiosample_channel_count(mp_obj_t sample_obj);
 void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t audio_channel);
 audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
-                                                   bool single_channel,
-                                                   uint8_t channel,
-                                                   uint8_t** buffer, uint32_t* buffer_length);
+    bool single_channel,
+    uint8_t channel,
+    uint8_t **buffer, uint32_t *buffer_length);
 void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
-                                      bool* single_buffer, bool* samples_signed,
-                                      uint32_t* max_buffer_length, uint8_t* spacing);
+    bool *single_buffer, bool *samples_signed,
+    uint32_t *max_buffer_length, uint8_t *spacing);
 
 void audiosample_convert_u8m_s16s(int16_t *buffer_out, const uint8_t *buffer_in, size_t nframes);
 void audiosample_convert_u8s_s16s(int16_t *buffer_out, const uint8_t *buffer_in, size_t nframes);