get rid of video buffers; refactor; add garbage code

1 files changed, 98 insertions, 47 deletions

diff --git a/src/camera/veyeimx287m.cpp b/src/camera/veyeimx287m.cpp
index 6491d9d..04ee7d2 100644
--- a/src/camera/veyeimx287m.cpp
+++ b/src/camera/veyeimx287m.cpp
@@ -16,6 +16,7 @@
 // orpheus
 #include "camera/veye_i2c.h"
 #include "constants.h"
+#include "pixels.h"
 #include "protocols/httpserver.h"
 #include "veyeimx287m_types.h"
 
@@ -196,7 +197,12 @@ VeyeIMX287m::VeyeIMX287m() {}
 
 VeyeIMX287m::~VeyeIMX287m()
 {
-    for (auto &t : m_calcThreads) {
+    for (auto &t : m_rotateThreads) {
+        t.request_stop();
+        t.join();
+    }
+
+    for (auto &t : m_getThreads) {
         t.request_stop();
         t.join();
     }
@@ -211,19 +217,11 @@ VeyeIMX287m::~VeyeIMX287m()
         std::cout << "cannot stop stream" << std::endl;
     }
 
-#ifdef RADXA_ZERO_3E
-    for (const auto buffer : m_buffers) {
+    for (const auto &buffer : m_buffers) {
         if (munmap(buffer.mem, radxa_raw_img_size) < 0) {
             DBG("Munmap failed!!.");
         }
     }
-#else
-    for (const auto buffer : m_videoBuffers) {
-        if (munmap(buffer, img_size) < 0) {
-            DBG("Munmap failed!!.");
-        }
-    }
-#endif // RADXA_ZERO_3E
 
     if (m_cam_fd >= 0) {
         if (close(m_cam_fd) == -1) {
@@ -273,8 +271,12 @@ bool VeyeIMX287m::startStream()
         return false;
     }
 
-    for (auto &t : m_calcThreads) {
-        t = std::jthread{&VeyeIMX287m::calcFrameLoop, this};
+    for (auto &t : m_getThreads) {
+        t = std::jthread{&VeyeIMX287m::getFrameLoop, this};
+    }
+
+    for (auto &t : m_rotateThreads) {
+        t = std::jthread{&VeyeIMX287m::rotateFrameLoop, this};
     }
 
     std::cout << __func__ << " - OK" << std::endl;
@@ -551,15 +553,8 @@ bool VeyeIMX287m::initCam()
             return false;
         }
 
-        m_videoBuffers[i] = (uint8_t *) m_buffers[i].mem;
-
-        auto p1 = (Image::radxa_data_t *) m_videoBuffers[i];
-        auto p2 = (Image::radxa_data_t *) m_buffers[i].mem;
-        if (p1 != p2) {
-            std::cout << "AAAAAAA: " << (void *) p1 << ' ' << (void *) p2 << std::endl;
-        }
-        m_buffers[i].size[i] = length;
-        m_buffers[i].padding[i] = 0;
+        m_buffers[i].size = length;
+        m_buffers[i].padding = 0;
 
         printf("Buffer mapped at address %p.\n", m_buffers[i].mem);
 
@@ -592,7 +587,7 @@ bool VeyeIMX287m::initI2C()
 //     return m_httpServer != nullptr;
 // }
 
-void VeyeIMX287m::calcFrameLoop(std::stop_token stopToken)
+void VeyeIMX287m::getFrameLoop(std::stop_token stopToken)
 {
     QElapsedTimer t;
 
@@ -603,38 +598,62 @@ void VeyeIMX287m::calcFrameLoop(std::stop_token stopToken)
             continue;
         }
 
+        // std::cout << __func__ << " acquire" << std::endl;
+        // std::cout << __func__ << " acquired" << std::endl;
         // ++processedCounter;
         // continue;
 
-        std::lock_guard lock{m_imageMutexes[bufferIdx]};
+        // std::lock_guard lock{m_imageMutexes[bufferIdx]};
 
-        auto &image = m_images[bufferIdx];
+        // auto &image = m_images[bufferIdx];
+        const auto &image = m_buffers[bufferIdx].image;
 
         {
             t.start();
 
-            auto p1 = (void *) m_videoBuffers[bufferIdx];
-            auto p2 = (void *) m_buffers[bufferIdx].mem;
-
-            // if (p1 != p2) {
-            //     std::cout << (void *) p1 << ' ' << (void *) p2 << std::endl;
-            // }
-
-            auto &src = *(Image::radxa_data_t *) m_videoBuffers[bufferIdx];
-            // auto &src = *(Image::radxa_data_t *) buffers[bufferIdx].mem[0];
-            auto &dst = image.data;
+            auto &src = *(Image::radxa_data_t *) m_buffers[bufferIdx].mem;
+            auto &dst = image->data;
             Image::copy(dst, src);
 
             get_elapsed_ns += t.nsecsElapsed();
         }
 
-        image.rotate();
-        const auto pixels = image.sharedPixels();
+        // m_receiverCalculatorSem.main2calc.release();
+        // std::cout << __func__ << ": main2calc.release" << std::endl;
+        // m_receiverCalculatorSem.bufferIdx = bufferIdx;
+        // m_receiverCalculatorSem.calc2main.acquire();
+        // std::cout << __func__ << ": calc2main.acquire" << std::endl;
+        // std::cout << __func__ << " released" << std::endl;
 
         ++processedCounter;
+        // return;
+
+        image->rotate();
+        const auto pixels = image->sharedPixels();
+
+    }
+}
+
+void VeyeIMX287m::rotateFrameLoop(std::stop_token stopToken)
+{
+    return;
+    while (!stopToken.stop_requested()) {
+        std::cout << __func__ << std::endl;
+
+        m_receiverCalculatorSem.main2calc.acquire();
+        std::cout << __func__ << ": main2calc.acquired" << std::endl;
+        const auto idx = m_receiverCalculatorSem.bufferIdx;
+        m_receiverCalculatorSem.calc2main.release();
+        std::cout << __func__ << ": calc2main.released" << std::endl;
+
+        const auto &image = m_buffers[idx].image;
+        image->rotate();
+        std::cout << "rotated" << std::endl;
+        const auto pixels = image->sharedPixels();
     }
 }
 
+// TODO: check if some of buffers are being overritten during processing
 bool VeyeIMX287m::dequeueImageBuffer(size_t &imageIndex)
 // TODO: get Image from video_buffer_ptr
 {
@@ -716,20 +735,22 @@ bool VeyeIMX287m::dequeueImageBuffer(size_t &imageIndex)
     }
 
     imageIndex = buf.index;
-    auto &image = m_images[buf.index];
-    image.height = img_height;
-    image.width = img_width;
+    // auto &image = m_images[buf.index];
+    const auto &image = m_buffers[buf.index].image;
+    image->height = img_height;
+    image->width = img_width;
     // TODO: fill
     // image.counters.encoderPosition = RotaryEncoder::instance()->position();
-    image.counters.measurementCounter = buf.sequence;
+    image->counters.measurementCounter = buf.sequence;
 
     // FIXME: git rid of static vars
-    static int64_t prevCounter = buf.sequence;
-    dropped_count += buf.sequence - prevCounter - 1;
-    prevCounter = buf.sequence;
+    // if (not m_previousFrameCounter.has_value()) {
+    //     m_previousFrameCounter = buf.sequence;
+    // }
+    dropped_count += buf.sequence - m_previousFrameCounter.value_or(buf.sequence) - 1;
+    m_previousFrameCounter = buf.sequence;
 
-    image.counters.timestampUs = buf.timestamp.tv_sec * 1000 * 1000
-                                 + buf.timestamp.tv_usec;
+    image->counters.timestampUs = buf.timestamp.tv_sec * 1000 * 1000 + buf.timestamp.tv_usec;
 
     {
         std::lock_guard<std::mutex> lock(m_camMtx);
@@ -761,12 +782,14 @@ bool VeyeIMX287m::getImage(Image *image)
 
     // TODO: remove this bullshit. return ptr to image or copy image metainfo
     // only, then copy data
-    *image = std::move(m_images[bufferIdx]);
+    // *image = std::move(m_images[bufferIdx]);
+    *image = std::move(*m_buffers[bufferIdx].image);
     {
         QElapsedTimer t;
         t.start();
         std::lock_guard lock{m_imageMutexes[bufferIdx]};
-        auto &src = *(Image::radxa_data_t *) m_videoBuffers[bufferIdx];
+
+        auto &src = *(Image::radxa_data_t *) m_buffers[bufferIdx].mem;
         auto &dst = image->data;
         Image::copy(dst, src);
         get_elapsed_ns += t.nsecsElapsed();
@@ -774,3 +797,31 @@ bool VeyeIMX287m::getImage(Image *image)
 
     return true;
 }
+
+std::shared_ptr<Image> VeyeIMX287m::getImage()
+{
+    std::shared_ptr<Image> result;
+
+    size_t bufferIdx{};
+
+    if (!dequeueImageBuffer(bufferIdx)) {
+        return {};
+    }
+
+    // TODO: remove this bullshit. return ptr to image or copy image metainfo
+    // only, then copy data
+    // *image = std::move(m_images[bufferIdx]);
+    result = m_buffers[bufferIdx].image;
+    {
+        QElapsedTimer t;
+        t.start();
+        std::lock_guard lock{m_imageMutexes[bufferIdx]};
+
+        auto &src = *(Image::radxa_data_t *) m_buffers[bufferIdx].mem;
+        auto &dst = result->data;
+        Image::copy(dst, src);
+        get_elapsed_ns += t.nsecsElapsed();
+    }
+
+    return result;
+}