git.sesse.net Git - casparcg/blob - modules/psd/psd_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: Niklas P Andersson, niklas.p.andersson@svt.se
  20 */
  21
  22 #include "psd_scene_producer.h"
  23 #include "psd_document.h"
  24 #include "layer.h"
  25
  26 #include <core/frame/pixel_format.h>
  27 #include <core/frame/frame_factory.h>
  28 #include <core/frame/audio_channel_layout.h>
  29 #include <core/producer/frame_producer.h>
  30 #include <core/producer/color/color_producer.h>
  31 #include <core/producer/text/text_producer.h>
  32 #include <core/producer/scene/scene_cg_proxy.h>
  33 #include <core/producer/scene/scene_producer.h>
  34 #include <core/producer/scene/const_producer.h>
  35 #include <core/producer/scene/hotswap_producer.h>
  36 #include <core/producer/media_info/media_info.h>
  37 #include <core/frame/draw_frame.h>
  38 #include <core/help/help_repository.h>
  39 #include <core/help/help_sink.h>
  40
  41 #include <common/env.h>
  42 #include <common/memory.h>
  43 #include <common/log.h>
  44 #include <common/os/filesystem.h>
  45
  46 #include <boost/filesystem.hpp>
  47 #include <boost/thread/future.hpp>
  48 #include <boost/algorithm/string.hpp>
  49 #include <boost/rational.hpp>
  50
  51 #include <future>
  52
  53 namespace caspar { namespace psd {
  54
  55 core::text::text_info get_text_info(const boost::property_tree::wptree& ptree)
  56 {
  57         core::text::text_info result;
  58         int font_index = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.Font", 0);
  59         result.size = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.FontSize", 30.0f);
  60         //result.leading = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.Leading", 0);
  61         result.tracking = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.Tracking", 0);
  62         result.baseline_shift = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.BaselineShift", 0);
  63         //result.kerning = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.Kerning", 0);
  64
  65         int child_index = 0;
  66         auto color_node = ptree.get_child_optional(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.FillColor.Values");
  67
  68         if (color_node)
  69         {
  70                 for(auto it = color_node->begin(); it != color_node->end(); ++it, ++child_index)
  71                 {
  72                         auto& value_node = (*it).second;
  73                         float value = value_node.get_value(0.0f);
  74                         switch(child_index)
  75                         {
  76                         case 0: result.color.a = value; break;
  77                         case 1: result.color.r = value; break;
  78                         case 2: result.color.g = value; break;
  79                         case 3: result.color.b = value; break;
  80                         }
  81                 }
  82         }
  83
  84         //find fontname
  85         child_index = 0;
  86         auto fontset_node = ptree.get_child(L"ResourceDict.FontSet");
  87         for(auto it = fontset_node.begin(); it != fontset_node.end(); ++it, ++child_index)
  88         {
  89                 auto& font_node = (*it).second;
  90                 if(child_index == font_index)
  91                 {
  92                         result.font = font_node.get(L"Name", L"");
  93                         break;
  94                 }
  95         }
  96
  97         return result;
  98 }
  99
 100
 101 class dependency_resolver
 102 {
 103         struct layer_record
 104         {
 105                 layer_record() : layer(nullptr), tags(layer_tag::none), adjustment_x(0), adjustment_y(0), vector_mask(false)
 106                 {}
 107                 layer_record(caspar::core::scene::layer* l, caspar::psd::layer_tag t, double x, double y, bool v) :
 108                         layer(l), tags(t), adjustment_x(x), adjustment_y(y), vector_mask(v)
 109                 {}
 110
 111                 caspar::core::scene::layer* layer;
 112                 layer_tag tags;
 113                 double adjustment_x;
 114                 double adjustment_y;
 115                 bool vector_mask;
 116         };
 117
 118         std::list<layer_record> layers;
 119         layer_record master;
 120
 121         spl::shared_ptr<core::scene::scene_producer> scene_;
 122         bool is_root_;
 123
 124 public:
 125         dependency_resolver(const spl::shared_ptr<core::scene::scene_producer>& s) :
 126                 scene_(s), is_root_(false)
 127         {}
 128         dependency_resolver(const spl::shared_ptr<core::scene::scene_producer>& s, bool root) :
 129                 scene_(s), is_root_(root)
 130         {}
 131
 132         spl::shared_ptr<core::scene::scene_producer> scene() { return scene_; }
 133
 134         void add(caspar::core::scene::layer* layer, layer_tag tags, double adjustment_x, double adjustment_y, bool vector_mask)
 135         {
 136                 layer_record rec{ layer, tags, adjustment_x, adjustment_y, vector_mask };
 137                 layers.push_back(rec);
 138
 139                 //if the layer is either explicitly tagged as dynamic or at least not tagged as static/rasterized we should try to set it as master
 140                 if((rec.tags & layer_tag::explicit_dynamic) == layer_tag::explicit_dynamic || (rec.tags & layer_tag::rasterized) == layer_tag::none)
 141                 {
 142                         //if we don't have a master already, just assign this
 143                         if (master.layer == nullptr)
 144                                 master = rec;
 145                         else if ((rec.tags & layer_tag::explicit_dynamic) == layer_tag::explicit_dynamic)
 146                         {
 147                                 if((master.tags & layer_tag::explicit_dynamic) == layer_tag::none)
 148                                 {
 149                                         //if we have a master that's not explicitly tagged as dynamic but this layer is; use this as master
 150                                         master = rec;
 151                                 }
 152                                 else {
 153                                         //we have multiple layers that're tagged as dynamic, warn that the first one will be used
 154                                         CASPAR_LOG(warning) << "Multiple explicitly dynamic layers in the same group. The first one will be used";
 155                                 }
 156                         }
 157                 }
 158         }
 159
 160         void calculate()
 161         {
 162                 if (layers.size() == 0)
 163                         return;
 164
 165                 if (master.layer == nullptr) {
 166                         CASPAR_LOG(warning) << "Dependent layers without any dynamic layer";
 167                         return;
 168                 }
 169
 170                 for (auto &r : layers)
 171                 {
 172                         if (r.layer != master.layer)
 173                         {
 174                                 //x-coords
 175                                 double slave_left = r.layer->position.x.get();
 176                                 double master_left = master.layer->position.x.get();
 177                                 double slave_right = slave_left + r.layer->producer.get()->pixel_constraints().width.get();
 178                                 double master_right = master_left + master.layer->producer.get()->pixel_constraints().width.get();
 179
 180                                 double slave_width = slave_right - slave_left;
 181                                 double master_width = master_right - master_left;
 182
 183                                 double offset_start_x = slave_left - master_left;
 184                                 double offset_end_x = slave_left - master_right;
 185
 186                                 if((r.tags & layer_tag::moveable) == layer_tag::moveable)
 187                                         r.layer->position.x.bind(master.layer->position.x + master.layer->producer.get()->pixel_constraints().width + offset_end_x + r.adjustment_x);
 188                                 else if ((r.tags & layer_tag::resizable) == layer_tag::resizable) {
 189                                         r.layer->position.x.bind(master.layer->position.x + offset_start_x + r.adjustment_x);
 190
 191                                         if(r.vector_mask)       //adjust crop-rect if we have a vector-mask
 192                                                 r.layer->crop.lower_right.x.bind(master.layer->producer.get()->pixel_constraints().width + ((r.layer->crop.lower_right.x.get() - r.layer->crop.upper_left.x.get()) - master_width));
 193                                         else //just stretch the content
 194                                                 r.layer->producer.get()->pixel_constraints().width.bind(master.layer->producer.get()->pixel_constraints().width + (slave_width - master_width));
 195                                 }
 196
 197                                 //no support for changes in the y-direction yet
 198                         }
 199                 }
 200         }
 201 };
 202
 203 int64_t get_frame_number(
 204                 const core::video_format_desc& format_desc,
 205                 const boost::rational<int>& at_second)
 206 {
 207         return static_cast<int64_t>(
 208                         boost::rational_cast<double>(at_second) * format_desc.fps);
 209 }
 210
 211 boost::rational<int> get_rational(const boost::property_tree::wptree& node)
 212 {
 213         return boost::rational<int>(
 214                         node.get<int>(L"numerator"), node.get<int>(L"denominator"));
 215 }
 216
 217 void create_marks_from_comments(
 218                 const spl::shared_ptr<core::scene::scene_producer>& scene,
 219                 const core::video_format_desc& format_desc,
 220                 const boost::property_tree::wptree& comment_track)
 221 {
 222         auto keylist = comment_track.get_child_optional(L"keyList");
 223
 224         if (!keylist)
 225                 return;
 226
 227         for (auto& key : *keylist)
 228         {
 229                 auto time = get_rational(key.second.get_child(L"time"));
 230                 auto frame = get_frame_number(format_desc, time);
 231                 auto text = key.second.get<std::wstring>(L"animKey.Vl  ");
 232                 std::vector<std::wstring> marks;
 233                 boost::split(marks, text, boost::is_any_of(","));
 234
 235                 for (auto& mark : marks)
 236                 {
 237                         boost::trim_if(mark, [](wchar_t c) { return isspace(c) || c == 0; });
 238
 239                         std::vector<std::wstring> args;
 240                         boost::split(args, mark, boost::is_any_of(" \t"), boost::algorithm::token_compress_on);
 241
 242                         scene->add_mark(frame, core::scene::get_mark_action(args.at(0)), args.size() == 1 ? L"" : args.at(1));
 243                 }
 244         }
 245 }
 246
 247 void create_marks(
 248                 const spl::shared_ptr<core::scene::scene_producer>& scene,
 249                 const core::video_format_desc& format_desc,
 250                 const boost::property_tree::wptree& global_timeline)
 251 {
 252         auto time = get_rational(global_timeline.get_child(L"duration"));
 253         auto remove_at_frame = get_frame_number(format_desc, time);
 254
 255         scene->add_mark(remove_at_frame, core::scene::mark_action::remove, L"");
 256
 257         auto tracklist = global_timeline.get_child_optional(L"globalTrackList");
 258
 259         if (!tracklist)
 260                 return;
 261
 262         for (auto& track : *tracklist)
 263         {
 264                 auto track_id = track.second.get<std::wstring>(L"stdTrackID");
 265
 266                 if (track_id == L"globalCommentTrack")
 267                         create_marks_from_comments(scene, format_desc, track.second);
 268         }
 269 }
 270
 271 void create_timelines(
 272                 const spl::shared_ptr<core::scene::scene_producer>& scene,
 273                 const core::video_format_desc& format_desc,
 274                 core::scene::layer& layer,
 275                 const layer_ptr& psd_layer,
 276                 double adjustment_x,
 277                 double adjustment_y)
 278 {
 279         auto timeline = psd_layer->timeline_data();
 280         auto start = get_rational(timeline.get_child(L"timeScope.Strt"));
 281         auto end_offset = get_rational(timeline.get_child(L"timeScope.outTime"));
 282         auto end = start + end_offset;
 283         auto start_frame = get_frame_number(format_desc, start);
 284         auto end_frame = get_frame_number(format_desc, end);
 285
 286         layer.hidden = scene->timeline_frame() < start_frame || scene->timeline_frame() > end_frame;
 287
 288         auto tracklist = timeline.get_child_optional(L"trackList");
 289
 290         if (!tracklist)
 291                 return;
 292
 293         double original_pos_x = psd_layer->location().x;
 294         double original_pos_y = psd_layer->location().y;
 295
 296         for (auto& track : *tracklist)
 297         {
 298                 auto track_id = track.second.get<std::wstring>(L"stdTrackID");
 299
 300                 if (track_id == L"sheetPositionTrack")
 301                 {
 302                         for (auto& key : track.second.get_child(L"keyList"))
 303                         {
 304                                 bool tween = key.second.get<std::wstring>(L"animInterpStyle")
 305                                                 == L"Lnr ";
 306                                 auto time = get_rational(key.second.get_child(L"time"));
 307                                 auto hrzn = key.second.get<double>(L"animKey.Hrzn");
 308                                 auto vrtc = key.second.get<double>(L"animKey.Vrtc");
 309                                 auto x = original_pos_x + hrzn + adjustment_x;
 310                                 auto y = original_pos_y + vrtc + adjustment_y;
 311                                 auto frame = get_frame_number(format_desc, time);
 312
 313                                 if (frame == 0) // Consider as initial value (rewind)
 314                                 {
 315                                         layer.position.x.set(x);
 316                                         layer.position.y.set(y);
 317                                 }
 318
 319                                 frame = start_frame + frame; // translate to global timeline
 320
 321                                 if (tween)
 322                                 {
 323                                         scene->add_keyframe(layer.position.x, x, frame, L"easeOutSine");
 324                                         scene->add_keyframe(layer.position.y, y, frame, L"easeOutSine");
 325                                 }
 326                                 else
 327                                 {
 328                                         scene->add_keyframe(layer.position.x, x, frame);
 329                                         scene->add_keyframe(layer.position.y, y, frame);
 330                                 }
 331                         }
 332                 }
 333                 else if (track_id == L"opacityTrack")
 334                 {
 335                         auto& opacity = layer.adjustments.opacity;
 336
 337                         for (auto& key : track.second.get_child(L"keyList"))
 338                         {
 339                                 bool tween = key.second.get<std::wstring>(L"animInterpStyle")
 340                                                 == L"Lnr ";
 341                                 auto time = get_rational(key.second.get_child(L"time"));
 342                                 auto opct = key.second.get<double>(L"animKey.Opct.#Prc") / 100.0;
 343                                 auto frame = get_frame_number(format_desc, time);
 344
 345                                 if (frame == 0) // Consider as initial value (rewind)
 346                                         opacity.set(opct);
 347
 348                                 frame = start_frame + frame; // translate to global timeline
 349
 350                                 if (tween)
 351                                         scene->add_keyframe(opacity, opct, frame, L"easeOutSine");
 352                                 else
 353                                         scene->add_keyframe(opacity, opct, frame);
 354                         }
 355                 }
 356                 else
 357                 {
 358                         //ignore other kinds of tracks for now
 359                 }
 360         }
 361 }
 362
 363 spl::shared_ptr<core::frame_producer> create_psd_scene_producer(const core::frame_producer_dependencies& dependencies, const std::vector<std::wstring>& params)
 364 {
 365         std::wstring filename = env::template_folder() + params.at(0) + L".psd";
 366         auto found_file = find_case_insensitive(filename);
 367
 368         if (!found_file)
 369                 return core::frame_producer::empty();
 370
 371         psd_document doc;
 372         doc.parse(*found_file);
 373
 374         auto root = spl::make_shared<core::scene::scene_producer>(L"psd", params.at(0), doc.width(), doc.height(), dependencies.format_desc);
 375
 376         std::vector<std::pair<std::wstring, spl::shared_ptr<core::text_producer>>> text_producers_by_layer_name;
 377
 378         std::stack<dependency_resolver> scene_stack;
 379         scene_stack.push(dependency_resolver{ root, true });
 380
 381         auto layers_end = doc.layers().rend();
 382         for(auto it = doc.layers().rbegin(); it != layers_end; ++it)
 383         {
 384                 auto& psd_layer = (*it);
 385                 auto& current = scene_stack.top();
 386
 387                 if (psd_layer->group_mode() == layer_type::group) {
 388                         //we've found a group. Create a new scene and add it to the scene-stack
 389
 390                         auto format_desc = (dependencies.format_desc.field_count == 1) ? dependencies.format_desc : core::video_format_desc{ dependencies.format_desc.format,
 391                                                                                                                                                                                                                                                                         dependencies.format_desc.width,
 392                                                                                                                                                                                                                                                                         dependencies.format_desc.height,
 393                                                                                                                                                                                                                                                                         dependencies.format_desc.square_width,
 394                                                                                                                                                                                                                                                                         dependencies.format_desc.square_height,
 395                                                                                                                                                                                                                                                                         core::field_mode::progressive,
 396                                                                                                                                                                                                                                                                         dependencies.format_desc.time_scale*2,
 397                                                                                                                                                                                                                                                                         dependencies.format_desc.duration,
 398                                                                                                                                                                                                                                                                         dependencies.format_desc.name,
 399                                                                                                                                                                                                                                                                         core::find_audio_cadence(dependencies.format_desc.framerate * 2) };
 400
 401                         auto group = spl::make_shared<core::scene::scene_producer>(psd_layer->name(), L"layer group in " + params.at(0), doc.width(), doc.height(), format_desc);
 402
 403                         auto& scene_layer = current.scene()->create_layer(group, psd_layer->location().x, psd_layer->location().y, psd_layer->name());
 404                         scene_layer.adjustments.opacity.set(psd_layer->opacity() / 255.0);
 405                         scene_layer.hidden.set(!psd_layer->is_visible());
 406
 407                         if (psd_layer->has_timeline())
 408                                 create_timelines(root, dependencies.format_desc, scene_layer, psd_layer, 0, 0);
 409
 410                         if (psd_layer->is_movable())
 411                                 current.add(&scene_layer, psd_layer->tags(), 0, 0, false);
 412
 413                         if (psd_layer->is_resizable())  //TODO: we could add support for resizable groups with vector masks
 414                                 CASPAR_LOG(warning) << "Groups doesn't support the \"resizable\"-tag.";
 415
 416                         if (psd_layer->is_placeholder())
 417                                 CASPAR_LOG(warning) << "Groups doesn't support the \"producer\"-tag.";
 418
 419                         if (psd_layer->is_cornerpin())
 420                                 CASPAR_LOG(warning) << "Groups doesn't support the \"cornerpin\"-tag.";
 421
 422                         if (psd_layer->is_explicit_dynamic())
 423                                 CASPAR_LOG(warning) << "Groups doesn't support the \"dynamic\"-tag.";
 424
 425                         scene_stack.push(group);
 426                         continue;
 427                 }
 428                 else if (psd_layer->group_mode() == layer_type::group_delimiter) {
 429                         //a group-terminator. Finish the scene
 430                         current.scene()->reverse_layers();
 431                         current.calculate();
 432                         scene_stack.pop();
 433                         continue;
 434                 }
 435
 436                 if (psd_layer->is_visible())
 437                 {
 438                         caspar::core::scene::layer* scene_layer = nullptr;
 439                         std::shared_ptr<core::frame_producer> layer_producer;
 440                         auto layer_name = psd_layer->name();
 441                         int adjustment_x = 0,
 442                                 adjustment_y = 0;
 443
 444                         if(psd_layer->is_text() && !psd_layer->is_static())
 445                         {
 446                                 std::wstring str = psd_layer->text_data().get(L"EngineDict.Editor.Text", L"");
 447
 448                                 core::text::text_info text_info(std::move(get_text_info(psd_layer->text_data())));
 449                                 auto max_scale = std::max(abs(psd_layer->scale().x), abs(psd_layer->scale().y));
 450                                 text_info.size *= max_scale;
 451                                 text_info.scale_x = psd_layer->scale().x / max_scale;
 452                                 text_info.scale_y = psd_layer->scale().y / max_scale;
 453                                 text_info.shear = 0;
 454
 455                                 auto text_producer = core::text_producer::create(dependencies.frame_factory, 0, 0, str, text_info, doc.width(), doc.height());
 456                                 //text_producer->pixel_constraints().width.set(psd_layer->size().width);
 457                                 //text_producer->pixel_constraints().height.set(psd_layer->size().height);
 458                                 core::text::string_metrics metrics = text_producer->measure_string(str);
 459
 460                                 //adjustment_x = -2;    //the 2 offset is just a hack for now. don't know why our text is rendered 2 px to the right of that in photoshop
 461                                 //adjustment_y = metrics.bearingY;
 462                                 layer_producer = text_producer;
 463                                 scene_layer = &current.scene()->create_layer(spl::make_shared_ptr(layer_producer), static_cast<int>(psd_layer->text_pos().x) + adjustment_x, static_cast<int>(psd_layer->text_pos().y) + adjustment_y, layer_name);
 464
 465                                 int justification = psd_layer->text_data().get(L"EngineDict.ParagraphRun.RunArray..ParagraphSheet.Properties.Justification", 0);
 466
 467                                 switch (justification)
 468                                 {
 469                                 case 1: // Right
 470                                         scene_layer->anchor.x = text_producer.get()->pixel_constraints().width;
 471                                         break;
 472                                 case 2: // Center
 473                                         scene_layer->anchor.x = text_producer.get()->pixel_constraints().width / 2.0;
 474                                         break;
 475                                 }
 476
 477                                 text_producers_by_layer_name.push_back(std::make_pair(layer_name, text_producer));
 478                         }
 479                         else
 480                         {
 481                                 if (psd_layer->is_placeholder())
 482                                 {
 483                                         auto hotswap = std::make_shared<core::hotswap_producer>(psd_layer->bitmap()->width(), psd_layer->bitmap()->height());
 484
 485                                         if (psd_layer->is_explicit_dynamic())
 486                                         {
 487                                                 /*auto& var = root->create_variable<std::wstring>(boost::to_lower_copy(layer_name), true, L"");
 488                                                 var.on_change([=]() {
 489                                                         hotswap->producer().set(dependencies.producer_registry->create_producer(dependencies, root->get_variable(layer_name).as<std::wstring>().get()));
 490                                                 });*/
 491
 492                                         }
 493                                         else
 494                                                 hotswap->producer().set(dependencies.producer_registry->create_producer(dependencies, layer_name));
 495
 496                                         layer_producer = hotswap;
 497                                 }
 498                                 else if(psd_layer->is_solid())
 499                                 {
 500                                         layer_producer = core::create_const_producer(core::create_color_frame(it->get(), dependencies.frame_factory, psd_layer->solid_color().to_uint32()), psd_layer->bitmap()->width(), psd_layer->bitmap()->height());
 501                                 }
 502                                 else if(psd_layer->bitmap())
 503                                 {
 504                                         core::pixel_format_desc pfd(core::pixel_format::bgra);
 505                                         pfd.planes.push_back(core::pixel_format_desc::plane(psd_layer->bitmap()->width(), psd_layer->bitmap()->height(), 4));
 506
 507                                         auto frame = dependencies.frame_factory->create_frame(it->get(), pfd, core::audio_channel_layout::invalid());
 508                                         auto destination = frame.image_data().data();
 509                                         auto source = psd_layer->bitmap()->data();
 510                                         memcpy(destination, source, frame.image_data().size());
 511
 512                                         layer_producer = core::create_const_producer(core::draw_frame(std::move(frame)), psd_layer->bitmap()->width(), psd_layer->bitmap()->height());
 513                                 }
 514                                 else {
 515                                         CASPAR_LOG(warning) << "Ignoring layer \"" << layer_name << "\", layer type not supported";
 516                                 }
 517
 518                                 if(layer_producer)
 519                                         scene_layer = &current.scene()->create_layer(spl::make_shared_ptr(layer_producer), psd_layer->location().x + adjustment_x, psd_layer->location().y + adjustment_y, layer_name);
 520                         }
 521
 522                         if (layer_producer && scene_layer)
 523                         {
 524                                 scene_layer->adjustments.opacity.set(psd_layer->opacity() / 255.0);
 525                                 scene_layer->hidden.set(!psd_layer->is_visible());      //this will always evaluate to true
 526                                 scene_layer->blend_mode.set(psd_layer->blend_mode());
 527                                 scene_layer->rotation.set(psd_layer->angle());
 528
 529                                 if (psd_layer->mask().has_vector()) {
 530
 531                                         if (psd_layer->is_placeholder() && psd_layer->is_cornerpin()) {
 532
 533                                                 psd::point<int> layer_pos{ static_cast<int>(scene_layer->position.x.get()), static_cast<int>(scene_layer->position.y.get()) };
 534                                                 auto unbind_and_set = [&layer_pos](caspar::core::scene::coord& c, const caspar::psd::point<int>& pt) {
 535                                                         c.x.unbind();
 536                                                         c.x.set(pt.x - layer_pos.x);    //remap to layer-coordinates
 537                                                         c.y.unbind();
 538                                                         c.y.set(pt.y - layer_pos.y);    //remap to layer-coordinates
 539                                                 };
 540
 541                                                 if (!psd_layer->mask().vector()->rect().empty()) {
 542                                                         //this rectangle is in document-coordinates
 543                                                         auto& mask = psd_layer->mask().vector()->rect();
 544
 545                                                         unbind_and_set(scene_layer->perspective.upper_left, mask.location);
 546                                                         unbind_and_set(scene_layer->perspective.upper_right, point<int>{mask.location.x + mask.size.width, mask.location.y});
 547                                                         unbind_and_set(scene_layer->perspective.lower_right, point<int>{mask.location.x + mask.size.width, mask.location.y + mask.size.width});
 548                                                         unbind_and_set(scene_layer->perspective.lower_left, point<int>{mask.location.x, mask.location.y + mask.size.width});
 549                                                 }
 550                                                 else if (!psd_layer->mask().vector()->knots().empty()) {
 551                                                         auto& knots = psd_layer->mask().vector()->knots();
 552                                                         unbind_and_set(scene_layer->perspective.upper_left, knots[0]);
 553                                                         unbind_and_set(scene_layer->perspective.upper_right, knots[1]);
 554                                                         unbind_and_set(scene_layer->perspective.lower_right, knots[2]);
 555                                                         unbind_and_set(scene_layer->perspective.lower_left, knots[3]);
 556                                                 }
 557                                         }
 558                                         else if(!psd_layer->mask().vector()->rect().empty())
 559                                         {
 560                                                 //this rectangle is in document-coordinates
 561                                                 auto mask = psd_layer->mask().vector()->rect();
 562
 563                                                 //remap to layer-coordinates
 564                                                 auto left = static_cast<double>(mask.location.x) - scene_layer->position.x.get();
 565                                                 auto right = left + static_cast<double>(mask.size.width);
 566                                                 auto top = static_cast<double>(mask.location.y) - scene_layer->position.y.get();
 567                                                 auto bottom = top + static_cast<double>(mask.size.height);
 568
 569                                                 scene_layer->crop.upper_left.x.unbind();
 570                                                 scene_layer->crop.upper_left.x.set(left);
 571
 572                                                 scene_layer->crop.upper_left.y.unbind();
 573                                                 scene_layer->crop.upper_left.y.set(top);
 574
 575                                                 scene_layer->crop.lower_right.x.unbind();
 576                                                 scene_layer->crop.lower_right.x.set(right);
 577
 578                                                 scene_layer->crop.lower_right.y.unbind();
 579                                                 scene_layer->crop.lower_right.y.set(bottom);
 580                                         }
 581                                 }
 582
 583                                 if (psd_layer->has_timeline())
 584                                         create_timelines(root, dependencies.format_desc, *scene_layer, psd_layer, adjustment_x, adjustment_y);
 585
 586                                 if (psd_layer->is_movable() || psd_layer->is_resizable() || (psd_layer->is_text() && !psd_layer->is_static()))
 587                                         current.add(scene_layer, psd_layer->tags(), -adjustment_x, -adjustment_y, psd_layer->mask().has_vector());
 588
 589                                 if (psd_layer->is_placeholder())
 590                                         scene_layer->use_mipmap.set(true);
 591                         }
 592                 }
 593         }
 594
 595         if (scene_stack.size() != 1) {
 596
 597         }
 598         root->reverse_layers();
 599         scene_stack.top().calculate();
 600
 601         if (doc.has_timeline())
 602                 create_marks(root, dependencies.format_desc, doc.timeline());
 603
 604         // Reset all dynamic text fields to empty strings and expose them as a scene parameter.
 605         for (auto& text_layer : text_producers_by_layer_name) {
 606                 text_layer.second->text().set(L"");
 607                 auto var = root->create_variable<std::wstring>(boost::to_lower_copy(text_layer.first), true, L"");
 608                 text_layer.second->text().bind(var);
 609         }
 610
 611         auto params2 = params;
 612         params2.erase(params2.begin());
 613
 614         root->call(params2);
 615
 616         return root;
 617 }
 618
 619 void describe_psd_scene_producer(core::help_sink& sink, const core::help_repository& repo)
 620 {
 621         sink.short_description(L"A producer for dynamic graphics using Photoshops .psd files.");
 622         sink.syntax(L"[.psd_filename:string] {[param1:string] [value1:string]} {[param2:string] [value2:string]} ...");
 623         sink.para()->text(L"A producer that looks in the ")->code(L"templates")->text(L" folder for .psd files.");
 624 }
 625
 626 void init(core::module_dependencies dependencies)
 627 {
 628         dependencies.producer_registry->register_producer_factory(L"PSD Scene Producer", create_psd_scene_producer, describe_psd_scene_producer);
 629         dependencies.cg_registry->register_cg_producer(
 630                         L"psd",
 631                         { L".psd" },
 632                         [](const std::wstring& filename) { return ""; },
 633                         [](const spl::shared_ptr<core::frame_producer>& producer)
 634                         {
 635                                 return spl::make_shared<core::scene::scene_cg_proxy>(producer);
 636                         },
 637                         [](
 638                                         const core::frame_producer_dependencies& dependencies,
 639                                         const std::wstring& filename)
 640                         {
 641                                 return create_psd_scene_producer(dependencies, { filename });
 642                         },
 643                         false);
 644 }
 645
 646 }}