X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fverify.cc;h=42ee192119b85280ada83512167a01aaa2a4805d;hb=4dca630057509164494b65c2deeb748a51928c73;hp=e176362aeae3a78e98056eb9842cb6c409607211;hpb=7d66bda50ade8ea618f331b885f1bfa4fa0a2af9;p=libdcp.git

diff --git a/src/verify.cc b/src/verify.cc
index e176362a..42ee1921 100644
--- a/src/verify.cc
+++ b/src/verify.cc
@@ -58,6 +58,7 @@
 #include "stereo_picture_frame.h"
 #include "verify.h"
 #include "verify_j2k.h"
+#include <libxml/parserInternals.h>
 #include <xercesc/dom/DOMAttr.hpp>
 #include <xercesc/dom/DOMDocument.hpp>
 #include <xercesc/dom/DOMError.hpp>
@@ -79,21 +80,23 @@
 #include <boost/algorithm/string.hpp>
 #include <iostream>
 #include <map>
+#include <regex>
+#include <set>
 #include <vector>
 
 
-using std::list;
-using std::vector;
-using std::string;
 using std::cout;
+using std::dynamic_pointer_cast;
+using std::list;
+using std::make_shared;
 using std::map;
 using std::max;
 using std::set;
 using std::shared_ptr;
-using std::make_shared;
+using std::string;
+using std::vector;
 using boost::optional;
 using boost::function;
-using std::dynamic_pointer_cast;
 
 
 using namespace dcp;
@@ -156,22 +159,22 @@ private:
 class DCPErrorHandler : public ErrorHandler
 {
 public:
-	void warning(const SAXParseException& e)
+	void warning(const SAXParseException& e) override
 	{
 		maybe_add (XMLValidationError(e));
 	}
 
-	void error(const SAXParseException& e)
+	void error(const SAXParseException& e) override
 	{
 		maybe_add (XMLValidationError(e));
 	}
 
-	void fatalError(const SAXParseException& e)
+	void fatalError(const SAXParseException& e) override
 	{
 		maybe_add (XMLValidationError(e));
 	}
 
-	void resetErrors() {
+	void resetErrors() override {
 		_errors.clear ();
 	}
 
@@ -240,13 +243,14 @@ 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");
 	}
 
-	InputSource* resolveEntity(XMLCh const *, XMLCh const * system_id)
+	InputSource* resolveEntity(XMLCh const *, XMLCh const * system_id) override
 	{
 		if (!system_id) {
 			return 0;
@@ -276,7 +280,7 @@ private:
 static void
 parse (XercesDOMParser& parser, boost::filesystem::path xml)
 {
-	parser.parse(xml.string().c_str());
+	parser.parse(xml.c_str());
 }
 
 
@@ -319,6 +323,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");
@@ -381,6 +386,12 @@ enum class VerifyAssetResult {
 static VerifyAssetResult
 verify_asset (shared_ptr<const DCP> dcp, shared_ptr<const ReelFileAsset> reel_file_asset, function<void (float)> progress)
 {
+	/* When reading the DCP the hash will have been set to the one from the PKL/CPL.
+	 * We want to calculate the hash of the actual file contents here, so that we
+	 * can check it.  unset_hash() means that this calculation will happen on the
+	 * call to hash().
+	 */
+	reel_file_asset->asset_ref()->unset_hash();
 	auto const actual_hash = reel_file_asset->asset_ref()->hash(progress);
 
 	auto pkls = dcp->pkls();
@@ -445,7 +456,7 @@ verify_picture_asset (shared_ptr<const ReelFileAsset> reel_file_asset, boost::fi
 			biggest_frame = max(biggest_frame, frame->size());
 			if (!mono_asset->encrypted() || mono_asset->key()) {
 				vector<VerificationNote> j2k_notes;
-				verify_j2k (frame, j2k_notes);
+				verify_j2k(frame, i, mono_asset->frame_rate().numerator, j2k_notes);
 				check_and_add (j2k_notes);
 			}
 			progress (float(i) / duration);
@@ -455,10 +466,10 @@ verify_picture_asset (shared_ptr<const ReelFileAsset> reel_file_asset, boost::fi
 		for (int64_t i = 0; i < duration; ++i) {
 			auto frame = reader->get_frame (i);
 			biggest_frame = max(biggest_frame, max(frame->left()->size(), frame->right()->size()));
-			if (!stereo_asset->encrypted() || mono_asset->key()) {
+			if (!stereo_asset->encrypted() || stereo_asset->key()) {
 				vector<VerificationNote> j2k_notes;
-				verify_j2k (frame->left(), j2k_notes);
-				verify_j2k (frame->right(), j2k_notes);
+				verify_j2k(frame->left(), i, stereo_asset->frame_rate().numerator, j2k_notes);
+				verify_j2k(frame->right(), i, stereo_asset->frame_rate().numerator, j2k_notes);
 				check_and_add (j2k_notes);
 			}
 			progress (float(i) / duration);
@@ -486,27 +497,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);
 
@@ -563,36 +579,55 @@ verify_main_picture_asset (
 }
 
 
+struct State
+{
+	boost::optional<string> subtitle_language;
+	boost::optional<int> audio_channels;
+};
+
+
 static void
 verify_main_sound_asset (
 	shared_ptr<const DCP> dcp,
 	shared_ptr<const ReelSoundAsset> reel_asset,
 	function<void (string, optional<boost::filesystem::path>)> stage,
 	function<void (float)> progress,
-	vector<VerificationNote>& notes
+	VerificationOptions options,
+	vector<VerificationNote>& notes,
+	State& state
 	)
 {
 	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;
+		}
+	}
+
+	if (!state.audio_channels) {
+		state.audio_channels = asset->channels();
+	} else if (*state.audio_channels != asset->channels()) {
+		notes.push_back({ VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_SOUND_CHANNEL_COUNTS, file });
 	}
 
-	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});
 	}
 }
 
@@ -629,12 +664,6 @@ verify_closed_caption_reel (shared_ptr<const ReelClosedCaptionAsset> reel_asset,
 }
 
 
-struct State
-{
-	boost::optional<string> subtitle_language;
-};
-
-
 /** Verify stuff that is common to both subtitles and closed captions */
 void
 verify_smpte_timed_text_asset (
@@ -686,6 +715,20 @@ 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() });
+	}
+	auto const unresolved = asset->unresolved_fonts();
+	if (!unresolved.empty()) {
+		notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::MISSING_FONT, unresolved.front() });
+	}
+}
+
+
 /** Verify SMPTE subtitle-only stuff */
 void
 verify_smpte_subtitle_asset (
@@ -703,12 +746,28 @@ verify_smpte_subtitle_asset (
 	}
 
 	DCP_ASSERT (asset->resource_id());
-	if (asset->resource_id().get() != asset->xml_id()) {
-		notes.push_back ({ VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISMATCHED_TIMED_TEXT_RESOURCE_ID });
+	auto xml_id = asset->xml_id();
+	if (xml_id) {
+		if (asset->resource_id().get() != xml_id) {
+			notes.push_back ({ VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISMATCHED_TIMED_TEXT_RESOURCE_ID });
+		}
+
+		if (asset->id() == asset->resource_id().get() || asset->id() == xml_id) {
+			notes.push_back ({ VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INCORRECT_TIMED_TEXT_ASSET_ID });
+		}
+	} else {
+		notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSED_CHECK_OF_ENCRYPTED});
 	}
 
-	if (asset->id() == asset->resource_id().get() || asset->id() == asset->xml_id()) {
-		notes.push_back ({ VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INCORRECT_TIMED_TEXT_ASSET_ID });
+	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});
+		}
 	}
 }
 
