/*
- Copyright (C) 2012-2016 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
This file is part of libdcp.
files in the program, then also delete it here.
*/
+
+/** @file src/subtitle_asset.cc
+ * @brief SubtitleAsset class
+ */
+
+
#include "raw_convert.h"
#include "compose.hpp"
#include "subtitle_asset.h"
#include "util.h"
#include "xml.h"
#include "subtitle_string.h"
+#include "subtitle_image.h"
#include "dcp_assert.h"
+#include "load_font_node.h"
+#include "reel_asset.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>
+#include <algorithm>
+
-using std::string;
-using std::list;
-using std::cout;
using std::cerr;
+using std::cout;
+using std::dynamic_pointer_cast;
+using std::make_shared;
using std::map;
-using std::distance;
-using boost::shared_ptr;
-using boost::shared_array;
-using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::pair;
+using std::shared_ptr;
+using std::string;
+using std::vector;
using boost::lexical_cast;
+using boost::optional;
using namespace dcp;
+
SubtitleAsset::SubtitleAsset ()
{
}
+
SubtitleAsset::SubtitleAsset (boost::filesystem::path file)
: Asset (file)
{
}
+
string
string_attribute (xmlpp::Element const * node, string name)
{
- xmlpp::Attribute* a = node->get_attribute (name);
+ auto a = node->get_attribute (name);
if (!a) {
throw XMLError (String::compose ("missing attribute %1", name));
}
return string (a->get_value ());
}
+
optional<string>
optional_string_attribute (xmlpp::Element const * node, string name)
{
- xmlpp::Attribute* a = node->get_attribute (name);
+ auto a = node->get_attribute (name);
if (!a) {
- return optional<string>();
+ return {};
}
return string (a->get_value ());
}
+
optional<bool>
optional_bool_attribute (xmlpp::Element const * node, string name)
{
- optional<string> s = optional_string_attribute (node, name);
+ auto s = optional_string_attribute (node, name);
if (!s) {
- return optional<bool> ();
+ return {};
}
return (s.get() == "1" || s.get() == "yes");
}
+
template <class T>
optional<T>
optional_number_attribute (xmlpp::Element const * node, string name)
{
- boost::optional<std::string> s = optional_string_attribute (node, name);
+ auto s = optional_string_attribute (node, name);
if (!s) {
return boost::optional<T> ();
}
return raw_convert<T> (t);
}
+
SubtitleAsset::ParseState
SubtitleAsset::font_node_state (xmlpp::Element const * node, Standard standard) const
{
ParseState ps;
- if (standard == INTEROP) {
+ if (standard == Standard::INTEROP) {
ps.font_id = optional_string_attribute (node, "Id");
} else {
ps.font_id = optional_string_attribute (node, "ID");
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) {
+ if (standard == 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");
+ auto c = optional_string_attribute (node, "Color");
if (c) {
ps.colour = Colour (c.get ());
}
- optional<string> const e = optional_string_attribute (node, "Effect");
+ auto const e = optional_string_attribute (node, "Effect");
if (e) {
ps.effect = string_to_effect (e.get ());
}
return ps;
}
-SubtitleAsset::ParseState
-SubtitleAsset::text_node_state (xmlpp::Element const * node) const
+void
+SubtitleAsset::position_align (SubtitleAsset::ParseState& ps, xmlpp::Element const * node) const
{
- ParseState ps;
-
- optional<float> hp = optional_number_attribute<float> (node, "HPosition");
+ auto hp = optional_number_attribute<float> (node, "HPosition");
if (!hp) {
hp = optional_number_attribute<float> (node, "Hposition");
}
ps.h_position = hp.get () / 100;
}
- optional<string> ha = optional_string_attribute (node, "HAlign");
+ auto ha = optional_string_attribute (node, "HAlign");
if (!ha) {
ha = optional_string_attribute (node, "Halign");
}
ps.h_align = string_to_halign (ha.get ());
}
- optional<float> vp = optional_number_attribute<float> (node, "VPosition");
+ auto vp = optional_number_attribute<float> (node, "VPosition");
if (!vp) {
vp = optional_number_attribute<float> (node, "Vposition");
}
ps.v_position = vp.get () / 100;
}
- optional<string> va = optional_string_attribute (node, "VAlign");
+ auto va = optional_string_attribute (node, "VAlign");
if (!va) {
va = optional_string_attribute (node, "Valign");
}
ps.v_align = string_to_valign (va.get ());
}
- optional<string> d = optional_string_attribute (node, "Direction");
+ auto zp = optional_number_attribute<float>(node, "Zposition");
+ if (zp) {
+ ps.z_position = zp.get() / 100;
+ }
+}
+
+
+SubtitleAsset::ParseState
+SubtitleAsset::text_node_state (xmlpp::Element const * node) const
+{
+ ParseState ps;
+
+ position_align (ps, node);
+
+ auto d = optional_string_attribute (node, "Direction");
if (d) {
ps.direction = string_to_direction (d.get ());
}
+ ps.type = ParseState::Type::TEXT;
+
return ps;
}
+
+SubtitleAsset::ParseState
+SubtitleAsset::image_node_state (xmlpp::Element const * node) const
+{
+ ParseState ps;
+
+ position_align (ps, node);
+
+ ps.type = ParseState::Type::IMAGE;
+
+ return ps;
+}
+
+
SubtitleAsset::ParseState
SubtitleAsset::subtitle_node_state (xmlpp::Element const * node, optional<int> tcr) const
{
return ps;
}
+
Time
SubtitleAsset::fade_time (xmlpp::Element const * node, string name, optional<int> tcr) const
{
- string const u = optional_string_attribute(node, name).get_value_or ("");
+ auto const u = optional_string_attribute(node, name).get_value_or ("");
Time t;
if (u.empty ()) {
return t;
}
+
void
-SubtitleAsset::parse_subtitles (xmlpp::Element const * node,
list<ParseState>& state, optional<int> tcr, Standard standard)
+SubtitleAsset::parse_subtitles (xmlpp::Element const * node,
vector<ParseState>& state, optional<int> tcr, Standard standard)
{
if (node->get_name() == "Font") {
state.push_back (font_node_state (node, standard));
state.push_back (text_node_state (node));
} else if (node->get_name() == "SubtitleList") {
state.push_back (ParseState ());
+ } else if (node->get_name() == "Image") {
+ state.push_back (image_node_state (node));
} else {
throw XMLError ("unexpected node " + node->get_name());
}
- 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);
+ float space_before = 0;
+
+ for (auto i: node->get_children()) {
+ auto const v = dynamic_cast<xmlpp::ContentNode const *>(i);
if (v) {
- maybe_add_subtitle (v->get_content(), state);
+ maybe_add_subtitle (v->get_content(), state, space_before, standard);
+ space_before = 0;
}
- xmlpp::Element const * e = dynamic_cast<xmlpp::Element const *> (*i);
+ auto const e = dynamic_cast<xmlpp::Element const *>(i);
if (e) {
- parse_subtitles (e, state, tcr, standard);
+ if (e->get_name() == "Space") {
+ if (node->get_name() != "Text") {
+ throw XMLError ("Space node found outside Text");
+ }
+ auto size = optional_string_attribute(e, "Size").get_value_or("0.5");
+ if (standard == dcp::Standard::INTEROP) {
+ boost::replace_all(size, "em", "");
+ }
+ space_before += raw_convert<float>(size);
+ } else {
+ parse_subtitles (e, state, tcr, standard);
+ }
}
}
state.pop_back ();
}
+
void
-SubtitleAsset::maybe_add_subtitle (string text, list<ParseState> const & parse_state)
+SubtitleAsset::maybe_add_subtitle (string text, vector<ParseState> const & parse_state, float space_before, Standard standard)
{
- if (empty_or_white_space (text)) {
+ auto wanted = [](ParseState const& ps) {
+ return ps.type && (ps.type.get() == ParseState::Type::TEXT || ps.type.get() == ParseState::Type::IMAGE);
+ };
+
+ if (find_if(parse_state.begin(), parse_state.end(), wanted) == parse_state.end()) {
return;
}
ParseState ps;
- BOOST_FOREACH (ParseState const & i, parse_state) {
+ for (auto const& i: parse_state) {
if (i.font_id) {
ps.font_id = i.font_id.get();
}
if (i.v_align) {
ps.v_align = i.v_align.get();
}
+ if (i.z_position) {
+ ps.z_position = i.z_position.get();
+ }
if (i.direction) {
ps.direction = i.direction.get();
}
if (i.fade_down_time) {
ps.fade_down_time = i.fade_down_time.get();
}
+ if (i.type) {
+ ps.type = i.type.get();
+ }
}
if (!ps.in || !ps.out) {
- /* We're not in a <Text> node; just ignore this content */
+ /* We're not in a <Subtitle> node; just ignore this content */
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 (0, 0, 0)),
- ps.fade_up_time.get_value_or(Time()),
- ps.fade_down_time.get_value_or(Time())
- )
- );
+ DCP_ASSERT (ps.type);
+
+ switch (ps.type.get()) {
+ case ParseState::Type::TEXT:
+ _subtitles.push_back (
+ make_shared<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.z_position.get_value_or(0),
+ ps.direction.get_value_or (Direction::LTR),
+ text,
+ ps.effect.get_value_or (Effect::NONE),
+ ps.effect_colour.get_value_or (dcp::Colour (0, 0, 0)),
+ ps.fade_up_time.get_value_or(Time()),
+ ps.fade_down_time.get_value_or(Time()),
+ space_before
+ )
+ );
+ break;
+ case ParseState::Type::IMAGE:
+ {
+ switch (standard) {
+ case Standard::INTEROP:
+ if (text.size() >= 4) {
+ /* Remove file extension */
+ text = text.substr(0, text.size() - 4);
+ }
+ break;
+ case Standard::SMPTE:
+ /* It looks like this urn:uuid: is required, but DoM wasn't expecting it (and not writing it)
+ * until around 2.15.140 so I guess either:
+ * a) it is not (always) used in the field, or
+ * b) nobody noticed / complained.
+ */
+ if (text.substr(0, 9) == "urn:uuid:") {
+ text = text.substr(9);
+ }
+ break;
+ }
+
+ /* Add a subtitle with no image data and we'll fill that in later */
+ _subtitles.push_back (
+ make_shared<SubtitleImage>(
+ ArrayData(),
+ text,
+ 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.z_position.get_value_or(0),
+ ps.fade_up_time.get_value_or(Time()),
+ ps.fade_down_time.get_value_or(Time())
+ )
+ );
+ break;
+ }
+ }
+}
+
+
+vector<shared_ptr<const Subtitle>>
+SubtitleAsset::subtitles () const
+{
+ vector<shared_ptr<const Subtitle>> s;
+ for (auto i: _subtitles) {
+ s.push_back (i);
+ }
+ return s;
}
-list<SubtitleString>
+
+vector<shared_ptr<const Subtitle>>
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)) {
+ vector<shared_ptr<const Subtitle>> s;
+ for (auto i: _subtitles) {
+ if ((starting && from <= i->in() && i->in() < to) || (!starting && i->out() >= from && i->in() <= to)) {
s.push_back (i);
}
}
return s;
}
+
+/* XXX: this needs a test */
+vector<shared_ptr<const Subtitle>>
+SubtitleAsset::subtitles_in_reel (shared_ptr<const dcp::ReelAsset> asset) const
+{
+ auto frame_rate = asset->edit_rate().as_float();
+ auto start = dcp::Time(asset->entry_point().get_value_or(0), frame_rate, time_code_rate());
+ auto during = subtitles_during (start, start + dcp::Time(asset->intrinsic_duration(), frame_rate, time_code_rate()), false);
+
+ vector<shared_ptr<const dcp::Subtitle>> corrected;
+ for (auto i: during) {
+ auto c = make_shared<dcp::Subtitle>(*i);
+ c->set_in (c->in() - start);
+ c->set_out (c->out() - start);
+ corrected.push_back (c);
+ }
+
+ return corrected;
+}
+
+
void
-SubtitleAsset::add (SubtitleString s)
+SubtitleAsset::add (shared_ptr<Subtitle> s)
{
_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 ();
+ for (auto i: _subtitles) {
+ if (i->out() > t) {
+ t = i->out ();
}
}
return t;
}
+
bool
-SubtitleAsset::equals (shared_ptr<const Asset> other_asset, EqualityOptions options, NoteHandler note) const
+SubtitleAsset::equals(shared_ptr<const Asset> other_asset, EqualityOptions const& options, NoteHandler note) const
{
if (!Asset::equals (other_asset, options, note)) {
return false;
}
- shared_ptr<const SubtitleAsset> other = dynamic_pointer_cast<const SubtitleAsset> (other_asset);
+ auto other = dynamic_pointer_cast<const SubtitleAsset> (other_asset);
if (!other) {
return false;
}
- if (_subtitles != other->_subtitles) {
- note (DCP_ERROR, "subtitles differ");
+ if (_subtitles.size() != other->_subtitles.size()) {
+ note (NoteType::ERROR, String::compose("different number of subtitles: %1 vs %2", _subtitles.size(), other->_subtitles.size()));
return false;
}
+ auto i = _subtitles.begin();
+ auto j = other->_subtitles.begin();
+
+ while (i != _subtitles.end()) {
+ auto string_i = dynamic_pointer_cast<SubtitleString> (*i);
+ auto string_j = dynamic_pointer_cast<SubtitleString> (*j);
+ auto image_i = dynamic_pointer_cast<SubtitleImage> (*i);
+ auto image_j = dynamic_pointer_cast<SubtitleImage> (*j);
+
+ if ((string_i && !string_j) || (image_i && !image_j)) {
+ note (NoteType::ERROR, "subtitles differ: string vs. image");
+ return false;
+ }
+
+ if (string_i && !string_i->equals(string_j, options, note)) {
+ return false;
+ }
+
+ if (image_i && !image_i->equals(image_j, options, note)) {
+ return false;
+ }
+
+ ++i;
+ ++j;
+ }
+
return true;
}
+
struct SubtitleSorter
{
- bool operator() (SubtitleString const & a, SubtitleString const & b) {
- if (a.in() != b.in()) {
- return a.in() < b.in();
+ bool operator() (shared_ptr<Subtitle> a, shared_ptr<Subtitle> b) {
+ if (a->in() != b->in()) {
+ return a->in() < b->in();
}
- return a.v_position() < b.v_position();
+ if (a->v_align() == VAlign::BOTTOM) {
+ return a->v_position() > b->v_position();
+ }
+ return a->v_position() < b->v_position();
}
};
+
void
SubtitleAsset::pull_fonts (shared_ptr<order::Part> part)
{
}
/* Pull up from children */
- BOOST_FOREACH (shared_ptr<order::Part> i, part->children) {
+ for (auto i: part->children) {
pull_fonts (i);
}
these features go into part's font.
*/
part->font = part->children.front()->font;
- BOOST_FOREACH (shared_ptr<order::Part> i, part->children) {
+ for (auto 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) {
+ for (auto 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;
+ auto i = part->children.begin();
+ vector<shared_ptr<order::Part>> merged;
while (i != part->children.end()) {
merged.push_back (*i);
++i;
} else {
- list<shared_ptr<order::Part> >::const_iterator j = i;
+ auto j = i;
++j;
while (j != part->children.end() && (*i)->font == (*j)->font) {
++j;
}
- if (distance (i, j) == 1) {
+ if (std::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) {
+ for (auto k = i; k != j; ++k) {
(*k)->font.clear ();
group->children.push_back (*k);
}
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 ());
+ auto sorted = _subtitles;
+ std::stable_sort(sorted.begin(), sorted.end(), 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> ()));
+ auto root = make_shared<order::Part>(shared_ptr<order::Part>());
shared_ptr<order::Subtitle> subtitle;
shared_ptr<order::Text> text;
float last_h_position;
VAlign last_v_align;
float last_v_position;
+ float last_z_position;
Direction last_direction;
- BOOST_FOREACH (SubtitleString const & i, sorted) {
+ for (auto 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())
+ (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()));
+ subtitle = make_shared<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 ();
+ 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);
+ auto is = dynamic_pointer_cast<SubtitleString>(i);
+ if (is) {
+ if (!text ||
+ last_h_align != is->h_align() ||
+ fabs(last_h_position - is->h_position()) > ALIGN_EPSILON ||
+ last_v_align != is->v_align() ||
+ fabs(last_v_position - is->v_position()) > ALIGN_EPSILON ||
+ fabs(last_z_position - is->z_position()) > ALIGN_EPSILON ||
+ last_direction != is->direction()
+ ) {
+ text = make_shared<order::Text>(subtitle, is->h_align(), is->h_position(), is->v_align(), is->v_position(), is->z_position(), is->direction());
+ subtitle->children.push_back (text);
+
+ last_h_align = is->h_align ();
+ last_h_position = is->h_position ();
+ last_v_align = is->v_align ();
+ last_v_position = is->v_position ();
+ last_z_position = is->z_position();
+ last_direction = is->direction ();
+ }
- 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 (make_shared<order::String>(text, order::Font (is, standard), is->text(), is->space_before()));
}
- text->children.push_back (shared_ptr<order::String> (new order::String (text, order::Font (i, standard), i.text())));
+ auto ii = dynamic_pointer_cast<SubtitleImage>(i);
+ if (ii) {
+ text.reset ();
+ subtitle->children.push_back (
+ make_shared<order::Image>(subtitle, ii->id(), ii->png_image(), ii->h_align(), ii->h_position(), ii->v_align(), ii->v_position(), ii->z_position())
+ );
+ }
}
/* Pull font changes as high up the hierarchy as we can */
root->write_xml (xml_root, context);
}
-map<string, Data>
-SubtitleAsset::fonts_with_load_ids () const
+
+map<string, ArrayData>
+SubtitleAsset::font_data () const
{
- map<string, Data> out;
- BOOST_FOREACH (Font const & i, _fonts) {
+ map<string, ArrayData> out;
+ for (auto const& i: _fonts) {
out[i.load_id] = i.data;
}
return out;
}
+
+
+map<string, boost::filesystem::path>
+SubtitleAsset::font_filenames () const
+{
+ map<string, boost::filesystem::path> out;
+ for (auto const& i: _fonts) {
+ if (i.file) {
+ out[i.load_id] = *i.file;
+ }
+ }
+ return out;
+}
+
+
+/** Replace empty IDs in any <LoadFontId> and <Font> tags with
+ * a dummy string. Some systems give errors with empty font IDs
+ * (see DCP-o-matic bug #1689).
+ */
+void
+SubtitleAsset::fix_empty_font_ids ()
+{
+ bool have_empty = false;
+ vector<string> ids;
+ for (auto i: load_font_nodes()) {
+ if (i->id == "") {
+ have_empty = true;
+ } else {
+ ids.push_back (i->id);
+ }
+ }
+
+ if (!have_empty) {
+ return;
+ }
+
+ string const empty_id = unique_string (ids, "font");
+
+ for (auto i: load_font_nodes()) {
+ if (i->id == "") {
+ i->id = empty_id;
+ }
+ }
+
+ for (auto i: _subtitles) {
+ auto j = dynamic_pointer_cast<SubtitleString> (i);
+ if (j && j->font() && j->font().get() == "") {
+ j->set_font (empty_id);
+ }
+ }
+}
+
+
+namespace {
+
+struct State
+{
+ int indent;
+ string xml;
+ int disable_formatting;
+};
+
+}
+
+
+static
+void
+format_xml_node (xmlpp::Node const* node, State& state)
+{
+ if (auto text_node = dynamic_cast<const xmlpp::TextNode*>(node)) {
+ string content = text_node->get_content();
+ boost::replace_all(content, "&", "&");
+ boost::replace_all(content, "<", "<");
+ boost::replace_all(content, ">", ">");
+ state.xml += content;
+ } else if (auto element = dynamic_cast<const xmlpp::Element*>(node)) {
+ ++state.indent;
+
+ auto children = element->get_children();
+ auto const should_disable_formatting =
+ std::any_of(
+ children.begin(), children.end(),
+ [](xmlpp::Node const* node) { return static_cast<bool>(dynamic_cast<const xmlpp::ContentNode*>(node)); }
+ ) || element->get_name() == "Text";
+
+ if (!state.disable_formatting) {
+ state.xml += "\n" + string(state.indent * 2, ' ');
+ }
+
+ state.xml += "<" + element->get_name();
+
+ for (auto attribute: element->get_attributes()) {
+ state.xml += String::compose(" %1=\"%2\"", attribute->get_name().raw(), attribute->get_value().raw());
+ }
+
+ if (children.empty()) {
+ state.xml += "/>";
+ } else {
+ state.xml += ">";
+
+ if (should_disable_formatting) {
+ ++state.disable_formatting;
+ }
+
+ for (auto child: children) {
+ format_xml_node(child, state);
+ }
+
+ if (!state.disable_formatting) {
+ state.xml += "\n" + string(state.indent * 2, ' ');
+ }
+
+ state.xml += String::compose("</%1>", element->get_name().raw());
+
+ if (should_disable_formatting) {
+ --state.disable_formatting;
+ }
+ }
+
+ --state.indent;
+ }
+}
+
+
+/** Format XML much as write_to_string_formatted() would do, except without adding any white space
+ * to <Text> nodes. This is an attempt to avoid changing what is actually displayed as subtitles
+ * while also formatting the XML in such a way as to avoid DoM bug 2205.
+ *
+ * xml_namespace is an optional namespace for the root node; it would be nicer to set this up with
+ * set_namespace_declaration in the caller and then to extract it here but I couldn't find a way
+ * to get all namespaces with the libxml++ API.
+ */
+string
+SubtitleAsset::format_xml(xmlpp::Document const& document, optional<pair<string, string>> xml_namespace)
+{
+ auto root = document.get_root_node();
+
+ State state = {};
+ state.xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<" + root->get_name();
+
+ if (xml_namespace) {
+ if (xml_namespace->first.empty()) {
+ state.xml += String::compose(" xmlns=\"%1\"", xml_namespace->second);
+ } else {
+ state.xml += String::compose(" xmlns:%1=\"%2\"", xml_namespace->first, xml_namespace->second);
+ }
+ }
+
+ for (auto attribute: root->get_attributes()) {
+ state.xml += String::compose(" %1=\"%2\"", attribute->get_name().raw(), attribute->get_value().raw());
+ }
+
+ state.xml += ">";
+
+ for (auto child: document.get_root_node()->get_children()) {
+ format_xml_node(child, state);
+ }
+
+ state.xml += String::compose("\n</%1>\n", root->get_name().raw());
+
+ return state.xml;
+}
+
+
+void
+SubtitleAsset::ensure_font(string load_id, dcp::ArrayData data)
+{
+ if (std::find_if(_fonts.begin(), _fonts.end(), [load_id](Font const& font) { return font.load_id == load_id; }) == _fonts.end()) {
+ add_font(load_id, data);
+ }
+}
+
projects / libdcp.git / blobdiff