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

Feature/video in #3

Merged
itten merged 12 commits from feature/video-in into main 2026-07-05 12:57:40 +03:00
Conversation 0 Commits 12 Files Changed 13
+161 -196
2 changed files with 161 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 96475acf62 - Show all commits
nodes/videoin/main.cpp
+14 -21
View File
@@ -4,7 +4,6 @@ extern "C" {
#include <libavutil/avutil.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>
#include <libavutil/pixdesc.h>
}
#include <string>
@@ -19,8 +18,10 @@ class VideoInNode : public dmf::NodeBase {
void run() override {
const std::string filename = config().value("file", std::string{});
if (filename.empty()) { log("config missing 'file'"); return; }
log("VideoIn Node started with file: %s", filename.c_str());
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>();
@@ -29,32 +30,24 @@ class VideoInNode : public dmf::NodeBase {
const int fps_num = video_flow_info.value("fps_num", video_reader.source_info.fps_num);
const int fps_den = video_flow_info.value("fps_den", video_reader.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 = nullptr;
mxlFlowConfigInfo video_config = {};
std::string video_flow_def = dmf::make_video_flow_def(
video_flow_id,
node_id(),
width,
height,
fps_num,
fps_den
);
mxlFlowConfigInfo video_cfg = {};
bool created = false;
mxlStatus vst = mxlCreateFlowWriter(
instance(),
video_flow_def.c_str(),
"",
&video_writer,
&video_config,
&created
);
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_config.discrete.sliceSizes[0];
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);
mxlRational video_rate = {fps_num, fps_den};
const mxlRational video_rate = {fps_num, fps_den};
uint64_t video_index = mxlGetCurrentIndex(&video_rate);
while (dmf::g_running.load(std::memory_order_relaxed)) {
@@ -62,7 +55,7 @@ class VideoInNode : public dmf::NodeBase {
mxlGrainInfo grain{};
vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &buf);
if (vst == MXL_STATUS_OK) {
if (!video_reader.get_next_frame(buf, video_stride, nullptr)) continue;
if (!video_reader.get_next_frame(buf, video_stride)) break;
grain.flags = 0;
grain.validSlices = grain.totalSlices;
mxlFlowWriterCommitGrain(video_writer, &grain);
@@ -72,11 +65,11 @@ class VideoInNode : public dmf::NodeBase {
video_index++;
}
log("stopped at video_index=%llu", video_index);
mxlReleaseFlowWriter(instance(), video_writer);
}
};
int main() {
VideoInNode node;
return node.execute();
shared/VideoReader.hpp
+35 -63
View File
@@ -4,9 +4,8 @@ extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/avutil.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>
#include <libavutil/pixdesc.h>
#include <libswscale/swscale.h>
}
#include <stdexcept>
@@ -15,6 +14,7 @@ extern "C" {
#include "V210.hpp"
namespace dmf {
class VideoReader {
public:
struct SourceInfo {
@@ -22,28 +22,21 @@ class VideoReader {
int height = 0;
int fps_num = 0;
int fps_den = 0;
int stride = 0;
AVPixelFormat pix_fmt{};
};
struct AudioInfo {
int sample_rate = 0;
int channels = 0;
int samples = 0;
int channel_stride = 0; // floats between channel planes
};
struct SourceInfo source_info{};
SourceInfo source_info{};
bool has_audio = false;
bool have_video = false;
VideoReader(std::string filename) {
if (!open_file(filename)) {
explicit VideoReader(const std::string& filename) {
if (!open_file(filename))
return;
}
if (have_video) {
get_source_info();
allocate_conversion_buffers();
}
}
~VideoReader() {
avcodec_free_context(&codec_context);
@@ -54,9 +47,11 @@ class VideoReader {
av_packet_free(&packet);
}
bool get_next_frame(uint8_t* video_buf, uint32_t mxl_stride, uint8_t* audiobuf) {
// Returns true when a frame was decoded and written into video_buf.
// Returns false when g_running goes false.
bool get_next_frame(uint8_t* video_buf, uint32_t mxl_stride) {
while (dmf::g_running.load(std::memory_order_relaxed)) {
// Try to get a buffered frame from previous packet first
// Drain any frames buffered in the decoder first
if (avcodec_receive_frame(codec_context, frame) == 0) {
sws_scale(
sws_ctx,
@@ -82,13 +77,13 @@ class VideoReader {
av_frame_unref(frame);
return true;
}
// No buffered frame — read next packet
av_packet_unref(packet);
if (av_read_frame(format_context, packet) < 0) {
// EOF — seek back to start and keep going
// EOF — loop back to start
avformat_seek_file(format_context, -1, 0, 0, 0, AVSEEK_FLAG_BACKWARD);
avcodec_flush_buffers(codec_context);
av_packet_unref(packet);
continue;
}
if (packet->stream_index != video_stream_index) continue;
@@ -105,71 +100,56 @@ class VideoReader {
int video_stream_index = -1;
int audio_stream_index = -1;
// conversion data
struct SwsContext *sws_ctx{};
SwsContext* sws_ctx = nullptr;
int p10_linesizes[4] = {0, 0, 0, 0};
uint8_t* p10_data[4] = {nullptr, nullptr, nullptr, nullptr};
bool open_file(std::string filename) {
if (avformat_open_input(&format_context, filename.c_str(), nullptr, nullptr) != 0) {
bool open_file(const std::string& filename) {
if (avformat_open_input(&format_context, filename.c_str(), nullptr, nullptr) != 0)
throw std::runtime_error("Could not open file: " + filename);
return false;
}
// Find stream info
if (avformat_find_stream_info(format_context, nullptr) < 0) {
avformat_close_input(&format_context);
throw std::runtime_error("Could not find stream info");
return false;
}
// Find streams
for (unsigned int i = 0; i < format_context->nb_streams; i++) {
AVMediaType data_type = format_context->streams[i]->codecpar->codec_type;
if (data_type == AVMEDIA_TYPE_VIDEO) {
video_stream_index = i;
for (unsigned int i = 0; i < format_context->nb_streams; ++i) {
const AVMediaType type = format_context->streams[i]->codecpar->codec_type;
if (type == AVMEDIA_TYPE_VIDEO && video_stream_index == -1) {
video_stream_index = static_cast<int>(i);
have_video = true;
} else if (data_type == AVMEDIA_TYPE_AUDIO && audio_stream_index == -1) {
// TODO: show list of available audio tracks and allow user to pick
// or handle multiple audio streams
audio_stream_index = i;
} else if (type == AVMEDIA_TYPE_AUDIO && audio_stream_index == -1) {
audio_stream_index = static_cast<int>(i);
has_audio = true;
}
}
if (video_stream_index == -1 && audio_stream_index == -1) {
avformat_close_input(&format_context);
throw std::runtime_error("No audio/video stream found");
return false;
throw std::runtime_error("No audio/video stream found in: " + filename);
}
return true;
}
void get_source_info() {
// Get codec parameters
AVCodecParameters* codec_params = format_context->streams[video_stream_index]->codecpar;
const AVCodec* codec = avcodec_find_decoder(codec_params->codec_id);
if (!codec) {
avformat_close_input(&format_context);
if (!codec)
throw std::runtime_error("Unsupported codec");
}
// Open codec
codec_context = avcodec_alloc_context3(codec);
avcodec_parameters_to_context(codec_context, codec_params);
if (avcodec_parameters_to_context(codec_context, codec_params) < 0)
throw std::runtime_error("Could not copy codec parameters");
if (avcodec_open2(codec_context, codec, nullptr) < 0) {
avcodec_free_context(&codec_context);
avformat_close_input(&format_context);
throw std::runtime_error("Could not open codec");
}
AVRational fps = codec_context->framerate;
if (fps.num == 0 || fps.den == 0) {
if (fps.num == 0 || fps.den == 0)
fps = format_context->streams[video_stream_index]->avg_frame_rate;
}
source_info.width = codec_context->width;
source_info.height = codec_context->height;
@@ -178,28 +158,20 @@ class VideoReader {
source_info.pix_fmt = codec_context->pix_fmt;
}
void allocate_conversion_buffers()
{
// Create Sws context to convert to planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), LE
void allocate_conversion_buffers() {
sws_ctx = sws_getContext(
source_info.width, source_info.height, source_info.pix_fmt,
source_info.width, source_info.height, AV_PIX_FMT_YUV422P10LE,
0, NULL, NULL, NULL
SWS_BILINEAR, nullptr, nullptr, nullptr
);
if (!sws_ctx) {
if (!sws_ctx)
throw std::runtime_error("Failed to create SwsContext");
return;
}
// Allocate P10 image (freed in destructor via av_freep(&p10_data[0]))
av_image_alloc(
p10_data, p10_linesizes,
if (av_image_alloc(p10_data, p10_linesizes,
source_info.width, source_info.height,
AV_PIX_FMT_YUV422P10LE, 64
);
AV_PIX_FMT_YUV422P10LE, 64) < 0)
throw std::runtime_error("Failed to allocate YUV422P10 buffer");
}
};
}
} // namespace dmf