Small C++11 tweaks.

[libsub.git] / src / subrip_reader.cc

diff --git a/src/subrip_reader.cc b/src/subrip_reader.cc
index 6fab0ffcbdcfed813a7207dbbcda35d513daa115..8ba7c7ddc51f08f2434541d3d07d9fc6fffd129b 100644 (file)
--- a/src/subrip_reader.cc
+++ b/src/subrip_reader.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2014-2015 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2014-2020 Carl Hetherington <cth@carlh.net>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -24,7 +24,9 @@
 #include "subrip_reader.h"
 #include "exceptions.h"
 #include "util.h"
-#include <locked_sstream.h>
+#include "sub_assert.h"
+#include "raw_convert.h"
+#include "ssa_reader.h"
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/regex.hpp>
@@ -35,20 +37,19 @@
 
 using std::string;
 using std::vector;
-using std::list;
 using std::cout;
 using std::hex;
 using boost::lexical_cast;
 using boost::to_upper;
 using boost::optional;
 using boost::function;
+using boost::algorithm::replace_all;
 using namespace sub;
 
 /** @param s Subtitle string encoded in UTF-8 */
-SubripReader::SubripReader (string const & s)
+SubripReader::SubripReader (string s)
 {
-       locked_stringstream str (s);
-       this->read (boost::bind (&get_line_stringstream, &str));
+       this->read (boost::bind(&get_line_string, &s));
 }
 
 /** @param f Subtitle file encoded in UTF-8 */
@@ -68,14 +69,11 @@ SubripReader::read (function<optional<string> ()> get_line)
 
        RawSubtitle rs;
 
-       /* This reader extracts no information about where the subtitle
-          should be on screen, so its reference is TOP_OF_SUBTITLE.
-       */
        rs.vertical_position.line = 0;
        rs.vertical_position.reference = TOP_OF_SUBTITLE;
 
        while (true) {
-               optional<string> line = get_line ();
+               auto line = get_line ();
                if (!line) {
                        break;
                }
@@ -104,6 +102,7 @@ SubripReader::read (function<optional<string> ()> get_line)
                        rs.italic = false;
                        rs.underline = false;
                        rs.vertical_position.line = 0;
+                       rs.vertical_position.reference = TOP_OF_SUBTITLE;
                }
                break;
                case METADATA:
@@ -113,7 +112,7 @@ SubripReader::read (function<optional<string> ()> get_line)
                        /* Further trim this line, removing spaces from the end */
                        trim_right_if (*line, boost::is_any_of (" "));
 
-                       boost::algorithm::split (p, *line, boost::algorithm::is_any_of (" "));
+                       boost::algorithm::split (p, *line, boost::algorithm::is_any_of (" "), boost::token_compress_on);
                        if (p.size() != 3 && p.size() != 7) {
                                for (int i = 0; i < 2; ++i) {
                                        optional<string> ex = get_line ();
@@ -155,13 +154,37 @@ SubripReader::convert_time (string t)
 
        vector<string> b;
        boost::algorithm::split (b, a[2], boost::is_any_of (","));
+       if (b.size() != 2) {
+               throw SubripError (t, "time in the format h:m:s,ms", _context);
+       }
+
+       int h, m, s, ms;
+
+       try {
+               h = lexical_cast<int>(a[0]);
+       } catch (boost::bad_lexical_cast &) {
+               throw SubripError (t, "integer hour value", _context);
+       }
+
+       try {
+               m = lexical_cast<int>(a[1]);
+       } catch (boost::bad_lexical_cast &) {
+               throw SubripError (t, "integer minute value", _context);
+       }
+
+       try {
+               s = lexical_cast<int>(b[0]);
+       } catch (boost::bad_lexical_cast &) {
+               throw SubripError (t, "integer second value", _context);
+       }
 
-       return Time::from_hms (
-               lexical_cast<int> (a[0]),
-               lexical_cast<int> (a[1]),
-               lexical_cast<int> (b[0]),
-               lexical_cast<int> (b[1])
-               );
+       try {
+               ms = lexical_cast<int>(b[1]);
+       } catch (boost::bad_lexical_cast &) {
+               throw SubripError (t, "integer millisecond value", _context);
+       }
+
+       return Time::from_hms (h, m, s, ms);
 }
 
 void
@@ -174,7 +197,7 @@ SubripReader::convert_line (string t, RawSubtitle& p)
 
        string tag;
 
-       list<Colour> colours;
+       vector<Colour> colours;
        colours.push_back (Colour (1, 1, 1));
 
        /* XXX: missing <font> support */
@@ -213,26 +236,51 @@ SubripReader::convert_line (string t, RawSubtitle& p)
                                        p.underline = false;
                                } else if (boost::starts_with (tag, "font")) {
                                        maybe_content (p);
-                                       boost::regex re (".*color=\"#([0123456789abcdef]+)\"");
+                                       boost::regex re (".*color=\"?#([[:xdigit:]]+)\"?");
                                        boost::smatch match;
                                        if (boost::regex_search (tag, match, re) && string (match[1]).size() == 6) {
                                                p.colour = Colour::from_rgb_hex (match[1]);
                                                colours.push_back (p.colour);
+                                       } else {
+                                               re = boost::regex (
+                                                       ".*color=\"rgba\\("
+                                                       "[[:space:]]*([[:digit:]]+)[[:space:]]*,"
+                                                       "[[:space:]]*([[:digit:]]+)[[:space:]]*,"
+                                                       "[[:space:]]*([[:digit:]]+)[[:space:]]*,"
+                                                       "[[:space:]]*([[:digit:]]+)[[:space:]]*"
+                                                       "\\)\""
+                                                       );
+                                               if (boost::regex_search (tag, match, re) && match.size() == 5) {
+                                                       p.colour.r = raw_convert<int>(string(match[1])) / 255.0;
+                                                       p.colour.g = raw_convert<int>(string(match[2])) / 255.0;
+                                                       p.colour.b = raw_convert<int>(string(match[3])) / 255.0;
+                                                       colours.push_back (p.colour);
+                                               } else {
+                                                       throw SubripError (tag, "a colour in the format #rrggbb or rgba(rr,gg,bb,aa)", _context);
+                                               }
                                        }
                                } else if (tag == "/font") {
                                        maybe_content (p);
+                                       SUB_ASSERT (!colours.empty());
                                        colours.pop_back ();
                                        p.colour = colours.back ();
+                               } else if (tag.size() > 0 && tag[0] == '\\') {
+                                       SSAReader::parse_style (p, tag, 288, 288);
                                }
                                tag.clear ();
                                state = TEXT;
                        } else {
-                               tag += t[i];
+                               tag += tolower (t[i]);
                        }
                        break;
                }
        }
 
+       /* Strip Unicode U+202B (right-to-left embedding) as sometimes it is rendered
+          as a missing character.  This may be a hack.
+       */
+       replace_all (p.text, "\xe2\x80\xab", "");
+
        maybe_content (p);
 }