Allow verification of 428-7-2014 subtitles.
[libdcp.git] / src / verify.cc
index b554612b1480641f2bb1cce07df9f1889b4f4e93..7cc6d3572b69fcc5897e6cf4a7262586f404fd29 100644 (file)
@@ -79,6 +79,7 @@
 #include <boost/algorithm/string.hpp>
 #include <iostream>
 #include <map>
+#include <regex>
 #include <set>
 #include <vector>
 
@@ -241,7 +242,8 @@ public:
                add("http://www.digicine.com/PROTO-ASDCP-AM-20040311.xsd", "PROTO-ASDCP-AM-20040311.xsd");
                add("http://www.digicine.com/PROTO-ASDCP-CC-CPL-20070926#", "PROTO-ASDCP-CC-CPL-20070926.xsd");
                add("interop-subs", "DCSubtitle.v1.mattsson.xsd");
-               add("http://www.smpte-ra.org/schemas/428-7/2010/DCST.xsd", "SMPTE-428-7-2010-DCST.xsd");
+               add("http://www.smpte-ra.org/schemas/428-7/2010/DCST.xsd", "DCDMSubtitle-2010.xsd");
+               add("http://www.smpte-ra.org/schemas/428-7/2014/DCST.xsd", "DCDMSubtitle-2014.xsd");
                add("http://www.smpte-ra.org/schemas/429-16/2014/CPL-Metadata", "SMPTE-429-16.xsd");
                add("http://www.dolby.com/schemas/2012/AD", "Dolby-2012-AD.xsd");
                add("http://www.smpte-ra.org/schemas/429-10/2008/Main-Stereo-Picture-CPL", "SMPTE-429-10-2008.xsd");
@@ -277,7 +279,7 @@ private:
 static void
 parse (XercesDOMParser& parser, boost::filesystem::path xml)
 {
-       parser.parse(xml.string().c_str());
+       parser.parse(xml.c_str());
 }
 
 
@@ -320,6 +322,7 @@ validate_xml (T xml, boost::filesystem::path xsd_dtd_directory, vector<Verificat
                schema.push_back("PROTO-ASDCP-AM-20040311.xsd");
                schema.push_back("DCSubtitle.v1.mattsson.xsd");
                schema.push_back("DCDMSubtitle-2010.xsd");
+               schema.push_back("DCDMSubtitle-2014.xsd");
                schema.push_back("PROTO-ASDCP-CC-CPL-20070926.xsd");
                schema.push_back("SMPTE-429-16.xsd");
                schema.push_back("Dolby-2012-AD.xsd");
@@ -487,27 +490,32 @@ verify_main_picture_asset (
        shared_ptr<const ReelPictureAsset> reel_asset,
        function<void (string, optional<boost::filesystem::path>)> stage,
        function<void (float)> progress,
+       VerificationOptions options,
        vector<VerificationNote>& notes
        )
 {
        auto asset = reel_asset->asset();
        auto const file = *asset->file();
-       stage ("Checking picture asset hash", file);
-       auto const r = verify_asset (dcp, reel_asset, progress);
-       switch (r) {
-               case VerifyAssetResult::BAD:
-                       notes.push_back ({
-                               VerificationNote::Type::ERROR, VerificationNote::Code::INCORRECT_PICTURE_HASH, file
-                       });
-                       break;
-               case VerifyAssetResult::CPL_PKL_DIFFER:
-                       notes.push_back ({
-                               VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_PICTURE_HASHES, file
-                       });
-                       break;
-               default:
-                       break;
+
+       if (options.check_asset_hashes && (!options.maximum_asset_size_for_hash_check || boost::filesystem::file_size(file) < *options.maximum_asset_size_for_hash_check)) {
+               stage ("Checking picture asset hash", file);
+               auto const r = verify_asset (dcp, reel_asset, progress);
+               switch (r) {
+                       case VerifyAssetResult::BAD:
+                               notes.push_back ({
+                                       VerificationNote::Type::ERROR, VerificationNote::Code::INCORRECT_PICTURE_HASH, file
+                               });
+                               break;
+                       case VerifyAssetResult::CPL_PKL_DIFFER:
+                               notes.push_back ({
+                                       VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_PICTURE_HASHES, file
+                               });
+                               break;
+                       default:
+                               break;
+               }
        }
+
        stage ("Checking picture frame sizes", asset->file());
        verify_picture_asset (reel_asset, file, notes, progress);
 
@@ -570,30 +578,35 @@ verify_main_sound_asset (
        shared_ptr<const ReelSoundAsset> reel_asset,
        function<void (string, optional<boost::filesystem::path>)> stage,
        function<void (float)> progress,
+       VerificationOptions options,
        vector<VerificationNote>& notes
        )
 {
        auto asset = reel_asset->asset();
-       stage ("Checking sound asset hash", asset->file());
-       auto const r = verify_asset (dcp, reel_asset, progress);
-       switch (r) {
-               case VerifyAssetResult::BAD:
-                       notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::INCORRECT_SOUND_HASH, *asset->file()});
-                       break;
-               case VerifyAssetResult::CPL_PKL_DIFFER:
-                       notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_SOUND_HASHES, *asset->file()});
-                       break;
-               default:
-                       break;
+       auto const file = *asset->file();
+
+       if (options.check_asset_hashes && (!options.maximum_asset_size_for_hash_check || boost::filesystem::file_size(file) < *options.maximum_asset_size_for_hash_check)) {
+               stage("Checking sound asset hash", file);
+               auto const r = verify_asset (dcp, reel_asset, progress);
+               switch (r) {
+                       case VerifyAssetResult::BAD:
+                               notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::INCORRECT_SOUND_HASH, file});
+                               break;
+                       case VerifyAssetResult::CPL_PKL_DIFFER:
+                               notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_SOUND_HASHES, file});
+                               break;
+                       default:
+                               break;
+               }
        }
 