@@ -728,12 +787,39 @@ verify_subtitle_asset (
 	/* Note: we must not use SubtitleAsset::xml_as_string() here as that will mean the data on disk
 	 * gets passed through libdcp which may clean up and therefore hide errors.
 	 */
-	validate_xml (asset->raw_xml(), xsd_dtd_directory, notes);
+	if (asset->raw_xml()) {
+		validate_xml (asset->raw_xml().get(), xsd_dtd_directory, notes);
+	} else {
+		notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSED_CHECK_OF_ENCRYPTED});
+	}
+
+	auto namespace_count = [](shared_ptr<const SubtitleAsset> asset, string root_node) {
+		cxml::Document doc(root_node);
+		doc.read_string(asset->raw_xml().get());
+		auto root = dynamic_cast<xmlpp::Element*>(doc.node())->cobj();
+		int count = 0;
+		for (auto ns = root->nsDef; ns != nullptr; ns = ns->next) {
+			++count;
+		}
+		return count;
+	};
+
+	auto interop = dynamic_pointer_cast<const InteropSubtitleAsset>(asset);
+	if (interop) {
+		verify_interop_subtitle_asset(interop, notes);
+		if (namespace_count(asset, "DCSubtitle") > 1) {
+			notes.push_back({ VerificationNote::Type::WARNING, VerificationNote::Code::INCORRECT_SUBTITLE_NAMESPACE_COUNT, asset->id() });
+		}
+	}
 
 	auto smpte = dynamic_pointer_cast<const SMPTESubtitleAsset>(asset);
 	if (smpte) {
 		verify_smpte_timed_text_asset (smpte, reel_asset_duration, notes);
 		verify_smpte_subtitle_asset (smpte, notes, state);
+		/* This asset may be encrypted and in that case we'll have no raw_xml() */
+		if (asset->raw_xml() && namespace_count(asset, "SubtitleReel") > 1) {
+			notes.push_back({ VerificationNote::Type::WARNING, VerificationNote::Code::INCORRECT_SUBTITLE_NAMESPACE_COUNT, asset->id()});
+		}
 	}
 }
 
@@ -752,28 +838,35 @@ verify_closed_caption_asset (
 	/* Note: we must not use SubtitleAsset::xml_as_string() here as that will mean the data on disk
 	 * gets passed through libdcp which may clean up and therefore hide errors.
 	 */
-	validate_xml (asset->raw_xml(), xsd_dtd_directory, notes);
+	auto raw_xml = asset->raw_xml();
+	if (raw_xml) {
+		validate_xml (*raw_xml, xsd_dtd_directory, notes);
+		if (raw_xml->size() > 256 * 1024) {
+			notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_CLOSED_CAPTION_XML_SIZE_IN_BYTES, raw_convert<string>(raw_xml->size()), *asset->file()});
+		}
+	} else {
+		notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSED_CHECK_OF_ENCRYPTED});
+	}
 
 	auto smpte = dynamic_pointer_cast<const SMPTESubtitleAsset>(asset);
 	if (smpte) {
 		verify_smpte_timed_text_asset (smpte, reel_asset_duration, notes);
 	}
-
-	if (asset->raw_xml().size() > 256 * 1024) {
-		notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_CLOSED_CAPTION_XML_SIZE_IN_BYTES, raw_convert<string>(asset->raw_xml().size()), *asset->file()});
-	}
 }
 
 
+/** Check the timing of the individual subtitles and make sure there are no empty <Text> nodes etc. */
 static
 void
