/*
- 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.
#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>
#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>
#include "i18n.h"
using std::string;
+using std::wstring;
using std::setfill;
using std::ostream;
using std::endl;
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().
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 ();
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]));
- fread (p, 1, this_time, f);
+ checked_fread (p, this_time, f, files[i]);
p += this_time;
to_do -= this_time;
fclose (f);
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]));
dcpomatic_fseek (f, -this_time, SEEK_END);
- fread (p, 1, this_time, f);
+ checked_fread (p, this_time, f, files[i]);
p += this_time;
to_do -= this_time;
fclose (f);
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);
}
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)
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;
}
}
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