JohannesItten
640271384e
DeckLinkReceiver:
- Make InputCallback a private nested class — no longer exposed publicly
- DeckLinkReceiver owns all shared state (mutex, CVs, frame buffer)
- Replace get_input_callback() with clean wait_for_frame() API
- Fix device list leak: enumerate_devices stores raw IDeckLink* in
raw_devices; destructor releases all of them + selected_device's AddRef
- Remove dead members: device_config, device_status, deckLink_notification
- Remove dead SourceInfo::stride field; rename SourceInfo → VideoInfo
- Remove dead video_source_info public member
- Remove printf; use no logging in receiver (caller logs)
- Remove commented-out notification code
- Fix dead return false after throw in enumerate_devices
- Fix dead null check after new InputCallback
- Replace IDeckLinkVideoBuffer QueryInterface with simpler GetBytes()
- Replace plain bool frame_ready/format_detected with consistent usage
under mutex (no longer mixing atomic + CV pattern)
- Call StopStreams/DisableVideoInput in destructor
- Consistent snake_case naming throughout
decklinkin main.cpp:
- Rename NodeDeckLinkIn → DeckLinkInNode
- Get device_index from config().value("device_index", 0u)
- Remove unused includes: <time.h>, <algorithm>, <cstdio>, <DeckLinkAPI.h>
- Use clean receiver.wait_for_frame() instead of reaching into callback
- Use mxlGetCurrentIndex resync after sleep (consistent with other nodes)
- Fix return node.execute() (was node.execute(); return 0)
- Fix main() spacing
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
86 lines
3.5 KiB
C++
86 lines
3.5 KiB
C++
#include <cstring>
|
|
#include <vector>
|
|
#include <mxl/flow.h>
|
|
#include <mxl/time.h>
|
|
#include "NodeBase.hpp"
|
|
#include "FlowDef.hpp"
|
|
#include "DeckLinkReceiver.hpp"
|
|
|
|
class DeckLinkInNode : public dmf::NodeBase {
|
|
void run() override {
|
|
dmf::DeckLinkReceiver receiver;
|
|
|
|
log("Available DeckLink devices:");
|
|
for (const auto& d : receiver.devices)
|
|
log(" %u) %s", d.index, d.name.c_str());
|
|
|
|
const uint32_t device_index = config().value("device_index", 0u);
|
|
receiver.start_capture(device_index);
|
|
log("Capturing from: %s", receiver.devices[device_index].name.c_str());
|
|
|
|
if (!receiver.wait_for_format(5000)) {
|
|
log("Timeout waiting for format detection");
|
|
return;
|
|
}
|
|
const auto& vi = receiver.video_info;
|
|
if (vi.width == 0 || vi.fps_num == 0) { log("Invalid format detected"); return; }
|
|
log("Detected: %dx%d @ %d/%d fps", vi.width, vi.height, vi.fps_num, vi.fps_den);
|
|
|
|
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", vi.width);
|
|
const int height = video_flow_info.value("height", vi.height);
|
|
const int fps_num = video_flow_info.value("fps_num", vi.fps_num);
|
|
const int fps_den = video_flow_info.value("fps_den", vi.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 = nullptr;
|
|
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("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=%llu", video_index);
|
|
|
|
std::vector<uint8_t> frame_buf(static_cast<size_t>(video_stride) * static_cast<size_t>(height), 0);
|
|
|
|
while (dmf::g_running.load(std::memory_order_relaxed)) {
|
|
if (!receiver.wait_for_frame(frame_buf.data(), video_stride, width, height)) break;
|
|
|
|
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, frame_buf.data(), frame_buf.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 = mxlGetCurrentIndex(&video_rate);
|
|
}
|
|
}
|
|
|
|
log("stopped at video_index=%llu", video_index);
|
|
mxlReleaseFlowWriter(instance(), video_writer);
|
|
}
|
|
};
|
|
|
|
int main() {
|
|
DeckLinkInNode node;
|
|
return node.execute();
|
|
}
|