-verify_text_timing (
+verify_text_details (
+	dcp::Standard standard,
 	vector<shared_ptr<Reel>> reels,
 	int edit_rate,
 	vector<VerificationNote>& notes,
 	std::function<bool (shared_ptr<Reel>)> check,
-	std::function<string (shared_ptr<Reel>)> xml,
-	std::function<int64_t (shared_ptr<Reel>)> duration
+	std::function<optional<string> (shared_ptr<Reel>)> xml,
+	std::function<int64_t (shared_ptr<Reel>)> duration,
+	std::function<std::string (shared_ptr<Reel>)> id
 	)
 {
 	/* end of last subtitle (in editable units) */
@@ -782,11 +875,22 @@ verify_text_timing (
 	auto too_close = false;
 	auto too_early = false;
 	auto reel_overlap = false;
+	auto empty_text = false;
 	/* current reel start time (in editable units) */
 	int64_t reel_offset = 0;
-
-	std::function<void (cxml::ConstNodePtr, optional<int>, optional<Time>, int, bool)> parse;
-	parse = [&parse, &last_out, &too_short, &too_close, &too_early, &reel_offset](cxml::ConstNodePtr node, optional<int> tcr, optional<Time> start_time, int er, bool first_reel) {
+	optional<string> missing_load_font_id;
+
+	std::function<void (cxml::ConstNodePtr, optional<int>, optional<Time>, int, bool, bool&, vector<string>&)> parse;
+
+	parse = [&parse, &last_out, &too_short, &too_close, &too_early, &empty_text, &reel_offset, &missing_load_font_id](
+		cxml::ConstNodePtr node,
+		optional<int> tcr,
+		optional<Time> start_time,
+		int er,
+		bool first_reel,
+		bool& has_text,
+		vector<string>& font_ids
+		) {
 		if (node->name() == "Subtitle") {
 			Time in (node->string_attribute("TimeIn"), tcr);
 			if (start_time) {
@@ -811,11 +915,38 @@ verify_text_timing (
 				}
 			}
 			last_out = reel_offset + out.as_editable_units_floor(er);
-		} else {
-			for (auto i: node->node_children()) {
-				parse(i, tcr, start_time, er, first_reel);
+		} else if (node->name() == "Text") {
+			std::function<bool (cxml::ConstNodePtr)> node_has_content = [&](cxml::ConstNodePtr node) {
+				if (!node->content().empty()) {
+					return true;
+				}
+				for (auto i: node->node_children()) {
+					if (node_has_content(i)) {
+						return true;
+					}
+				}
+				return false;
+			};
+			if (!node_has_content(node)) {
+				empty_text = true;
+			}
+			has_text = true;
+		} else if (node->name() == "LoadFont") {
+			if (auto const id = node->optional_string_attribute("Id")) {
+				font_ids.push_back(*id);
+			} else if (auto const id = node->optional_string_attribute("ID")) {
+				font_ids.push_back(*id);
+			}
+		} else if (node->name() == "Font") {
+			if (auto const font_id = node->optional_string_attribute("Id")) {
+				if (std::find_if(font_ids.begin(), font_ids.end(), [font_id](string const& id) { return id == font_id; }) == font_ids.end()) {
+					missing_load_font_id = font_id;
+				}
 			}
 		}
+		for (auto i: node->node_children()) {
+			parse(i, tcr, start_time, er, first_reel, has_text, font_ids);
+		}
 	};
 
 	for (auto i = 0U; i < reels.size(); ++i) {
@@ -823,6 +954,12 @@ verify_text_timing (
 			continue;
 		}
 
+		auto reel_xml = xml(reels[i]);
+		if (!reel_xml) {
+			notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSED_CHECK_OF_ENCRYPTED});
+			continue;
+		}
+
 		/* We need to look at <Subtitle> instances in the XML being checked, so we can't use the subtitles
 		 * read in by libdcp's parser.
 		 */
@@ -830,24 +967,32 @@ verify_text_timing (
 		shared_ptr<cxml::Document> doc;
 		optional<int> tcr;
 		optional<Time> start_time;
-		try {
+		switch (standard) {
+		case dcp::Standard::INTEROP:
+			doc = make_shared<cxml::Document>("DCSubtitle");
+			doc->read_string (*reel_xml);
+			break;
+		case dcp::Standard::SMPTE:
 			doc = make_shared<cxml::Document>("SubtitleReel");
-			doc->read_string (xml(reels[i]));
+			doc->read_string (*reel_xml);
 			tcr = doc->number_child<int>("TimeCodeRate");
-			auto start_time_string = doc->optional_string_child("StartTime");
-			if (start_time_string) {
+			if (auto start_time_string = doc->optional_string_child("StartTime")) {
 				start_time = Time(*start_time_string, tcr);
 			}
-		} catch (...) {
-			doc = make_shared<cxml::Document>("DCSubtitle");
-			doc->read_string (xml(reels[i]));
+			break;
 		}
-		parse (doc, tcr, start_time, edit_rate, i == 0);
+		bool has_text = false;
+		vector<string> font_ids;
+		parse(doc, tcr, start_time, edit_rate, i == 0, has_text, font_ids);
 		auto end = reel_offset + duration(reels[i]);
 		if (last_out && *last_out > end) {
 			reel_overlap = true;
 		}
 		reel_offset = end;
+
+		if (standard == dcp::Standard::SMPTE && has_text && font_ids.empty()) {
+			notes.push_back(dcp::VerificationNote(dcp::VerificationNote::Type::ERROR, VerificationNote::Code::MISSING_LOAD_FONT).set_id(id(reels[i])));
+		}
 	}
 
 	if (last_out && *last_out > reel_offset) {
@@ -877,6 +1022,123 @@ verify_text_timing (
 			VerificationNote::Type::ERROR, VerificationNote::Code::SUBTITLE_OVERLAPS_REEL_BOUNDARY
 		});
 	}
+
+	if (empty_text) {
+		notes.push_back ({
+			VerificationNote::Type::WARNING, VerificationNote::Code::EMPTY_TEXT
+		});
+	}
+
+	if (missing_load_font_id) {
+		notes.push_back(dcp::VerificationNote(VerificationNote::Type::ERROR, VerificationNote::Code::MISSING_LOAD_FONT_FOR_FONT).set_id(*missing_load_font_id));
+	}
+}
+
+
+static
+void
+verify_closed_caption_details (
+	vector<shared_ptr<Reel>> reels,
+	vector<VerificationNote>& notes
+	)
+{
+	std::function<void (cxml::ConstNodePtr node, std::vector<cxml::ConstNodePtr>& text_or_image)> find_text_or_image;
+	find_text_or_image = [&find_text_or_image](cxml::ConstNodePtr node, std::vector<cxml::ConstNodePtr>& text_or_image) {
+		for (auto i: node->node_children()) {
+			if (i->name() == "Text") {
+				text_or_image.push_back (i);
+			} else {
+				find_text_or_image (i, text_or_image);
+			}
+		}
+	};
+
+	auto mismatched_valign = false;
+	auto incorrect_order = false;
+
+	std::function<void (cxml::ConstNodePtr)> parse;
+	parse = [&parse, &find_text_or_image, &mismatched_valign, &incorrect_order](cxml::ConstNodePtr node) {
+		if (node->name() == "Subtitle") {
+			vector<cxml::ConstNodePtr> text_or_image;
+			find_text_or_image (node, text_or_image);
+			optional<string> last_valign;
+			optional<float> last_vpos;
+			for (auto i: text_or_image) {
+				auto valign = i->optional_string_attribute("VAlign");
+				if (!valign) {
+					valign = i->optional_string_attribute("Valign").get_value_or("center");
+				}
+				auto vpos = i->optional_number_attribute<float>("VPosition");
+				if (!vpos) {
+					vpos = i->optional_number_attribute<float>("Vposition").get_value_or(50);
+				}
+
+				if (last_valign) {
+					if (*last_valign != valign) {
+						mismatched_valign = true;
+					}
+				}
+				last_valign = valign;
+
+				if (!mismatched_valign) {
+					if (last_vpos) {
+						if (*last_valign == "top" || *last_valign == "center") {
+							if (*vpos < *last_vpos) {
+								incorrect_order = true;
+							}
+						} else {
+							if (*vpos > *last_vpos) {
+								incorrect_order = true;
+							}
+						}
+					}
+					last_vpos = vpos;
+				}
+			}
+		}
+
+		for (auto i: node->node_children()) {
+			parse(i);
+		}
+	};
+
+	for (auto reel: reels) {
+		for (auto ccap: reel->closed_captions()) {
+			auto reel_xml = ccap->asset()->raw_xml();
+			if (!reel_xml) {
+				notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSED_CHECK_OF_ENCRYPTED});
+				continue;
+			}
+
+			/* We need to look at <Subtitle> instances in the XML being checked, so we can't use the subtitles
+			 * read in by libdcp's parser.
+			 */
+
+			shared_ptr<cxml::Document> doc;
+			optional<int> tcr;
+			optional<Time> start_time;
+			try {
+				doc = make_shared<cxml::Document>("SubtitleReel");
+				doc->read_string (*reel_xml);
+			} catch (...) {
+				doc = make_shared<cxml::Document>("DCSubtitle");
+				doc->read_string (*reel_xml);
+			}
+			parse (doc);
+		}
+	}
+
+	if (mismatched_valign) {
+		notes.push_back ({
+			VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_CLOSED_CAPTION_VALIGN,
+		});
+	}
+
+	if (incorrect_order) {
+		notes.push_back ({
+			VerificationNote::Type::ERROR, VerificationNote::Code::INCORRECT_CLOSED_CAPTION_ORDERING,
+		});
+	}
 }
 
 
@@ -951,10 +1213,10 @@ verify_text_lines_and_characters (
 			result->line_count_exceeded = true;
 		}
 		for (auto j: current) {
-			if (j.second >= warning_length) {
+			if (j.second > warning_length) {
 				result->warning_length_exceeded = true;
 			}
-			if (j.second >= error_length) {
+			if (j.second > error_length) {
 				result->error_length_exceeded = true;
 			}
 		}
@@ -981,34 +1243,31 @@ verify_text_lines_and_characters (
 
 static
 void
-verify_text_timing (vector<shared_ptr<Reel>> reels, vector<VerificationNote>& notes)
+verify_text_details(dcp::Standard standard, vector<shared_ptr<Reel>> reels, vector<VerificationNote>& notes)
 {
 	if (reels.empty()) {
 		return;
 	}
 
 	if (reels[0]->main_subtitle()) {
-		verify_text_timing (reels, reels[0]->main_subtitle()->edit_rate().numerator, notes,
+		verify_text_details(standard, reels, reels[0]->main_subtitle()->edit_rate().numerator, notes,
 			[](shared_ptr<Reel> reel) {
 				return static_cast<bool>(reel->main_subtitle());
 			},
 			[](shared_ptr<Reel> reel) {
-				auto interop = dynamic_pointer_cast<ReelInteropSubtitleAsset>(reel->main_subtitle());
-				if (interop) {
-					return interop->asset()->raw_xml();
-				}
-				auto smpte = dynamic_pointer_cast<ReelSMPTESubtitleAsset>(reel->main_subtitle());
-				DCP_ASSERT (smpte);
-				return smpte->asset()->raw_xml();
+				return reel->main_subtitle()->asset()->raw_xml();
 			},
 			[](shared_ptr<Reel> reel) {
 				return reel->main_subtitle()->actual_duration();
+			},
+			[](shared_ptr<Reel> reel) {
+				return reel->main_subtitle()->id();
 			}
 		);
 	}
 
 	for (auto i = 0U; i < reels[0]->closed_captions().size(); ++i) {
-		verify_text_timing (reels, reels[0]->closed_captions()[i]->edit_rate().numerator, notes,
+		verify_text_details(standard, reels, reels[0]->closed_captions()[i]->edit_rate().numerator, notes,
 			[i](shared_ptr<Reel> reel) {
 				return i < reel->closed_captions().size();
 			},
@@ -1017,14 +1276,19 @@ verify_text_timing (vector<shared_ptr<Reel>> reels, vector<VerificationNote>& no
 			},
 			[i](shared_ptr<Reel> reel) {
 				return reel->closed_captions()[i]->actual_duration();
+			},
+			[i](shared_ptr<Reel> reel) {
+				return reel->closed_captions()[i]->id();
 			}
 		);
 	}
+
+	verify_closed_caption_details (reels, notes);
 }
 
 
 void
-verify_extension_metadata (shared_ptr<CPL> cpl, vector<VerificationNote>& notes)
+verify_extension_metadata(shared_ptr<const CPL> cpl, vector<VerificationNote>& notes)
 {
 	DCP_ASSERT (cpl->file());
 	cxml::Document doc ("CompositionPlaylist");
@@ -1082,26 +1346,21 @@ verify_extension_metadata (shared_ptr<CPL> cpl, vector<VerificationNote>& notes)
 
 
 bool
-pkl_has_encrypted_assets (shared_ptr<DCP> dcp, shared_ptr<PKL> pkl)
+pkl_has_encrypted_assets(shared_ptr<const DCP> dcp, shared_ptr<const PKL> pkl)
 {
 	vector<string> encrypted;
 	for (auto i: dcp->cpls()) {
 		for (auto j: i->reel_file_assets()) {
 			if (j->asset_ref().resolved()) {
-				/* It's a bit surprising / broken but Interop subtitle assets are represented
-				 * in reels by ReelSubtitleAsset which inherits ReelEncryptableAsset, so it's possible for
-				 * ReelEncryptableAssets to have assets which are not MXFs.
-				 */
-				if (auto asset = dynamic_pointer_cast<MXF>(j->asset_ref().asset())) {
-					if (asset->encrypted()) {
-						encrypted.push_back(j->asset_ref().id());
-					}
+				auto mxf = dynamic_pointer_cast<MXF>(j->asset_ref().asset());
+				if (mxf && mxf->encrypted()) {
+					encrypted.push_back(j->asset_ref().id());
 				}
 			}
 		}
 	}
 
-	for (auto i: pkl->asset_list()) {
+	for (auto i: pkl->assets()) {
 		if (find(encrypted.begin(), encrypted.end(), i->id()) != encrypted.end()) {
 			return true;
 		}
@@ -1111,315 +1370,503 @@ pkl_has_encrypted_assets (shared_ptr<DCP> dcp, shared_ptr<PKL> pkl)
 }
 
 
-vector<VerificationNote>
-dcp::verify (
-	vector<boost::filesystem::path> directories,
+static
+void
+verify_reel(
+	shared_ptr<const DCP> dcp,
+	shared_ptr<const CPL> cpl,
+	shared_ptr<const Reel> reel,
+	optional<dcp::Size> main_picture_active_area,
 	function<void (string, optional<boost::filesystem::path>)> stage,
+	boost::filesystem::path xsd_dtd_directory,
 	function<void (float)> progress,
-	optional<boost::filesystem::path> xsd_dtd_directory
+	VerificationOptions options,
+	vector<VerificationNote>& notes,
+	State& state,
+	bool* have_main_subtitle,
+	bool* have_no_main_subtitle,
+	size_t* most_closed_captions,
+	size_t* fewest_closed_captions,
+	map<Marker, Time>* markers_seen
 	)
 {
-	if (!xsd_dtd_directory) {
-		xsd_dtd_directory = resources_directory() / "xsd";
+	for (auto i: reel->assets()) {
+		if (i->duration() && (i->duration().get() * i->edit_rate().denominator / i->edit_rate().numerator) < 1) {
+			notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::INVALID_DURATION, i->id()});
+		}
+		if ((i->intrinsic_duration() * i->edit_rate().denominator / i->edit_rate().numerator) < 1) {
+			notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::INVALID_INTRINSIC_DURATION, i->id()});
+		}
+		auto file_asset = dynamic_pointer_cast<ReelFileAsset>(i);
+		if (i->encryptable() && !file_asset->hash()) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_HASH, i->id()});
+		}
 	}
-	*xsd_dtd_directory = boost::filesystem::canonical (*xsd_dtd_directory);
 
-	vector<VerificationNote> notes;
-	State state{};
+	if (dcp->standard() == Standard::SMPTE) {
+		boost::optional<int64_t> duration;
+		for (auto i: reel->assets()) {
+			if (!duration) {
+				duration = i->actual_duration();
+			} else if (*duration != i->actual_duration()) {
+				notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISMATCHED_ASSET_DURATION});
+				break;
+			}
+		}
+	}
+
+	if (reel->main_picture()) {
+		/* Check reel stuff */
+		auto const frame_rate = reel->main_picture()->frame_rate();
+		if (frame_rate.denominator != 1 ||
+		    (frame_rate.numerator != 24 &&
+		     frame_rate.numerator != 25 &&
+		     frame_rate.numerator != 30 &&
+		     frame_rate.numerator != 48 &&
+		     frame_rate.numerator != 50 &&
+		     frame_rate.numerator != 60 &&
+		     frame_rate.numerator != 96)) {
+			notes.push_back({
+				VerificationNote::Type::ERROR,
+				VerificationNote::Code::INVALID_PICTURE_FRAME_RATE,
+				String::compose("%1/%2", frame_rate.numerator, frame_rate.denominator)
+			});
+		}
+		/* Check asset */
+		if (reel->main_picture()->asset_ref().resolved()) {
+			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) {
+					notes.push_back({
+							VerificationNote::Type::ERROR,
+							VerificationNote::Code::INVALID_MAIN_PICTURE_ACTIVE_AREA,
+							String::compose("width %1 is bigger than the asset width %2", main_picture_active_area->width, asset_size.width),
+							cpl->file().get()
+							});
+				}
+				if (main_picture_active_area->height > asset_size.height) {
+					notes.push_back({
+							VerificationNote::Type::ERROR,
+							VerificationNote::Code::INVALID_MAIN_PICTURE_ACTIVE_AREA,
+							String::compose("height %1 is bigger than the asset height %2", main_picture_active_area->height, asset_size.height),
+							cpl->file().get()
+							});
+				}
+			}
+		}
 
-	vector<shared_ptr<DCP>> dcps;
-	for (auto i: directories) {
-		dcps.push_back (make_shared<DCP>(i));
 	}
 
-	for (auto dcp: dcps) {
-		stage ("Checking DCP", dcp->directory());
-		bool carry_on = true;
-		try {
-			dcp->read (&notes);
-		} catch (MissingAssetmapError& e) {
-			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
-			carry_on = false;
-		} catch (ReadError& e) {
-			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
-		} catch (XMLError& e) {
-			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
-		} catch (MXFFileError& e) {
-			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
-		} catch (cxml::Error& e) {
-			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
+	if (reel->main_sound() && reel->main_sound()->asset_ref().resolved()) {
+		verify_main_sound_asset(dcp, reel->main_sound(), stage, progress, options, notes, state);
+	}
+
+	if (reel->main_subtitle()) {
+		verify_main_subtitle_reel(reel->main_subtitle(), notes);
+		if (reel->main_subtitle()->asset_ref().resolved()) {
+			verify_subtitle_asset(reel->main_subtitle()->asset(), reel->main_subtitle()->duration(), stage, xsd_dtd_directory, notes, state);
 		}
+		*have_main_subtitle = true;
+	} else {
+		*have_no_main_subtitle = true;
+	}
 
-		if (!carry_on) {
-			continue;
+	for (auto i: reel->closed_captions()) {
+		verify_closed_caption_reel(i, notes);
+		if (i->asset_ref().resolved()) {
+			verify_closed_caption_asset(i->asset(), i->duration(), stage, xsd_dtd_directory, notes);
 		}
+	}
 
-		if (dcp->standard() != Standard::SMPTE) {
-			notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_STANDARD});
+	if (reel->main_markers()) {
+		for (auto const& i: reel->main_markers()->get()) {
+			markers_seen->insert(i);
+		}
+		if (reel->main_markers()->entry_point()) {
+			notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::UNEXPECTED_ENTRY_POINT});
+		}
+		if (reel->main_markers()->duration()) {
+			notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::UNEXPECTED_DURATION});
 		}
+	}
 
-		for (auto cpl: dcp->cpls()) {
-			stage ("Checking CPL", cpl->file());
-			validate_xml (cpl->file().get(), *xsd_dtd_directory, notes);
+	*fewest_closed_captions = std::min(*fewest_closed_captions, reel->closed_captions().size());
+	*most_closed_captions = std::max(*most_closed_captions, reel->closed_captions().size());
 
-			if (cpl->any_encrypted() && !cpl->all_encrypted()) {
-				notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::PARTIALLY_ENCRYPTED});
-			}
+}
+
+
+static
+void
+verify_cpl(
+	shared_ptr<const DCP> dcp,
+	shared_ptr<const CPL> 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
+	)
+{
+	stage("Checking CPL", cpl->file());
+	validate_xml(cpl->file().get(), xsd_dtd_directory, notes);
+
+	if (cpl->any_encrypted() && !cpl->all_encrypted()) {
+		notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::PARTIALLY_ENCRYPTED});
+	}
+
+	for (auto const& i: cpl->additional_subtitle_languages()) {
+		verify_language_tag(i, notes);
+	}
 
