git.sesse.net Git - casparcg/blob - core/channel.cpp

   1 #include "StdAfx.h"\r
   2 \r
   3 #include "channel.h"\r
   4 \r
   5 #include <boost/noncopyable.hpp>\r
   6 \r
   7 #include <memory>\r
   8 \r
   9 namespace caspar { namespace core {\r
  10 \r
  11 struct channel::implementation : boost::noncopyable\r
  12 {\r
  13 public:\r
  14         implementation(const frame_producer_device_ptr& producer_device, const frame_processor_device_ptr& processor_device, const frame_consumer_device_ptr& consumer_device)\r
  15                 : producer_device_(producer_device), processor_device_(processor_device), consumer_device_(consumer_device)\r
  16         {\r
  17         }\r
  18 \r
  19         ~implementation()\r
  20         {\r
  21                 producer_device_->clear();\r
  22         }\r
  23         \r
  24         void load(int render_layer, const safe_ptr<frame_producer>& producer, load_option::type option = load_option::none)\r
  25         {\r
  26                 producer_device_->load(render_layer, producer, option);\r
  27         }\r
  28 \r
  29         void pause(int render_layer)\r
  30         {\r
  31                 producer_device_->pause(render_layer);\r
  32         }\r
  33 \r
  34         void play(int render_layer)\r
  35         {\r
  36                 producer_device_->play(render_layer);\r
  37         }\r
  38 \r
  39         void stop(int render_layer)\r
  40         {\r
  41                 producer_device_->stop(render_layer);\r
  42         }\r
  43 \r
  44         void clear(int render_layer)\r
  45         {\r
  46                 producer_device_->clear(render_layer);\r
  47         }\r
  48 \r
  49         void clear()\r
  50         {\r
  51                 producer_device_->clear();\r
  52         }\r
  53         \r
  54         boost::unique_future<safe_ptr<frame_producer>> foreground(int render_layer) const\r
  55         {\r
  56                 return producer_device_->foreground(render_layer);\r
  57         }\r
  58 \r
  59         boost::unique_future<safe_ptr<frame_producer>> background(int render_layer) const\r
  60         {\r
  61                 return producer_device_->background(render_layer);\r
  62         }\r
  63 \r
  64         const video_format_desc& get_video_format_desc() const\r
  65         {\r
  66                 return processor_device_->get_video_format_desc();\r
  67         }\r
  68 \r
  69 private:\r
  70         const frame_processor_device_ptr processor_device_; // Destroyed last inorder to have all frames returned to their pools.\r
  71         const frame_producer_device_ptr producer_device_;\r
  72         const frame_consumer_device_ptr consumer_device_;\r
  73 };\r
  74 \r
  75 channel::channel(const frame_producer_device_ptr& producer_device, const frame_processor_device_ptr& processor_device, const frame_consumer_device_ptr& consumer_device)\r
  76         : impl_(new implementation(producer_device, processor_device, consumer_device)){}\r
  77 void channel::load(int render_layer, const safe_ptr<frame_producer>& producer, load_option::type option){impl_->load(render_layer, producer, option);}\r
  78 void channel::pause(int render_layer){impl_->pause(render_layer);}\r
  79 void channel::play(int render_layer){impl_->play(render_layer);}\r
  80 void channel::stop(int render_layer){impl_->stop(render_layer);}\r
  81 void channel::clear(int render_layer){impl_->clear(render_layer);}\r
  82 void channel::clear(){impl_->clear();}\r
  83 boost::unique_future<safe_ptr<frame_producer>> channel::foreground(int render_layer) const{     return impl_->foreground(render_layer);}\r
  84 boost::unique_future<safe_ptr<frame_producer>> channel::background(int render_layer) const{return impl_->background(render_layer);}\r
  85 const video_format_desc& channel::get_video_format_desc() const{        return impl_->get_video_format_desc();}\r
  86 \r
  87 }}