itten
123 lines
5.2 KiB
C++
123 lines
5.2 KiB
C++
#include "NodeBase.hpp"
|
|
#include "DeckLinkReceiver.hpp"
|
|
#include "Signal.hpp"
|
|
#include "FlowDef.hpp"
|
|
#include <cstdio>
|
|
#include <vector>
|
|
#include <DeckLinkAPI.h>
|
|
#include <time.h>
|
|
#include <mxl/flow.h>
|
|
#include <mxl/time.h>
|
|
#include <string>
|
|
#include <algorithm>
|
|
|
|
class NodeDeckLinkIn: public dmf::NodeBase {
|
|
void run() override {
|
|
dmf::DeckLinkReceiver decklink_receiver;
|
|
log("Available DeckLink input devices:");
|
|
for (auto device : decklink_receiver.devices_list) {
|
|
log("%i) %s", device.index, device.display_name.c_str());
|
|
}
|
|
int selected_device = 0;
|
|
decklink_receiver.start_capture(selected_device);
|
|
log(
|
|
"DeckLink feed for device '%s':",
|
|
decklink_receiver.devices_list.at(selected_device).display_name.c_str()
|
|
);
|
|
|
|
dmf::SourceInfo video_source_info{};
|
|
if (!decklink_receiver.wait_for_format(5000)) {
|
|
log("Timeout waiting for format detection");
|
|
return;
|
|
}
|
|
video_source_info = decklink_receiver.get_input_callback()->video_info;
|
|
if (video_source_info.width == 0 || video_source_info.fps_num == 0) {
|
|
log("Invalid format detected");
|
|
return;
|
|
}
|
|
|
|
|
|
const auto video_flow_info = config().at("video_flow_id");
|
|
const auto video_flow_id = video_flow_info.at("id").get<std::string>();
|
|
const int width = video_flow_info.value("width", video_source_info.width);
|
|
const int height = video_flow_info.value("height", video_source_info.height);
|
|
const int fps_num = video_flow_info.value("fps_num", video_source_info.fps_num);
|
|
const int fps_den = video_flow_info.value("fps_den", video_source_info.fps_den);
|
|
|
|
log("video flow=%s %dx%d @ %d/%d fps", video_flow_id.c_str(), width, height, fps_num, fps_den);
|
|
|
|
mxlFlowWriter video_writer{};
|
|
mxlFlowConfigInfo video_cfg{};
|
|
bool created = false;
|
|
mxlStatus vst = mxlCreateFlowWriter(
|
|
instance(),
|
|
dmf::make_video_flow_def(video_flow_id, node_id(), width, height, fps_num, fps_den).c_str(),
|
|
"", &video_writer, &video_cfg, &created);
|
|
if (vst != MXL_STATUS_OK) { log("video mxlCreateFlowWriter failed (%s)", dmf::mxl_status_str(vst)); return; }
|
|
|
|
const uint32_t video_stride = video_cfg.discrete.sliceSizes[0];
|
|
log("video stride=%u B/line grain=%u B ring=%u grains",
|
|
video_stride, video_stride * static_cast<uint32_t>(height), video_cfg.discrete.grainCount);
|
|
|
|
const mxlRational video_rate = {fps_num, fps_den};
|
|
uint64_t video_index = mxlGetCurrentIndex(&video_rate);
|
|
log("start video_index=%lu", static_cast<unsigned long>(video_index));
|
|
|
|
auto* cb = decklink_receiver.get_input_callback();
|
|
const uint32_t dst_row = video_stride;
|
|
std::vector<uint8_t> local_frame(dst_row * height, 0);
|
|
|
|
while(dmf::g_running.load(std::memory_order_relaxed)) {
|
|
// Wait for a fresh frame from the callback
|
|
uint32_t src_row;
|
|
int src_w, src_h;
|
|
{
|
|
std::unique_lock<std::mutex> lk(cb->frame_mutex);
|
|
cb->frame_cv.wait(lk, [&] {
|
|
return cb->frame_ready.load(std::memory_order_acquire)
|
|
|| !dmf::g_running.load(std::memory_order_relaxed);
|
|
});
|
|
if (!dmf::g_running.load(std::memory_order_relaxed)) break;
|
|
src_row = cb->frame_row_bytes ? cb->frame_row_bytes : dst_row;
|
|
src_w = cb->frame_width;
|
|
src_h = cb->frame_height;
|
|
// Row-by-row copy with zero padding for stride difference
|
|
const uint8_t* src = cb->frame_buffer.data();
|
|
uint8_t* dst = local_frame.data();
|
|
const uint32_t copy_row = std::min<uint32_t>(src_row, dst_row);
|
|
const int rows = std::min(src_h, height);
|
|
std::memset(local_frame.data(), 0, local_frame.size());
|
|
for (int y = 0; y < rows; ++y) {
|
|
std::memcpy(dst, src, copy_row);
|
|
src += src_row;
|
|
dst += dst_row;
|
|
}
|
|
cb->frame_ready.store(false, std::memory_order_release);
|
|
}
|
|
if (src_w != width || src_h != height) {
|
|
log("frame dim mismatch: src=%dx%d mxl=%dx%d (skipping)", src_w, src_h, width, height);
|
|
continue;
|
|
}
|
|
// MXL write — no lock held, callback can fill next frame in parallel
|
|
mxlGrainInfo grain{};
|
|
uint8_t* video_buf = nullptr;
|
|
vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &video_buf);
|
|
if (vst == MXL_STATUS_OK) {
|
|
std::memcpy(video_buf, local_frame.data(), local_frame.size());
|
|
grain.flags = 0;
|
|
grain.validSlices = grain.totalSlices;
|
|
mxlFlowWriterCommitGrain(video_writer, &grain);
|
|
const uint64_t ns = mxlGetNsUntilIndex(video_index + 1, &video_rate);
|
|
if (ns > 0 && ns < 2'000'000'000ULL) mxlSleepForNs(ns);
|
|
video_index++;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
int main ()
|
|
{
|
|
NodeDeckLinkIn node;
|
|
node.execute();
|
|
return 0;
|
|
} |