-			for (auto const& i: cpl->additional_subtitle_languages()) {
-				verify_language_tag (i, notes);
+	if (!cpl->content_kind().scope() || *cpl->content_kind().scope() == "http://www.smpte-ra.org/schemas/429-7/2006/CPL#standard-content") {
+		/* This is a content kind from http://www.smpte-ra.org/schemas/429-7/2006/CPL#standard-content; make sure it's one
+		 * of the approved ones.
+		 */
+		auto all = ContentKind::all();
+		auto name = cpl->content_kind().name();
+		transform(name.begin(), name.end(), name.begin(), ::tolower);
+		auto iter = std::find_if(all.begin(), all.end(), [name](ContentKind const& k) { return !k.scope() && k.name() == name; });
+		if (iter == all.end()) {
+			notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::INVALID_CONTENT_KIND, cpl->content_kind().name()});
+		}
+	}
+
+	if (cpl->release_territory()) {
+		if (!cpl->release_territory_scope() || cpl->release_territory_scope().get() != "http://www.smpte-ra.org/schemas/429-16/2014/CPL-Metadata#scope/release-territory/UNM49") {
+			auto terr = cpl->release_territory().get();
+			/* Must be a valid region tag, or "001" */
+			try {
+				LanguageTag::RegionSubtag test(terr);
+			} catch (...) {
+				if (terr != "001") {
+					notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_LANGUAGE, terr});
+				}
 			}
