src/dcp.cc

   1 /*
   2     Copyright (C) 2012 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 /** @file  src/dcp.cc
  21  *  @brief A class to create a DCP.
  22  */
  23
  24 #include <sstream>
  25 #include <fstream>
  26 #include <iomanip>
  27 #include <cassert>
  28 #include <iostream>
  29 #include <boost/filesystem.hpp>
  30 #include <libxml++/libxml++.h>
  31 #include "dcp.h"
  32 #include "asset.h"
  33 #include "sound_asset.h"
  34 #include "picture_asset.h"
  35 #include "subtitle_asset.h"
  36 #include "util.h"
  37 #include "metadata.h"
  38 #include "exceptions.h"
  39 #include "cpl.h"
  40 #include "pkl.h"
  41 #include "asset_map.h"
  42 #include "reel.h"
  43
  44 using namespace std;
  45 using namespace boost;
  46 using namespace libdcp;
  47
  48 DCP::DCP (string directory, string name, ContentKind content_kind, int fps, int length)
  49         : _directory (directory)
  50         , _name (name)
  51         , _content_kind (content_kind)
  52         , _fps (fps)
  53         , _length (length)
  54 {
  55
  56 }
  57
  58 void
  59 DCP::add_reel (shared_ptr<const Reel> reel)
  60 {
  61         _reels.push_back (reel);
  62 }
  63
  64 void
  65 DCP::write_xml () const
  66 {
  67         string cpl_uuid = make_uuid ();
  68         string cpl_path = write_cpl (cpl_uuid);
  69         int cpl_length = filesystem::file_size (cpl_path);
  70         string cpl_digest = make_digest (cpl_path, 0);
  71
  72         string pkl_uuid = make_uuid ();
  73         string pkl_path = write_pkl (pkl_uuid, cpl_uuid, cpl_digest, cpl_length);
  74
  75         write_volindex ();
  76         write_assetmap (cpl_uuid, cpl_length, pkl_uuid, filesystem::file_size (pkl_path));
  77 }
  78
  79 string
  80 DCP::write_cpl (string cpl_uuid) const
  81 {
  82         filesystem::path p;
  83         p /= _directory;
  84         stringstream s;
  85         s << cpl_uuid << "_cpl.xml";
  86         p /= s.str();
  87         ofstream cpl (p.string().c_str());
  88
  89         cpl << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
  90             << "<CompositionPlaylist xmlns=\"http://www.smpte-ra.org/schemas/429-7/2006/CPL\">\n"
  91             << "  <Id>urn:uuid:" << cpl_uuid << "</Id>\n"
  92             << "  <AnnotationText>" << _name << "</AnnotationText>\n"
  93             << "  <IssueDate>" << Metadata::instance()->issue_date << "</IssueDate>\n"
  94             << "  <Creator>" << Metadata::instance()->creator << "</Creator>\n"
  95             << "  <ContentTitleText>" << _name << "</ContentTitleText>\n"
  96             << "  <ContentKind>" << content_kind_to_string (_content_kind) << "</ContentKind>\n"
  97             << "  <ContentVersion>\n"
  98             << "    <Id>urn:uri:" << cpl_uuid << "_" << Metadata::instance()->issue_date << "</Id>\n"
  99             << "    <LabelText>" << cpl_uuid << "_" << Metadata::instance()->issue_date << "</LabelText>\n"
 100             << "  </ContentVersion>\n"
 101             << "  <RatingList/>\n"
 102             << "  <ReelList>\n";
 103
 104         for (list<shared_ptr<const Reel> >::const_iterator i = _reels.begin(); i != _reels.end(); ++i) {
 105                 (*i)->write_to_cpl (cpl);
 106         }
 107
 108         cpl << "      </AssetList>\n"
 109             << "    </Reel>\n"
 110             << "  </ReelList>\n"
 111             << "</CompositionPlaylist>\n";
 112
 113         return p.string ();
 114 }
 115
 116 std::string
 117 DCP::write_pkl (string pkl_uuid, string cpl_uuid, string cpl_digest, int cpl_length) const
 118 {
 119         filesystem::path p;
 120         p /= _directory;
 121         stringstream s;
 122         s << pkl_uuid << "_pkl.xml";
 123         p /= s.str();
 124         ofstream pkl (p.string().c_str());
 125
 126         pkl << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 127             << "<PackingList xmlns=\"http://www.smpte-ra.org/schemas/429-8/2007/PKL\">\n"
 128             << "  <Id>urn:uuid:" << pkl_uuid << "</Id>\n"
 129             << "  <AnnotationText>" << _name << "</AnnotationText>\n"
 130             << "  <IssueDate>" << Metadata::instance()->issue_date << "</IssueDate>\n"
 131             << "  <Issuer>" << Metadata::instance()->issuer << "</Issuer>\n"
 132             << "  <Creator>" << Metadata::instance()->creator << "</Creator>\n"
 133             << "  <AssetList>\n";
 134
 135         for (list<shared_ptr<const Reel> >::const_iterator i = _reels.begin(); i != _reels.end(); ++i) {
 136                 (*i)->write_to_pkl (pkl);
 137         }
 138
 139         pkl << "    <Asset>\n"
 140             << "      <Id>urn:uuid:" << cpl_uuid << "</Id>\n"
 141             << "      <Hash>" << cpl_digest << "</Hash>\n"
 142             << "      <Size>" << cpl_length << "</Size>\n"
 143             << "      <Type>text/xml</Type>\n"
 144             << "    </Asset>\n";
 145
 146         pkl << "  </AssetList>\n"
 147             << "</PackingList>\n";
 148
 149         return p.string ();
 150 }
 151
 152 void
 153 DCP::write_volindex () const
 154 {
 155         filesystem::path p;
 156         p /= _directory;
 157         p /= "VOLINDEX.xml";
 158         ofstream vi (p.string().c_str());
 159
 160         vi << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 161            << "<VolumeIndex xmlns=\"http://www.smpte-ra.org/schemas/429-9/2007/AM\">\n"
 162            << "  <Index>1</Index>\n"
 163            << "</VolumeIndex>\n";
 164 }
 165
 166 void
 167 DCP::write_assetmap (string cpl_uuid, int cpl_length, string pkl_uuid, int pkl_length) const
 168 {
 169         filesystem::path p;
 170         p /= _directory;
 171         p /= "ASSETMAP.xml";
 172         ofstream am (p.string().c_str());
 173
 174         am << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 175            << "<AssetMap xmlns=\"http://www.smpte-ra.org/schemas/429-9/2007/AM\">\n"
 176            << "  <Id>urn:uuid:" << make_uuid() << "</Id>\n"
 177            << "  <Creator>" << Metadata::instance()->creator << "</Creator>\n"
 178            << "  <VolumeCount>1</VolumeCount>\n"
 179            << "  <IssueDate>" << Metadata::instance()->issue_date << "</IssueDate>\n"
 180            << "  <Issuer>" << Metadata::instance()->issuer << "</Issuer>\n"
 181            << "  <AssetList>\n";
 182
 183         am << "    <Asset>\n"
 184            << "      <Id>urn:uuid:" << pkl_uuid << "</Id>\n"
 185            << "      <PackingList>true</PackingList>\n"
 186            << "      <ChunkList>\n"
 187            << "        <Chunk>\n"
 188            << "          <Path>" << pkl_uuid << "_pkl.xml</Path>\n"
 189            << "          <VolumeIndex>1</VolumeIndex>\n"
 190            << "          <Offset>0</Offset>\n"
 191            << "          <Length>" << pkl_length << "</Length>\n"
 192            << "        </Chunk>\n"
 193            << "      </ChunkList>\n"
 194            << "    </Asset>\n";
 195
 196         am << "    <Asset>\n"
 197            << "      <Id>urn:uuid:" << cpl_uuid << "</Id>\n"
 198            << "      <ChunkList>\n"
 199            << "        <Chunk>\n"
 200            << "          <Path>" << cpl_uuid << "_cpl.xml</Path>\n"
 201            << "          <VolumeIndex>1</VolumeIndex>\n"
 202            << "          <Offset>0</Offset>\n"
 203            << "          <Length>" << cpl_length << "</Length>\n"
 204            << "        </Chunk>\n"
 205            << "      </ChunkList>\n"
 206            << "    </Asset>\n";
 207
 208         for (list<shared_ptr<const Reel> >::const_iterator i = _reels.begin(); i != _reels.end(); ++i) {
 209                 (*i)->write_to_assetmap (am);
 210         }
 211
 212         am << "  </AssetList>\n"
 213            << "</AssetMap>\n";
 214 }
 215
 216
 217 DCP::DCP (string directory)
 218         : _directory (directory)
 219 {
 220         Files files;
 221         scan (files, directory);
 222
 223         if (files.cpl.empty ()) {
 224                 throw FileError ("no CPL file found", "");
 225         }
 226
 227         if (files.pkl.empty ()) {
 228                 throw FileError ("no PKL file found", "");
 229         }
 230
 231         if (files.asset_map.empty ()) {
 232                 throw FileError ("no AssetMap file found", "");
 233         }
 234
 235         /* Read the XML */
 236         shared_ptr<CPL> cpl;
 237         try {
 238                 cpl.reset (new CPL (files.cpl));
 239         } catch (FileError& e) {
 240                 throw FileError ("could not load CPL file", files.cpl);
 241         }
 242
 243         shared_ptr<PKL> pkl;
 244         try {
 245                 pkl.reset (new PKL (files.pkl));
 246         } catch (FileError& e) {
 247                 throw FileError ("could not load PKL file", files.pkl);
 248         }
 249
 250         shared_ptr<AssetMap> asset_map;
 251         try {
 252                 asset_map.reset (new AssetMap (files.asset_map));
 253         } catch (FileError& e) {
 254                 throw FileError ("could not load AssetMap file", files.asset_map);
 255         }
 256
 257         /* Cross-check */
 258         /* XXX */
 259
 260         /* Now cherry-pick the required bits into our own data structure */
 261
 262         _name = cpl->annotation_text;
 263         _content_kind = cpl->content_kind;
 264         _length = 0;
 265         _fps = 0;
 266
 267         for (list<shared_ptr<CPLReel> >::iterator i = cpl->reels.begin(); i != cpl->reels.end(); ++i) {
 268                 assert (_fps == 0 || _fps == (*i)->asset_list->main_picture->frame_rate.numerator);
 269                 _fps = (*i)->asset_list->main_picture->frame_rate.numerator;
 270                 _length += (*i)->asset_list->main_picture->duration;
 271
 272                 string n = pkl->asset_from_id ((*i)->asset_list->main_picture->id)->original_file_name;
 273                 if (n.empty ()) {
 274                         n = (*i)->asset_list->main_picture->annotation_text;
 275                 }
 276
 277                 shared_ptr<PictureAsset> picture (new PictureAsset (
 278                                                           _directory,
 279                                                           n,
 280                                                           _fps,
 281                                                           (*i)->asset_list->main_picture->duration
 282                                                           )
 283                         );
 284
 285                 shared_ptr<SoundAsset> sound;
 286
 287                 if ((*i)->asset_list->main_sound) {
 288
 289                         n = pkl->asset_from_id ((*i)->asset_list->main_sound->id)->original_file_name;
 290                         if (n.empty ()) {
 291                                 n = (*i)->asset_list->main_sound->annotation_text;
 292                         }
 293
 294                         sound.reset (new SoundAsset (
 295                                              _directory,
 296                                              n,
 297                                              _fps,
 298                                              (*i)->asset_list->main_sound->duration
 299                                              )
 300                                 );
 301                 }
 302
 303                 assert (files.subtitles.size() < 2);
 304
 305                 shared_ptr<SubtitleAsset> subtitle;
 306                 if (!files.subtitles.empty ()) {
 307                         string const l = files.subtitles.front().substr (_directory.length ());
 308                         subtitle.reset (new SubtitleAsset (_directory, l));
 309                 }
 310
 311                 _reels.push_back (shared_ptr<Reel> (new Reel (picture, sound, subtitle)));
 312         }
 313 }
 314
 315
 316 void
 317 DCP::scan (Files& files, string directory) const
 318 {
 319         for (filesystem::directory_iterator i = filesystem::directory_iterator(directory); i != filesystem::directory_iterator(); ++i) {
 320
 321                 string const t = i->path().string ();
 322
 323                 if (filesystem::is_directory (*i)) {
 324                         scan (files, t);
 325                         continue;
 326                 }
 327
 328                 if (ends_with (t, ".mxf") || ends_with (t, ".ttf")) {
 329                         continue;
 330                 }
 331
 332                 xmlpp::DomParser* p = new xmlpp::DomParser;
 333
 334                 try {
 335                         p->parse_file (t);
 336                 } catch (std::exception& e) {
 337                         delete p;
 338                         continue;
 339                 }
 340
 341                 if (!p) {
 342                         delete p;
 343                         continue;
 344                 }
 345
 346                 string const root = p->get_document()->get_root_node()->get_name ();
 347                 delete p;
 348
 349                 if (root == "CompositionPlaylist") {
 350                         if (files.cpl.empty ()) {
 351                                 files.cpl = t;
 352                         } else {
 353                                 throw DCPReadError ("duplicate CPLs found");
 354                         }
 355                 } else if (root == "PackingList") {
 356                         if (files.pkl.empty ()) {
 357                                 files.pkl = t;
 358                         } else {
 359                                 throw DCPReadError ("duplicate PKLs found");
 360                         }
 361                 } else if (root == "AssetMap") {
 362                         if (files.asset_map.empty ()) {
 363                                 files.asset_map = t;
 364                         } else {
 365                                 throw DCPReadError ("duplicate AssetMaps found");
 366                         }
 367                         files.asset_map = t;
 368                 } else if (root == "DCSubtitle") {
 369                         files.subtitles.push_back (t);
 370                 }
 371         }
 372 }
 373
 374
 375 list<string>
 376 DCP::equals (DCP const & other, EqualityOptions opt) const
 377 {
 378         list<string> notes;
 379
 380         if (opt.flags & LIBDCP_METADATA) {
 381                 if (_name != other._name) {
 382                         notes.push_back ("names differ");
 383                 }
 384                 if (_content_kind != other._content_kind) {
 385                         notes.push_back ("content kinds differ");
 386                 }
 387                 if (_fps != other._fps) {
 388                         notes.push_back ("frames per second differ");
 389                 }
 390                 if (_length != other._length) {
 391                         notes.push_back ("lengths differ");
 392                 }
 393         }
 394
 395         if (_reels.size() != other._reels.size()) {
 396                 notes.push_back ("reel counts differ");
 397         }
 398
 399         list<shared_ptr<const Reel> >::const_iterator a = _reels.begin ();
 400         list<shared_ptr<const Reel> >::const_iterator b = other._reels.begin ();
 401
 402         while (a != _reels.end ()) {
 403                 list<string> n = (*a)->equals (*b, opt);
 404                 notes.merge (n);
 405                 ++a;
 406                 ++b;
 407         }
 408
 409         return notes;
 410 }
 411