run clang format

Author: oliviamiller

src/viam/examples/modules/audioin/client.cpp

@@ -1,7 +1,7 @@
+#include <fstream>
 #include <iostream>
 #include <memory>
 #include <string>
-#include <fstream>
 #include <vector>
 
 #include <viam/sdk/common/instance.hpp>
@@ -66,8 +66,8 @@ int main() {
     auto chunk_handler = [&](AudioIn::audio_chunk&& chunk) -> bool {
         chunk_count++;
         VIAM_SDK_LOG(info) << "Received chunk " << chunk_count
-                          << " - length: " << chunk.audio_data.size()
-                          << " bytes, timestamp: " << chunk.start_timestamp_ns;
+                           << " - length: " << chunk.audio_data.size()
+                           << " bytes, timestamp: " << chunk.start_timestamp_ns;
 
         for (const auto& byte : chunk.audio_data) {
             all_audio_data.push_back(static_cast<uint8_t>(byte));

src/viam/examples/modules/audioin/main.cpp

@@ -1,16 +1,16 @@
+#include <chrono>
+#include <cmath>
+#include <cstring>
 #include <iostream>
 #include <memory>
 #include <sstream>
-#include <cmath>
-#include <cstring>
 #include <vector>
-#include <chrono>
 
 #include <viam/sdk/common/exception.hpp>
 #include <viam/sdk/common/instance.hpp>
 #include <viam/sdk/common/proto_value.hpp>
-#include <viam/sdk/components/sensor.hpp>
 #include <viam/sdk/components/audio_in.hpp>
+#include <viam/sdk/components/sensor.hpp>
 #include <viam/sdk/config/resource.hpp>
 #include <viam/sdk/log/logging.hpp>
 #include <viam/sdk/module/service.hpp>
@@ -39,10 +39,10 @@ class SineWaveAudioIn : public AudioIn, public Reconfigurable {
     properties get_properties(const ProtoStruct&) override;
 
     void get_audio(std::string const& codec,
-                            std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
-                            double const& duration_seconds,
-                            int64_t const& previous_timestamp,
-                            const ProtoStruct& extra) override;
+                   std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
+                   double const& duration_seconds,
+                   int64_t const& previous_timestamp,
+                   const ProtoStruct& extra) override;
 
    private:
     double frequency_{440.0};
@@ -88,21 +88,19 @@ AudioIn::properties SineWaveAudioIn::get_properties(const ProtoStruct&) {
 }
 
 void SineWaveAudioIn::get_audio(std::string const& codec,
-                            std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
-                            double const& duration_seconds,
-                            int64_t const& previous_timestamp,
-                            const ProtoStruct& extra) {
-
-
+                                std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
+                                double const& duration_seconds,
+                                int64_t const& previous_timestamp,
+                                const ProtoStruct& extra) {
     const int sample_rate = 44100;  // 44.1 kHz
-    const double amplitude = 0.5;    // Half volume
-    const int chunk_size = 1024;     // Samples per chunk
+    const double amplitude = 0.5;   // Half volume
+    const int chunk_size = 1024;    // Samples per chunk
 
     int total_samples = static_cast<int>(duration_seconds * sample_rate);
     int num_chunks = (total_samples + chunk_size - 1) / chunk_size;
 
-    VIAM_RESOURCE_LOG(info) << "Generating sine wave: " << frequency_ << "Hz, "
-                           << duration_seconds << "s, " << num_chunks << " chunks";
+    VIAM_RESOURCE_LOG(info) << "Generating sine wave: " << frequency_ << "Hz, " << duration_seconds
+                            << "s, " << num_chunks << " chunks";
 
     for (int chunk_idx = 0; chunk_idx < num_chunks; ++chunk_idx) {
         int samples_in_chunk = std::min(chunk_size, total_samples - (chunk_idx * chunk_size));
@@ -133,8 +131,8 @@ void SineWaveAudioIn::get_audio(std::string const& codec,
 
         // Get current timestamp in nanoseconds
         auto now = std::chrono::system_clock::now();
-        auto nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(
-            now.time_since_epoch()).count();
+        auto nanos =
+            std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
         chunk.start_timestamp_ns = nanos;
         chunk.end_timestamp_ns = nanos;
         chunk.sequence = chunk_idx;
@@ -154,7 +152,6 @@ int main(int argc, char** argv) try {
     // any other C++ SDK objects and stays alive until all Viam C++ SDK objects are destroyed.
     Instance inst;
 
-
     Model sinewave_model("viam", "audio_in", "sinewave");
 
     std::shared_ptr<ModelRegistration> mr = std::make_shared<ModelRegistration>(

src/viam/sdk/components/audio_in.cpp

@@ -19,8 +19,7 @@ AudioIn::AudioIn(std::string name) : Component(std::move(name)) {}
 
 bool operator==(const AudioIn::properties& lhs, const AudioIn::properties& rhs) {
     return lhs.supported_codecs == rhs.supported_codecs &&
-           lhs.sample_rate_hz == rhs.sample_rate_hz &&
-           lhs.sample_rate_hz == rhs.sample_rate_hz;
+           lhs.sample_rate_hz == rhs.sample_rate_hz && lhs.sample_rate_hz == rhs.sample_rate_hz;
 }
 
 }  // namespace sdk

src/viam/sdk/components/audio_in.hpp

@@ -9,7 +9,6 @@
 #include <viam/sdk/common/utils.hpp>
 #include <viam/sdk/config/resource.hpp>
 
-
 namespace viam {
 namespace sdk {
 
@@ -22,7 +21,7 @@ namespace sdk {
 /// This acts as an abstract parent class to be inherited from by any drivers representing
 /// specific AudioIn implementations. This class cannot be used on its own.
 class AudioIn : public Component {
-    public:
+   public:
     /// @struct properties
     /// @brief properties of the AudioIn component
     struct properties {
@@ -31,7 +30,6 @@ class AudioIn : public Component {
         int num_channels;
     };
 
-
     /// @struct audio_info
     /// @brief Information about a piece of audio data
     struct audio_info {
@@ -41,7 +39,8 @@ class AudioIn : public Component {
     };
 
     /// @struct audio_chunk
-    /// @brief A sequential chunk of audio data with timing information for continuous audio streams.
+    /// @brief A sequential chunk of audio data with timing information for continuous audio
+    /// streams.
     struct audio_chunk {
         std::vector<std::byte> audio_data;
         audio_info audio_info;
@@ -55,41 +54,44 @@ class AudioIn : public Component {
     /// until completed or cancelled
     /// @param codec requested codec of the audio data
     /// @param chunk_handler callback function to call when an audio response is received.
-    /// For an infinite stream this should return true to keep streaming audio and false to indicate that the stream should terminate.
-    /// The callback function should not be blocking.
+    /// For an infinite stream this should return true to keep streaming audio and false to indicate
+    /// that the stream should terminate. The callback function should not be blocking.
     /// @param duration_seconds duration of audio stream. If not set, stream duration is indefinite.
-    /// @param previous_timestamp timestamp to start the audio stream from for continuity between multiple calls. If not set, will stream data
+    /// @param previous_timestamp timestamp to start the audio stream from for continuity between
+    /// multiple calls. If not set, will stream data
     // starting from the time the request was received by the server.
     inline void get_audio(std::string const& codec,
-                            std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
-                            double const& duration_seconds,
-                            int64_t const& previous_timestamp) {
+                          std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
+                          double const& duration_seconds,
+                          int64_t const& previous_timestamp) {
         return get_audio(codec, chunk_handler, duration_seconds, previous_timestamp, {});
     }
 
-
     /// @brief Get a stream of audio from the device
     /// until completed or cancelled
     /// @param codec requested codec of the audio data
     /// @param chunk_handler callback function to call when an audio response is received.
-    /// For an infinite stream this should return true to keep streaming audio and false to indicate that the stream should terminate.
-    /// The callback function should not be blocking.
+    /// For an infinite stream this should return true to keep streaming audio and false to indicate
+    /// that the stream should terminate. The callback function should not be blocking.
     /// @param duration_seconds duration of audio stream. If zero, stream duration is indefinite.
-    /// @param previous_timestamp timestamp to start the audio stream from for continuity between multiple calls. If zero, will stream data
-    //starting from the time the request was received by the server.
+    /// @param previous_timestamp timestamp to start the audio stream from for continuity between
+    /// multiple calls. If zero, will stream data
+    // starting from the time the request was received by the server.
     /// @param extra Any additional arguments to the method
     virtual void get_audio(std::string const& codec,
-                            std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
-                            double const& duration_seconds,
-                            int64_t const& previous_timestamp,
-                            const ProtoStruct& extra) = 0;
+                           std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
+                           double const& duration_seconds,
+                           int64_t const& previous_timestamp,
+                           const ProtoStruct& extra) = 0;
 
-    /// @brief Returns properties of the audio in device (supported codecs, sample rate, number of channels)
+    /// @brief Returns properties of the audio in device (supported codecs, sample rate, number of
+    /// channels)
     inline properties get_properties() {
         return get_properties({});
     }
 
-    /// @brief Returns properties of the audio in device (supported codecs, sample rate, number of channels)
+    /// @brief Returns properties of the audio in device (supported codecs, sample rate, number of
+    /// channels)
     /// @param extra Any additional arguments to the method
     virtual properties get_properties(const ProtoStruct& extra) = 0;
 
@@ -113,16 +115,14 @@ class AudioIn : public Component {
 
    protected:
     explicit AudioIn(std::string name);
+};
 
-    };
-
-    template <>
-    struct API::traits<AudioIn> {
-        static API api();
-    };
-
-    bool operator==(const AudioIn::properties& lhs, const AudioIn::properties& rhs);
+template <>
+struct API::traits<AudioIn> {
+    static API api();
+};
 
-} // namespace sdk
-} // namespace viam
+bool operator==(const AudioIn::properties& lhs, const AudioIn::properties& rhs);
 
+}  // namespace sdk
+}  // namespace viam

src/viam/sdk/components/private/audio_in_client.cpp

@@ -26,42 +26,39 @@ AudioInClient::AudioInClient(std::string name, std::shared_ptr<grpc::Channel> ch
       stub_(viam::component::audioin::v1::AudioInService::NewStub(channel)),
       channel_(std::move(channel)) {}
 
-
-void AudioInClient::get_audio(std::string  const& codec,
-                               std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
-                               double const& duration_seconds,
-                               int64_t const& previous_timestamp,
-                               const ProtoStruct& extra) {
+void AudioInClient::get_audio(std::string const& codec,
+                              std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
+                              double const& duration_seconds,
+                              int64_t const& previous_timestamp,
+                              const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::GetAudio)
         .with(extra,
               [&](auto& request) {
-                request.set_codec(codec);
-                request.set_duration_seconds(duration_seconds);
-                request.set_previous_timestamp_nanoseconds(previous_timestamp);
+                  request.set_codec(codec);
+                  request.set_duration_seconds(duration_seconds);
+                  request.set_previous_timestamp_nanoseconds(previous_timestamp);
               })
         .invoke_stream([&](auto& response) {
+            // Create audio_chunk struct from proto response
+            audio_chunk chunk;
+
+            // Convert audio_data from string to std::vector<std::byte>
+            const std::string& audio_data_str = response.audio().audio_data();
+            chunk.audio_data.reserve(audio_data_str.size());
+            for (char c : audio_data_str) {
+                chunk.audio_data.push_back(static_cast<std::byte>(c));
+            }
 
-        // Create audio_chunk struct from proto response
-        audio_chunk chunk;
-
-        // Convert audio_data from string to std::vector<std::byte>
-        const std::string& audio_data_str = response.audio().audio_data();
-        chunk.audio_data.reserve(audio_data_str.size());
-        for (char c : audio_data_str) {
-            chunk.audio_data.push_back(static_cast<std::byte>(c));
-        }
-
-        chunk.sequence = response.audio().sequence();
-        chunk.request_id = response.request_id();
-
-        if (response.audio().has_audio_info()) {
-            chunk.audio_info.codec = response.audio().audio_info().codec();
-            chunk.audio_info.sample_rate_hz = response.audio().audio_info().sample_rate_hz();
-            chunk.audio_info.num_channels = response.audio().audio_info().num_channels();
-        }
-        return chunk_handler(std::move(chunk));
-  });
+            chunk.sequence = response.audio().sequence();
+            chunk.request_id = response.request_id();
 
+            if (response.audio().has_audio_info()) {
+                chunk.audio_info.codec = response.audio().audio_info().codec();
+                chunk.audio_info.sample_rate_hz = response.audio().audio_info().sample_rate_hz();
+                chunk.audio_info.num_channels = response.audio().audio_info().num_channels();
+            }
+            return chunk_handler(std::move(chunk));
+        });
 }
 
 AudioIn::properties AudioInClient::get_properties(const ProtoStruct& extra) {
@@ -75,9 +72,8 @@ AudioIn::properties AudioInClient::get_properties(const ProtoStruct& extra) {
                 codecs.push_back(codec);
             }
 
-            return properties{std::move(codecs),
-                              response.sample_rate_hz(),
-                              response.num_channels()};
+            return properties{
+                std::move(codecs), response.sample_rate_hz(), response.num_channels()};
         });
 }
 

src/viam/sdk/components/private/audio_in_client.hpp

@@ -21,16 +21,15 @@ class AudioInClient : public AudioIn {
     AudioInClient(std::string name, std::shared_ptr<grpc::Channel> channel);
 
     void get_audio(std::string const& codec,
-                    std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
-                    double const& duration_seconds,
-                    int64_t const& previous_timestamp,
-                    const ProtoStruct& extra) override;
+                   std::function<bool(audio_chunk&& chunk)> const& chunk_handler,
+                   double const& duration_seconds,
+                   int64_t const& previous_timestamp,
+                   const ProtoStruct& extra) override;
 
     properties get_properties(const ProtoStruct& extra) override;
     ProtoStruct do_command(const ProtoStruct& command) override;
     std::vector<GeometryConfig> get_geometries(const ProtoStruct& extra) override;
 
-
     // the `extra` param is frequently unnecessary but needs to be supported. Ideally, we'd
     // like to live in a world where implementers of derived classes don't need to go out of
     // their way to support two versions of a method (an `extra` version and a non-`extra`
@@ -40,12 +39,11 @@ class AudioInClient : public AudioIn {
     // that calls the virtual method and passes a `nullptr` by default in place of the `extra`
     // param. In order to access these versions of the methods within the client code, however,
     // we need to include these `using` lines.
-    using AudioIn::get_geometries;
     using AudioIn::get_audio;
+    using AudioIn::get_geometries;
     using AudioIn::get_properties;
 
    private:
-
     using StubType = viam::component::audioin::v1::AudioInService::StubInterface;
     std::unique_ptr<StubType> stub_;
     std::shared_ptr<grpc::Channel> channel_;