clang format

Author: joeloftusdev

.clang-format

@@ -0,0 +1,31 @@
+---
+BasedOnStyle: LLVM
+IndentWidth: 4
+---
+Language: Cpp
+BasedOnStyle: LLVM
+IndentWidth: 4
+AlignAfterOpenBracket: Align
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel:  true
+  AfterClass:      true
+  AfterControlStatement: Always
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  true
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  AfterExternBlock: true
+  BeforeCatch:     true
+  BeforeElse:      true
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+ColumnLimit: 100
+SortIncludes: false
+---

src-cli/crepe.cpp

@@ -6,124 +6,148 @@
 
 #define MINIAUDIO_IMPLEMENTATION
 #include "miniaudio.h"
-#include "../src/crepe.hpp"
+#include "crepe.hpp"
 
 
-class AudioProcessor {
+class AudioProcessor
+{
 private:
     moodycamel::ReaderWriterQueue<float> queue;
     std::atomic<bool> finished{false};
     size_t frame_size;
-    
+
 public:
-    explicit AudioProcessor(const size_t size) : queue(size * 10), frame_size(size) {}
-    
-    void push(const float* data, const size_t count) {
-        for (size_t i = 0; i < count; i++) {
+    explicit AudioProcessor(const size_t size) : queue(size * 10), frame_size(size)
+    {
+    }
+
+    void push(const float *data, const size_t count)
+    {
+        for (size_t i = 0; i < count; i++)
+        {
             queue.enqueue(data[i]);
         }
     }
-    
-    bool get_frame(std::vector<float>& frame) {
-        if (finished && queue.size_approx() < frame_size) {
+
+    bool get_frame(std::vector<float> &frame)
+    {
+        if (finished && queue.size_approx() < frame_size)
+        {
             return false;
         }
-        
+
         //until we have enough data
-        while (queue.size_approx() < frame_size && !finished) {
+        while (queue.size_approx() < frame_size && !finished)
+        {
             std::this_thread::sleep_for(std::chrono::milliseconds(1));
         }
-        
-        if (queue.size_approx() < frame_size) {
+
+        if (queue.size_approx() < frame_size)
+        {
             return false;
         }
-        
+
         frame.resize(frame_size);
-        for (size_t i = 0; i < frame_size; i++) {
+        for (size_t i = 0; i < frame_size; i++)
+        {
             float value;
-            if (bool success = queue.try_dequeue(value); !success) return false;
+            if (bool success = queue.try_dequeue(value); !success)
+                return false;
             frame[i] = value;
         }
         return true;
     }
-    
-    void set_finished() {
+
+    void set_finished()
+    {
         finished = true;
     }
 };
 
 //miniaudio callbacl
-void data_callback(ma_device* device, void* output, const void* input, ma_uint32 frame_count) {
-    auto* processor = static_cast<AudioProcessor*>(device->pUserData);
-    const auto* in_samples = static_cast<const float*>(input);
-    
+void data_callback(ma_device *device, void *output, const void *input, ma_uint32 frame_count)
+{
+    auto *processor = static_cast<AudioProcessor *>(device->pUserData);
+    const auto *in_samples = static_cast<const float *>(input);
+
     //push
     processor->push(in_samples, frame_count * device->capture.channels);
-    
+
     // clear if it's required
-    if (output != nullptr) {
+    if (output != nullptr)
+    {
         memset(output, 0, frame_count * device->playback.channels * sizeof(float));
     }
 }
 
-int main() {
-    try {
+int main()
+{
+    try
+    {
         //init miniaudio
         ma_device_config config = ma_device_config_init(ma_device_type_capture);
         config.capture.format = ma_format_f32;
-        config.capture.channels = 1;  // Mono for simplicity
+        config.capture.channels = 1; // Mono for simplicity
         config.sampleRate = crepe::constants::SAMPLE_RATE;
         config.dataCallback = data_callback;
 
         AudioProcessor processor(crepe::constants::FRAME_LENGTH);
         config.pUserData = &processor;
-        
+
         ma_device device;
-        if (ma_device_init(nullptr, &config, &device) != MA_SUCCESS) {
+        if (ma_device_init(nullptr, &config, &device) != MA_SUCCESS)
+        {
             std::cerr << "Error: Failed to initialize audio device" << std::endl;
         }
-        
-        if (ma_device_start(&device) != MA_SUCCESS) {
+
+        if (ma_device_start(&device) != MA_SUCCESS)
+        {
             ma_device_uninit(&device);
             std::cerr << "Error: Failed to start audio device" << std::endl;
         }
 
-        
         std::cout << "Recording. Press Enter to stop." << std::endl;
-        
+
         //analysis thread
         std::atomic<bool> running{true};
         std::thread analysis_thread([&]() {
             std::vector<float> frame;
-            while (running) {
-                if (processor.get_frame(frame)) {
+            while (running)
+            {
+                if (processor.get_frame(frame))
+                {
                     // Run inference on the frame
                     // Display the detected pitch
-                    if (crepe::PredictionResults results = crepe::run_inference(frame, crepe::constants::SAMPLE_RATE); results.num_frames > 0) {
-                        std::cout << "Pitch: " << results.pitches(0) << " Hz, Confidence: " 
-                                  << results.confidences(0) << "   \r" << std::flush;
+                    if (crepe::PredictionResults results = crepe::run_inference(
+                        frame, crepe::constants::SAMPLE_RATE); results.num_frames > 0)
+                    {
+                        std::cout << "Pitch: " << results.pitches(0) << " Hz, Confidence: "
+                            << results.confidences(0) << "   \r" << std::flush;
                     }
                 }
             }
         });
-        
+
         // Wait for user to press Enter
         std::cin.get();
 
         running = false;
         processor.set_finished();
-        
-        if (analysis_thread.joinable()) {
+
+        if (analysis_thread.joinable())
+        {
             analysis_thread.join();
         }
-        
+
         ma_device_uninit(&device);
         std::cout << "\nRecording stopped." << std::endl;
-        
-    } catch (const std::exception& e) {
+
+    }
+    catch (const std::exception &e)
+    {
         std::cerr << "Error: " << e.what() << std::endl;
         return 1;
     }
-    
+
     return 0;
 }

src-test/crepe.cpp

@@ -8,59 +8,73 @@
 #include "../deps/miniaudio/miniaudio.h"
 #include <iostream>
 
-std::vector<float> load_wav_file(const std::string &filename, int *out_sample_rate, std::string *error_msg) {
+std::vector<float> load_wav_file(const std::string &filename, int *out_sample_rate,
+                                 std::string *error_msg)
+{
     ma_decoder decoder;
 
-    if (const ma_result result = ma_decoder_init_file(filename.c_str(), nullptr, &decoder); result != MA_SUCCESS) {
-        if (error_msg) *error_msg = "Failed to initialize decoder for file: " + filename;
+    if (const ma_result result = ma_decoder_init_file(filename.c_str(), nullptr, &decoder);
+        result != MA_SUCCESS)
+    {
+        if (error_msg)
+            *error_msg = "Failed to initialize decoder for file: " + filename;
         return {};
     }
 
-    if (out_sample_rate) {
+    if (out_sample_rate)
+    {
         *out_sample_rate = static_cast<int>(decoder.outputSampleRate);
         std::cout << "Debug: Detected sample rate: " << *out_sample_rate << "Hz" << std::endl;
     }
 
     ma_uint64 frame_count;
     ma_decoder_get_length_in_pcm_frames(&decoder, &frame_count);
 
-
-    if (out_sample_rate) {
+    if (out_sample_rate)
+    {
         *out_sample_rate = decoder.outputSampleRate;
     }
 
     const bool needs_conversion = decoder.outputChannels > 1;
 
     std::vector<float> audio_data(frame_count);
 
-    if (needs_conversion) {
+    if (needs_conversion)
+    {
         std::vector<float> multi_channel_data(frame_count * decoder.outputChannels);
         const ma_uint64 frames_read =
-                ma_decoder_read_pcm_frames(&decoder, multi_channel_data.data(), frame_count, nullptr);
+            ma_decoder_read_pcm_frames(&decoder, multi_channel_data.data(), frame_count, nullptr);
 
-        for (ma_uint64 i = 0; i < frames_read; i++) {
+        for (ma_uint64 i = 0; i < frames_read; i++)
+        {
             float sum = 0.0f;
-            for (ma_uint32 c = 0; c < decoder.outputChannels; c++) {
+            for (ma_uint32 c = 0; c < decoder.outputChannels; c++)
+            {
                 sum += multi_channel_data[i * decoder.outputChannels + c];
             }
             audio_data[i] = sum / decoder.outputChannels;
         }
-    } else {
+    }
+    else
+    {
         ma_decoder_read_pcm_frames(&decoder, audio_data.data(), frame_count, nullptr);
     }
 
     ma_decoder_uninit(&decoder);
     return audio_data;
 }
 
-int main() {
-    try {
+int main()
+{
+    try
+    {
         // enable this to debug frequency mapping
         //crepe::analyze_frequency_bins();
 
         const std::string wav_file_path = "sweep.wav";
         std::ifstream file_check(wav_file_path);
-        if (!file_check) {
+        if (!file_check)
+        {
             std::cerr << "Error: Cannot open file at path: " << wav_file_path << std::endl;
             return 1;
         }
@@ -80,18 +94,23 @@ int main() {
         std::cout << "Mean confidence: " << analytics.mean_confidence << std::endl;
 
         std::cout << "Sample frequencies (Hz): [";
-        for (int i = 0; i < std::min(5, results.num_frames); i++) {
+        for (int i = 0; i < std::min(5, results.num_frames); i++)
+        {
             std::cout << results.pitches(i);
-            if (i < std::min(4, results.num_frames - 1)) std::cout << " ";
+            if (i < std::min(4, results.num_frames - 1))
+                std::cout << " ";
         }
         std::cout << "]" << std::endl;
 
         std::cout << "Min frequency: " << analytics.min_frequency << std::endl;
         std::cout << "Max frequency: " << analytics.max_frequency << std::endl;
-        std::cout << "Correlation between time and frequency: " << analytics.time_pitch_correlation << std::endl;
+        std::cout << "Correlation between time and frequency: " << analytics.time_pitch_correlation
+            << std::endl;
         std::cout << "Should be close to 1.0 for frequency sweep" << std::endl;
 
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception &e)
+    {
         std::cerr << "Error: " << e.what() << std::endl;
         return 1;
     }