2.0. core: Simplified layer and frame_producer logic.

[casparcg] / modules / ffmpeg / producer / ffmpeg_producer.cpp

diff --git a/modules/ffmpeg/producer/ffmpeg_producer.cpp b/modules/ffmpeg/producer/ffmpeg_producer.cpp
index 0b6128b117705c7971a6d1af83a9b208e945fe8e..3db902f5fe64b8e93776972bebce1a95e3de7e65 100644 (file)
--- a/modules/ffmpeg/producer/ffmpeg_producer.cpp
+++ b/modules/ffmpeg/producer/ffmpeg_producer.cpp
@@ -46,7 +46,7 @@
 #include <tbb/parallel_invoke.h>\r
 \r
 namespace caspar {\r
-                       \r
+                               \r
 struct ffmpeg_producer : public core::frame_producer\r
 {\r
        const std::wstring                                                              filename_;\r
@@ -62,34 +62,41 @@ struct ffmpeg_producer : public core::frame_producer
        input                                                                                   input_; \r
        video_decoder                                                                   video_decoder_;\r
        audio_decoder                                                                   audio_decoder_; \r
+       double                                                                                  fps_;\r
        frame_muxer                                                                             muxer_;\r
 \r
-       int                                                                                             late_frames_;\r
        const int                                                                               start_;\r
        const bool                                                                              loop_;\r
+       const size_t                                                                    length_;\r
 \r
        safe_ptr<core::basic_frame>                                             last_frame_;\r
-       bool                                                                                    eof_;\r
+\r
+       const size_t                                                                    width_;\r
+       const size_t                                                                    height_;\r
+       bool                                                                                    is_progressive_;\r
        \r
 public:\r
-       explicit ffmpeg_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::wstring& filename, const std::wstring& filter, bool loop, int start, int length) \r
+       explicit ffmpeg_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::wstring& filename, const std::wstring& filter, bool loop, int start, size_t length) \r
                : filename_(filename)\r
-               , graph_(diagnostics::create_graph(narrow(print())))\r
+               , graph_(diagnostics::create_graph([this]{return print();}))\r
                , frame_factory_(frame_factory)         \r
                , format_desc_(frame_factory->get_video_format_desc())\r
                , input_(graph_, filename_, loop, start, length)\r
                , video_decoder_(input_.context(), frame_factory, filter)\r
                , audio_decoder_(input_.context(), frame_factory->get_video_format_desc())\r
-               , muxer_(video_decoder_.fps(), frame_factory)\r
-               , late_frames_(0)\r
+               , fps_(video_decoder_.fps())\r
+               , muxer_(fps_, frame_factory)\r
                , start_(start)\r
                , loop_(loop)\r
+               , length_(length)\r
                , last_frame_(core::basic_frame::empty())\r
-               , eof_(false)\r
+               , width_(video_decoder_.width())\r
+               , height_(video_decoder_.height())\r
+               , is_progressive_(true)\r
        {\r
                graph_->add_guide("frame-time", 0.5);\r
-               graph_->set_color("frame-time", diagnostics::color(1.0f, 0.0f, 0.0f));\r
-               graph_->set_color("underflow", diagnostics::color(0.6f, 0.3f, 0.9f));           \r
+               graph_->set_color("frame-time", diagnostics::color(0.1f, 1.0f, 0.1f));\r
+               graph_->set_color("underflow", diagnostics::color(0.6f, 0.3f, 0.9f));   \r
                \r
                for(int n = 0; n < 32 && muxer_.empty(); ++n)\r
                        decode_frame(0);\r
@@ -97,9 +104,6 @@ public:
                        \r
        virtual safe_ptr<core::basic_frame> receive(int hints)\r
        {\r
-               if(eof_)\r
-                       return last_frame();\r
-\r
                auto frame = core::basic_frame::late();\r
                \r
                frame_timer_.restart();\r
@@ -114,15 +118,9 @@ public:
                else\r
                {\r
                        if(input_.eof())\r
-                       {\r
-                               eof_ = true;\r
-                               return last_frame();\r
-                       }\r
-                       else\r
-                       {\r
+                               return core::basic_frame::eof();\r
+                       else                    \r
                                graph_->add_tag("underflow");   \r
-                               ++late_frames_;         \r
-                       }\r
                }\r
                \r
                return frame;\r
@@ -152,8 +150,11 @@ public:
                                return;\r
 \r
                        auto video_frames = video_decoder_.poll();\r
-                       BOOST_FOREACH(auto& video, video_frames)                \r
+                       BOOST_FOREACH(auto& video, video_frames)        \r
+                       {\r
+                               is_progressive_ = video ? video->interlaced_frame == 0 : is_progressive_;\r
                                muxer_.push(video, hints);      \r
+                       }\r
                },\r
                [&]\r
                {\r
@@ -181,19 +182,22 @@ public:
                        int64_t video_nb_frames = video_decoder_.nb_frames();\r
                        int64_t audio_nb_frames = audio_decoder_.nb_frames();\r
 \r
-                       nb_frames = std::max(nb_frames, std::max(video_nb_frames, audio_nb_frames));\r
+                       nb_frames = std::min(static_cast<int64_t>(length_), std::max(nb_frames, std::max(video_nb_frames, audio_nb_frames)));\r
                }\r
 \r
                nb_frames = muxer_.calc_nb_frames(nb_frames);\r
 \r
                // TODO: Might need to scale nb_frames av frame_muxer transformations.\r
 \r
-               return nb_frames + late_frames_ - start_;\r
+               return nb_frames - start_;\r
        }\r
                                \r
        virtual std::wstring print() const\r
        {\r
-               return L"ffmpeg[" + boost::filesystem::wpath(filename_).filename() + L"]";\r
+               return L"ffmpeg[" + boost::filesystem::wpath(filename_).filename() + L"|" \r
+                                                 + boost::lexical_cast<std::wstring>(width_) + L"x" + boost::lexical_cast<std::wstring>(height_)\r
+                                                 + (is_progressive_ ? L"p" : L"i")  + boost::lexical_cast<std::wstring>(fps_)\r
+                                                 + L"]";\r
        }\r
 };\r
 \r