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

   1 /*
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
   3 *
   4 * This file is part of CasparCG (www.casparcg.com).
   5 *
   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.
  10 *
  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.
  15 *
  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/>.
  18 *
  19 * Author: Helge Norberg, helge.norberg@svt.se
  20 */
  21
  22 #include "../../StdAfx.h"
  23
  24 #include <common/future.h>
  25 #include <common/prec_timer.h>
  26
  27 #include <boost/algorithm/string/split.hpp>
  28 #include <boost/algorithm/string.hpp>
  29
  30 #include "scene_producer.h"
  31
  32 #include "../../frame/draw_frame.h"
  33 #include "../../interaction/interaction_aggregator.h"
  34 #include "../text/text_producer.h"
  35
  36 namespace caspar { namespace core { namespace scene {
  37
  38 layer::layer(const std::wstring& name, const spl::shared_ptr<frame_producer>& producer)
  39         : name(name), producer(producer)
  40 {
  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);
  47 }
  48
  49 adjustments::adjustments()
  50         : opacity(1.0)
  51 {
  52 }
  53
  54 struct timeline
  55 {
  56         std::map<int64_t, keyframe> keyframes;
  57
  58         void on_frame(int64_t frame)
  59         {
  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();
  66
  67                 if (found_exact_frame)
  68                 {
  69                         exact_frame->second.on_destination_frame();
  70
  71                         auto next_frame = ++exact_frame;
  72
  73                         if (next_frame != keyframes.end() && next_frame->second.on_start_animate)
  74                                 next_frame->second.on_start_animate();
  75                 }
  76                 else if (found_after)
  77                 {
  78                         int64_t start_frame = 0;
  79
  80                         if (found_before)
  81                         {
  82                                 start_frame = before->first;
  83                         }
  84
  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);
  89                 }
  90         }
  91 };
  92
  93 mark_action get_mark_action(const std::wstring& name)
  94 {
  95         if (name == L"start")
  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;
 103         else
 104                 CASPAR_THROW_EXCEPTION(user_error() << msg_info(L"Invalid mark_action " + name));
 105 }
 106
 107 struct marker
 108 {
 109         mark_action             action;
 110         std::wstring    label_argument;
 111
 112         marker(mark_action action, const std::wstring& label_argument)
 113                 : action(action)
 114                 , label_argument(label_argument)
 115         {
 116         }
 117 };
 118
 119 struct scene_producer::impl
 120 {
 121         std::wstring                                                                                    producer_name_;
 122         std::wstring                                                                                    template_name_;
 123         constraints                                                                                             pixel_constraints_;
 124         video_format_desc                                                                               format_desc_;
 125         std::list<layer>                                                                                layers_;
 126         interaction_aggregator                                                                  aggregator_;
 127         binding<double>                                                                                 frame_number_;
 128         binding<int64_t>                                                                                timeline_frame_number_;
 129         binding<double>                                                                                 speed_;
 130         mutable tbb::atomic<int64_t>                                                    m_x_;
 131         mutable tbb::atomic<int64_t>                                                    m_y_;
 132         binding<int64_t>                                                                                mouse_x_;
 133         binding<int64_t>                                                                                mouse_y_;
 134         double                                                                                                  frame_fraction_         = 0.0;
 135         std::map<void*, timeline>                                                               timelines_;
 136         std::map<std::wstring, std::shared_ptr<core::variable>> variables_;
 137         std::vector<std::wstring>                                                               variable_names_;
 138         std::multimap<int64_t, marker>                                                  markers_by_frame_;
 139         std::vector<std::shared_ptr<void>>                                              task_subscriptions_;
 140         monitor::subject                                                                                monitor_subject_;
 141         bool                                                                                                    paused_                         = true;
 142         bool                                                                                                    removed_                        = false;
 143         bool                                                                                                    going_to_mark_          = false;
 144
 145         impl(
 146                         std::wstring producer_name,
 147                         std::wstring template_name,
 148                         int width,
 149                         int height,
 150                         const video_format_desc& format_desc)
 151                 : producer_name_(std::move(producer_name))
 152                 , template_name_(std::move(template_name))
 153                 , format_desc_(format_desc)
 154                 , aggregator_([=] (double x, double y) { return collission_detect(x, y); })
 155         {
 156                 auto speed_variable = std::make_shared<core::variable_impl<double>>(L"1.0", true, 1.0);
 157                 store_variable(L"scene_speed", speed_variable);
 158                 speed_ = speed_variable->value();
 159
 160                 auto frame_variable = std::make_shared<core::variable_impl<double>>(L"-1", true, -1);
 161                 store_variable(L"frame", frame_variable);
 162                 frame_number_ = frame_variable->value();
 163
 164                 auto fps = format_desc_.fps * format_desc_.field_count;
 165                 auto fps_variable = std::make_shared<core::variable_impl<double>>(boost::lexical_cast<std::wstring>(fps), false, fps);
 166                 store_variable(L"fps", fps_variable);
 167
 168                 auto timeline_frame_variable = std::make_shared<core::variable_impl<int64_t>>(L"-1", false, -1);
 169                 store_variable(L"timeline_frame", timeline_frame_variable);
 170                 timeline_frame_number_ = timeline_frame_variable->value();
 171
 172                 auto mouse_x_variable = std::make_shared<core::variable_impl<int64_t>>(L"0", false, 0);
 173                 auto mouse_y_variable = std::make_shared<core::variable_impl<int64_t>>(L"0", false, 0);
 174                 store_variable(L"mouse_x", mouse_x_variable);
 175                 store_variable(L"mouse_y", mouse_y_variable);
 176                 mouse_x_ = mouse_x_variable->value();
 177                 mouse_y_ = mouse_y_variable->value();
 178                 m_x_ = 0;
 179                 m_y_ = 0;
 180
 181                 auto scene_width = std::make_shared<core::variable_impl<double>>(boost::lexical_cast<std::wstring>(width), false, width);
 182                 auto scene_height = std::make_shared<core::variable_impl<double>>(boost::lexical_cast<std::wstring>(height), false, height);
 183                 store_variable(L"scene_width", scene_width);
 184                 store_variable(L"scene_height", scene_height);
 185                 pixel_constraints_.width = scene_width->value();
 186                 pixel_constraints_.height = scene_height->value();
 187         }
 188
 189         layer& create_layer(
 190                         const spl::shared_ptr<frame_producer>& producer, int x, int y, const std::wstring& name)
 191         {
 192                 layer layer(name, producer);
 193
 194                 layer.position.x.set(x);
 195                 layer.position.y.set(y);
 196
 197                 layers_.push_back(layer);
 198
 199                 return layers_.back();
 200         }
 201
 202         void reverse_layers() {
 203                 layers_.reverse();
 204         }
 205
 206         layer& get_layer(const std::wstring& name)
 207         {
 208                 for (auto& layer : layers_)
 209                         if (layer.name.get() == name)
 210                                 return layer;
 211
 212                 CASPAR_THROW_EXCEPTION(user_error() << msg_info(name + L" not found in scene"));
 213         }
 214
 215         void store_keyframe(void* timeline_identity, const keyframe& k)
 216         {
 217                 timelines_[timeline_identity].keyframes.insert(std::make_pair(k.destination_frame, k));
 218         }
 219
 220         void store_variable(
 221                         const std::wstring& name, const std::shared_ptr<core::variable>& var)
 222         {
 223                 variables_.insert(std::make_pair(name, var));
 224                 variable_names_.push_back(name);
 225         }
 226
 227         void add_mark(int64_t frame, mark_action action, const std::wstring& label)
 228         {
 229                 markers_by_frame_.insert(std::make_pair(frame, marker(action, label)));
 230         }
 231
 232         void add_task(binding<bool> when, std::function<void ()> task)
 233         {
 234                 auto subscription = when.on_change([=]
 235                 {
 236                         if (when.get())
 237                         {
 238                                 try
 239                                 {
 240                                         task();
 241                                 }
 242                                 catch (...)
 243                                 {
 244                                         CASPAR_LOG_CURRENT_EXCEPTION_AT_LEVEL(debug);
 245                                         CASPAR_LOG(error) << print() << " Error when invoking scene task. Turn on log level debug for stacktrace.";
 246                                 }
 247                         }
 248                 });
 249
 250                 task_subscriptions_.push_back(std::move(subscription));
 251         }
 252
 253         core::variable& get_variable(const std::wstring& name)
 254         {
 255                 auto found = variables_.find(name);
 256
 257                 if (found == variables_.end())
 258                         CASPAR_THROW_EXCEPTION(user_error() << msg_info(name + L" not found in scene"));
 259
 260                 return *found->second;
 261         }
 262
 263         const std::vector<std::wstring>& get_variables() const
 264         {
 265                 return variable_names_;
 266         }
 267
 268         binding<int64_t> timeline_frame()
 269         {
 270                 return timeline_frame_number_;
 271         }
 272
 273         frame_transform get_transform(const layer& layer) const
 274         {
 275                 frame_transform transform;
 276
 277                 auto& anchor            = transform.image_transform.anchor;
 278                 auto& pos                       = transform.image_transform.fill_translation;
 279                 auto& scale                     = transform.image_transform.fill_scale;
 280                 auto& angle                     = transform.image_transform.angle;
 281                 auto& crop                      = transform.image_transform.crop;
 282                 auto& pers                      = transform.image_transform.perspective;
 283
 284                 anchor[0]       = layer.anchor.x.get()                                                                          / layer.producer.get()->pixel_constraints().width.get();
 285                 anchor[1]       = layer.anchor.y.get()                                                                          / layer.producer.get()->pixel_constraints().height.get();
 286                 pos[0]          = layer.position.x.get()                                                                        / pixel_constraints_.width.get();
 287                 pos[1]          = layer.position.y.get()                                                                        / pixel_constraints_.height.get();
 288                 scale[0]        = layer.producer.get()->pixel_constraints().width.get()         / pixel_constraints_.width.get();
 289                 scale[1]        = layer.producer.get()->pixel_constraints().height.get()        / pixel_constraints_.height.get();
 290                 crop.ul[0]      = layer.crop.upper_left.x.get()                                                         / layer.producer.get()->pixel_constraints().width.get();
 291                 crop.ul[1]      = layer.crop.upper_left.y.get()                                                         / layer.producer.get()->pixel_constraints().height.get();
 292                 crop.lr[0]      = layer.crop.lower_right.x.get()                                                        / layer.producer.get()->pixel_constraints().width.get();
 293                 crop.lr[1]      = layer.crop.lower_right.y.get()                                                        / layer.producer.get()->pixel_constraints().height.get();
 294                 pers.ul[0]      = layer.perspective.upper_left.x.get()                                          / layer.producer.get()->pixel_constraints().width.get();
 295                 pers.ul[1]      = layer.perspective.upper_left.y.get()                                          / layer.producer.get()->pixel_constraints().height.get();
 296                 pers.ur[0]      = layer.perspective.upper_right.x.get()                                         / layer.producer.get()->pixel_constraints().width.get();
 297                 pers.ur[1]      = layer.perspective.upper_right.y.get()                                         / layer.producer.get()->pixel_constraints().height.get();
 298                 pers.lr[0]      = layer.perspective.lower_right.x.get()                                         / layer.producer.get()->pixel_constraints().width.get();
 299                 pers.lr[1]      = layer.perspective.lower_right.y.get()                                         / layer.producer.get()->pixel_constraints().height.get();
 300                 pers.ll[0]      = layer.perspective.lower_left.x.get()                                          / layer.producer.get()->pixel_constraints().width.get();
 301                 pers.ll[1]      = layer.perspective.lower_left.y.get()                                          / layer.producer.get()->pixel_constraints().height.get();
 302
 303                 static const double PI = 3.141592653589793;
 304
 305                 angle           = layer.rotation.get() * PI / 180.0;
 306
 307                 transform.image_transform.opacity                                                       = layer.adjustments.opacity.get();
 308                 transform.image_transform.is_key                                                        = layer.is_key.get();
 309                 transform.image_transform.use_mipmap                                            = layer.use_mipmap.get();
 310                 transform.image_transform.blend_mode                                            = layer.blend_mode.get();
 311                 transform.image_transform.chroma.enable                                         = layer.chroma_key.enable.get();
 312                 transform.image_transform.chroma.target_hue                                     = layer.chroma_key.target_hue.get();
 313                 transform.image_transform.chroma.hue_width                                      = layer.chroma_key.hue_width.get();
 314                 transform.image_transform.chroma.min_saturation                         = layer.chroma_key.min_saturation.get();
 315                 transform.image_transform.chroma.min_brightness                         = layer.chroma_key.min_brightness.get();
 316                 transform.image_transform.chroma.softness                                       = layer.chroma_key.softness.get();
 317                 transform.image_transform.chroma.spill_suppress                         = layer.chroma_key.spill_suppress.get();
 318                 transform.image_transform.chroma.spill_suppress_saturation      = layer.chroma_key.spill_suppress_saturation.get();
 319
 320                 // Mark as sublayer, so it will be composited separately by the mixer.
 321                 transform.image_transform.layer_depth = 1;
 322
 323                 return transform;
 324         }
 325
 326         boost::optional<std::pair<int64_t, marker>> find_first_stop_or_jump_or_remove(int64_t start_frame, int64_t end_frame)
 327         {
 328                 auto lower = markers_by_frame_.lower_bound(start_frame);
 329                 auto upper = markers_by_frame_.upper_bound(end_frame);
 330
 331                 if (lower == markers_by_frame_.end())
 332                         return boost::none;
 333
 334                 for (auto iter = lower; iter != upper; ++iter)
 335                 {
 336                         auto action = iter->second.action;
 337
 338                         if (action == mark_action::stop || action == mark_action::jump_to || action == mark_action::remove)
 339                                 return std::make_pair(iter->first, iter->second);
 340                 }
 341
 342                 return boost::none;
 343         }
 344
 345         boost::optional<std::pair<int64_t, marker>> find_first_start(int64_t start_frame)
 346         {
 347                 auto lower = markers_by_frame_.lower_bound(start_frame);
 348
 349                 if (lower == markers_by_frame_.end())
 350                         return boost::none;
 351
 352                 for (auto iter = lower; iter != markers_by_frame_.end(); ++iter)
 353                 {
 354                         auto action = iter->second.action;
 355
 356                         if (action == mark_action::start)
 357                                 return std::make_pair(iter->first, iter->second);
 358                 }
 359
 360                 return boost::none;
 361         }
 362
 363         draw_frame render_frame()
 364         {
 365                 if (format_desc_.field_count == 1)
 366                         return render_progressive_frame();
 367                 else
 368                 {
 369                         prec_timer timer;
 370                         timer.tick_millis(0);
 371
 372                         auto field1 = render_progressive_frame();
 373
 374                         timer.tick(0.5 / format_desc_.fps);
 375
 376                         auto field2 = render_progressive_frame();
 377
 378                         return draw_frame::interlace(field1, field2, format_desc_.field_mode);
 379                 }
 380         }
 381
 382         void advance()
 383         {
 384                 frame_fraction_ += speed_.get();
 385
 386                 if (std::abs(frame_fraction_) >= 1.0)
 387                 {
 388                         int64_t delta = static_cast<int64_t>(frame_fraction_);
 389                         auto previous_frame = timeline_frame_number_.get();
 390                         auto next_frame = timeline_frame_number_.get() + delta;
 391                         auto marker = find_first_stop_or_jump_or_remove(previous_frame + 1, next_frame);
 392
 393                         if (marker && marker->second.action == mark_action::remove)
 394                         {
 395                                 remove();
 396                         }
 397                         if (marker && !going_to_mark_)
 398                         {
 399                                 if (marker->second.action == mark_action::stop)
 400                                 {
 401                                         timeline_frame_number_.set(marker->first);
 402                                         frame_fraction_ = 0.0;
 403                                         paused_ = true;
 404                                 }
 405                                 else if (marker->second.action == mark_action::jump_to)
 406                                 {
 407                                         go_to_marker(marker->second.label_argument, 0);
 408                                 }
 409                         }
 410                         else
 411                         {
 412                                 timeline_frame_number_.set(next_frame);
 413                                 frame_fraction_ -= delta;
 414                         }
 415
 416                         going_to_mark_ = false;
 417                 }
 418         }
 419
 420         draw_frame render_progressive_frame()
 421         {
 422                 if (removed_)
 423                         return draw_frame::empty();
 424
 425                 mouse_x_.set(m_x_);
 426                 mouse_y_.set(m_y_);
 427
 428                 if (!paused_)
 429                         advance();
 430
 431                 frame_number_.set(frame_number_.get() + speed_.get());
 432
 433                 for (auto& timeline : timelines_)
 434                         timeline.second.on_frame(timeline_frame_number_.get());
 435
 436                 std::vector<draw_frame> frames;
 437
 438                 for (auto& layer : layers_)
 439                 {
 440                         if (layer.hidden.get())
 441                                 continue;
 442
 443                         draw_frame frame(layer.producer.get()->receive());
 444                         frame.transform() = get_transform(layer);
 445                         frames.push_back(frame);
 446                 }
 447
 448                 return draw_frame(frames);
 449         }
 450
 451         void on_interaction(const interaction_event::ptr& event)
 452         {
 453                 aggregator_.translate_and_send(event);
 454         }
 455
 456         bool collides(double x, double y) const
 457         {
 458                 m_x_ = static_cast<int64_t>(x * pixel_constraints_.width.get());
 459                 m_y_ = static_cast<int64_t>(y * pixel_constraints_.height.get());
 460
 461                 return static_cast<bool>((collission_detect(x, y)));
 462         }
 463
 464         boost::optional<interaction_target> collission_detect(double x, double y) const
 465         {
 466                 for (auto& layer : layers_ | boost::adaptors::reversed)
 467                 {
 468                         if (layer.hidden.get())
 469                                 continue;
 470
 471                         auto transform = get_transform(layer);
 472                         auto translated = translate(x, y, transform);
 473
 474                         if (translated.first >= 0.0
 475                                 && translated.first <= 1.0
 476                                 && translated.second >= 0.0
 477                                 && translated.second <= 1.0
 478                                 && layer.producer.get()->collides(translated.first, translated.second))
 479                         {
 480                                 return std::make_pair(transform, static_cast<interaction_sink*>(layer.producer.get().get()));
 481                         }
 482                 }
 483
 484                 return boost::optional<interaction_target>();
 485         }
 486
 487         std::future<std::wstring> call(const std::vector<std::wstring>& params)
 488         {
 489                 if (!params.empty() && boost::ends_with(params.at(0), L"()"))
 490                         return make_ready_future(handle_call(params));
 491                 else
 492                         return make_ready_future(handle_variable_set(params));
 493         }
 494
 495         std::wstring handle_variable_set(const std::vector<std::wstring>& params)
 496         {
 497                 for (int i = 0; i + 1 < params.size(); i += 2)
 498                 {
 499                         auto found = variables_.find(boost::to_lower_copy(params.at(i)));
 500
 501                         if (found != variables_.end() && found->second->is_public())
 502                                 found->second->from_string(params.at(i + 1));
 503                 }
 504
 505                 return L"";
 506         }
 507
 508         std::wstring handle_call(const std::vector<std::wstring>& params)
 509         {
 510                 auto call = params.at(0);
 511
 512                 if (call == L"play()")
 513                         go_to_marker(params.at(1), -1);
 514                 else if (call == L"remove()")
 515                         remove();
 516                 else if (call == L"next()")
 517                         next();
 518                 else
 519                         CASPAR_THROW_EXCEPTION(user_error() << msg_info(L"Unknown call " + call));
 520
 521                 return L"";
 522         }
 523
 524         void remove()
 525         {
 526                 removed_ = true;
 527                 layers_.clear();
 528         }
 529
 530         void next()
 531         {
 532                 auto marker = find_first_start(timeline_frame_number_.get() + 1);
 533
 534                 if (marker)
 535                 {
 536                         timeline_frame_number_.set(marker->first - 1);
 537                         frame_fraction_ = 0.0;
 538                         paused_ = false;
 539                         going_to_mark_ = true;
 540                 }
 541                 else
 542                 {
 543                         remove();
 544                 }
 545         }
 546
 547         void go_to_marker(const std::wstring& marker_name, int64_t offset)
 548         {
 549                 for (auto& marker : markers_by_frame_)
 550                 {
 551                         if (marker.second.label_argument == marker_name && marker.second.action == mark_action::start)
 552                         {
 553                                 timeline_frame_number_.set(marker.first + offset);
 554                                 frame_fraction_ = 0.0;
 555                                 paused_ = false;
 556                                 going_to_mark_ = true;
 557
 558                                 return;
 559                         }
 560                 }
 561
 562                 if (marker_name == L"intro")
 563                 {
 564                         timeline_frame_number_.set(offset);
 565                         frame_fraction_ = 0.0;
 566                         paused_ = false;
 567                         going_to_mark_ = true;
 568                 }
 569                 else if (marker_name == L"outro")
 570                 {
 571                         remove();
 572                 }
 573                 else
 574                         CASPAR_LOG(info) << print() << L" no marker called " << marker_name << " found";
 575         }
 576
 577         std::wstring print() const
 578         {
 579                 return L"scene[type=" + name() + L" template=" + template_name_ + L"]";
 580         }
 581
 582         std::wstring name() const
 583         {
 584                 return producer_name_;
 585         }
 586
 587         boost::property_tree::wptree info() const
 588         {
 589                 boost::property_tree::wptree info;
 590                 info.add(L"type", L"scene");
 591                 info.add(L"producer-name", name());
 592                 info.add(L"template-name", template_name_);
 593                 info.add(L"frame-number", frame_number_.get());
 594                 info.add(L"timeline-frame-number", timeline_frame_number_.get());
 595
 596                 for (auto& var : variables_)
 597                 {
 598                         boost::property_tree::wptree variable_info;
 599
 600                         variable_info.add(L"name", var.first);
 601                         variable_info.add(L"public", var.second->is_public());
 602                         variable_info.add(L"value", var.second->to_string());
 603
 604                         info.add_child(L"variables.variable", variable_info);
 605                 }
 606
 607                 for (auto& layer : layers_)
 608                 {
 609                         boost::property_tree::wptree layer_info;
 610
 611                         layer_info.add(L"name", layer.name.get());
 612                         layer_info.add_child(L"producer", layer.producer.get()->info());
 613                         layer_info.add(L"x", layer.position.x.get());
 614                         layer_info.add(L"y", layer.position.y.get());
 615                         layer_info.add(L"width", layer.producer.get()->pixel_constraints().width.get());
 616                         layer_info.add(L"height", layer.producer.get()->pixel_constraints().height.get());
 617
 618                         info.add_child(L"layers.layer", layer_info);
 619                 }
 620
 621                 return info;
 622         }
 623
 624         monitor::subject& monitor_output()
 625         {
 626                 return monitor_subject_;
 627         }
 628 };
 629
 630 scene_producer::scene_producer(std::wstring producer_name, std::wstring template_name, int width, int height, const video_format_desc& format_desc)
 631         : impl_(new impl(std::move(producer_name), std::move(template_name), width, height, format_desc))
 632 {
 633 }
 634
 635 scene_producer::~scene_producer()
 636 {
 637 }
 638
 639 layer& scene_producer::create_layer(
 640                 const spl::shared_ptr<frame_producer>& producer, int x, int y, const std::wstring& name)
 641 {
 642         return impl_->create_layer(producer, x, y, name);
 643 }
 644
 645 layer& scene_producer::create_layer(
 646                 const spl::shared_ptr<frame_producer>& producer, const std::wstring& name)
 647 {
 648         return impl_->create_layer(producer, 0, 0, name);
 649 }
 650
 651 void scene_producer::reverse_layers()
 652 {
 653         impl_->reverse_layers();
 654 }
 655
 656 layer& scene_producer::get_layer(const std::wstring& name)
 657 {
 658         return impl_->get_layer(name);
 659 }
 660
 661 binding<int64_t> scene_producer::timeline_frame()
 662 {
 663         return impl_->timeline_frame();
 664 }
 665
 666 draw_frame scene_producer::receive_impl()
 667 {
 668         return impl_->render_frame();
 669 }
 670
 671 constraints& scene_producer::pixel_constraints() { return impl_->pixel_constraints_; }
 672
 673 void scene_producer::on_interaction(const interaction_event::ptr& event)
 674 {
 675         impl_->on_interaction(event);
 676 }
 677
 678 bool scene_producer::collides(double x, double y) const
 679 {
 680         return impl_->collides(x, y);
 681 }
 682
 683 std::wstring scene_producer::print() const
 684 {
 685         return impl_->print();
 686 }
 687
 688 std::wstring scene_producer::name() const
 689 {
 690         return impl_->name();
 691 }
 692
 693 boost::property_tree::wptree scene_producer::info() const
 694 {
 695         return impl_->info();
 696 }
 697
 698 std::future<std::wstring> scene_producer::call(const std::vector<std::wstring>& params)
 699 {
 700         return impl_->call(params);
 701 }
 702
 703 monitor::subject& scene_producer::monitor_output()
 704 {
 705         return impl_->monitor_output();
 706 }
 707
 708 void scene_producer::store_keyframe(void* timeline_identity, const keyframe& k)
 709 {
 710         impl_->store_keyframe(timeline_identity, k);
 711 }
 712
 713 void scene_producer::store_variable(
 714                 const std::wstring& name, const std::shared_ptr<core::variable>& var)
 715 {
 716         impl_->store_variable(name, var);
 717 }
 718
 719 void scene_producer::add_mark(int64_t frame, mark_action action, const std::wstring& label)
 720 {
 721         impl_->add_mark(frame, action, label);
 722 }
 723
 724 void scene_producer::add_task(binding<bool> when, std::function<void ()> task)
 725 {
 726         impl_->add_task(std::move(when), std::move(task));
 727 }
 728
 729 core::variable& scene_producer::get_variable(const std::wstring& name)
 730 {
 731         return impl_->get_variable(name);
 732 }
 733
 734 const std::vector<std::wstring>& scene_producer::get_variables() const
 735 {
 736         return impl_->get_variables();
 737 }
 738
 739 }}}