+		}
+	}
 
-			if (cpl->release_territory()) {
-				if (!cpl->release_territory_scope() || cpl->release_territory_scope().get() != "http://www.smpte-ra.org/schemas/429-16/2014/CPL-Metadata#scope/release-territory/UNM49") {
-					auto terr = cpl->release_territory().get();
-					/* Must be a valid region tag, or "001" */
-					try {
-						LanguageTag::RegionSubtag test (terr);
-					} catch (...) {
-						if (terr != "001") {
-							notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_LANGUAGE, terr});
-						}
+	for (auto version: cpl->content_versions()) {
+		if (version.label_text.empty()) {
+			notes.push_back(
+				dcp::VerificationNote(VerificationNote::Type::WARNING, VerificationNote::Code::EMPTY_CONTENT_VERSION_LABEL_TEXT, cpl->file().get()).set_id(cpl->id())
+				);
+			break;
+		}
+	}
+
+	if (dcp->standard() == Standard::SMPTE) {
+		if (!cpl->annotation_text()) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_CPL_ANNOTATION_TEXT, cpl->id(), cpl->file().get()});
+		} else if (cpl->annotation_text().get() != cpl->content_title_text()) {
+			notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::MISMATCHED_CPL_ANNOTATION_TEXT, cpl->id(), cpl->file().get()});
+		}
+	}
+
+	for (auto i: dcp->pkls()) {
+		/* Check that the CPL's hash corresponds to the PKL */
+		optional<string> h = i->hash(cpl->id());
+		if (h && make_digest(ArrayData(*cpl->file())) != *h) {
+			notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_CPL_HASHES, cpl->id(), cpl->file().get()});
+		}
+
+		/* 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->assets()) {
+			/* See if this is a CPL */
+			for (auto k: dcp->cpls()) {
+				if (j->id() == k->id()) {
+					if (!required_annotation_text) {
+						/* First CPL we have found; this is the required AnnotationText unless we find another */
+						required_annotation_text = cpl->content_title_text();
+					} else {
+						/* There's more than one CPL so we don't care what the PKL's AnnotationText is */
+						required_annotation_text = boost::none;
 					}
 				}
 			}
+		}
 
-			if (dcp->standard() == Standard::SMPTE) {
-				if (!cpl->annotation_text()) {
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_CPL_ANNOTATION_TEXT, cpl->id(), cpl->file().get()});
-				} else if (cpl->annotation_text().get() != cpl->content_title_text()) {
-					notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISMATCHED_CPL_ANNOTATION_TEXT, cpl->id(), cpl->file().get()});
-				}
+		if (required_annotation_text && i->annotation_text() != required_annotation_text) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISMATCHED_PKL_ANNOTATION_TEXT_WITH_CPL, i->id(), i->file().get()});
+		}
+	}
+
+	/* set to true if any reel has a MainSubtitle */
+	auto have_main_subtitle = false;
+	/* set to true if any reel has no MainSubtitle */
+	auto have_no_main_subtitle = false;
+	/* fewest number of closed caption assets seen in a reel */
+	size_t fewest_closed_captions = SIZE_MAX;
+	/* most number of closed caption assets seen in a reel */
+	size_t most_closed_captions = 0;
+	map<Marker, Time> markers_seen;
+
+	auto const main_picture_active_area = cpl->main_picture_active_area();
+	if (main_picture_active_area && (main_picture_active_area->width % 2)) {
+		notes.push_back({
+				VerificationNote::Type::ERROR,
+				VerificationNote::Code::INVALID_MAIN_PICTURE_ACTIVE_AREA,
+				String::compose("width %1 is not a multiple of 2", main_picture_active_area->width),
+				cpl->file().get()
+			});
+	}
+	if (main_picture_active_area && (main_picture_active_area->height % 2)) {
+		notes.push_back({
+				VerificationNote::Type::ERROR,
+				VerificationNote::Code::INVALID_MAIN_PICTURE_ACTIVE_AREA,
+				String::compose("height %1 is not a multiple of 2", main_picture_active_area->height),
+				cpl->file().get()
+			});
+	}
+
+	for (auto reel: cpl->reels()) {
+		stage("Checking reel", optional<boost::filesystem::path>());
+		verify_reel(
+			dcp,
+			cpl,
+			reel,
+			main_picture_active_area,
+			stage,
+			xsd_dtd_directory,
+			progress,
+			options,
+			notes,
+			state,
+			&have_main_subtitle,
+			&have_no_main_subtitle,
+			&most_closed_captions,
+			&fewest_closed_captions,
+			&markers_seen
+			);
+	}
+
+	verify_text_details(dcp->standard().get_value_or(dcp::Standard::SMPTE), cpl->reels(), notes);
+
+	if (dcp->standard() == Standard::SMPTE) {
+		if (auto msc = cpl->main_sound_configuration()) {
+			if (state.audio_channels && msc->channels() != *state.audio_channels) {
+				notes.push_back({
+						VerificationNote::Type::ERROR,
+						VerificationNote::Code::INVALID_MAIN_SOUND_CONFIGURATION,
+						String::compose("MainSoundConfiguration has %1 channels but sound assets have %2", msc->channels(), *state.audio_channels),
+						cpl->file().get()
+					});
 			}
+		}
 
-			for (auto i: dcp->pkls()) {
-				/* Check that the CPL's hash corresponds to the PKL */
-				optional<string> h = i->hash(cpl->id());
-				if (h && make_digest(ArrayData(*cpl->file())) != *h) {
-					notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::MISMATCHED_CPL_HASHES, cpl->id(), cpl->file().get()});
-				}
+		if (have_main_subtitle && have_no_main_subtitle) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_MAIN_SUBTITLE_FROM_SOME_REELS});
+		}
 
-				/* 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()) {
-					/* See if this is a CPL */
-					for (auto k: dcp->cpls()) {
-						if (j->id() == k->id()) {
-							if (!required_annotation_text) {
-								/* First CPL we have found; this is the required AnnotationText unless we find another */
-								required_annotation_text = cpl->content_title_text();
-							} else {
-								/* There's more than one CPL so we don't care what the PKL's AnnotationText is */
-								required_annotation_text = boost::none;
-							}
-						}
-					}
-				}
+		if (fewest_closed_captions != most_closed_captions) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISMATCHED_CLOSED_CAPTION_ASSET_COUNTS});
+		}
 
-				if (required_annotation_text && i->annotation_text() != required_annotation_text) {
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISMATCHED_PKL_ANNOTATION_TEXT_WITH_CPL, i->id(), i->file().get()});
-				}
+		if (cpl->content_kind() == ContentKind::FEATURE) {
+			if (markers_seen.find(Marker::FFEC) == markers_seen.end()) {
+				notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_FFEC_IN_FEATURE});
+			}
+			if (markers_seen.find(Marker::FFMC) == markers_seen.end()) {
+				notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_FFMC_IN_FEATURE});
 			}
