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

Some fixes. For a now we fully support only .ts, due to huge problem with h264/hevc audio bursts

Browse Source
This commit is contained in:
itten
2026-07-05 12:39:06 +03:00
parent b2534efb0f
commit 166efc3c59
3 changed files with 106 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
nodes/videoin/main.cpp
+70 -44
View File
@@ -21,31 +21,40 @@ class VideoInNode : public dmf::NodeBase {
log("file: %s", filename.c_str());
dmf::VideoReader video_reader(filename);
if (!video_reader.have_video) { log("no video stream found"); 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_reader.video_info.width);
const int height = video_flow_info.value("height", video_reader.video_info.height);
const int fps_num = video_flow_info.value("fps_num", video_reader.video_info.fps_num);
const int fps_den = video_flow_info.value("fps_den", video_reader.video_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 = 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;
if (!video_reader.have_video && !video_reader.has_audio) {
log("no video or audio stream found"); return;
}
const bool has_video = config().contains("video_flow_id") && video_reader.have_video;
mxlFlowWriter video_writer = nullptr;
mxlFlowConfigInfo video_cfg{};
uint32_t video_stride = 0;
int width = 0, height = 0, fps_num = 25, fps_den = 1;
std::string video_flow_id;
if (has_video) {
const auto video_flow_info = config().at("video_flow_id");
video_flow_id = video_flow_info.at("id").get<std::string>();
width = video_flow_info.value("width", video_reader.video_info.width);
height = video_flow_info.value("height", video_reader.video_info.height);
fps_num = video_flow_info.value("fps_num", video_reader.video_info.fps_num);
fps_den = video_flow_info.value("fps_den", video_reader.video_info.fps_den);
log("video flow=%s %dx%d @ %d/%d fps", video_flow_id.c_str(), width, height, fps_num, fps_den);
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;
}
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 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);
mxlFlowWriter audio_writer{};
mxlFlowConfigInfo audio_cfg{};
@@ -53,7 +62,7 @@ class VideoInNode : public dmf::NodeBase {
int channels = video_reader.audio_info.channels;
int bit_depth = 32;
bool has_audio = config().contains("audio_flow_id") && video_reader.has_audio;
int max_audio_samples = 0;
if (has_audio) {
const auto audio_flow_info = config().at("audio_flow_id");
@@ -61,6 +70,7 @@ class VideoInNode : public dmf::NodeBase {
log("audio flow=%s %d Hz %dch %d-bit", audio_flow_id.c_str(), sample_rate, channels, bit_depth);
bool created = false;
mxlStatus ast = mxlCreateFlowWriter(
instance(),
dmf::make_audio_flow_def(audio_flow_id, node_id(), sample_rate, channels, bit_depth,
@@ -81,55 +91,71 @@ class VideoInNode : public dmf::NodeBase {
std::vector<uint8_t> audio_temp(max_audio_samples * channels * sizeof(float));
const mxlRational video_rate = {fps_num, fps_den};
const mxlRational audio_rate = {sample_rate, 1};
uint64_t audio_index = 0;
if (has_audio) {
const mxlRational audio_rate = {sample_rate, 1};
audio_index = mxlGetCurrentIndex(&audio_rate);
}
uint64_t video_index = mxlGetCurrentIndex(&video_rate);
uint64_t video_index = has_video ? mxlGetCurrentIndex(&video_rate) : 0;
while (dmf::g_running.load(std::memory_order_relaxed)) {
uint8_t* video_buf = nullptr;
mxlGrainInfo grain{};
vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &video_buf);
uint8_t* video_buf = nullptr;
mxlGrainInfo grain{};
mxlStatus vst = MXL_ERR_UNSUPPORTED_OPERATION;
if (has_video) {
vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &video_buf);
}
int out_samples_written = 0;
dmf::VideoReader::FrameKind frame_kind = video_reader.get_next_frame(
video_buf,
has_video ? video_buf : nullptr,
video_stride,
has_audio ? audio_temp.data() : nullptr,
max_audio_samples,
out_samples_written
);
if (frame_kind == dmf::VideoReader::FrameKind::None) break;
if (frame_kind == dmf::VideoReader::FrameKind::Video) {
if (vst == MXL_STATUS_OK) {
if (has_video && vst == MXL_STATUS_OK) {
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++;
if (has_video) {
const uint64_t ns = mxlGetNsUntilIndex(video_index + 1, &video_rate);
if (ns > 0 && ns < 2'000'000'000ULL) mxlSleepForNs(ns);
video_index++;
}
} else if (frame_kind == dmf::VideoReader::FrameKind::Audio) {
mxlFlowWriterCancelGrain(video_writer);
if (has_video && vst == MXL_STATUS_OK) mxlFlowWriterCancelGrain(video_writer);
// Wait for audio clock to catch up — prevents TOO_EARLY and sample loss
while (dmf::g_running.load(std::memory_order_relaxed)) {
const uint64_t audio_now = mxlGetCurrentIndex(&audio_rate);
if (audio_index + static_cast<uint64_t>(out_samples_written) <= audio_now) break;
const uint64_t ns = mxlGetNsUntilIndex(audio_index + out_samples_written, &audio_rate);
if (ns > 0 && ns < 2'000'000'000ULL) mxlSleepForNs(ns);
else break;
}
if (!dmf::g_running.load(std::memory_order_relaxed)) break;
mxlMutableWrappedMultiBufferSlice slice{};
mxlStatus ast = mxlFlowWriterOpenSamples(audio_writer, audio_index, out_samples_written, &slice);
if (ast != MXL_STATUS_OK) {
log("audio OpenSamples failed (%s) index=%llu", dmf::mxl_status_str(ast), audio_index);
log("audio OpenSamples failed (%s) index=%llu — skipping", dmf::mxl_status_str(ast), audio_index);
audio_index += out_samples_written; // advance even on failure — keeps alignment
continue;
}
// copy per channel from audio_temp into slice
for (int ch = 0; ch < channels; ch++) {
uint8_t* dst0 = static_cast<uint8_t*>(slice.base.fragments[0].pointer)
uint8_t* dst0 = static_cast<uint8_t*>(slice.base.fragments[0].pointer)
+ ch * slice.stride;
uint8_t* src = audio_temp.data() + ch * max_audio_samples * sizeof(float);
size_t frag0_bytes = slice.base.fragments[0].size;
size_t total_bytes = out_samples_written * sizeof(float);
if (total_bytes <= frag0_bytes) {
std::memcpy(dst0, src, total_bytes);
} else {
@@ -145,9 +171,9 @@ class VideoInNode : public dmf::NodeBase {
}
}
log("stopped at video_index=%llu", video_index);
mxlReleaseFlowWriter(instance(), video_writer);
mxlReleaseFlowWriter(instance(), audio_writer);
log("stopped at video_index=%llu", static_cast<unsigned long long>(video_index));
if (has_video) mxlReleaseFlowWriter(instance(), video_writer);
if (has_audio) mxlReleaseFlowWriter(instance(), audio_writer);
}
};