X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=tools%2Fdcpdiff.cc;h=af0e18548419a51a989d40f3b7a3c32b73a80398;hb=9c69468557794b9b1230df459dccdebdb561d52d;hp=0b6ffd92b5f92e52960741336103577237922f4f;hpb=eb68e2a85f132cc2e75547a71484254fba17c4ac;p=libdcp.git diff --git a/tools/dcpdiff.cc b/tools/dcpdiff.cc index 0b6ffd92..af0e1854 100644 --- a/tools/dcpdiff.cc +++ b/tools/dcpdiff.cc @@ -1,62 +1,194 @@ -#include -#include -#include +/* + Copyright (C) 2012-2014 Carl Hetherington + + This file is part of libdcp. + + libdcp is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + libdcp is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with libdcp. If not, see . + + In addition, as a special exception, the copyright holders give + permission to link the code of portions of this program with the + OpenSSL library under certain conditions as described in each + individual source file, and distribute linked combinations + including the two. + + You must obey the GNU General Public License in all respects + for all of the code used other than OpenSSL. If you modify + file(s) with this exception, you may extend this exception to your + version of the file(s), but you are not obligated to do so. If you + do not wish to do so, delete this exception statement from your + version. If you delete this exception statement from all source + files in the program, then also delete it here. +*/ + #include "dcp.h" #include "exceptions.h" +#include "common.h" +#include "mxf.h" +#include +#include +#include +#include +#include +#include + +using std::list; +using std::cerr; +using std::cout; +using std::string; +using boost::shared_ptr; +using boost::optional; +using boost::dynamic_pointer_cast; +using namespace dcp; -using namespace std; -using namespace boost; -using namespace libdcp; +static bool verbose = false; static void help (string n) { cerr << "Syntax: " << n << " [OPTION] \n" - << " -b, --bitwise bitwise check\n" - << " -v, --version show libdcp version\n" - << " -d, --verbose be verbose\n" - << " -h, --help show this help\n" + << " -V, --version show libdcp version\n" + << " -h, --help show this help\n" + << " -v, --verbose be verbose\n" + << " --cpl-annotation-texts allow differing CPL annotation texts\n" + << " --reel-annotation-texts allow differing reel annotation texts\n" + << " -a, --annotation-texts allow different CPL and reel annotation texts\n" + << " -d, --issue-dates allow different issue dates\n" + << " -m, --mean-pixel maximum allowed mean pixel error (default 5)\n" + << " -s, --std-dev-pixel maximum allowed standard deviation of pixel error (default 5)\n" + << " --key hexadecimal key to use to decrypt MXFs\n" + << " -k, --keep-going carry on in the event of errors, if possible\n" + << " --ignore-missing-assets ignore missing asset files\n" << "\n" << "The s are the DCP directories to compare.\n" - << "Default is to compare metadata and content, ignoring timestamps\n" - << "and differing UUIDs. Pass -b to perform a bitwise comparison.\n"; + << "Comparison is of metadata and content, ignoring timestamps\n" + << "and differing UUIDs.\n"; +} + +void +note (NoteType t, string n) +{ + if (t == DCP_ERROR || verbose) { + cout << " " << n << "\n"; + cout.flush (); + } +} + +DCP * +load_dcp (boost::filesystem::path path, bool keep_going, bool ignore_missing_assets, optional key) +{ + DCP* dcp = 0; + try { + dcp = new DCP (path); + DCP::ReadErrors errors; + dcp->read (keep_going, &errors); + filter_errors (errors, ignore_missing_assets); + for (DCP::ReadErrors::const_iterator i = errors.begin(); i != errors.end(); ++i) { + cerr << (*i)->what() << "\n"; + } + + if (key) { + list > assets = dcp->assets (); + for (list >::const_iterator i = assets.begin(); i != assets.end(); ++i) { + shared_ptr mxf = dynamic_pointer_cast (*i); + if (mxf) { + mxf->set_key (Key (key.get ())); + } + } + } + + } catch (FileError& e) { + cerr << "Could not read DCP " << path.string() << "; " << e.what() << " " << e.filename() << "\n"; + exit (EXIT_FAILURE); + } + + return dcp; } int main (int argc, char* argv[]) { EqualityOptions options; - options.flags = EqualityFlags (LIBDCP_METADATA | MXF_INSPECT); - options.verbose = false; - + options.max_mean_pixel_error = 5; + options.max_std_dev_pixel_error = 5; + options.reel_hashes_can_differ = true; + options.reel_annotation_texts_can_differ = false; + options.keep_going = false; + bool ignore_missing_assets = false; + optional key; + int option_index = 0; while (1) { static struct option long_options[] = { - { "bitwise", no_argument, 0, 'b'}, - { "version", no_argument, 0, 'v'}, + { "version", no_argument, 0, 'V'}, { "help", no_argument, 0, 'h'}, - { "verbose", no_argument, 0, 'd'}, + { "verbose", no_argument, 0, 'v'}, + { "mean-pixel", required_argument, 0, 'm'}, + { "std-dev-pixel", required_argument, 0, 's'}, + { "keep-going", no_argument, 0, 'k'}, + { "annotation-texts", no_argument, 0, 'a'}, + { "issue-dates", no_argument, 0, 'd'}, + /* From here we're using random capital letters for the short option */ + { "ignore-missing-assets", no_argument, 0, 'A'}, + { "cpl-annotation-texts", no_argument, 0, 'C'}, + { "key", required_argument, 0, 'D'}, + { "reel-annotation-texts", no_argument, 0, 'E'}, { 0, 0, 0, 0 } }; - int c = getopt_long (argc, argv, "bvhd", long_options, &option_index); + int c = getopt_long (argc, argv, "Vhvm:s:kadACD:E", long_options, &option_index); if (c == -1) { break; } switch (c) { - case 'b': - options.flags = EqualityFlags (options.flags | MXF_BITWISE); - break; - case 'v': + case 'V': cout << "dcpdiff version " << LIBDCP_VERSION << "\n"; exit (EXIT_SUCCESS); case 'h': help (argv[0]); exit (EXIT_SUCCESS); + case 'v': + verbose = true; + break; + case 'm': + options.max_mean_pixel_error = atof (optarg); + break; + case 's': + options.max_std_dev_pixel_error = atof (optarg); + break; + case 'k': + options.keep_going = true; + break; + case 'a': + options.cpl_annotation_texts_can_differ = options.reel_annotation_texts_can_differ = true; + break; case 'd': - options.verbose = true; + options.issue_dates_can_differ = true; + break; + case 'A': + ignore_missing_assets = true; + break; + case 'B': + case 'C': + options.cpl_annotation_texts_can_differ = true; + break; + case 'D': + key = string (optarg); + break; + case 'E': + options.reel_annotation_texts_can_differ = true; break; } } @@ -66,44 +198,23 @@ main (int argc, char* argv[]) exit (EXIT_FAILURE); } - if (!filesystem::exists (argv[optind])) { + if (!boost::filesystem::exists (argv[optind])) { cerr << argv[0] << ": DCP " << argv[optind] << " not found.\n"; exit (EXIT_FAILURE); } - if (!filesystem::exists (argv[optind + 1])) { + if (!boost::filesystem::exists (argv[optind + 1])) { cerr << argv[0] << ": DCP " << argv[optind + 1] << " not found.\n"; exit (EXIT_FAILURE); } - DCP* a = 0; - try { - a = new DCP (argv[optind]); - } catch (FileError& e) { - cerr << "Could not read DCP " << argv[optind] << "; " << e.what() << " " << e.filename() << "\n"; - exit (EXIT_FAILURE); - } - - DCP* b = 0; - try { - b = new DCP (argv[optind + 1]); - } catch (FileError& e) { - cerr << "Could not read DCP " << argv[optind + 1] << "; " << e.what() << " " << e.filename() << "\n"; - exit (EXIT_FAILURE); - } + DCP* a = load_dcp (argv[optind], options.keep_going, ignore_missing_assets, key); + DCP* b = load_dcp (argv[optind + 1], options.keep_going, ignore_missing_assets, key); - options.max_mean_pixel_error = 5; - options.max_std_dev_pixel_error = 5; + /* I think this is just below the LSB at 16-bits (ie the 8th most significant bit at 24-bit) */ + options.max_audio_sample_error = 255; - list notes = a->equals (*b, options); - if (notes.empty ()) { - cout << "DCPs equal\n"; - exit (EXIT_SUCCESS); - } - - for (list::iterator i = notes.begin(); i != notes.end(); ++i) { - cout << " " << *i << "\n"; - } + bool const equals = a->equals (*b, options, boost::bind (note, _1, _2)); - exit (EXIT_FAILURE); + exit (equals ? EXIT_SUCCESS : EXIT_FAILURE); }