7a43e9b23e38219483577d8bdf7956f315444b48
[libdcp.git] / 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 <boost/algorithm/string.hpp>
31 #include <libxml++/libxml++.h>
32 #include "dcp.h"
33 #include "asset.h"
34 #include "sound_asset.h"
35 #include "picture_asset.h"
36 #include "subtitle_asset.h"
37 #include "util.h"
38 #include "metadata.h"
39 #include "exceptions.h"
40 #include "parse/pkl.h"
41 #include "parse/asset_map.h"
42 #include "reel.h"
43 #include "cpl.h"
44
45 using std::string;
46 using std::list;
47 using std::stringstream;
48 using std::ofstream;
49 using std::ostream;
50 using boost::shared_ptr;
51 using namespace libdcp;
52
53 DCP::DCP (string directory)
54         : _directory (directory)
55 {
56         boost::filesystem::create_directories (directory);
57 }
58
59 void
60 DCP::write_xml (XMLMetadata const & metadata) const
61 {
62         for (list<shared_ptr<const CPL> >::const_iterator i = _cpls.begin(); i != _cpls.end(); ++i) {
63                 (*i)->write_xml (metadata);
64         }
65
66         string pkl_uuid = make_uuid ();
67         string pkl_path = write_pkl (pkl_uuid, metadata);
68         
69         write_volindex ();
70         write_assetmap (pkl_uuid, boost::filesystem::file_size (pkl_path), metadata);
71 }
72
73 std::string
74 DCP::write_pkl (string pkl_uuid, XMLMetadata const & metadata) const
75 {
76         assert (!_cpls.empty ());
77         
78         boost::filesystem::path p;
79         p /= _directory;
80         stringstream s;
81         s << pkl_uuid << "_pkl.xml";
82         p /= s.str();
83         ofstream pkl (p.string().c_str());
84
85         pkl << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
86             << "<PackingList xmlns=\"http://www.smpte-ra.org/schemas/429-8/2007/PKL\">\n"
87             << "  <Id>urn:uuid:" << pkl_uuid << "</Id>\n"
88                 /* XXX: this is a bit of a hack */
89             << "  <AnnotationText>" << _cpls.front()->name() << "</AnnotationText>\n"
90             << "  <IssueDate>" << metadata.issue_date << "</IssueDate>\n"
91             << "  <Issuer>" << metadata.issuer << "</Issuer>\n"
92             << "  <Creator>" << metadata.creator << "</Creator>\n"
93             << "  <AssetList>\n";
94
95         list<shared_ptr<const Asset> > a = assets ();
96         for (list<shared_ptr<const Asset> >::const_iterator i = a.begin(); i != a.end(); ++i) {
97                 (*i)->write_to_pkl (pkl);
98         }
99
100         for (list<shared_ptr<const CPL> >::const_iterator i = _cpls.begin(); i != _cpls.end(); ++i) {
101                 (*i)->write_to_pkl (pkl);
102         }
103
104         pkl << "  </AssetList>\n"
105             << "</PackingList>\n";
106
107         return p.string ();
108 }
109
110 void
111 DCP::write_volindex () const
112 {
113         boost::filesystem::path p;
114         p /= _directory;
115         p /= "VOLINDEX.xml";
116         ofstream vi (p.string().c_str());
117
118         vi << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
119            << "<VolumeIndex xmlns=\"http://www.smpte-ra.org/schemas/429-9/2007/AM\">\n"
120            << "  <Index>1</Index>\n"
121            << "</VolumeIndex>\n";
122 }
123
124 void
125 DCP::write_assetmap (string pkl_uuid, int pkl_length, XMLMetadata const & metadata) const
126 {
127         boost::filesystem::path p;
128         p /= _directory;
129         p /= "ASSETMAP.xml";
130         ofstream am (p.string().c_str());
131
132         am << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
133            << "<AssetMap xmlns=\"http://www.smpte-ra.org/schemas/429-9/2007/AM\">\n"
134            << "  <Id>urn:uuid:" << make_uuid() << "</Id>\n"
135            << "  <Creator>" << metadata.creator << "</Creator>\n"
136            << "  <VolumeCount>1</VolumeCount>\n"
137            << "  <IssueDate>" << metadata.issue_date << "</IssueDate>\n"
138            << "  <Issuer>" << metadata.issuer << "</Issuer>\n"
139            << "  <AssetList>\n";
140
141         am << "    <Asset>\n"
142            << "      <Id>urn:uuid:" << pkl_uuid << "</Id>\n"
143            << "      <PackingList>true</PackingList>\n"
144            << "      <ChunkList>\n"
145            << "        <Chunk>\n"
146            << "          <Path>" << pkl_uuid << "_pkl.xml</Path>\n"
147            << "          <VolumeIndex>1</VolumeIndex>\n"
148            << "          <Offset>0</Offset>\n"
149            << "          <Length>" << pkl_length << "</Length>\n"
150            << "        </Chunk>\n"
151            << "      </ChunkList>\n"
152            << "    </Asset>\n";
153         
154         for (list<shared_ptr<const CPL> >::const_iterator i = _cpls.begin(); i != _cpls.end(); ++i) {
155                 (*i)->write_to_assetmap (am);
156         }
157
158         list<shared_ptr<const Asset> > a = assets ();
159         for (list<shared_ptr<const Asset> >::const_iterator i = a.begin(); i != a.end(); ++i) {
160                 (*i)->write_to_assetmap (am);
161         }
162
163         am << "  </AssetList>\n"
164            << "</AssetMap>\n";
165 }
166
167
168 void
169 DCP::read (bool require_mxfs)
170 {
171         Files files;
172
173         shared_ptr<parse::AssetMap> asset_map;
174         try {
175                 boost::filesystem::path p = _directory;
176                 p /= "ASSETMAP";
177                 if (boost::filesystem::exists (p)) {
178                         asset_map.reset (new libdcp::parse::AssetMap (p.string ()));
179                 } else {
180                         p = _directory;
181                         p /= "ASSETMAP.xml";
182                         if (boost::filesystem::exists (p)) {
183                                 asset_map.reset (new libdcp::parse::AssetMap (p.string ()));
184                         } else {
185                                 boost::throw_exception (DCPReadError ("could not find AssetMap file"));
186                         }
187                 }
188                 
189         } catch (FileError& e) {
190                 boost::throw_exception (FileError ("could not load AssetMap file", files.asset_map));
191         }
192
193         for (list<shared_ptr<libdcp::parse::AssetMapAsset> >::const_iterator i = asset_map->assets.begin(); i != asset_map->assets.end(); ++i) {
194                 if ((*i)->chunks.size() != 1) {
195                         boost::throw_exception (XMLError ("unsupported asset chunk count"));
196                 }
197
198                 boost::filesystem::path t = _directory;
199                 t /= (*i)->chunks.front()->path;
200                 
201                 if (boost::algorithm::ends_with (t.string(), ".mxf") || boost::algorithm::ends_with (t.string(), ".ttf")) {
202                         continue;
203                 }
204
205                 xmlpp::DomParser* p = new xmlpp::DomParser;
206                 try {
207                         p->parse_file (t.string());
208                 } catch (std::exception& e) {
209                         delete p;
210                         continue;
211                 }
212
213                 string const root = p->get_document()->get_root_node()->get_name ();
214                 delete p;
215
216                 if (root == "CompositionPlaylist") {
217                         files.cpls.push_back (t.string());
218                 } else if (root == "PackingList") {
219                         if (files.pkl.empty ()) {
220                                 files.pkl = t.string();
221                         } else {
222                                 boost::throw_exception (DCPReadError ("duplicate PKLs found"));
223                         }
224                 }
225         }
226         
227         if (files.cpls.empty ()) {
228                 boost::throw_exception (FileError ("no CPL files found", ""));
229         }
230
231         if (files.pkl.empty ()) {
232                 boost::throw_exception (FileError ("no PKL file found", ""));
233         }
234
235         shared_ptr<parse::PKL> pkl;
236         try {
237                 pkl.reset (new parse::PKL (files.pkl));
238         } catch (FileError& e) {
239                 boost::throw_exception (FileError ("could not load PKL file", files.pkl));
240         }
241
242         /* Cross-check */
243         /* XXX */
244
245         for (list<string>::iterator i = files.cpls.begin(); i != files.cpls.end(); ++i) {
246                 _cpls.push_back (shared_ptr<CPL> (new CPL (_directory, *i, asset_map, require_mxfs)));
247         }
248 }
249
250 bool
251 DCP::equals (DCP const & other, EqualityOptions opt, boost::function<void (NoteType, string)> note) const
252 {
253         if (_cpls.size() != other._cpls.size()) {
254                 note (ERROR, "CPL counts differ");
255                 return false;
256         }
257
258         list<shared_ptr<const CPL> >::const_iterator a = _cpls.begin ();
259         list<shared_ptr<const CPL> >::const_iterator b = other._cpls.begin ();
260
261         while (a != _cpls.end ()) {
262                 if (!(*a)->equals (*b->get(), opt, note)) {
263                         return false;
264                 }
265                 ++a;
266                 ++b;
267         }
268
269         return true;
270 }
271
272
273 void
274 DCP::add_cpl (shared_ptr<CPL> cpl)
275 {
276         _cpls.push_back (cpl);
277 }
278
279 class AssetComparator
280 {
281 public:
282         bool operator() (shared_ptr<const Asset> a, shared_ptr<const Asset> b) {
283                 return a->uuid() < b->uuid();
284         }
285 };
286
287 list<shared_ptr<const Asset> >
288 DCP::assets () const
289 {
290         list<shared_ptr<const Asset> > a;
291         for (list<shared_ptr<const CPL> >::const_iterator i = _cpls.begin(); i != _cpls.end(); ++i) {
292                 list<shared_ptr<const Asset> > t = (*i)->assets ();
293                 a.merge (t);
294         }
295
296         a.sort ();
297         a.unique ();
298         return a;
299 }
300