src/types.h

   1 /*
   2     Copyright (C) 2012-2019 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp 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     libdcp 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 libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34 /** @file  src/types.h
  35  *  @brief Miscellaneous types.
  36  */
  37
  38 #ifndef LIBDCP_TYPES_H
  39 #define LIBDCP_TYPES_H
  40
  41 #include <libcxml/cxml.h>
  42 #include <boost/shared_ptr.hpp>
  43 #include <boost/function.hpp>
  44 #include <string>
  45
  46 namespace xmlpp {
  47         class Element;
  48 }
  49
  50 namespace dcp
  51 {
  52
  53 /** @struct Size
  54  *  @brief The integer, two-dimensional size of something.
  55  */
  56 struct Size
  57 {
  58         Size ()
  59                 : width (0)
  60                 , height (0)
  61         {}
  62
  63         Size (int w, int h)
  64                 : width (w)
  65                 , height (h)
  66         {}
  67
  68         float ratio () const {
  69                 return float (width) / height;
  70         }
  71
  72         int width;
  73         int height;
  74 };
  75
  76 extern bool operator== (Size const & a, Size const & b);
  77 extern bool operator!= (Size const & a, Size const & b);
  78 extern std::ostream& operator<< (std::ostream& s, Size const & a);
  79
  80 /** Identifier for a sound channel */
  81 enum Channel {
  82         LEFT = 0,      ///< left
  83         RIGHT = 1,     ///< right
  84         CENTRE = 2,    ///< centre
  85         LFE = 3,       ///< low-frequency effects (sub)
  86         LS = 4,        ///< left surround
  87         RS = 5,        ///< right surround
  88         HI = 6,
  89         VI = 7,
  90         LC = 8,
  91         RC = 9,
  92         BSL = 10,
  93         BSR = 11
  94 };
  95
  96 enum ContentKind
  97 {
  98         FEATURE,
  99         SHORT,
 100         TRAILER,
 101         TEST,
 102         TRANSITIONAL,
 103         RATING,
 104         TEASER,
 105         POLICY,
 106         PUBLIC_SERVICE_ANNOUNCEMENT,
 107         ADVERTISEMENT,
 108         EPISODE,
 109         PROMO
 110 };
 111
 112 extern std::string content_kind_to_string (ContentKind kind);
 113 extern ContentKind content_kind_from_string (std::string kind);
 114
 115 enum Effect
 116 {
 117         NONE,
 118         BORDER,
 119         SHADOW
 120 };
 121
 122 extern std::string effect_to_string (Effect e);
 123 extern Effect string_to_effect (std::string s);
 124
 125 enum HAlign
 126 {
 127         HALIGN_LEFT,   ///< horizontal position is distance from left of screen to left of subtitle
 128         HALIGN_CENTER, ///< horizontal position is distance from centre of screen to centre of subtitle
 129         HALIGN_RIGHT,  ///< horizontal position is distance from right of screen to right of subtitle
 130 };
 131
 132 extern std::string halign_to_string (HAlign a);
 133 extern HAlign string_to_halign (std::string s);
 134
 135 enum VAlign
 136 {
 137         VALIGN_TOP,    ///< vertical position is distance from top of screen to top of subtitle
 138         VALIGN_CENTER, ///< vertical position is distance from centre of screen to centre of subtitle
 139         VALIGN_BOTTOM  ///< vertical position is distance from bottom of screen to bottom of subtitle
 140 };
 141
 142 extern std::string valign_to_string (VAlign a);
 143 extern VAlign string_to_valign (std::string s);
 144
 145 /** Direction for subtitle test */
 146 enum Direction
 147 {
 148         DIRECTION_LTR, ///< left-to-right
 149         DIRECTION_RTL, ///< right-to-left
 150         DIRECTION_TTB, ///< top-to-bottom
 151         DIRECTION_BTT  ///< bottom-to-top
 152 };
 153
 154 extern std::string direction_to_string (Direction a);
 155 extern Direction string_to_direction (std::string s);
 156
 157 enum Eye
 158 {
 159         EYE_LEFT,
 160         EYE_RIGHT
 161 };
 162
 163 /** @class Fraction
 164  *  @brief A fraction (i.e. a thing with an integer numerator and an integer denominator).
 165  */
 166 class Fraction
 167 {
 168 public:
 169         /** Construct a fraction of 0/0 */
 170         Fraction () : numerator (0), denominator (0) {}
 171         explicit Fraction (std::string s);
 172         /** Construct a fraction with a specified numerator and denominator.
 173          *  @param n Numerator.
 174          *  @param d Denominator.
 175          */
 176         Fraction (int n, int d) : numerator (n), denominator (d) {}
 177
 178         float as_float () const {
 179                 return float (numerator) / denominator;
 180         }
 181
 182         std::string as_string () const;
 183
 184         int numerator;
 185         int denominator;
 186 };
 187
 188 extern bool operator== (Fraction const & a, Fraction const & b);
 189 extern bool operator!= (Fraction const & a, Fraction const & b);
 190 extern std::ostream& operator<< (std::ostream& s, Fraction const & f);
 191
 192 /** @struct EqualityOptions
 193  *  @brief  A class to describe what "equality" means for a particular test.
 194  *
 195  *  When comparing things, we want to be able to ignore some differences;
 196  *  this class expresses those differences.
 197  */
 198 struct EqualityOptions
 199 {
 200         /** Construct an EqualityOptions where nothing at all can differ */
 201         EqualityOptions ()
 202                 : max_mean_pixel_error (0)
 203                 , max_std_dev_pixel_error (0)
 204                 , max_audio_sample_error (0)
 205                 , cpl_annotation_texts_can_differ (false)
 206                 , reel_annotation_texts_can_differ (false)
 207                 , reel_hashes_can_differ (false)
 208                 , issue_dates_can_differ (false)
 209                 , keep_going (false)
 210         {}
 211
 212         /** The maximum allowable mean difference in pixel value between two images */
 213         double max_mean_pixel_error;
 214         /** The maximum standard deviation of the differences in pixel value between two images */
 215         double max_std_dev_pixel_error;
 216         /** The maximum difference in audio sample value between two soundtracks */
 217         int max_audio_sample_error;
 218         /** true if the &lt;AnnotationText&gt; nodes of CPLs are allowed to differ */
 219         bool cpl_annotation_texts_can_differ;
 220         /** true if the &lt;AnnotationText&gt; nodes of Reels are allowed to differ */
 221         bool reel_annotation_texts_can_differ;
 222         /** true if <Hash>es in Reels can differ */
 223         bool reel_hashes_can_differ;
 224         /** true if IssueDate nodes can differ */
 225         bool issue_dates_can_differ;
 226         bool keep_going;
 227 };
 228
 229 /* I've been unable to make mingw happy with ERROR as a symbol, so
 230    I'm using a DCP_ prefix here.
 231 */
 232 enum NoteType {
 233         DCP_PROGRESS,
 234         DCP_ERROR,
 235         DCP_NOTE
 236 };
 237
 238 enum Standard {
 239         INTEROP,
 240         SMPTE
 241 };
 242
 243 enum Formulation {
 244         MODIFIED_TRANSITIONAL_1,
 245         MULTIPLE_MODIFIED_TRANSITIONAL_1,
 246         DCI_ANY,
 247         DCI_SPECIFIC,
 248         /** For testing: adds no AuthorizedDeviceInfo tag */
 249         MODIFIED_TRANSITIONAL_TEST
 250 };
 251
 252 /** @class Colour
 253  *  @brief An RGB colour.
 254  */
 255 class Colour
 256 {
 257 public:
 258         Colour ();
 259         Colour (int r_, int g_, int b_);
 260         explicit Colour (std::string argb_hex);
 261
 262         int r; ///< red component, from 0 to 255
 263         int g; ///< green component, from 0 to 255
 264         int b; ///< blue component, from 0 to 255
 265
 266         std::string to_rgb_string () const;
 267         std::string to_argb_string () const;
 268 };
 269
 270 extern bool operator== (Colour const & a, Colour const & b);
 271 extern bool operator!= (Colour const & a, Colour const & b);
 272 extern std::ostream & operator<< (std::ostream & s, Colour const & c);
 273
 274 typedef boost::function<void (NoteType, std::string)> NoteHandler;
 275
 276 /** Maximum absolute difference between dcp::SubtitleString::aspect_adjust values that
 277  *  are considered equal.
 278  */
 279 const float ASPECT_ADJUST_EPSILON = 1e-3;
 280
 281 /** Maximum absolute difference between dcp::SubtitleString alignment values that
 282  *  are considered equal.
 283  */
 284 const float ALIGN_EPSILON = 1e-3;
 285
 286 enum Marker {
 287         FFOC, ///< first frame of composition
 288         LFOC, ///< last frame of composition
 289         FFTC, ///< first frame of title credits
 290         LFTC, ///< last frame of title credits
 291         FFOI, ///< first frame of intermission
 292         LFOI, ///< last frame of intermission
 293         FFEC, ///< first frame of end credits
 294         LFEC, ///< last frame of end credits
 295         FFMC, ///< first frame of moving credits
 296         LFMC  ///< last frame of moving credits
 297 };
 298
 299 std::string marker_to_string (Marker);
 300 Marker marker_from_string (std::string);
 301
 302 class Rating
 303 {
 304 public:
 305         Rating (std::string agency_, std::string label_)
 306                 : agency (agency_)
 307                 , label (label_)
 308         {}
 309
 310         explicit Rating (cxml::ConstNodePtr node);
 311
 312         void as_xml (xmlpp::Element* parent) const;
 313
 314         /** URI of the agency issuing the rating */
 315         std::string agency;
 316         /** Rating (e.g. PG, PG-13, 12A etc) */
 317         std::string label;
 318 };
 319
 320 extern bool operator== (Rating const & a, Rating const & b);
 321 extern std::ostream& operator<< (std::ostream& s, Rating const & r);
 322
 323 }
 324
 325 #endif