X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Ftypes.cc;h=7853d11c6e874bc9c7de26bef821b05947a4e046;hb=b872223e0652ed828dc3b4ad1eb8a0bbb34a7da0;hp=ac01ae451466ee68c3dd9ce75eaaa8766841551b;hpb=41daa5821b3d3b0f450094fbf0d1e37a449f482c;p=libdcp.git diff --git a/src/types.cc b/src/types.cc index ac01ae45..7853d11c 100644 --- a/src/types.cc +++ b/src/types.cc @@ -1,39 +1,76 @@ +/* + Copyright (C) 2012-2014 Carl Hetherington + + 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 + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#include "raw_convert.h" +#include "types.h" +#include "exceptions.h" +#include "compose.hpp" +#include #include #include #include -#include -#include -#include "types.h" -#include "exceptions.h" using namespace std; -using namespace libdcp; +using namespace dcp; using namespace boost; +/** Construct a Fraction from a string of the form + * e.g. "1 3". + */ Fraction::Fraction (string s) { vector b; split (b, s, is_any_of (" ")); if (b.size() != 2) { - throw XMLError ("malformed fraction " + s + " in XML node"); + boost::throw_exception (XMLError ("malformed fraction " + s + " in XML node")); } - numerator = lexical_cast (b[0]); - denominator = lexical_cast (b[1]); + numerator = raw_convert (b[0]); + denominator = raw_convert (b[1]); +} + +string +Fraction::as_string () const +{ + return String::compose ("%1 %2", numerator, denominator); } bool -libdcp::operator== (Fraction const & a, Fraction const & b) +dcp::operator== (Fraction const & a, Fraction const & b) { return (a.numerator == b.numerator && a.denominator == b.denominator); } bool -libdcp::operator!= (Fraction const & a, Fraction const & b) +dcp::operator!= (Fraction const & a, Fraction const & b) { return (a.numerator != b.numerator || a.denominator != b.denominator); } -Color::Color () +ostream& +dcp::operator<< (ostream& s, Fraction const & f) +{ + s << f.numerator << "/" << f.denominator; + return s; +} + +/** Construct a Colour, initialising it to black. */ +Colour::Colour () : r (0) , g (0) , b (0) @@ -41,7 +78,10 @@ Color::Color () } -Color::Color (int r_, int g_, int b_) +/** Construct a Colour from R, G and B. The values run between + * 0 and 255. + */ +Colour::Colour (int r_, int g_, int b_) : r (r_) , g (g_) , b (b_) @@ -49,15 +89,15 @@ Color::Color (int r_, int g_, int b_) } -/** Construct a Color from an ARGB hex string; the alpha value is ignored. +/** Construct a Colour from an ARGB hex string; the alpha value is ignored. * @param argb_hex A string of the form AARRGGBB, where e.g. RR is a two-character * hex value. */ -Color::Color (string argb_hex) +Colour::Colour (string argb_hex) { int alpha; - if (sscanf (argb_hex.c_str(), "%2x%2x%2x%2x", &alpha, &r, &g, &b) < 4) { - throw XMLError ("could not parse colour string"); + if (sscanf (argb_hex.c_str(), "%2x%2x%2x%2x", &alpha, &r, &g, &b) != 4) { + boost::throw_exception (XMLError ("could not parse colour string")); } } @@ -65,7 +105,7 @@ Color::Color (string argb_hex) * hex value. The alpha value will always be FF (ie 255; maximum alpha). */ string -Color::to_argb_string () const +Colour::to_argb_string () const { stringstream s; s << "FF"; @@ -79,35 +119,35 @@ Color::to_argb_string () const return t; } -/** operator== for Colors. - * @param a First color to compare. - * @param b Second color to compare. +/** operator== for Colours. + * @param a First colour to compare. + * @param b Second colour to compare. */ bool -libdcp::operator== (Color const & a, Color const & b) +dcp::operator== (Colour const & a, Colour const & b) { return (a.r == b.r && a.g == b.g && a.b == b.b); } -/** operator!= for Colors. - * @param a First color to compare. - * @param b Second color to compare. +/** operator!= for Colours. + * @param a First colour to compare. + * @param b Second colour to compare. */ bool -libdcp::operator!= (Color const & a, Color const & b) +dcp::operator!= (Colour const & a, Colour const & b) { return !(a == b); } ostream & -libdcp::operator<< (ostream& s, Color const & c) +dcp::operator<< (ostream& s, Colour const & c) { s << "(" << c.r << ", " << c.g << ", " << c.b << ")"; return s; } string -libdcp::effect_to_string (Effect e) +dcp::effect_to_string (Effect e) { switch (e) { case NONE: @@ -118,11 +158,11 @@ libdcp::effect_to_string (Effect e) return "shadow"; } - throw MiscError ("unknown effect type"); + boost::throw_exception (MiscError ("unknown effect type")); } Effect -libdcp::string_to_effect (string s) +dcp::string_to_effect (string s) { if (s == "none") { return NONE; @@ -132,36 +172,96 @@ libdcp::string_to_effect (string s) return SHADOW; } - throw DCPReadError ("unknown subtitle effect type"); + boost::throw_exception (DCPReadError ("unknown subtitle effect type")); +} + +string +dcp::halign_to_string (HAlign h) +{ + switch (h) { + case HALIGN_LEFT: + return "left"; + case HALIGN_CENTER: + return "center"; + case HALIGN_RIGHT: + return "right"; + } + + boost::throw_exception (MiscError ("unknown subtitle halign type")); +} + +HAlign +dcp::string_to_halign (string s) +{ + if (s == "left") { + return HALIGN_LEFT; + } else if (s == "center") { + return HALIGN_CENTER; + } else if (s == "right") { + return HALIGN_RIGHT; + } + + boost::throw_exception (DCPReadError ("unknown subtitle halign type")); } string -libdcp::valign_to_string (VAlign v) +dcp::valign_to_string (VAlign v) { switch (v) { - case TOP: + case VALIGN_TOP: return "top"; - case CENTER: + case VALIGN_CENTER: return "center"; - case BOTTOM: + case VALIGN_BOTTOM: return "bottom"; } - throw MiscError ("unknown valign type"); + boost::throw_exception (MiscError ("unknown subtitle valign type")); } VAlign -libdcp::string_to_valign (string s) +dcp::string_to_valign (string s) { if (s == "top") { - return TOP; + return VALIGN_TOP; } else if (s == "center") { - return CENTER; + return VALIGN_CENTER; } else if (s == "bottom") { - return BOTTOM; + return VALIGN_BOTTOM; } - - throw DCPReadError ("unknown subtitle valign type"); + + boost::throw_exception (DCPReadError ("unknown subtitle valign type")); } - +string +dcp::direction_to_string (Direction v) +{ + switch (v) { + case DIRECTION_LTR: + return "ltr"; + case DIRECTION_RTL: + return "rtl"; + case DIRECTION_TTB: + return "ttb"; + case DIRECTION_BTT: + return "btt"; + } + + boost::throw_exception (MiscError ("unknown subtitle direction type")); +} + +Direction +dcp::string_to_direction (string s) +{ + if (s == "ltr" || s == "horizontal") { + return DIRECTION_LTR; + } else if (s == "rtl") { + return DIRECTION_RTL; + } else if (s == "ttb" || s == "vertical") { + return DIRECTION_TTB; + } else if (s == "btt") { + return DIRECTION_BTT; + } + + boost::throw_exception (DCPReadError ("unknown subtitle direction type")); +}