src/interop_subtitle_asset.cc

   1 /*
   2     Copyright (C) 2012-2018 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp 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 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp 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 libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34 #include "interop_subtitle_asset.h"
  35 #include "interop_load_font_node.h"
  36 #include "subtitle_asset_internal.h"
  37 #include "xml.h"
  38 #include "raw_convert.h"
  39 #include "util.h"
  40 #include "font_asset.h"
  41 #include "dcp_assert.h"
  42 #include "subtitle_image.h"
  43 #include <libxml++/libxml++.h>
  44 #include <boost/foreach.hpp>
  45 #include <cmath>
  46 #include <cstdio>
  47
  48 using std::list;
  49 using std::string;
  50 using std::cout;
  51 using std::cerr;
  52 using std::map;
  53 using boost::shared_ptr;
  54 using boost::shared_array;
  55 using boost::optional;
  56 using boost::dynamic_pointer_cast;
  57 using namespace dcp;
  58
  59 InteropSubtitleAsset::InteropSubtitleAsset (boost::filesystem::path file)
  60         : SubtitleAsset (file)
  61 {
  62         shared_ptr<cxml::Document> xml (new cxml::Document ("DCSubtitle"));
  63         xml->read_file (file);
  64         _id = xml->string_child ("SubtitleID");
  65         _reel_number = xml->string_child ("ReelNumber");
  66         _language = xml->string_child ("Language");
  67         _movie_title = xml->string_child ("MovieTitle");
  68         _load_font_nodes = type_children<InteropLoadFontNode> (xml, "LoadFont");
  69
  70         /* Now we need to drop down to xmlpp */
  71
  72         list<ParseState> ps;
  73         xmlpp::Node::NodeList c = xml->node()->get_children ();
  74         for (xmlpp::Node::NodeList::const_iterator i = c.begin(); i != c.end(); ++i) {
  75                 xmlpp::Element const * e = dynamic_cast<xmlpp::Element const *> (*i);
  76                 if (e && (e->get_name() == "Font" || e->get_name() == "Subtitle")) {
  77                         parse_subtitles (e, ps, optional<int>(), INTEROP);
  78                 }
  79         }
  80 }
  81
  82 InteropSubtitleAsset::InteropSubtitleAsset ()
  83 {
  84
  85 }
  86
  87 string
  88 InteropSubtitleAsset::xml_as_string () const
  89 {
  90         xmlpp::Document doc;
  91         xmlpp::Element* root = doc.create_root_node ("DCSubtitle");
  92         root->set_attribute ("Version", "1.0");
  93
  94         root->add_child("SubtitleID")->add_child_text (_id);
  95         root->add_child("MovieTitle")->add_child_text (_movie_title);
  96         root->add_child("ReelNumber")->add_child_text (raw_convert<string> (_reel_number));
  97         root->add_child("Language")->add_child_text (_language);
  98
  99         for (list<shared_ptr<InteropLoadFontNode> >::const_iterator i = _load_font_nodes.begin(); i != _load_font_nodes.end(); ++i) {
 100                 xmlpp::Element* load_font = root->add_child("LoadFont");
 101                 load_font->set_attribute ("Id", (*i)->id);
 102                 load_font->set_attribute ("URI", (*i)->uri);
 103         }
 104
 105         subtitles_as_xml (root, 250, INTEROP);
 106
 107         return doc.write_to_string ("UTF-8");
 108 }
 109
 110 void
 111 InteropSubtitleAsset::add_font (string load_id, boost::filesystem::path file)
 112 {
 113         _fonts.push_back (Font (load_id, make_uuid(), file));
 114         _load_font_nodes.push_back (shared_ptr<InteropLoadFontNode> (new InteropLoadFontNode (load_id, file.leaf().string ())));
 115 }
 116
 117 bool
 118 InteropSubtitleAsset::equals (shared_ptr<const Asset> other_asset, EqualityOptions options, NoteHandler note) const
 119 {
 120         if (!SubtitleAsset::equals (other_asset, options, note)) {
 121                 return false;
 122         }
 123
 124         shared_ptr<const InteropSubtitleAsset> other = dynamic_pointer_cast<const InteropSubtitleAsset> (other_asset);
 125         if (!other) {
 126                 return false;
 127         }
 128
 129         list<shared_ptr<InteropLoadFontNode> >::const_iterator i = _load_font_nodes.begin ();
 130         list<shared_ptr<InteropLoadFontNode> >::const_iterator j = other->_load_font_nodes.begin ();
 131
 132         while (i != _load_font_nodes.end ()) {
 133                 if (j == other->_load_font_nodes.end ()) {
 134                         note (DCP_ERROR, "<LoadFont> nodes differ");
 135                         return false;
 136                 }
 137
 138                 if (**i != **j) {
 139                         note (DCP_ERROR, "<LoadFont> nodes differ");
 140                         return false;
 141                 }
 142
 143                 ++i;
 144                 ++j;
 145         }
 146
 147         if (_movie_title != other->_movie_title) {
 148                 note (DCP_ERROR, "Subtitle movie titles differ");
 149                 return false;
 150         }
 151
 152         return true;
 153 }
 154
 155 list<shared_ptr<LoadFontNode> >
 156 InteropSubtitleAsset::load_font_nodes () const
 157 {
 158         list<shared_ptr<LoadFontNode> > lf;
 159         copy (_load_font_nodes.begin(), _load_font_nodes.end(), back_inserter (lf));
 160         return lf;
 161 }
 162
 163 /** Write this content to an XML file with its fonts alongside */
 164 void
 165 InteropSubtitleAsset::write (boost::filesystem::path p) const
 166 {
 167         FILE* f = fopen_boost (p, "w");
 168         if (!f) {
 169                 throw FileError ("Could not open file for writing", p, -1);
 170         }
 171
 172         string const s = xml_as_string ();
 173         /* length() here gives bytes not characters */
 174         fwrite (s.c_str(), 1, s.length(), f);
 175         fclose (f);
 176
 177         _file = p;
 178
 179         /* Image subtitles */
 180         int n = 0;
 181         BOOST_FOREACH (shared_ptr<dcp::Subtitle> i, _subtitles) {
 182                 shared_ptr<dcp::SubtitleImage> im = dynamic_pointer_cast<dcp::SubtitleImage> (i);
 183                 if (im) {
 184                         im->png_image().write (p.parent_path() / image_subtitle_file (n++));
 185                 }
 186         }
 187
 188         /* Fonts */
 189         BOOST_FOREACH (shared_ptr<InteropLoadFontNode> i, _load_font_nodes) {
 190                 boost::filesystem::path file = p.parent_path() / i->uri;
 191                 FILE* f = fopen_boost (file, "wb");
 192                 if (!f) {
 193                         throw FileError ("could not open font file for writing", file, errno);
 194                 }
 195                 list<Font>::const_iterator j = _fonts.begin ();
 196                 while (j != _fonts.end() && j->load_id != i->id) {
 197                         ++j;
 198                 }
 199                 if (j != _fonts.end ()) {
 200                         fwrite (j->data.data().get(), 1, j->data.size(), f);
 201                         j->file = file;
 202                 }
 203                 fclose (f);
 204         }
 205 }
 206
 207 /** Look at a supplied list of assets and find the fonts.  Then match these
 208  *  fonts up with anything requested by a <LoadFont> so that _fonts contains
 209  *  a list of font ID, load ID and data.
 210  */
 211 void
 212 InteropSubtitleAsset::resolve_fonts (list<shared_ptr<Asset> > assets)
 213 {
 214         BOOST_FOREACH (shared_ptr<Asset> i, assets) {
 215                 shared_ptr<FontAsset> font = dynamic_pointer_cast<FontAsset> (i);
 216                 if (!font) {
 217                         continue;
 218                 }
 219
 220                 BOOST_FOREACH (shared_ptr<InteropLoadFontNode> j, _load_font_nodes) {
 221                         bool got = false;
 222                         BOOST_FOREACH (Font const & k, _fonts) {
 223                                 if (k.load_id == j->id) {
 224                                         got = true;
 225                                         break;
 226                                 }
 227                         }
 228
 229                         if (!got && font->file() && j->uri == font->file()->leaf().string()) {
 230                                 _fonts.push_back (Font (j->id, i->id(), font->file().get()));
 231                         }
 232                 }
 233         }
 234 }
 235
 236 void
 237 InteropSubtitleAsset::add_font_assets (list<shared_ptr<Asset> >& assets)
 238 {
 239         BOOST_FOREACH (Font const & i, _fonts) {
 240                 DCP_ASSERT (i.file);
 241                 assets.push_back (shared_ptr<FontAsset> (new FontAsset (i.uuid, i.file.get ())));
 242         }
 243 }