Added VideoEncoder node bindings

themarpe · themarpe · commit 807f67166484 · 2020-10-06T17:51:49.000+02:00
diff --git a/depthai-core b/depthai-core
@@ -1 +1 @@
-Subproject commit 3cb65f13c0d9b3f271ca712e27512562e566ad17
+Subproject commit f4739bdffed79bc23565e31126921d56393ed5a1
diff --git a/src/DataQueueBindings.cpp b/src/DataQueueBindings.cpp
@@ -1,23 +1,53 @@
 #include "DataQueueBindings.hpp"
 
-// depthai-shared
+// std
+#include <chrono>
+
+// depthai
 #include "depthai/DataQueue.hpp"
 
 void DataQueueBindings::bind(pybind11::module& m){
 
     using namespace dai;
+    using namespace std::chrono_literals;
+
+    // To prevent blocking whole python interpreter, blocking functions like 'get' and 'send' 
+    // are pooled with a reasonable delay and check for python interrupt signal in between.
 
     // Bind DataOutputQueue
     py::class_<DataOutputQueue, std::shared_ptr<DataOutputQueue>>(m, "DataOutputQueue")
-        .def("get", static_cast<std::shared_ptr<RawBuffer>(DataOutputQueue::*)()>(&DataOutputQueue::get) )
+        .def("get", [](DataOutputQueue& obj){
+            
+            std::shared_ptr<RawBuffer> d = nullptr;
+            do {
+                // block for 100ms
+                d = obj.get(100ms);
+                // check if interrupt triggered in between
+                if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+            } while(d == nullptr);
+
+            return d;
+        })
         .def("has", static_cast<bool(DataOutputQueue::*)()>(&DataOutputQueue::has))
         .def("tryGet", static_cast<std::shared_ptr<RawBuffer>(DataOutputQueue::*)()>(&DataOutputQueue::tryGet))
         ;
 
     // Bind DataInputQueue
     py::class_<DataInputQueue, std::shared_ptr<DataInputQueue>>(m, "DataInputQueue")
-        .def("send", &DataInputQueue::send)
-        .def("sendAsync", &DataInputQueue::sendAsync)
+        .def("send", [](DataInputQueue& obj, std::shared_ptr<RawBuffer> d){
+            
+            bool sent = false;
+            do {
+                // block for 100ms
+                sent = obj.send(d, 100ms);
+
+                // check if interrupt triggered in between
+                if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+
+            } while(!sent);
+
+            return d;
+        })
         ;
 
 }
diff --git a/src/DeviceBindings.cpp b/src/DeviceBindings.cpp
@@ -1,7 +1,7 @@
 #include "DeviceBindings.hpp"
 
 // depthai
