]> git.sesse.net Git - casparcg/blobdiff - core/producer/layer.cpp
git-svn-id: https://casparcg.svn.sourceforge.net/svnroot/casparcg/server/branches...
[casparcg] / core / producer / layer.cpp
index 21db1d15316afa1f8d47b02eac34e8690531a75d..227c0293daa3db445b85552ec2420ec49cc3697e 100644 (file)
 #include "../stdafx.h"\r
 \r
 #include "layer.h"\r
+#include "frame_producer.h"\r
 \r
-#include "../mixer/frame/draw_frame.h"\r
-#include "../mixer/image/image_mixer.h"\r
-#include "../mixer/audio/audio_mixer.h"\r
-#include "../producer/frame_producer.h"\r
-\r
-#include "../video_format.h"\r
-\r
-#include <common/utility/assert.h>\r
+#include "../producer/frame/basic_frame.h"\r
+#include "../producer/frame/audio_transform.h"\r
 \r
 namespace caspar { namespace core {\r
-\r
+       \r
 struct layer::implementation : boost::noncopyable\r
-{                                      \r
+{                              \r
+       int                                                     index_; \r
        safe_ptr<frame_producer>        foreground_;\r
        safe_ptr<frame_producer>        background_;\r
-       safe_ptr<draw_frame>            last_frame_;\r
-       const int                                       index_;\r
+       safe_ptr<basic_frame>           last_frame_;\r
        bool                                            is_paused_;\r
-\r
-       double                                          video_gain_;\r
-       double                                          video_opacity_;\r
-       \r
-       double                                          audio_gain_;\r
-\r
 public:\r
        implementation(int index) \r
-               : foreground_(frame_producer::empty())\r
+               : index_(index)\r
+               , foreground_(frame_producer::empty())\r
                , background_(frame_producer::empty())\r
-               , last_frame_(draw_frame::empty())\r
-               , index_(index) \r
-               , is_paused_(false)\r
-               , video_gain_(1.0)\r
-               , video_opacity_(1.0)\r
-               , audio_gain_(1.0){}\r
+               , last_frame_(basic_frame::empty())\r
+               , is_paused_(false){}\r
        \r
-       void load(const safe_ptr<frame_producer>& frame_producer, bool play_on_load)\r
-       {                       \r
-               background_ = frame_producer;\r
-               CASPAR_LOG(info) << print() << " " << frame_producer->print() << " => background";\r
-               if(play_on_load)\r
-                       play();                 \r
+       void pause() \r
+       {\r
+               is_paused_ = true; \r
        }\r
 \r
-       void preview(const safe_ptr<frame_producer>& frame_producer)\r
+       void resume()\r
        {\r
-               stop();\r
-               load(frame_producer, false);            \r
-               try\r
-               {\r
-                       last_frame_ = frame_producer->receive();\r
-               }\r
-               catch(...)\r
+               if(is_paused_)\r
+                       CASPAR_LOG(info) << foreground_->print() << L" Resumed.";\r
+               is_paused_ = false;\r
+       }\r
+\r
+       void load(const safe_ptr<frame_producer>& producer, bool play_on_load, bool preview)\r
+       {               \r
+               background_ = producer;\r
+\r
+               if(play_on_load)\r
+                       play();         \r
+               else if(preview)\r
                {\r
-                       CASPAR_LOG_CURRENT_EXCEPTION();\r
-                       clear();\r
+                       play();\r
+                       receive();\r
+                       pause();\r
                }\r
+\r
+               CASPAR_LOG(info) << producer->print() << L" Loaded.";\r
        }\r
        \r
        void play()\r
        {                       \r
-               if(is_paused_)                  \r
-                       is_paused_ = false;\r
-               else\r
+               if(background_ != frame_producer::empty())\r
                {\r
                        background_->set_leading_producer(foreground_);\r
                        foreground_ = background_;\r
                        background_ = frame_producer::empty();\r
-                       CASPAR_LOG(info) << print() << L" background => foreground";\r
+                       CASPAR_LOG(info) << foreground_->print() << L" Active.";\r
                }\r
+               resume();\r
        }\r
-\r
-       void pause()\r
-       {\r
-               is_paused_ = true;\r
-       }\r
-\r
+       \r
        void stop()\r
        {\r
                pause();\r
-               last_frame_ = draw_frame::empty();\r
+               last_frame_ = basic_frame::empty();\r
                foreground_ = frame_producer::empty();\r
-               CASPAR_LOG(warning) << print() << L" empty => foreground";\r
-       }\r
-\r
-       void clear()\r
-       {\r
-               stop();\r
-               background_ = frame_producer::empty();\r
-               CASPAR_LOG(warning) << print() << L" empty => background";\r
        }\r
-       \r
-       safe_ptr<draw_frame> receive()\r
+               \r
+       safe_ptr<basic_frame> receive()\r
        {               \r
-               if(is_paused_)\r
-                       return last_frame_;\r
-\r
-               try\r
-               {\r
-                       last_frame_ = foreground_->receive(); \r
-                       if(last_frame_ == draw_frame::eof())\r
-                       {\r
-                               CASPAR_ASSERT(foreground_ != frame_producer::empty());\r
-\r
-                               auto following = foreground_->get_following_producer();\r
-                               following->set_leading_producer(foreground_);\r
-                               foreground_ = following;\r
-\r
-                               CASPAR_LOG(info) << print() << L" [EOF] " << foreground_->print() << " => foreground";\r
-\r
-                               last_frame_ = receive();\r
-                       }\r
-                       else\r
-                       {\r
-                               last_frame_ = draw_frame(last_frame_);\r
-                               last_frame_->get_image_transform().gain *= video_gain_;\r
-                               last_frame_->get_image_transform().alpha *= video_opacity_;\r
-                               last_frame_->get_audio_transform().gain *= audio_gain_;\r
-                       }\r
-               }\r
-               catch(...)\r
-               {\r
-                       CASPAR_LOG_CURRENT_EXCEPTION();\r
-                       stop();\r
-               }\r
+               if(is_paused_)          \r
+                       last_frame_->get_audio_transform().set_has_audio(false);                \r
+               else\r
+                       last_frame_ = receive_and_follow(foreground_);\r
 \r
                return last_frame_;\r
        }\r
-\r
-       std::wstring print() const { return L"layer[" + boost::lexical_cast<std::wstring>(index_) + L"]"; }\r
+               \r
+       std::wstring print() const\r
+       {\r
+               return L"layer[" + boost::lexical_cast<std::wstring>(index_) + L"]";\r
+       }\r
 };\r
 \r
 layer::layer(int index) : impl_(new implementation(index)){}\r
-layer::layer(layer&& other) : impl_(std::move(other.impl_)){other.impl_ = nullptr;}\r
+layer::layer(layer&& other) : impl_(std::move(other.impl_)){}\r
 layer& layer::operator=(layer&& other)\r
 {\r
-       impl_ = std::move(other.impl_); \r
-       other.impl_ = nullptr;\r
+       impl_ = std::move(other.impl_);\r
        return *this;\r
 }\r
-void layer::load(const safe_ptr<frame_producer>& frame_producer, bool play_on_load){return impl_->load(frame_producer, play_on_load);} \r
-void layer::preview(const safe_ptr<frame_producer>& frame_producer){return impl_->preview(frame_producer);}    \r
-void layer::set_video_gain(double value) { impl_->video_gain_ = value;}\r
-void layer::set_video_opacity(double value) { impl_->video_opacity_ = value;}\r
-void layer::set_audio_gain(double value) { impl_->audio_gain_ = value;}\r
+void layer::swap(layer& other)\r
+{      \r
+       impl_->foreground_.swap(other.impl_->foreground_);\r
+       impl_->background_.swap(other.impl_->background_);\r
+       impl_->last_frame_.swap(other.impl_->last_frame_);\r
+       std::swap(impl_->is_paused_     , other.impl_->is_paused_ );\r
+}\r
+void layer::load(const safe_ptr<frame_producer>& frame_producer, bool play_on_load, bool preview){return impl_->load(frame_producer, play_on_load, preview);}  \r
 void layer::play(){impl_->play();}\r
 void layer::pause(){impl_->pause();}\r
 void layer::stop(){impl_->stop();}\r
-void layer::clear(){impl_->clear();}\r
-safe_ptr<draw_frame> layer::receive() {return impl_->receive();}\r
+safe_ptr<basic_frame> layer::receive() {return impl_->receive();}\r
 safe_ptr<frame_producer> layer::foreground() const { return impl_->foreground_;}\r
 safe_ptr<frame_producer> layer::background() const { return impl_->background_;}\r
+std::wstring layer::print() const { return impl_->print();}\r
 }}
\ No newline at end of file