X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Futil.cc;h=bbb44436713281d5a3a88ee0bec5a265bd2e6efa;hb=3dfe3b92df03eee932f3c92336197559c11a5913;hp=5eba8d73a0f214f07339998c9a6c4543f5f86e2f;hpb=05d90a3edda9c1f5e7499f0ce7b6617fe46ac54d;p=dcpomatic.git

diff --git a/src/lib/util.cc b/src/lib/util.cc
index 5eba8d73a..bbb444367 100644
--- a/src/lib/util.cc
+++ b/src/lib/util.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012-2016 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2012-2019 Carl Hetherington <cth@carlh.net>
 
     This file is part of DCP-o-matic.
 
@@ -35,8 +35,16 @@
 #include "rect.h"
 #include "digester.h"
 #include "audio_processor.h"
+#include "crypto.h"
 #include "compose.hpp"
 #include "audio_buffers.h"
+#include "string_text.h"
+#include "font.h"
+#include "render_text.h"
+#include "ffmpeg_image_proxy.h"
+#include "image.h"
+#include "text_decoder.h"
+#include "job_manager.h"
 #include <dcp/locale_convert.h>
 #include <dcp/util.h>
 #include <dcp/raw_convert.h>
@@ -55,6 +63,7 @@ extern "C" {
 #include <boost/range/algorithm/replace_if.hpp>
 #include <boost/thread.hpp>
 #include <boost/filesystem.hpp>
+#include <boost/locale.hpp>
 #ifdef DCPOMATIC_WINDOWS
 #include <boost/locale.hpp>
 #include <dbghelp.h>
@@ -73,6 +82,7 @@ extern "C" {
 #include "i18n.h"
 
 using std::string;
+using std::wstring;
 using std::setfill;
 using std::ostream;
 using std::endl;
@@ -93,9 +103,11 @@ using boost::thread;
 using boost::optional;
 using boost::lexical_cast;
 using boost::bad_lexical_cast;
+using boost::scoped_array;
 using dcp::Size;
 using dcp::raw_convert;
 using dcp::locale_convert;
+using namespace dcpomatic;
 
 /** Path to our executable, required by the stacktrace stuff and filled
  *  in during App::onInit().
@@ -356,9 +368,30 @@ dcpomatic_setup ()
 
 	set_terminate (terminate);
 
+#ifdef DCPOMATIC_WINDOWS
+	putenv ("PANGOCAIRO_BACKEND=fontconfig");
+	putenv (String::compose("FONTCONFIG_PATH=%1", shared_path().string()).c_str());
+#endif
+
+#ifdef DCPOMATIC_OSX
+	setenv ("PANGOCAIRO_BACKEND", "fontconfig", 1);
+	setenv ("FONTCONFIG_PATH", shared_path().string().c_str(), 1);
+#endif
+
 	Pango::init ();
 	dcp::init ();
 
+#if defined(DCPOMATIC_WINDOWS) || defined(DCPOMATIC_OSX)
+	/* Render something to fontconfig to create its cache */
+	list<StringText> subs;
+	dcp::SubtitleString ss(
+		optional<string>(), false, false, false, dcp::Colour(), 42, 1, dcp::Time(), dcp::Time(), 0, dcp::HALIGN_CENTER, 0, dcp::VALIGN_CENTER, dcp::DIRECTION_LTR,
+		"Hello dolly", dcp::NONE, dcp::Colour(), dcp::Time(), dcp::Time()
+		);
+	subs.push_back (StringText(ss, 0));
+	render_text (subs, list<shared_ptr<Font> >(), dcp::Size(640, 480), DCPTime(), 24);
+#endif
+
 	Ratio::setup_ratios ();
 	PresetColourConversion::setup_colour_conversion_presets ();
 	VideoContentScale::setup_scales ();
@@ -440,7 +473,7 @@ digest_head_tail (vector<boost::filesystem::path> files, boost::uintmax_t size)
 	while (i < int64_t (files.size()) && to_do > 0) {
 		FILE* f = fopen_boost (files[i], "rb");
 		if (!f) {
-			throw OpenFileError (files[i].string(), errno, true);
+			throw OpenFileError (files[i].string(), errno, OpenFileError::READ);
 		}
 
 		boost::uintmax_t this_time = min (to_do, boost::filesystem::file_size (files[i]));
@@ -460,7 +493,7 @@ digest_head_tail (vector<boost::filesystem::path> files, boost::uintmax_t size)
 	while (i >= 0 && to_do > 0) {
 		FILE* f = fopen_boost (files[i], "rb");
 		if (!f) {
-			throw OpenFileError (files[i].string(), errno, true);
+			throw OpenFileError (files[i].string(), errno, OpenFileError::READ);
 		}
 
 		boost::uintmax_t this_time = min (to_do, boost::filesystem::file_size (files[i]));
@@ -700,7 +733,7 @@ relaxed_string_to_float (string s)
 	try {
 		boost::algorithm::replace_all (s, ",", ".");
 		return lexical_cast<float> (s);
-	} catch (bad_lexical_cast) {
+	} catch (bad_lexical_cast &) {
 		boost::algorithm::replace_all (s, ".", ",");
 		return lexical_cast<float> (s);
 	}
@@ -714,20 +747,39 @@ careful_string_filter (string s)
 	   Safety first and all that.
 	*/
 
+	wstring ws = boost::locale::conv::utf_to_utf<wchar_t>(s);
+
 	string out;
 	string const allowed = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_%.+";
-	for (size_t i = 0; i < s.size(); ++i) {
-		if (allowed.find (s[i]) != string::npos) {
-			out += s[i];
+	for (size_t i = 0; i < ws.size(); ++i) {
+
+		wchar_t c = ws[i];
+
+		/* Remove some accents */
+		if (wstring(L"áàâ").find(c) != string::npos) {
+			c = 'a';
+		}
+		if (wstring(L"éèêë").find(c) != string::npos) {
+			c = 'e';
+		}
+		if (wstring(L"ö").find(c) != string::npos) {
+			c = 'o';
+		}
+		if (wstring(L"ü").find(c) != string::npos) {
+			c = 'u';
+		}
+
+		if (allowed.find(c) != string::npos) {
+			out += c;
 		}
 	}
 
-	return out;
+	return boost::locale::conv::utf_to_utf<char>(out);
 }
 
 /** @param mapped List of mapped audio channels from a Film.
  *  @param channels Total number of channels in the Film.
- *  @return First: number of non-LFE channels, second: number of LFE channels.
+ *  @return First: number of non-LFE soundtrack channels (L/R/C/Ls/Rs/Lc/Rc/Bsl/Bsr), second: number of LFE channels.
  */
 pair<int, int>
 audio_channel_types (list<int> mapped, int channels)
@@ -741,10 +793,24 @@ audio_channel_types (list<int> mapped, int channels)
 			continue;
 		}
 
-		if (static_cast<dcp::Channel> (i) == dcp::LFE) {
+		switch (static_cast<dcp::Channel>(i)) {
+		case dcp::LFE:
 			++lfe;
-		} else {
+			break;
+		case dcp::LEFT:
+		case dcp::RIGHT:
+		case dcp::CENTRE:
+		case dcp::LS:
+		case dcp::RS:
+		case dcp::LC:
+		case dcp::RC:
+		case dcp::BSL:
+		case dcp::BSR:
 			++non_lfe;
+			break;
+		case dcp::HI:
+		case dcp::VI:
+			break;
 		}
 	}
 
@@ -783,15 +849,325 @@ increment_eyes (Eyes e)
 	return EYES_LEFT;
 }
 
+void
+checked_fwrite (void const * ptr, size_t size, FILE* stream, boost::filesystem::path path)
+{
+	size_t N = fwrite (ptr, 1, size, stream);
+	if (N != size) {
+		if (ferror(stream)) {
+			fclose (stream);
+			throw FileError (String::compose("fwrite error %1", errno), path);
+		} else {
+			fclose (stream);
+			throw FileError ("Unexpected short write", path);
+		}
+	}
+}
+
 void
 checked_fread (void* ptr, size_t size, FILE* stream, boost::filesystem::path path)
 {
 	size_t N = fread (ptr, 1, size, stream);
 	if (N != size) {
 		if (ferror(stream)) {
+			fclose (stream);
 			throw FileError (String::compose("fread error %1", errno), path);
 		} else {
+			fclose (stream);
 			throw FileError ("Unexpected short read", path);
 		}
 	}
 }
+
+size_t
+utf8_strlen (string s)
+{
+	size_t const len = s.length ();
+	int N = 0;
+	for (size_t i = 0; i < len; ++i) {
+		unsigned char c = s[i];
+		if ((c & 0xe0) == 0xc0) {
+			++i;
+		} else if ((c & 0xf0) == 0xe0) {
+			i += 2;
+		} else if ((c & 0xf8) == 0xf0) {
+			i += 3;
+		}
+		++N;
+	}
+	return N;
+}
+
+string
+day_of_week_to_string (boost::gregorian::greg_weekday d)
+{
+	switch (d.as_enum()) {
+	case boost::date_time::Sunday:
+		return _("Sunday");
+	case boost::date_time::Monday:
+		return _("Monday");
+	case boost::date_time::Tuesday:
+		return _("Tuesday");
+	case boost::date_time::Wednesday:
+		return _("Wednesday");
+	case boost::date_time::Thursday:
+		return _("Thursday");
+	case boost::date_time::Friday:
+		return _("Friday");
+	case boost::date_time::Saturday:
+		return _("Saturday");
+	}
+
+	return d.as_long_string ();
+}
+
+/** @param size Size of picture that the subtitle will be overlaid onto */
+void
+emit_subtitle_image (ContentTimePeriod period, dcp::SubtitleImage sub, dcp::Size size, shared_ptr<TextDecoder> decoder)
+{
+	/* XXX: this is rather inefficient; decoding the image just to get its size */
+	FFmpegImageProxy proxy (sub.png_image());
+	shared_ptr<Image> image = proxy.image().first;
+	/* set up rect with height and width */
+	dcpomatic::Rect<double> rect(0, 0, image->size().width / double(size.width), image->size().height / double(size.height));
+
+	/* add in position */
+
+	switch (sub.h_align()) {
+	case dcp::HALIGN_LEFT:
+		rect.x += sub.h_position();
+		break;
+	case dcp::HALIGN_CENTER:
+		rect.x += 0.5 + sub.h_position() - rect.width / 2;
+		break;
+	case dcp::HALIGN_RIGHT:
+		rect.x += 1 - sub.h_position() - rect.width;
+		break;
+	}
+
+	switch (sub.v_align()) {
+	case dcp::VALIGN_TOP:
+		rect.y += sub.v_position();
+		break;
+	case dcp::VALIGN_CENTER:
+		rect.y += 0.5 + sub.v_position() - rect.height / 2;
+		break;
+	case dcp::VALIGN_BOTTOM:
+		rect.y += 1 - sub.v_position() - rect.height;
+		break;
+	}
+
+	decoder->emit_bitmap (period, image, rect);
+}
+
+bool
+show_jobs_on_console (bool progress)
+{
+	bool first = true;
+	bool error = false;
+	while (true) {
+
+		dcpomatic_sleep_seconds (5);
+
+		list<shared_ptr<Job> > jobs = JobManager::instance()->get();
+
+		if (!first && progress) {
+			for (size_t i = 0; i < jobs.size(); ++i) {
+				cout << "\033[1A\033[2K";
+			}
+			cout.flush ();
+		}
+
+		first = false;
+
+		BOOST_FOREACH (shared_ptr<Job> i, jobs) {
+			if (progress) {
+				cout << i->name();
+				if (!i->sub_name().empty()) {
+					cout << "; " << i->sub_name();
+				}
+				cout << ": ";
+
+				if (i->progress ()) {
+					cout << i->status() << "			    \n";
+				} else {
+					cout << ": Running	     \n";
+				}
+			}
+
+			if (!progress && i->finished_in_error()) {
+				/* We won't see this error if we haven't been showing progress,
+				   so show it now.
+				*/
+				cout << i->status() << "\n";
+			}
+
+			if (i->finished_in_error()) {
+				error = true;
+			}
+		}
+
+		if (!JobManager::instance()->work_to_do()) {
+			break;
+		}
+	}
+
+	return error;
+}
+
+/** XXX: could use mmap? */
+void
+copy_in_bits (boost::filesystem::path from, boost::filesystem::path to, boost::function<void (float)> progress)
+{
+	FILE* f = fopen_boost (from, "rb");
+	if (!f) {
+		throw OpenFileError (from, errno, OpenFileError::READ);
+	}
+	FILE* t = fopen_boost (to, "wb");
+	if (!t) {
+		fclose (f);
+		throw OpenFileError (to, errno, OpenFileError::WRITE);
+	}
+
+	/* on the order of a second's worth of copying */
+	boost::uintmax_t const chunk = 20 * 1024 * 1024;
+
+	uint8_t* buffer = static_cast<uint8_t*> (malloc(chunk));
+	if (!buffer) {
+		throw std::bad_alloc ();
+	}
+
+	boost::uintmax_t const total = boost::filesystem::file_size (from);
+	boost::uintmax_t remaining = total;
+
+	while (remaining) {
+		boost::uintmax_t this_time = min (chunk, remaining);
+		size_t N = fread (buffer, 1, chunk, f);
+		if (N < this_time) {
+			fclose (f);
+			fclose (t);
+			free (buffer);
+			throw ReadFileError (from, errno);
+		}
+
+		N = fwrite (buffer, 1, this_time, t);
+		if (N < this_time) {
+			fclose (f);
+			fclose (t);
+			free (buffer);
+			throw WriteFileError (to, errno);
+		}
+
+		progress (1 - float(remaining) / total);
+		remaining -= this_time;
+	}
+
+	fclose (f);
+	fclose (t);
+	free (buffer);
+}
+
+#ifdef DCPOMATIC_VARIANT_SWAROOP
+
+/* Make up a key from the machine UUID */
+dcp::Data
+key_from_uuid ()
+{
+	dcp::Data key (dcpomatic::crypto_key_length());
+	memset (key.data().get(), 0, key.size());
+	string const magic = command_and_read ("dcpomatic2_uuid");
+	strncpy ((char *) key.data().get(), magic.c_str(), dcpomatic::crypto_key_length());
+	return key;
+}
+
+/* swaroop chain file format:
+ *
+ *  0 [int16_t] IV length
+ *  2 [int16_t] cert #1 length, or 0 for none
+ *  4 [int16_t] cert #2 length, or 0 for none
+ *  6 [int16_t] cert #3 length, or 0 for none
+ *  8 [int16_t] cert #4 length, or 0 for none
+ * 10 [int16_t] cert #5 length, or 0 for none
+ * 12 [int16_t] cert #6 length, or 0 for none
+ * 14 [int16_t] cert #7 length, or 0 for none
+ * 16 [int16_t] cert #8 length, or 0 for none
+ * 16 [int16_t] private key length
+ * 20 IV
+ *    cert #1
+ *    cert #2
+ *    cert #3
+ *    cert #4
+ *    cert #5
+ *    cert #6
+ *    cert #7
+ *    cert #8
+ *    private key
+ */
+
+struct __attribute__ ((packed)) Header_ {
+	int16_t iv_length;
+	int16_t cert_length[8];
+	int16_t private_key_length;
+};
+
+typedef struct Header_ Header;
+
+shared_ptr<dcp::CertificateChain>
+read_swaroop_chain (boost::filesystem::path path)
+{
+	dcp::Data data (path);
+	Header* header = (Header *) data.data().get();
+	uint8_t* p = data.data().get() + sizeof(Header);
+
+	dcp::Data iv (p, header->iv_length);
+	p += iv.size();
+
+	shared_ptr<dcp::CertificateChain> cc (new dcp::CertificateChain());
+	for (int i = 0; i < 8; ++i) {
+		if (header->cert_length[i] == 0) {
+			break;
+		}
+		dcp::Data c(p, header->cert_length[i]);
+		p += c.size();
+		cc->add (dcp::Certificate(dcpomatic::decrypt(c, key_from_uuid(), iv)));
+	}
+
+	dcp::Data k (p, header->private_key_length);
+	cc->set_key (dcpomatic::decrypt(k, key_from_uuid(), iv));
+	return cc;
+}
+
+void
+write_swaroop_chain (shared_ptr<const dcp::CertificateChain> chain, boost::filesystem::path output)
+{
+	scoped_array<uint8_t> buffer (new uint8_t[65536]);
+	Header* header = (Header *) buffer.get();
+	memset (header, 0, sizeof(Header));
+	uint8_t* p = buffer.get() + sizeof(Header);
+
+	dcp::Data iv = dcpomatic::random_iv ();
+	header->iv_length = iv.size ();
+	memcpy (p, iv.data().get(), iv.size());
+	p += iv.size();
+
+	int N = 0;
+	BOOST_FOREACH (dcp::Certificate i, chain->root_to_leaf()) {
+		dcp::Data e = dcpomatic::encrypt (i.certificate(true), key_from_uuid(), iv);
+		memcpy (p, e.data().get(), e.size());
+		p += e.size();
+		DCPOMATIC_ASSERT (N < 8);
+		header->cert_length[N] = e.size ();
+		++N;
+	}
+
+	dcp::Data k = dcpomatic::encrypt (chain->key().get(), key_from_uuid(), iv);
+	memcpy (p, k.data().get(), k.size());
+	p += k.size();
+	header->private_key_length = k.size ();
+
+	FILE* f = fopen_boost (output, "wb");
+	checked_fwrite (buffer.get(), p - buffer.get(), f, output);
+	fclose (f);
+}
+
+#endif