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