mirror of https://github.com/opencv/opencv.git
Merge pull request #20785 from smirnov-alexey:as/oak_backend
GAPI: Add OAK backend * Initial tests and cmake integration * Add a public header and change tests * Stub initial empty template for the OAK backend * WIP * WIP * WIP * WIP * Runtime dai hang debug * Refactoring * Fix hang and debug frame data * Fix frame size * Fix data size issue * Move test code to sample * tmp refactoring * WIP: Code refactoring except for the backend * WIP: Add non-camera sample * Fix samples * Backend refactoring wip * Backend rework wip * Backend rework wip * Remove mat encoder * Fix namespace * Minor backend fixes * Fix hetero sample and refactor backend * Change linking logic in the backend * Fix oak sample * Fix working with ins/outs in OAK island * Trying to fix nv12 problem * Make both samples work * Small refactoring * Remove meta args * WIP refactoring kernel API * Change in/out args API for kernels * Fix build * Fix cmake warning * Partially address review comments * Partially address review comments * Address remaining comments * Add memory ownership * Change pointer-to-pointer to reference-to-pointer * Remove unnecessary reference wrappers * Apply review comments * Check that graph contains only one OAK island * Minor refactoring * Address review commentspull/21475/head
Alexey Smirnov
3 years ago
committed by
GitHub
parent
a1ec4ea3a9
commit
f2d5d6d24e
10 changed files with 1155 additions and 2 deletions
@ -0,0 +1,131 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
//
|
||||||
|
// Copyright (C) 2021 Intel Corporation
|
||||||
|
|
||||||
|
#ifndef OPENCV_GAPI_OAK_HPP |
||||||
|
#define OPENCV_GAPI_OAK_HPP |
||||||
|
|
||||||
|
#include <opencv2/gapi/garg.hpp> // IStreamSource |
||||||
|
#include <opencv2/gapi/gkernel.hpp> // GKernelPackage |
||||||
|
#include <opencv2/gapi/gstreaming.hpp> // GOptRunArgsP |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace gapi { |
||||||
|
namespace oak { |
||||||
|
|
||||||
|
// FIXME: copypasted from dai library
|
||||||
|
struct EncoderConfig { |
||||||
|
/**
|
||||||
|
* Rate control mode specifies if constant or variable bitrate should be used (H264 / H265) |
||||||
|
*/ |
||||||
|
enum class RateControlMode: int { CBR, VBR }; |
||||||
|
|
||||||
|
/**
|
||||||
|
* Encoding profile, H264, H265 or MJPEG |
||||||
|
*/ |
||||||
|
enum class Profile: int { H264_BASELINE, H264_HIGH, H264_MAIN, H265_MAIN, MJPEG }; |
||||||
|
/**
|
||||||
|
* Specifies prefered bitrate (kb) of compressed output bitstream |
||||||
|
*/ |
||||||
|
std::int32_t bitrate = 8000; |
||||||
|
/**
|
||||||
|
* Every x number of frames a keyframe will be inserted |
||||||
|
*/ |
||||||
|
std::int32_t keyframeFrequency = 30; |
||||||
|
/**
|
||||||
|
* Specifies maximum bitrate (kb) of compressed output bitstream |
||||||
|
*/ |
||||||
|
std::int32_t maxBitrate = 8000; |
||||||
|
/**
|
||||||
|
* Specifies number of B frames to be inserted |
||||||
|
*/ |
||||||
|
std::int32_t numBFrames = 0; |
||||||
|
/**
|
||||||
|
* This options specifies how many frames are available in this nodes pool (can help if |
||||||
|
* receiver node is slow at consuming |
||||||
|
*/ |
||||||
|
std::uint32_t numFramesPool = 4; |
||||||
|
/**
|
||||||
|
* Encoding profile, H264, H265 or MJPEG |
||||||
|
*/ |
||||||
|
Profile profile = Profile::H265_MAIN; |
||||||
|
/**
|
||||||
|
* Value between 0-100% (approximates quality) |
||||||
|
*/ |
||||||
|
std::int32_t quality = 80; |
||||||
|
/**
|
||||||
|
* Lossless mode ([M]JPEG only) |
||||||
|
*/ |
||||||
|
bool lossless = false; |
||||||
|
/**
|
||||||
|
* Rate control mode specifies if constant or variable bitrate should be used (H264 / H265) |
||||||
|
*/ |
||||||
|
RateControlMode rateCtrlMode = RateControlMode::CBR; |
||||||
|
/**
|
||||||
|
* Input and compressed output frame width |
||||||
|
*/ |
||||||
|
std::int32_t width = 1920; |
||||||
|
/**
|
||||||
|
* Input and compressed output frame height |
||||||
|
*/ |
||||||
|
std::int32_t height = 1080; |
||||||
|
/**
|
||||||
|
* Frame rate |
||||||
|
*/ |
||||||
|
float frameRate = 30.0f; |
||||||
|
}; |
||||||
|
|
||||||
|
G_API_OP(GEncFrame, <GArray<uint8_t>(GFrame, EncoderConfig)>, "org.opencv.oak.enc_frame") { |
||||||
|
static GArrayDesc outMeta(const GFrameDesc&, const EncoderConfig&) { |
||||||
|
return cv::empty_array_desc(); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
G_API_OP(GSobelXY, <GFrame(GFrame, const cv::Mat&, const cv::Mat&)>, "org.opencv.oak.sobelxy") { |
||||||
|
static GFrameDesc outMeta(const GFrameDesc& in, const cv::Mat&, const cv::Mat&) { |
||||||
|
return in; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
GAPI_EXPORTS GArray<uint8_t> encode(const GFrame& in, const EncoderConfig&); |
||||||
|
|
||||||
|
GAPI_EXPORTS GFrame sobelXY(const GFrame& in, |
||||||
|
const cv::Mat& hk, |
||||||
|
const cv::Mat& vk); |
||||||
|
|
||||||
|
// OAK backend & kernels ////////////////////////////////////////////////////////
|
||||||
|
GAPI_EXPORTS cv::gapi::GBackend backend(); |
||||||
|
GAPI_EXPORTS cv::gapi::GKernelPackage kernels(); |
||||||
|
|
||||||
|
// Camera object ///////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
struct GAPI_EXPORTS ColorCameraParams {}; |
||||||
|
|
||||||
|
class GAPI_EXPORTS ColorCamera: public cv::gapi::wip::IStreamSource { |
||||||
|
cv::MediaFrame m_dummy; |
||||||
|
|
||||||
|
virtual bool pull(cv::gapi::wip::Data &data) override; |
||||||
|
virtual GMetaArg descr_of() const override; |
||||||
|
|
||||||
|
public: |
||||||
|
ColorCamera(); |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace oak
|
||||||
|
} // namespace gapi
|
||||||
|
|
||||||
|
namespace detail { |
||||||
|
template<> struct CompileArgTag<gapi::oak::ColorCameraParams> { |
||||||
|
static const char* tag() { return "gapi.oak.colorCameraParams"; } |
||||||
|
}; |
||||||
|
|
||||||
|
template<> struct CompileArgTag<gapi::oak::EncoderConfig> { |
||||||
|
static const char* tag() { return "gapi.oak.encoderConfig"; } |
||||||
|
}; |
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
} // namespace cv
|
||||||
|
|
||||||
|
#endif // OPENCV_GAPI_OAK_HPP
|
||||||
@ -0,0 +1,70 @@ |
|||||||
|
#include <fstream> |
||||||
|
|
||||||
|
#include <opencv2/gapi.hpp> |
||||||
|
#include <opencv2/gapi/core.hpp> |
||||||
|
#include <opencv2/gapi/gframe.hpp> |
||||||
|
|
||||||
|
#include <opencv2/gapi/oak/oak.hpp> |
||||||
|
#include <opencv2/gapi/streaming/format.hpp> // BGR accessor |
||||||
|
|
||||||
|
#include <opencv2/highgui.hpp> // CommandLineParser |
||||||
|
|
||||||
|
const std::string keys = |
||||||
|
"{ h help | | Print this help message }" |
||||||
|
"{ output | output.h265 | Path to the output .h265 video file }"; |
||||||
|
|
||||||
|
#ifdef HAVE_OAK |
||||||
|
|
||||||
|
int main(int argc, char *argv[]) { |
||||||
|
cv::CommandLineParser cmd(argc, argv, keys); |
||||||
|
if (cmd.has("help")) { |
||||||
|
cmd.printMessage(); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
const std::string output_name = cmd.get<std::string>("output"); |
||||||
|
|
||||||
|
cv::gapi::oak::EncoderConfig cfg; |
||||||
|
cfg.profile = cv::gapi::oak::EncoderConfig::Profile::H265_MAIN; |
||||||
|
|
||||||
|
cv::GFrame in; |
||||||
|
cv::GArray<uint8_t> encoded = cv::gapi::oak::encode(in, cfg); |
||||||
|
|
||||||
|
auto args = cv::compile_args(cv::gapi::oak::ColorCameraParams{}, cv::gapi::oak::kernels()); |
||||||
|
|
||||||
|
auto pipeline = cv::GComputation(cv::GIn(in), cv::GOut(encoded)).compileStreaming(std::move(args)); |
||||||
|
|
||||||
|
// Graph execution /////////////////////////////////////////////////////////
|
||||||
|
pipeline.setSource(cv::gapi::wip::make_src<cv::gapi::oak::ColorCamera>()); |
||||||
|
pipeline.start(); |
||||||
|
|
||||||
|
std::vector<uint8_t> out_h265_data; |
||||||
|
|
||||||
|
std::ofstream out_h265_file; |
||||||
|
out_h265_file.open(output_name, std::ofstream::out | std::ofstream::binary | std::ofstream::trunc); |
||||||
|
|
||||||
|
// Pull 300 frames from the camera
|
||||||
|
uint32_t frames = 300; |
||||||
|
uint32_t pulled = 0; |
||||||
|
|
||||||
|
while (pipeline.pull(cv::gout(out_h265_data))) { |
||||||
|
if (out_h265_file.is_open()) { |
||||||
|
out_h265_file.write(reinterpret_cast<const char*>(out_h265_data.data()), |
||||||
|
out_h265_data.size()); |
||||||
|
} |
||||||
|
if (pulled++ == frames) { |
||||||
|
pipeline.stop(); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
std::cout << "Pipeline finished: " << output_name << " file has been written." << std::endl; |
||||||
|
} |
||||||
|
#else // HAVE_OAK
|
||||||
|
|
||||||
|
int main() { |
||||||
|
GAPI_Assert(false && "Built without OAK support"); |
||||||
|
return -1; |
||||||
|
} |
||||||
|
|
||||||
|
#endif // HAVE_OAK
|
||||||
@ -0,0 +1,69 @@ |
|||||||
|
#include <opencv2/gapi.hpp> |
||||||
|
#include <opencv2/gapi/core.hpp> |
||||||
|
#include <opencv2/gapi/cpu/core.hpp> |
||||||
|
#include <opencv2/gapi/gframe.hpp> |
||||||
|
#include <opencv2/gapi/media.hpp> |
||||||
|
|
||||||
|
#include <opencv2/gapi/oak/oak.hpp> |
||||||
|
#include <opencv2/gapi/streaming/format.hpp> // BGR accessor |
||||||
|
|
||||||
|
#include <opencv2/highgui.hpp> // CommandLineParser |
||||||
|
|
||||||
|
const std::string keys = |
||||||
|
"{ h help | | Print this help message }" |
||||||
|
"{ output | output.png | Path to the output file }"; |
||||||
|
|
||||||
|
#ifdef HAVE_OAK |
||||||
|
|
||||||
|
int main(int argc, char *argv[]) { |
||||||
|
cv::CommandLineParser cmd(argc, argv, keys); |
||||||
|
if (cmd.has("help")) { |
||||||
|
cmd.printMessage(); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
const std::string output_name = cmd.get<std::string>("output"); |
||||||
|
|
||||||
|
std::vector<int> h = {1, 0, -1, |
||||||
|
2, 0, -2, |
||||||
|
1, 0, -1}; |
||||||
|
std::vector<int> v = { 1, 2, 1, |
||||||
|
0, 0, 0, |
||||||
|
-1, -2, -1}; |
||||||
|
cv::Mat hk(3, 3, CV_32SC1, h.data()); |
||||||
|
cv::Mat vk(3, 3, CV_32SC1, v.data()); |
||||||
|
|
||||||
|
// Heterogeneous pipeline:
|
||||||
|
// OAK camera -> Sobel -> streaming accessor (CPU)
|
||||||
|
cv::GFrame in; |
||||||
|
cv::GFrame sobel = cv::gapi::oak::sobelXY(in, hk, vk); |
||||||
|
// Default camera and then sobel work only with nv12 format
|
||||||
|
cv::GMat out = cv::gapi::streaming::Y(sobel); |
||||||
|
|
||||||
|
auto args = cv::compile_args(cv::gapi::oak::ColorCameraParams{}, |
||||||
|
cv::gapi::oak::kernels()); |
||||||
|
|
||||||
|
auto pipeline = cv::GComputation(cv::GIn(in), cv::GOut(out)).compileStreaming(std::move(args)); |
||||||
|
|
||||||
|
// Graph execution /////////////////////////////////////////////////////////
|
||||||
|
cv::Mat out_mat(1920, 1080, CV_8UC1); |
||||||
|
|
||||||
|
pipeline.setSource(cv::gapi::wip::make_src<cv::gapi::oak::ColorCamera>()); |
||||||
|
pipeline.start(); |
||||||
|
|
||||||
|
// pull 1 frame
|
||||||
|
pipeline.pull(cv::gout(out_mat)); |
||||||
|
|
||||||
|
cv::imwrite(output_name, out_mat); |
||||||
|
|
||||||
|
std::cout << "Pipeline finished: " << output_name << " file has been written." << std::endl; |
||||||
|
} |
||||||
|
|
||||||
|
#else // HAVE_OAK
|
||||||
|
|
||||||
|
int main() { |
||||||
|
GAPI_Assert(false && "Built without OAK support"); |
||||||
|
return -1; |
||||||
|
} |
||||||
|
|
||||||
|
#endif // HAVE_OAK
|
||||||
@ -0,0 +1,47 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
//
|
||||||
|
// Copyright (C) 2021 Intel Corporation
|
||||||
|
|
||||||
|
#include <opencv2/gapi/oak/oak.hpp> |
||||||
|
#include <opencv2/gapi/cpu/gcpukernel.hpp> |
||||||
|
|
||||||
|
#include "oak_media_adapter.hpp" |
||||||
|
|
||||||
|
#include <thread> |
||||||
|
#include <chrono> |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace gapi { |
||||||
|
namespace oak { |
||||||
|
|
||||||
|
GArray<uint8_t> encode(const GFrame& in, const EncoderConfig& cfg) { |
||||||
|
return GEncFrame::on(in, cfg); |
||||||
|
} |
||||||
|
|
||||||
|
GFrame sobelXY(const GFrame& in, const cv::Mat& hk, const cv::Mat& vk) { |
||||||
|
return GSobelXY::on(in, hk, vk); |
||||||
|
} |
||||||
|
|
||||||
|
// This is a dummy oak::ColorCamera class that just makes our pipelining
|
||||||
|
// machinery work. The real data comes from the physical camera which
|
||||||
|
// is handled by DepthAI library.
|
||||||
|
ColorCamera::ColorCamera() |
||||||
|
: m_dummy(cv::MediaFrame::Create<cv::gapi::oak::OAKMediaAdapter>()) { |
||||||
|
} |
||||||
|
|
||||||
|
bool ColorCamera::pull(cv::gapi::wip::Data &data) { |
||||||
|
// FIXME: Avoid passing this formal frame to the pipeline
|
||||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(10)); |
||||||
|
data = m_dummy; |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
cv::GMetaArg ColorCamera::descr_of() const { |
||||||
|
return cv::GMetaArg{cv::descr_of(m_dummy)}; |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace oak
|
||||||
|
} // namespace gapi
|
||||||
|
} // namespace cv
|
||||||
@ -0,0 +1,32 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
//
|
||||||
|
// Copyright (C) 2021 Intel Corporation
|
||||||
|
|
||||||
|
#include "oak_media_adapter.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace gapi { |
||||||
|
namespace oak { |
||||||
|
|
||||||
|
OAKMediaAdapter::OAKMediaAdapter(cv::Size sz, cv::MediaFormat fmt, std::vector<uint8_t>&& buffer) { |
||||||
|
GAPI_Assert(fmt == cv::MediaFormat::NV12 && "OAKMediaAdapter only supports NV12 format for now"); |
||||||
|
m_sz = sz; |
||||||
|
m_fmt = fmt; |
||||||
|
m_buffer = buffer; |
||||||
|
} |
||||||
|
|
||||||
|
MediaFrame::View OAKMediaAdapter::OAKMediaAdapter::access(MediaFrame::Access) { |
||||||
|
uint8_t* y_ptr = m_buffer.data(); |
||||||
|
uint8_t* uv_ptr = m_buffer.data() + static_cast<long>(m_buffer.size() / 3 * 2); |
||||||
|
return MediaFrame::View{cv::MediaFrame::View::Ptrs{y_ptr, uv_ptr}, |
||||||
|
cv::MediaFrame::View::Strides{static_cast<long unsigned int>(m_sz.width), |
||||||
|
static_cast<long unsigned int>(m_sz.width)}}; |
||||||
|
} |
||||||
|
|
||||||
|
cv::GFrameDesc OAKMediaAdapter::OAKMediaAdapter::meta() const { return {m_fmt, m_sz}; } |
||||||
|
|
||||||
|
} // namespace oak
|
||||||
|
} // namespace gapi
|
||||||
|
} // namespace cv
|
||||||
@ -0,0 +1,711 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
//
|
||||||
|
// Copyright (C) 2021 Intel Corporation
|
||||||
|
|
||||||
|
#include <opencv2/gapi/gkernel.hpp> // GKernelPackage |
||||||
|
|
||||||
|
#ifdef HAVE_OAK |
||||||
|
|
||||||
|
#include <cstring> |
||||||
|
#include <unordered_set> |
||||||
|
#include <algorithm> // any_of |
||||||
|
#include <functional> // reference_wrapper |
||||||
|
|
||||||
|
#include <ade/util/zip_range.hpp> |
||||||
|
|
||||||
|
#include <api/gbackend_priv.hpp> |
||||||
|
#include <backends/common/gbackend.hpp> |
||||||
|
|
||||||
|
#include <opencv2/gapi/streaming/meta.hpp> // streaming::meta_tag |
||||||
|
|
||||||
|
#include "depthai/depthai.hpp" |
||||||
|
|
||||||
|
#include <opencv2/gapi/oak/oak.hpp> |
||||||
|
#include "oak_media_adapter.hpp" |
||||||
|
|
||||||
|
namespace cv { namespace gimpl { |
||||||
|
|
||||||
|
// Forward declaration
|
||||||
|
class GOAKContext; |
||||||
|
struct OAKNodeInfo; |
||||||
|
|
||||||
|
class GOAKExecutable final: public GIslandExecutable { |
||||||
|
friend class GOAKContext; |
||||||
|
virtual void run(std::vector<InObj>&&, |
||||||
|
std::vector<OutObj>&&) override { |
||||||
|
GAPI_Assert(false && "Not implemented"); |
||||||
|
} |
||||||
|
|
||||||
|
virtual void run(GIslandExecutable::IInput &in, |
||||||
|
GIslandExecutable::IOutput &out) override; |
||||||
|
|
||||||
|
void LinkToParents(ade::NodeHandle handle); |
||||||
|
|
||||||
|
class ExtractTypeHelper : protected dai::Node { |
||||||
|
public: |
||||||
|
using Input = dai::Node::Input; |
||||||
|
using Output = dai::Node::Output; |
||||||
|
using InputPtr = dai::Node::Input*; |
||||||
|
using OutputPtr = dai::Node::Output*; |
||||||
|
}; |
||||||
|
|
||||||
|
struct OAKNodeInfo { |
||||||
|
std::shared_ptr<dai::Node> node = nullptr; |
||||||
|
std::vector<ExtractTypeHelper::InputPtr> inputs = {}; |
||||||
|
std::vector<ExtractTypeHelper::OutputPtr> outputs = {}; |
||||||
|
}; |
||||||
|
|
||||||
|
struct OAKOutQueueInfo { |
||||||
|
std::shared_ptr<dai::node::XLinkOut> xlink_output; |
||||||
|
std::shared_ptr<dai::DataOutputQueue> out_queue; |
||||||
|
std::string out_queue_name; |
||||||
|
}; |
||||||
|
|
||||||
|
cv::GArg packInArg(const GArg &arg, std::vector<ExtractTypeHelper::InputPtr>& oak_ins); |
||||||
|
void packOutArg(const RcDesc &rc, std::vector<ExtractTypeHelper::OutputPtr>& oak_outs); |
||||||
|
|
||||||
|
const ade::Graph& m_g; |
||||||
|
GModel::ConstGraph m_gm; |
||||||
|
cv::GCompileArgs m_args; |
||||||
|
|
||||||
|
std::unordered_map<ade::NodeHandle, |
||||||
|
OAKNodeInfo, |
||||||
|
ade::HandleHasher<ade::Node>> m_oak_nodes; |
||||||
|
|
||||||
|
// Will be reworked later when XLinkIn will be introduced as input
|
||||||
|
std::shared_ptr<dai::node::ColorCamera> m_camera_input; |
||||||
|
cv::Size m_camera_size; |
||||||
|
|
||||||
|
// Backend outputs
|
||||||
|
std::vector<OAKOutQueueInfo> m_out_queues; |
||||||
|
|
||||||
|
// Backend inputs
|
||||||
|
std::vector<std::pair<std::string, dai::Buffer>> m_in_queues; |
||||||
|
|
||||||
|
// Note: dai::Pipeline should be the only one for the whole pipeline,
|
||||||
|
// so there is no way to insert any non-OAK node in graph between other OAK nodes.
|
||||||
|
// The only heterogeneous case possible is if we insert other backends after or before
|
||||||
|
// OAK island.
|
||||||
|
std::unique_ptr<dai::Device> m_device; |
||||||
|
std::unique_ptr<dai::Pipeline> m_pipeline; |
||||||
|
|
||||||
|
public: |
||||||
|
GOAKExecutable(const ade::Graph& g, |
||||||
|
const cv::GCompileArgs& args, |
||||||
|
const std::vector<ade::NodeHandle>& nodes, |
||||||
|
const std::vector<cv::gimpl::Data>& ins_data, |
||||||
|
const std::vector<cv::gimpl::Data>& outs_data); |
||||||
|
~GOAKExecutable() = default; |
||||||
|
|
||||||
|
// FIXME: could it reshape?
|
||||||
|
virtual bool canReshape() const override { return false; } |
||||||
|
virtual void reshape(ade::Graph&, const GCompileArgs&) override { |
||||||
|
GAPI_Assert(false && "GOAKExecutable::reshape() is not supported"); |
||||||
|
} |
||||||
|
|
||||||
|
virtual void handleNewStream() override; |
||||||
|
virtual void handleStopStream() override; |
||||||
|
}; |
||||||
|
|
||||||
|
class GOAKContext { |
||||||
|
public: |
||||||
|
// FIXME: make private?
|
||||||
|
using Input = GOAKExecutable::ExtractTypeHelper::Input; |
||||||
|
using Output = GOAKExecutable::ExtractTypeHelper::Output; |
||||||
|
using InputPtr = GOAKExecutable::ExtractTypeHelper::Input*; |
||||||
|
using OutputPtr = GOAKExecutable::ExtractTypeHelper::Output*; |
||||||
|
|
||||||
|
GOAKContext(const std::unique_ptr<dai::Pipeline>& pipeline, |
||||||
|
const cv::Size& camera_size, |
||||||
|
std::vector<cv::GArg>& args, |
||||||
|
std::vector<OutputPtr>& results); |
||||||
|
|
||||||
|
// Generic accessor API
|
||||||
|
template<typename T> |
||||||
|
T& inArg(int input) { return m_args.at(input).get<T>(); } |
||||||
|
|
||||||
|
// FIXME: consider not using raw pointers
|
||||||
|
InputPtr& in(int input); |
||||||
|
OutputPtr& out(int output); |
||||||
|
|
||||||
|
const std::unique_ptr<dai::Pipeline>& pipeline(); |
||||||
|
const cv::Size& camera_size() const; |
||||||
|
|
||||||
|
private: |
||||||
|
const std::unique_ptr<dai::Pipeline>& m_pipeline; |
||||||
|
const cv::Size& m_camera_size; |
||||||
|
std::vector<cv::GArg>& m_args; |
||||||
|
std::vector<OutputPtr>& m_outputs; |
||||||
|
}; |
||||||
|
|
||||||
|
GOAKContext::GOAKContext(const std::unique_ptr<dai::Pipeline>& pipeline, |
||||||
|
const cv::Size& camera_size, |
||||||
|
std::vector<cv::GArg>& args, |
||||||
|
std::vector<OutputPtr>& results) |
||||||
|
: m_pipeline(pipeline), m_camera_size(camera_size), m_args(args), m_outputs(results) {} |
||||||
|
|
||||||
|
const std::unique_ptr<dai::Pipeline>& GOAKContext::pipeline() { |
||||||
|
return m_pipeline; |
||||||
|
} |
||||||
|
|
||||||
|
const cv::Size& GOAKContext::camera_size() const { |
||||||
|
return m_camera_size; |
||||||
|
} |
||||||
|
|
||||||
|
GOAKContext::InputPtr& GOAKContext::in(int input) { |
||||||
|
return inArg<std::reference_wrapper<GOAKContext::InputPtr>>(input).get(); |
||||||
|
} |
||||||
|
|
||||||
|
GOAKContext::OutputPtr& GOAKContext::out(int output) { |
||||||
|
return m_outputs.at(output); |
||||||
|
} |
||||||
|
|
||||||
|
namespace detail { |
||||||
|
template<class T> struct get_in; |
||||||
|
template<> struct get_in<cv::GFrame> { |
||||||
|
static GOAKContext::InputPtr& get(GOAKContext &ctx, int idx) { return ctx.in(idx); } |
||||||
|
}; |
||||||
|
template<class T> struct get_in { |
||||||
|
static T get(GOAKContext &ctx, int idx) { return ctx.inArg<T>(idx); } |
||||||
|
}; |
||||||
|
// FIXME: add support of other types
|
||||||
|
|
||||||
|
template<class T> struct get_out; |
||||||
|
template<> struct get_out<cv::GFrame> { |
||||||
|
static GOAKContext::OutputPtr& get(GOAKContext &ctx, int idx) { return ctx.out(idx); } |
||||||
|
}; |
||||||
|
template<typename U> struct get_out<cv::GArray<U>> { |
||||||
|
static GOAKContext::OutputPtr& get(GOAKContext &ctx, int idx) { return ctx.out(idx); } |
||||||
|
}; |
||||||
|
// FIXME: add support of other types
|
||||||
|
|
||||||
|
struct OAKKernelParams { |
||||||
|
const std::unique_ptr<dai::Pipeline>& pipeline; |
||||||
|
const cv::Size& camera_size; |
||||||
|
std::vector<std::pair<std::string, dai::Buffer>>& m_in_queues; |
||||||
|
}; |
||||||
|
|
||||||
|
template<typename, typename, typename> |
||||||
|
struct OAKCallHelper; |
||||||
|
|
||||||
|
template<typename Impl, typename... Ins, typename... Outs> |
||||||
|
struct OAKCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...> > { |
||||||
|
template<int... IIs, int... OIs> |
||||||
|
static std::shared_ptr<dai::Node> construct_impl( GOAKContext &ctx |
||||||
|
, std::vector<std::pair<std::string, |
||||||
|
dai::Buffer>>& in_queues_params |
||||||
|
, cv::detail::Seq<IIs...> |
||||||
|
, cv::detail::Seq<OIs...>) { |
||||||
|
return Impl::put(OAKKernelParams{ctx.pipeline(), |
||||||
|
ctx.camera_size(), |
||||||
|
in_queues_params}, |
||||||
|
get_in<Ins>::get(ctx, IIs)..., |
||||||
|
get_out<Outs>::get(ctx, OIs)...); |
||||||
|
} |
||||||
|
|
||||||
|
static std::shared_ptr<dai::Node> construct(GOAKContext &ctx, |
||||||
|
std::vector<std::pair<std::string, |
||||||
|
dai::Buffer>>& in_queues_params) { |
||||||
|
return construct_impl(ctx, |
||||||
|
in_queues_params, |
||||||
|
typename cv::detail::MkSeq<sizeof...(Ins)>::type(), |
||||||
|
typename cv::detail::MkSeq<sizeof...(Outs)>::type()); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
struct GOAKKernel { |
||||||
|
using F = std::function<std::shared_ptr<dai::Node>(GOAKContext&, |
||||||
|
std::vector<std::pair<std::string, dai::Buffer>>&)>; |
||||||
|
explicit GOAKKernel(const F& f) : m_put_f(f) {} |
||||||
|
const F m_put_f; |
||||||
|
}; |
||||||
|
|
||||||
|
struct OAKComponent |
||||||
|
{ |
||||||
|
static const char *name() { return "OAK Component"; } |
||||||
|
GOAKKernel k; |
||||||
|
}; |
||||||
|
|
||||||
|
}} // namespace gimpl // namespace cv
|
||||||
|
|
||||||
|
using OAKGraph = ade::TypedGraph |
||||||
|
< cv::gimpl::OAKComponent |
||||||
|
// FIXME: extend
|
||||||
|
>; |
||||||
|
|
||||||
|
using ConstOAKGraph = ade::ConstTypedGraph |
||||||
|
< cv::gimpl::OAKComponent |
||||||
|
// FIXME: extend
|
||||||
|
>; |
||||||
|
|
||||||
|
// This function links dai operation nodes - parent's output to child's input.
|
||||||
|
// It utilizes G-API graph to search for operation's node it's previous operation in graph
|
||||||
|
// when links them in dai graph.
|
||||||
|
void cv::gimpl::GOAKExecutable::LinkToParents(ade::NodeHandle handle) |
||||||
|
{ |
||||||
|
ade::NodeHandle parent; |
||||||
|
for (const auto& data_nh : handle.get()->inNodes()) { |
||||||
|
// Data node has only 1 input
|
||||||
|
GAPI_Assert(data_nh.get()->inNodes().size() == 1); |
||||||
|
parent = data_nh.get()->inNodes().front(); |
||||||
|
|
||||||
|
// Assuming that OAK nodes are aligned for linking.
|
||||||
|
// FIXME: potential rework might be needed then
|
||||||
|
// counterexample is found.
|
||||||
|
GAPI_Assert(m_oak_nodes.at(handle).inputs.size() == |
||||||
|
m_oak_nodes.at(parent).outputs.size() && |
||||||
|
"Internal OAK nodes are not aligned for linking"); |
||||||
|
for (auto && it : ade::util::zip(ade::util::toRange(m_oak_nodes.at(parent).outputs), |
||||||
|
ade::util::toRange(m_oak_nodes.at(handle).inputs))) |
||||||
|
{ |
||||||
|
auto &out = std::get<0>(it); |
||||||
|
auto &in = std::get<1>(it); |
||||||
|
out->link(*in); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
cv::GArg |
||||||
|
cv::gimpl::GOAKExecutable::packInArg(const GArg &arg, |
||||||
|
std::vector<ExtractTypeHelper::InputPtr>& oak_ins) { |
||||||
|
if (arg.kind != cv::detail::ArgKind::GOBJREF) { |
||||||
|
GAPI_Assert( arg.kind != cv::detail::ArgKind::GMAT |
||||||
|
&& arg.kind != cv::detail::ArgKind::GSCALAR |
||||||
|
&& arg.kind != cv::detail::ArgKind::GARRAY |
||||||
|
&& arg.kind != cv::detail::ArgKind::GOPAQUE |
||||||
|
&& arg.kind != cv::detail::ArgKind::GFRAME); |
||||||
|
// All other cases - pass as-is, with no transformations to
|
||||||
|
// GArg contents.
|
||||||
|
return const_cast<cv::GArg&>(arg); |
||||||
|
} |
||||||
|
const cv::gimpl::RcDesc &ref = arg.get<cv::gimpl::RcDesc>(); |
||||||
|
switch (ref.shape) { |
||||||
|
case GShape::GFRAME: |
||||||
|
oak_ins.push_back(nullptr); |
||||||
|
return GArg(std::reference_wrapper<ExtractTypeHelper::InputPtr>(oak_ins.back())); |
||||||
|
break; |
||||||
|
default: |
||||||
|
util::throw_error(std::logic_error("Unsupported GShape type in OAK backend")); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void cv::gimpl::GOAKExecutable::packOutArg(const RcDesc &rc, |
||||||
|
std::vector<ExtractTypeHelper::OutputPtr>& oak_outs) { |
||||||
|
switch (rc.shape) { |
||||||
|
case GShape::GFRAME: |
||||||
|
oak_outs.push_back(nullptr); |
||||||
|
break; |
||||||
|
case GShape::GARRAY: |
||||||
|
oak_outs.push_back(nullptr); |
||||||
|
break; |
||||||
|
default: |
||||||
|
util::throw_error(std::logic_error("Unsupported GShape type in OAK backend")); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
cv::gimpl::GOAKExecutable::GOAKExecutable(const ade::Graph& g, |
||||||
|
const cv::GCompileArgs &args, |
||||||
|
const std::vector<ade::NodeHandle>& nodes, |
||||||
|
const std::vector<cv::gimpl::Data>& ins_data, |
||||||
|
const std::vector<cv::gimpl::Data>& outs_data) |
||||||
|
: m_g(g), m_gm(m_g), m_args(args), |
||||||
|
m_device(nullptr), m_pipeline(new dai::Pipeline) |
||||||
|
{ |
||||||
|
// FIXME: currently OAK backend only works with camera as input,
|
||||||
|
// so it must be a single object
|
||||||
|
GAPI_Assert(ins_data.size() == 1); |
||||||
|
|
||||||
|
// Check that there is only one OAK island in graph since there
|
||||||
|
// can only be one instance of dai::Pipeline in the application
|
||||||
|
auto isl_graph = m_gm.metadata().get<IslandModel>().model; |
||||||
|
GIslandModel::Graph gim(*isl_graph); |
||||||
|
size_t oak_islands = 0; |
||||||
|
|
||||||
|
for (const auto& nh : gim.nodes()) |
||||||
|
{ |
||||||
|
if (gim.metadata(nh).get<NodeKind>().k == NodeKind::ISLAND) |
||||||
|
{ |
||||||
|
const auto isl = gim.metadata(nh).get<FusedIsland>().object; |
||||||
|
if (isl->backend() == cv::gapi::oak::backend()) |
||||||
|
{ |
||||||
|
++oak_islands; |
||||||
|
} |
||||||
|
if (oak_islands > 1) { |
||||||
|
util::throw_error |
||||||
|
(std::logic_error |
||||||
|
("There can only be one OAK island in graph")); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// FIXME: change the hard-coded behavior (XLinkIn path)
|
||||||
|
auto camRgb = m_pipeline->create<dai::node::ColorCamera>(); |
||||||
|
// FIXME: extract camera compile arguments here and properly convert them for dai
|
||||||
|
camRgb->setBoardSocket(dai::CameraBoardSocket::RGB); |
||||||
|
camRgb->setResolution(dai::ColorCameraProperties::SensorResolution::THE_1080_P); |
||||||
|
|
||||||
|
// Set camera output. Fixme: consider working with other camera outputs
|
||||||
|
m_camera_input = camRgb; |
||||||
|
// FIXME: change when other camera censors are introduced
|
||||||
|
std::tuple<int, int> video_size = camRgb->getVideoSize(); |
||||||
|
m_camera_size = cv::Size{std::get<0>(video_size), std::get<1>(video_size)}; |
||||||
|
|
||||||
|
// Prepare XLinkOut nodes for each output object in graph
|
||||||
|
for (size_t i = 0; i < outs_data.size(); ++i) { |
||||||
|
auto xout = m_pipeline->create<dai::node::XLinkOut>(); |
||||||
|
std::string xout_name = "xout" + std::to_string(i); |
||||||
|
xout->setStreamName(xout_name); |
||||||
|
m_out_queues.push_back({xout, nullptr, xout_name}); |
||||||
|
} |
||||||
|
|
||||||
|
// Create OAK node for each node in this backend
|
||||||
|
for (const auto& nh : nodes) { |
||||||
|
if (m_gm.metadata(nh).get<NodeType>().t == NodeType::OP) { |
||||||
|
const auto& op = m_gm.metadata(nh).get<Op>(); |
||||||
|
const auto &u = ConstOAKGraph(m_g).metadata(nh).get<OAKComponent>(); |
||||||
|
// pass kernel input args and compile args to prepare OAK node and
|
||||||
|
// store it to link later
|
||||||
|
m_oak_nodes[nh] = {}; |
||||||
|
m_oak_nodes.at(nh).inputs.reserve(op.args.size()); |
||||||
|
m_oak_nodes.at(nh).outputs.reserve(op.outs.size()); |
||||||
|
|
||||||
|
std::vector<cv::GArg> in_ctx_args; |
||||||
|
in_ctx_args.reserve(op.args.size()); |
||||||
|
for (auto &op_arg : op.args) in_ctx_args.push_back(packInArg(op_arg, |
||||||
|
m_oak_nodes.at(nh).inputs)); |
||||||
|
for (auto &&op_out : op.outs) packOutArg(op_out, m_oak_nodes.at(nh).outputs); |
||||||
|
GAPI_Assert(!m_oak_nodes.at(nh).inputs.empty()); |
||||||
|
GAPI_Assert(!m_oak_nodes.at(nh).outputs.empty()); |
||||||
|
|
||||||
|
GOAKContext ctx(m_pipeline, m_camera_size, in_ctx_args, m_oak_nodes.at(nh).outputs); |
||||||
|
m_oak_nodes.at(nh).node = u.k.m_put_f(ctx, m_in_queues); |
||||||
|
GAPI_Assert(m_oak_nodes.at(nh).node != nullptr); |
||||||
|
|
||||||
|
// Check that all inputs and outputs are properly filled after constructing kernels
|
||||||
|
// to then link it together
|
||||||
|
// FIXME: add more logging
|
||||||
|
const auto& node = m_oak_nodes.at(nh); |
||||||
|
if (std::any_of(node.inputs.cbegin(), node.inputs.cend(), |
||||||
|
[](ExtractTypeHelper::InputPtr ptr) { |
||||||
|
return ptr == nullptr; |
||||||
|
})) { |
||||||
|
GAPI_Assert(false && "DAI input are not set"); |
||||||
|
} |
||||||
|
if (std::any_of(node.outputs.cbegin(), node.outputs.cend(), |
||||||
|
[](ExtractTypeHelper::OutputPtr ptr) { |
||||||
|
return ptr == nullptr; |
||||||
|
})) { |
||||||
|
GAPI_Assert(false && "DAI outputs are not set"); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Prepare nodes for linking
|
||||||
|
std::unordered_set<ade::NodeHandle, |
||||||
|
ade::HandleHasher<ade::Node>> in_nodes; |
||||||
|
std::unordered_set<ade::NodeHandle, |
||||||
|
ade::HandleHasher<ade::Node>> out_nodes; |
||||||
|
std::unordered_set<ade::NodeHandle, |
||||||
|
ade::HandleHasher<ade::Node>> inter_nodes; |
||||||
|
|
||||||
|
// TODO: optimize this loop
|
||||||
|
for (const auto& node : m_oak_nodes) { |
||||||
|
auto nh = node.first; |
||||||
|
// Fill input op nodes
|
||||||
|
for (const auto& d : ins_data) { |
||||||
|
for (const auto& indata : nh.get()->inNodes()) { |
||||||
|
auto rc = m_gm.metadata(indata).get<cv::gimpl::Data>().rc; |
||||||
|
if (rc == d.rc) { |
||||||
|
in_nodes.insert(nh); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
// Fill output op nodes
|
||||||
|
for (const auto& d : outs_data) { |
||||||
|
for (const auto& outdata : nh.get()->outNodes()) { |
||||||
|
auto rc = m_gm.metadata(outdata).get<cv::gimpl::Data>().rc; |
||||||
|
if (rc == d.rc) { |
||||||
|
out_nodes.insert(nh); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
// Fill internal op nodes
|
||||||
|
if (in_nodes.find(nh) == in_nodes.end() && |
||||||
|
out_nodes.find(nh) == in_nodes.end()) { |
||||||
|
inter_nodes.insert(nh); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Properly link all nodes
|
||||||
|
// 1. Link input nodes to camera
|
||||||
|
for (const auto& nh : in_nodes) { |
||||||
|
GAPI_Assert(m_oak_nodes.at(nh).inputs.size() == 1); |
||||||
|
// FIXME: covert other camera outputs
|
||||||
|
m_camera_input->video.link(*(m_oak_nodes.at(nh).inputs[0])); |
||||||
|
} |
||||||
|
|
||||||
|
// 2. Link output nodes to XLinkOut nodes
|
||||||
|
size_t out_counter = 0; |
||||||
|
for (const auto& nh : out_nodes) { |
||||||
|
GAPI_Assert(out_counter + m_oak_nodes.at(nh).outputs.size() <= m_out_queues.size()); |
||||||
|
for (const auto& out : m_oak_nodes.at(nh).outputs) { |
||||||
|
out->link(m_out_queues[out_counter++].xlink_output->input); |
||||||
|
} |
||||||
|
// Input nodes in OAK doesn't have parent operation - just camera (for now)
|
||||||
|
if (in_nodes.find(nh) == in_nodes.end()) { |
||||||
|
LinkToParents(nh); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// 3. Link internal nodes to their parents
|
||||||
|
for (const auto& nh : inter_nodes) { |
||||||
|
// Input nodes in OAK doesn't have parent operation - just camera (for now)
|
||||||
|
if (in_nodes.find(nh) == in_nodes.end()) { |
||||||
|
LinkToParents(nh); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
m_device = std::unique_ptr<dai::Device>(new dai::Device(*m_pipeline)); |
||||||
|
|
||||||
|
// Prepare OAK output queues
|
||||||
|
GAPI_Assert(m_out_queues.size() == outs_data.size()); |
||||||
|
for (const auto out_it : ade::util::indexed(outs_data)) |
||||||
|
{ |
||||||
|
auto& q = m_out_queues[ade::util::index(out_it)]; |
||||||
|
GAPI_Assert(q.out_queue == nullptr); // shouldn't be not filled till this point
|
||||||
|
// FIXME: add queue parameters
|
||||||
|
// Currently: 30 - max DAI queue capacity, true - blocking queue
|
||||||
|
q.out_queue = m_device->getOutputQueue(q.out_queue_name, 30, true); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void cv::gimpl::GOAKExecutable::handleNewStream() { |
||||||
|
// do nothing
|
||||||
|
} |
||||||
|
|
||||||
|
void cv::gimpl::GOAKExecutable::handleStopStream() { |
||||||
|
// do nothing
|
||||||
|
} |
||||||
|
|
||||||
|
void cv::gimpl::GOAKExecutable::run(GIslandExecutable::IInput &in, |
||||||
|
GIslandExecutable::IOutput &out) { |
||||||
|
const auto in_msg = in.get(); |
||||||
|
|
||||||
|
if (cv::util::holds_alternative<cv::gimpl::EndOfStream>(in_msg)) { |
||||||
|
out.post(cv::gimpl::EndOfStream{}); |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
for (const auto& in_q : m_in_queues) { |
||||||
|
auto q = m_device->getInputQueue(in_q.first); |
||||||
|
q->send(in_q.second); |
||||||
|
} |
||||||
|
|
||||||
|
for (size_t i = 0; i < m_out_queues.size(); ++i) { |
||||||
|
auto q = m_out_queues[i].out_queue; |
||||||
|
// TODO: support other DAI types if needed
|
||||||
|
// Note: we utilize getData() method that returns std::vector of data
|
||||||
|
// on which we gain ownership
|
||||||
|
auto oak_frame = q->get<dai::ImgFrame>(); |
||||||
|
|
||||||
|
auto out_arg = out.get(i); |
||||||
|
|
||||||
|
switch(out_arg.index()) { |
||||||
|
case cv::GRunArgP::index_of<cv::MediaFrame*>(): |
||||||
|
// FIXME: hard-coded NV12
|
||||||
|
*cv::util::get<cv::MediaFrame*>(out_arg) = |
||||||
|
cv::MediaFrame::Create<cv::gapi::oak::OAKMediaAdapter>( |
||||||
|
cv::Size(static_cast<int>(oak_frame->getWidth()), |
||||||
|
static_cast<int>(oak_frame->getHeight())), |
||||||
|
cv::MediaFormat::NV12, |
||||||
|
std::move(oak_frame->getData())); |
||||||
|
break; |
||||||
|
case cv::GRunArgP::index_of<cv::detail::VectorRef>(): |
||||||
|
cv::util::get<cv::detail::VectorRef>(out_arg).wref<uint8_t>() = std::move(oak_frame->getData()); |
||||||
|
break; |
||||||
|
// FIXME: Add support for remaining types
|
||||||
|
default: |
||||||
|
GAPI_Assert(false && "Unsupported type in OAK backend"); |
||||||
|
} |
||||||
|
|
||||||
|
using namespace cv::gapi::streaming::meta_tag; |
||||||
|
cv::GRunArg::Meta meta; |
||||||
|
meta[timestamp] = oak_frame->getTimestamp(); |
||||||
|
meta[seq_id] = oak_frame->getSequenceNum(); |
||||||
|
|
||||||
|
out.meta(out_arg, meta); |
||||||
|
out.post(std::move(out_arg)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Built-in kernels for OAK /////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
class GOAKBackendImpl final : public cv::gapi::GBackend::Priv { |
||||||
|
virtual void unpackKernel(ade::Graph &graph, |
||||||
|
const ade::NodeHandle &op_node, |
||||||
|
const cv::GKernelImpl &impl) override { |
||||||
|
OAKGraph gm(graph); |
||||||
|
|
||||||
|
const auto &kimpl = cv::util::any_cast<cv::gimpl::GOAKKernel>(impl.opaque); |
||||||
|
gm.metadata(op_node).set(cv::gimpl::OAKComponent{kimpl}); |
||||||
|
} |
||||||
|
|
||||||
|
virtual EPtr compile(const ade::Graph &graph, |
||||||
|
const cv::GCompileArgs &args, |
||||||
|
const std::vector<ade::NodeHandle> &nodes, |
||||||
|
const std::vector<cv::gimpl::Data>& ins_data, |
||||||
|
const std::vector<cv::gimpl::Data>& outs_data) const override { |
||||||
|
cv::gimpl::GModel::ConstGraph gm(graph); |
||||||
|
// FIXME: pass streaming/non-streaming option to support non-camera case
|
||||||
|
// NB: how could we have non-OAK source in streaming mode, then OAK backend in
|
||||||
|
// streaming mode but without camera input?
|
||||||
|
if (!gm.metadata().contains<cv::gimpl::Streaming>()) { |
||||||
|
GAPI_Assert(false && "OAK backend only supports Streaming mode for now"); |
||||||
|
} |
||||||
|
return EPtr{new cv::gimpl::GOAKExecutable(graph, args, nodes, ins_data, outs_data)}; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
cv::gapi::GBackend cv::gapi::oak::backend() { |
||||||
|
static cv::gapi::GBackend this_backend(std::make_shared<GOAKBackendImpl>()); |
||||||
|
return this_backend; |
||||||
|
} |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace gimpl { |
||||||
|
namespace oak { |
||||||
|
|
||||||
|
namespace { |
||||||
|
static dai::VideoEncoderProperties::Profile convertEncProfile(cv::gapi::oak::EncoderConfig::Profile pf) { |
||||||
|
switch (pf) { |
||||||
|
case cv::gapi::oak::EncoderConfig::Profile::H264_BASELINE: |
||||||
|
return dai::VideoEncoderProperties::Profile::H264_BASELINE; |
||||||
|
case cv::gapi::oak::EncoderConfig::Profile::H264_HIGH: |
||||||
|
return dai::VideoEncoderProperties::Profile::H264_HIGH; |
||||||
|
case cv::gapi::oak::EncoderConfig::Profile::H264_MAIN: |
||||||
|
return dai::VideoEncoderProperties::Profile::H264_MAIN; |
||||||
|
case cv::gapi::oak::EncoderConfig::Profile::H265_MAIN: |
||||||
|
return dai::VideoEncoderProperties::Profile::H265_MAIN; |
||||||
|
case cv::gapi::oak::EncoderConfig::Profile::MJPEG: |
||||||
|
return dai::VideoEncoderProperties::Profile::MJPEG; |
||||||
|
default: |
||||||
|
// basically unreachable
|
||||||
|
GAPI_Assert("Unsupported encoder profile"); |
||||||
|
return {}; |
||||||
|
} |
||||||
|
} |
||||||
|
} // anonymous namespace
|
||||||
|
|
||||||
|
// Kernels ///////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
template<class Impl, class K> |
||||||
|
class GOAKKernelImpl: public detail::OAKCallHelper<Impl, typename K::InArgs, typename K::OutArgs> |
||||||
|
, public cv::detail::KernelTag { |
||||||
|
using P = detail::OAKCallHelper<Impl, typename K::InArgs, typename K::OutArgs>; |
||||||
|
public: |
||||||
|
using API = K; |
||||||
|
static cv::gapi::GBackend backend() { return cv::gapi::oak::backend(); } |
||||||
|
static GOAKKernel kernel() { return GOAKKernel(&P::construct); } |
||||||
|
}; |
||||||
|
|
||||||
|
#define GAPI_OAK_KERNEL(Name, API) \ |
||||||
|
struct Name: public cv::gimpl::oak::GOAKKernelImpl<Name, API> |
||||||
|
|
||||||
|
namespace { |
||||||
|
GAPI_OAK_KERNEL(GOAKEncFrame, cv::gapi::oak::GEncFrame) { |
||||||
|
static std::shared_ptr<dai::Node> put(const cv::gimpl::detail::OAKKernelParams& params, |
||||||
|
GOAKContext::InputPtr& in, |
||||||
|
const cv::gapi::oak::EncoderConfig& cfg, |
||||||
|
GOAKContext::OutputPtr& out) { |
||||||
|
auto videoEnc = params.pipeline->create<dai::node::VideoEncoder>(); |
||||||
|
|
||||||
|
// FIXME: convert all the parameters to dai
|
||||||
|
videoEnc->setDefaultProfilePreset(cfg.width, cfg.height, |
||||||
|
cfg.frameRate, |
||||||
|
convertEncProfile(cfg.profile)); |
||||||
|
|
||||||
|
in = &(videoEnc->input); |
||||||
|
out = &(videoEnc->bitstream); |
||||||
|
|
||||||
|
return videoEnc; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
GAPI_OAK_KERNEL(GOAKSobelXY, cv::gapi::oak::GSobelXY) { |
||||||
|
static std::shared_ptr<dai::Node> put(const cv::gimpl::detail::OAKKernelParams& params, |
||||||
|
GOAKContext::InputPtr& in, |
||||||
|
const cv::Mat& hk, |
||||||
|
const cv::Mat& vk, |
||||||
|
GOAKContext::OutputPtr& out) { |
||||||
|
auto edgeDetector = params.pipeline->create<dai::node::EdgeDetector>(); |
||||||
|
|
||||||
|
edgeDetector->setMaxOutputFrameSize(params.camera_size.width * params.camera_size.height); |
||||||
|
|
||||||
|
auto xinEdgeCfg = params.pipeline->create<dai::node::XLinkIn>(); |
||||||
|
xinEdgeCfg->setStreamName("sobel_cfg"); |
||||||
|
|
||||||
|
auto mat2vec = [&](cv::Mat m) { |
||||||
|
std::vector<std::vector<int>> v(m.rows); |
||||||
|
for (int i = 0; i < m.rows; ++i) |
||||||
|
{ |
||||||
|
m.row(i).reshape(1,1).copyTo(v[i]); |
||||||
|
} |
||||||
|
return v; |
||||||
|
}; |
||||||
|
|
||||||
|
dai::EdgeDetectorConfig cfg; |
||||||
|
cfg.setSobelFilterKernels(mat2vec(hk), mat2vec(vk)); |
||||||
|
|
||||||
|
xinEdgeCfg->out.link(edgeDetector->inputConfig); |
||||||
|
|
||||||
|
params.m_in_queues.push_back({"sobel_cfg", cfg}); |
||||||
|
|
||||||
|
in = &(edgeDetector->inputImage); |
||||||
|
out = &(edgeDetector->outputImage); |
||||||
|
|
||||||
|
return edgeDetector; |
||||||
|
} |
||||||
|
}; |
||||||
|
} // anonymous namespace
|
||||||
|
} // namespace oak
|
||||||
|
} // namespace gimpl
|
||||||
|
} // namespace cv
|
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace gapi { |
||||||
|
namespace oak { |
||||||
|
|
||||||
|
cv::gapi::GKernelPackage kernels() { |
||||||
|
return cv::gapi::kernels< cv::gimpl::oak::GOAKEncFrame |
||||||
|
, cv::gimpl::oak::GOAKSobelXY |
||||||
|
>(); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace oak
|
||||||
|
} // namespace gapi
|
||||||
|
} // namespace cv
|
||||||
|
|
||||||
|
#else |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace gapi { |
||||||
|
namespace oak { |
||||||
|
|
||||||
|
cv::gapi::GKernelPackage kernels(); |
||||||
|
|
||||||
|
cv::gapi::GKernelPackage kernels() { |
||||||
|
GAPI_Assert(false && "Built without OAK support"); |
||||||
|
return {}; |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace oak
|
||||||
|
} // namespace gapi
|
||||||
|
} // namespace cv
|
||||||
|
|
||||||
|
#endif // HAVE_OAK
|
||||||
@ -0,0 +1,35 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
//
|
||||||
|
// Copyright (C) 2021 Intel Corporation
|
||||||
|
|
||||||
|
#ifndef OPENCV_GAPI_OAK_MEDIA_ADAPTER_HPP |
||||||
|
#define OPENCV_GAPI_OAK_MEDIA_ADAPTER_HPP |
||||||
|
|
||||||
|
#include <memory> |
||||||
|
|
||||||
|
#include <opencv2/gapi/media.hpp> |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace gapi { |
||||||
|
namespace oak { |
||||||
|
|
||||||
|
class GAPI_EXPORTS OAKMediaAdapter final : public cv::MediaFrame::IAdapter { |
||||||
|
public: |
||||||
|
OAKMediaAdapter() = default; |
||||||
|
OAKMediaAdapter(cv::Size sz, cv::MediaFormat fmt, std::vector<uint8_t>&& buffer); |
||||||
|
cv::GFrameDesc meta() const override; |
||||||
|
cv::MediaFrame::View access(cv::MediaFrame::Access) override; |
||||||
|
~OAKMediaAdapter() = default; |
||||||
|
private: |
||||||
|
cv::Size m_sz; |
||||||
|
cv::MediaFormat m_fmt; |
||||||
|
std::vector<uint8_t> m_buffer; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace oak
|
||||||
|
} // namespace gapi
|
||||||
|
} // namespace cv
|
||||||
|
|
||||||
|
#endif // OPENCV_GAPI_OAK_MEDIA_ADAPTER_HPP
|
||||||
@ -0,0 +1,26 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
//
|
||||||
|
// Copyright (C) 2021 Intel Corporation
|
||||||
|
|
||||||
|
#include "../test_precomp.hpp" |
||||||
|
|
||||||
|
#ifdef HAVE_OAK |
||||||
|
|
||||||
|
#include <opencv2/gapi/oak/oak.hpp> |
||||||
|
|
||||||
|
namespace opencv_test |
||||||
|
{ |
||||||
|
|
||||||
|
// FIXME: consider a better solution
|
||||||
|
TEST(OAK, Available) |
||||||
|
{ |
||||||
|
cv::GFrame in; |
||||||
|
auto out = cv::gapi::oak::encode(in, {}); |
||||||
|
auto args = cv::compile_args(cv::gapi::oak::ColorCameraParams{}, cv::gapi::oak::kernels()); |
||||||
|
auto pipeline = cv::GComputation(cv::GIn(in), cv::GOut(out)).compileStreaming(std::move(args)); |
||||||
|
} |
||||||
|
} // opencv_test
|
||||||
|
|
||||||
|
#endif // HAVE_OAK
|
||||||
Loading…
Reference in new issue