-#include "depthai/device.hpp"
+#include "depthai/Device.hpp"
 
 void DeviceBindings::bind(pybind11::module& m){
 
@@ -14,8 +14,8 @@ void DeviceBindings::bind(pybind11::module& m){
         .def(py::init<const DeviceInfo&, std::string>(), py::arg("deviceDesc"), py::arg("pathToCmd"))
         .def("isPipelineRunning", &Device::isPipelineRunning)
         .def("startPipeline", &Device::startPipeline)
-        .def("getOutputQueue", &Device::getOutputQueue)
-        .def("getInputQueue", &Device::getInputQueue)
+        .def("getOutputQueue", &Device::getOutputQueue, py::arg("name"), py::arg("maxSize") = 120, py::arg("overwrite") = false )
+        .def("getInputQueue", &Device::getInputQueue,  py::arg("name"), py::arg("maxSize") = 120, py::arg("overwrite") = false )
         .def("setCallback", &Device::setCallback)
         ;
 
diff --git a/src/pipeline/NodeBindings.cpp b/src/pipeline/NodeBindings.cpp
@@ -5,6 +5,8 @@
 #include "depthai/pipeline/node/XLinkOut.hpp"
 #include "depthai/pipeline/node/ColorCamera.hpp"
 #include "depthai/pipeline/node/NeuralNetwork.hpp"
+#include "depthai/pipeline/node/VideoEncoder.hpp"
+
 
 void NodeBindings::bind(pybind11::module& m){
 
@@ -21,22 +23,25 @@ void NodeBindings::bind(pybind11::module& m){
 
     py::class_<Node, std::shared_ptr<Node>>(m, "Node");
 
+
+    // XLinkIn node
     py::class_<XLinkIn, Node, std::shared_ptr<XLinkIn>>(m, "XLinkIn")
         .def_readonly("out", &XLinkIn::out)
         .def("setStreamName", &XLinkIn::setStreamName)
         .def("setMaxDataSize", &XLinkIn::setMaxDataSize)
         .def("setNumFrames",  &XLinkIn::setNumFrames)   
         ;
 
-
+    // XLinkOut node
     py::class_<XLinkOut, Node, std::shared_ptr<XLinkOut>>(m, "XLinkOut")
-        .def_readonly("input", &XLinkOut::in)
+        .def_readonly("input", &XLinkOut::input)
         .def("setStreamName", &XLinkOut::setStreamName)
         .def("setFpsLimit", &XLinkOut::setFpsLimit)
         ;
 
+    // NeuralNetwork node
     py::class_<NeuralNetwork, Node, std::shared_ptr<NeuralNetwork>>(m, "NeuralNetwork")
-        .def_readonly("input", &NeuralNetwork::in)
+        .def_readonly("input", &NeuralNetwork::input)
         .def_readonly("out", &NeuralNetwork::out)
         .def("setBlobPath", &NeuralNetwork::setBlobPath)
         .def("setNumPoolFrames", &NeuralNetwork::setNumPoolFrames)
@@ -66,6 +71,8 @@ void NodeBindings::bind(pybind11::module& m){
         .export_values()
         ;
         
+
+    // ColorCamera node
     py::class_<ColorCamera, Node, std::shared_ptr<ColorCamera>>(m, "ColorCamera")
         .def_readonly("video", &ColorCamera::video)
         .def_readonly("preview", &ColorCamera::preview)
@@ -78,6 +85,42 @@ void NodeBindings::bind(pybind11::module& m){
         ;
 
 
+    // VideoEncoder props
+    py::class_<VideoEncoderProperties> videoEncoderProperties(m, "VideoEncoderProperties");
+    videoEncoderProperties
+        .def_readwrite("bitrate", &VideoEncoderProperties::bitrate)
+        .def_readwrite("keyframeFrequency", &VideoEncoderProperties::keyframeFrequency)
+        .def_readwrite("maxBitrate", &VideoEncoderProperties::maxBitrate)
+        .def_readwrite("numBFrames", &VideoEncoderProperties::numBFrames)
+        .def_readwrite("numFramesPool", &VideoEncoderProperties::numFramesPool)
+        .def_readwrite("profile", &VideoEncoderProperties::profile)
+        .def_readwrite("quality", &VideoEncoderProperties::quality)
+        .def_readwrite("rateCtrlMode", &VideoEncoderProperties::rateCtrlMode)
+        .def_readwrite("width", &VideoEncoderProperties::width)
+        .def_readwrite("height", &VideoEncoderProperties::height)
+        ;
+
+    py::enum_<VideoEncoderProperties::Profile>(videoEncoderProperties, "Profile")
+        .value("H264_BASELINE", VideoEncoderProperties::Profile::H264_BASELINE)
+        .value("H264_HIGH", VideoEncoderProperties::Profile::H264_HIGH)
+        .value("H264_MAIN", VideoEncoderProperties::Profile::H264_MAIN)
+        .value("H265_MAIN", VideoEncoderProperties::Profile::H265_MAIN)
+        .value("MJPEG", VideoEncoderProperties::Profile::MJPEG)
+        .export_values()
+        ;
+
+    py::enum_<VideoEncoderProperties::RateControlMode>(videoEncoderProperties, "RateControlMode")
+        .value("CBR", VideoEncoderProperties::RateControlMode::CBR)
+        .value("VBR", VideoEncoderProperties::RateControlMode::VBR)
+        .export_values()
+        ;     
+
+    // VideoEncoder node
+    py::class_<VideoEncoder, Node, std::shared_ptr<VideoEncoder>>(m, "VideoEncoder")
+        .def_readonly("input", &VideoEncoder::input)
+        .def_readonly("bitstream", &VideoEncoder::bitstream)
+        .def("setDefaultProfilePreset", &VideoEncoder::setDefaultProfilePreset)
+        ;
 
 
 }
diff --git a/src/py_bindings.cpp b/src/py_bindings.cpp
@@ -10,7 +10,7 @@
 // pybind11
 
 // depthai-core
-#include "depthai/device.hpp"
+#include "depthai/Device.hpp"
 #include "depthai/build/version.hpp"
 
 // project