+		}
 
-			/* set to true if any reel has a MainSubtitle */
-			auto have_main_subtitle = false;
-			/* set to true if any reel has no MainSubtitle */
-			auto have_no_main_subtitle = false;
-			/* fewest number of closed caption assets seen in a reel */
-			size_t fewest_closed_captions = SIZE_MAX;
-			/* most number of closed caption assets seen in a reel */
-			size_t most_closed_captions = 0;
-			map<Marker, Time> markers_seen;
-
-			for (auto reel: cpl->reels()) {
-				stage ("Checking reel", optional<boost::filesystem::path>());
-
-				for (auto i: reel->assets()) {
-					if (i->duration() && (i->duration().get() * i->edit_rate().denominator / i->edit_rate().numerator) < 1) {
-						notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::INVALID_DURATION, i->id()});
-					}
-					if ((i->intrinsic_duration() * i->edit_rate().denominator / i->edit_rate().numerator) < 1) {
-						notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::INVALID_INTRINSIC_DURATION, i->id()});
-					}
-					auto file_asset = dynamic_pointer_cast<ReelFileAsset>(i);
-					if (dynamic_pointer_cast<ReelEncryptableAsset>(i) && !file_asset->hash()) {
-						notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_HASH, i->id()});
-					}
-				}
+		auto ffoc = markers_seen.find(Marker::FFOC);
+		if (ffoc == markers_seen.end()) {
+			notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::MISSING_FFOC});
+		} else if (ffoc->second.e != 1) {
+			notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::INCORRECT_FFOC, raw_convert<string>(ffoc->second.e)});
+		}
 
-				if (dcp->standard() == Standard::SMPTE) {
-					boost::optional<int64_t> duration;
-					for (auto i: reel->assets()) {
-						if (!duration) {
-							duration = i->actual_duration();
-						} else if (*duration != i->actual_duration()) {
-							notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISMATCHED_ASSET_DURATION});
-							break;
-						}
-					}
-				}
+		auto lfoc = markers_seen.find(Marker::LFOC);
+		if (lfoc == markers_seen.end()) {
+			notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::MISSING_LFOC});
+		} else {
+			auto lfoc_time = lfoc->second.as_editable_units_ceil(lfoc->second.tcr);
+			if (lfoc_time != (cpl->reels().back()->duration() - 1)) {
+				notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::INCORRECT_LFOC, raw_convert<string>(lfoc_time)});
+			}
+		}
 
-				if (reel->main_picture()) {
-					/* Check reel stuff */
-					auto const frame_rate = reel->main_picture()->frame_rate();
-					if (frame_rate.denominator != 1 ||
-					    (frame_rate.numerator != 24 &&
-					     frame_rate.numerator != 25 &&
-					     frame_rate.numerator != 30 &&
-					     frame_rate.numerator != 48 &&
-					     frame_rate.numerator != 50 &&
-					     frame_rate.numerator != 60 &&
-					     frame_rate.numerator != 96)) {
-						notes.push_back ({
-							VerificationNote::Type::ERROR,
-							VerificationNote::Code::INVALID_PICTURE_FRAME_RATE,
-							String::compose("%1/%2", frame_rate.numerator, frame_rate.denominator)
-						});
-					}
-					/* Check asset */
-					if (reel->main_picture()->asset_ref().resolved()) {
-						verify_main_picture_asset (dcp, reel->main_picture(), stage, progress, notes);
-					}
-				}
+		LinesCharactersResult result;
+		for (auto reel: cpl->reels()) {
+			if (reel->main_subtitle() && reel->main_subtitle()->asset()) {
+				verify_text_lines_and_characters(reel->main_subtitle()->asset(), 52, 79, &result);
+			}
+		}
 
-				if (reel->main_sound() && reel->main_sound()->asset_ref().resolved()) {
-					verify_main_sound_asset (dcp, reel->main_sound(), stage, progress, notes);
-				}
+		if (result.line_count_exceeded) {
+			notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::INVALID_SUBTITLE_LINE_COUNT});
+		}
+		if (result.error_length_exceeded) {
+			notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::INVALID_SUBTITLE_LINE_LENGTH});
+		} else if (result.warning_length_exceeded) {
+			notes.push_back({VerificationNote::Type::WARNING, VerificationNote::Code::NEARLY_INVALID_SUBTITLE_LINE_LENGTH});
+		}
 
-				if (reel->main_subtitle()) {
-					verify_main_subtitle_reel (reel->main_subtitle(), notes);
-					if (reel->main_subtitle()->asset_ref().resolved()) {
-						verify_subtitle_asset (reel->main_subtitle()->asset(), reel->main_subtitle()->duration(), stage, *xsd_dtd_directory, notes, state);
-					}
-					have_main_subtitle = true;
-				} else {
-					have_no_main_subtitle = true;
+		result = LinesCharactersResult();
+		for (auto reel: cpl->reels()) {
+			for (auto i: reel->closed_captions()) {
+				if (i->asset()) {
+					verify_text_lines_and_characters(i->asset(), 32, 32, &result);
 				}
+			}
+		}
 
-				for (auto i: reel->closed_captions()) {
-					verify_closed_caption_reel (i, notes);
-					if (i->asset_ref().resolved()) {
-						verify_closed_caption_asset (i->asset(), i->duration(), stage, *xsd_dtd_directory, notes);
-					}
-				}
+		if (result.line_count_exceeded) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_CLOSED_CAPTION_LINE_COUNT});
+		}
+		if (result.error_length_exceeded) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_CLOSED_CAPTION_LINE_LENGTH});
+		}
 
-				if (reel->main_markers()) {
-					for (auto const& i: reel->main_markers()->get()) {
-						markers_seen.insert (i);
-					}
-				}
+		if (!cpl->read_composition_metadata()) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_CPL_METADATA, cpl->id(), cpl->file().get()});
+		} else if (!cpl->version_number()) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_CPL_METADATA_VERSION_NUMBER, cpl->id(), cpl->file().get()});
+		}
+
+		verify_extension_metadata(cpl, notes);
 
-				fewest_closed_captions = std::min (fewest_closed_captions, reel->closed_captions().size());
-				most_closed_captions = std::max (most_closed_captions, reel->closed_captions().size());
+		if (cpl->any_encrypted()) {
+			cxml::Document doc("CompositionPlaylist");
+			DCP_ASSERT(cpl->file());
+			doc.read_file(cpl->file().get());
+			if (!doc.optional_node_child("Signature")) {
+				notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::UNSIGNED_CPL_WITH_ENCRYPTED_CONTENT, cpl->id(), cpl->file().get()});
 			}
+		}
+	}
+}
 
-			verify_text_timing (cpl->reels(), notes);
 
-			if (dcp->standard() == Standard::SMPTE) {
+static
+void
+verify_pkl(
+	shared_ptr<const DCP> dcp,
+	shared_ptr<const PKL> pkl,
+	boost::filesystem::path xsd_dtd_directory,
+	vector<VerificationNote>& notes
+	)
+{
+	validate_xml(pkl->file().get(), xsd_dtd_directory, notes);
 
-				if (have_main_subtitle && have_no_main_subtitle) {
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_MAIN_SUBTITLE_FROM_SOME_REELS});
-				}
+	if (pkl_has_encrypted_assets(dcp, pkl)) {
+		cxml::Document doc("PackingList");
+		doc.read_file(pkl->file().get());
+		if (!doc.optional_node_child("Signature")) {
+			notes.push_back({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::UNSIGNED_PKL_WITH_ENCRYPTED_CONTENT, pkl->id(), pkl->file().get()});
+		}
+	}
 
-				if (fewest_closed_captions != most_closed_captions) {
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISMATCHED_CLOSED_CAPTION_ASSET_COUNTS});
-				}
+	set<string> uuid_set;
+	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;
+		}
+	}
+}
 
-				if (cpl->content_kind() == ContentKind::FEATURE) {
-					if (markers_seen.find(Marker::FFEC) == markers_seen.end()) {
-						notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_FFEC_IN_FEATURE});
-					}
-					if (markers_seen.find(Marker::FFMC) == markers_seen.end()) {
-						notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_FFMC_IN_FEATURE});
-					}
-				}
 
