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
 269                 shared_ptr<Picture> p;
 270
 271                 if ((*i)->asset_list->main_picture) {
 272                         p = (*i)->asset_list->main_picture;
 273                 } else {
 274                         p = (*i)->asset_list->main_stereoscopic_picture;
 275                 }
 276
 277                 assert (_fps == 0 || _fps == p->frame_rate.numerator);
 278                 _fps = p->frame_rate.numerator;
 279                 _length += p->duration;
 280
 281                 shared_ptr<PictureAsset> picture;
 282                 shared_ptr<SoundAsset> sound;
 283                 shared_ptr<SubtitleAsset> subtitle;
 284
 285                 if ((*i)->asset_list->main_picture) {
 286
 287                         string n = pkl->asset_from_id (p->id)->original_file_name;
 288                         if (n.empty ()) {
 289                                 n = p->annotation_text;
 290                         }
 291
 292                         picture.reset (new MonoPictureAsset (
 293                                                _directory,
 294                                                n,
 295                                                _fps,
 296                                                (*i)->asset_list->main_picture->entry_point,
 297                                                (*i)->asset_list->main_picture->duration
 298                                                )
 299                                 );
 300
 301                 } else if ((*i)->asset_list->main_stereoscopic_picture) {
 302
 303                         string n = pkl->asset_from_id (p->id)->original_file_name;
 304                         if (n.empty ()) {
 305                                 n = p->annotation_text;
 306                         }
 307
 308                         picture.reset (new StereoPictureAsset (
 309                                                _directory,
 310                                                n,
 311                                                _fps,
 312                                                (*i)->asset_list->main_stereoscopic_picture->entry_point,
 313                                                (*i)->asset_list->main_stereoscopic_picture->duration
 314                                                )
 315                                 );
 316
 317                 }
 318
 319                 if ((*i)->asset_list->main_sound) {
 320
 321                         string n = pkl->asset_from_id ((*i)->asset_list->main_sound->id)->original_file_name;
 322                         if (n.empty ()) {
 323                                 n = (*i)->asset_list->main_sound->annotation_text;
 324                         }
 325
 326                         sound.reset (new SoundAsset (
 327                                              _directory,
 328                                              n,
 329                                              _fps,
 330                                              (*i)->asset_list->main_sound->entry_point,
 331                                              (*i)->asset_list->main_sound->duration
 332                                              )
 333                                 );
 334                 }
 335
 336                 if ((*i)->asset_list->main_subtitle) {
 337
 338                         string n = pkl->asset_from_id ((*i)->asset_list->main_subtitle->id)->original_file_name;
 339                         if (n.empty ()) {
 340                                 n = (*i)->asset_list->main_subtitle->annotation_text;
 341                         }
 342
 343                         subtitle.reset (new SubtitleAsset (
 344                                              _directory,
 345                                              n
 346                                              )
 347                                 );
 348                 }
 349
 350                 _reels.push_back (shared_ptr<Reel> (new Reel (picture, sound, subtitle)));
 351         }
 352 }
 353
 354
 355 void
 356 DCP::scan (Files& files, string directory) const
 357 {
 358         for (filesystem::directory_iterator i = filesystem::directory_iterator(directory); i != filesystem::directory_iterator(); ++i) {
 359
 360                 string const t = i->path().string ();
 361
 362                 if (filesystem::is_directory (*i)) {
 363                         scan (files, t);
 364                         continue;
 365                 }
 366
 367                 if (ends_with (t, ".mxf") || ends_with (t, ".ttf")) {
 368                         continue;
 369                 }
 370
 371                 xmlpp::DomParser* p = new xmlpp::DomParser;
 372
 373                 try {
 374                         p->parse_file (t);
 375                 } catch (std::exception& e) {
 376                         delete p;
 377                         continue;
 378                 }
 379
 380                 if (!p) {
 381                         delete p;
 382                         continue;
 383                 }
 384
 385                 string const root = p->get_document()->get_root_node()->get_name ();
 386                 delete p;
 387
 388                 if (root == "CompositionPlaylist") {
 389                         if (files.cpl.empty ()) {
 390                                 files.cpl = t;
 391                         } else {
 392                                 throw DCPReadError ("duplicate CPLs found");
 393                         }
 394                 } else if (root == "PackingList") {
 395                         if (files.pkl.empty ()) {
 396                                 files.pkl = t;
 397                         } else {
 398                                 throw DCPReadError ("duplicate PKLs found");
 399                         }
 400                 } else if (root == "AssetMap") {
 401                         if (files.asset_map.empty ()) {
 402                                 files.asset_map = t;
 403                         } else {
 404                                 throw DCPReadError ("duplicate AssetMaps found");
 405                         }
 406                         files.asset_map = t;
 407                 } else if (root == "DCSubtitle") {
 408                         files.subtitles.push_back (t);
 409                 }
 410         }
 411 }
 412
 413
 414 list<string>
 415 DCP::equals (DCP const & other, EqualityOptions opt) const
 416 {
 417         list<string> notes;
 418
 419         if (opt.flags & LIBDCP_METADATA) {
 420                 if (_name != other._name) {
 421                         notes.push_back ("names differ");
 422                 }
 423                 if (_content_kind != other._content_kind) {
 424                         notes.push_back ("content kinds differ");
 425                 }
 426                 if (_fps != other._fps) {
 427                         notes.push_back ("frames per second differ");
 428                 }
 429                 if (_length != other._length) {
 430                         notes.push_back ("lengths differ");
 431                 }
 432         }
 433
 434         if (_reels.size() != other._reels.size()) {
 435                 notes.push_back ("reel counts differ");
 436         }
 437
 438         list<shared_ptr<const Reel> >::const_iterator a = _reels.begin ();
 439         list<shared_ptr<const Reel> >::const_iterator b = other._reels.begin ();
 440
 441         while (a != _reels.end ()) {
 442                 list<string> n = (*a)->equals (*b, opt);
 443                 notes.merge (n);
 444                 ++a;
 445                 ++b;
 446         }
 447
 448         return notes;
 449 }
 450