/*
- Copyright (C) 2012 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2015 Carl Hetherington <cth@carlh.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-#include <fstream>
-#include <boost/lexical_cast.hpp>
+#include "raw_convert.h"
#include "subtitle_asset.h"
#include "util.h"
+#include "xml.h"
+#include "font_node.h"
+#include "text_node.h"
+#include "subtitle_string.h"
+#include "dcp_assert.h"
+#include "AS_DCP.h"
+#include "KM_util.h"
+#include <libxml++/nodes/element.h>
+#include <boost/algorithm/string.hpp>
+#include <boost/shared_array.hpp>
+#include <boost/foreach.hpp>
+#include <fstream>
using std::string;
using std::list;
using std::ostream;
using std::ofstream;
using std::stringstream;
+using std::cout;
+using std::cerr;
+using std::map;
using boost::shared_ptr;
-using boost::lexical_cast;
-using namespace libdcp;
+using boost::shared_array;
+using boost::optional;
+using boost::dynamic_pointer_cast;
+using namespace dcp;
-SubtitleAsset::SubtitleAsset (string directory, string xml_file)
- : Asset (directory, xml_file)
+SubtitleAsset::SubtitleAsset ()
{
- read_xml (path().string());
+
}
-SubtitleAsset::SubtitleAsset (string directory, string movie_title, string language)
- : Asset (directory)
- , _movie_title (movie_title)
- , _reel_number ("1")
- , _language (language)
+SubtitleAsset::SubtitleAsset (boost::filesystem::path file)
+ : Asset (file)
{
}
void
-SubtitleAsset::read_xml (string xml_file)
+SubtitleAsset::parse_subtitles (
+ shared_ptr<cxml::Document> xml,
+ list<shared_ptr<dcp::FontNode> > font_nodes,
+ list<shared_ptr<dcp::SubtitleNode> > subtitle_nodes
+ )
{
- shared_ptr<XMLFile> xml (new XMLFile (xml_file, "DCSubtitle"));
-
- _uuid = xml->string_child ("SubtitleID");
- _movie_title = xml->string_child ("MovieTitle");
- _reel_number = xml->string_child ("ReelNumber");
- _language = xml->string_child ("Language");
-
- xml->ignore_child ("LoadFont");
-
- list<shared_ptr<FontNode> > font_nodes = xml->type_children<FontNode> ("Font");
- _load_font_nodes = xml->type_children<LoadFontNode> ("LoadFont");
-
- /* Now make Subtitle objects to represent the raw XML nodes
- in a sane way.
- */
-
+ /* Make Subtitle objects to represent the raw XML nodes in a sane way */
ParseState parse_state;
- examine_font_nodes (xml, font_nodes, parse_state);
+ examine_nodes (xml, font_nodes, parse_state);
+ examine_nodes (xml, subtitle_nodes, parse_state);
}
void
-SubtitleAsset::examine_font_nodes (
- shared_ptr<XMLFile> xml,
- list<shared_ptr<FontNode> > const & font_nodes,
+SubtitleAsset::examine_nodes (
+ shared_ptr<const cxml::Node> xml,
+ list<shared_ptr<dcp::SubtitleNode> > const & subtitle_nodes,
ParseState& parse_state
)
{
- for (list<shared_ptr<FontNode> >::const_iterator i = font_nodes.begin(); i != font_nodes.end(); ++i) {
+ BOOST_FOREACH (shared_ptr<dcp::SubtitleNode> i, subtitle_nodes) {
+ parse_state.subtitle_nodes.push_back (i);
+ examine_nodes (xml, i->text_nodes, parse_state);
+ examine_nodes (xml, i->font_nodes, parse_state);
+ parse_state.subtitle_nodes.pop_back ();
+ }
+}
- parse_state.font_nodes.push_back (*i);
- maybe_add_subtitle ((*i)->text, parse_state);
+void
+SubtitleAsset::examine_nodes (
+ shared_ptr<const cxml::Node> xml,
+ list<shared_ptr<dcp::FontNode> > const & font_nodes,
+ ParseState& parse_state
+ )
+{
+ BOOST_FOREACH (shared_ptr<dcp::FontNode> i, font_nodes) {
+
+ parse_state.font_nodes.push_back (i);
+ maybe_add_subtitle (i->text, parse_state);
+
+ examine_nodes (xml, i->subtitle_nodes, parse_state);
+ examine_nodes (xml, i->font_nodes, parse_state);
+ examine_nodes (xml, i->text_nodes, parse_state);
- for (list<shared_ptr<SubtitleNode> >::iterator j = (*i)->subtitle_nodes.begin(); j != (*i)->subtitle_nodes.end(); ++j) {
- parse_state.subtitle_nodes.push_back (*j);
- examine_text_nodes (xml, (*j)->text_nodes, parse_state);
- examine_font_nodes (xml, (*j)->font_nodes, parse_state);
- parse_state.subtitle_nodes.pop_back ();
- }
-
- examine_font_nodes (xml, (*i)->font_nodes, parse_state);
- examine_text_nodes (xml, (*i)->text_nodes, parse_state);
-
parse_state.font_nodes.pop_back ();
}
}
void
-SubtitleAsset::examine_text_nodes (
- shared_ptr<XMLFile> xml,
- list<shared_ptr<TextNode> > const & text_nodes,
+SubtitleAsset::examine_nodes (
+ shared_ptr<const cxml::Node> xml,
+ list<shared_ptr<dcp::TextNode> > const & text_nodes,
ParseState& parse_state
)
{
- for (list<shared_ptr<TextNode> >::const_iterator i = text_nodes.begin(); i != text_nodes.end(); ++i) {
- parse_state.text_nodes.push_back (*i);
- maybe_add_subtitle ((*i)->text, parse_state);
- examine_font_nodes (xml, (*i)->font_nodes, parse_state);
+ BOOST_FOREACH (shared_ptr<dcp::TextNode> i, text_nodes) {
+ parse_state.text_nodes.push_back (i);
+ maybe_add_subtitle (i->text, parse_state);
+ examine_nodes (xml, i->font_nodes, parse_state);
parse_state.text_nodes.pop_back ();
}
}
if (empty_or_white_space (text)) {
return;
}
-
+
if (parse_state.text_nodes.empty() || parse_state.subtitle_nodes.empty ()) {
return;
}
- assert (!parse_state.text_nodes.empty ());
- assert (!parse_state.subtitle_nodes.empty ());
-
- FontNode effective_font (parse_state.font_nodes);
- TextNode effective_text (*parse_state.text_nodes.back ());
- SubtitleNode effective_subtitle (*parse_state.subtitle_nodes.back ());
+ DCP_ASSERT (!parse_state.text_nodes.empty ());
+ DCP_ASSERT (!parse_state.subtitle_nodes.empty ());
+
+ dcp::FontNode effective_font (parse_state.font_nodes);
+ dcp::TextNode effective_text (*parse_state.text_nodes.back ());
+ dcp::SubtitleNode effective_subtitle (*parse_state.subtitle_nodes.back ());
_subtitles.push_back (
- shared_ptr<Subtitle> (
- new Subtitle (
- font_id_to_name (effective_font.id),
- effective_font.italic.get(),
- effective_font.color.get(),
- effective_font.size,
- effective_subtitle.in,
- effective_subtitle.out,
- effective_text.v_position,
- effective_text.v_align,
- text,
- effective_font.effect ? effective_font.effect.get() : NONE,
- effective_font.effect_color.get(),
- effective_subtitle.fade_up_time,
- effective_subtitle.fade_down_time
- )
+ SubtitleString (
+ effective_font.id,
+ effective_font.italic.get_value_or (false),
+ effective_font.bold.get_value_or (false),
+ effective_font.colour.get_value_or (dcp::Colour (255, 255, 255)),
+ effective_font.size,
+ effective_font.aspect_adjust.get_value_or (1.0),
+ effective_subtitle.in,
+ effective_subtitle.out,
+ effective_text.h_position,
+ effective_text.h_align,
+ effective_text.v_position,
+ effective_text.v_align,
+ effective_text.direction,
+ text,
+ effective_font.effect.get_value_or (NONE),
+ effective_font.effect_colour.get_value_or (dcp::Colour (0, 0, 0)),
+ effective_subtitle.fade_up_time,
+ effective_subtitle.fade_down_time
)
);
}
-FontNode::FontNode (xmlpp::Node const * node)
- : XMLNode (node)
+list<SubtitleString>
+SubtitleAsset::subtitles_during (Time from, Time to, bool starting) const
{
- text = content ();
-
- 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.empty ()) {
- effect = string_to_effect (e);
- }
- effect_color = optional_color_attribute ("EffectColor");
- subtitle_nodes = type_children<SubtitleNode> ("Subtitle");
- font_nodes = type_children<FontNode> ("Font");
- text_nodes = type_children<TextNode> ("Text");
-}
-
-FontNode::FontNode (list<shared_ptr<FontNode> > const & font_nodes)
- : size (0)
- , italic (false)
- , color ("FFFFFFFF")
- , effect_color ("FFFFFFFF")
-{
- 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 ();
+ 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);
}
}
-}
-LoadFontNode::LoadFontNode (xmlpp::Node const * node)
- : XMLNode (node)
-{
- id = string_attribute ("Id");
- uri = string_attribute ("URI");
+ return s;
}
-
-SubtitleNode::SubtitleNode (xmlpp::Node const * node)
- : XMLNode (node)
+void
+SubtitleAsset::add (SubtitleString s)
{
- in = time_attribute ("TimeIn");
- out = time_attribute ("TimeOut");
- font_nodes = type_children<FontNode> ("Font");
- text_nodes = type_children<TextNode> ("Text");
- fade_up_time = fade_time ("FadeUpTime");
- fade_down_time = fade_time ("FadeDownTime");
+ _subtitles.push_back (s);
}
Time
-SubtitleNode::fade_time (string name)
+SubtitleAsset::latest_subtitle_out () const
{
- string const u = optional_string_attribute (name);
Time t;
-
- if (u.empty ()) {
- t = Time (0, 0, 0, 20);
- } else if (u.find (":") != string::npos) {
- t = Time (u);
- } else {
- t = Time (0, 0, 0, lexical_cast<int> (u));
- }
-
- if (t > Time (0, 0, 8, 0)) {
- t = Time (0, 0, 8, 0);
- }
-
- return t;
-}
-
-TextNode::TextNode (xmlpp::Node const * node)
- : XMLNode (node)
- , v_align (CENTER)
-{
- text = content ();
- v_position = float_attribute ("VPosition");
- string const v = optional_string_attribute ("VAlign");
- if (!v.empty ()) {
- v_align = string_to_valign (v);
- }
-
- font_nodes = type_children<FontNode> ("Font");
-}
-
-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);
+ BOOST_FOREACH (SubtitleString const & i, _subtitles) {
+ if (i.out() > t) {
+ t = i.out ();
}
}
- return s;
+ return t;
}
-std::string
-SubtitleAsset::font_id_to_name (string id) const
+bool
+SubtitleAsset::equals (shared_ptr<const Asset> other_asset, EqualityOptions options, NoteHandler note) const
{
- list<shared_ptr<LoadFontNode> >::const_iterator i = _load_font_nodes.begin();
- while (i != _load_font_nodes.end() && (*i)->id != id) {
- ++i;
+ if (!Asset::equals (other_asset, options, note)) {
+ return false;
}
- if (i == _load_font_nodes.end ()) {
- return "";
+ shared_ptr<const SubtitleAsset> other = dynamic_pointer_cast<const SubtitleAsset> (other_asset);
+ if (!other) {
+ return false;
}
- if ((*i)->uri == "arial.ttf") {
- return "Arial";
+ if (_subtitles != other->_subtitles) {
+ note (DCP_ERROR, "subtitles differ");
+ return false;
}
- return "";
-}
-
-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)
-{
-
-}
-
-int
-Subtitle::size_in_pixels (int screen_height) const
-{
- /* 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);
-}
-
-bool
-libdcp::operator== (Subtitle const & a, Subtitle const & b)
-{
- 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()
- );
-}
-
-ostream&
-libdcp::operator<< (ostream& s, Subtitle const & sub)
-{
- 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() << ", ";
-
- if (sub.italic()) {
- s << "italic";
- } else {
- s << "non-italic";
- }
-
- 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;
-}
-
-void
-SubtitleAsset::add (shared_ptr<Subtitle> s)
-{
- _subtitles.push_back (s);
-}
-
-void
-SubtitleAsset::write_to_cpl (ostream& s) const
-{
- /* XXX: should EditRate, Duration and IntrinsicDuration be in here? */
-
- s << " <MainSubtitle>\n"
- << " <Id>urn:uuid:" << _uuid << "</Id>\n"
- << " <AnnotationText>" << _file_name << "</AnnotationText>\n"
- << " <EntryPoint>0</EntryPoint>\n"
- << " </MainSubtitle>\n";
+ return true;
}
struct SubtitleSorter {
- bool operator() (shared_ptr<Subtitle> a, shared_ptr<Subtitle> b) {
- if (a->in() != b->in()) {
- return a->in() < b->in();
+ 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();
+ return a.v_position() < b.v_position();
}
};
+/** @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::write_xml ()
-{
- ofstream f (path().string().c_str());
- write_xml (f);
-}
-
-void
-SubtitleAsset::write_xml (ostream& s)
+SubtitleAsset::subtitles_as_xml (xmlpp::Element* root, int time_code_rate, Standard standard) const
{
- s << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- << "<DCSubtitle Version=\"1.0\">\n"
- << " <SubtitleID>" << _uuid << "</SubtitleID>\n"
- << " <MovieTitle>" << _movie_title << "</MovieTitle>\n"
- << " <ReelNumber>" << _reel_number << "</ReelNumber>\n"
- << " <Language>" << _language << "</Language>\n"
- << " <LoadFont Id=\"theFontId\" URI=\"arial.ttf\"/>\n";
+ list<SubtitleString> sorted = _subtitles;
+ sorted.sort (SubtitleSorter ());
- _subtitles.sort (SubtitleSorter ());
+ string const xmlns = standard == SMPTE ? "dcst" : "";
- /* XXX: multiple fonts not supported */
- /* XXX: script, underlined, weight not supported */
+ /* XXX: script, underlined not supported */
- bool first = true;
+ optional<string> font;
bool italic = false;
- Color color;
+ bool bold = false;
+ Colour colour;
int size = 0;
+ float aspect_adjust = 1.0;
Effect effect = NONE;
- Color effect_color;
+ Colour effect_colour;
int spot_number = 1;
Time last_in;
Time last_out;
Time last_fade_up_time;
Time last_fade_down_time;
- for (list<shared_ptr<Subtitle> >::iterator i = _subtitles.begin(); i != _subtitles.end(); ++i) {
+ xmlpp::Element* font_element = 0;
+ xmlpp::Element* subtitle_element = 0;
+
+ BOOST_FOREACH (SubtitleString const & i, sorted) {
/* We will start a new <Font>...</Font> whenever some font property changes.
- I suppose should really make an optimal hierarchy of <Font> tags, but
+ I suppose we should really make an optimal hierarchy of <Font> tags, but
that seems hard.
*/
- bool const font_changed = first ||
- italic != (*i)->italic() ||
- color != (*i)->color() ||
- size != (*i)->size() ||
- effect != (*i)->effect() ||
- effect_color != (*i)->effect_color();
+ bool const font_changed =
+ font != i.font() ||
+ italic != i.italic() ||
+ bold != i.bold() ||
+ colour != i.colour() ||
+ size != i.size() ||
+ fabs (aspect_adjust - i.aspect_adjust()) > ASPECT_ADJUST_EPSILON ||
+ effect != i.effect() ||
+ effect_colour != i.effect_colour();
- stringstream a;
if (font_changed) {
- italic = (*i)->italic ();
- a << "Italic=\"" << (italic ? "yes" : "no") << "\" ";
- color = (*i)->color ();
- a << "Color=\"" << color.to_argb_string() << "\" ";
- size = (*i)->size ();
- a << "Size=\"" << size << "\" ";
- effect = (*i)->effect ();
- a << "Effect=\"" << effect_to_string(effect) << "\" ";
- effect_color = (*i)->effect_color ();
- a << "EffectColor=\"" << effect_color.to_argb_string() << "\" ";
- a << "Script=\"normal\" Underlined=\"no\" Weight=\"normal\"";
+ font = i.font ();
+ italic = i.italic ();
+ bold = i.bold ();
+ colour = i.colour ();
+ size = i.size ();
+ aspect_adjust = i.aspect_adjust ();
+ effect = i.effect ();
+ effect_colour = i.effect_colour ();
}
- if (first ||
- (last_in != (*i)->in() ||
- last_out != (*i)->out() ||
- last_fade_up_time != (*i)->fade_up_time() ||
- last_fade_down_time != (*i)->fade_down_time()
+ if (!font_element || font_changed) {
+ font_element = root->add_child ("Font", xmlns);
+ if (font) {
+ if (standard == SMPTE) {
+ font_element->set_attribute ("ID", font.get ());
+ } else {
+ font_element->set_attribute ("Id", font.get ());
+ }
+ }
+ font_element->set_attribute ("Italic", italic ? "yes" : "no");
+ font_element->set_attribute ("Color", colour.to_argb_string());
+ font_element->set_attribute ("Size", raw_convert<string> (size));
+ if (fabs (aspect_adjust - 1.0) > ASPECT_ADJUST_EPSILON) {
+ font_element->set_attribute ("AspectAdjust", raw_convert<string> (aspect_adjust));
+ }
+ font_element->set_attribute ("Effect", effect_to_string (effect));
+ font_element->set_attribute ("EffectColor", effect_colour.to_argb_string());
+ font_element->set_attribute ("Script", "normal");
+ if (standard == SMPTE) {
+ font_element->set_attribute ("Underline", "no");
+ } else {
+ font_element->set_attribute ("Underlined", "no");
+ }
+ font_element->set_attribute ("Weight", bold ? "bold" : "normal");
+ }
+
+ if (!subtitle_element || font_changed ||
+ (last_in != i.in() ||
+ last_out != i.out() ||
+ last_fade_up_time != i.fade_up_time() ||
+ last_fade_down_time != i.fade_down_time()
)) {
- if (!first) {
- s << " </Subtitle>\n";
+ subtitle_element = font_element->add_child ("Subtitle", xmlns);
+ subtitle_element->set_attribute ("SpotNumber", raw_convert<string> (spot_number++));
+ subtitle_element->set_attribute ("TimeIn", i.in().rebase(time_code_rate).as_string(standard));
+ subtitle_element->set_attribute ("TimeOut", i.out().rebase(time_code_rate).as_string(standard));
+ if (standard == SMPTE) {
+ subtitle_element->set_attribute ("FadeUpTime", i.fade_up_time().rebase(time_code_rate).as_string(standard));
+ subtitle_element->set_attribute ("FadeDownTime", i.fade_down_time().rebase(time_code_rate).as_string(standard));
+ } else {
+ subtitle_element->set_attribute ("FadeUpTime", raw_convert<string> (i.fade_up_time().as_editable_units(time_code_rate)));
+ subtitle_element->set_attribute ("FadeDownTime", raw_convert<string> (i.fade_down_time().as_editable_units(time_code_rate)));
}
- if (font_changed) {
- if (!first) {
- s << " </Font>\n";
- }
- s << " <Font Id=\"theFontId\" " << a.str() << ">\n";
+ last_in = i.in ();
+ last_out = i.out ();
+ last_fade_up_time = i.fade_up_time ();
+ last_fade_down_time = i.fade_down_time ();
+ }
+
+ xmlpp::Element* text = subtitle_element->add_child ("Text", xmlns);
+
+ if (i.h_align() != HALIGN_CENTER) {
+ if (standard == SMPTE) {
+ text->set_attribute ("Halign", halign_to_string (i.h_align ()));
+ } else {
+ text->set_attribute ("HAlign", halign_to_string (i.h_align ()));
}
+ }
+
+ if (i.h_position() > ALIGN_EPSILON) {
+ if (standard == SMPTE) {
+ text->set_attribute ("Hposition", raw_convert<string> (i.h_position() * 100, 6));
+ } else {
+ text->set_attribute ("HPosition", raw_convert<string> (i.h_position() * 100, 6));
+ }
+ }
- s << " <Subtitle "
- << "SpotNumber=\"" << spot_number++ << "\" "
- << "TimeIn=\"" << (*i)->in().to_string() << "\" "
- << "TimeOut=\"" << (*i)->out().to_string() << "\" "
- << "FadeUpTime=\"" << (*i)->fade_up_time().to_ticks() << "\" "
- << "FadeDownTime=\"" << (*i)->fade_down_time().to_ticks() << "\""
- << ">\n";
-
- last_in = (*i)->in ();
- last_out = (*i)->out ();
- last_fade_up_time = (*i)->fade_up_time ();
- last_fade_down_time = (*i)->fade_down_time ();
+ if (standard == SMPTE) {
+ text->set_attribute ("Valign", valign_to_string (i.v_align()));
+ } else {
+ text->set_attribute ("VAlign", valign_to_string (i.v_align()));
}
- s << " <Text "
- << "VAlign=\"" << valign_to_string ((*i)->v_align()) << "\" "
- << "VPosition=\"" << (*i)->v_position() << "\""
- << ">" << (*i)->text() << "</Text>\n";
+ if (i.v_position() > ALIGN_EPSILON) {
+ if (standard == SMPTE) {
+ text->set_attribute ("Vposition", raw_convert<string> (i.v_position() * 100, 6));
+ } else {
+ text->set_attribute ("VPosition", raw_convert<string> (i.v_position() * 100, 6));
+ }
+ } else {
+ if (standard == SMPTE) {
+ text->set_attribute ("Vposition", "0");
+ } else {
+ text->set_attribute ("VPosition", "0");
+ }
+ }
- first = false;
+ /* Interop only supports "horizontal" or "vertical" for direction, so only write this
+ for SMPTE.
+ */
+ if (i.direction() != DIRECTION_LTR && standard == SMPTE) {
+ text->set_attribute ("Direction", direction_to_string (i.direction ()));
+ }
+
+ text->add_child_text (i.text());
}
+}
- s << " </Subtitle>\n";
- s << " </Font>\n";
- s << "</DCSubtitle>\n";
+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