Remove all use of stringstream in an attempt to fix
[dcpomatic.git] / src / lib / util.cc
1 /*
2     Copyright (C) 2012-2016 Carl Hetherington <cth@carlh.net>
3
4     This file is part of DCP-o-matic.
5
6     DCP-o-matic is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     DCP-o-matic is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
18
19 */
20
21 /** @file src/lib/util.cc
22  *  @brief Some utility functions and classes.
23  */
24
25 #include "util.h"
26 #include "exceptions.h"
27 #include "dcp_content_type.h"
28 #include "filter.h"
29 #include "cinema_sound_processor.h"
30 #include "config.h"
31 #include "ratio.h"
32 #include "job.h"
33 #include "cross.h"
34 #include "video_content.h"
35 #include "rect.h"
36 #include "digester.h"
37 #include "audio_processor.h"
38 #include "compose.hpp"
39 #include <dcp/util.h>
40 #include <dcp/picture_asset.h>
41 #include <dcp/sound_asset.h>
42 #include <dcp/subtitle_asset.h>
43 extern "C" {
44 #include <libavfilter/avfilter.h>
45 #include <libavcodec/avcodec.h>
46 }
47 #include <curl/curl.h>
48 #ifdef DCPOMATIC_GRAPHICS_MAGICK
49 #include <Magick++.h>
50 #endif
51 #include <glib.h>
52 #include <pangomm/init.h>
53 #include <boost/algorithm/string.hpp>
54 #include <boost/thread.hpp>
55 #include <boost/filesystem.hpp>
56 #ifdef DCPOMATIC_WINDOWS
57 #include <boost/locale.hpp>
58 #include <dbghelp.h>
59 #endif
60 #include <signal.h>
61 #include <iomanip>
62 #include <iostream>
63 #include <fstream>
64 #include <climits>
65 #include <stdexcept>
66 #ifdef DCPOMATIC_POSIX
67 #include <execinfo.h>
68 #include <cxxabi.h>
69 #endif
70
71 #include "i18n.h"
72
73 using std::string;
74 using std::setfill;
75 using std::ostream;
76 using std::endl;
77 using std::vector;
78 using std::min;
79 using std::max;
80 using std::map;
81 using std::list;
82 using std::multimap;
83 using std::istream;
84 using std::pair;
85 using std::cout;
86 using std::bad_alloc;
87 using std::set_terminate;
88 using boost::shared_ptr;
89 using boost::thread;
90 using boost::optional;
91 using boost::lexical_cast;
92 using boost::bad_lexical_cast;
93 using dcp::Size;
94
95 /** Path to our executable, required by the stacktrace stuff and filled
96  *  in during App::onInit().
97  */
98 string program_name;
99 static boost::thread::id ui_thread;
100 static boost::filesystem::path backtrace_file;
101
102 /** Convert some number of seconds to a string representation
103  *  in hours, minutes and seconds.
104  *
105  *  @param s Seconds.
106  *  @return String of the form H:M:S (where H is hours, M
107  *  is minutes and S is seconds).
108  */
109 string
110 seconds_to_hms (int s)
111 {
112         int m = s / 60;
113         s -= (m * 60);
114         int h = m / 60;
115         m -= (h * 60);
116
117         char buffer[64];
118         snprintf (buffer, sizeof(buffer), "%d:%02d:%02d", h, m, s);
119         return buffer;
120 }
121
122 /** @param s Number of seconds.
123  *  @return String containing an approximate description of s (e.g. "about 2 hours")
124  */
125 string
126 seconds_to_approximate_hms (int s)
127 {
128         int m = s / 60;
129         s -= (m * 60);
130         int h = m / 60;
131         m -= (h * 60);
132
133         string ap;
134
135         bool const hours = h > 0;
136         bool const minutes = h < 6 && m > 0;
137         bool const seconds = h == 0 && m < 10 && s > 0;
138
139         if (hours) {
140                 if (m > 30 && !minutes) {
141                         /// TRANSLATORS: h here is an abbreviation for hours
142                         ap += raw_convert<string>(h + 1) + _("h");
143                 } else {
144                         /// TRANSLATORS: h here is an abbreviation for hours
145                         ap += raw_convert<string>(h) + _("h");
146                 }
147
148                 if (minutes || seconds) {
149                         ap += N_(" ");
150                 }
151         }
152
153         if (minutes) {
154                 /* Minutes */
155                 if (s > 30 && !seconds) {
156                         /// TRANSLATORS: m here is an abbreviation for minutes
157                         ap += raw_convert<string>(m + 1) + _("m");
158                 } else {
159                         /// TRANSLATORS: m here is an abbreviation for minutes
160                         ap += raw_convert<string>(m) + _("m");
161                 }
162
163                 if (seconds) {
164                         ap += N_(" ");
165                 }
166         }
167
168         if (seconds) {
169                 /* Seconds */
170                 /// TRANSLATORS: s here is an abbreviation for seconds
171                 ap += raw_convert<string>(s) + _("s");
172         }
173
174         return ap;
175 }
176
177 double
178 seconds (struct timeval t)
179 {
180         return t.tv_sec + (double (t.tv_usec) / 1e6);
181 }
182
183 #ifdef DCPOMATIC_WINDOWS
184
185 /** Resolve symbol name and source location given the path to the executable */
186 int
187 addr2line (void const * const addr)
188 {
189         char addr2line_cmd[512] = { 0 };
190         sprintf (addr2line_cmd, "addr2line -f -p -e %.256s %p > %s", program_name.c_str(), addr, backtrace_file.string().c_str());
191         return system(addr2line_cmd);
192 }
193
194 /** This is called when C signals occur on Windows (e.g. SIGSEGV)
195  *  (NOT C++ exceptions!).  We write a backtrace to backtrace_file by dark means.
196  *  Adapted from code here: http://spin.atomicobject.com/2013/01/13/exceptions-stack-traces-c/
197  */
198 LONG WINAPI
199 exception_handler(struct _EXCEPTION_POINTERS * info)
200 {
201         FILE* f = fopen_boost (backtrace_file, "w");
202         fprintf (f, "C-style exception %d\n", info->ExceptionRecord->ExceptionCode);
203         fclose(f);
204
205         if (info->ExceptionRecord->ExceptionCode != EXCEPTION_STACK_OVERFLOW) {
206                 CONTEXT* context = info->ContextRecord;
207                 SymInitialize (GetCurrentProcess (), 0, true);
208
209                 STACKFRAME frame = { 0 };
210
211                 /* setup initial stack frame */
212 #if _WIN64
213                 frame.AddrPC.Offset    = context->Rip;
214                 frame.AddrStack.Offset = context->Rsp;
215                 frame.AddrFrame.Offset = context->Rbp;
216 #else
217                 frame.AddrPC.Offset    = context->Eip;
218                 frame.AddrStack.Offset = context->Esp;
219                 frame.AddrFrame.Offset = context->Ebp;
220 #endif
221                 frame.AddrPC.Mode      = AddrModeFlat;
222                 frame.AddrStack.Mode   = AddrModeFlat;
223                 frame.AddrFrame.Mode   = AddrModeFlat;
224
225                 while (
226                         StackWalk (
227                                 IMAGE_FILE_MACHINE_I386,
228                                 GetCurrentProcess (),
229                                 GetCurrentThread (),
230                                 &frame,
231                                 context,
232                                 0,
233                                 SymFunctionTableAccess,
234                                 SymGetModuleBase,
235                                 0
236                                 )
237                         ) {
238                         addr2line((void *) frame.AddrPC.Offset);
239                 }
240         } else {
241 #ifdef _WIN64
242                 addr2line ((void *) info->ContextRecord->Rip);
243 #else
244                 addr2line ((void *) info->ContextRecord->Eip);
245 #endif
246         }
247
248         return EXCEPTION_CONTINUE_SEARCH;
249 }
250 #endif
251
252 void
253 set_backtrace_file (boost::filesystem::path p)
254 {
255         backtrace_file = p;
256 }
257
258 /** This is called when there is an unhandled exception.  Any
259  *  backtrace in this function is useless on Windows as the stack has
260  *  already been unwound from the throw; we have the gdb wrap hack to
261  *  cope with that.
262  */
263 void
264 terminate ()
265 {
266         try {
267                 static bool tried_throw = false;
268                 // try once to re-throw currently active exception
269                 if (!tried_throw) {
270                         tried_throw = true;
271                         throw;
272                 }
273         }
274         catch (const std::exception &e) {
275                 std::cerr << __FUNCTION__ << " caught unhandled exception. what(): "
276                           << e.what() << std::endl;
277         }
278         catch (...) {
279                 std::cerr << __FUNCTION__ << " caught unknown/unhandled exception."
280                           << std::endl;
281         }
282
283         abort();
284 }
285
286 void
287 dcpomatic_setup_path_encoding ()
288 {
289 #ifdef DCPOMATIC_WINDOWS
290         /* Dark voodoo which, I think, gets boost::filesystem::path to
291            correctly convert UTF-8 strings to paths, and also paths
292            back to UTF-8 strings (on path::string()).
293
294            After this, constructing boost::filesystem::paths from strings
295            converts from UTF-8 to UTF-16 inside the path.  Then
296            path::string().c_str() gives UTF-8 and
297            path::c_str()          gives UTF-16.
298
299            This is all Windows-only.  AFAICT Linux/OS X use UTF-8 everywhere,
300            so things are much simpler.
301         */
302         std::locale::global (boost::locale::generator().generate (""));
303         boost::filesystem::path::imbue (std::locale ());
304 #endif
305 }
306
307 /** Call the required functions to set up DCP-o-matic's static arrays, etc.
308  *  Must be called from the UI thread, if there is one.
309  */
310 void
311 dcpomatic_setup ()
312 {
313 #ifdef DCPOMATIC_WINDOWS
314         boost::filesystem::path p = g_get_user_config_dir ();
315         p /= "backtrace.txt";
316         set_backtrace_file (p);
317         SetUnhandledExceptionFilter(exception_handler);
318 #endif
319
320         avfilter_register_all ();
321
322 #ifdef DCPOMATIC_OSX
323         /* Add our lib directory to the libltdl search path so that
324            xmlsec can find xmlsec1-openssl.
325         */
326         boost::filesystem::path lib = app_contents ();
327         lib /= "lib";
328         setenv ("LTDL_LIBRARY_PATH", lib.c_str (), 1);
329 #endif
330
331         set_terminate (terminate);
332
333         Pango::init ();
334         dcp::init ();
335
336         Ratio::setup_ratios ();
337         PresetColourConversion::setup_colour_conversion_presets ();
338         VideoContentScale::setup_scales ();
339         DCPContentType::setup_dcp_content_types ();
340         Filter::setup_filters ();
341         CinemaSoundProcessor::setup_cinema_sound_processors ();
342         AudioProcessor::setup_audio_processors ();
343
344         curl_global_init (CURL_GLOBAL_ALL);
345
346 #ifdef DCPOMATIC_GRAPHICS_MAGICK
347         Magick::InitializeMagick (0);
348 #endif
349
350         ui_thread = boost::this_thread::get_id ();
351 }
352
353 #ifdef DCPOMATIC_WINDOWS
354 boost::filesystem::path
355 mo_path ()
356 {
357         wchar_t buffer[512];
358         GetModuleFileName (0, buffer, 512 * sizeof(wchar_t));
359         boost::filesystem::path p (buffer);
360         p = p.parent_path ();
361         p = p.parent_path ();
362         p /= "locale";
363         return p;
364 }
365 #endif
366
367 #ifdef DCPOMATIC_OSX
368 boost::filesystem::path
369 mo_path ()
370 {
371         return "DCP-o-matic 2.app/Contents/Resources";
372 }
373 #endif
374
375 void
376 dcpomatic_setup_gettext_i18n (string lang)
377 {
378 #ifdef DCPOMATIC_LINUX
379         lang += ".UTF8";
380 #endif
381
382         if (!lang.empty ()) {
383                 /* Override our environment language.  Note that the caller must not
384                    free the string passed into putenv().
385                 */
386                 string s = String::compose ("LANGUAGE=%1", lang);
387                 putenv (strdup (s.c_str ()));
388                 s = String::compose ("LANG=%1", lang);
389                 putenv (strdup (s.c_str ()));
390                 s = String::compose ("LC_ALL=%1", lang);
391                 putenv (strdup (s.c_str ()));
392         }
393
394         setlocale (LC_ALL, "");
395         textdomain ("libdcpomatic2");
396
397 #if defined(DCPOMATIC_WINDOWS) || defined(DCPOMATIC_OSX)
398         bindtextdomain ("libdcpomatic2", mo_path().string().c_str());
399         bind_textdomain_codeset ("libdcpomatic2", "UTF8");
400 #endif
401
402 #ifdef DCPOMATIC_LINUX
403         bindtextdomain ("libdcpomatic2", LINUX_LOCALE_PREFIX);
404 #endif
405 }
406
407 /** Compute a digest of the first and last `size' bytes of a set of files. */
408 string
409 digest_head_tail (vector<boost::filesystem::path> files, boost::uintmax_t size)
410 {
411         boost::scoped_array<char> buffer (new char[size]);
412         Digester digester;
413
414         /* Head */
415         boost::uintmax_t to_do = size;
416         char* p = buffer.get ();
417         int i = 0;
418         while (i < int64_t (files.size()) && to_do > 0) {
419                 FILE* f = fopen_boost (files[i], "rb");
420                 if (!f) {
421                         throw OpenFileError (files[i].string());
422                 }
423
424                 boost::uintmax_t this_time = min (to_do, boost::filesystem::file_size (files[i]));
425                 fread (p, 1, this_time, f);
426                 p += this_time;
427                 to_do -= this_time;
428                 fclose (f);
429
430                 ++i;
431         }
432         digester.add (buffer.get(), size - to_do);
433
434         /* Tail */
435         to_do = size;
436         p = buffer.get ();
437         i = files.size() - 1;
438         while (i >= 0 && to_do > 0) {
439                 FILE* f = fopen_boost (files[i], "rb");
440                 if (!f) {
441                         throw OpenFileError (files[i].string());
442                 }
443
444                 boost::uintmax_t this_time = min (to_do, boost::filesystem::file_size (files[i]));
445                 dcpomatic_fseek (f, -this_time, SEEK_END);
446                 fread (p, 1, this_time, f);
447                 p += this_time;
448                 to_do -= this_time;
449                 fclose (f);
450
451                 --i;
452         }
453         digester.add (buffer.get(), size - to_do);
454
455         return digester.get ();
456 }
457
458 /** Round a number up to the nearest multiple of another number.
459  *  @param c Index.
460  *  @param s Array of numbers to round, indexed by c.
461  *  @param t Multiple to round to.
462  *  @return Rounded number.
463  */
464 int
465 stride_round_up (int c, int const * stride, int t)
466 {
467         int const a = stride[c] + (t - 1);
468         return a - (a % t);
469 }
470
471 /** Trip an assert if the caller is not in the UI thread */
472 void
473 ensure_ui_thread ()
474 {
475         DCPOMATIC_ASSERT (boost::this_thread::get_id() == ui_thread);
476 }
477
478 string
479 audio_channel_name (int c)
480 {
481         DCPOMATIC_ASSERT (MAX_DCP_AUDIO_CHANNELS == 16);
482
483         /// TRANSLATORS: these are the names of audio channels; Lfe (sub) is the low-frequency
484         /// enhancement channel (sub-woofer).  HI is the hearing-impaired audio track and
485         /// VI is the visually-impaired audio track (audio describe).
486         string const channels[] = {
487                 _("Left"),
488                 _("Right"),
489                 _("Centre"),
490                 _("Lfe (sub)"),
491                 _("Left surround"),
492                 _("Right surround"),
493                 _("Hearing impaired"),
494                 _("Visually impaired"),
495                 _("Left centre"),
496                 _("Right centre"),
497                 _("Left rear surround"),
498                 _("Right rear surround"),
499                 _("D-BOX primary"),
500                 _("D-BOX secondary"),
501                 _("Unused"),
502                 _("Unused")
503         };
504
505         return channels[c];
506 }
507
508 bool
509 valid_image_file (boost::filesystem::path f)
510 {
511         if (boost::starts_with (f.leaf().string(), "._")) {
512                 return false;
513         }
514
515         string ext = f.extension().string();
516         transform (ext.begin(), ext.end(), ext.begin(), ::tolower);
517         return (
518                 ext == ".tif" || ext == ".tiff" || ext == ".jpg" || ext == ".jpeg" ||
519                 ext == ".png" || ext == ".bmp" || ext == ".tga" || ext == ".dpx" ||
520                 ext == ".j2c" || ext == ".j2k" || ext == ".jp2"
521                 );
522 }
523
524 bool
525 valid_j2k_file (boost::filesystem::path f)
526 {
527         string ext = f.extension().string();
528         transform (ext.begin(), ext.end(), ext.begin(), ::tolower);
529         return (ext == ".j2k" || ext == ".j2c" || ext == ".jp2");
530 }
531
532 string
533 tidy_for_filename (string f)
534 {
535         string t;
536         for (size_t i = 0; i < f.length(); ++i) {
537                 if (isalnum (f[i]) || f[i] == '_' || f[i] == '-') {
538                         t += f[i];
539                 } else {
540                         t += '_';
541                 }
542         }
543
544         return t;
545 }
546
547 dcp::Size
548 fit_ratio_within (float ratio, dcp::Size full_frame)
549 {
550         if (ratio < full_frame.ratio ()) {
551                 return dcp::Size (lrintf (full_frame.height * ratio), full_frame.height);
552         }
553
554         return dcp::Size (full_frame.width, lrintf (full_frame.width / ratio));
555 }
556
557 void *
558 wrapped_av_malloc (size_t s)
559 {
560         void* p = av_malloc (s);
561         if (!p) {
562                 throw bad_alloc ();
563         }
564         return p;
565 }
566
567 map<string, string>
568 split_get_request (string url)
569 {
570         enum {
571                 AWAITING_QUESTION_MARK,
572                 KEY,
573                 VALUE
574         } state = AWAITING_QUESTION_MARK;
575
576         map<string, string> r;
577         string k;
578         string v;
579         for (size_t i = 0; i < url.length(); ++i) {
580                 switch (state) {
581                 case AWAITING_QUESTION_MARK:
582                         if (url[i] == '?') {
583                                 state = KEY;
584                         }
585                         break;
586                 case KEY:
587                         if (url[i] == '=') {
588                                 v.clear ();
589                                 state = VALUE;
590                         } else {
591                                 k += url[i];
592                         }
593                         break;
594                 case VALUE:
595                         if (url[i] == '&') {
596                                 r.insert (make_pair (k, v));
597                                 k.clear ();
598                                 state = KEY;
599                         } else {
600                                 v += url[i];
601                         }
602                         break;
603                 }
604         }
605
606         if (state == VALUE) {
607                 r.insert (make_pair (k, v));
608         }
609
610         return r;
611 }
612
613 string
614 video_asset_filename (shared_ptr<dcp::PictureAsset> asset, int reel_index, int reel_count, optional<string> summary)
615 {
616         dcp::NameFormat::Map values;
617         values['t'] = "j2c";
618         values['i'] = asset->id();
619         values['r'] = raw_convert<string> (reel_index + 1);
620         values['n'] = raw_convert<string> (reel_count);
621         if (summary) {
622                 values['c'] = summary.get();
623         }
624         return Config::instance()->dcp_asset_filename_format().get(values) + ".mxf";
625 }
626
627 string
628 audio_asset_filename (shared_ptr<dcp::SoundAsset> asset, int reel_index, int reel_count, optional<string> summary)
629 {
630         dcp::NameFormat::Map values;
631         values['t'] = "pcm";
632         values['i'] = asset->id();
633         values['r'] = raw_convert<string> (reel_index + 1);
634         values['n'] = raw_convert<string> (reel_count);
635         if (summary) {
636                 values['c'] = summary.get();
637         }
638         return Config::instance()->dcp_asset_filename_format().get(values) + ".mxf";
639 }
640
641 float
642 relaxed_string_to_float (string s)
643 {
644         try {
645                 boost::algorithm::replace_all (s, ",", ".");
646                 return lexical_cast<float> (s);
647         } catch (bad_lexical_cast) {
648                 boost::algorithm::replace_all (s, ".", ",");
649                 return lexical_cast<float> (s);
650         }
651 }
652
653 bool
654 string_not_empty (string s)
655 {
656         return !s.empty ();
657 }