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 enum class NoteType {
 233         PROGRESS,
 234         ERROR,
 235         NOTE
 236 };
 237
 238
 239 enum class Standard {
 240         INTEROP,
 241         SMPTE
 242 };
 243
 244
 245 enum class Formulation {
 246         MODIFIED_TRANSITIONAL_1,
 247         MULTIPLE_MODIFIED_TRANSITIONAL_1,
 248         DCI_ANY,
 249         DCI_SPECIFIC,
 250 };
 251
 252
 253 std::string formulation_to_string (dcp::Formulation formulation);
 254 dcp::Formulation string_to_formulation (std::string forumulation);
 255
 256
 257 /** @class Colour
 258  *  @brief An RGB colour
 259  */
 260 class Colour
 261 {
 262 public:
 263         /** Construct a Colour, initialising it to black */
 264         Colour ();
 265
 266         /** Construct a Colour from R, G and B.  The values run between
 267          *  0 and 255.
 268          */
 269         Colour (int r_, int g_, int b_);
 270
 271         /** Construct a Colour from an ARGB hex string; the alpha value is ignored.
 272          *  @param argb_hex A string of the form AARRGGBB, where e.g. RR is a two-character
 273          *  hex value.
 274          */
 275         explicit Colour (std::string argb_hex);
 276
 277         int r = 0; ///< red component, from 0 to 255
 278         int g = 0; ///< green component, from 0 to 255
 279         int b = 0; ///< blue component, from 0 to 255
 280
 281         /** @return An RGB string of the form RRGGBB, where e.g. RR is a two-character
 282          *  hex value.
 283          */
 284         std::string to_rgb_string () const;
 285
 286         /** @return An ARGB string of the form AARRGGBB, where e.g. RR is a two-character
 287          *  hex value.  The alpha value will always be FF (ie 255; maximum alpha).
 288          */
 289         std::string to_argb_string () const;
 290 };
 291
 292
 293 extern bool operator== (Colour const & a, Colour const & b);
 294 extern bool operator!= (Colour const & a, Colour const & b);
 295
 296
 297 typedef boost::function<void (NoteType, std::string)> NoteHandler;
 298
 299
 300 /** Maximum absolute difference between dcp::SubtitleString::aspect_adjust values that
 301  *  are considered equal
 302  */
 303 constexpr float ASPECT_ADJUST_EPSILON = 1e-3;
 304
 305
 306 /** Maximum absolute difference between dcp::SubtitleString alignment values that
 307  *  are considered equal.
 308  */
 309 constexpr float ALIGN_EPSILON = 1e-3;
 310
 311
 312 /** Maximum absolute difference between dcp::SubtitleString space_before values that
 313  *  are considered equal.
 314  */
 315 constexpr float SPACE_BEFORE_EPSILON = 1e-3;
 316
 317
 318 enum class Marker {
 319         FFOC, ///< first frame of composition
 320         LFOC, ///< last frame of composition
 321         FFTC, ///< first frame of title credits
 322         LFTC, ///< last frame of title credits
 323         FFOI, ///< first frame of intermission
 324         LFOI, ///< last frame of intermission
 325         FFEC, ///< first frame of end credits
 326         LFEC, ///< last frame of end credits
 327         FFMC, ///< first frame of moving credits
 328         LFMC  ///< last frame of moving credits
 329 };
 330
 331
 332 std::string marker_to_string (Marker);
 333 Marker marker_from_string (std::string);
 334
 335
 336 enum class Status
 337 {
 338         FINAL, ///< final version
 339         TEMP,  ///< temporary version (picture/sound unfinished)
 340         PRE    ///< pre-release (picture/sound finished)
 341 };
 342
 343
 344 extern std::string status_to_string (Status s);
 345 extern Status string_to_status (std::string s);
 346
 347
 348 class ContentVersion
 349 {
 350 public:
 351         ContentVersion ();
 352
 353         explicit ContentVersion (cxml::ConstNodePtr node);
 354
 355         explicit ContentVersion (std::string label_text_);
 356
 357         ContentVersion (std::string id_, std::string label_text_)
 358                 : id (id_)
 359                 , label_text (label_text_)
 360         {}
 361
 362         void as_xml (xmlpp::Element* parent) const;
 363
 364         std::string id;
 365         std::string label_text;
 366 };
 367
 368
 369 class Luminance
 370 {
 371 public:
 372         enum class Unit {
 373                 CANDELA_PER_SQUARE_METRE,
 374                 FOOT_LAMBERT
 375         };
 376
 377         Luminance (cxml::ConstNodePtr node);
 378
 379         Luminance (float value, Unit unit);
 380
 381         void set_value (float v);
 382         void set_unit (Unit u) {
 383                 _unit = u;
 384         }
 385
 386         float value () const {
 387                 return _value;
 388         }
 389
 390         Unit unit () const {
 391                 return _unit;
 392         }
 393
 394         float value_in_foot_lamberts () const;
 395
 396         void as_xml (xmlpp::Element* parent, std::string ns) const;
 397
 398         static std::string unit_to_string (Unit u);
 399         static Unit string_to_unit (std::string u);
 400
 401 private:
 402         float _value;
 403         Unit _unit;
 404 };
 405
 406
 407 bool operator== (Luminance const& a, Luminance const& b);
 408
 409
 410 class MainSoundConfiguration
 411 {
 412 public:
 413         explicit MainSoundConfiguration(std::string);
 414         MainSoundConfiguration (MCASoundField field_, int channels);
 415
 416         MCASoundField field () const {
 417                 return _field;
 418         }
 419
 420         int channels () const {
 421                 return _channels.size();
 422         }
 423
 424         boost::optional<Channel> mapping (int index) const;
 425         void set_mapping (int index, Channel channel);
 426
 427         std::string to_string () const;
 428
 429 private:
 430         MCASoundField _field;
 431         std::vector<boost::optional<Channel>> _channels;
 432 };
 433
 434
 435 }
 436
 437
 438 #endif