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                 , load_font_nodes_can_differ (false)
 210                 , keep_going (false)
 211         {}
 212
 213         /** The maximum allowable mean difference in pixel value between two images */
 214         double max_mean_pixel_error;
 215         /** The maximum standard deviation of the differences in pixel value between two images */
 216         double max_std_dev_pixel_error;
 217         /** The maximum difference in audio sample value between two soundtracks */
 218         int max_audio_sample_error;
 219         /** true if the &lt;AnnotationText&gt; nodes of CPLs are allowed to differ */
 220         bool cpl_annotation_texts_can_differ;
 221         /** true if the &lt;AnnotationText&gt; nodes of Reels are allowed to differ */
 222         bool reel_annotation_texts_can_differ;
 223         /** true if <Hash>es in Reels can differ */
 224         bool reel_hashes_can_differ;
 225         /** true if IssueDate nodes can differ */
 226         bool issue_dates_can_differ;
 227         bool load_font_nodes_can_differ;
 228         bool keep_going;
 229 };
 230
 231 /* I've been unable to make mingw happy with ERROR as a symbol, so
 232    I'm using a DCP_ prefix here.
 233 */
 234 enum NoteType {
 235         DCP_PROGRESS,
 236         DCP_ERROR,
 237         DCP_NOTE
 238 };
 239
 240 enum Standard {
 241         INTEROP,
 242         SMPTE
 243 };
 244
 245 enum Formulation {
 246         MODIFIED_TRANSITIONAL_1,
 247         MULTIPLE_MODIFIED_TRANSITIONAL_1,
 248         DCI_ANY,
 249         DCI_SPECIFIC,
 250         /** For testing: adds no AuthorizedDeviceInfo tag */
 251         MODIFIED_TRANSITIONAL_TEST
 252 };
 253
 254 /** @class Colour
 255  *  @brief An RGB colour.
 256  */
 257 class Colour
 258 {
 259 public:
 260         Colour ();
 261         Colour (int r_, int g_, int b_);
 262         explicit Colour (std::string argb_hex);
 263
 264         int r; ///< red component, from 0 to 255
 265         int g; ///< green component, from 0 to 255
 266         int b; ///< blue component, from 0 to 255
 267
 268         std::string to_rgb_string () const;
 269         std::string to_argb_string () const;
 270 };
 271
 272 extern bool operator== (Colour const & a, Colour const & b);
 273 extern bool operator!= (Colour const & a, Colour const & b);
 274 extern std::ostream & operator<< (std::ostream & s, Colour const & c);
 275
 276 typedef boost::function<void (NoteType, std::string)> NoteHandler;
 277
 278 /** Maximum absolute difference between dcp::SubtitleString::aspect_adjust values that
 279  *  are considered equal.
 280  */
 281 const float ASPECT_ADJUST_EPSILON = 1e-3;
 282
 283 /** Maximum absolute difference between dcp::SubtitleString alignment values that
 284  *  are considered equal.
 285  */
 286 const float ALIGN_EPSILON = 1e-3;
 287
 288 enum Marker {
 289         FFOC, ///< first frame of composition
 290         LFOC, ///< last frame of composition
 291         FFTC, ///< first frame of title credits
 292         LFTC, ///< last frame of title credits
 293         FFOI, ///< first frame of intermission
 294         LFOI, ///< last frame of intermission
 295         FFEC, ///< first frame of end credits
 296         LFEC, ///< last frame of end credits
 297         FFMC, ///< first frame of moving credits
 298         LFMC  ///< last frame of moving credits
 299 };
 300
 301 std::string marker_to_string (Marker);
 302 Marker marker_from_string (std::string);
 303
 304 class Rating
 305 {
 306 public:
 307         Rating (std::string agency_, std::string label_)
 308                 : agency (agency_)
 309                 , label (label_)
 310         {}
 311
 312         explicit Rating (cxml::ConstNodePtr node);
 313
 314         void as_xml (xmlpp::Element* parent) const;
 315
 316         /** URI of the agency issuing the rating */
 317         std::string agency;
 318         /** Rating (e.g. PG, PG-13, 12A etc) */
 319         std::string label;
 320 };
 321
 322 extern bool operator== (Rating const & a, Rating const & b);
 323 extern std::ostream& operator<< (std::ostream& s, Rating const & r);
 324
 325 }
 326
 327 #endif