2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
4 * This file is part of CasparCG (www.casparcg.com).
6 * CasparCG is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * CasparCG is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
19 * Author: Helge Norberg, helge.norberg@svt.se
22 #include "../../StdAfx.h"
24 #include <common/future.h>
25 #include <common/prec_timer.h>
27 #include <boost/algorithm/string/split.hpp>
28 #include <boost/algorithm/string.hpp>
30 #include "scene_producer.h"
32 #include "../../frame/draw_frame.h"
33 #include "../../interaction/interaction_aggregator.h"
34 #include "../text/text_producer.h"
36 namespace caspar { namespace core { namespace scene {
38 layer::layer(const std::wstring& name, const spl::shared_ptr<frame_producer>& producer)
39 : name(name), producer(producer)
41 crop.lower_right.x.bind(producer.get()->pixel_constraints().width);
42 crop.lower_right.y.bind(producer.get()->pixel_constraints().height);
43 perspective.upper_right.x.bind(producer.get()->pixel_constraints().width);
44 perspective.lower_right.x.bind(producer.get()->pixel_constraints().width);
45 perspective.lower_right.y.bind(producer.get()->pixel_constraints().height);
46 perspective.lower_left.y.bind(producer.get()->pixel_constraints().height);
49 adjustments::adjustments()
56 std::map<int64_t, keyframe> keyframes;
58 void on_frame(int64_t frame)
60 auto before = --keyframes.upper_bound(frame);
61 bool found_before = before != keyframes.end() && before->first < frame;
62 auto after = keyframes.upper_bound(frame);
63 bool found_after = after != keyframes.end() && after->first > frame;
64 auto exact_frame = keyframes.find(frame);
65 bool found_exact_frame = exact_frame != keyframes.end();
67 if (found_exact_frame)
69 exact_frame->second.on_destination_frame();
71 auto next_frame = ++exact_frame;
73 if (next_frame != keyframes.end() && next_frame->second.on_start_animate)
74 next_frame->second.on_start_animate();
78 int64_t start_frame = 0;
82 start_frame = before->first;
85 if (after->second.on_start_animate && frame == 0)
86 after->second.on_start_animate();
87 else if (after->second.on_animate_to)
88 after->second.on_animate_to(start_frame, frame);
93 mark_action get_mark_action(const std::wstring& name)
96 return mark_action::start;
97 else if (name == L"stop")
98 return mark_action::stop;
99 else if (name == L"jump_to")
100 return mark_action::jump_to;
101 else if (name == L"remove")
102 return mark_action::remove;
104 CASPAR_THROW_EXCEPTION(invalid_argument() << msg_info(L"Invalid mark_action " + name));
110 std::wstring label_argument;
112 marker(mark_action action, const std::wstring& label_argument)
114 , label_argument(label_argument)
119 struct scene_producer::impl
121 constraints pixel_constraints_;
122 video_format_desc format_desc_;
123 std::list<layer> layers_;
124 interaction_aggregator aggregator_;
125 binding<int64_t> frame_number_;
126 binding<double> speed_;
127 double frame_fraction_ = 0.0;
128 std::map<void*, timeline> timelines_;
129 std::map<std::wstring, std::shared_ptr<core::variable>> variables_;
130 std::vector<std::wstring> variable_names_;
131 std::multimap<int64_t, marker> markers_by_frame_;
132 monitor::subject monitor_subject_;
134 bool going_to_mark_ = false;
135 draw_frame last_frame_ = draw_frame::empty();
137 impl(int width, int height, const video_format_desc& format_desc)
138 : pixel_constraints_(width, height)
139 , format_desc_(format_desc)
140 , aggregator_([=] (double x, double y) { return collission_detect(x, y); })
142 auto speed_variable = std::make_shared<core::variable_impl<double>>(L"1.0", true, 1.0);
143 store_variable(L"scene_speed", speed_variable);
144 speed_ = speed_variable->value();
145 auto frame_variable = std::make_shared<core::variable_impl<int64_t>>(L"-1", true, -1);
146 store_variable(L"frame", frame_variable);
147 frame_number_ = frame_variable->value();
151 const spl::shared_ptr<frame_producer>& producer, int x, int y, const std::wstring& name)
153 layer layer(name, producer);
155 layer.position.x.set(x);
156 layer.position.y.set(y);
158 layers_.push_back(layer);
160 return layers_.back();
163 void store_keyframe(void* timeline_identity, const keyframe& k)
165 timelines_[timeline_identity].keyframes.insert(std::make_pair(k.destination_frame, k));
169 const std::wstring& name, const std::shared_ptr<core::variable>& var)
171 variables_.insert(std::make_pair(name, var));
172 variable_names_.push_back(name);
175 void add_mark(int64_t frame, mark_action action, const std::wstring& label)
177 markers_by_frame_.insert(std::make_pair(frame, marker(action, label)));
180 core::variable& get_variable(const std::wstring& name)
182 auto found = variables_.find(name);
184 if (found == variables_.end())
185 CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info(name + L" not found in scene"));
187 return *found->second;
190 const std::vector<std::wstring>& get_variables() const
192 return variable_names_;
195 binding<int64_t> frame()
197 return frame_number_;
200 frame_transform get_transform(const layer& layer) const
202 frame_transform transform;
204 auto& anchor = transform.image_transform.anchor;
205 auto& pos = transform.image_transform.fill_translation;
206 auto& scale = transform.image_transform.fill_scale;
207 auto& angle = transform.image_transform.angle;
208 auto& crop = transform.image_transform.crop;
209 auto& pers = transform.image_transform.perspective;
211 anchor[0] = layer.anchor.x.get() / layer.producer.get()->pixel_constraints().width.get();
212 anchor[1] = layer.anchor.y.get() / layer.producer.get()->pixel_constraints().height.get();
213 pos[0] = layer.position.x.get() / pixel_constraints_.width.get();
214 pos[1] = layer.position.y.get() / pixel_constraints_.height.get();
215 scale[0] = layer.producer.get()->pixel_constraints().width.get() / pixel_constraints_.width.get();
216 scale[1] = layer.producer.get()->pixel_constraints().height.get() / pixel_constraints_.height.get();
217 crop.ul[0] = layer.crop.upper_left.x.get() / layer.producer.get()->pixel_constraints().width.get();
218 crop.ul[1] = layer.crop.upper_left.y.get() / layer.producer.get()->pixel_constraints().height.get();
219 crop.lr[0] = layer.crop.lower_right.x.get() / layer.producer.get()->pixel_constraints().width.get();
220 crop.lr[1] = layer.crop.lower_right.y.get() / layer.producer.get()->pixel_constraints().height.get();
221 pers.ul[0] = layer.perspective.upper_left.x.get() / layer.producer.get()->pixel_constraints().width.get();
222 pers.ul[1] = layer.perspective.upper_left.y.get() / layer.producer.get()->pixel_constraints().height.get();
223 pers.ur[0] = layer.perspective.upper_right.x.get() / layer.producer.get()->pixel_constraints().width.get();
224 pers.ur[1] = layer.perspective.upper_right.y.get() / layer.producer.get()->pixel_constraints().height.get();
225 pers.lr[0] = layer.perspective.lower_right.x.get() / layer.producer.get()->pixel_constraints().width.get();
226 pers.lr[1] = layer.perspective.lower_right.y.get() / layer.producer.get()->pixel_constraints().height.get();
227 pers.ll[0] = layer.perspective.lower_left.x.get() / layer.producer.get()->pixel_constraints().width.get();
228 pers.ll[1] = layer.perspective.lower_left.y.get() / layer.producer.get()->pixel_constraints().height.get();
230 static const double PI = 3.141592653589793;
232 angle = layer.rotation.get() * PI / 180.0;
234 transform.image_transform.opacity = layer.adjustments.opacity.get();
235 transform.image_transform.is_key = layer.is_key.get();
236 transform.image_transform.use_mipmap = layer.use_mipmap.get();
237 transform.image_transform.blend_mode = layer.blend_mode.get();
238 transform.image_transform.chroma.key = layer.chroma_key.key.get();
239 transform.image_transform.chroma.threshold = layer.chroma_key.threshold.get();
240 transform.image_transform.chroma.softness = layer.chroma_key.softness.get();
241 transform.image_transform.chroma.spill = layer.chroma_key.spill.get();
243 // Mark as sublayer, so it will be composited separately by the mixer.
244 transform.image_transform.layer_depth = 1;
249 boost::optional<std::pair<int64_t, marker>> find_first_stop_or_jump_or_remove(int64_t start_frame, int64_t end_frame)
251 auto lower = markers_by_frame_.lower_bound(start_frame);
252 auto upper = markers_by_frame_.upper_bound(end_frame);
254 if (lower == markers_by_frame_.end())
257 for (auto iter = lower; iter != upper; ++iter)
259 auto action = iter->second.action;
261 if (action == mark_action::stop || action == mark_action::jump_to || action == mark_action::remove)
268 boost::optional<std::pair<int64_t, marker>> find_first_start(int64_t start_frame)
270 auto lower = markers_by_frame_.lower_bound(start_frame);
272 if (lower == markers_by_frame_.end())
275 for (auto iter = lower; iter != markers_by_frame_.end(); ++iter)
277 auto action = iter->second.action;
279 if (action == mark_action::start)
286 draw_frame render_frame()
288 if (format_desc_.field_count == 1)
289 return render_progressive_frame();
293 timer.tick_millis(0);
295 auto field1 = render_progressive_frame();
297 timer.tick(0.5 / format_desc_.fps);
299 auto field2 = render_progressive_frame();
301 return draw_frame::interlace(field1, field2, format_desc_.field_mode);
305 draw_frame render_progressive_frame()
310 frame_fraction_ += speed_.get();
312 if (std::abs(frame_fraction_) >= 1.0)
314 int64_t delta = static_cast<int64_t>(frame_fraction_);
315 auto previous_frame = frame_number_.get();
316 auto next_frame = frame_number_.get() + delta;
317 auto marker = find_first_stop_or_jump_or_remove(previous_frame + 1, next_frame);
319 if (marker && marker->second.action == mark_action::remove)
324 if (marker && !going_to_mark_)
326 if (marker->second.action == mark_action::stop)
328 frame_number_.set(marker->first);
329 frame_fraction_ = 0.0;
332 else if (marker->second.action == mark_action::jump_to)
334 go_to_marker(marker->second.label_argument, 0);
339 frame_number_.set(next_frame);
340 frame_fraction_ -= delta;
343 going_to_mark_ = false;
346 for (auto& timeline : timelines_)
347 timeline.second.on_frame(frame_number_.get());
349 std::vector<draw_frame> frames;
351 for (auto& layer : layers_)
353 if (layer.hidden.get())
356 draw_frame frame(layer.producer.get()->receive());
357 frame.transform() = get_transform(layer);
358 frames.push_back(frame);
361 return last_frame_ = draw_frame(frames);
364 void on_interaction(const interaction_event::ptr& event)
366 aggregator_.translate_and_send(event);
369 bool collides(double x, double y) const
371 return static_cast<bool>((collission_detect(x, y)));
374 boost::optional<interaction_target> collission_detect(double x, double y) const
376 for (auto& layer : layers_ | boost::adaptors::reversed)
378 if (layer.hidden.get())
381 auto transform = get_transform(layer);
382 auto translated = translate(x, y, transform);
384 if (translated.first >= 0.0
385 && translated.first <= 1.0
386 && translated.second >= 0.0
387 && translated.second <= 1.0
388 && layer.producer.get()->collides(translated.first, translated.second))
390 return std::make_pair(transform, static_cast<interaction_sink*>(layer.producer.get().get()));
394 return boost::optional<interaction_target>();
397 std::future<std::wstring> call(const std::vector<std::wstring>& params)
399 if (!params.empty() && boost::ends_with(params.at(0), L"()"))
400 return make_ready_future(handle_call(params));
402 return make_ready_future(handle_variable_set(params));
405 std::wstring handle_variable_set(const std::vector<std::wstring>& params)
407 for (int i = 0; i + 1 < params.size(); i += 2)
409 auto found = variables_.find(boost::to_lower_copy(params[i]));
411 if (found != variables_.end() && found->second->is_public())
412 found->second->from_string(params[i + 1]);
418 std::wstring handle_call(const std::vector<std::wstring>& params)
420 auto call = params.at(0);
422 if (call == L"play()")
423 go_to_marker(params.at(1), -1);
424 else if (call == L"remove()")
426 else if (call == L"next()")
429 CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info(L"Unknown call " + call));
437 last_frame_ = draw_frame::empty();
443 auto marker = find_first_start(frame_number_.get() + 1);
447 frame_number_.set(marker->first - 1);
448 frame_fraction_ = 0.0;
450 going_to_mark_ = true;
458 void go_to_marker(const std::wstring& marker_name, int64_t offset)
460 for (auto& marker : markers_by_frame_)
462 if (marker.second.label_argument == marker_name && marker.second.action == mark_action::start)
464 frame_number_.set(marker.first + offset);
465 frame_fraction_ = 0.0;
467 going_to_mark_ = true;
473 if (marker_name == L"intro")
475 frame_number_.set(offset);
476 frame_fraction_ = 0.0;
478 going_to_mark_ = true;
480 else if (marker_name == L"outro")
485 CASPAR_LOG(info) << print() << L" no marker called " << marker_name << " found";
488 std::wstring print() const
493 std::wstring name() const
498 boost::property_tree::wptree info() const
500 boost::property_tree::wptree info;
501 info.add(L"type", L"scene");
505 monitor::subject& monitor_output()
507 return monitor_subject_;
511 scene_producer::scene_producer(int width, int height, const video_format_desc& format_desc)
512 : impl_(new impl(width, height, format_desc))
516 scene_producer::~scene_producer()
520 layer& scene_producer::create_layer(
521 const spl::shared_ptr<frame_producer>& producer, int x, int y, const std::wstring& name)
523 return impl_->create_layer(producer, x, y, name);
526 layer& scene_producer::create_layer(
527 const spl::shared_ptr<frame_producer>& producer, const std::wstring& name)
529 return impl_->create_layer(producer, 0, 0, name);
532 binding<int64_t> scene_producer::frame()
534 return impl_->frame();
537 draw_frame scene_producer::receive_impl()
539 return impl_->render_frame();
542 constraints& scene_producer::pixel_constraints() { return impl_->pixel_constraints_; }
544 void scene_producer::on_interaction(const interaction_event::ptr& event)
546 impl_->on_interaction(event);
549 bool scene_producer::collides(double x, double y) const
551 return impl_->collides(x, y);
554 std::wstring scene_producer::print() const
556 return impl_->print();
559 std::wstring scene_producer::name() const
561 return impl_->name();
564 boost::property_tree::wptree scene_producer::info() const
566 return impl_->info();
569 std::future<std::wstring> scene_producer::call(const std::vector<std::wstring>& params)
571 return impl_->call(params);
574 monitor::subject& scene_producer::monitor_output()
576 return impl_->monitor_output();
579 void scene_producer::store_keyframe(void* timeline_identity, const keyframe& k)
581 impl_->store_keyframe(timeline_identity, k);
584 void scene_producer::store_variable(
585 const std::wstring& name, const std::shared_ptr<core::variable>& var)
587 impl_->store_variable(name, var);
590 void scene_producer::add_mark(int64_t frame, mark_action action, const std::wstring& label)
592 impl_->add_mark(frame, action, label);
595 core::variable& scene_producer::get_variable(const std::wstring& name)
597 return impl_->get_variable(name);
600 const std::vector<std::wstring>& scene_producer::get_variables() const
602 return impl_->get_variables();
605 spl::shared_ptr<core::frame_producer> create_dummy_scene_producer(const spl::shared_ptr<core::frame_factory>& frame_factory, const video_format_desc& format_desc, const std::vector<std::wstring>& params)
607 if (params.size() < 1 || !boost::iequals(params.at(0), L"[SCENE]"))
608 return core::frame_producer::empty();
610 auto scene = spl::make_shared<scene_producer>(format_desc.width, format_desc.height, format_desc);
612 text::text_info text_info;
613 text_info.font = L"ArialMT";
615 text_info.color.r = 1;
616 text_info.color.g = 1;
617 text_info.color.b = 1;
618 text_info.color.a = 0.5;
619 auto text_area = text_producer::create(frame_factory, 0, 0, L"a", text_info, 1280, 720, false);
621 auto text_width = text_area->pixel_constraints().width;
622 binding<double> padding(1.0);
623 binding<double> panel_width = padding + text_width + padding;
624 binding<double> panel_height = padding + text_area->pixel_constraints().height + padding;
626 auto subscription = panel_width.on_change([&]
628 CASPAR_LOG(info) << "Panel width: " << panel_width.get();
633 auto create_param = [](std::wstring elem) -> std::vector<std::wstring>
635 std::vector<std::wstring> result;
636 result.push_back(elem);
640 auto& car_layer = scene->create_layer(create_producer(frame_factory, format_desc, create_param(L"car")), L"car");
641 car_layer.adjustments.opacity.set(0.5);
642 //car_layer.hidden = scene->frame() % 50 > 25 || !(scene->frame() < 1000);
643 std::vector<std::wstring> sub_params;
644 sub_params.push_back(L"[FREEHAND]");
645 sub_params.push_back(L"640");
646 sub_params.push_back(L"360");
647 scene->create_layer(create_producer(frame_factory, format_desc, sub_params), 10, 10, L"freehand");
650 auto& color_layer = scene->create_layer(create_producer(frame_factory, format_desc, create_param(L"RED")), 110, 10, L"color");
651 color_layer.producer.get()->pixel_constraints().width.set(1000);
652 color_layer.producer.get()->pixel_constraints().height.set(550);
654 //scene->create_layer(create_producer(frame_factory, format_desc, create_param(L"SP")), 50, 50);
656 auto& upper_left = scene->create_layer(create_producer(frame_factory, format_desc, create_param(L"scene/upper_left")), L"upper_left");
657 auto& upper_right = scene->create_layer(create_producer(frame_factory, format_desc, create_param(L"scene/upper_right")), L"upper_right");
658 auto& lower_left = scene->create_layer(create_producer(frame_factory, format_desc, create_param(L"scene/lower_left")), L"lower_left");
659 auto& lower_right = scene->create_layer(create_producer(frame_factory, format_desc, create_param(L"scene/lower_right")), L"lower_right");
660 auto& text_layer = scene->create_layer(text_area, L"text_area");
661 upper_left.adjustments.opacity.bind(text_layer.adjustments.opacity);
662 upper_right.adjustments.opacity.bind(text_layer.adjustments.opacity);
663 lower_left.adjustments.opacity.bind(text_layer.adjustments.opacity);
664 lower_right.adjustments.opacity.bind(text_layer.adjustments.opacity);
667 binding<double> panel_x = (scene->frame()
669 .transformed([](double v) { return std::sin(v / 20.0); })
672 .transformed([](double v) { return std::floor(v); }); // snap to pixels instead of subpixels
674 tweener tween(L"easeoutbounce");
675 binding<double> panel_x(0.0);
677 scene->add_keyframe(panel_x, -panel_width, 0);
678 scene->add_keyframe(panel_x, 300.0, 50, L"easeinoutsine");
679 scene->add_keyframe(panel_x, 300.0, 50 * 4);
680 scene->add_keyframe(panel_x, 1000.0, 50 * 5, L"easeinoutsine");
681 //panel_x = delay(panel_x, add_tween(panel_x, scene->frame(), 200.0, int64_t(50), L"linear"), scene->frame(), int64_t(100));
682 /*binding<double> panel_x = when(scene->frame() < 50)
683 .then(scene->frame().as<double>().transformed([tween](double t) { return tween(t, 0.0, 200, 50); }))
685 //binding<double> panel_y = when(car_layer.hidden).then(500.0).otherwise(-panel_x + 300);
686 binding<double> panel_y(500.0);
687 scene->add_keyframe(panel_y, panel_y.get(), 50 * 4);
688 scene->add_keyframe(panel_y, 720.0, 50 * 5, L"easeinexpo");
690 scene->add_keyframe(text_layer.adjustments.opacity, 1.0, 100);
691 scene->add_keyframe(text_layer.adjustments.opacity, 0.0, 125, L"linear");
692 scene->add_keyframe(text_layer.adjustments.opacity, 1.0, 150, L"linear");
694 upper_left.position.x = panel_x;
695 upper_left.position.y = panel_y;
696 upper_right.position.x = upper_left.position.x + upper_left.producer.get()->pixel_constraints().width + panel_width;
697 upper_right.position.y = upper_left.position.y;
698 lower_left.position.x = upper_left.position.x;
699 lower_left.position.y = upper_left.position.y + upper_left.producer.get()->pixel_constraints().height + panel_height;
700 lower_right.position.x = upper_right.position.x;
701 lower_right.position.y = lower_left.position.y;
702 text_layer.position.x = upper_left.position.x + upper_left.producer.get()->pixel_constraints().width + padding;
703 text_layer.position.y = upper_left.position.y + upper_left.producer.get()->pixel_constraints().height + padding + text_area->current_bearing_y().as<double>();
705 text_area->text().bind(scene->create_variable<std::wstring>(L"text", true));
707 auto params2 = params;
708 params2.erase(params2.begin());
710 scene->call(params2);