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
23 #include "psd_document.h"
24 #include "descriptor.h"
25 #include "util/pdf_reader.h"
27 #include "../image/util/image_algorithms.h"
28 #include "../image/util/image_view.h"
30 #include <common/log.h>
32 #include <boost/property_tree/ptree.hpp>
33 #include <boost/lexical_cast.hpp>
37 namespace caspar { namespace psd {
39 void layer::layer_mask_info::read_mask_data(bigendian_file_input_stream& stream)
41 unsigned long length = stream.read_long();
48 case 36: //discard total user mask data
49 rect_.location.y = stream.read_long();
50 rect_.location.x = stream.read_long();
51 rect_.size.height = stream.read_long() - rect_.location.y;
52 rect_.size.width = stream.read_long() - rect_.location.x;
54 default_value_ = stream.read_byte();
55 flags_ = stream.read_byte();
56 stream.discard_bytes(2);
60 stream.discard_bytes(18); //discard "total user mask" data
61 //flags_ = stream.read_byte();
62 //default_value_ = stream.read_byte();
63 //rect_.location.y = stream.read_long();
64 //rect_.location.x = stream.read_long();
65 //rect_.size.height = stream.read_long() - rect_.location.y;
66 //rect_.size.width = stream.read_long() - rect_.location.x;
71 //TODO: Log that we discard a mask that is not supported
72 stream.discard_bytes(length);
81 impl() : blend_mode_(blend_mode::InvalidBlendMode), link_group_id_(0), opacity_(255), sheet_color_(0), baseClipping_(false), flags_(0), protection_flags_(0), masks_count_(0), text_scale_(1.0f)
85 std::vector<channel> channels_;
86 blend_mode blend_mode_;
88 unsigned char opacity_;
89 unsigned short sheet_color_;
92 int protection_flags_;
97 rect<long> vector_mask_;
98 layer::layer_mask_info mask_;
100 rect<long> bitmap_rect_;
101 image8bit_ptr bitmap_;
103 boost::property_tree::wptree text_layer_info_;
104 boost::property_tree::wptree timeline_info_;
106 color<unsigned char> solid_color_;
109 void populate(bigendian_file_input_stream& stream, const psd_document& doc)
111 bitmap_rect_.location.y = stream.read_long();
112 bitmap_rect_.location.x = stream.read_long();
113 bitmap_rect_.size.height = stream.read_long() - bitmap_rect_.location.y;
114 bitmap_rect_.size.width = stream.read_long() - bitmap_rect_.location.x;
116 //Get info about the channels in the layer
117 unsigned short channelCount = stream.read_short();
118 for(int channelIndex = 0; channelIndex < channelCount; ++channelIndex)
120 short id = static_cast<short>(stream.read_short());
121 channel c(id, stream.read_long());
126 channels_.push_back(c);
129 unsigned long blendModeSignature = stream.read_long();
130 if(blendModeSignature != '8BIM')
131 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("blendModeSignature != '8BIM'"));
133 blend_mode_ = int_to_blend_mode(stream.read_long());
134 opacity_ = stream.read_byte();
135 baseClipping_ = stream.read_byte() == 1 ? false : true;
136 flags_ = stream.read_byte();
138 stream.discard_bytes(1); //padding
140 unsigned long extras_size = stream.read_long();
141 auto position = stream.current_position();
142 mask_.read_mask_data(stream);
143 read_blending_ranges(stream);
144 name_ = stream.read_pascal_string(4);
146 //Aditional Layer Information
147 auto end_of_layer_info = position + extras_size;
150 while(stream.current_position() < end_of_layer_info)
152 read_chunk(stream, doc);
155 catch(psd_file_format_exception&)
157 stream.set_position(end_of_layer_info);
161 void read_chunk(bigendian_file_input_stream& stream, const psd_document& doc, bool isMetadata = false)
163 auto signature = stream.read_long();
164 if(signature != '8BIM' && signature != '8B64')
165 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("signature != '8BIM' && signature != '8B64'"));
167 auto key = stream.read_long();
169 if(isMetadata) stream.read_long();
171 auto length = stream.read_long();
172 auto end_of_chunk = stream.current_position() + length;
179 read_solid_color(stream);
182 case 'lspf': //protection settings
183 protection_flags_ = stream.read_long();
186 case 'Txt2': //text engine data
190 name_ = stream.read_unicode_string();
193 case 'TySh': //type tool object settings
194 read_text_data(stream);
197 case 'shmd': //metadata
198 read_metadata(stream, doc);
202 sheet_color_ = stream.read_short();
205 case 'lyvr': //layer version
208 case 'lnkD': //linked layer
209 case 'lnk2': //linked layer
210 case 'lnk3': //linked layer
214 read_vector_mask(length, stream, doc.width(), doc.height());
218 read_timeline_data(stream);
225 catch(psd_file_format_exception& ex)
227 //ignore failed chunks silently
228 CASPAR_LOG(warning) << ex.what();
231 stream.set_position(end_of_chunk);
234 void read_solid_color(bigendian_file_input_stream& stream)
236 if(stream.read_long() != 16) //"descriptor version" should be 16
237 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("descriptor version should be 16"));
239 descriptor solid_descriptor;
240 solid_descriptor.populate(stream);
241 solid_color_.red = static_cast<unsigned char>(solid_descriptor.items().get(L"Clr .Rd ", 0.0) + 0.5);
242 solid_color_.green = static_cast<unsigned char>(solid_descriptor.items().get(L"Clr .Grn ", 0.0) + 0.5);
243 solid_color_.blue = static_cast<unsigned char>(solid_descriptor.items().get(L"Clr .Bl ", 0.0) + 0.5);
244 solid_color_.alpha = 255;
247 void read_vector_mask(unsigned long length, bigendian_file_input_stream& stream, long doc_width, long doc_height)
249 typedef std::pair<unsigned long, unsigned long> path_point;
251 stream.read_long(); // version
252 stream.read_long(); // flags
253 int path_records = (length-8) / 26;
255 auto position = stream.current_position();
257 std::vector<path_point> knots;
258 for(int i=1; i <= path_records; ++i)
260 auto selector = stream.read_short();
261 if(selector == 2) //we only concern ourselves with closed paths
263 auto p_y = stream.read_long();
264 auto p_x = stream.read_long();
265 path_point cp_prev(p_x, p_y);
267 auto a_y = stream.read_long();
268 auto a_x = stream.read_long();
269 path_point anchor(a_x, a_y);
271 auto n_y = stream.read_long();
272 auto n_x = stream.read_long();
273 path_point cp_next(n_x, n_y);
275 if(anchor == cp_prev && anchor == cp_next)
276 knots.push_back(anchor);
278 { //we can't handle smooth curves yet
279 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("we can't handle smooth curves yet"));
283 stream.set_position(position + 26*i);
286 if(knots.size() != 4) //we only support rectangular vector masks
287 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("we only support rectangular vector masks"));
289 //we only support rectangular vector masks
290 if(!(knots[0].first == knots[3].first && knots[1].first == knots[2].first && knots[0].second == knots[1].second && knots[2].second == knots[3].second))
291 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("we only support rectangular vector masks"));
293 //the path_points are given in fixed-point 8.24 as a ratio with regards to the width/height of the document. we need to divide by 16777215.0f to get the real ratio.
294 float x_ratio = doc_width / 16777215.0f;
295 float y_ratio = doc_height / 16777215.0f;
296 vector_mask_.location.x = static_cast<long>(knots[0].first * x_ratio +0.5f); //add .5 to get propper rounding when converting to integer
297 vector_mask_.location.y = static_cast<long>(knots[0].second * y_ratio +0.5f); //add .5 to get propper rounding when converting to integer
298 vector_mask_.size.width = static_cast<long>(knots[1].first * x_ratio +0.5f) - vector_mask_.location.x; //add .5 to get propper rounding when converting to integer
299 vector_mask_.size.height = static_cast<long>(knots[2].second * y_ratio +0.5f) - vector_mask_.location.y; //add .5 to get propper rounding when converting to integer
302 void read_metadata(bigendian_file_input_stream& stream, const psd_document& doc)
304 auto count = stream.read_long();
305 for(unsigned long index = 0; index < count; ++index)
306 read_chunk(stream, doc, true);
309 void read_timeline_data(bigendian_file_input_stream& stream)
311 if(stream.read_long() != 16) //"descriptor version" should be 16
312 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("descriptor version should be 16"));
314 descriptor timeline_descriptor;
315 timeline_descriptor.populate(stream);
316 timeline_info_.swap(timeline_descriptor.items());
319 void read_text_data(bigendian_file_input_stream& stream)
321 std::wstring text; //the text in the layer
323 stream.read_short(); //should be 1
325 //transformation info
326 auto xx = stream.read_double();
327 auto xy = stream.read_double();
328 auto yx = stream.read_double();
329 auto yy = stream.read_double();
330 stream.read_double(); // tx
331 stream.read_double(); // ty
332 if(xx != yy || (xy != 0 && yx != 0))
333 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("Rotation and non-uniform scaling of dynamic textfields is not supported yet"));
335 text_scale_ = static_cast<float>(xx);
337 if(stream.read_short() != 50) //"text version" should be 50
338 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("invalid text version"));
340 if(stream.read_long() != 16) //"descriptor version" should be 16
341 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("Invalid descriptor version while reading text-data"));
343 descriptor text_descriptor;
344 text_descriptor.populate(stream);
345 auto text_info = text_descriptor.items().get_optional<std::wstring>(L"EngineData");
346 if(text_info.is_initialized())
348 std::string str(text_info.get().begin(), text_info.get().end());
349 read_pdf(text_layer_info_, str);
352 if(stream.read_short() != 1) //"warp version" should be 1
353 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("invalid warp version"));
355 if(stream.read_long() != 16) //"descriptor version" should be 16
356 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("Invalid descriptor version while reading text warp-data"));
358 descriptor warp_descriptor;
359 warp_descriptor.populate(stream);
360 stream.read_double(); // w_top
361 stream.read_double(); // w_left
362 stream.read_double(); // w_right
363 stream.read_double(); // w_bottom
367 void read_blending_ranges(bigendian_file_input_stream& stream)
369 auto length = stream.read_long();
370 stream.discard_bytes(length);
373 bool has_channel(channel_type type)
375 return std::find_if(channels_.begin(), channels_.end(), [=](const channel& c) { return c.id == static_cast<int>(type); }) != channels_.end();
378 void read_channel_data(bigendian_file_input_stream& stream)
380 image8bit_ptr bitmap;
383 bool has_transparency = has_channel(channel_type::transparency);
385 rect<long> clip_rect;
386 if(!bitmap_rect_.empty())
388 clip_rect = bitmap_rect_;
390 if(!vector_mask_.empty())
391 clip_rect = vector_mask_;
393 bitmap = std::make_shared<image8bit>(clip_rect.size.width, clip_rect.size.height, 4);
395 if(!has_transparency)
396 std::memset(bitmap->data(), 255, bitmap->width()*bitmap->height()*bitmap->channel_count());
399 if(masks_count_ > 0 && !mask_.rect_.empty())
401 mask = std::make_shared<image8bit>(mask_.rect_.size.width, mask_.rect_.size.height, 1);
404 for(auto it = channels_.begin(); it != channels_.end(); ++it)
406 psd::rect<long> src_rect;
407 image8bit_ptr target;
408 unsigned char offset = 0;
409 bool discard_channel = false;
411 //determine target bitmap and offset
413 discard_channel = true; //discard channels that doesn't contribute to the final image
414 else if((*it).id >= -1) //BGRA-data
417 offset = static_cast<unsigned char>(((*it).id >= 0) ? 2 - (*it).id : 3);
418 src_rect = bitmap_rect_;
422 if((*it).id == -3) //discard the "total user mask"
423 discard_channel = true;
428 src_rect = mask_.rect_;
432 if(!target || src_rect.empty())
433 discard_channel = true;
435 auto end_of_data = stream.current_position() + (*it).data_length;
438 auto encoding = stream.read_short();
442 read_raw_image_data(stream, (*it).data_length-2, target, offset);
443 else if(encoding == 1)
444 read_rle_image_data(stream, src_rect, (target == bitmap) ? clip_rect : mask_.rect_, target, offset);
446 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("Unhandled image data encoding: " + boost::lexical_cast<std::string>(encoding)));
449 stream.set_position(end_of_data);
452 if(bitmap && has_transparency)
454 caspar::image::image_view<caspar::image::bgra_pixel> view(bitmap->data(), bitmap->width(), bitmap->height());
455 caspar::image::premultiply(view);
459 bitmap_rect_ = clip_rect;
460 mask_.bitmap_ = mask;
463 void read_raw_image_data(bigendian_file_input_stream& stream, unsigned long data_length, image8bit_ptr target, unsigned char offset)
465 unsigned long total_length = target->width() * target->height();
466 if(total_length != data_length)
467 CASPAR_THROW_EXCEPTION(psd_file_format_exception() << msg_info("total_length != data_length"));
469 auto data = target->data();
471 auto stride = target->channel_count();
473 stream.read(reinterpret_cast<char*>(data + offset), total_length);
476 for(unsigned long index=0; index < total_length; ++index)
477 data[index*stride+offset] = stream.read_byte();
481 void read_rle_image_data(bigendian_file_input_stream& stream, const rect<long>&src_rect, const rect<long>&clip_rect, image8bit_ptr target, unsigned char offset)
483 auto width = src_rect.size.width;
484 auto height = src_rect.size.height;
485 auto stride = target->channel_count();
487 int offset_x = clip_rect.location.x - src_rect.location.x;
488 int offset_y = clip_rect.location.y - src_rect.location.y;
490 std::vector<unsigned short> scanline_lengths;
491 scanline_lengths.reserve(height);
493 for (long scanlineIndex = 0; scanlineIndex < height; ++scanlineIndex)
494 scanline_lengths.push_back(stream.read_short());
496 auto target_data = target->data();
498 std::vector<unsigned char> line(width);
500 for(long scanlineIndex=0; scanlineIndex < height; ++scanlineIndex)
502 if(scanlineIndex >= target->height()+offset_y)
509 unsigned char length = 0;
512 char controlByte = static_cast<char>(stream.read_byte());
515 //Read uncompressed string
516 length = controlByte+1;
517 for(unsigned long index=0; index < length; ++index)
518 line[colIndex+index] = stream.read_byte();
520 else if(controlByte > -128)
523 length = -controlByte+1;
524 unsigned char value = stream.read_byte();
525 for(unsigned long index=0; index < length; ++index)
526 line[colIndex+index] = value;
531 while(colIndex < width);
533 //use line to populate target
534 if(scanlineIndex >= offset_y)
535 for(int index = offset_x; index < target->width(); ++index)
537 target_data[((scanlineIndex-offset_y)*target->width()+index-offset_x) * stride + offset] = line[index];
543 layer::layer() : impl_(spl::make_shared<impl>()) {}
545 void layer::populate(bigendian_file_input_stream& stream, const psd_document& doc) { impl_->populate(stream, doc); }
546 void layer::read_channel_data(bigendian_file_input_stream& stream) { impl_->read_channel_data(stream); }
548 const std::wstring& layer::name() const { return impl_->name_; }
549 unsigned char layer::opacity() const { return impl_->opacity_; }
550 unsigned short layer::sheet_color() const { return impl_->sheet_color_; }
552 bool layer::is_visible() { return (impl_->flags_ & 2) == 0; } //the (PSD file-format) documentation is is saying the opposite but what the heck
553 bool layer::is_position_protected() { return (impl_->protection_flags_& 4) == 4; }
555 float layer::text_scale() const { return impl_->text_scale_; }
556 bool layer::is_text() const { return !impl_->text_layer_info_.empty(); }
557 const boost::property_tree::wptree& layer::text_data() const { return impl_->text_layer_info_; }
559 bool layer::has_timeline() const { return !impl_->timeline_info_.empty(); }
560 const boost::property_tree::wptree& layer::timeline_data() const { return impl_->timeline_info_; }
562 bool layer::is_solid() const { return impl_->solid_color_.alpha != 0; }
563 color<unsigned char> layer::solid_color() const { return impl_->solid_color_; }
565 const point<long>& layer::location() const { return impl_->bitmap_rect_.location; }
566 const image8bit_ptr& layer::bitmap() const { return impl_->bitmap_; }
568 int layer::link_group_id() const { return impl_->link_group_id_; }
569 void layer::set_link_group_id(int id) { impl_->link_group_id_ = id; }