Clangformat

include/depthai/pipeline/ThreadedHostNode.hpp

@@ -16,7 +16,7 @@ class ThreadedHostNode : public ThreadedNode {
     }
 };
 
-template<typename T>
+template <typename T>
 using CustomThreadedNode = NodeCRTP<ThreadedHostNode, T>;
 }  // namespace node
 }  // namespace dai

include/depthai/pipeline/datatype/Buffer.hpp

@@ -43,7 +43,6 @@ class Buffer : public ADatatype {
      * @param data Moves data to internal buffer
      */
     void setData(std::vector<std::uint8_t>&& data);
-
 
     /**
      * Retrieves timestamp related to dai::Clock::now()

include/depthai/pipeline/node/host/HostNode.hpp

@@ -40,7 +40,7 @@ class HostNode : public ThreadedHostNode {
     }
 };
 
-template<typename T>
+template <typename T>
 using CustomNode = NodeCRTP<HostNode, T>;
 }  // namespace node
 }  // namespace dai

include/depthai/utility/Memory.hpp

@@ -128,7 +128,7 @@ class Memory {
     };
 
     MemoryKinds getKind() {
-	return kind;
+        return kind;
     }
 
    protected:

include/depthai/utility/SharedMemory.hpp

@@ -6,11 +6,11 @@
 #include <functional>
 #include <iostream>
 #ifdef __unix__
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/un.h>
-#include <unistd.h>
+    #include <fcntl.h>
+    #include <sys/mman.h>
+    #include <sys/stat.h>
+    #include <sys/un.h>
+    #include <unistd.h>
 #endif
 
 // project
@@ -24,100 +24,101 @@ class SharedMemory : public Memory {
     long fd = -1;
     void* mapping;
     void mapFd() {
-	if (fd < 0) {
-	    /* Error handling here */
-	}
+        if(fd < 0) {
+            /* Error handling here */
+        }
 
