feat: add recording support on Jetson

Author: TzuHuanTai

src/capturer/libargus_buffer_capturer.cpp

@@ -272,6 +272,7 @@ void LibargusBufferCapturer::CaptureImage() {
     auto dmabuf = DmaBuffer::fromArgusBuffer(buffer);
     int dmabuf_fd = dmabuf->getFd();
     frame_buffer_->SetDmaFd(dmabuf_fd);
+    frame_buffer_->SetTimestamp(dmabuf->getTimeval());
 
     // NV12M to NV12
     NvBufSurface *nvbuf = nullptr;

src/capturer/libargus_buffer_capturer.h

@@ -50,15 +50,28 @@ class DmaBuffer : public ArgusSamples::NvNativeBuffer,
 
     /* Help function to convert Argus Buffer to DmaBuffer */
     static DmaBuffer *fromArgusBuffer(Argus::Buffer *buffer) {
-        Argus::IBuffer *iBuffer = interface_cast<Argus::IBuffer>(buffer);
-        const DmaBuffer *dmabuf = static_cast<const DmaBuffer *>(iBuffer->getClientData());
+        Argus::IBuffer *i_buffer = interface_cast<Argus::IBuffer>(buffer);
+        const DmaBuffer *dmabuf = static_cast<const DmaBuffer *>(i_buffer->getClientData());
 
         return const_cast<DmaBuffer *>(dmabuf);
     }
 
     /* Return DMA buffer handle */
     int getFd() const { return m_fd; }
 
+    /* Get timestamp*/
+    timeval getTimeval() const {
+        Argus::IBuffer *i_buffer = interface_cast<Argus::IBuffer>(m_buffer);
+        auto metadata = i_buffer->getMetadata();
+        const Argus::ICaptureMetadata *imetadata =
+            Argus::interface_cast<const Argus::ICaptureMetadata>(metadata);
+
+        timeval tv = {};
+        tv.tv_sec = imetadata->getSensorTimestamp() / 1000000000;
+        tv.tv_usec = (imetadata->getSensorTimestamp() % 1000000000) / 1000;
+        return tv;
+    }
+
     /* Get and set reference to Argus buffer */
     void setArgusBuffer(Argus::Buffer *buffer) { m_buffer = buffer; }
     Argus::Buffer *getArgusBuffer() const { return m_buffer; }

src/common/v4l2_frame_buffer.cpp

@@ -108,6 +108,8 @@ bool V4L2FrameBuffer::SetDmaFd(int fd) {
     return true;
 }
 
+void V4L2FrameBuffer::SetTimestamp(timeval timestamp) { timestamp_ = timestamp; }
+
 /*  Return a new refptr with copied metadata and frame data. */
 rtc::scoped_refptr<V4L2FrameBuffer> V4L2FrameBuffer::Clone() const {
     auto clone = rtc::make_ref_counted<V4L2FrameBuffer>(width_, height_, size_, format_);

src/common/v4l2_frame_buffer.h

@@ -32,6 +32,7 @@ class V4L2FrameBuffer : public webrtc::VideoFrameBuffer {
     V4L2Buffer GetRawBuffer();
     int GetDmaFd() const;
     bool SetDmaFd(int fd);
+    void SetTimestamp(timeval timestamp);
     rtc::scoped_refptr<V4L2FrameBuffer> Clone() const;
 
   protected:

src/common/v4l2_utils.h

@@ -20,13 +20,6 @@ struct V4L2Buffer {
 
     V4L2Buffer() = default;
 
-    static V4L2Buffer FromRaw(void *start, uint32_t length) {
-        V4L2Buffer buf;
-        buf.start = start;
-        buf.length = length;
-        return buf;
-    }
-
     static V4L2Buffer FromV4L2(void *start, const v4l2_buffer &v4l2, uint32_t fmt) {
         V4L2Buffer buf;
         buf.start = start;

src/recorder/h264_recorder.cpp

@@ -0,0 +1,21 @@
+#include "recorder/openh264_recorder.h"
+
+std::unique_ptr<Openh264Recorder> Openh264Recorder::Create(Args config) {
+    return std::make_unique<Openh264Recorder>(config, "h264_v4l2m2m");
+}
+
+Openh264Recorder::Openh264Recorder(Args config, std::string encoder_name)
+    : VideoRecorder(config, encoder_name) {}
+
+void Openh264Recorder::Encode(rtc::scoped_refptr<V4L2FrameBuffer> frame_buffer) {
+    if (!encoder_) {
+        encoder_ = Openh264Encoder::Create(config);
+    }
+
+    auto i420_buffer = frame_buffer->ToI420();
+    encoder_->Encode(i420_buffer, [this, frame_buffer](uint8_t *encoded_buffer, int size) {
+        OnEncoded(encoded_buffer, size, frame_buffer->timestamp());
+    });
+}
+
+void Openh264Recorder::ReleaseEncoder() { encoder_.reset(); }

src/recorder/h264_recorder.h

@@ -0,0 +1,20 @@
+#ifndef OPENH264_RECORDER_H_
+#define OPENH264_RECORDER_H_
+
+#include "codecs/h264/openh264_encoder.h"
+#include "recorder/video_recorder.h"
+
+class Openh264Recorder : public VideoRecorder {
+  public:
+    static std::unique_ptr<Openh264Recorder> Create(Args config);
+    Openh264Recorder(Args config, std::string encoder_name);
+
+  protected:
+    void ReleaseEncoder() override;
+    void Encode(rtc::scoped_refptr<V4L2FrameBuffer> frame_buffer) override;
+
+  private:
+    std::unique_ptr<Openh264Encoder> encoder_;
+};
+
+#endif

src/recorder/openh264_recorder.cpp

@@ -11,8 +11,11 @@
 #include "common/logging.h"
 #include "common/utils.h"
 #include "common/v4l2_frame_buffer.h"
-#include "recorder/h264_recorder.h"
+#include "recorder/openh264_recorder.h"
+#if defined(RPI_PLATFORM)
 #include "recorder/raw_h264_recorder.h"
+#include "recorder/v4l2_h264_recorder.h"
+#endif
 
 const int ROTATION_PERIOD = 60;
 const unsigned long MIN_FREE_BYTE = 400 * 1024 * 1024;
@@ -88,11 +91,19 @@ void RecorderManager::CreateVideoRecorder(std::shared_ptr<VideoCapturer> capture
     video_recorder = ([this, capturer]() -> std::unique_ptr<VideoRecorder> {
         if (config.record_mode == RecordMode::Snapshot) {
             return nullptr;
-        } else if (capturer->format() == V4L2_PIX_FMT_H264) {
+        }
+#if defined(RPI_PLATFORM)
+        if (capturer->format() == V4L2_PIX_FMT_H264) {
             return RawH264Recorder::Create(capturer->config());
-        } else {
-            return H264Recorder::Create(capturer->config());
+        } else if (config.hw_accel) {
+            return V4L2H264Recorder::Create(capturer->config());
         }
+#endif
+
+#if defined(JETSON_PLATFORM)
+        // todo: use jetson hw video encoder
+#endif
+        return Openh264Recorder::Create(capturer->config());
     })();
 }