-				auto ffoc = markers_seen.find(Marker::FFOC);
-				if (ffoc == markers_seen.end()) {
-					notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSING_FFOC});
-				} else if (ffoc->second.e != 1) {
-					notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::INCORRECT_FFOC, raw_convert<string>(ffoc->second.e)});
-				}
 
-				auto lfoc = markers_seen.find(Marker::LFOC);
-				if (lfoc == markers_seen.end()) {
-					notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::MISSING_LFOC});
-				} else {
-					auto lfoc_time = lfoc->second.as_editable_units_ceil(lfoc->second.tcr);
-					if (lfoc_time != (cpl->reels().back()->duration() - 1)) {
-						notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::INCORRECT_LFOC, raw_convert<string>(lfoc_time)});
-					}
-				}
+static
+void
+verify_assetmap(
+	shared_ptr<const DCP> dcp,
+	boost::filesystem::path xsd_dtd_directory,
+	vector<VerificationNote>& notes
+	)
+{
+	auto asset_map = dcp->asset_map();
+	DCP_ASSERT(asset_map);
 
-				LinesCharactersResult result;
-				for (auto reel: cpl->reels()) {
-					if (reel->main_subtitle() && reel->main_subtitle()->asset()) {
-						verify_text_lines_and_characters (reel->main_subtitle()->asset(), 52, 79, &result);
-					}
-				}
+	validate_xml(asset_map->file().get(), xsd_dtd_directory, notes);
 
-				if (result.line_count_exceeded) {
-					notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::INVALID_SUBTITLE_LINE_COUNT});
-				}
-				if (result.error_length_exceeded) {
-					notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::INVALID_SUBTITLE_LINE_LENGTH});
-				} else if (result.warning_length_exceeded) {
-					notes.push_back ({VerificationNote::Type::WARNING, VerificationNote::Code::NEARLY_INVALID_SUBTITLE_LINE_LENGTH});
-				}
+	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;
+		}
+	}
+}
 
-				result = LinesCharactersResult();
-				for (auto reel: cpl->reels()) {
-					for (auto i: reel->closed_captions()) {
-						if (i->asset()) {
-							verify_text_lines_and_characters (i->asset(), 32, 32, &result);
-						}
-					}
-				}
 
-				if (result.line_count_exceeded) {
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_CLOSED_CAPTION_LINE_COUNT});
-				}
-				if (result.error_length_exceeded) {
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_CLOSED_CAPTION_LINE_LENGTH});
-				}
+vector<VerificationNote>
+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
+	)
+{
+	if (!xsd_dtd_directory) {
+		xsd_dtd_directory = resources_directory() / "xsd";
+	}
+	*xsd_dtd_directory = boost::filesystem::canonical (*xsd_dtd_directory);
 
-				if (!cpl->full_content_title_text()) {
-					/* Since FullContentTitleText is assumed always to exist if there's a CompositionMetadataAsset we
-					 * can use it as a proxy for CompositionMetadataAsset's existence.
-					 */
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_CPL_METADATA, cpl->id(), cpl->file().get()});
-				} else if (!cpl->version_number()) {
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::MISSING_CPL_METADATA_VERSION_NUMBER, cpl->id(), cpl->file().get()});
-				}
+	vector<VerificationNote> notes;
+	State state{};
 
-				verify_extension_metadata (cpl, notes);
+	vector<shared_ptr<DCP>> dcps;
+	for (auto i: directories) {
+		dcps.push_back (make_shared<DCP>(i));
+	}
 
-				if (cpl->any_encrypted()) {
-					cxml::Document doc ("CompositionPlaylist");
-					DCP_ASSERT (cpl->file());
-					doc.read_file (cpl->file().get());
-					if (!doc.optional_node_child("Signature")) {
-						notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::UNSIGNED_CPL_WITH_ENCRYPTED_CONTENT, cpl->id(), cpl->file().get()});
-					}
-				}
-			}
+	for (auto dcp: dcps) {
+		stage ("Checking DCP", dcp->directory());
+		bool carry_on = true;
+		try {
+			dcp->read (&notes, true);
+		} catch (MissingAssetmapError& e) {
+			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
+			carry_on = false;
+		} catch (ReadError& e) {
+			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
+		} catch (XMLError& e) {
+			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
+		} catch (MXFFileError& e) {
+			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
+		} catch (BadURNUUIDError& e) {
+			notes.push_back({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
+		} catch (cxml::Error& e) {
+			notes.push_back ({VerificationNote::Type::ERROR, VerificationNote::Code::FAILED_READ, string(e.what())});
+		}
+
+		if (!carry_on) {
+			continue;
+		}
+
+		if (dcp->standard() != Standard::SMPTE) {
+			notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::INVALID_STANDARD});
+		}
+
+		for (auto cpl: dcp->cpls()) {
+			verify_cpl(
+				dcp,
+				cpl,
+				stage,
+				*xsd_dtd_directory,
+				progress,
+				options,
+				notes,
+				state
+				);
 		}
 
 		for (auto pkl: dcp->pkls()) {
-			stage ("Checking PKL", pkl->file());
-			validate_xml (pkl->file().get(), *xsd_dtd_directory, notes);
-			if (pkl_has_encrypted_assets(dcp, pkl)) {
-				cxml::Document doc ("PackingList");
-				doc.read_file (pkl->file().get());
-				if (!doc.optional_node_child("Signature")) {
-					notes.push_back ({VerificationNote::Type::BV21_ERROR, VerificationNote::Code::UNSIGNED_PKL_WITH_ENCRYPTED_CONTENT, pkl->id(), pkl->file().get()});
-				}
-			}
+			stage("Checking PKL", pkl->file());
+			verify_pkl(dcp, pkl, *xsd_dtd_directory, notes);
 		}
 
-		if (dcp->asset_map_path()) {
-			stage ("Checking ASSETMAP", dcp->asset_map_path().get());
-			validate_xml (dcp->asset_map_path().get(), *xsd_dtd_directory, notes);
+		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});
 		}
@@ -1466,7 +1913,7 @@ dcp::note_to_string (VerificationNote note)
 	case VerificationNote::Code::INVALID_XML:
 		return String::compose("An XML file is badly formed: %1 (%2:%3)", note.note().get(), note.file()->filename(), note.line().get());
 	case VerificationNote::Code::MISSING_ASSETMAP:
-		return "No ASSETMAP or ASSETMAP.xml was found.";
+		return "No valid ASSETMAP or ASSETMAP.xml was found.";
 	case VerificationNote::Code::INVALID_INTRINSIC_DURATION:
 		return String::compose("The intrinsic duration of the asset %1 is less than 1 second.", note.note().get());
 	case VerificationNote::Code::INVALID_DURATION:
@@ -1477,6 +1924,8 @@ dcp::note_to_string (VerificationNote note)
 		return String::compose("The instantaneous bit rate of the picture asset %1 is close to the limit of 250Mbit/s in at least one place.", note.file()->filename());
 	case VerificationNote::Code::EXTERNAL_ASSET:
 		return String::compose("The asset %1 that this DCP refers to is not included in the DCP.  It may be a VF.", note.note().get());
+	case VerificationNote::Code::THREED_ASSET_MARKED_AS_TWOD:
+		return String::compose("The asset %1 is 3D but its MXF is marked as 2D.", note.file()->filename());
 	case VerificationNote::Code::INVALID_STANDARD:
 		return "This DCP does not use the SMPTE standard.";
 	case VerificationNote::Code::INVALID_LANGUAGE:
@@ -1526,11 +1975,11 @@ dcp::note_to_string (VerificationNote note)
 	case VerificationNote::Code::MISSING_CPL_ANNOTATION_TEXT:
 		return String::compose("The CPL %1 has no <AnnotationText> tag.", note.note().get());
 	case VerificationNote::Code::MISMATCHED_CPL_ANNOTATION_TEXT:
-		return String::compose("The CPL %1 has an <AnnotationText> which differs from its <ContentTitleText>", note.note().get());
+		return String::compose("The CPL %1 has an <AnnotationText> which differs from its <ContentTitleText>.", note.note().get());
 	case VerificationNote::Code::MISMATCHED_ASSET_DURATION:
 		return "All assets in a reel do not have the same duration.";
 	case VerificationNote::Code::MISSING_MAIN_SUBTITLE_FROM_SOME_REELS:
