git.sesse.net Git - casparcg/blob - core/producer/layer.cpp

   1 #include "../stdafx.h"\r
   2 \r
   3 #include "layer.h"\r
   4 #include "frame_producer.h"\r
   5 \r
   6 #include "../producer/frame/basic_frame.h"\r
   7 #include "../producer/frame/audio_transform.h"\r
   8 \r
   9 namespace caspar { namespace core {\r
  10         \r
  11 struct layer::implementation : boost::noncopyable\r
  12 {                               \r
  13         int                                                     index_; \r
  14         safe_ptr<frame_producer>        foreground_;\r
  15         safe_ptr<frame_producer>        background_;\r
  16         safe_ptr<basic_frame>           last_frame_;\r
  17         bool                                            is_paused_;\r
  18 public:\r
  19         implementation(int index) \r
  20                 : index_(index)\r
  21                 , foreground_(frame_producer::empty())\r
  22                 , background_(frame_producer::empty())\r
  23                 , last_frame_(basic_frame::empty())\r
  24                 , is_paused_(false){}\r
  25         \r
  26         void pause() \r
  27         {\r
  28                 is_paused_ = true; \r
  29         }\r
  30 \r
  31         void resume()\r
  32         {\r
  33                 if(is_paused_)\r
  34                         CASPAR_LOG(info) << foreground_->print() << L" Resumed.";\r
  35                 is_paused_ = false;\r
  36         }\r
  37 \r
  38         void load(const safe_ptr<frame_producer>& producer, bool play_on_load, bool preview)\r
  39         {               \r
  40                 background_ = producer;\r
  41 \r
  42                 if(play_on_load)\r
  43                         play();         \r
  44                 else if(preview)\r
  45                 {\r
  46                         play();\r
  47                         receive();\r
  48                         pause();\r
  49                 }\r
  50 \r
  51                 CASPAR_LOG(info) << producer->print() << L" Loaded.";\r
  52         }\r
  53         \r
  54         void play()\r
  55         {                       \r
  56                 if(background_ != frame_producer::empty())\r
  57                 {\r
  58                         background_->set_leading_producer(foreground_);\r
  59                         foreground_ = background_;\r
  60                         background_ = frame_producer::empty();\r
  61                         CASPAR_LOG(info) << foreground_->print() << L" Active.";\r
  62                 }\r
  63                 resume();\r
  64         }\r
  65         \r
  66         void stop()\r
  67         {\r
  68                 pause();\r
  69                 last_frame_ = basic_frame::empty();\r
  70                 foreground_ = frame_producer::empty();\r
  71         }\r
  72                 \r
  73         safe_ptr<basic_frame> receive()\r
  74         {               \r
  75                 if(is_paused_)          \r
  76                         last_frame_->get_audio_transform().set_has_audio(false);                \r
  77                 else\r
  78                         last_frame_ = receive_and_follow(foreground_);\r
  79 \r
  80                 return last_frame_;\r
  81         }\r
  82                 \r
  83         std::wstring print() const\r
  84         {\r
  85                 return L"layer[" + boost::lexical_cast<std::wstring>(index_) + L"]";\r
  86         }\r
  87 };\r
  88 \r
  89 layer::layer(int index) : impl_(new implementation(index)){}\r
  90 layer::layer(layer&& other) : impl_(std::move(other.impl_)){}\r
  91 layer& layer::operator=(layer&& other)\r
  92 {\r
  93         impl_ = std::move(other.impl_);\r
  94         return *this;\r
  95 }\r
  96 void layer::swap(layer& other)\r
  97 {       \r
  98         impl_->foreground_.swap(other.impl_->foreground_);\r
  99         impl_->background_.swap(other.impl_->background_);\r
 100         impl_->last_frame_.swap(other.impl_->last_frame_);\r
 101         std::swap(impl_->is_paused_     , other.impl_->is_paused_ );\r
 102 }\r
 103 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
 104 void layer::play(){impl_->play();}\r
 105 void layer::pause(){impl_->pause();}\r
 106 void layer::stop(){impl_->stop();}\r
 107 safe_ptr<basic_frame> layer::receive() {return impl_->receive();}\r
 108 safe_ptr<frame_producer> layer::foreground() const { return impl_->foreground_;}\r
 109 safe_ptr<frame_producer> layer::background() const { return impl_->background_;}\r
 110 std::wstring layer::print() const { return impl_->print();}\r
 111 }}