-	mapping = mmap(NULL, getSize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-	if (mapping == NULL) {
-	    /* Error handling here */
-	}
+        mapping = mmap(NULL, getSize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if(mapping == NULL) {
+            /* Error handling here */
+        }
     }
     void unmapFd() {
-	if (mapping == NULL) {
-	    return;
-	}
+        if(mapping == NULL) {
+            return;
+        }
 
-	munmap(mapping, getSize());
+        munmap(mapping, getSize());
     }
+
    public:
     SharedMemory() {
-	kind = MemoryKinds::MEMORY_KIND_SHARED;
-	fd = -1;
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        fd = -1;
     }
 
     SharedMemory(long argFd) : fd(argFd) {
-	kind = MemoryKinds::MEMORY_KIND_SHARED;
-	mapFd();
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        mapFd();
     }
 
     SharedMemory(long argFd, std::size_t size) : fd(argFd) {
-	kind = MemoryKinds::MEMORY_KIND_SHARED;
-	setSize(size);
-	mapFd();
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        setSize(size);
+        mapFd();
     }
 
-    SharedMemory(const char *name) {
-	kind = MemoryKinds::MEMORY_KIND_SHARED;
-	fd = memfd_create(name, 0);
-	mapFd();
+    SharedMemory(const char* name) {
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        fd = memfd_create(name, 0);
+        mapFd();
     }
 
-    SharedMemory(const char *name, std::size_t size) {
-	kind = MemoryKinds::MEMORY_KIND_SHARED;
-	fd = memfd_create(name, 0);
+    SharedMemory(const char* name, std::size_t size) {
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        fd = memfd_create(name, 0);
 
-	setSize(size);
-	mapFd();
+        setSize(size);
+        mapFd();
     }
 
     ~SharedMemory() {
-	unmapFd();
-	close(fd);
+        unmapFd();
+        close(fd);
     }
 
     SharedMemory& operator=(long argFd) {
-	unmapFd();
-	fd = argFd;
-	mapFd();
+        unmapFd();
+        fd = argFd;
+        mapFd();
 
         return *this;
     }
 
     span<std::uint8_t> getData() override {
-	if (mapping == NULL) {
-	    mapFd();
-	}
+        if(mapping == NULL) {
+            mapFd();
+        }
 
         return {(uint8_t*)mapping, getSize()};
     }
     span<const std::uint8_t> getData() const override {
         return {(const uint8_t*)mapping, getSize()};
     }
     std::size_t getMaxSize() const override {
-	struct stat fileStats;
-	fstat(fd, &fileStats);
+        struct stat fileStats;
+        fstat(fd, &fileStats);
 
         return fileStats.st_size;
     }
     std::size_t getOffset() const override {
         return ftell(fdopen(fd, "r"));
     }
     void setSize(std::size_t size) override {
-	if (mapping != NULL) {
-	    unmapFd();
-	}
+        if(mapping != NULL) {
+            unmapFd();
+        }
 
-	ftruncate(fd, size);
-	mapFd();
+        ftruncate(fd, size);
+        mapFd();
     }
 
     std::size_t getSize() const {
-	return getMaxSize();
+        return getMaxSize();
     }
 
     long getFd() const {
-	return fd;
+        return fd;
     }
 };
 

include/depthai/utility/VectorMemory.hpp

@@ -14,9 +14,15 @@ namespace dai {
 class VectorMemory : public std::vector<std::uint8_t>, public Memory {
    public:
     // using std::vector<std::uint8_t>::vector;
-    VectorMemory() { kind = MemoryKinds::MEMORY_KIND_VECTOR; }
-    VectorMemory(const std::vector<std::uint8_t>& d) : vector(std::move(d)) { kind = MemoryKinds::MEMORY_KIND_VECTOR; }
-    VectorMemory(std::vector<std::uint8_t>&& d) : vector(std::move(d)) { kind = MemoryKinds::MEMORY_KIND_VECTOR; }
+    VectorMemory() {
+        kind = MemoryKinds::MEMORY_KIND_VECTOR;
+    }
+    VectorMemory(const std::vector<std::uint8_t>& d) : vector(std::move(d)) {
+        kind = MemoryKinds::MEMORY_KIND_VECTOR;
+    }
+    VectorMemory(std::vector<std::uint8_t>&& d) : vector(std::move(d)) {
+        kind = MemoryKinds::MEMORY_KIND_VECTOR;
+    }
     VectorMemory& operator=(std::vector<std::uint8_t>&& d) {
         std::vector<std::uint8_t>::operator=(std::move(d));
         return *this;

src/device/DataQueue.cpp

@@ -9,10 +9,10 @@
 #include "depthai/pipeline/datatype/ADatatype.hpp"
 #include "depthai/pipeline/datatype/DatatypeEnum.hpp"
 #include "depthai/pipeline/datatype/MessageGroup.hpp"
+#include "depthai/utility/SharedMemory.hpp"
 #include "depthai/xlink/XLinkStream.hpp"
 #include "pipeline/datatype/MessageGroup.hpp"
 #include "pipeline/datatype/StreamMessageParser.hpp"
-#include "depthai/utility/SharedMemory.hpp"
 
 // shared
 #include "depthai/xlink/XLinkConstants.hpp"
@@ -206,14 +206,14 @@ DataInputQueue::DataInputQueue(
 
                 // Blocking
                 auto t1 = steady_clock::now();
-		
-		if(outgoing->data->getSize() > 0) {
-		    if (outgoing->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
-		        stream.write(outgoing->data->getData(), metadata);
-		    } else if (outgoing->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
-		        std::shared_ptr<SharedMemory> memory = std::dynamic_pointer_cast<SharedMemory>(outgoing->data);
-		        stream.write(memory->getFd(), metadata);
-		    }
+
+                if(outgoing->data->getSize() > 0) {
+                    if(outgoing->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
+                        stream.write(outgoing->data->getData(), metadata);
+                    } else if(outgoing->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
+                        std::shared_ptr<SharedMemory> memory = std::dynamic_pointer_cast<SharedMemory>(outgoing->data);
+                        stream.write(memory->getFd(), metadata);
+                    }
                 } else {
                     stream.write(metadata);
                 }
@@ -234,12 +234,12 @@ DataInputQueue::DataInputQueue(
                         logger::trace("Sending part of a group message: {}", msg.first);
                         auto metadata = StreamMessageParser::serializeMetadata(msg.second);
                         if(msg.second->data->getSize() > 0) {
-			    if (msg.second->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
-				stream.write(msg.second->data->getData(), metadata);
-			    } else if (msg.second->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
-				std::shared_ptr<SharedMemory> memory = std::dynamic_pointer_cast<SharedMemory>(msg.second->data);
-				stream.write(memory->getFd(), metadata);
-			    }
+                            if(msg.second->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
+                                stream.write(msg.second->data->getData(), metadata);
+                            } else if(msg.second->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
+                                std::shared_ptr<SharedMemory> memory = std::dynamic_pointer_cast<SharedMemory>(msg.second->data);
+                                stream.write(memory->getFd(), metadata);
+                            }
                         } else {
                             stream.write(metadata);
                         }

src/pipeline/datatype/Buffer.cpp

@@ -1,7 +1,7 @@
 #include "depthai/pipeline/datatype/Buffer.hpp"
 
-#include "depthai/utility/VectorMemory.hpp"
 #include "depthai/utility/SharedMemory.hpp"
+#include "depthai/utility/VectorMemory.hpp"
 
 namespace dai {
 Buffer::Buffer(size_t size) : Buffer() {
@@ -14,13 +14,12 @@ Buffer::Buffer(long fd) : Buffer() {
     auto mem = std::make_shared<SharedMemory>(fd);
     data = mem;
 }
-    
+
 Buffer::Buffer(long fd, size_t size) : Buffer() {
     auto mem = std::make_shared<SharedMemory>(fd, size);
     data = mem;
 }
 
-
 span<uint8_t> Buffer::getData() {
     return data->getData();
 }

src/pipeline/datatype/ImgFrame.cpp

@@ -2,7 +2,6 @@
 #include "depthai/pipeline/datatype/ImgFrame.hpp"
 
 #include "depthai/utility/SharedMemory.hpp"
-
 #include "spdlog/fmt/fmt.h"
 #include "spdlog/spdlog.h"
 namespace dai {
@@ -21,16 +20,13 @@ ImgFrame::ImgFrame(size_t size) : ImgFrame() {
 ImgFrame::ImgFrame(long fd) : ImgFrame() {
     auto mem = std::make_shared<SharedMemory>(fd);
     data = mem;
-
 }
 
 ImgFrame::ImgFrame(long fd, size_t size) : ImgFrame() {
     auto mem = std::make_shared<SharedMemory>(fd, size);
     data = mem;
 }
 
-
-
 std::chrono::time_point<std::chrono::steady_clock, std::chrono::steady_clock::duration> ImgFrame::getTimestamp(CameraExposureOffset offset) const {
     auto ts = getTimestamp();
     auto expTime = getExposureTime();