-		return "At least one reel contains a subtitle asset, but some reel(s) do not";
+		return "At least one reel contains a subtitle asset, but some reel(s) do not.";
 	case VerificationNote::Code::MISMATCHED_CLOSED_CAPTION_ASSET_COUNTS:
 		return "At least one reel has closed captions, but reels have different numbers of closed caption assets.";
 	case VerificationNote::Code::MISSING_SUBTITLE_ENTRY_POINT:
@@ -1544,13 +1993,13 @@ dcp::note_to_string (VerificationNote note)
 	case VerificationNote::Code::MISSING_HASH:
 		return String::compose("The asset %1 has no <Hash> tag in the CPL.", note.note().get());
 	case VerificationNote::Code::MISSING_FFEC_IN_FEATURE:
-		return "The DCP is marked as a Feature but there is no FFEC (first frame of end credits) marker";
+		return "The DCP is marked as a Feature but there is no FFEC (first frame of end credits) marker.";
 	case VerificationNote::Code::MISSING_FFMC_IN_FEATURE:
-		return "The DCP is marked as a Feature but there is no FFMC (first frame of moving credits) marker";
+		return "The DCP is marked as a Feature but there is no FFMC (first frame of moving credits) marker.";
 	case VerificationNote::Code::MISSING_FFOC:
-		return "There should be a FFOC (first frame of content) marker";
+		return "There should be a FFOC (first frame of content) marker.";
 	case VerificationNote::Code::MISSING_LFOC:
-		return "There should be a LFOC (last frame of content) marker";
+		return "There should be a LFOC (last frame of content) marker.";
 	case VerificationNote::Code::INCORRECT_FFOC:
 		return String::compose("The FFOC marker is %1 instead of 1", note.note().get());
 	case VerificationNote::Code::INCORRECT_LFOC:
@@ -1572,7 +2021,7 @@ dcp::note_to_string (VerificationNote note)
 	case VerificationNote::Code::PARTIALLY_ENCRYPTED:
 		return "Some assets are encrypted but some are not.";
 	case VerificationNote::Code::INVALID_JPEG2000_CODESTREAM:
-		return String::compose("The JPEG2000 codestream for at least one frame is invalid (%1)", note.note().get());
+		return String::compose("The JPEG2000 codestream for at least one frame is invalid (%1).", note.note().get());
 	case VerificationNote::Code::INVALID_JPEG2000_GUARD_BITS_FOR_2K:
 		return String::compose("The JPEG2000 codestream uses %1 guard bits in a 2K image instead of 1.", note.note().get());
 	case VerificationNote::Code::INVALID_JPEG2000_GUARD_BITS_FOR_4K:
@@ -1588,9 +2037,9 @@ dcp::note_to_string (VerificationNote note)
 	case VerificationNote::Code::INCORRECT_JPEG2000_POC_MARKER_COUNT_FOR_4K:
 		return String::compose("%1 POC markers found in 4K JPEG2000 codestream instead of 1.", note.note().get());
 	case VerificationNote::Code::INCORRECT_JPEG2000_POC_MARKER:
-		return String::compose("Incorrect POC marker content found (%1)", note.note().get());
+		return String::compose("Incorrect POC marker content found (%1).", note.note().get());
 	case VerificationNote::Code::INVALID_JPEG2000_POC_MARKER_LOCATION:
-		return "POC marker found outside main header";
+		return "POC marker found outside main header.";
 	case VerificationNote::Code::INVALID_JPEG2000_TILE_PARTS_FOR_2K:
 		return String::compose("The JPEG2000 codestream has %1 tile parts in a 2K image instead of 3.", note.note().get());
 	case VerificationNote::Code::INVALID_JPEG2000_TILE_PARTS_FOR_4K:
@@ -1608,6 +2057,51 @@ dcp::note_to_string (VerificationNote note)
 		DCP_ASSERT (parts.size() == 2);
 		return String::compose("The reel duration of some timed text (%1) is not the same as the ContainerDuration of its MXF (%2).", parts[0], parts[1]);
 	}
+	case VerificationNote::Code::MISSED_CHECK_OF_ENCRYPTED:
+		return "Some aspect of this DCP could not be checked because it is encrypted.";
+	case VerificationNote::Code::EMPTY_TEXT:
+		return "There is an empty <Text> node in a subtitle or closed caption.";
+	case VerificationNote::Code::MISMATCHED_CLOSED_CAPTION_VALIGN:
+		return "Some closed <Text> or <Image> nodes have different vertical alignments within a <Subtitle>.";
+	case VerificationNote::Code::INCORRECT_CLOSED_CAPTION_ORDERING:
+		return "Some closed captions are not listed in the order of their vertical position.";
+	case VerificationNote::Code::UNEXPECTED_ENTRY_POINT:
+		return "There is an <EntryPoint> node inside a <MainMarkers>.";
+	case VerificationNote::Code::UNEXPECTED_DURATION:
+		return "There is an <Duration> node inside a <MainMarkers>.";
+	case VerificationNote::Code::INVALID_CONTENT_KIND:
+		return String::compose("<ContentKind> has an invalid value %1.", note.note().get());
+	case VerificationNote::Code::INVALID_MAIN_PICTURE_ACTIVE_AREA:
+		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());
+	case VerificationNote::Code::MISMATCHED_SOUND_CHANNEL_COUNTS:
+		return String::compose("The sound assets do not all have the same channel count; the first to differ is %1", note.file()->filename());
+	case VerificationNote::Code::INVALID_MAIN_SOUND_CONFIGURATION:
+		return String::compose("<MainSoundConfiguration> has an invalid value: %1", note.note().get());
+	case VerificationNote::Code::MISSING_FONT:
+		return String::compose("The font file for font ID \"%1\" was not found, or was not referred to in the ASSETMAP.", note.note().get());
+	case VerificationNote::Code::INVALID_JPEG2000_TILE_PART_SIZE:
+		return String::compose(
+			"Frame %1 has an image component that is too large (component %2 is %3 bytes in size).",
+			note.frame().get(), note.component().get(), note.size().get()
+			);
+	case VerificationNote::Code::INCORRECT_SUBTITLE_NAMESPACE_COUNT:
+		return String::compose("The XML in the subtitle asset %1 has more than one namespace declaration.", note.note().get());
+	case VerificationNote::Code::MISSING_LOAD_FONT_FOR_FONT:
+		return String::compose("A subtitle or closed caption refers to a font with ID %1 that does not have a corresponding <LoadFont> node", note.id().get());
+	case VerificationNote::Code::MISSING_LOAD_FONT:
+		return String::compose("The SMPTE subtitle asset %1 has <Text> nodes but no <LoadFont> node", note.id().get());
+	case VerificationNote::Code::MISMATCHED_ASSET_MAP_ID:
+		return String::compose("The asset with ID %1 in the asset map actually has an id of %2", note.id().get(), note.other_id().get());
+	case VerificationNote::Code::EMPTY_CONTENT_VERSION_LABEL_TEXT:
+		return String::compose("The <LabelText> in a <ContentVersion> in CPL %1 is empty", note.id().get());
 	}
 
 	return "";
@@ -1621,6 +2115,29 @@ dcp::operator== (dcp::VerificationNote const& a, dcp::VerificationNote const& b)
 }
 
 
+bool
+dcp::operator< (dcp::VerificationNote const& a, dcp::VerificationNote const& b)
+{
+	if (a.type() != b.type()) {
+		return a.type() < b.type();
+	}
+
+	if (a.code() != b.code()) {
+		return a.code() < b.code();
+	}
+
+	if (a.note() != b.note()) {
+		return a.note().get_value_or("") < b.note().get_value_or("");
+	}
+
+	if (a.file() != b.file()) {
+		return a.file().get_value_or("") < b.file().get_value_or("");
+	}
+
+	return a.line().get_value_or(0) < b.line().get_value_or(0);
+}
+
+
 std::ostream&
 dcp::operator<< (std::ostream& s, dcp::VerificationNote const& note)
 {