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 "compose.hpp"
  43 #include "subtitle_image.h"
  44 #include <libxml++/libxml++.h>
  45 #include <boost/foreach.hpp>
  46 #include <boost/weak_ptr.hpp>
  47 #include <cmath>
  48 #include <cstdio>
  49
  50 using std::list;
  51 using std::string;
  52 using std::cout;
  53 using std::cerr;
  54 using std::map;
  55 using boost::shared_ptr;
  56 using boost::shared_array;
  57 using boost::optional;
  58 using boost::dynamic_pointer_cast;
  59 using namespace dcp;
  60
  61 InteropSubtitleAsset::InteropSubtitleAsset (boost::filesystem::path file)
  62         : SubtitleAsset (file)
  63 {
  64         shared_ptr<cxml::Document> xml (new cxml::Document ("DCSubtitle"));
  65         xml->read_file (file);
  66         _id = xml->string_child ("SubtitleID");
  67         _reel_number = xml->string_child ("ReelNumber");
  68         _language = xml->string_child ("Language");
  69         _movie_title = xml->string_child ("MovieTitle");
  70         _load_font_nodes = type_children<InteropLoadFontNode> (xml, "LoadFont");
  71
  72         /* Now we need to drop down to xmlpp */
  73
  74         list<ParseState> ps;
  75         xmlpp::Node::NodeList c = xml->node()->get_children ();
  76         for (xmlpp::Node::NodeList::const_iterator i = c.begin(); i != c.end(); ++i) {
  77                 xmlpp::Element const * e = dynamic_cast<xmlpp::Element const *> (*i);
  78                 if (e && (e->get_name() == "Font" || e->get_name() == "Subtitle")) {
  79                         parse_subtitles (e, ps, optional<int>(), INTEROP);
  80                 }
  81         }
  82 }
  83
  84 InteropSubtitleAsset::InteropSubtitleAsset ()
  85 {
  86
  87 }
  88
  89 string
  90 InteropSubtitleAsset::xml_as_string () const
  91 {
  92         xmlpp::Document doc;
  93         xmlpp::Element* root = doc.create_root_node ("DCSubtitle");
  94         root->set_attribute ("Version", "1.0");
  95
  96         root->add_child("SubtitleID")->add_child_text (_id);
  97         root->add_child("MovieTitle")->add_child_text (_movie_title);
  98         root->add_child("ReelNumber")->add_child_text (raw_convert<string> (_reel_number));
  99         root->add_child("Language")->add_child_text (_language);
 100
 101         for (list<shared_ptr<InteropLoadFontNode> >::const_iterator i = _load_font_nodes.begin(); i != _load_font_nodes.end(); ++i) {
 102                 xmlpp::Element* load_font = root->add_child("LoadFont");
 103                 load_font->set_attribute ("Id", (*i)->id);
 104                 load_font->set_attribute ("URI", (*i)->uri);
 105         }
 106
 107         subtitles_as_xml (root, 250, INTEROP);
 108
 109         return doc.write_to_string ("UTF-8");
 110 }
 111
 112 void
 113 InteropSubtitleAsset::add_font (string load_id, boost::filesystem::path file)
 114 {
 115         _fonts.push_back (Font (load_id, make_uuid(), file));
 116         _load_font_nodes.push_back (shared_ptr<InteropLoadFontNode> (new InteropLoadFontNode (load_id, file.leaf().string ())));
 117 }
 118
 119 bool
 120 InteropSubtitleAsset::equals (shared_ptr<const Asset> other_asset, EqualityOptions options, NoteHandler note) const
 121 {
 122         if (!SubtitleAsset::equals (other_asset, options, note)) {
 123                 return false;
 124         }
 125
 126         shared_ptr<const InteropSubtitleAsset> other = dynamic_pointer_cast<const InteropSubtitleAsset> (other_asset);
 127         if (!other) {
 128                 return false;
 129         }
 130
 131         list<shared_ptr<InteropLoadFontNode> >::const_iterator i = _load_font_nodes.begin ();
 132         list<shared_ptr<InteropLoadFontNode> >::const_iterator j = other->_load_font_nodes.begin ();
 133
 134         while (i != _load_font_nodes.end ()) {
 135                 if (j == other->_load_font_nodes.end ()) {
 136                         note (DCP_ERROR, "<LoadFont> nodes differ");
 137                         return false;
 138                 }
 139
 140                 if (**i != **j) {
 141                         note (DCP_ERROR, "<LoadFont> nodes differ");
 142                         return false;
 143                 }
 144
 145                 ++i;
 146                 ++j;
 147         }
 148
 149         if (_movie_title != other->_movie_title) {
 150                 note (DCP_ERROR, "Subtitle movie titles differ");
 151                 return false;
 152         }
 153
 154         return true;
 155 }
 156
 157 list<shared_ptr<LoadFontNode> >
 158 InteropSubtitleAsset::load_font_nodes () const
 159 {
 160         list<shared_ptr<LoadFontNode> > lf;
 161         copy (_load_font_nodes.begin(), _load_font_nodes.end(), back_inserter (lf));
 162         return lf;
 163 }
 164
 165 /** Write this content to an XML file with its fonts alongside */
 166 void
 167 InteropSubtitleAsset::write (boost::filesystem::path p) const
 168 {
 169         FILE* f = fopen_boost (p, "w");
 170         if (!f) {
 171                 throw FileError ("Could not open file for writing", p, -1);
 172         }
 173
 174         string const s = xml_as_string ();
 175         /* length() here gives bytes not characters */
 176         fwrite (s.c_str(), 1, s.length(), f);
 177         fclose (f);
 178
 179         _file = p;
 180
 181         /* Image subtitles */
 182         BOOST_FOREACH (shared_ptr<dcp::Subtitle> i, _subtitles) {
 183                 shared_ptr<dcp::SubtitleImage> im = dynamic_pointer_cast<dcp::SubtitleImage> (i);
 184                 if (im) {
 185                         ImageUUIDMap::const_iterator uuid = _image_subtitle_uuid.find(im);
 186                         DCP_ASSERT (uuid != _image_subtitle_uuid.end());
 187                         im->png_image().write (p.parent_path() / String::compose("%1.png", uuid->second));
 188                 }
 189         }
 190
 191         /* Fonts */
 192         BOOST_FOREACH (shared_ptr<InteropLoadFontNode> i, _load_font_nodes) {
 193                 boost::filesystem::path file = p.parent_path() / i->uri;
 194                 FILE* f = fopen_boost (file, "wb");
 195                 if (!f) {
 196                         throw FileError ("could not open font file for writing", file, errno);
 197                 }
 198                 list<Font>::const_iterator j = _fonts.begin ();
 199                 while (j != _fonts.end() && j->load_id != i->id) {
 200                         ++j;
 201                 }
 202                 if (j != _fonts.end ()) {
 203                         fwrite (j->data.data().get(), 1, j->data.size(), f);
 204                         j->file = file;
 205                 }
 206                 fclose (f);
 207         }
 208 }
 209
 210 /** Look at a supplied list of assets and find the fonts.  Then match these
 211  *  fonts up with anything requested by a <LoadFont> so that _fonts contains
 212  *  a list of font ID, load ID and data.
 213  */
 214 void
 215 InteropSubtitleAsset::resolve_fonts (list<shared_ptr<Asset> > assets)
 216 {
 217         BOOST_FOREACH (shared_ptr<Asset> i, assets) {
 218                 shared_ptr<FontAsset> font = dynamic_pointer_cast<FontAsset> (i);
 219                 if (!font) {
 220                         continue;
 221                 }
 222
 223                 BOOST_FOREACH (shared_ptr<InteropLoadFontNode> j, _load_font_nodes) {
 224                         bool got = false;
 225                         BOOST_FOREACH (Font const & k, _fonts) {
 226                                 if (k.load_id == j->id) {
 227                                         got = true;
 228                                         break;
 229                                 }
 230                         }
 231
 232                         if (!got && font->file() && j->uri == font->file()->leaf().string()) {
 233                                 _fonts.push_back (Font (j->id, i->id(), font->file().get()));
 234                         }
 235                 }
 236         }
 237 }
 238
 239 void
 240 InteropSubtitleAsset::add_font_assets (list<shared_ptr<Asset> >& assets)
 241 {
 242         BOOST_FOREACH (Font const & i, _fonts) {
 243                 DCP_ASSERT (i.file);
 244                 assets.push_back (shared_ptr<FontAsset> (new FontAsset (i.uuid, i.file.get ())));
 245         }
 246 }