nodes/videoin/main.cpp

@@ -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 = {};
+        mxlFlowConfigInfo video_cfg   = {};
-        std::string video_flow_def = dmf::make_video_flow_def(
-            video_flow_id,
-            node_id(),
-            width,
-            height,
-            fps_num,
-            fps_den
-        );
         bool created = false;
         mxlStatus vst = mxlCreateFlowWriter(
             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) {
             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

@@ -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 {
+    SourceInfo source_info{};
-            int sample_rate    = 0;
-            int channels       = 0;
-            int samples        = 0;
-            int channel_stride = 0;  // floats between channel planes
-        };
-
-        struct SourceInfo source_info{};
     bool has_audio  = false;
     bool have_video = false;
 
-        VideoReader(std::string filename) {
+    explicit VideoReader(const std::string& filename) {
-            if (!open_file(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
+    SwsContext* sws_ctx         = nullptr;
-        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) {
+    bool open_file(const std::string& filename) {
-            if (avformat_open_input(&format_context, filename.c_str(), nullptr, nullptr) != 0) {
+        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) {
-            for (unsigned int i = 0; i < format_context->nb_streams; i++) {
+            const AVMediaType type = format_context->streams[i]->codecpar->codec_type;
-                AVMediaType data_type = format_context->streams[i]->codecpar->codec_type;
+            if (type == AVMEDIA_TYPE_VIDEO && video_stream_index == -1) {
-                if (data_type == AVMEDIA_TYPE_VIDEO) {
+                video_stream_index = static_cast<int>(i);
-                    video_stream_index = i;
                 have_video = true;
-                } else if (data_type == AVMEDIA_TYPE_AUDIO && audio_stream_index == -1) {
+            } else if (type == AVMEDIA_TYPE_AUDIO && audio_stream_index == -1) {
-                    // TODO: show list of available audio tracks and allow user to pick
+                audio_stream_index = static_cast<int>(i);
-                    // 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");
+            throw std::runtime_error("No audio/video stream found in: " + filename);
-                return false;
         }
 
         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)
-            if (!codec) {
-                avformat_close_input(&format_context);
             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()
+    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
         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]))
+        if (av_image_alloc(p10_data, p10_linesizes,
-            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