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 /* windows.h defines 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() = default;
  73
  74         Size (int w, int h)
  75                 : width (w)
  76                 , height (h)
  77         {}
  78
  79         float ratio () const {
  80                 return float (width) / height;
  81         }
  82
  83         int width = 0;
  84         int height = 0;
  85 };
  86
  87
  88 extern bool operator== (Size const & a, Size const & b);
  89 extern bool operator!= (Size const & a, Size const & b);
  90
  91
  92 /** Identifier for a sound channel */
  93 enum class Channel {
  94         LEFT = 0,      ///< left
  95         RIGHT = 1,     ///< right
  96         CENTRE = 2,    ///< centre
  97         LFE = 3,       ///< low-frequency effects (sub)
  98         LS = 4,        ///< left surround
  99         RS = 5,        ///< right surround
 100         HI = 6,
 101         VI = 7,
 102         /* 8 and 9 are not used */
 103         BSL = 10,
 104         BSR = 11,
 105         MOTION_DATA = 12,
 106         SYNC_SIGNAL = 13,
 107         SIGN_LANGUAGE = 14,
 108         /* 15 is not used */
 109         CHANNEL_COUNT = 16
 110 };
 111
 112
 113 std::vector<dcp::Channel> used_audio_channels ();
 114
 115
 116 enum class MCASoundField
 117 {
 118         FIVE_POINT_ONE,
 119         SEVEN_POINT_ONE,
 120         OTHER
 121 };
 122
 123
 124 extern std::string channel_to_mca_id (Channel c, MCASoundField field);
 125 extern Channel mca_id_to_channel (std::string);
 126 extern std::string channel_to_mca_name (Channel c, MCASoundField field);
 127 extern ASDCP::UL channel_to_mca_universal_label (Channel c, MCASoundField field, ASDCP::Dictionary const* dict);
 128
 129
 130 enum class Effect
 131 {
 132         NONE,
 133         BORDER,
 134         SHADOW
 135 };
 136
 137
 138 extern std::string effect_to_string (Effect e);
 139 extern Effect string_to_effect (std::string s);
 140
 141
 142 enum class HAlign
 143 {
 144         LEFT,   ///< horizontal position is distance from left of screen to left of subtitle
 145         CENTER, ///< horizontal position is distance from centre of screen to centre of subtitle
 146         RIGHT,  ///< horizontal position is distance from right of screen to right of subtitle
 147 };
 148
 149
 150 extern std::string halign_to_string (HAlign a);
 151 extern HAlign string_to_halign (std::string s);
 152
 153
 154 enum class VAlign
 155 {
 156         /** vertical position is distance:
 157          *    from top of screen to top of subtitle (for SMPTE 428-7:{2007,2010} or
 158          *    from top of screen to subtitle baseline (for Interop or SMPTE 428-7:2014)
 159          */
 160         TOP,
 161         /** vertical position is distance:
 162          *    from centre of screen to centre of subtitle (for SMPTE 428-7:{2007,2010}) or
 163          *    from centre of screen to subtitle baseline (for Interop or SMPTE 428-7:2014)
 164          */
 165         CENTER,
 166         /** vertical position is distance:
 167          *    from bottom of screen to bottom of subtitle (for SMPTE 428-7:{2007,2010}) or
 168          *    from bottom of screen to subtitle baseline (for Interop or SMPTE 428-7:2014)
 169          */
 170         BOTTOM
 171 };
 172
 173
 174 extern std::string valign_to_string (VAlign a);
 175 extern VAlign string_to_valign (std::string s);
 176
 177
 178 /** Direction for subtitle test */
 179 enum class Direction
 180 {
 181         LTR, ///< left-to-right
 182         RTL, ///< right-to-left
 183         TTB, ///< top-to-bottom
 184         BTT  ///< bottom-to-top
 185 };
 186
 187
 188 extern std::string direction_to_string (Direction a);
 189 extern Direction string_to_direction (std::string s);
 190
 191
 192 enum class Eye
 193 {
 194         LEFT,
 195         RIGHT
 196 };
 197
 198
 199 /** @class Fraction
 200  *  @brief A fraction (i.e. a thing with an integer numerator and an integer denominator).
 201  */
 202 class Fraction
 203 {
 204 public:
 205         /** Construct a fraction of 0/0 */
 206         Fraction() = default;
 207
 208         explicit Fraction (std::string s);
 209         /** Construct a fraction with a specified numerator and denominator.
 210          *  @param n Numerator.
 211          *  @param d Denominator.
 212          */
 213         Fraction (int n, int d) : numerator (n), denominator (d) {}
 214
 215         float as_float () const {
 216                 return float (numerator) / denominator;
 217         }
 218
 219         std::string as_string () const;
 220
 221         int numerator = 0;
 222         int denominator = 0;
 223 };
 224
 225
 226 extern bool operator== (Fraction const & a, Fraction const & b);
 227 extern bool operator!= (Fraction const & a, Fraction const & b);
 228
 229
 230 enum class NoteType {
 231         PROGRESS,
 232         ERROR,
 233         NOTE
 234 };
 235
 236
 237 enum class Standard {
 238         INTEROP,
 239         SMPTE
 240 };
 241
 242
 243 enum class Formulation {
 244         MODIFIED_TRANSITIONAL_1,
 245         MULTIPLE_MODIFIED_TRANSITIONAL_1,
 246         DCI_ANY,
 247         DCI_SPECIFIC,
 248 };
 249
 250
 251 std::string formulation_to_string (dcp::Formulation formulation);
 252 dcp::Formulation string_to_formulation (std::string forumulation);
 253
 254
 255 /** @class Colour
 256  *  @brief An RGB colour
 257  */
 258 class Colour
 259 {
 260 public:
 261         /** Construct a Colour, initialising it to black */
 262         Colour() = default;
 263
 264         /** Construct a Colour from R, G and B.  The values run between
 265          *  0 and 255.
 266          */
 267         Colour (int r_, int g_, int b_);
 268
 269         /** Construct a Colour from an ARGB hex string; the alpha value is ignored.
 270          *  @param argb_hex A string of the form AARRGGBB, where e.g. RR is a two-character
 271          *  hex value.
 272          */
 273         explicit Colour (std::string argb_hex);
 274
 275         int r = 0; ///< red component, from 0 to 255
 276         int g = 0; ///< green component, from 0 to 255
 277         int b = 0; ///< blue component, from 0 to 255
 278
 279         /** @return An RGB string of the form RRGGBB, where e.g. RR is a two-character
 280          *  hex value.
 281          */
 282         std::string to_rgb_string () const;
 283
 284         /** @return An ARGB string of the form AARRGGBB, where e.g. RR is a two-character
 285          *  hex value.  The alpha value will always be FF (ie 255; maximum alpha).
 286          */
 287         std::string to_argb_string () const;
 288 };
 289
 290
 291 extern bool operator== (Colour const & a, Colour const & b);
 292 extern bool operator!= (Colour const & a, Colour const & b);
 293
 294
 295 typedef boost::function<void (NoteType, std::string)> NoteHandler;
 296
 297
 298 /** Maximum absolute difference between dcp::SubtitleString::aspect_adjust values that
 299  *  are considered equal
 300  */
 301 constexpr float ASPECT_ADJUST_EPSILON = 1e-3;
 302
 303
 304 /** Maximum absolute difference between dcp::SubtitleString alignment values that
 305  *  are considered equal.
 306  */
 307 constexpr float ALIGN_EPSILON = 1e-3;
 308
 309
 310 /** Maximum absolute difference between dcp::SubtitleString space_before values that
 311  *  are considered equal.
 312  */
 313 constexpr float SPACE_BEFORE_EPSILON = 1e-3;
 314
 315
 316 enum class Marker {
 317         FFOC, ///< first frame of composition
 318         LFOC, ///< last frame of composition
 319         FFTC, ///< first frame of title credits
 320         LFTC, ///< last frame of title credits
 321         FFOI, ///< first frame of intermission
 322         LFOI, ///< last frame of intermission
 323         FFEC, ///< first frame of end credits
 324         LFEC, ///< last frame of end credits
 325         FFMC, ///< first frame of moving credits
 326         LFMC  ///< last frame of moving credits
 327 };
 328
 329
 330 std::string marker_to_string (Marker);
 331 Marker marker_from_string (std::string);
 332
 333
 334 enum class Status
 335 {
 336         FINAL, ///< final version
 337         TEMP,  ///< temporary version (picture/sound unfinished)
 338         PRE    ///< pre-release (picture/sound finished)
 339 };
 340
 341
 342 extern std::string status_to_string (Status s);
 343 extern Status string_to_status (std::string s);
 344
 345
 346 class ContentVersion
 347 {
 348 public:
 349         ContentVersion ();
 350
 351         explicit ContentVersion (cxml::ConstNodePtr node);
 352
 353         explicit ContentVersion (std::string label_text_);
 354
 355         ContentVersion (std::string id_, std::string label_text_)
 356                 : id (id_)
 357                 , label_text (label_text_)
 358         {}
 359
 360         void as_xml (xmlpp::Element* parent) const;
 361
 362         std::string id;
 363         std::string label_text;
 364 };
 365
 366
 367 class Luminance
 368 {
 369 public:
 370         enum class Unit {
 371                 CANDELA_PER_SQUARE_METRE,
 372                 FOOT_LAMBERT
 373         };
 374
 375         Luminance (cxml::ConstNodePtr node);
 376
 377         Luminance (float value, Unit unit);
 378
 379         void set_value (float v);
 380         void set_unit (Unit u) {
 381                 _unit = u;
 382         }
 383
 384         float value () const {
 385                 return _value;
 386         }
 387
 388         Unit unit () const {
 389                 return _unit;
 390         }
 391
 392         float value_in_foot_lamberts () const;
 393
 394         void as_xml (xmlpp::Element* parent, std::string ns) const;
 395
 396         static std::string unit_to_string (Unit u);
 397         static Unit string_to_unit (std::string u);
 398
 399 private:
 400         float _value;
 401         Unit _unit;
 402 };
 403
 404
 405 bool operator== (Luminance const& a, Luminance const& b);
 406
 407
 408 class MainSoundConfiguration
 409 {
 410 public:
 411         explicit MainSoundConfiguration(std::string);
 412         MainSoundConfiguration (MCASoundField field_, int channels);
 413
 414         MCASoundField field () const {
 415                 return _field;
 416         }
 417
 418         int channels () const {
 419                 return _channels.size();
 420         }
 421
 422         boost::optional<Channel> mapping (int index) const;
 423         void set_mapping (int index, Channel channel);
 424
 425         std::string to_string () const;
 426
 427 private:
 428         MCASoundField _field;
 429         std::vector<boost::optional<Channel>> _channels;
 430 };
 431
 432
 433 }
 434
 435
 436 #endif