/*
- Copyright (C) 2012 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2016 Carl Hetherington <cth@carlh.net>
- This program is free software; you can redistribute it and/or modify
+ This file is part of libdcp.
+
+ libdcp is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
- This program is distributed in the hope that it will be useful,
+ libdcp is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
+ along with libdcp. If not, see <http://www.gnu.org/licenses/>.
+
+ In addition, as a special exception, the copyright holders give
+ permission to link the code of portions of this program with the
+ OpenSSL library under certain conditions as described in each
+ individual source file, and distribute linked combinations
+ including the two.
+
+ You must obey the GNU General Public License in all respects
+ for all of the code used other than OpenSSL. If you modify
+ file(s) with this exception, you may extend this exception to your
+ version of the file(s), but you are not obligated to do so. If you
+ do not wish to do so, delete this exception statement from your
+ version. If you delete this exception statement from all source
+ files in the program, then also delete it here.
*/
-#include <boost/lexical_cast.hpp>
+#include "raw_convert.h"
+#include "compose.hpp"
#include "subtitle_asset.h"
-
-using namespace std;
-using namespace boost;
-using namespace libdcp;
-
-SubtitleAsset::SubtitleAsset (string directory, string xml)
- : Asset (directory, xml)
- , XMLFile (path().string(), "DCSubtitle")
+#include "subtitle_asset_internal.h"
+#include "util.h"
+#include "xml.h"
+#include "subtitle_string.h"
+#include "dcp_assert.h"
+#include <asdcp/AS_DCP.h>
+#include <asdcp/KM_util.h>
+#include <libxml++/nodes/element.h>
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/shared_array.hpp>
+#include <boost/foreach.hpp>
+
+using std::string;
+using std::list;
+using std::cout;
+using std::cerr;
+using std::map;
+using std::distance;
+using boost::shared_ptr;
+using boost::shared_array;
+using boost::optional;
+using boost::dynamic_pointer_cast;
+using boost::lexical_cast;
+using namespace dcp;
+
+SubtitleAsset::SubtitleAsset ()
{
- _subtitle_id = string_node ("SubtitleID");
- _movie_title = string_node ("MovieTitle");
- _reel_number = int64_node ("ReelNumber");
- _language = string_node ("Language");
- ignore_node ("LoadFont");
+}
- list<shared_ptr<FontNode> > font_nodes = sub_nodes<FontNode> ("Font");
- _load_font_nodes = sub_nodes<LoadFontNode> ("LoadFont");
+SubtitleAsset::SubtitleAsset (boost::filesystem::path file)
+ : Asset (file)
+{
- /* Now make Subtitle objects to represent the raw XML nodes
- in a sane way.
- */
+}
- list<shared_ptr<FontNode> > current_font_nodes;
- list<shared_ptr<SubtitleNode> > current_subtitle_nodes;
- current_subtitle_nodes.push_back (shared_ptr<SubtitleNode> ());
- examine_font_nodes (font_nodes, current_font_nodes, current_subtitle_nodes);
+string
+string_attribute (xmlpp::Element const * node, string name)
+{
+ xmlpp::Attribute* a = node->get_attribute (name);
+ if (!a) {
+ throw XMLError (String::compose ("missing attribute %1", name));
+ }
+ return string (a->get_value ());
}
-void
-SubtitleAsset::examine_font_nodes (
- list<shared_ptr<FontNode> > const & font_nodes,
- list<shared_ptr<FontNode> >& current_font_nodes,
- list<shared_ptr<SubtitleNode> >& current_subtitle_nodes
- )
+optional<string>
+optional_string_attribute (xmlpp::Element const * node, string name)
{
- for (list<shared_ptr<FontNode> >::const_iterator i = font_nodes.begin(); i != font_nodes.end(); ++i) {
-
- current_font_nodes.push_back (*i);
-
- for (list<shared_ptr<SubtitleNode> >::iterator j = (*i)->subtitle_nodes.begin(); j != (*i)->subtitle_nodes.end(); ++j) {
- current_subtitle_nodes.push_back (*j);
- examine_text_nodes (*j, (*j)->text_nodes, current_font_nodes);
- examine_font_nodes ((*j)->font_nodes, current_font_nodes, current_subtitle_nodes);
- current_subtitle_nodes.pop_back ();
- }
-
- examine_font_nodes ((*i)->font_nodes, current_font_nodes, current_subtitle_nodes);
- examine_text_nodes (current_subtitle_nodes.back (), (*i)->text_nodes, current_font_nodes);
-
- current_font_nodes.pop_back ();
+ xmlpp::Attribute* a = node->get_attribute (name);
+ if (!a) {
+ return optional<string>();
}
+ return string (a->get_value ());
}
-void
-SubtitleAsset::examine_text_nodes (
- shared_ptr<SubtitleNode> subtitle_node,
- list<shared_ptr<TextNode> > const & text_nodes,
- list<shared_ptr<FontNode> >& current_font_nodes
- )
+optional<bool>
+optional_bool_attribute (xmlpp::Element const * node, string name)
{
- for (list<shared_ptr<TextNode> >::const_iterator i = text_nodes.begin(); i != text_nodes.end(); ++i) {
- FontNode effective (current_font_nodes);
- _subtitles.push_back (
- shared_ptr<Subtitle> (
- new Subtitle (
- font_id_to_name (effective.id),
- effective.italic.get(),
- effective.color.get(),
- effective.size,
- subtitle_node->in,
- subtitle_node->out,
- (*i)->v_position,
- (*i)->v_align,
- (*i)->text,
- effective.effect.get(),
- effective.effect_color.get(),
- subtitle_node->fade_up_time,
- subtitle_node->fade_down_time
- )
- )
- );
+ optional<string> s = optional_string_attribute (node, name);
+ if (!s) {
+ return optional<bool> ();
}
+
+ return (s.get() == "1" || s.get() == "yes");
}
-FontNode::FontNode (xmlpp::Node const * node)
- : XMLNode (node)
+template <class T>
+optional<T>
+optional_number_attribute (xmlpp::Element const * node, string name)
{
- id = optional_string_attribute ("Id");
- size = optional_int64_attribute ("Size");
- italic = optional_bool_attribute ("Italic");
- color = optional_color_attribute ("Color");
- string const e = optional_string_attribute ("Effect");
- if (e == "none") {
- effect = NONE;
- } else if (e == "border") {
- effect = BORDER;
- } else if (e == "shadow") {
- effect = SHADOW;
- } else if (!e.empty ()) {
- throw DCPReadError ("unknown subtitle effect type");
- }
- effect_color = optional_color_attribute ("EffectColor");
- subtitle_nodes = sub_nodes<SubtitleNode> ("Subtitle");
- font_nodes = sub_nodes<FontNode> ("Font");
- text_nodes = sub_nodes<TextNode> ("Text");
+ boost::optional<std::string> s = optional_string_attribute (node, name);
+ if (!s) {
+ return boost::optional<T> ();
+ }
+
+ std::string t = s.get ();
+ boost::erase_all (t, " ");
+ return raw_convert<T> (t);
}
-FontNode::FontNode (list<shared_ptr<FontNode> > const & font_nodes)
- : size (0)
- , italic (false)
- , color ("FFFFFFFF")
- , effect_color ("FFFFFFFF")
+SubtitleAsset::ParseState
+SubtitleAsset::font_node_state (xmlpp::Element const * node, Standard standard) const
{
- for (list<shared_ptr<FontNode> >::const_iterator i = font_nodes.begin(); i != font_nodes.end(); ++i) {
- if (!(*i)->id.empty ()) {
- id = (*i)->id;
- }
- if ((*i)->size != 0) {
- size = (*i)->size;
- }
- if ((*i)->italic) {
- italic = (*i)->italic.get ();
- }
- if ((*i)->color) {
- color = (*i)->color.get ();
- }
- if ((*i)->effect) {
- effect = (*i)->effect.get ();
- }
- if ((*i)->effect_color) {
- effect_color = (*i)->effect_color.get ();
- }
+ ParseState ps;
+
+ if (standard == INTEROP) {
+ ps.font_id = optional_string_attribute (node, "Id");
+ } else {
+ ps.font_id = optional_string_attribute (node, "ID");
}
+ ps.size = optional_number_attribute<int64_t> (node, "Size");
+ ps.aspect_adjust = optional_number_attribute<float> (node, "AspectAdjust");
+ ps.italic = optional_bool_attribute (node, "Italic");
+ ps.bold = optional_string_attribute(node, "Weight").get_value_or("normal") == "bold";
+ if (standard == INTEROP) {
+ ps.underline = optional_bool_attribute (node, "Underlined");
+ } else {
+ ps.underline = optional_bool_attribute (node, "Underline");
+ }
+ optional<string> c = optional_string_attribute (node, "Color");
+ if (c) {
+ ps.colour = Colour (c.get ());
+ }
+ optional<string> const e = optional_string_attribute (node, "Effect");
+ if (e) {
+ ps.effect = string_to_effect (e.get ());
+ }
+ c = optional_string_attribute (node, "EffectColor");
+ if (c) {
+ ps.effect_colour = Colour (c.get ());
+ }
+
+ return ps;
}
-LoadFontNode::LoadFontNode (xmlpp::Node const * node)
- : XMLNode (node)
+SubtitleAsset::ParseState
+SubtitleAsset::text_node_state (xmlpp::Element const * node) const
{
- id = string_attribute ("Id");
- uri = string_attribute ("URI");
+ ParseState ps;
+
+ optional<float> hp = optional_number_attribute<float> (node, "HPosition");
+ if (!hp) {
+ hp = optional_number_attribute<float> (node, "Hposition");
+ }
+ if (hp) {
+ ps.h_position = hp.get () / 100;
+ }
+
+ optional<string> ha = optional_string_attribute (node, "HAlign");
+ if (!ha) {
+ ha = optional_string_attribute (node, "Halign");
+ }
+ if (ha) {
+ ps.h_align = string_to_halign (ha.get ());
+ }
+
+ optional<float> vp = optional_number_attribute<float> (node, "VPosition");
+ if (!vp) {
+ vp = optional_number_attribute<float> (node, "Vposition");
+ }
+ if (vp) {
+ ps.v_position = vp.get () / 100;
+ }
+
+ optional<string> va = optional_string_attribute (node, "VAlign");
+ if (!va) {
+ va = optional_string_attribute (node, "Valign");
+ }
+ if (va) {
+ ps.v_align = string_to_valign (va.get ());
+ }
+
+ optional<string> d = optional_string_attribute (node, "Direction");
+ if (d) {
+ ps.direction = string_to_direction (d.get ());
+ }
+
+ return ps;
}
-
-SubtitleNode::SubtitleNode (xmlpp::Node const * node)
- : XMLNode (node)
+SubtitleAsset::ParseState
+SubtitleAsset::subtitle_node_state (xmlpp::Element const * node, optional<int> tcr) const
{
- in = time_attribute ("TimeIn");
- out = time_attribute ("TimeOut");
- font_nodes = sub_nodes<FontNode> ("Font");
- text_nodes = sub_nodes<TextNode> ("Text");
- fade_up_time = fade_time ("FadeUpTime");
- fade_down_time = fade_time ("FadeDownTime");
+ ParseState ps;
+ ps.in = Time (string_attribute(node, "TimeIn"), tcr);
+ ps.out = Time (string_attribute(node, "TimeOut"), tcr);
+ ps.fade_up_time = fade_time (node, "FadeUpTime", tcr);
+ ps.fade_down_time = fade_time (node, "FadeDownTime", tcr);
+ return ps;
}
Time
-SubtitleNode::fade_time (string name)
+SubtitleAsset::fade_time (xmlpp::Element const * node, string name, optional<int> tcr) const
{
- string const u = optional_string_attribute (name);
+ string const u = optional_string_attribute(node, name).get_value_or ("");
Time t;
-
+
if (u.empty ()) {
- t = Time (0, 0, 0, 20);
+ t = Time (0, 0, 0, 20, 250);
} else if (u.find (":") != string::npos) {
- t = Time (u);
+ t = Time (u, tcr);
} else {
- t = Time (0, 0, 0, lexical_cast<int> (u));
+ t = Time (0, 0, 0, lexical_cast<int> (u), tcr.get_value_or(250));
}
- if (t > Time (0, 0, 8, 0)) {
- t = Time (0, 0, 8, 0);
+ if (t > Time (0, 0, 8, 0, 250)) {
+ t = Time (0, 0, 8, 0, 250);
}
return t;
}
-TextNode::TextNode (xmlpp::Node const * node)
- : XMLNode (node)
- , v_align (CENTER)
+void
+SubtitleAsset::parse_subtitles (xmlpp::Element const * node, list<ParseState>& state, optional<int> tcr, Standard standard)
{
- text = content ();
- v_position = float_attribute ("VPosition");
- string const v = optional_string_attribute ("VAlign");
- if (v == "top") {
- v_align = TOP;
- } else if (v == "center") {
- v_align = CENTER;
- } else if (v == "bottom") {
- v_align = BOTTOM;
+ if (node->get_name() == "Font") {
+ state.push_back (font_node_state (node, standard));
+ } else if (node->get_name() == "Subtitle") {
+ state.push_back (subtitle_node_state (node, tcr));
+ } else if (node->get_name() == "Text") {
+ state.push_back (text_node_state (node));
+ } else if (node->get_name() == "SubtitleList") {
+ state.push_back (ParseState ());
+ } else {
+ throw XMLError ("unexpected node " + node->get_name());
}
-}
-
-list<shared_ptr<Subtitle> >
-SubtitleAsset::subtitles_at (Time t) const
-{
- list<shared_ptr<Subtitle> > s;
- for (list<shared_ptr<Subtitle> >::const_iterator i = _subtitles.begin(); i != _subtitles.end(); ++i) {
- if ((*i)->in() <= t && t <= (*i)->out ()) {
- s.push_back (*i);
+ xmlpp::Node::NodeList c = node->get_children ();
+ for (xmlpp::Node::NodeList::const_iterator i = c.begin(); i != c.end(); ++i) {
+ xmlpp::ContentNode const * v = dynamic_cast<xmlpp::ContentNode const *> (*i);
+ if (v) {
+ maybe_add_subtitle (v->get_content(), state);
+ }
+ xmlpp::Element const * e = dynamic_cast<xmlpp::Element const *> (*i);
+ if (e) {
+ parse_subtitles (e, state, tcr, standard);
}
}
- return s;
+ state.pop_back ();
}
-std::string
-SubtitleAsset::font_id_to_name (string id) const
+void
+SubtitleAsset::maybe_add_subtitle (string text, list<ParseState> const & parse_state)
{
- list<shared_ptr<LoadFontNode> >::const_iterator i = _load_font_nodes.begin();
- while (i != _load_font_nodes.end() && (*i)->id != id) {
- ++i;
+ if (empty_or_white_space (text)) {
+ return;
}
- if (i == _load_font_nodes.end ()) {
- return "";
+ ParseState ps;
+ BOOST_FOREACH (ParseState const & i, parse_state) {
+ if (i.font_id) {
+ ps.font_id = i.font_id.get();
+ }
+ if (i.size) {
+ ps.size = i.size.get();
+ }
+ if (i.aspect_adjust) {
+ ps.aspect_adjust = i.aspect_adjust.get();
+ }
+ if (i.italic) {
+ ps.italic = i.italic.get();
+ }
+ if (i.bold) {
+ ps.bold = i.bold.get();
+ }
+ if (i.underline) {
+ ps.underline = i.underline.get();
+ }
+ if (i.colour) {
+ ps.colour = i.colour.get();
+ }
+ if (i.effect) {
+ ps.effect = i.effect.get();
+ }
+ if (i.effect_colour) {
+ ps.effect_colour = i.effect_colour.get();
+ }
+ if (i.h_position) {
+ ps.h_position = i.h_position.get();
+ }
+ if (i.h_align) {
+ ps.h_align = i.h_align.get();
+ }
+ if (i.v_position) {
+ ps.v_position = i.v_position.get();
+ }
+ if (i.v_align) {
+ ps.v_align = i.v_align.get();
+ }
+ if (i.direction) {
+ ps.direction = i.direction.get();
+ }
+ if (i.in) {
+ ps.in = i.in.get();
+ }
+ if (i.out) {
+ ps.out = i.out.get();
+ }
+ if (i.fade_up_time) {
+ ps.fade_up_time = i.fade_up_time.get();
+ }
+ if (i.fade_down_time) {
+ ps.fade_down_time = i.fade_down_time.get();
+ }
}
- if ((*i)->uri == "arial.ttf") {
- return "Arial";
+ if (!ps.in || !ps.out) {
+ /* We're not in a <Text> node; just ignore this content */
+ return;
}
- return "";
+ _subtitles.push_back (
+ SubtitleString (
+ ps.font_id,
+ ps.italic.get_value_or (false),
+ ps.bold.get_value_or (false),
+ ps.underline.get_value_or (false),
+ ps.colour.get_value_or (dcp::Colour (255, 255, 255)),
+ ps.size.get_value_or (42),
+ ps.aspect_adjust.get_value_or (1.0),
+ ps.in.get(),
+ ps.out.get(),
+ ps.h_position.get_value_or(0),
+ ps.h_align.get_value_or(HALIGN_CENTER),
+ ps.v_position.get_value_or(0),
+ ps.v_align.get_value_or(VALIGN_CENTER),
+ ps.direction.get_value_or (DIRECTION_LTR),
+ text,
+ ps.effect.get_value_or (NONE),
+ ps.effect_colour.get_value_or (dcp::Colour (255, 255, 255)),
+ ps.fade_up_time.get_value_or(Time()),
+ ps.fade_down_time.get_value_or(Time())
+ )
+ );
}
-Subtitle::Subtitle (
- string font,
- bool italic,
- Color color,
- int size,
- Time in,
- Time out,
- float v_position,
- VAlign v_align,
- string text,
- Effect effect,
- Color effect_color,
- Time fade_up_time,
- Time fade_down_time
- )
- : _font (font)
- , _italic (italic)
- , _color (color)
- , _size (size)
- , _in (in)
- , _out (out)
- , _v_position (v_position)
- , _v_align (v_align)
- , _text (text)
- , _effect (effect)
- , _effect_color (effect_color)
- , _fade_up_time (fade_up_time)
- , _fade_down_time (fade_down_time)
+list<SubtitleString>
+SubtitleAsset::subtitles_during (Time from, Time to, bool starting) const
{
+ list<SubtitleString> s;
+ BOOST_FOREACH (SubtitleString const & i, _subtitles) {
+ if ((starting && from <= i.in() && i.in() < to) || (!starting && i.out() >= from && i.in() <= to)) {
+ s.push_back (i);
+ }
+ }
+ return s;
}
-int
-Subtitle::size_in_pixels (int screen_height) const
+void
+SubtitleAsset::add (SubtitleString s)
{
- /* Size in the subtitle file is given in points as if the screen
- height is 11 inches, so a 72pt font would be 1/11th of the screen
- height.
- */
-
- return _size * screen_height / (11 * 72);
+ _subtitles.push_back (s);
+}
+
+Time
+SubtitleAsset::latest_subtitle_out () const
+{
+ Time t;
+ BOOST_FOREACH (SubtitleString const & i, _subtitles) {
+ if (i.out() > t) {
+ t = i.out ();
+ }
+ }
+
+ return t;
}
bool
-libdcp::operator== (Subtitle const & a, Subtitle const & b)
+SubtitleAsset::equals (shared_ptr<const Asset> other_asset, EqualityOptions options, NoteHandler note) const
{
- return (
- a.font() == b.font() &&
- a.italic() == b.italic() &&
- a.color() == b.color() &&
- a.size() == b.size() &&
- a.in() == b.in() &&
- a.out() == b.out() &&
- a.v_position() == b.v_position() &&
- a.v_align() == b.v_align() &&
- a.text() == b.text() &&
- a.effect() == b.effect() &&
- a.effect_color() == b.effect_color() &&
- a.fade_up_time() == b.fade_up_time() &&
- a.fade_down_time() == b.fade_down_time()
- );
+ if (!Asset::equals (other_asset, options, note)) {
+ return false;
+ }
+
+ shared_ptr<const SubtitleAsset> other = dynamic_pointer_cast<const SubtitleAsset> (other_asset);
+ if (!other) {
+ return false;
+ }
+
+ if (_subtitles != other->_subtitles) {
+ note (DCP_ERROR, "subtitles differ");
+ return false;
+ }
+
+ return true;
}
-ostream&
-libdcp::operator<< (ostream& s, Subtitle const & sub)
+struct SubtitleSorter
{
- s << "\n`" << sub.text() << "' from " << sub.in() << " to " << sub.out() << ";\n"
- << "fade up " << sub.fade_up_time() << ", fade down " << sub.fade_down_time() << ";\n"
- << "font " << sub.font() << ", ";
+ bool operator() (SubtitleString const & a, SubtitleString const & b) {
+ if (a.in() != b.in()) {
+ return a.in() < b.in();
+ }
+ return a.v_position() < b.v_position();
+ }
+};
- if (sub.italic()) {
- s << "italic";
- } else {
- s << "non-italic";
+void
+SubtitleAsset::pull_fonts (shared_ptr<order::Part> part)
+{
+ if (part->children.empty ()) {
+ return;
}
-
- s << ", size " << sub.size() << ", color " << sub.color() << ", vpos " << sub.v_position() << ", valign " << ((int) sub.v_align()) << ";\n"
- << "effect " << ((int) sub.effect()) << ", effect color " << sub.effect_color();
- return s;
+ /* Pull up from children */
+ BOOST_FOREACH (shared_ptr<order::Part> i, part->children) {
+ pull_fonts (i);
+ }
+
+ if (part->parent) {
+ /* Establish the common font features that each of part's children have;
+ these features go into part's font.
+ */
+ part->font = part->children.front()->font;
+ BOOST_FOREACH (shared_ptr<order::Part> i, part->children) {
+ part->font.take_intersection (i->font);
+ }
+
+ /* Remove common values from part's children's fonts */
+ BOOST_FOREACH (shared_ptr<order::Part> i, part->children) {
+ i->font.take_difference (part->font);
+ }
+ }
+
+ /* Merge adjacent children with the same font */
+ list<shared_ptr<order::Part> >::const_iterator i = part->children.begin();
+ list<shared_ptr<order::Part> > merged;
+
+ while (i != part->children.end()) {
+
+ if ((*i)->font.empty ()) {
+ merged.push_back (*i);
+ ++i;
+ } else {
+ list<shared_ptr<order::Part> >::const_iterator j = i;
+ ++j;
+ while (j != part->children.end() && (*i)->font == (*j)->font) {
+ ++j;
+ }
+ if (distance (i, j) == 1) {
+ merged.push_back (*i);
+ ++i;
+ } else {
+ shared_ptr<order::Part> group (new order::Part (part, (*i)->font));
+ for (list<shared_ptr<order::Part> >::const_iterator k = i; k != j; ++k) {
+ (*k)->font.clear ();
+ group->children.push_back (*k);
+ }
+ merged.push_back (group);
+ i = j;
+ }
+ }
+ }
+
+ part->children = merged;
+}
+
+/** @param standard Standard (INTEROP or SMPTE); this is used rather than putting things in the child
+ * class because the differences between the two are fairly subtle.
+ */
+void
+SubtitleAsset::subtitles_as_xml (xmlpp::Element* xml_root, int time_code_rate, Standard standard) const
+{
+ list<SubtitleString> sorted = _subtitles;
+ sorted.sort (SubtitleSorter ());
+
+ /* Gather our subtitles into a hierarchy of Subtitle/Text/String objects, writing
+ font information into the bottom level (String) objects.
+ */
+
+ shared_ptr<order::Part> root (new order::Part (shared_ptr<order::Part> ()));
+ shared_ptr<order::Subtitle> subtitle;
+ shared_ptr<order::Text> text;
+
+ Time last_in;
+ Time last_out;
+ Time last_fade_up_time;
+ Time last_fade_down_time;
+ HAlign last_h_align;
+ float last_h_position;
+ VAlign last_v_align;
+ float last_v_position;
+ Direction last_direction;
+
+ BOOST_FOREACH (SubtitleString const & i, sorted) {
+ if (!subtitle ||
+ (last_in != i.in() ||
+ last_out != i.out() ||
+ last_fade_up_time != i.fade_up_time() ||
+ last_fade_down_time != i.fade_down_time())
+ ) {
+
+ subtitle.reset (new order::Subtitle (root, i.in(), i.out(), i.fade_up_time(), i.fade_down_time()));
+ root->children.push_back (subtitle);
+
+ last_in = i.in ();
+ last_out = i.out ();
+ last_fade_up_time = i.fade_up_time ();
+ last_fade_down_time = i.fade_down_time ();
+ text.reset ();
+ }
+
+ if (!text ||
+ last_h_align != i.h_align() ||
+ fabs(last_h_position - i.h_position()) > ALIGN_EPSILON ||
+ last_v_align != i.v_align() ||
+ fabs(last_v_position - i.v_position()) > ALIGN_EPSILON ||
+ last_direction != i.direction()
+ ) {
+
+ text.reset (new order::Text (subtitle, i.h_align(), i.h_position(), i.v_align(), i.v_position(), i.direction()));
+ subtitle->children.push_back (text);
+
+ last_h_align = i.h_align ();
+ last_h_position = i.h_position ();
+ last_v_align = i.v_align ();
+ last_v_position = i.v_position ();
+ last_direction = i.direction ();
+ }
+
+ text->children.push_back (shared_ptr<order::String> (new order::String (text, order::Font (i, standard), i.text())));
+ }
+
+ /* Pull font changes as high up the hierarchy as we can */
+
+ pull_fonts (root);
+
+ /* Write XML */
+
+ order::Context context;
+ context.time_code_rate = time_code_rate;
+ context.standard = standard;
+ context.spot_number = 1;
+
+ root->write_xml (xml_root, context);
+}
+
+map<string, Data>
+SubtitleAsset::fonts_with_load_ids () const
+{
+ map<string, Data> out;
+ BOOST_FOREACH (Font const & i, _fonts) {
+ out[i.load_id] = i.data;
+ }
+ return out;
}
projects / libdcp.git / blobdiff