-       stage ("Checking sound asset metadata", asset->file());
+       stage ("Checking sound asset metadata", file);
 
        if (auto lang = asset->language()) {
                verify_language_tag (*lang, notes);
        }
        if (asset->sampling_rate() != 48000) {
-               notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_SOUND_FRAME_RATE, raw_convert<string>(asset->sampling_rate()), *asset->file()});
+               notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_SOUND_FRAME_RATE, raw_convert<string>(asset->sampling_rate()), file});
        }
 }
 
@@ -687,6 +700,16 @@ verify_smpte_timed_text_asset (
 }
 
 
+/** Verify Interop subtitle-only stuff */
+void
+verify_interop_subtitle_asset(shared_ptr<const InteropSubtitleAsset> asset, vector<VerificationNote>& notes)
+{
+       if (asset->subtitles().empty()) {
+               notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::MISSING_SUBTITLE, asset->id(), asset->file().get() });
+       }
+}
+
+
 /** Verify SMPTE subtitle-only stuff */
 void
 verify_smpte_subtitle_asset (
@@ -716,6 +739,17 @@ verify_smpte_subtitle_asset (
        } else {
                notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSED_CHECK_OF_ENCRYPTED});
        }
+
+       if (asset->raw_xml()) {
+               /* Deluxe require this in their QC even if it seems never to be mentioned in any standard */
+               cxml::Document doc("SubtitleReel");
+               doc.read_string(*asset->raw_xml());
+               auto issue_date = doc.string_child("IssueDate");
+               std::regex reg("^\\d\\d\\d\\d-\\d\\d-\\d\\dT\\d\\d:\\d\\d:\\d\\d$");
+               if (!std::regex_match(issue_date, reg)) {
+                       notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::INVALID_SUBTITLE_ISSUE_DATE, issue_date});
+               }
+       }
 }
 
 
@@ -740,6 +774,11 @@ verify_subtitle_asset (
                notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSED_CHECK_OF_ENCRYPTED});
        }
 
+       auto interop = dynamic_pointer_cast<const InteropSubtitleAsset>(asset);
+       if (interop) {
+               verify_interop_subtitle_asset(interop, notes);
+       }
+
        auto smpte = dynamic_pointer_cast<const SMPTESubtitleAsset>(asset);
        if (smpte) {
                verify_smpte_timed_text_asset (smpte, reel_asset_duration, notes);
@@ -1248,7 +1287,7 @@ pkl_has_encrypted_assets(shared_ptr<const DCP> dcp, shared_ptr<const PKL> pkl)
                }
        }
 
