X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Ftypes.cc;h=29e2c387ff05d028c02bce6724b87ff49d85bee7;hb=1b9271d523018476936bc22a1ef7d4f1ee4cf42c;hp=f32d90bdd73b9cae51550797b2b645cdf7ac801d;hpb=43515be4f21d92d66f28588bcd0dc93ee517d301;p=libdcp.git diff --git a/src/types.cc b/src/types.cc index f32d90bd..29e2c387 100644 --- a/src/types.cc +++ b/src/types.cc @@ -1,26 +1,42 @@ /* - Copyright (C) 2012-2014 Carl Hetherington + Copyright (C) 2012-2019 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of libdcp. + + libdcp 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, + libdcp 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. + along with libdcp. If not, see . + + In addition, as a special exception, the copyright holders give + permission to link the code of portions of this program with the + OpenSSL library under certain conditions as described in each + individual source file, and distribute linked combinations + including the two. + You must obey the GNU General Public License in all respects + for all of the code used other than OpenSSL. If you modify + file(s) with this exception, you may extend this exception to your + version of the file(s), but you are not obligated to do so. If you + do not wish to do so, delete this exception statement from your + version. If you delete this exception statement from all source + files in the program, then also delete it here. */ #include "raw_convert.h" #include "types.h" #include "exceptions.h" #include "compose.hpp" +#include "dcp_assert.h" +#include #include #include #include @@ -30,6 +46,22 @@ using namespace std; using namespace dcp; using namespace boost; +bool dcp::operator== (dcp::Size const & a, dcp::Size const & b) +{ + return (a.width == b.width && a.height == b.height); +} + +bool dcp::operator!= (dcp::Size const & a, dcp::Size const & b) +{ + return !(a == b); +} + +ostream& dcp::operator<< (ostream& s, dcp::Size const & a) +{ + s << a.width << "x" << a.height; + return s; +} + /** Construct a Fraction from a string of the form * e.g. "1 3". */ @@ -107,16 +139,20 @@ Colour::Colour (string argb_hex) string Colour::to_argb_string () const { - stringstream s; - s << "FF"; - s << hex - << setw(2) << setfill('0') << r - << setw(2) << setfill('0') << g - << setw(2) << setfill('0') << b; + char buffer[9]; + snprintf (buffer, sizeof(buffer), "FF%02X%02X%02X", r, g, b); + return buffer; +} - string t = s.str(); - to_upper (t); - return t; +/** @return An RGB string of the form RRGGBB, where e.g. RR is a two-character + * hex value. + */ +string +Colour::to_rgb_string () const +{ + char buffer[7]; + snprintf (buffer, sizeof(buffer), "%02X%02X%02X", r, g, b); + return buffer; } /** operator== for Colours. @@ -200,7 +236,7 @@ dcp::string_to_halign (string s) } else if (s == "right") { return HALIGN_RIGHT; } - + boost::throw_exception (DCPReadError ("unknown subtitle halign type")); } @@ -229,6 +265,200 @@ dcp::string_to_valign (string s) } else if (s == "bottom") { return VALIGN_BOTTOM; } - + 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")); +} + +/** Convert a content kind to a string which can be used in a + * <ContentKind> node. + * @param kind ContentKind. + * @return string. + */ +string +dcp::content_kind_to_string (ContentKind kind) +{ + switch (kind) { + case FEATURE: + return "feature"; + case SHORT: + return "short"; + case TRAILER: + return "trailer"; + case TEST: + return "test"; + case TRANSITIONAL: + return "transitional"; + case RATING: + return "rating"; + case TEASER: + return "teaser"; + case POLICY: + return "policy"; + case PUBLIC_SERVICE_ANNOUNCEMENT: + return "psa"; + case ADVERTISEMENT: + return "advertisement"; + case EPISODE: + return "episode"; + case PROMO: + return "promo"; + } + + DCP_ASSERT (false); +} + +/** Convert a string from a <ContentKind> node to a libdcp ContentKind. + * Reasonably tolerant about varying case. + * @param kind Content kind string. + * @return libdcp ContentKind. + */ +dcp::ContentKind +dcp::content_kind_from_string (string kind) +{ + transform (kind.begin(), kind.end(), kind.begin(), ::tolower); + + if (kind == "feature") { + return FEATURE; + } else if (kind == "short") { + return SHORT; + } else if (kind == "trailer") { + return TRAILER; + } else if (kind == "test") { + return TEST; + } else if (kind == "transitional") { + return TRANSITIONAL; + } else if (kind == "rating") { + return RATING; + } else if (kind == "teaser") { + return TEASER; + } else if (kind == "policy") { + return POLICY; + } else if (kind == "psa") { + return PUBLIC_SERVICE_ANNOUNCEMENT; + } else if (kind == "advertisement") { + return ADVERTISEMENT; + } else if (kind == "episode") { + return EPISODE; + } else if (kind == "promo") { + return PROMO; + } + + throw BadContentKindError (kind); +} + +string +dcp::marker_to_string (dcp::Marker m) +{ + switch (m) { + case FFOC: + return "FFOC"; + case LFOC: + return "LFOC"; + case FFTC: + return "FFTC"; + case LFTC: + return "LFTC"; + case FFOI: + return "FFOI"; + case LFOI: + return "LFOI"; + case FFEC: + return "FFEC"; + case LFEC: + return "LFEC"; + case FFMC: + return "FFMC"; + case LFMC: + return "LFMC"; + } + + DCP_ASSERT (false); +} + +dcp::Marker +dcp::marker_from_string (string s) +{ + if (s == "FFOC") { + return FFOC; + } else if (s == "LFOC") { + return LFOC; + } else if (s == "FFTC") { + return FFTC; + } else if (s == "LFTC") { + return LFTC; + } else if (s == "FFOI") { + return FFOI; + } else if (s == "LFOI") { + return LFOI; + } else if (s == "FFEC") { + return FFEC; + } else if (s == "LFEC") { + return LFEC; + } else if (s == "FFMC") { + return FFMC; + } else if (s == "LFMC") { + return LFMC; + } + + DCP_ASSERT (false); +} + +Rating::Rating (cxml::ConstNodePtr node) +{ + agency = node->string_child("Agency"); + label = node->string_child("Label"); + node->done (); +} + +void +Rating::as_xml (xmlpp::Element* parent) const +{ + parent->add_child("Agency")->add_child_text(agency); + parent->add_child("Label")->add_child_text(label); +} + +bool +dcp::operator== (Rating const & a, Rating const & b) +{ + return a.agency == b.agency && a.label == b.label; +} + +ostream & +dcp::operator<< (ostream& s, Rating const & r) +{ + s << r.agency << " " << r.label; + return s; +}