]> git.sesse.net Git - casparcg/blob - core/producer/stage.cpp
git-svn-id: https://casparcg.svn.sourceforge.net/svnroot/casparcg/server/branches...
[casparcg] / core / producer / stage.cpp
1 /*\r
2 * copyright (c) 2010 Sveriges Television AB <info@casparcg.com>\r
3 *\r
4 *  This file is part of CasparCG.\r
5 *\r
6 *    CasparCG is free software: you can redistribute it and/or modify\r
7 *    it under the terms of the GNU General Public License as published by\r
8 *    the Free Software Foundation, either version 3 of the License, or\r
9 *    (at your option) any later version.\r
10 *\r
11 *    CasparCG is distributed in the hope that it will be useful,\r
12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
14 *    GNU General Public License for more details.\r
15 \r
16 *    You should have received a copy of the GNU General Public License\r
17 *    along with CasparCG.  If not, see <http://www.gnu.org/licenses/>.\r
18 *\r
19 */\r
20 \r
21 #include "../StdAfx.h"\r
22 \r
23 #include "stage.h"\r
24 \r
25 #include "layer.h"\r
26 \r
27 #include <core/producer/frame/basic_frame.h>\r
28 #include <core/producer/frame/frame_factory.h>\r
29 \r
30 #include <common/concurrency/executor.h>\r
31 #include <common/utility/move_on_copy.h>\r
32 \r
33 #include <boost/foreach.hpp>\r
34 \r
35 #include <agents.h>\r
36 #include <ppl.h>\r
37 \r
38 #include <map>\r
39 #include <set>\r
40 \r
41 using namespace Concurrency;\r
42 \r
43 namespace caspar { namespace core {\r
44 \r
45 struct stage::implementation : public agent, public boost::noncopyable\r
46 {               \r
47         overwrite_buffer<bool>                                          is_running_;\r
48         Concurrency::critical_section                           mutex_;\r
49         stage::target_t&                                                        target_;\r
50         std::map<int, layer>                                            layers_;        \r
51         safe_ptr<semaphore>                                                     semaphore_;\r
52 public:\r
53         implementation(stage::target_t& target, const safe_ptr<semaphore>& semaphore)  \r
54                 : target_(target)\r
55                 , semaphore_(semaphore)\r
56         {\r
57                 start();\r
58         }\r
59 \r
60         ~implementation()\r
61         {\r
62                 send(is_running_, false);\r
63                 semaphore_->release();\r
64                 agent::wait(this);\r
65         }\r
66 \r
67         virtual void run()\r
68         {\r
69                 send(is_running_, true);\r
70                 while(is_running_.value())\r
71                 {\r
72                         try\r
73                         {\r
74                                 std::map<int, safe_ptr<basic_frame>> frames;\r
75                                 {\r
76                                         critical_section::scoped_lock lock(mutex_);\r
77                 \r
78                                         BOOST_FOREACH(auto& layer, layers_)                     \r
79                                                 frames[layer.first] = basic_frame::empty();     \r
80 \r
81                                         Concurrency::parallel_for_each(layers_.begin(), layers_.end(), [&](std::map<int, layer>::value_type& layer) \r
82                                         {\r
83                                                 frames[layer.first] = layer.second.receive();   \r
84                                         });\r
85                                 }\r
86 \r
87                                 send(target_, make_safe<message<decltype(frames)>>(frames, token(semaphore_)));\r
88                         }\r
89                         catch(...)\r
90                         {\r
91                                 CASPAR_LOG_CURRENT_EXCEPTION();\r
92                                 Concurrency::wait(20);\r
93                         }       \r
94                 }\r
95 \r
96                 send(is_running_, false);\r
97                 done();\r
98         }\r
99                                 \r
100         void load(int index, const safe_ptr<frame_producer>& producer, bool preview, int auto_play_delta)\r
101         {\r
102                 critical_section::scoped_lock lock(mutex_);\r
103                 layers_[index].load(producer, preview, auto_play_delta);\r
104         }\r
105 \r
106         void pause(int index)\r
107         {               \r
108                 critical_section::scoped_lock lock(mutex_);\r
109                 layers_[index].pause();\r
110         }\r
111 \r
112         void play(int index)\r
113         {               \r
114                 critical_section::scoped_lock lock(mutex_);\r
115                 layers_[index].play();\r
116         }\r
117 \r
118         void stop(int index)\r
119         {               \r
120                 critical_section::scoped_lock lock(mutex_);\r
121                 layers_[index].stop();\r
122         }\r
123 \r
124         void clear(int index)\r
125         {\r
126                 critical_section::scoped_lock lock(mutex_);\r
127                 layers_.erase(index);\r
128         }\r
129                 \r
130         void clear()\r
131         {\r
132                 critical_section::scoped_lock lock(mutex_);\r
133                 layers_.clear();\r
134         }       \r
135         \r
136         void swap_layer(int index, size_t other_index)\r
137         {\r
138                 critical_section::scoped_lock lock(mutex_);\r
139                 std::swap(layers_[index], layers_[other_index]);\r
140         }\r
141 \r
142         void swap_layer(int index, size_t other_index, stage& other)\r
143         {\r
144                 if(other.impl_.get() == this)\r
145                         swap_layer(index, other_index);\r
146                 else\r
147                 {                       \r
148                         critical_section::scoped_lock lock1(mutex_);\r
149                         critical_section::scoped_lock lock2(other.impl_->mutex_);\r
150                         std::swap(layers_[index], other.impl_->layers_[other_index]);\r
151                 }\r
152         }\r
153 \r
154         void swap(stage& other)\r
155         {\r
156                 if(other.impl_.get() == this)\r
157                         return;\r
158                 \r
159                 critical_section::scoped_lock lock1(mutex_);\r
160                 critical_section::scoped_lock lock2(other.impl_->mutex_);\r
161                 std::swap(layers_, other.impl_->layers_);\r
162         }\r
163 \r
164         layer_status get_status(int index)\r
165         {               \r
166                 critical_section::scoped_lock lock(mutex_);\r
167                 return layers_[index].status();\r
168         }\r
169         \r
170         safe_ptr<frame_producer> foreground(int index)\r
171         {\r
172                 critical_section::scoped_lock lock(mutex_);\r
173                 return layers_[index].foreground();\r
174         }\r
175         \r
176         safe_ptr<frame_producer> background(int index)\r
177         {\r
178                 critical_section::scoped_lock lock(mutex_);\r
179                 return layers_[index].background();\r
180         }\r
181 \r
182         std::wstring print() const\r
183         {\r
184                 // C-TODO\r
185                 return L"stage []";// + boost::lexical_cast<std::wstring>(channel_.index()) + L"]";\r
186         }\r
187 \r
188 };\r
189 \r
190 stage::stage(target_t& target, const safe_ptr<semaphore>& semaphore) : impl_(new implementation(target, semaphore)){}\r
191 void stage::swap(stage& other){impl_->swap(other);}\r
192 void stage::load(int index, const safe_ptr<frame_producer>& producer, bool preview, int auto_play_delta){impl_->load(index, producer, preview, auto_play_delta);}\r
193 void stage::pause(int index){impl_->pause(index);}\r
194 void stage::play(int index){impl_->play(index);}\r
195 void stage::stop(int index){impl_->stop(index);}\r
196 void stage::clear(int index){impl_->clear(index);}\r
197 void stage::clear(){impl_->clear();}\r
198 void stage::swap_layer(int index, size_t other_index){impl_->swap_layer(index, other_index);}\r
199 void stage::swap_layer(int index, size_t other_index, stage& other){impl_->swap_layer(index, other_index, other);}\r
200 layer_status stage::get_status(int index){return impl_->get_status(index);}\r
201 safe_ptr<frame_producer> stage::foreground(size_t index) {return impl_->foreground(index);}\r
202 safe_ptr<frame_producer> stage::background(size_t index) {return impl_->background(index);}\r
203 }}