itten/dmf-studio-rnd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

audio support

Browse Source
This commit is contained in:
JohannesItten
2026-07-06 01:51:47 +03:00
parent 7847a8b70d
commit 94da6f3283
3 changed files with 182 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files
nodes/decklinkin/main.cpp
+111 -29
View File
@@ -8,14 +8,17 @@
class DeckLinkInNode : public dmf::NodeBase {
void run() override {
const uint32_t device_index = config().value("device_index", 0u);
const uint32_t device_index = config().value("device_index", 0u);
const bool want_audio = config().contains("audio_flow_id");
const int channels = want_audio
? config().at("audio_flow_id").value("channels", 2) : 0;
dmf::DeckLinkReceiver receiver;
try {
log("Available DeckLink devices:");
for (const auto& d : receiver.devices)
log(" %u) %s", d.index, d.name.c_str());
receiver.start_capture(device_index);
receiver.start_capture(device_index, channels);
log("Capturing from: %s", receiver.devices[device_index].name.c_str());
} catch (const std::runtime_error& e) {
log("DeckLink init error: %s", e.what());
@@ -30,13 +33,13 @@ class DeckLinkInNode : public dmf::NodeBase {
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);
// --- Video writer ---
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;
@@ -50,36 +53,115 @@ class DeckLinkInNode : public dmf::NodeBase {
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);
// --- Audio writer (optional) ---
mxlFlowWriter audio_writer = nullptr;
int max_audio_samples = 0;
const bool has_audio = want_audio && receiver.has_audio;
std::vector<uint8_t> frame_buf(static_cast<size_t>(video_stride) * static_cast<size_t>(height));
if (has_audio) {
const auto audio_flow_info = config().at("audio_flow_id");
const auto audio_flow_id = audio_flow_info.at("id").get<std::string>();
const int sample_rate = receiver.audio_info.sample_rate;
const int bit_depth = 32;
log("audio flow=%s %d Hz %dch %d-bit",
audio_flow_id.c_str(), sample_rate, channels, bit_depth);
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);
mxlFlowConfigInfo audio_cfg{};
mxlStatus ast = mxlCreateFlowWriter(
instance(),
dmf::make_audio_flow_def(audio_flow_id, node_id(), sample_rate, channels, bit_depth,
fps_num, fps_den).c_str(),
"", &audio_writer, &audio_cfg, &created);
if (ast != MXL_STATUS_OK) {
log("audio mxlCreateFlowWriter failed (%s) — continuing without audio",
dmf::mxl_status_str(ast));
} else {
log("audio channels=%u buffer=%u samples",
audio_cfg.continuous.channelCount, audio_cfg.continuous.bufferLength);
size_t max_write = 0;
mxlFlowWriterGetMaxWriteLengthSamples(audio_writer, &max_write);
max_audio_samples = static_cast<int>(max_write);
}
}
log("stopped at video_index=%llu", video_index);
// --- Buffers ---
std::vector<uint8_t> frame_buf(static_cast<size_t>(video_stride) * static_cast<size_t>(height));
// Planar float32: channel c at audio_buf[c * max_audio_samples]
std::vector<float> audio_buf(static_cast<size_t>(max_audio_samples) * static_cast<size_t>(channels));
// --- Clock ---
const mxlRational video_rate = {fps_num, fps_den};
const mxlRational audio_rate = {receiver.audio_info.sample_rate, 1};
uint64_t video_index = mxlGetCurrentIndex(&video_rate);
uint64_t audio_index = has_audio ? mxlGetCurrentIndex(&audio_rate) : 0;
log("start video_index=%llu", static_cast<unsigned long long>(video_index));
// --- Capture loop ---
while (dmf::g_running.load(std::memory_order_relaxed)) {
int samples_written = 0;
// DeckLink delivers one video frame + accompanying audio per callback.
if (!receiver.wait_for_frame(
frame_buf.data(), video_stride, width, height,
(has_audio && audio_writer) ? audio_buf.data() : nullptr,
max_audio_samples,
(has_audio && audio_writer) ? &samples_written : nullptr)) break;
// Video grain
mxlGrainInfo grain{};
uint8_t* video_buf_ptr = nullptr;
vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &video_buf_ptr);
if (vst == MXL_STATUS_OK) {
std::memcpy(video_buf_ptr, frame_buf.data(), frame_buf.size());
grain.flags = 0;
grain.validSlices = grain.totalSlices;
mxlFlowWriterCommitGrain(video_writer, &grain);
}
// Audio samples (same fragment-wrap pattern as videoin)
if (has_audio && audio_writer && samples_written > 0) {
mxlMutableWrappedMultiBufferSlice slice{};
mxlStatus ast = mxlFlowWriterOpenSamples(
audio_writer, audio_index, static_cast<size_t>(samples_written), &slice);
if (ast == MXL_STATUS_OK) {
for (int ch = 0; ch < channels; ++ch) {
const uint8_t* src = reinterpret_cast<const uint8_t*>(
audio_buf.data() + ch * max_audio_samples);
uint8_t* dst0 = static_cast<uint8_t*>(
slice.base.fragments[0].pointer) + ch * slice.stride;
const size_t frag0_bytes = slice.base.fragments[0].size;
const size_t total_bytes = static_cast<size_t>(samples_written) * sizeof(float);
if (total_bytes <= frag0_bytes) {
std::memcpy(dst0, src, total_bytes);
} else {
std::memcpy(dst0, src, frag0_bytes);
uint8_t* dst1 = static_cast<uint8_t*>(
slice.base.fragments[1].pointer) + ch * slice.stride;
std::memcpy(dst1, src + frag0_bytes, total_bytes - frag0_bytes);
}
}
mxlFlowWriterCommitSamples(audio_writer);
} else {
log("audio OpenSamples failed (%s) index=%llu — skipping",
dmf::mxl_status_str(ast), static_cast<unsigned long long>(audio_index));
}
audio_index += static_cast<uint64_t>(samples_written);
}
// Pace video to the MXL clock
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", static_cast<unsigned long long>(video_index));
mxlReleaseFlowWriter(instance(), video_writer);
if (audio_writer) mxlReleaseFlowWriter(instance(), audio_writer);
}
};