Add VideoFrameV2

src/PySource.hpp

@@ -1,6 +1,7 @@
-#include <Processing.NDI.Lib.h>
 #include <string>
 
+#include <Processing.NDI.Lib.h>
+
 class PySource : public NDIlib_source_t {
 public:
   PySource(const std::string &ndi_name_, const std::string &url_address_);

src/PyVideoFrame.cpp

@@ -0,0 +1,42 @@
+#include "PyVideoFrame.hpp"
+
+PyVideoFrameV2::PyVideoFrameV2(int xres_, int yres_,
+                               NDIlib_FourCC_video_type_e FourCC_,
+                               int frame_rate_N_, int frame_rate_D_,
+                               float picture_aspect_ratio_,
+                               NDIlib_frame_format_type_e frame_format_type_,
+                               int64_t timecode_, uint8_t *data_,
+                               int line_stride_in_bytes_,
+                               const std::string &metadata_, int64_t timestamp_)
+    : _metadata(metadata_) {
+  xres = xres_;
+  yres = yres_;
+  FourCC = FourCC_;
+  frame_rate_N = frame_rate_N_;
+  frame_rate_D = frame_rate_D_;
+  picture_aspect_ratio = picture_aspect_ratio_;
+  frame_format_type = frame_format_type_;
+  timecode = timecode_;
+  line_stride_in_bytes = line_stride_in_bytes_;
+  p_data = data_;
+  p_metadata = _metadata.c_str();
+  timestamp = timestamp_;
+}
+
+PyVideoFrameV2::~PyVideoFrameV2() {}
+
+void PyVideoFrameV2::setData(py::array_t<uint8_t> &array) {
+  auto info = array.request();
+  p_data = reinterpret_cast<uint8_t *>(info.ptr);
+  picture_aspect_ratio = info.shape[1] / float(info.shape[0]);
+  xres = info.shape[1];
+  yres = info.shape[0];
+  line_stride_in_bytes = info.strides[0];
+}
+
+const std::string &PyVideoFrameV2::getMetadata() const { return _metadata; }
+
+void PyVideoFrameV2::setMetadata(const std::string &data) {
+  _metadata = data;
+  p_metadata = _metadata.c_str();
+}

src/PyVideoFrame.hpp

@@ -0,0 +1,26 @@
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <string>
+
+#include <Processing.NDI.Lib.h>
+
+namespace py = pybind11;
+
+class PyVideoFrameV2 : public NDIlib_video_frame_v2_t {
+public:
+  PyVideoFrameV2(int xres_, int yres_, NDIlib_FourCC_video_type_e FourCC_,
+                 int frame_rate_N_, int frame_rate_D_,
+                 float picture_aspect_ratio_,
+                 NDIlib_frame_format_type_e frame_format_type_,
+                 int64_t timecode_, uint8_t *data_, int line_stride_in_bytes_,
+                 const std::string &metadata_, int64_t timestamp_);
+  virtual ~PyVideoFrameV2();
+
+  void setData(py::array_t<uint8_t> &array);
+
+  const std::string &getMetadata() const;
+  void setMetadata(const std::string &data);
+
+private:
+  std::string _metadata;
+};

src/main.cpp

@@ -1,6 +1,8 @@
+#include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 
 #include "PySource.hpp"
+#include "PyVideoFrame.hpp"
 
 namespace py = pybind11;
 
@@ -100,33 +102,33 @@ PYBIND11_MODULE(NDIlib, m) {
       .def_property("url_address", &PySource::getUrlAddress,
                     &PySource::setUrlAddress);
 
-  py::class_<NDIlib_video_frame_v2_t>(m, "VideoFrameV2")
+  py::class_<PyVideoFrameV2>(m, "VideoFrameV2")
       .def(py::init<int, int, NDIlib_FourCC_type_e, int, int, float,
                     NDIlib_frame_format_type_e, int64_t, uint8_t *, int,
-                    const char *, int64_t>(),
+                    const std::string &, int64_t>(),
            py::arg("xres") = 0, py::arg("yres") = 0,
-           py::arg("FourCC") = FOURCC_TYPE_UYVY,
+           py::arg("FourCC") = FOURCC_VIDEO_TYPE_UYVY,
            py::arg("frame_rate_N") = 30000, py::arg("frame_rate_D") = 1001,
            py::arg("picture_aspect_ratio") = 0.0f,
            py::arg("frame_format_type") = FRAME_FORMAT_TYPE_PROGRESSIVE,
-           py::arg("timecode") = 0, py::arg("data") = NULL,
+           py::arg("timecode") = 0, py::arg("data") = nullptr,
            py::arg("line_stride_in_bytes") = 0, py::arg("metadata") = nullptr,
            py::arg("timestamp") = 0)
-      .def_readwrite("xres", &NDIlib_video_frame_v2_t::xres)
+      .def_readwrite("xres", &PyVideoFrameV2::xres)
-      .def_readwrite("yres", &NDIlib_video_frame_v2_t::yres)
+      .def_readwrite("yres", &PyVideoFrameV2::yres)
-      .def_readwrite("FourCC", &NDIlib_video_frame_v2_t::FourCC)
+      .def_readwrite("FourCC", &PyVideoFrameV2::FourCC)
-      .def_readwrite("frame_rate_N", &NDIlib_video_frame_v2_t::frame_rate_N)
+      .def_readwrite("frame_rate_N", &PyVideoFrameV2::frame_rate_N)
-      .def_readwrite("frame_rate_D", &NDIlib_video_frame_v2_t::frame_rate_D)
+      .def_readwrite("frame_rate_D", &PyVideoFrameV2::frame_rate_D)
       .def_readwrite("picture_aspect_ratio",
-                     &NDIlib_video_frame_v2_t::picture_aspect_ratio)
+                     &PyVideoFrameV2::picture_aspect_ratio)
-      .def_readwrite("frame_format_type",
+      .def_readwrite("frame_format_type", &PyVideoFrameV2::frame_format_type)
-                     &NDIlib_video_frame_v2_t::frame_format_type)
+      .def_readwrite("timecode", &PyVideoFrameV2::timecode)
-      .def_readwrite("timecode", &NDIlib_video_frame_v2_t::timecode)
+      .def_property("data", nullptr, &PyVideoFrameV2::setData)
-      .def_readwrite("data", &NDIlib_video_frame_v2_t::p_data)
       .def_readwrite("line_stride_in_bytes",
-                     &NDIlib_video_frame_v2_t::line_stride_in_bytes)
+                     &PyVideoFrameV2::line_stride_in_bytes)
-      .def_readwrite("metadata", &NDIlib_video_frame_v2_t::p_metadata)
+      .def_property("metadata", &PyVideoFrameV2::getMetadata,
-      .def_readwrite("timestamp", &NDIlib_video_frame_v2_t::timestamp);
+                    &PyVideoFrameV2::setMetadata)
+      .def_readwrite("timestamp", &PyVideoFrameV2::timestamp);
 
   py::class_<NDIlib_audio_frame_v2_t>(m, "AudioFrameV2")
       .def(py::init<int, int, int, int64_t, float *, int, const char *,