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
+21 -28
View File
@@ -4,7 +4,6 @@ extern "C" {
#include <libavutil/avutil.h> #include <libavutil/avutil.h>
#include <libswscale/swscale.h> #include <libswscale/swscale.h>
#include <libavutil/imgutils.h> #include <libavutil/imgutils.h>
#include <libavutil/pixdesc.h>
} }
#include <string> #include <string>
@@ -19,51 +18,45 @@ class VideoInNode : public dmf::NodeBase {
void run() override { void run() override {
const std::string filename = config().value("file", std::string{}); const std::string filename = config().value("file", std::string{});
if (filename.empty()) { log("config missing 'file'"); return; } 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); 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_info = config().at("video_flow_id");
const auto video_flow_id = video_flow_info.at("id").get<std::string>(); const auto video_flow_id = video_flow_info.at("id").get<std::string>();
const int width = video_flow_info.value("width", video_reader.source_info.width); const int width = video_flow_info.value("width", video_reader.source_info.width);
const int height = video_flow_info.value("height", video_reader.source_info.height); const int height = video_flow_info.value("height", video_reader.source_info.height);
const int fps_num = video_flow_info.value("fps_num", video_reader.source_info.fps_num); 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); const int fps_den = video_flow_info.value("fps_den", video_reader.source_info.fps_den);
mxlFlowWriter video_writer = nullptr; log("video flow=%s %dx%d @ %d/%d fps", video_flow_id.c_str(), width, height, fps_num, fps_den);
mxlFlowConfigInfo video_config = {};
std::string video_flow_def = dmf::make_video_flow_def( mxlFlowWriter video_writer = nullptr;
video_flow_id, mxlFlowConfigInfo video_cfg = {};
node_id(),
width,
height,
fps_num,
fps_den
);
bool created = false; bool created = false;
mxlStatus vst = mxlCreateFlowWriter( mxlStatus vst = mxlCreateFlowWriter(
instance(), instance(),
video_flow_def.c_str(), dmf::make_video_flow_def(video_flow_id, node_id(), width, height, fps_num, fps_den).c_str(),
"", "", &video_writer, &video_cfg, &created);
&video_writer,
&video_config,
&created
);
if (vst != MXL_STATUS_OK) { if (vst != MXL_STATUS_OK) {
log("mxlCreateFlowWriter failed (%s)", dmf::mxl_status_str(vst)); log("mxlCreateFlowWriter failed (%s)", dmf::mxl_status_str(vst));
return; 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); uint64_t video_index = mxlGetCurrentIndex(&video_rate);
while (dmf::g_running.load(std::memory_order_relaxed)) { while (dmf::g_running.load(std::memory_order_relaxed)) {
uint8_t* buf = nullptr; uint8_t* buf = nullptr;
mxlGrainInfo grain{}; mxlGrainInfo grain{};
vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &buf); vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &buf);
if (vst == MXL_STATUS_OK) { 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.flags = 0;
grain.validSlices = grain.totalSlices; grain.validSlices = grain.totalSlices;
mxlFlowWriterCommitGrain(video_writer, &grain); mxlFlowWriterCommitGrain(video_writer, &grain);
} }
@@ -72,11 +65,11 @@ class VideoInNode : public dmf::NodeBase {
video_index++; video_index++;
} }
log("stopped at video_index=%llu", video_index);
mxlReleaseFlowWriter(instance(), video_writer); mxlReleaseFlowWriter(instance(), video_writer);
} }
}; };
int main() { int main() {
VideoInNode node; VideoInNode node;
return node.execute(); return node.execute();
shared/VideoReader.hpp
+138 -166
View File
@@ -4,9 +4,8 @@ extern "C" {
#include <libavformat/avformat.h> #include <libavformat/avformat.h>
#include <libavcodec/avcodec.h> #include <libavcodec/avcodec.h>
#include <libavutil/avutil.h> #include <libavutil/avutil.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h> #include <libavutil/imgutils.h>
#include <libavutil/pixdesc.h> #include <libswscale/swscale.h>
} }
#include <stdexcept> #include <stdexcept>
@@ -15,191 +14,164 @@ extern "C" {
#include "V210.hpp" #include "V210.hpp"
namespace dmf { namespace dmf {
class VideoReader { class VideoReader {
public: public:
struct SourceInfo { struct SourceInfo {
int width = 0; int width = 0;
int height = 0; int height = 0;
int fps_num = 0; int fps_num = 0;
int fps_den = 0; int fps_den = 0;
int stride = 0; AVPixelFormat pix_fmt{};
AVPixelFormat pix_fmt{}; };
};
struct AudioInfo { SourceInfo source_info{};
int sample_rate = 0; bool has_audio = false;
int channels = 0; bool have_video = false;
int samples = 0;
int channel_stride = 0; // floats between channel planes
};
struct SourceInfo source_info{}; explicit VideoReader(const std::string& filename) {
bool has_audio = false; if (!open_file(filename))
bool have_video = false; return;
if (have_video) {
VideoReader(std::string filename) {
if (!open_file(filename)) {
return;
}
get_source_info(); get_source_info();
allocate_conversion_buffers(); allocate_conversion_buffers();
} }
}
~VideoReader() { ~VideoReader() {
avcodec_free_context(&codec_context); avcodec_free_context(&codec_context);
avformat_close_input(&format_context);
sws_freeContext(sws_ctx);
av_freep(&p10_data[0]);
av_frame_free(&frame);
av_packet_free(&packet);
}
// 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)) {
// Drain any frames buffered in the decoder first
if (avcodec_receive_frame(codec_context, frame) == 0) {
sws_scale(
sws_ctx,
frame->data,
frame->linesize,
0,
source_info.height,
p10_data,
p10_linesizes
);
dmf::v210::YUV422P10toV210(
reinterpret_cast<uint16_t*>(p10_data[0]),
reinterpret_cast<uint16_t*>(p10_data[1]),
reinterpret_cast<uint16_t*>(p10_data[2]),
video_buf,
source_info.width,
source_info.height,
p10_linesizes[0],
p10_linesizes[1],
p10_linesizes[2],
mxl_stride
);
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 — loop back to start
avformat_seek_file(format_context, -1, 0, 0, 0, AVSEEK_FLAG_BACKWARD);
avcodec_flush_buffers(codec_context);
continue;
}
if (packet->stream_index != video_stream_index) continue;
avcodec_send_packet(codec_context, packet);
}
return false;
}
private:
AVFormatContext* format_context = nullptr;
AVCodecContext* codec_context = nullptr;
AVPacket* packet = av_packet_alloc();
AVFrame* frame = av_frame_alloc();
int video_stream_index = -1;
int audio_stream_index = -1;
SwsContext* sws_ctx = nullptr;
int p10_linesizes[4] = {0, 0, 0, 0};
uint8_t* p10_data[4] = {nullptr, nullptr, nullptr, nullptr};
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);
if (avformat_find_stream_info(format_context, nullptr) < 0) {
avformat_close_input(&format_context); avformat_close_input(&format_context);
sws_freeContext(sws_ctx); throw std::runtime_error("Could not find stream info");
av_freep(&p10_data[0]);
av_frame_free(&frame);
av_packet_free(&packet);
} }
bool get_next_frame(uint8_t* video_buf, uint32_t mxl_stride, uint8_t* audiobuf) { for (unsigned int i = 0; i < format_context->nb_streams; ++i) {
while (dmf::g_running.load(std::memory_order_relaxed)) { const AVMediaType type = format_context->streams[i]->codecpar->codec_type;
// Try to get a buffered frame from previous packet first if (type == AVMEDIA_TYPE_VIDEO && video_stream_index == -1) {
if (avcodec_receive_frame(codec_context, frame) == 0) { video_stream_index = static_cast<int>(i);
sws_scale( have_video = true;
sws_ctx, } else if (type == AVMEDIA_TYPE_AUDIO && audio_stream_index == -1) {
frame->data, audio_stream_index = static_cast<int>(i);
frame->linesize, has_audio = true;
0,
source_info.height,
p10_data,
p10_linesizes
);
dmf::v210::YUV422P10toV210(
reinterpret_cast<uint16_t*>(p10_data[0]),
reinterpret_cast<uint16_t*>(p10_data[1]),
reinterpret_cast<uint16_t*>(p10_data[2]),
video_buf,
source_info.width,
source_info.height,
p10_linesizes[0],
p10_linesizes[1],
p10_linesizes[2],
mxl_stride
);
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
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;
avcodec_send_packet(codec_context, packet);
} }
return false;
} }
private: if (video_stream_index == -1 && audio_stream_index == -1) {
AVFormatContext* format_context = nullptr; avformat_close_input(&format_context);
AVCodecContext* codec_context = nullptr; throw std::runtime_error("No audio/video stream found in: " + filename);
AVPacket* packet = av_packet_alloc();
AVFrame* frame = av_frame_alloc();
int video_stream_index = -1;
int audio_stream_index = -1;
// conversion data
struct SwsContext *sws_ctx{};
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) {
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;
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;
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;
}
return true;
} }
void get_source_info() { return true;
// 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) { void get_source_info() {
avformat_close_input(&format_context); AVCodecParameters* codec_params = format_context->streams[video_stream_index]->codecpar;
throw std::runtime_error("Unsupported codec"); const AVCodec* codec = avcodec_find_decoder(codec_params->codec_id);
} if (!codec)
throw std::runtime_error("Unsupported codec");
// Open codec codec_context = avcodec_alloc_context3(codec);
codec_context = avcodec_alloc_context3(codec); if (avcodec_parameters_to_context(codec_context, codec_params) < 0)
avcodec_parameters_to_context(codec_context, codec_params); throw std::runtime_error("Could not copy codec parameters");
if (avcodec_open2(codec_context, codec, nullptr) < 0) { if (avcodec_open2(codec_context, codec, nullptr) < 0) {
avcodec_free_context(&codec_context); avcodec_free_context(&codec_context);
avformat_close_input(&format_context); throw std::runtime_error("Could not open codec");
throw std::runtime_error("Could not open codec");
}
AVRational fps = codec_context->framerate;
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;
source_info.fps_num = fps.num;
source_info.fps_den = fps.den;
source_info.pix_fmt = codec_context->pix_fmt;
} }
void allocate_conversion_buffers() AVRational fps = codec_context->framerate;
{ if (fps.num == 0 || fps.den == 0)
// Create Sws context to convert to planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), LE fps = format_context->streams[video_stream_index]->avg_frame_rate;
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
);
if (!sws_ctx) { source_info.width = codec_context->width;
throw std::runtime_error("Failed to create SwsContext"); source_info.height = codec_context->height;
return; source_info.fps_num = fps.num;
} source_info.fps_den = fps.den;
source_info.pix_fmt = codec_context->pix_fmt;
}
// Allocate P10 image (freed in destructor via av_freep(&p10_data[0])) void allocate_conversion_buffers() {
av_image_alloc( sws_ctx = sws_getContext(
p10_data, p10_linesizes, source_info.width, source_info.height, source_info.pix_fmt,
source_info.width, source_info.height, AV_PIX_FMT_YUV422P10LE,
SWS_BILINEAR, nullptr, nullptr, nullptr
);
if (!sws_ctx)
throw std::runtime_error("Failed to create SwsContext");
if (av_image_alloc(p10_data, p10_linesizes,
source_info.width, source_info.height, 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