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/producer/frame_producer.h>
  29 #include <core/producer/color/color_producer.h>
  30 #include <core/producer/text/text_producer.h>
  31 #include <core/producer/scene/scene_cg_proxy.h>
  32 #include <core/producer/scene/scene_producer.h>
  33 #include <core/producer/scene/const_producer.h>
  34 #include <core/producer/scene/hotswap_producer.h>
  35 #include <core/producer/media_info/media_info.h>
  36 #include <core/frame/draw_frame.h>
  37
  38 #include <common/env.h>
  39 #include <common/memory.h>
  40 #include <common/log.h>
  41 #include <common/os/filesystem.h>
  42
  43 #include <boost/filesystem.hpp>
  44 #include <boost/thread/future.hpp>
  45 #include <boost/algorithm/string.hpp>
  46 #include <boost/rational.hpp>
  47
  48 #include <future>
  49
  50 namespace caspar { namespace psd {
  51
  52 core::text::text_info get_text_info(const boost::property_tree::wptree& ptree)
  53 {
  54         core::text::text_info result;
  55         int font_index = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.Font", 0);
  56         result.size = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.FontSize", 30.0f);
  57         //result.leading = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.Leading", 0);
  58         result.tracking = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.Tracking", 0);
  59         result.baseline_shift = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.BaselineShift", 0);
  60         //result.kerning = ptree.get(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.Kerning", 0);
  61
  62         int child_index = 0;
  63         auto color_node = ptree.get_child(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.FillColor.Values");
  64         for(auto it = color_node.begin(); it != color_node.end(); ++it, ++child_index)
  65         {
  66                 auto& value_node = (*it).second;
  67                 float value = value_node.get_value(0.0f);
  68                 switch(child_index)
  69                 {
  70                 case 0: result.color.a = value; break;
  71                 case 1: result.color.r = value; break;
  72                 case 2: result.color.g = value; break;
  73                 case 3: result.color.b = value; break;
  74                 }
  75         }
  76
  77         //find fontname
  78         child_index = 0;
  79         auto fontset_node = ptree.get_child(L"ResourceDict.FontSet");
  80         for(auto it = fontset_node.begin(); it != fontset_node.end(); ++it, ++child_index)
  81         {
  82                 auto& font_node = (*it).second;
  83                 if(child_index == font_index)
  84                 {
  85                         result.font = font_node.get(L"Name", L"");
  86                         break;
  87                 }
  88         }
  89
  90         return result;
  91 }
  92
  93
  94         class layer_link_constructor
  95         {
  96                 struct linked_layer_record
  97                 {
  98                         caspar::core::scene::layer* layer;
  99                         int link_id;
 100                         bool is_master;
 101                         double adjustment_x;
 102                         double adjustment_y;
 103                 };
 104
 105                 std::vector<linked_layer_record> layers;
 106                 std::vector<linked_layer_record> masters;
 107
 108         public:
 109                 void add(caspar::core::scene::layer* layer, int link_group, bool master, double adjustment_x, double adjustment_y)
 110                 {
 111                         linked_layer_record rec;
 112                         rec.layer = layer;
 113                         rec.link_id = link_group;
 114                         rec.is_master = master;
 115                         rec.adjustment_x = adjustment_x;
 116                         rec.adjustment_y = adjustment_y;
 117                         layers.push_back(rec);
 118
 119                         if(rec.is_master)
 120                         {
 121                                 auto it = std::find_if(masters.begin(), masters.end(), [=](linked_layer_record const &r){ return r.link_id == link_group; });
 122                                 if(it == masters.end())
 123                                         masters.push_back(rec);
 124                                 else
 125                                         masters.erase(it);      //ambigous, two linked layers with locked position
 126                         }
 127                 }
 128
 129                 void calculate()
 130                 {
 131                         for(auto it = masters.begin(); it != masters.end(); ++it)
 132                         {
 133                                 auto& master = (*it);
 134                                 //std::for_each(layers.begin(), layers.end(), [&master](linked_layer_record &r) mutable {
 135                                 for (auto &r : layers) {
 136                                         if(r.link_id == master.link_id && r.layer != master.layer)
 137                                         {
 138                                                 {       //x-coords
 139                                                         double slave_left = r.layer->position.x.get() + r.adjustment_x;
 140                                                         double slave_right = slave_left + r.layer->producer.get()->pixel_constraints().width.get();
 141
 142                                                         double master_left = master.layer->position.x.get() + master.adjustment_x;
 143                                                         double master_right = master_left + master.layer->producer.get()->pixel_constraints().width.get();
 144
 145                                                         if((slave_left >= master_left && slave_right <= master_right) || (slave_left <= master_left && slave_right >= master_right))
 146                                                         {
 147                                                                 //change width of slave
 148                                                                 r.layer->position.x.bind(master.layer->position.x - r.adjustment_x + master.adjustment_x + (slave_left - master_left));
 149                                                                 r.layer->producer.get()->pixel_constraints().width.bind(master.layer->producer.get()->pixel_constraints().width + (slave_right - slave_left - master_right + master_left));
 150                                                         }
 151                                                         else if(slave_left >= master_right)
 152                                                         {
 153                                                                 //push slave ahead of master
 154                                                                 r.layer->position.x.bind(master.layer->position.x - r.adjustment_x + master.adjustment_x + master.layer->producer.get()->pixel_constraints().width + (slave_left - master_right));
 155                                                         }
 156                                                         else if(slave_right <= master_left)
 157                                                         {
 158                                                                 r.layer->position.x.bind(master.layer->position.x - r.adjustment_x + master.adjustment_x - (master_left - slave_left));
 159                                                         }
 160                                                 }
 161
 162                                                 {       //y-coords
 163                                                         double slave_top = r.layer->position.y.get() + r.adjustment_y;
 164                                                         double slave_bottom = slave_top + r.layer->producer.get()->pixel_constraints().height.get();
 165
 166                                                         double master_top = master.layer->position.y.get() + master.adjustment_y;
 167                                                         double master_bottom = master_top + master.layer->producer.get()->pixel_constraints().height.get();
 168
 169                                                         if((slave_top >= master_top && slave_bottom <= master_bottom) || (slave_top <= master_top && slave_bottom >= master_bottom))
 170                                                         {
 171                                                                 //change height of slave
 172                                                                 r.layer->position.y.bind(master.layer->position.y - r.adjustment_y + master.adjustment_y + (slave_top - master_top));
 173                                                                 r.layer->producer.get()->pixel_constraints().height.bind(master.layer->producer.get()->pixel_constraints().height + (slave_bottom - slave_top - master_bottom + master_top));
 174                                                         }
 175                                                         else if(slave_top >= master_bottom)
 176                                                         {
 177                                                                 //push slave ahead of master
 178                                                                 r.layer->position.y.bind(master.layer->position.y - r.adjustment_y + master.adjustment_y + master.layer->producer.get()->pixel_constraints().height + (slave_top - master_bottom));
 179                                                         }
 180                                                         else if(slave_bottom <= master_top)
 181                                                         {
 182                                                                 r.layer->position.y.bind(master.layer->position.y - r.adjustment_y + master.adjustment_y - (master_top - slave_top));
 183                                                         }
 184                                                 }
 185
 186                                         }
 187                                 }
 188                         }
 189                 }
 190         };
 191
 192 int64_t get_frame_number(
 193                 const core::video_format_desc& format_desc,
 194                 const boost::rational<int>& at_second)
 195 {
 196         return static_cast<int64_t>(
 197                         boost::rational_cast<double>(at_second) * format_desc.fps);
 198 }
 199
 200 boost::rational<int> get_rational(const boost::property_tree::wptree& node)
 201 {
 202         return boost::rational<int>(
 203                         node.get<int>(L"numerator"), node.get<int>(L"denominator"));
 204 }
 205
 206 void create_marks_from_comments(
 207                 const spl::shared_ptr<core::scene::scene_producer>& scene,
 208                 const core::video_format_desc& format_desc,
 209                 const boost::property_tree::wptree& comment_track)
 210 {
 211         auto keylist = comment_track.get_child_optional(L"keyList");
 212
 213         if (!keylist)
 214                 return;
 215
 216         for (auto& key : *keylist)
 217         {
 218                 auto time = get_rational(key.second.get_child(L"time"));
 219                 auto frame = get_frame_number(format_desc, time);
 220                 auto text = key.second.get<std::wstring>(L"animKey.Vl  ");
 221                 std::vector<std::wstring> marks;
 222                 boost::split(marks, text, boost::is_any_of(","));
 223
 224                 for (auto& mark : marks)
 225                 {
 226                         boost::trim_if(mark, [](wchar_t c) { return isspace(c) || c == 0; });
 227
 228                         std::vector<std::wstring> args;
 229                         boost::split(args, mark, boost::is_any_of(" \t"), boost::algorithm::token_compress_on);
 230
 231                         scene->add_mark(frame, core::scene::get_mark_action(args.at(0)), args.size() == 1 ? L"" : args.at(1));
 232                 }
 233         }
 234 }
 235
 236 void create_marks(
 237                 const spl::shared_ptr<core::scene::scene_producer>& scene,
 238                 const core::video_format_desc& format_desc,
 239                 const boost::property_tree::wptree& global_timeline)
 240 {
 241         auto time = get_rational(global_timeline.get_child(L"duration"));
 242         auto remove_at_frame = get_frame_number(format_desc, time);
 243
 244         scene->add_mark(remove_at_frame, core::scene::mark_action::remove, L"");
 245
 246         auto tracklist = global_timeline.get_child_optional(L"globalTrackList");
 247
 248         if (!tracklist)
 249                 return;
 250
 251         for (auto& track : *tracklist)
 252         {
 253                 auto track_id = track.second.get<std::wstring>(L"stdTrackID");
 254
 255                 if (track_id == L"globalCommentTrack")
 256                         create_marks_from_comments(scene, format_desc, track.second);
 257         }
 258 }
 259
 260 void create_timelines(
 261                 const spl::shared_ptr<core::scene::scene_producer>& scene,
 262                 const core::video_format_desc& format_desc,
 263                 core::scene::layer& layer,
 264                 const layer_ptr& psd_layer,
 265                 double adjustment_x,
 266                 double adjustment_y)
 267 {
 268         auto timeline = psd_layer->timeline_data();
 269         auto start = get_rational(timeline.get_child(L"timeScope.Strt"));
 270         auto end_offset = get_rational(timeline.get_child(L"timeScope.outTime"));
 271         auto end = start + end_offset;
 272         auto start_frame = get_frame_number(format_desc, start);
 273         auto end_frame = get_frame_number(format_desc, end);
 274
 275         layer.hidden = scene->frame() < start_frame || scene->frame() > end_frame;
 276
 277         auto tracklist = timeline.get_child_optional(L"trackList");
 278
 279         if (!tracklist)
 280                 return;
 281
 282         double original_pos_x = psd_layer->location().x;
 283         double original_pos_y = psd_layer->location().y;
 284
 285         for (auto& track : *tracklist)
 286         {
 287                 auto track_id = track.second.get<std::wstring>(L"stdTrackID");
 288
 289                 if (track_id == L"sheetPositionTrack")
 290                 {
 291                         for (auto& key : track.second.get_child(L"keyList"))
 292                         {
 293                                 bool tween = key.second.get<std::wstring>(L"animInterpStyle")
 294                                                 == L"Lnr ";
 295                                 auto time = get_rational(key.second.get_child(L"time"));
 296                                 auto hrzn = key.second.get<double>(L"animKey.Hrzn");
 297                                 auto vrtc = key.second.get<double>(L"animKey.Vrtc");
 298                                 auto x = original_pos_x + hrzn + adjustment_x;
 299                                 auto y = original_pos_y + vrtc + adjustment_y;
 300                                 auto frame = get_frame_number(format_desc, time);
 301
 302                                 if (frame == 0) // Consider as initial value (rewind)
 303                                 {
 304                                         layer.position.x.set(x);
 305                                         layer.position.y.set(y);
 306                                 }
 307
 308                                 frame = start_frame + frame; // translate to global timeline
 309
 310                                 if (tween)
 311                                 {
 312                                         scene->add_keyframe(layer.position.x, x, frame, L"easeOutSine");
 313                                         scene->add_keyframe(layer.position.y, y, frame, L"easeOutSine");
 314                                 }
 315                                 else
 316                                 {
 317                                         scene->add_keyframe(layer.position.x, x, frame);
 318                                         scene->add_keyframe(layer.position.y, y, frame);
 319                                 }
 320                         }
 321                 }
 322                 else if (track_id == L"opacityTrack")
 323                 {
 324                         auto& opacity = layer.adjustments.opacity;
 325
 326                         for (auto& key : track.second.get_child(L"keyList"))
 327                         {
 328                                 bool tween = key.second.get<std::wstring>(L"animInterpStyle")
 329                                                 == L"Lnr ";
 330                                 auto time = get_rational(key.second.get_child(L"time"));
 331                                 auto opct = key.second.get<double>(L"animKey.Opct.#Prc") / 100.0;
 332                                 auto frame = get_frame_number(format_desc, time);
 333
 334                                 if (frame == 0) // Consider as initial value (rewind)
 335                                         opacity.set(opct);
 336
 337                                 frame = start_frame + frame; // translate to global timeline
 338
 339                                 if (tween)
 340                                         scene->add_keyframe(opacity, opct, frame, L"easeOutSine");
 341                                 else
 342                                         scene->add_keyframe(opacity, opct, frame);
 343                         }
 344                 }
 345         }
 346 }
 347
 348 spl::shared_ptr<core::frame_producer> create_psd_scene_producer(const core::frame_producer_dependencies& dependencies, const std::vector<std::wstring>& params)
 349 {
 350         std::wstring filename = env::template_folder() + params.at(0) + L".psd";
 351         auto found_file = find_case_insensitive(filename);
 352
 353         if (!found_file)
 354                 return core::frame_producer::empty();
 355
 356         psd_document doc;
 357         doc.parse(*found_file);
 358
 359         spl::shared_ptr<core::scene::scene_producer> root(spl::make_shared<core::scene::scene_producer>(doc.width(), doc.height(), dependencies.format_desc));
 360
 361         layer_link_constructor link_constructor;
 362
 363         std::vector<std::pair<std::wstring, spl::shared_ptr<core::text_producer>>> text_producers_by_layer_name;
 364
 365         auto layers_end = doc.layers().end();
 366         for(auto it = doc.layers().begin(); it != layers_end; ++it)
 367         {
 368                 if((*it)->is_visible())
 369                 {
 370                         if((*it)->is_text() && (*it)->sheet_color() == 4)
 371                         {
 372                                 std::wstring str = (*it)->text_data().get(L"EngineDict.Editor.Text", L"");
 373
 374                                 core::text::text_info text_info(std::move(get_text_info((*it)->text_data())));
 375                                 text_info.size *= (*it)->text_scale();
 376
 377                                 auto text_producer = core::text_producer::create(dependencies.frame_factory, 0, 0, str, text_info, doc.width(), doc.height());
 378
 379                                 core::text::string_metrics metrics = text_producer->measure_string(str);
 380
 381                                 auto 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
 382                                 auto adjustment_y = metrics.bearingY;
 383                                 auto& new_layer = root->create_layer(text_producer, (*it)->location().x + adjustment_x, (*it)->location().y + adjustment_y, (*it)->name());
 384                                 new_layer.adjustments.opacity.set((*it)->opacity() / 255.0);
 385                                 new_layer.hidden.set(!(*it)->is_visible());
 386
 387                                 if ((*it)->has_timeline())
 388                                         create_timelines(root, dependencies.format_desc, new_layer, (*it), adjustment_x, adjustment_y);
 389
 390                                 if((*it)->link_group_id() != 0)
 391                                         link_constructor.add(&new_layer, (*it)->link_group_id(), (*it)->is_position_protected(), -adjustment_x, -adjustment_y);
 392
 393                                 text_producers_by_layer_name.push_back(std::make_pair((*it)->name(), text_producer));
 394                         }
 395                         else
 396                         {
 397                                 std::wstring layer_name = (*it)->name();
 398                                 std::shared_ptr<core::frame_producer> layer_producer;
 399                                 if((*it)->is_solid())
 400                                 {
 401                                         layer_producer = core::create_const_producer(core::create_color_frame(it->get(), dependencies.frame_factory, (*it)->solid_color().to_uint32()), (*it)->bitmap()->width(), (*it)->bitmap()->height());
 402                                 }
 403                                 else if((*it)->bitmap())
 404                                 {
 405                                         /*if (boost::algorithm::istarts_with(layer_name, L"[producer]"))
 406                                         {
 407                                                 auto hotswap = std::make_shared<core::hotswap_producer>((*it)->rect().width(), (*it)->rect().height());
 408                                                 hotswap->producer().set(core::create_producer(frame_factory, format_desc, layer_name.substr(10)));
 409                                                 layer_producer = hotswap;
 410                                         }
 411                                         else*/
 412                                         {
 413                                                 core::pixel_format_desc pfd(core::pixel_format::bgra);
 414                                                 pfd.planes.push_back(core::pixel_format_desc::plane((*it)->bitmap()->width(), (*it)->bitmap()->height(), 4));
 415
 416                                                 auto frame = dependencies.frame_factory->create_frame(it->get(), pfd);
 417                                                 memcpy(frame.image_data().data(), (*it)->bitmap()->data(), frame.image_data().size());
 418
 419                                                 layer_producer = core::create_const_producer(core::draw_frame(std::move(frame)), (*it)->bitmap()->width(), (*it)->bitmap()->height());
 420                                         }
 421                                 }
 422
 423                                 if(layer_producer)
 424                                 {
 425                                         auto& new_layer = root->create_layer(spl::make_shared_ptr(layer_producer), (*it)->location().x, (*it)->location().y, (*it)->name());
 426                                         new_layer.adjustments.opacity.set((*it)->opacity() / 255.0);
 427                                         new_layer.hidden.set(!(*it)->is_visible());
 428
 429                                         if ((*it)->has_timeline())
 430                                                 create_timelines(root, dependencies.format_desc, new_layer, (*it), 0, 0);
 431
 432                                         if((*it)->link_group_id() != 0)
 433                                                 link_constructor.add(&new_layer, (*it)->link_group_id(), (*it)->is_position_protected(), 0, 0);
 434                                 }
 435                         }
 436                 }
 437         }
 438
 439         link_constructor.calculate();
 440
 441         // Reset all dynamic text fields to empty strings and expose them as a scene parameter.
 442         for (auto& text_layer : text_producers_by_layer_name)
 443                 text_layer.second->text().bind(root->create_variable<std::wstring>(boost::to_lower_copy(text_layer.first), true, L""));
 444
 445         if (doc.has_timeline())
 446                 create_marks(root, dependencies.format_desc, doc.timeline());
 447
 448         auto params2 = params;
 449         params2.erase(params2.begin());
 450
 451         root->call(params2);
 452
 453         return root;
 454 }
 455
 456 void init(core::module_dependencies dependencies)
 457 {
 458         dependencies.producer_registry->register_producer_factory(create_psd_scene_producer);
 459         dependencies.media_info_repo->register_extractor(
 460                         [](const std::wstring& file, const std::wstring& upper_case_extension, core::media_info& info)
 461                         {
 462                                 if (upper_case_extension == L".PSD")
 463                                 {
 464                                         info.clip_type = L"STILL";
 465
 466                                         return true;
 467                                 }
 468
 469                                 return false;
 470                         });
 471         dependencies.cg_registry->register_cg_producer(
 472                         L"scene",
 473                         { L".psd" },
 474                         [](const std::wstring& filename) { return ""; },
 475                         [](const spl::shared_ptr<core::frame_producer>& producer)
 476                         {
 477                                 return spl::make_shared<core::scene::scene_cg_proxy>(producer);
 478                         },
 479                         [](
 480                                         const core::frame_producer_dependencies& dependencies,
 481                                         const std::wstring& filename)
 482                         {
 483                                 return create_psd_scene_producer(dependencies, { filename });
 484                         },
 485                         false);
 486 }
 487
 488 }}