src/types.h

   1 /*
   2     Copyright (C) 2012-2021 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
  35 /** @file  src/types.h
  36  *  @brief Miscellaneous types
  37  */
  38
  39
  40 #ifndef LIBDCP_TYPES_H
  41 #define LIBDCP_TYPES_H
  42
  43
  44 #include "warnings.h"
  45 #include <libcxml/cxml.h>
  46 LIBDCP_DISABLE_WARNINGS
  47 #include <asdcp/KLV.h>
  48 LIBDCP_ENABLE_WARNINGS
  49 #include <memory>
  50 #include <boost/function.hpp>
  51 #include <string>
  52
  53
  54 /* MinGW seems to define this, but we want to use it */
  55 #undef ERROR
  56
  57
  58 namespace xmlpp {
  59         class Element;
  60 }
  61
  62
  63 namespace dcp
  64 {
  65
  66
  67 /** @struct Size
  68  *  @brief The integer, two-dimensional size of something.
  69  */
  70 struct Size
  71 {
  72         Size ()
  73                 : width (0)
  74                 , height (0)
  75         {}
  76
  77         Size (int w, int h)
  78                 : width (w)
  79                 , height (h)
  80         {}
  81
  82         float ratio () const {
  83                 return float (width) / height;
  84         }
  85
  86         int width;
  87         int height;
  88 };
  89
  90
  91 extern bool operator== (Size const & a, Size const & b);
  92 extern bool operator!= (Size const & a, Size const & b);
  93
  94
  95 /** Identifier for a sound channel */
  96 enum class Channel {
  97         LEFT = 0,      ///< left
  98         RIGHT = 1,     ///< right
  99         CENTRE = 2,    ///< centre
 100         LFE = 3,       ///< low-frequency effects (sub)
 101         LS = 4,        ///< left surround
 102         RS = 5,        ///< right surround
 103         HI = 6,
 104         VI = 7,
 105         /* 8 and 9 are not used */
 106         BSL = 10,
 107         BSR = 11,
 108         MOTION_DATA = 12,
 109         SYNC_SIGNAL = 13,
 110         SIGN_LANGUAGE = 14,
 111         /* 15 is not used */
 112         CHANNEL_COUNT = 16
 113 };
 114
 115
 116 std::vector<dcp::Channel> used_audio_channels ();
 117
 118
 119 enum class MCASoundField
 120 {
 121         FIVE_POINT_ONE,
 122         SEVEN_POINT_ONE
 123 };
 124
 125
 126 extern std::string channel_to_mca_id (Channel c, MCASoundField field);
 127 extern Channel mca_id_to_channel (std::string);
 128 extern std::string channel_to_mca_name (Channel c, MCASoundField field);
 129 extern ASDCP::UL channel_to_mca_universal_label (Channel c, MCASoundField field, ASDCP::Dictionary const* dict);
 130
 131
 132 enum class Effect
 133 {
 134         NONE,
 135         BORDER,
 136         SHADOW
 137 };
 138
 139
 140 extern std::string effect_to_string (Effect e);
 141 extern Effect string_to_effect (std::string s);
 142
 143
 144 enum class HAlign
 145 {
 146         LEFT,   ///< horizontal position is distance from left of screen to left of subtitle
 147         CENTER, ///< horizontal position is distance from centre of screen to centre of subtitle
 148         RIGHT,  ///< horizontal position is distance from right of screen to right of subtitle
 149 };
 150
 151
 152 extern std::string halign_to_string (HAlign a);
 153 extern HAlign string_to_halign (std::string s);
 154
 155
 156 enum class VAlign
 157 {
 158         /** vertical position is distance:
 159          *    from top of screen to top of subtitle (for SMPTE) or
 160          *    from top of screen to subtitle baseline (for Interop)
 161          */
 162         TOP,
 163         /** vertical position is distance:
 164          *    from centre of screen to centre of subtitle (for SMPTE) or
 165          *    from centre of screen to subtitle baseline (for Interop)
 166          */
 167         CENTER,
 168         /** vertical position is distance:
 169          *    from bottom of screen to bottom of subtitle (for SMPTE) or
 170          *    from bottom of screen to subtitle baseline (for Interop)
 171          */
 172         BOTTOM
 173 };
 174
 175
 176 extern std::string valign_to_string (VAlign a);
 177 extern VAlign string_to_valign (std::string s);
 178
 179
 180 /** Direction for subtitle test */
 181 enum class Direction
 182 {
 183         LTR, ///< left-to-right
 184         RTL, ///< right-to-left
 185         TTB, ///< top-to-bottom
 186         BTT  ///< bottom-to-top
 187 };
 188
 189
 190 extern std::string direction_to_string (Direction a);
 191 extern Direction string_to_direction (std::string s);
 192
 193
 194 enum class Eye
 195 {
 196         LEFT,
 197         RIGHT
 198 };
 199
 200
 201 /** @class Fraction
 202  *  @brief A fraction (i.e. a thing with an integer numerator and an integer denominator).
 203  */
 204 class Fraction
 205 {
 206 public:
 207         /** Construct a fraction of 0/0 */
 208         Fraction () {}
 209         explicit Fraction (std::string s);
 210         /** Construct a fraction with a specified numerator and denominator.
 211          *  @param n Numerator.
 212          *  @param d Denominator.
 213          */
 214         Fraction (int n, int d) : numerator (n), denominator (d) {}
 215
 216         float as_float () const {
 217                 return float (numerator) / denominator;
 218         }
 219
 220         std::string as_string () const;
 221
 222         int numerator = 0;
 223         int denominator = 0;
 224 };
 225
 226
 227 extern bool operator== (Fraction const & a, Fraction const & b);
 228 extern bool operator!= (Fraction const & a, Fraction const & b);
 229
 230
 231 /** @struct EqualityOptions
 232  *  @brief  A class to describe what "equality" means for a particular test.
 233  *
 234  *  When comparing things, we want to be able to ignore some differences;
 235  *  this class expresses those differences.
 236  *
 237  *  It also contains some settings for how the comparison should be done.
 238  */
 239 struct EqualityOptions
 240 {
 241         /** Construct an EqualityOptions where nothing at all can differ */
 242         EqualityOptions () {}
 243
 244         /** The maximum allowable mean difference in pixel value between two images */
 245         double max_mean_pixel_error = 0;
 246         /** The maximum standard deviation of the differences in pixel value between two images */
 247         double max_std_dev_pixel_error = 0;
 248         /** The maximum difference in audio sample value between two soundtracks */
 249         int max_audio_sample_error = 0;
 250         /** true if the &lt;AnnotationText&gt; nodes of CPLs are allowed to differ */
 251         bool cpl_annotation_texts_can_differ = false;
 252         /** true if the &lt;AnnotationText&gt; nodes of Reels are allowed to differ */
 253         bool reel_annotation_texts_can_differ = false;
 254         /** true if <Hash>es in Reels can differ */
 255         bool reel_hashes_can_differ = false;
 256         /** true if IssueDate nodes can differ */
 257         bool issue_dates_can_differ = false;
 258         bool load_font_nodes_can_differ = false;
 259         bool keep_going = false;
 260         /** true to save the first pair of differeng image subtitles to the current working directory */
 261         bool export_differing_subtitles = false;
 262 };
 263
 264
 265 enum class NoteType {
 266         PROGRESS,
 267         ERROR,
 268         NOTE
 269 };
 270
 271
 272 enum class Standard {
 273         INTEROP,
 274         SMPTE
 275 };
 276
 277
 278 enum class Formulation {
 279         MODIFIED_TRANSITIONAL_1,
 280         MULTIPLE_MODIFIED_TRANSITIONAL_1,
 281         DCI_ANY,
 282         DCI_SPECIFIC,
 283 };
 284
 285
 286 std::string formulation_to_string (dcp::Formulation formulation);
 287 dcp::Formulation string_to_formulation (std::string forumulation);
 288
 289
 290 /** @class Colour
 291  *  @brief An RGB colour
 292  */
 293 class Colour
 294 {
 295 public:
 296         /** Construct a Colour, initialising it to black */
 297         Colour ();
 298
 299         /** Construct a Colour from R, G and B.  The values run between
 300          *  0 and 255.
 301          */
 302         Colour (int r_, int g_, int b_);
 303
 304         /** Construct a Colour from an ARGB hex string; the alpha value is ignored.
 305          *  @param argb_hex A string of the form AARRGGBB, where e.g. RR is a two-character
 306          *  hex value.
 307          */
 308         explicit Colour (std::string argb_hex);
 309
 310         int r = 0; ///< red component, from 0 to 255
 311         int g = 0; ///< green component, from 0 to 255
 312         int b = 0; ///< blue component, from 0 to 255
 313
 314         /** @return An RGB string of the form RRGGBB, where e.g. RR is a two-character
 315          *  hex value.
 316          */
 317         std::string to_rgb_string () const;
 318
 319         /** @return An ARGB string of the form AARRGGBB, where e.g. RR is a two-character
 320          *  hex value.  The alpha value will always be FF (ie 255; maximum alpha).
 321          */
 322         std::string to_argb_string () const;
 323 };
 324
 325
 326 extern bool operator== (Colour const & a, Colour const & b);
 327 extern bool operator!= (Colour const & a, Colour const & b);
 328
 329
 330 typedef boost::function<void (NoteType, std::string)> NoteHandler;
 331
 332
 333 /** Maximum absolute difference between dcp::SubtitleString::aspect_adjust values that
 334  *  are considered equal
 335  */
 336 constexpr float ASPECT_ADJUST_EPSILON = 1e-3;
 337
 338
 339 /** Maximum absolute difference between dcp::SubtitleString alignment values that
 340  *  are considered equal.
 341  */
 342 constexpr float ALIGN_EPSILON = 1e-3;
 343
 344
 345 /** Maximum absolute difference between dcp::SubtitleString space_before values that
 346  *  are considered equal.
 347  */
 348 constexpr float SPACE_BEFORE_EPSILON = 1e-3;
 349
 350
 351 enum class Marker {
 352         FFOC, ///< first frame of composition
 353         LFOC, ///< last frame of composition
 354         FFTC, ///< first frame of title credits
 355         LFTC, ///< last frame of title credits
 356         FFOI, ///< first frame of intermission
 357         LFOI, ///< last frame of intermission
 358         FFEC, ///< first frame of end credits
 359         LFEC, ///< last frame of end credits
 360         FFMC, ///< first frame of moving credits
 361         LFMC  ///< last frame of moving credits
 362 };
 363
 364
 365 std::string marker_to_string (Marker);
 366 Marker marker_from_string (std::string);
 367
 368
 369 enum class Status
 370 {
 371         FINAL, ///< final version
 372         TEMP,  ///< temporary version (picture/sound unfinished)
 373         PRE    ///< pre-release (picture/sound finished)
 374 };
 375
 376
 377 extern std::string status_to_string (Status s);
 378 extern Status string_to_status (std::string s);
 379
 380
 381 class ContentVersion
 382 {
 383 public:
 384         ContentVersion ();
 385
 386         explicit ContentVersion (cxml::ConstNodePtr node);
 387
 388         explicit ContentVersion (std::string label_text_);
 389
 390         ContentVersion (std::string id_, std::string label_text_)
 391                 : id (id_)
 392                 , label_text (label_text_)
 393         {}
 394
 395         void as_xml (xmlpp::Element* parent) const;
 396
 397         std::string id;
 398         std::string label_text;
 399 };
 400
 401
 402 class Luminance
 403 {
 404 public:
 405         enum class Unit {
 406                 CANDELA_PER_SQUARE_METRE,
 407                 FOOT_LAMBERT
 408         };
 409
 410         Luminance (cxml::ConstNodePtr node);
 411
 412         Luminance (float value, Unit unit);
 413
 414         void set_value (float v);
 415         void set_unit (Unit u) {
 416                 _unit = u;
 417         }
 418
 419         float value () const {
 420                 return _value;
 421         }
 422
 423         Unit unit () const {
 424                 return _unit;
 425         }
 426
 427         float value_in_foot_lamberts () const;
 428
 429         void as_xml (xmlpp::Element* parent, std::string ns) const;
 430
 431         static std::string unit_to_string (Unit u);
 432         static Unit string_to_unit (std::string u);
 433
 434 private:
 435         float _value;
 436         Unit _unit;
 437 };
 438
 439
 440 bool operator== (Luminance const& a, Luminance const& b);
 441
 442
 443 class MainSoundConfiguration
 444 {
 445 public:
 446         MainSoundConfiguration (std::string);
 447         MainSoundConfiguration (MCASoundField field_, int channels);
 448
 449         MCASoundField field () const {
 450                 return _field;
 451         }
 452
 453         int channels () const {
 454                 return _channels.size();
 455         }
 456
 457         boost::optional<Channel> mapping (int index) const;
 458         void set_mapping (int index, Channel channel);
 459
 460         std::string to_string () const;
 461
 462 private:
 463         MCASoundField _field;
 464         std::vector<boost::optional<Channel>> _channels;
 465 };
 466
 467
 468 }
 469
 470
 471 #endif