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: Niklas P Andersson, niklas.p.andersson@svt.se
22 #include "psd_scene_producer.h"
23 #include "psd_document.h"
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>
41 #include <common/env.h>
42 #include <common/memory.h>
43 #include <common/log.h>
44 #include <common/os/filesystem.h>
46 #include <boost/filesystem.hpp>
47 #include <boost/thread/future.hpp>
48 #include <boost/algorithm/string.hpp>
49 #include <boost/rational.hpp>
53 namespace caspar { namespace psd {
55 core::text::text_info get_text_info(const boost::property_tree::wptree& ptree)
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);
66 auto color_node = ptree.get_child_optional(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.FillColor.Values");
70 for(auto it = color_node->begin(); it != color_node->end(); ++it, ++child_index)
72 auto& value_node = (*it).second;
73 float value = value_node.get_value(0.0f);
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;
86 auto fontset_node = ptree.get_child(L"ResourceDict.FontSet");
87 for(auto it = fontset_node.begin(); it != fontset_node.end(); ++it, ++child_index)
89 auto& font_node = (*it).second;
90 if(child_index == font_index)
92 result.font = font_node.get(L"Name", L"");
101 class dependency_resolver
105 layer_record() : layer(nullptr), tags(layer_tag::none), adjustment_x(0), adjustment_y(0), vector_mask(false)
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)
111 caspar::core::scene::layer* layer;
118 std::list<layer_record> layers;
121 spl::shared_ptr<core::scene::scene_producer> scene_;
125 dependency_resolver(const spl::shared_ptr<core::scene::scene_producer>& s) :
126 scene_(s), is_root_(false)
128 dependency_resolver(const spl::shared_ptr<core::scene::scene_producer>& s, bool root) :
129 scene_(s), is_root_(root)
132 spl::shared_ptr<core::scene::scene_producer> scene() { return scene_; }
134 void add(caspar::core::scene::layer* layer, layer_tag tags, bool vector_mask)
136 layer_record rec{ layer, tags, 0, 0, vector_mask };
137 layers.push_back(rec);
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)
142 //if we don't have a master already, just assign this
143 if (master.layer == nullptr)
145 else if ((rec.tags & layer_tag::explicit_dynamic) == layer_tag::explicit_dynamic)
147 if((master.tags & layer_tag::explicit_dynamic) == layer_tag::none)
149 //if we have a master that's not explicitly tagged as dynamic but this layer is; use this as master
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";
162 if (layers.size() == 0)
165 if (master.layer == nullptr) {
166 CASPAR_LOG(warning) << "Dependent layers without any dynamic layer";
170 for (auto &r : layers)
172 if (r.layer != master.layer)
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();
180 double slave_width = slave_right - slave_left;
181 double master_width = master_right - master_left;
183 double offset_start_x = slave_left - master_left;
184 double offset_end_x = slave_left - master_right;
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);
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));
197 //no support for changes in the y-direction yet
203 boost::rational<int> get_frame_number(
204 const core::video_format_desc& format_desc,
205 const boost::rational<int>& at_second)
207 return at_second * format_desc.framerate * format_desc.field_count;
210 boost::rational<int> get_rational(const boost::property_tree::wptree& node)
212 return boost::rational<int>(
213 node.get<int>(L"numerator"), node.get<int>(L"denominator"));
216 void create_marks_from_comments(
217 const spl::shared_ptr<core::scene::scene_producer>& scene,
218 const core::video_format_desc& format_desc,
219 const boost::property_tree::wptree& comment_track)
221 auto keylist = comment_track.get_child_optional(L"keyList");
226 for (auto& key : *keylist)
228 auto time = get_rational(key.second.get_child(L"time"));
229 auto frame = boost::rational_cast<int64_t>(get_frame_number(format_desc, time));
230 auto text = key.second.get<std::wstring>(L"animKey.Vl ");
231 std::vector<std::wstring> marks;
232 boost::split(marks, text, boost::is_any_of(","));
234 for (auto& mark : marks)
236 boost::trim_if(mark, [](wchar_t c) { return isspace(c) || c == 0; });
238 std::vector<std::wstring> args;
239 boost::split(args, mark, boost::is_any_of(" \t"), boost::algorithm::token_compress_on);
241 scene->add_mark(frame, core::scene::get_mark_action(args.at(0)), args.size() == 1 ? L"" : args.at(1));
247 const spl::shared_ptr<core::scene::scene_producer>& scene,
248 const core::video_format_desc& format_desc,
249 const boost::property_tree::wptree& global_timeline)
251 auto time = get_rational(global_timeline.get_child(L"duration"));
252 auto remove_at_frame = get_frame_number(format_desc, time);
254 scene->add_mark(boost::rational_cast<int64_t>(remove_at_frame), core::scene::mark_action::remove, L"");
256 auto tracklist = global_timeline.get_child_optional(L"globalTrackList");
261 for (auto& track : *tracklist)
263 auto track_id = track.second.get<std::wstring>(L"stdTrackID");
265 if (track_id == L"globalCommentTrack")
266 create_marks_from_comments(scene, format_desc, track.second);
270 void create_timelines(
271 const spl::shared_ptr<core::scene::scene_producer>& scene,
272 const core::video_format_desc& format_desc,
273 core::scene::layer& layer,
274 const layer_ptr& psd_layer)
276 auto timeline = psd_layer->timeline_data();
277 auto start = get_rational(timeline.get_child(L"timeScope.Strt"));
278 auto end_offset = get_rational(timeline.get_child(L"timeScope.outTime"));
279 auto end = start + end_offset;
280 auto start_frame = get_frame_number(format_desc, start);
281 auto end_frame = get_frame_number(format_desc, end);
284 scene->timeline_frame() < boost::rational_cast<int64_t>(start_frame)
285 || scene->timeline_frame() > boost::rational_cast<int64_t>(end_frame);
287 auto tracklist = timeline.get_child_optional(L"trackList");
292 bool is_text_field = psd_layer->is_text() && !psd_layer->is_static();
293 double original_pos_x = is_text_field ? psd_layer->text_pos().x : psd_layer->location().x;
294 double original_pos_y = is_text_field ? psd_layer->text_pos().y : psd_layer->location().y;
296 for (auto& track : *tracklist)
298 auto track_id = track.second.get<std::wstring>(L"stdTrackID");
300 if (track_id == L"sheetPositionTrack")
302 for (auto& key : track.second.get_child(L"keyList"))
304 bool tween = key.second.get<std::wstring>(L"animInterpStyle") == L"Lnr ";
305 auto time = get_rational(key.second.get_child(L"time"));
306 auto hrzn = key.second.get<double>(L"animKey.Hrzn");
307 auto vrtc = key.second.get<double>(L"animKey.Vrtc");
308 auto x = original_pos_x + hrzn;
309 auto y = original_pos_y + vrtc;
310 auto frame = get_frame_number(format_desc, time);
312 if (frame == 0) // Consider as initial value (rewind)
314 layer.position.x.set(x);
315 layer.position.y.set(y);
318 frame = start_frame + frame; // translate to global timeline
322 scene->add_keyframe(layer.position.x, x, boost::rational_cast<int64_t>(frame), L"easeOutSine");
323 scene->add_keyframe(layer.position.y, y, boost::rational_cast<int64_t>(frame), L"easeOutSine");
327 scene->add_keyframe(layer.position.x, x, boost::rational_cast<int64_t>(frame));
328 scene->add_keyframe(layer.position.y, y, boost::rational_cast<int64_t>(frame));
332 else if (track_id == L"opacityTrack")
334 auto& opacity = layer.adjustments.opacity;
336 for (auto& key : track.second.get_child(L"keyList"))
338 bool tween = key.second.get<std::wstring>(L"animInterpStyle") == L"Lnr ";
339 auto time = get_rational(key.second.get_child(L"time"));
340 auto opct = key.second.get<double>(L"animKey.Opct.#Prc") / 100.0;
341 auto frame = get_frame_number(format_desc, time);
343 if (frame == 0) // Consider as initial value (rewind)
346 frame = start_frame + frame; // translate to global timeline
349 scene->add_keyframe(opacity, opct, boost::rational_cast<int64_t>(frame), L"linear");
351 scene->add_keyframe(opacity, opct, boost::rational_cast<int64_t>(frame));
356 //ignore other kinds of tracks for now
361 spl::shared_ptr<core::frame_producer> create_psd_scene_producer(const core::frame_producer_dependencies& dependencies, const std::vector<std::wstring>& params)
363 std::wstring filename = env::template_folder() + params.at(0) + L".psd";
364 auto found_file = find_case_insensitive(filename);
367 return core::frame_producer::empty();
370 doc.parse(*found_file);
372 auto root = spl::make_shared<core::scene::scene_producer>(L"psd", params.at(0), doc.width(), doc.height(), dependencies.format_desc);
374 std::vector<std::pair<std::wstring, spl::shared_ptr<core::text_producer>>> text_producers_by_layer_name;
376 std::stack<dependency_resolver> scene_stack;
377 scene_stack.push(dependency_resolver{ root, true });
379 auto layers_end = doc.layers().rend();
380 for(auto it = doc.layers().rbegin(); it != layers_end; ++it)
382 auto& psd_layer = (*it);
383 auto& current = scene_stack.top();
385 if (psd_layer->group_mode() == layer_type::group) {
386 //we've found a group. Create a new scene and add it to the scene-stack
388 auto format_desc = (dependencies.format_desc.field_count == 1) ? dependencies.format_desc : core::video_format_desc{ dependencies.format_desc.format,
389 dependencies.format_desc.width,
390 dependencies.format_desc.height,
391 dependencies.format_desc.square_width,
392 dependencies.format_desc.square_height,
393 core::field_mode::progressive,
394 dependencies.format_desc.time_scale*2,
395 dependencies.format_desc.duration,
396 dependencies.format_desc.name,
397 core::find_audio_cadence(dependencies.format_desc.framerate * 2) };
399 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);
401 auto& scene_layer = current.scene()->create_layer(group, psd_layer->location().x, psd_layer->location().y, psd_layer->name());
402 scene_layer.adjustments.opacity.set(psd_layer->opacity() / 255.0);
403 scene_layer.hidden.set(!psd_layer->is_visible());
405 if (psd_layer->has_timeline())
406 create_timelines(root, dependencies.format_desc, scene_layer, psd_layer);
408 if (psd_layer->is_movable())
409 current.add(&scene_layer, psd_layer->tags(), false);
411 if (psd_layer->is_resizable()) //TODO: we could add support for resizable groups with vector masks
412 CASPAR_LOG(warning) << "Groups doesn't support the \"resizable\"-tag.";
414 if (psd_layer->is_placeholder())
415 CASPAR_LOG(warning) << "Groups doesn't support the \"producer\"-tag.";
417 if (psd_layer->is_cornerpin())
418 CASPAR_LOG(warning) << "Groups doesn't support the \"cornerpin\"-tag.";
420 if (psd_layer->is_explicit_dynamic())
421 CASPAR_LOG(warning) << "Groups doesn't support the \"dynamic\"-tag.";
423 scene_stack.push(group);
426 else if (psd_layer->group_mode() == layer_type::group_delimiter) {
427 //a group-terminator. Finish the scene
428 current.scene()->reverse_layers();
434 if (psd_layer->is_visible())
436 caspar::core::scene::layer* scene_layer = nullptr;
437 std::shared_ptr<core::frame_producer> layer_producer;
438 auto layer_name = psd_layer->name();
440 if(psd_layer->is_text() && !psd_layer->is_static())
442 std::wstring str = psd_layer->text_data().get(L"EngineDict.Editor.Text", L"");
444 core::text::text_info text_info(std::move(get_text_info(psd_layer->text_data())));
445 auto max_scale = std::max(abs(psd_layer->scale().x), abs(psd_layer->scale().y));
446 text_info.size *= max_scale;
447 text_info.scale_x = psd_layer->scale().x / max_scale;
448 text_info.scale_y = psd_layer->scale().y / max_scale;
451 auto text_producer = core::text_producer::create(dependencies.frame_factory, 0, 0, str, text_info, doc.width(), doc.height());
452 //text_producer->pixel_constraints().width.set(psd_layer->size().width);
453 //text_producer->pixel_constraints().height.set(psd_layer->size().height);
455 layer_producer = text_producer;
456 scene_layer = ¤t.scene()->create_layer(spl::make_shared_ptr(layer_producer), static_cast<int>(psd_layer->text_pos().x), static_cast<int>(psd_layer->text_pos().y), layer_name);
458 int justification = psd_layer->text_data().get(L"EngineDict.ParagraphRun.RunArray..ParagraphSheet.Properties.Justification", 0);
460 switch (justification)
463 scene_layer->anchor.x = text_producer.get()->pixel_constraints().width;
466 scene_layer->anchor.x = text_producer.get()->pixel_constraints().width / 2.0;
470 text_producers_by_layer_name.push_back(std::make_pair(layer_name, text_producer));
474 if (psd_layer->is_placeholder())
476 auto hotswap = std::make_shared<core::hotswap_producer>(psd_layer->bitmap()->width(), psd_layer->bitmap()->height());
478 if (psd_layer->is_explicit_dynamic())
480 /*auto& var = root->create_variable<std::wstring>(boost::to_lower_copy(layer_name), true, L"");
481 var.on_change([=]() {
482 hotswap->producer().set(dependencies.producer_registry->create_producer(dependencies, root->get_variable(layer_name).as<std::wstring>().get()));
487 hotswap->producer().set(dependencies.producer_registry->create_producer(dependencies, layer_name));
489 layer_producer = hotswap;
491 else if(psd_layer->is_solid())
493 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());
495 else if(psd_layer->bitmap())
497 core::pixel_format_desc pfd(core::pixel_format::bgra);
498 pfd.planes.push_back(core::pixel_format_desc::plane(psd_layer->bitmap()->width(), psd_layer->bitmap()->height(), 4));
500 auto frame = dependencies.frame_factory->create_frame(it->get(), pfd, core::audio_channel_layout::invalid());
501 auto destination = frame.image_data().data();
502 auto source = psd_layer->bitmap()->data();
503 memcpy(destination, source, frame.image_data().size());
505 layer_producer = core::create_const_producer(core::draw_frame(std::move(frame)), psd_layer->bitmap()->width(), psd_layer->bitmap()->height());
508 CASPAR_LOG(warning) << "Ignoring layer \"" << layer_name << "\", layer type not supported";
512 scene_layer = ¤t.scene()->create_layer(spl::make_shared_ptr(layer_producer), psd_layer->location().x, psd_layer->location().y, layer_name);
515 if (layer_producer && scene_layer)
517 scene_layer->adjustments.opacity.set(psd_layer->opacity() / 255.0);
518 scene_layer->hidden.set(!psd_layer->is_visible()); //this will always evaluate to true
519 scene_layer->blend_mode.set(psd_layer->blend_mode());
520 scene_layer->rotation.set(psd_layer->angle());
522 if (psd_layer->mask().has_vector()) {
524 if (psd_layer->is_placeholder() && psd_layer->is_cornerpin()) {
526 psd::point<int> layer_pos{ static_cast<int>(scene_layer->position.x.get()), static_cast<int>(scene_layer->position.y.get()) };
527 auto unbind_and_set = [&layer_pos](caspar::core::scene::coord& c, const caspar::psd::point<int>& pt) {
529 c.x.set(pt.x - layer_pos.x); //remap to layer-coordinates
531 c.y.set(pt.y - layer_pos.y); //remap to layer-coordinates
534 if (!psd_layer->mask().vector()->rect().empty()) {
535 //this rectangle is in document-coordinates
536 auto& mask = psd_layer->mask().vector()->rect();
538 unbind_and_set(scene_layer->perspective.upper_left, mask.location);
539 unbind_and_set(scene_layer->perspective.upper_right, point<int>{mask.location.x + mask.size.width, mask.location.y});
540 unbind_and_set(scene_layer->perspective.lower_right, point<int>{mask.location.x + mask.size.width, mask.location.y + mask.size.width});
541 unbind_and_set(scene_layer->perspective.lower_left, point<int>{mask.location.x, mask.location.y + mask.size.width});
543 else if (!psd_layer->mask().vector()->knots().empty()) {
544 auto& knots = psd_layer->mask().vector()->knots();
545 unbind_and_set(scene_layer->perspective.upper_left, knots[0]);
546 unbind_and_set(scene_layer->perspective.upper_right, knots[1]);
547 unbind_and_set(scene_layer->perspective.lower_right, knots[2]);
548 unbind_and_set(scene_layer->perspective.lower_left, knots[3]);
551 else if(!psd_layer->mask().vector()->rect().empty())
553 //this rectangle is in document-coordinates
554 auto mask = psd_layer->mask().vector()->rect();
556 //remap to layer-coordinates
557 auto left = static_cast<double>(mask.location.x) - scene_layer->position.x.get();
558 auto right = left + static_cast<double>(mask.size.width);
559 auto top = static_cast<double>(mask.location.y) - scene_layer->position.y.get();
560 auto bottom = top + static_cast<double>(mask.size.height);
562 scene_layer->crop.upper_left.x.unbind();
563 scene_layer->crop.upper_left.x.set(left);
565 scene_layer->crop.upper_left.y.unbind();
566 scene_layer->crop.upper_left.y.set(top);
568 scene_layer->crop.lower_right.x.unbind();
569 scene_layer->crop.lower_right.x.set(right);
571 scene_layer->crop.lower_right.y.unbind();
572 scene_layer->crop.lower_right.y.set(bottom);
576 if (psd_layer->has_timeline())
577 create_timelines(root, dependencies.format_desc, *scene_layer, psd_layer);
579 if (psd_layer->is_movable() || psd_layer->is_resizable() || (psd_layer->is_text() && !psd_layer->is_static()))
580 current.add(scene_layer, psd_layer->tags(), psd_layer->mask().has_vector());
582 if (psd_layer->is_placeholder())
583 scene_layer->use_mipmap.set(true);
588 if (scene_stack.size() != 1) {
591 root->reverse_layers();
592 scene_stack.top().calculate();
594 if (doc.has_timeline())
595 create_marks(root, dependencies.format_desc, doc.timeline());
597 // Reset all dynamic text fields to empty strings and expose them as a scene parameter.
598 for (auto& text_layer : text_producers_by_layer_name) {
599 text_layer.second->text().set(L"");
600 auto var = root->create_variable<std::wstring>(boost::to_lower_copy(text_layer.first), true, L"");
601 text_layer.second->text().bind(var);
604 auto params2 = params;
605 params2.erase(params2.begin());
612 void describe_psd_scene_producer(core::help_sink& sink, const core::help_repository& repo)
614 sink.short_description(L"A producer for dynamic graphics using Photoshops .psd files.");
615 sink.syntax(L"[.psd_filename:string] {[param1:string] [value1:string]} {[param2:string] [value2:string]} ...");
616 sink.para()->text(L"A producer that looks in the ")->code(L"templates")->text(L" folder for .psd files.");
619 void init(core::module_dependencies dependencies)
621 dependencies.producer_registry->register_producer_factory(L"PSD Scene Producer", create_psd_scene_producer, describe_psd_scene_producer);
622 dependencies.cg_registry->register_cg_producer(
625 [](const std::wstring& filename) { return ""; },
626 [](const spl::shared_ptr<core::frame_producer>& producer)
628 return spl::make_shared<core::scene::scene_cg_proxy>(producer);
631 const core::frame_producer_dependencies& dependencies,
632 const std::wstring& filename)
634 return create_psd_scene_producer(dependencies, { filename });