From 2faf2f90767a9b7adabb07329d60458175b0bd5e Mon Sep 17 00:00:00 2001 From: itten Date: Tue, 7 Jul 2026 16:46:03 +0300 Subject: [PATCH] decklink + audio --- CMakeLists.txt | 3 +- decklink-ndi.json | 2 +- ndi-decklink.json | 18 +++ ndi-ndi.json | 13 ++ nodes/decklinkout/CMakeLists.txt | 11 ++ nodes/decklinkout/main.cpp | 222 +++++++++++++++++++++++++++ nodes/ndiin/main.cpp | 2 +- shared/DeckLinkSender.hpp | 250 +++++++++++++++++++++++++++++++ shared/NDIReceiver.hpp | 7 +- 9 files changed, 523 insertions(+), 5 deletions(-) create mode 100644 ndi-decklink.json create mode 100644 ndi-ndi.json create mode 100644 nodes/decklinkout/CMakeLists.txt create mode 100644 nodes/decklinkout/main.cpp create mode 100644 shared/DeckLinkSender.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index f93aadc..cfa16f2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -102,14 +102,15 @@ add_subdirectory(nodes/fakesink) # ── NDI nodes ──────────────────────────────────────────────────────────────── set(NDI_SDK_DIR "" CACHE PATH "Path to NDI SDK root") if(NDI_SDK_DIR) - add_subdirectory(nodes/ndiout) add_subdirectory(nodes/ndiin) + add_subdirectory(nodes/ndiout) endif() # ── DeckLink nodes ──────────────────────────────────────────────────────────────── set(DECKLINK_SDK_DIR "" CACHE PATH "Path to DeckLink SDK root") if(DECKLINK_SDK_DIR) add_subdirectory(nodes/decklinkin) + add_subdirectory(nodes/decklinkout) endif() add_subdirectory(nodes/videoin) diff --git a/decklink-ndi.json b/decklink-ndi.json index ad7c844..d55cc2c 100644 --- a/decklink-ndi.json +++ b/decklink-ndi.json @@ -11,7 +11,7 @@ }, { "from": "decklinkin", "from_port": "audio_flow_id", - "to": "ndiout", "to_port": "audio_flow_id", + "to": "ndiout", "to_port": "audio_flow_id", "format": { "kind": "audio", "sample_rate": 48000, "channels": 2, "bit_depth": 32 } } ] diff --git a/ndi-decklink.json b/ndi-decklink.json new file mode 100644 index 0000000..7ce118e --- /dev/null +++ b/ndi-decklink.json @@ -0,0 +1,18 @@ +{ + "nodes": [ + { "id": "ndiin", "type": "ndiin", "params": {} }, + { "id": "decklinkout", "type": "decklinkout", "params": { "device_index": 0 } } + ], + "edges": [ + { + "from": "ndiin", "from_port": "video_flow_id", + "to": "decklinkout", "to_port": "video_flow_id", + "format": { "kind": "video", "width": 1920, "height": 1080, "fps_num": 25, "fps_den": 1 } + }, + { + "from": "ndiin", "from_port": "audio_flow_id", + "to": "decklinkout", "to_port": "audio_flow_id", + "format": { "kind": "audio", "sample_rate": 48000, "channels": 2, "bit_depth": 32 } + } + ] +} diff --git a/ndi-ndi.json b/ndi-ndi.json new file mode 100644 index 0000000..037af62 --- /dev/null +++ b/ndi-ndi.json @@ -0,0 +1,13 @@ +{ + "nodes": [ + { "id": "ndiin", "type": "ndiin", "params": {} }, + { "id": "ndiout", "type": "ndiout", "params": { "device_index": 0 } } + ], + "edges": [ + { + "from": "ndiin", "from_port": "video_flow_id", + "to": "ndiout", "to_port": "video_flow_id", + "format": { "kind": "video", "width": 1920, "height": 1080, "fps_num": 25, "fps_den": 1 } + } + ] +} diff --git a/nodes/decklinkout/CMakeLists.txt b/nodes/decklinkout/CMakeLists.txt new file mode 100644 index 0000000..f447411 --- /dev/null +++ b/nodes/decklinkout/CMakeLists.txt @@ -0,0 +1,11 @@ +set(DECKLINK_INCLUDE "${DECKLINK_SDK_DIR}/include" + CACHE PATH "Path to DeckLink API headers") + +add_executable(dmf-node-decklinkout + main.cpp + "${DECKLINK_INCLUDE}/DeckLinkAPIDispatch.cpp" +) +target_compile_features(dmf-node-decklinkout PRIVATE cxx_std_20) +target_include_directories(dmf-node-decklinkout PRIVATE "${DECKLINK_INCLUDE}") +target_link_libraries(dmf-node-decklinkout PRIVATE dmf-shared ${CMAKE_DL_LIBS}) +install(TARGETS dmf-node-decklinkout RUNTIME DESTINATION bin) diff --git a/nodes/decklinkout/main.cpp b/nodes/decklinkout/main.cpp new file mode 100644 index 0000000..7c17eef --- /dev/null +++ b/nodes/decklinkout/main.cpp @@ -0,0 +1,222 @@ +#include +#include "DeckLinkSender.hpp" + +#include +#include +#include +#include +#include +#include "Signal.hpp" +#include "NodeBase.hpp" + +namespace dmf { +class DeckLinkOutNode : public dmf::NodeBase { + void run() override { + // --- common params (optional) --- + const uint32_t device_index = config().value("device_index", 0u); + // --- video flow (optional) --- + bool has_video = config().contains("video_flow_id"); + + int width = 1920; + int height = 1080; + int fps_num = 25; + int fps_den = 1; + std::string flow_id; + mxlFlowReader video_reader{}; + uint32_t video_stride = 0; + + if (has_video) { + const auto flow_info = config().at("video_flow_id"); + flow_id = flow_info.at("id").get(); + width = flow_info.value("width", 1920); + height = flow_info.value("height", 1080); + fps_num = flow_info.value("fps_num", 25); + fps_den = flow_info.value("fps_den", 1); + + log("video flow=%s %dx%d @ %d/%d fps", flow_id.c_str(), width, height, fps_num, fps_den); + + log("waiting for flow to become active..."); + bool active = false; + while (!active && dmf::g_running.load(std::memory_order_relaxed)) { + mxlIsFlowActive(instance(), flow_id.c_str(), &active); + if (!active) mxlSleepForNs(100'000'000); + } + if (!dmf::g_running) return; + log("flow active — starting read"); + + mxlFlowConfigInfo video_cfg{}; + mxlStatus vst = mxlCreateFlowReader(instance(), flow_id.c_str(), "", &video_reader); + if (vst != MXL_STATUS_OK) { log("video mxlCreateFlowReader failed (%s)", dmf::mxl_status_str(vst)); return; } + mxlFlowReaderGetConfigInfo(video_reader, &video_cfg); + video_stride = video_cfg.discrete.sliceSizes[0]; + } + + // --- audio flow (optional) --- + mxlFlowReader audio_reader{}; + mxlFlowConfigInfo audio_cfg{}; + int sample_rate = 0; + int channels = 0; + int samples_per_frame = 0; + bool has_audio = config().contains("audio_flow_id"); + std::string audio_flow_id; + + if (has_audio) { + const auto audio_flow_info = config().at("audio_flow_id"); + audio_flow_id = audio_flow_info.at("id").get(); + sample_rate = audio_flow_info.value("sample_rate", 48000); + channels = audio_flow_info.value("channels", 2); + samples_per_frame = sample_rate * fps_den / fps_num; + + log("audio flow=%s %d Hz %dch %d samples/frame", + audio_flow_id.c_str(), sample_rate, channels, samples_per_frame); + + mxlStatus ast = mxlCreateFlowReader(instance(), audio_flow_id.c_str(), "", &audio_reader); + if (ast != MXL_STATUS_OK) { + log("audio mxlCreateFlowReader failed (%s) — continuing without audio", dmf::mxl_status_str(ast)); + has_audio = false; + } else { + mxlFlowReaderGetConfigInfo(audio_reader, &audio_cfg); + log("audio channels=%u buffer=%u samples", + audio_cfg.continuous.channelCount, audio_cfg.continuous.bufferLength); + } + } + + if (!has_video && !has_audio) { log("no flows configured — exiting"); return; } + + dmf::DeckLinkSender sender; + try { + log("Available DeckLink output devices:\n"); + for (const auto& d : sender.devices) { + log(" %u) %s", d.index, d.name.c_str()); + } + sender.start_output(device_index, width, height, fps_num, fps_den, channels); + } catch (const std::runtime_error& e) { + log("DeckLink init error: %s", e.what()); + return; + } + + // --- main loop --- + uint64_t video_index = 0; + uint64_t audio_index = 0; + uint64_t frame_count = 0; + uint64_t invalid_count = 0; + uint64_t late_count = 0; + auto wall_start = std::chrono::steady_clock::now(); + auto last_log_time = wall_start; + + if (has_video) { + const mxlRational video_rate = {fps_num, fps_den}; + video_index = mxlGetCurrentIndex(&video_rate); + } + if (has_audio) { + const mxlRational audio_rate = {sample_rate, 1}; + audio_index = mxlGetCurrentIndex(&audio_rate); + } + + while (dmf::g_running.load(std::memory_order_relaxed)) { + // --- audio: non-blocking, one chunk per video frame (or free-running) --- + bool audio_advanced = false; + + if (has_audio) { + mxlWrappedMultiBufferSlice audio_slices{}; + mxlStatus ast = mxlFlowReaderGetSamplesNonBlocking( + audio_reader, audio_index, samples_per_frame, &audio_slices); + if (ast == MXL_STATUS_OK) { + // Extract planar float32 samples from MXL ring buffer + // (per-channel: ring buffer can wrap, so 2 fragments) + std::vector audio_planar( + static_cast(channels) * samples_per_frame); + const size_t frag0 = audio_slices.base.fragments[0].size / sizeof(float); + const size_t frag1 = audio_slices.base.fragments[1].size / sizeof(float); + for (int c = 0; c < channels; ++c) { + float* dst = audio_planar.data() + c * samples_per_frame; + const auto* src0 = reinterpret_cast( + static_cast(audio_slices.base.fragments[0].pointer) + + static_cast(c) * audio_slices.stride); + std::memcpy(dst, src0, frag0 * sizeof(float)); + if (frag1 > 0) { + const auto* src1 = reinterpret_cast( + static_cast(audio_slices.base.fragments[1].pointer) + + static_cast(c) * audio_slices.stride); + std::memcpy(dst + frag0, src1, frag1 * sizeof(float)); + } + } + sender.submit_audio(audio_planar.data(), samples_per_frame); + audio_index += samples_per_frame; + audio_advanced = true; + } else if (ast == MXL_ERR_OUT_OF_RANGE_TOO_LATE) { + mxlFlowRuntimeInfo ari{}; + mxlFlowReaderGetRuntimeInfo(audio_reader, &ari); + audio_index = ari.headIndex; + } else if (ast == MXL_ERR_FLOW_INVALID) { + log("audio flow invalidated — reconnecting..."); + mxlReleaseFlowReader(instance(), audio_reader); + audio_reader = nullptr; + mxlSleepForNs(100'000'000); + if (mxlCreateFlowReader(instance(), audio_flow_id.c_str(), "", &audio_reader) == MXL_STATUS_OK) { + log("audio flow reconnected"); + const mxlRational r = {sample_rate, 1}; + audio_index = mxlGetCurrentIndex(&r); + } + } + } + + // --- video --- + if (has_video) { + mxlGrainInfo video_grain{}; + uint8_t* video_buf = nullptr; + mxlStatus vst = mxlFlowReaderGetGrainNonBlocking( + video_reader, video_index, &video_grain, &video_buf); + + if (vst == MXL_STATUS_OK) { + if (video_grain.flags & MXL_GRAIN_FLAG_INVALID) invalid_count++; + sender.submit_frame(video_buf, video_stride); + frame_count++; + video_index++; + } else if (vst == MXL_ERR_OUT_OF_RANGE_TOO_EARLY) { + mxlSleepForNs(1'000'000); + } else if (vst == MXL_ERR_OUT_OF_RANGE_TOO_LATE) { + late_count++; + mxlFlowRuntimeInfo ri{}; + mxlFlowReaderGetRuntimeInfo(video_reader, &ri); + video_index = ri.headIndex; + } else if (vst == MXL_ERR_FLOW_INVALID) { + log("video flow invalidated — reconnecting..."); + mxlReleaseFlowReader(instance(), video_reader); + video_reader = nullptr; + mxlSleepForNs(100'000'000); + if (mxlCreateFlowReader(instance(), flow_id.c_str(), "", &video_reader) == MXL_STATUS_OK) { + log("video flow reconnected"); + const mxlRational r = {fps_num, fps_den}; + video_index = mxlGetCurrentIndex(&r); + } + } else { + log("unexpected video status (%s) on index=%llu", dmf::mxl_status_str(vst), video_index); + break; + } + + auto now = std::chrono::steady_clock::now(); + if (std::chrono::duration(now - last_log_time).count() >= 1.0) { + const double elapsed = std::chrono::duration(now - wall_start).count(); + log("frames=%llu invalid=%llu late=%llu avg=%.2f fps", + frame_count, invalid_count, late_count, + static_cast(frame_count) / elapsed); + last_log_time = now; + } + } else if (!audio_advanced) { + // audio-only and nothing was ready — avoid busy spin + mxlSleepForNs(1'000'000); + } + } + if (has_video && video_reader) mxlReleaseFlowReader(instance(), video_reader); + if (has_audio && audio_reader) mxlReleaseFlowReader(instance(), audio_reader); + } +}; +} + +int main() +{ + dmf::DeckLinkOutNode node; + node.execute(); + return 0; +} \ No newline at end of file diff --git a/nodes/ndiin/main.cpp b/nodes/ndiin/main.cpp index 07abb34..68a94b8 100644 --- a/nodes/ndiin/main.cpp +++ b/nodes/ndiin/main.cpp @@ -98,7 +98,7 @@ class NDIInNode : public dmf::NodeBase { while (dmf::g_running.load(std::memory_order_relaxed)) { dmf::NDIReceiver::FrameKind kind; try { - kind = ndi.capture(latest_video.data(), video_stride, audio_buf, audio_info); + kind = ndi.capture(latest_video.data(), video_stride, audio_buf, audio_info, has_audio); } catch (const std::runtime_error& e) { log("NDI error: %s — stopping", e.what()); break; diff --git a/shared/DeckLinkSender.hpp b/shared/DeckLinkSender.hpp new file mode 100644 index 0000000..036e6cf --- /dev/null +++ b/shared/DeckLinkSender.hpp @@ -0,0 +1,250 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include "V210.hpp" + +namespace dmf { + +class DeckLinkSender { +public: + struct VideoInfo { + int width = 0; + int height = 0; + int fps_num = 0; + int fps_den = 0; + }; + + struct AudioInfo { + int sample_rate = 48000; + int channels = 0; + }; + + struct DeviceInfo { + uint32_t index; + std::string name; + }; + + std::vector devices; + VideoInfo video_info{}; + AudioInfo audio_info{}; + bool has_audio = false; + int64_t frame_count = 0; + std::atomic audio_stream_time{0}; + + DeckLinkSender() { enumerate_devices(); } + ~DeckLinkSender() { + if (decklink_output) { + decklink_output->StopScheduledPlayback(frame_count * video_info.fps_den, + nullptr, + video_info.fps_num); + decklink_output->DisableVideoOutput(); + if (has_audio) decklink_output->DisableAudioOutput();; + decklink_output->SetScheduledFrameCompletionCallback(nullptr); + decklink_output->Release(); + for (auto* vf : frame_pool) vf->Release(); + frame_pool.clear(); + } + delete output_callback; + for (auto* d : raw_devices) d->Release(); + if (selected_device) selected_device->Release(); + } + + // channels > 0 enables audio output at 48 kHz / 32-bit int. + void start_output(uint32_t device_index, int width, int height, int fps_num, int fps_den, int channels = 0) { + if (device_index >= raw_devices.size()) + throw std::runtime_error("Device index out of range"); + + video_info.width = width; + video_info.height = height; + video_info.fps_num = fps_num; + video_info.fps_den = fps_den; + + BMDDisplayMode bm_display_mode = bmdModeHD1080p25; //need to create a func for detection + + selected_device = raw_devices[device_index]; + selected_device->AddRef(); + + HRESULT r = selected_device->QueryInterface(IID_IDeckLinkOutput, (void**)&decklink_output); + if (r != S_OK) throw std::runtime_error("Could not obtain IDeckLinkOutput"); + + output_callback = new OutputCallback(*this); + r = decklink_output->SetScheduledFrameCompletionCallback(output_callback); + if (r != S_OK) throw std::runtime_error("Could not set output callback"); + + r = decklink_output->EnableVideoOutput(bmdModeHD1080p25, bmdVideoOutputFlagDefault); + if (r != S_OK) throw std::runtime_error("Could not enable video output"); + + if (channels > 0) { + r = decklink_output->EnableAudioOutput(bmdAudioSampleRate48kHz, + bmdAudioSampleType32bitInteger, + static_cast(channels), + bmdAudioOutputStreamTimestamped); + if (r != S_OK) throw std::runtime_error("Could not enable audio output"); + // r = decklink_output->SetAudioCallback + has_audio = true; + audio_info.channels = channels; + } + + bool is_supported = false; + BMDDisplayMode actual_mode; + r = decklink_output->DoesSupportVideoMode( + bmdVideoConnectionUnspecified, // TODO: create selection between sdi, hdmi, etc. + bmdModeHD1080p25, + bmdFormat10BitYUV, + bmdNoVideoOutputConversion, + bmdSupportedVideoModeDefault, + &actual_mode, + &is_supported + ); + if (r != S_OK) throw std::runtime_error("Selected mode is not supported for bmdFormat10BitYUV"); + + int32_t row_bytes; + r = decklink_output->RowBytesForPixelFormat(bmdFormat10BitYUV, width, &row_bytes); + if (r != S_OK) throw std::runtime_error("Could not get row bytes for display mode"); + + // prefill frame pool + const int64_t duration = fps_den; + const int64_t timescale = fps_num; + const size_t preroll_pool_size = 3; // min=3, cause 1 displaying, 1 queued, 1 writable + for (size_t i = 0; i < preroll_pool_size; ++i) { + IDeckLinkMutableVideoFrame* vf = nullptr; + r = decklink_output->CreateVideoFrame(width, height, row_bytes, bmdFormat10BitYUV, bmdFrameFlagDefault, &vf); + if (r != S_OK) throw std::runtime_error("Could not create a video frame"); + IDeckLinkVideoBuffer* buf = nullptr; + vf->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&buf); + buf->StartAccess(bmdBufferAccessWrite); + void* ptr = nullptr; + buf->GetBytes(&ptr); + if (ptr) dmf::v210::fill_black(static_cast(ptr), width, height, row_bytes); + buf->EndAccess(bmdBufferAccessWrite); + buf->Release(); + + decklink_output->ScheduleVideoFrame(vf, i * duration, duration, timescale); + frame_pool.push_back(vf); + } + output_callback->next_time.store(preroll_pool_size * duration); + + // start playback + r = decklink_output->StartScheduledPlayback(0, timescale, 1.0); + if (r != S_OK) throw std::runtime_error("Could not start streams"); + } + + void submit_frame(const uint8_t* src, uint32_t stride) { + // Grab a free frame from the pool (round-robin) + IDeckLinkMutableVideoFrame* vf = frame_pool[frame_count % frame_pool.size()]; + frame_count++; + + IDeckLinkVideoBuffer* buf = nullptr; + if (vf->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&buf) != S_OK) return; + buf->StartAccess(bmdBufferAccessWrite); + void* ptr = nullptr; + buf->GetBytes(&ptr); + if (ptr) { + // Row-by-row copy with stride adaptation + const uint32_t dst_stride = vf->GetRowBytes(); + const uint32_t copy_row = std::min(stride, dst_stride); + for (int y = 0; y < video_info.height; ++y) { + std::memcpy(static_cast(ptr) + y * dst_stride, + src + y * stride, copy_row); + } + } + buf->EndAccess(bmdBufferAccessWrite); + buf->Release(); + + // Schedule for display + BMDTimeValue display_time = output_callback->next_time.fetch_add(video_info.fps_den); + decklink_output->ScheduleVideoFrame(vf, display_time, + video_info.fps_den, video_info.fps_num); + + } + + void submit_audio(const float* planar, int samples) { + if (!has_audio || samples <= 0) return; + // float32 planar → interleaved int32 (4-byte PCM) scaled to int32 range + const int channels = audio_info.channels; + std::vector interleaved( + static_cast(channels) * static_cast(samples)); + for (int s = 0; s < samples; ++s) { + for (int c = 0; c < channels; ++c) { + float v = planar[c * samples + s]; // planar: channel-major + // clamp to safe range and scale + if (v > 1.0f) v = 1.0f; + else if (v < -1.0f) v = -1.0f; + interleaved[static_cast(s) * channels + c] = + static_cast(v * 2147483647.0f); + } + } + const int64_t stream_time = audio_stream_time.fetch_add(samples); + uint32_t written = 0; + decklink_output->ScheduleAudioSamples( + interleaved.data(), static_cast(samples), + stream_time, audio_info.sample_rate, &written); + (void)written; + } + + +private: + class OutputCallback: public IDeckLinkVideoOutputCallback { + public: + explicit OutputCallback(DeckLinkSender& owner) : owner(owner) {} + + HRESULT ScheduledFrameCompleted (IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult result) override { + // Frame is done displaying — return it to the pool. + // submit_frame will overwrite and reschedule it with fresh MXL data. + return S_OK; + } + + HRESULT ScheduledPlaybackHasStopped (void) override { + return S_OK; + } + + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID, LPVOID*) override { return E_NOINTERFACE; } + ULONG STDMETHODCALLTYPE AddRef() override { return ++ref_count; } + ULONG STDMETHODCALLTYPE Release() override { return --ref_count; } + + std::atomic next_time{0}; + + private: + DeckLinkSender& owner; + std::atomic next_frame_idx{0}; + std::atomic ref_count{1}; + }; + + // DeckLink SDK objects + std::vector raw_devices; + IDeckLink* selected_device = nullptr; + IDeckLinkOutput* decklink_output = nullptr; + OutputCallback* output_callback = nullptr; + + std::vector frame_pool; + + void enumerate_devices() { + IDeckLinkIterator* it = CreateDeckLinkIteratorInstance(); + if (!it) throw std::runtime_error("DeckLink drivers not installed"); + + IDeckLink* device = nullptr; + uint32_t index = 0; + while (it->Next(&device) == S_OK) { + IDeckLinkInput* inp = nullptr; + if (device->QueryInterface(IID_IDeckLinkOutput, (void**)&inp) == S_OK) { + inp->Release(); + const char* name = nullptr; + device->GetDisplayName(&name); + devices.push_back({index, name ? name : "?"}); + raw_devices.push_back(device); + index++; + } else { + device->Release(); + } + } + it->Release(); + if (raw_devices.empty()) + throw std::runtime_error("No DeckLink output devices found"); + } +}; +} \ No newline at end of file diff --git a/shared/NDIReceiver.hpp b/shared/NDIReceiver.hpp index 848f247..9f7b8ba 100644 --- a/shared/NDIReceiver.hpp +++ b/shared/NDIReceiver.hpp @@ -126,10 +126,13 @@ public: // Returns FrameKind::None on timeout or non-A/V frames. // Throws on source lost or video format change. FrameKind capture(uint8_t* frame_buffer, uint32_t frame_stride, - std::vector& audio_out, AudioInfo& audio_info) { + std::vector& audio_out, AudioInfo& audio_info, + bool want_audio = false) { NDIlib_video_frame_v2_t video_frame{}; NDIlib_audio_frame_v3_t audio_frame{}; - auto type = NDIlib_recv_capture_v3(recv_, &video_frame, &audio_frame, nullptr, 5); + auto type = NDIlib_recv_capture_v3(recv_, &video_frame, + want_audio ? &audio_frame : nullptr, + nullptr, 5); if (type == NDIlib_frame_type_error) throw std::runtime_error("NDI source lost");