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 "layer.h"
  24 #include "doc.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/text/text_producer.h>
  30 #include <core/producer/scene/scene_producer.h>
  31 #include <core/producer/scene/const_producer.h>
  32 #include <core/producer/scene/hotswap_producer.h>
  33 #include <core/frame/draw_frame.h>
  34
  35 #include <common/env.h>
  36 #include <common/memory.h>
  37 #include <common/log.h>
  38
  39 #include <boost/filesystem.hpp>
  40 #include <boost/foreach.hpp>
  41 #include <boost/thread/future.hpp>
  42 #include <boost/algorithm/string.hpp>
  43 #include <boost/rational.hpp>
  44
  45 namespace caspar { namespace psd {
  46
  47 void init()
  48 {
  49         core::register_producer_factory(create_psd_scene_producer);
  50 }
  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
  58         int child_index = 0;
  59         auto color_node = ptree.get_child(L"EngineDict.StyleRun.RunArray..StyleSheet.StyleSheetData.FillColor.Values");
  60         for(auto it = color_node.begin(); it != color_node.end(); ++it, ++child_index)
  61         {
  62                 auto& value_node = (*it).second;
  63                 float value = value_node.get_value(0.0f);
  64                 switch(child_index)
  65                 {
  66                 case 0: result.color.a = value; break;
  67                 case 1: result.color.r = value; break;
  68                 case 2: result.color.g = value; break;
  69                 case 3: result.color.b = value; break;
  70                 }
  71         }
  72
  73         //find fontname
  74         child_index = 0;
  75         auto fontset_node = ptree.get_child(L"ResourceDict.FontSet");
  76         for(auto it = fontset_node.begin(); it != fontset_node.end(); ++it, ++child_index)
  77         {
  78                 auto& font_node = (*it).second;
  79                 if(child_index == font_index)
  80                 {
  81                         result.font = font_node.get(L"Name", L"");
  82                         break;
  83                 }
  84         }
  85
  86         return result;
  87 }
  88
  89         class layer_link_constructor
  90         {
  91                 struct linked_layer_record
  92                 {
  93                         caspar::core::scene::layer* layer;
  94                         int link_id;
  95                         bool is_master;
  96                         double adjustment_x;
  97                         double adjustment_y;
  98                 };
  99
 100                 std::vector<linked_layer_record> layers;
 101                 std::vector<linked_layer_record> masters;
 102
 103         public:
 104                 void add(caspar::core::scene::layer* layer, int link_group, bool master, double adjustment_x, double adjustment_y)
 105                 {
 106                         linked_layer_record rec;
 107                         rec.layer = layer;
 108                         rec.link_id = link_group;
 109                         rec.is_master = master;
 110                         rec.adjustment_x = adjustment_x;
 111                         rec.adjustment_y = adjustment_y;
 112                         layers.push_back(rec);
 113
 114                         if(rec.is_master)
 115                         {
 116                                 auto it = std::find_if(masters.begin(), masters.end(), [=](linked_layer_record const &r){ return r.link_id == link_group; });
 117                                 if(it == masters.end())
 118                                         masters.push_back(rec);
 119                                 else
 120                                         masters.erase(it);      //ambigous, two linked layers with locked position
 121                         }
 122                 }
 123
 124                 void calculate()
 125                 {
 126                         for(auto it = masters.begin(); it != masters.end(); ++it)
 127                         {
 128                                 auto& master = (*it);
 129                                 //std::for_each(layers.begin(), layers.end(), [&master](linked_layer_record &r) mutable {
 130                                 BOOST_FOREACH(auto &r, layers) {
 131                                         if(r.link_id == master.link_id && r.layer != master.layer)
 132                                         {
 133                                                 {       //x-coords
 134                                                         double slave_left = r.layer->position.x.get() + r.adjustment_x;
 135                                                         double slave_right = slave_left + r.layer->producer.get()->pixel_constraints().width.get();
 136
 137                                                         double master_left = master.layer->position.x.get() + master.adjustment_x;
 138                                                         double master_right = master_left + master.layer->producer.get()->pixel_constraints().width.get();
 139
 140                                                         if((slave_left >= master_left && slave_right <= master_right) || (slave_left <= master_left && slave_right >= master_right))
 141                                                         {
 142                                                                 //change width of slave
 143                                                                 r.layer->position.x.bind(master.layer->position.x - r.adjustment_x + master.adjustment_x + (slave_left - master_left));
 144                                                                 r.layer->producer.get()->pixel_constraints().width.bind(master.layer->producer.get()->pixel_constraints().width + (slave_right - slave_left - master_right + master_left));
 145                                                         }
 146                                                         else if(slave_left >= master_right)
 147                                                         {
 148                                                                 //push slave ahead of master
 149                                                                 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));
 150                                                         }
 151                                                         else if(slave_right <= master_left)
 152                                                         {
 153                                                                 r.layer->position.x.bind(master.layer->position.x - r.adjustment_x + master.adjustment_x - (master_left - slave_left));
 154                                                         }
 155                                                 }
 156
 157                                                 {       //y-coords
 158                                                         double slave_top = r.layer->position.y.get() + r.adjustment_y;
 159                                                         double slave_bottom = slave_top + r.layer->producer.get()->pixel_constraints().height.get();
 160
 161                                                         double master_top = master.layer->position.y.get() + master.adjustment_y;
 162                                                         double master_bottom = master_top + master.layer->producer.get()->pixel_constraints().height.get();
 163
 164                                                         if((slave_top >= master_top && slave_bottom <= master_bottom) || (slave_top <= master_top && slave_bottom >= master_bottom))
 165                                                         {
 166                                                                 //change height of slave
 167                                                                 r.layer->position.y.bind(master.layer->position.y - r.adjustment_y + master.adjustment_y + (slave_top - master_top));
 168                                                                 r.layer->producer.get()->pixel_constraints().height.bind(master.layer->producer.get()->pixel_constraints().height + (slave_bottom - slave_top - master_bottom + master_top));
 169                                                         }
 170                                                         else if(slave_top >= master_bottom)
 171                                                         {
 172                                                                 //push slave ahead of master
 173                                                                 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));
 174                                                         }
 175                                                         else if(slave_bottom <= master_top)
 176                                                         {
 177                                                                 r.layer->position.y.bind(master.layer->position.y - r.adjustment_y + master.adjustment_y - (master_top - slave_top));
 178                                                         }
 179                                                 }
 180
 181                                         }
 182                                 }
 183                         }
 184                 }
 185         };
 186
 187 int64_t get_frame_number(
 188                 const core::video_format_desc& format_desc,
 189                 const boost::rational<int>& at_second)
 190 {
 191         return static_cast<int64_t>(
 192                         boost::rational_cast<double>(at_second) * format_desc.fps);
 193 }
 194
 195 boost::rational<int> get_rational(const boost::property_tree::wptree& node)
 196 {
 197         return boost::rational<int>(
 198                         node.get<int>(L"numerator"), node.get<int>(L"denominator"));
 199 }
 200
 201 void create_timelines(
 202                 const spl::shared_ptr<core::scene::scene_producer>& scene,
 203                 const core::video_format_desc& format_desc,
 204                 core::scene::layer& layer,
 205                 const layer_ptr& psd_layer,
 206                 double adjustment_x,
 207                 double adjustment_y)
 208 {
 209         auto timeline = psd_layer->timeline_data();
 210         auto start = get_rational(timeline.get_child(L"timeScope.Strt"));
 211         auto end_offset = get_rational(timeline.get_child(L"timeScope.outTime"));
 212         auto end = start + end_offset;
 213         auto start_frame = get_frame_number(format_desc, start);
 214         auto end_frame = get_frame_number(format_desc, end);
 215
 216         layer.hidden = scene->frame() < start_frame || scene->frame() > end_frame;
 217
 218         auto tracklist = timeline.get_child_optional(L"trackList");
 219
 220         if (!tracklist)
 221                 return;
 222
 223         double original_pos_x = psd_layer->rect().left;
 224         double original_pos_y = psd_layer->rect().top;
 225
 226         BOOST_FOREACH(auto& track, *tracklist)
 227         {
 228                 auto track_id = track.second.get<std::wstring>(L"stdTrackID");
 229
 230                 if (track_id == L"sheetPositionTrack")
 231                 {
 232                         BOOST_FOREACH(auto& key, track.second.get_child(L"keyList"))
 233                         {
 234                                 bool tween = key.second.get<std::wstring>(L"animInterpStyle")
 235                                                 == L"Lnr ";
 236                                 auto time = get_rational(key.second.get_child(L"time"));
 237                                 auto hrzn = key.second.get<double>(L"animKey.Hrzn");
 238                                 auto vrtc = key.second.get<double>(L"animKey.Vrtc");
 239                                 auto x = original_pos_x + hrzn + adjustment_x;
 240                                 auto y = original_pos_y + vrtc + adjustment_y;
 241                                 auto frame = get_frame_number(format_desc, time);
 242
 243                                 if (frame == 0) // Consider as initial value (rewind)
 244                                 {
 245                                         layer.position.x.set(x);
 246                                         layer.position.y.set(y);
 247                                 }
 248
 249                                 frame = start_frame + frame; // translate to global timeline
 250
 251                                 if (tween)
 252                                 {
 253                                         scene->add_keyframe(layer.position.x, x, frame, L"easeOutSine");
 254                                         scene->add_keyframe(layer.position.y, y, frame, L"easeOutSine");
 255                                 }
 256                                 else
 257                                 {
 258                                         scene->add_keyframe(layer.position.x, x, frame);
 259                                         scene->add_keyframe(layer.position.y, y, frame);
 260                                 }
 261                         }
 262                 }
 263                 else if (track_id == L"opacityTrack")
 264                 {
 265                         auto& opacity = layer.adjustments.opacity;
 266
 267                         BOOST_FOREACH(auto& key, track.second.get_child(L"keyList"))
 268                         {
 269                                 bool tween = key.second.get<std::wstring>(L"animInterpStyle")
 270                                                 == L"Lnr ";
 271                                 auto time = get_rational(key.second.get_child(L"time"));
 272                                 auto opct = key.second.get<double>(L"animKey.Opct.#Prc") / 100.0;
 273                                 auto frame = get_frame_number(format_desc, time);
 274
 275                                 if (frame == 0) // Consider as initial value (rewind)
 276                                         opacity.set(opct);
 277
 278                                 frame = start_frame + frame; // translate to global timeline
 279
 280                                 if (tween)
 281                                         scene->add_keyframe(opacity, opct, frame, L"easeOutSine");
 282                                 else
 283                                         scene->add_keyframe(opacity, opct, frame);
 284                         }
 285                 }
 286         }
 287 }
 288
 289 spl::shared_ptr<core::frame_producer> create_psd_scene_producer(const spl::shared_ptr<core::frame_factory>& frame_factory, const core::video_format_desc& format_desc, const std::vector<std::wstring>& params)
 290 {
 291         std::wstring filename = env::media_folder() + L"\\" + params[0] + L".psd";
 292         if(!boost::filesystem::is_regular_file(boost::filesystem::path(filename)))
 293                 return core::frame_producer::empty();
 294
 295         psd_document doc;
 296         if(!doc.parse(filename))
 297                 return core::frame_producer::empty();
 298
 299         spl::shared_ptr<core::scene::scene_producer> root(spl::make_shared<core::scene::scene_producer>(doc.width(), doc.height()));
 300
 301         layer_link_constructor link_constructor;
 302
 303         std::vector<std::pair<std::wstring, spl::shared_ptr<core::text_producer>>> text_producers_by_layer_name;
 304
 305         auto layers_end = doc.layers().end();
 306         for(auto it = doc.layers().begin(); it != layers_end; ++it)
 307         {
 308                 if((*it)->is_text() && (*it)->visible())
 309                 {
 310                         std::wstring str = (*it)->text_data().get(L"EngineDict.Editor.Text", L"");
 311
 312                         core::text::text_info text_info(std::move(get_text_info((*it)->text_data())));
 313                         auto text_producer = core::text_producer::create(frame_factory, 0, 0, str, text_info, doc.width(), doc.height());
 314
 315                         core::text::string_metrics metrics = text_producer->measure_string(str);
 316
 317                         auto adjustment_x = -2;
 318                         auto adjustment_y = metrics.bearingY;
 319                         auto& new_layer = root->create_layer(text_producer, (*it)->rect().left + adjustment_x, (*it)->rect().top + adjustment_y, (*it)->name());        //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
 320                         new_layer.adjustments.opacity.set((*it)->opacity() / 255.0);
 321                         new_layer.hidden.set(!(*it)->visible());
 322
 323                         if ((*it)->has_timeline())
 324                                 create_timelines(root, format_desc, new_layer, (*it), adjustment_x, adjustment_y);
 325
 326                         if((*it)->link_group_id() != 0)
 327                                 link_constructor.add(&new_layer, (*it)->link_group_id(), (*it)->is_position_protected(), -adjustment_x, -adjustment_y);
 328
 329                         text_producers_by_layer_name.push_back(std::make_pair((*it)->name(), text_producer));
 330                 }
 331                 else if((*it)->image() && (*it)->visible())
 332                 {
 333                         std::wstring layer_name = (*it)->name();
 334                         std::shared_ptr<core::frame_producer> layer_producer;
 335
 336                         /*if (boost::algorithm::istarts_with(layer_name, L"[producer]"))
 337                         {
 338                                 auto hotswap = std::make_shared<core::hotswap_producer>((*it)->rect().width(), (*it)->rect().height());
 339                                 hotswap->producer().set(core::create_producer(frame_factory, format_desc, layer_name.substr(10)));
 340                                 layer_producer = hotswap;
 341                         }
 342                         else*/
 343                         {
 344                                 core::pixel_format_desc pfd(core::pixel_format::bgra);
 345                                 pfd.planes.push_back(core::pixel_format_desc::plane((*it)->rect().width(), (*it)->rect().height(), 4));
 346
 347                                 auto frame = frame_factory->create_frame(it->get(), pfd);
 348                                 memcpy(frame.image_data().data(), (*it)->image()->data(), frame.image_data().size());
 349
 350                                 layer_producer = core::create_const_producer(core::draw_frame(std::move(frame)), (*it)->rect().width(), (*it)->rect().height());
 351                         }
 352
 353                         auto& new_layer = root->create_layer(spl::make_shared_ptr(layer_producer), (*it)->rect().left, (*it)->rect().top, (*it)->name());
 354                         new_layer.adjustments.opacity.set((*it)->opacity() / 255.0);
 355                         new_layer.hidden.set(!(*it)->visible());
 356
 357                         if ((*it)->has_timeline())
 358                                 create_timelines(root, format_desc, new_layer, (*it), 0, 0);
 359
 360                         if((*it)->link_group_id() != 0)
 361                                 link_constructor.add(&new_layer, (*it)->link_group_id(), (*it)->is_position_protected(), 0, 0);
 362                 }
 363         }
 364
 365         link_constructor.calculate();
 366
 367         // Reset all dynamic text fields to empty strings and expose them as a scene parameter.
 368         BOOST_FOREACH(auto& text_layer, text_producers_by_layer_name)
 369                 text_layer.second->text().bind(root->create_variable<std::wstring>(boost::to_lower_copy(text_layer.first), true, L""));
 370
 371         auto params2 = params;
 372         params2.erase(params2.cbegin());
 373
 374         root->call(params2);
 375
 376         return root;
 377 }
 378
 379 }}