tools/dcpverify.cc

   1 /*
   2     Copyright (C) 2020 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 "verify.h"
  35 #include "compose.hpp"
  36 #include "common.h"
  37 #include <boost/bind.hpp>
  38 #include <boost/optional.hpp>
  39 #include <boost/filesystem.hpp>
  40 #include <getopt.h>
  41 #include <iostream>
  42 #include <cstdlib>
  43
  44 using std::cout;
  45 using std::cerr;
  46 using std::string;
  47 using std::vector;
  48 using std::list;
  49 using boost::bind;
  50 using boost::optional;
  51
  52 static void
  53 help (string n)
  54 {
  55         cerr << "Syntax: " << n << " [OPTION] <DCP>\n"
  56              << "  -V, --version           show libdcp version\n"
  57              << "  -h, --help              show this help\n"
  58              << "  --ignore-missing-assets don't give errors about missing assets\n"
  59              << "  --ignore-bv21-smpte     don't give the SMPTE Bv2.1 error about a DCP not being SMPTE\n"
  60              << "  -q, --quiet             don't report progress\n";
  61 }
  62
  63
  64 int
  65 main (int argc, char* argv[])
  66 {
  67         dcp::init ();
  68
  69         bool ignore_missing_assets = false;
  70         bool ignore_bv21_smpte = false;
  71         bool quiet = false;
  72
  73         int option_index = 0;
  74         while (true) {
  75                 static struct option long_options[] = {
  76                         { "version", no_argument, 0, 'V' },
  77                         { "help", no_argument, 0, 'h' },
  78                         { "ignore-missing-assets", no_argument, 0, 'A' },
  79                         { "ignore-bv21-smpte", no_argument, 0, 'B' },
  80                         { "quiet", no_argument, 0, 'q' },
  81                         { 0, 0, 0, 0 }
  82                 };
  83
  84                 int c = getopt_long (argc, argv, "VhABq", long_options, &option_index);
  85
  86                 if (c == -1) {
  87                         break;
  88                 } else if (c == '?' || c == ':') {
  89                         exit(EXIT_FAILURE);
  90                 }
  91
  92                 switch (c) {
  93                 case 'V':
  94                         cout << "dcpverify version " << LIBDCP_VERSION << "\n";
  95                         exit (EXIT_SUCCESS);
  96                 case 'h':
  97                         help (argv[0]);
  98                         exit (EXIT_SUCCESS);
  99                 case 'A':
 100                         ignore_missing_assets = true;
 101                         break;
 102                 case 'B':
 103                         ignore_bv21_smpte = true;
 104                         break;
 105                 case 'q':
 106                         quiet = true;
 107                         break;
 108                 }
 109         }
 110
 111         if (argc <= optind) {
 112                 help (argv[0]);
 113                 exit (EXIT_FAILURE);
 114         }
 115
 116         if (!boost::filesystem::exists (argv[optind])) {
 117                 cerr << argv[0] << ": DCP " << argv[optind] << " not found.\n";
 118                 exit (EXIT_FAILURE);
 119         }
 120
 121         auto stage = [quiet](string s, optional<boost::filesystem::path> path) {
 122                 if (quiet) {
 123                         return;
 124                 }
 125
 126                 if (path) {
 127                         cout << s << ": " << path->string() << "\n";
 128                 } else {
 129                         cout << s << "\n";
 130                 }
 131         };
 132
 133         auto progress = [quiet](float amount) {
 134                 if (quiet) {
 135                         return;
 136                 }
 137                 int const width = 60;
 138                 int const index = std::rint(amount * width);
 139                 cout << "[";
 140                 for (int i = 0; i < width; ++i) {
 141                         if (i < index) {
 142                                 std::cout << "=";
 143                         } else if (i == index) {
 144                                 std::cout << ">";
 145                         } else {
 146                                 std::cout << " ";
 147                         }
 148                 }
 149                 cout << "] " << std::rint(amount * 100) << "%\r";
 150                 cout.flush();
 151         };
 152
 153         vector<boost::filesystem::path> directories;
 154         directories.push_back (argv[optind]);
 155         auto notes = dcp::verify(directories, stage, progress);
 156         dcp::filter_notes (notes, ignore_missing_assets);
 157
 158         if (!quiet) {
 159                 cout << "\n";
 160         }
 161
 162         bool failed = false;
 163         bool bv21_failed = false;
 164         bool warned = false;
 165         for (auto i: notes) {
 166                 if (ignore_bv21_smpte && i.code() == dcp::VerificationNote::Code::INVALID_STANDARD) {
 167                         continue;
 168                 }
 169                 switch (i.type()) {
 170                 case dcp::VerificationNote::Type::ERROR:
 171                         cout << "Error: " << note_to_string(i) << "\n";
 172                         failed = true;
 173                         break;
 174                 case dcp::VerificationNote::Type::BV21_ERROR:
 175                         cout << "Bv2.1 error: " << note_to_string(i) << "\n";
 176                         bv21_failed = true;
 177                         break;
 178                 case dcp::VerificationNote::Type::WARNING:
 179                         cout << "Warning: " << note_to_string(i) << "\n";
 180                         warned = true;
 181                         break;
 182                 }
 183         }
 184
 185         if (!failed && !quiet) {
 186                 if (bv21_failed || warned) {
 187                         cout << "\n";
 188                 }
 189                 cout << "DCP verified OK.\n";
 190         }
 191
 192         exit (failed ? EXIT_FAILURE : EXIT_SUCCESS);
 193 }