-       for (auto i: pkl->asset_list()) {
+       for (auto i: pkl->assets()) {
                if (find(encrypted.begin(), encrypted.end(), i->id()) != encrypted.end()) {
                        return true;
                }
@@ -1268,6 +1307,7 @@ verify_reel(
        function<void (string, optional<boost::filesystem::path>)> stage,
        boost::filesystem::path xsd_dtd_directory,
        function<void (float)> progress,
+       VerificationOptions options,
        vector<VerificationNote>& notes,
        State& state,
        bool* have_main_subtitle,
@@ -1321,7 +1361,7 @@ verify_reel(
                }
                /* Check asset */
                if (reel->main_picture()->asset_ref().resolved()) {
-                       verify_main_picture_asset(dcp, reel->main_picture(), stage, progress, notes);
+                       verify_main_picture_asset(dcp, reel->main_picture(), stage, progress, options, notes);
                        auto const asset_size = reel->main_picture()->asset()->size();
                        if (main_picture_active_area) {
                                if (main_picture_active_area->width > asset_size.width) {
@@ -1345,7 +1385,7 @@ verify_reel(
        }
 
        if (reel->main_sound() && reel->main_sound()->asset_ref().resolved()) {
-               verify_main_sound_asset(dcp, reel->main_sound(), stage, progress, notes);
+               verify_main_sound_asset(dcp, reel->main_sound(), stage, progress, options, notes);
        }
 
        if (reel->main_subtitle()) {
@@ -1391,6 +1431,7 @@ verify_cpl(
        function<void (string, optional<boost::filesystem::path>)> stage,
        boost::filesystem::path xsd_dtd_directory,
        function<void (float)> progress,
+       VerificationOptions options,
        vector<VerificationNote>& notes,
        State& state
        )
@@ -1450,7 +1491,7 @@ verify_cpl(
 
                /* Check that any PKL with a single CPL has its AnnotationText the same as the CPL's ContentTitleText */
                optional<string> required_annotation_text;
-               for (auto j: i->asset_list()) {
+               for (auto j: i->assets()) {
                        /* See if this is a CPL */
                        for (auto k: dcp->cpls()) {
                                if (j->id() == k->id()) {
@@ -1508,6 +1549,7 @@ verify_cpl(
                        stage,
                        xsd_dtd_directory,
                        progress,
+                       options,
                        notes,
                        state,
                        &have_main_subtitle,
@@ -1628,7 +1670,7 @@ verify_pkl(
        }
 
        set<string> uuid_set;
-       for (auto asset: pkl->asset_list()) {
+       for (auto asset: pkl->assets()) {
                if (!uuid_set.insert(asset->id()).second) {
                        notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::DUPLICATE_ASSET_ID_IN_PKL, pkl->id(), pkl->file().get()});
                        break;
@@ -1646,7 +1688,18 @@ verify_assetmap(
        vector<VerificationNote>& notes
        )
 {
-       validate_xml(dcp->asset_map_path().get(), xsd_dtd_directory, notes);
+       auto asset_map = dcp->asset_map();
+       DCP_ASSERT(asset_map);
+
+       validate_xml(asset_map->file().get(), xsd_dtd_directory, notes);
+
+       set<string> uuid_set;
+       for (auto const& asset: asset_map->assets()) {
+               if (!uuid_set.insert(asset.id()).second) {
+                       notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::DUPLICATE_ASSET_ID_IN_ASSETMAP, asset_map->id(), asset_map->file().get()});
+                       break;
+               }
+       }
 }
 
 
@@ -1655,6 +1708,7 @@ dcp::verify (
        vector<boost::filesystem::path> directories,
        function<void (string, optional<boost::filesystem::path>)> stage,
        function<void (float)> progress,
+       VerificationOptions options,
        optional<boost::filesystem::path> xsd_dtd_directory
        )
 {
@@ -1704,6 +1758,7 @@ dcp::verify (
                                stage,
                                *xsd_dtd_directory,
                                progress,
+                               options,
                                notes,
                                state
                                );
@@ -1714,8 +1769,8 @@ dcp::verify (
                        verify_pkl(dcp, pkl, *xsd_dtd_directory, notes);
                }
 
-               if (dcp->asset_map_path()) {
-                       stage ("Checking ASSETMAP", dcp->asset_map_path().get());
+               if (dcp->asset_map_file()) {
+                       stage("Checking ASSETMAP", dcp->asset_map_file().get());
                        verify_assetmap(dcp, *xsd_dtd_directory, notes);
                } else {
                        notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::MISSING_ASSETMAP});
@@ -1925,6 +1980,12 @@ dcp::note_to_string (VerificationNote note)
                return String::compose("<MainPictureActiveaArea> has an invalid value: %1", note.note().get());
        case VerificationNote::Code::DUPLICATE_ASSET_ID_IN_PKL:
                return String::compose("The PKL %1 has more than one asset with the same ID", note.note().get());
+       case VerificationNote::Code::DUPLICATE_ASSET_ID_IN_ASSETMAP:
+               return String::compose("The ASSETMAP %1 has more than one asset with the same ID", note.note().get());
+       case VerificationNote::Code::MISSING_SUBTITLE:
+               return String::compose("The subtitle asset %1 has no subtitles", note.note().get());
+       case VerificationNote::Code::INVALID_SUBTITLE_ISSUE_DATE:
+               return String::compose("<IssueDate> has an invalid value: %1", note.note().get());
        }
 
        return "";