83b4e8e5dee1e222608182d16842234bcb1fc131
[libdcp.git] / 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 /** Direction for subtitle test */
155 enum class Direction
156 {
157         LTR, ///< left-to-right
158         RTL, ///< right-to-left
159         TTB, ///< top-to-bottom
160         BTT  ///< bottom-to-top
161 };
162
163
164 extern std::string direction_to_string (Direction a);
165 extern Direction string_to_direction (std::string s);
166
167
168 enum class Eye
169 {
170         LEFT,
171         RIGHT
172 };
173
174
175 /** @class Fraction
176  *  @brief A fraction (i.e. a thing with an integer numerator and an integer denominator).
177  */
178 class Fraction
179 {
180 public:
181         /** Construct a fraction of 0/0 */
182         Fraction() = default;
183
184         explicit Fraction (std::string s);
185         /** Construct a fraction with a specified numerator and denominator.
186          *  @param n Numerator.
187          *  @param d Denominator.
188          */
189         Fraction (int n, int d) : numerator (n), denominator (d) {}
190
191         float as_float () const {
192                 return float (numerator) / denominator;
193         }
194
195         std::string as_string () const;
196
197         int numerator = 0;
198         int denominator = 0;
199 };
200
201
202 extern bool operator== (Fraction const & a, Fraction const & b);
203 extern bool operator!= (Fraction const & a, Fraction const & b);
204
205
206 enum class NoteType {
207         PROGRESS,
208         ERROR,
209         NOTE
210 };
211
212
213 enum class Standard {
214         INTEROP,
215         SMPTE
216 };
217
218
219 enum class Formulation {
220         MODIFIED_TRANSITIONAL_1,
221         MULTIPLE_MODIFIED_TRANSITIONAL_1,
222         DCI_ANY,
223         DCI_SPECIFIC,
224 };
225
226
227 std::string formulation_to_string (dcp::Formulation formulation);
228 dcp::Formulation string_to_formulation (std::string forumulation);
229
230
231 /** @class Colour
232  *  @brief An RGB colour
233  */
234 class Colour
235 {
236 public:
237         /** Construct a Colour, initialising it to black */
238         Colour() = default;
239
240         /** Construct a Colour from R, G and B.  The values run between
241          *  0 and 255.
242          */
243         Colour (int r_, int g_, int b_);
244
245         /** Construct a Colour from an ARGB hex string; the alpha value is ignored.
246          *  @param argb_hex A string of the form AARRGGBB, where e.g. RR is a two-character
247          *  hex value.
248          */
249         explicit Colour (std::string argb_hex);
250
251         int r = 0; ///< red component, from 0 to 255
252         int g = 0; ///< green component, from 0 to 255
253         int b = 0; ///< blue component, from 0 to 255
254
255         /** @return An RGB string of the form RRGGBB, where e.g. RR is a two-character
256          *  hex value.
257          */
258         std::string to_rgb_string () const;
259
260         /** @return An ARGB string of the form AARRGGBB, where e.g. RR is a two-character
261          *  hex value.  The alpha value will always be FF (ie 255; maximum alpha).
262          */
263         std::string to_argb_string () const;
264 };
265
266
267 extern bool operator== (Colour const & a, Colour const & b);
268 extern bool operator!= (Colour const & a, Colour const & b);
269
270
271 typedef boost::function<void (NoteType, std::string)> NoteHandler;
272
273
274 /** Maximum absolute difference between dcp::SubtitleString::aspect_adjust values that
275  *  are considered equal
276  */
277 constexpr float ASPECT_ADJUST_EPSILON = 1e-3;
278
279
280 /** Maximum absolute difference between dcp::SubtitleString alignment values that
281  *  are considered equal.
282  */
283 constexpr float ALIGN_EPSILON = 1e-3;
284
285
286 /** Maximum absolute difference between dcp::SubtitleString space_before values that
287  *  are considered equal.
288  */
289 constexpr float SPACE_BEFORE_EPSILON = 1e-3;
290
291
292 enum class Marker {
293         FFOC, ///< first frame of composition
294         LFOC, ///< last frame of composition
295         FFTC, ///< first frame of title credits
296         LFTC, ///< last frame of title credits
297         FFOI, ///< first frame of intermission
298         LFOI, ///< last frame of intermission
299         FFEC, ///< first frame of end credits
300         LFEC, ///< last frame of end credits
301         FFMC, ///< first frame of moving credits
302         LFMC  ///< last frame of moving credits
303 };
304
305
306 std::string marker_to_string (Marker);
307 Marker marker_from_string (std::string);
308
309
310 enum class Status
311 {
312         FINAL, ///< final version
313         TEMP,  ///< temporary version (picture/sound unfinished)
314         PRE    ///< pre-release (picture/sound finished)
315 };
316
317
318 extern std::string status_to_string (Status s);
319 extern Status string_to_status (std::string s);
320
321
322 class ContentVersion
323 {
324 public:
325         ContentVersion ();
326
327         explicit ContentVersion (cxml::ConstNodePtr node);
328
329         explicit ContentVersion (std::string label_text_);
330
331         ContentVersion (std::string id_, std::string label_text_)
332                 : id (id_)
333                 , label_text (label_text_)
334         {}
335
336         void as_xml (xmlpp::Element* parent) const;
337
338         std::string id;
339         std::string label_text;
340 };
341
342
343 class Luminance
344 {
345 public:
346         enum class Unit {
347                 CANDELA_PER_SQUARE_METRE,
348                 FOOT_LAMBERT
349         };
350
351         Luminance (cxml::ConstNodePtr node);
352
353         Luminance (float value, Unit unit);
354
355         void set_value (float v);
356         void set_unit (Unit u) {
357                 _unit = u;
358         }
359
360         float value () const {
361                 return _value;
362         }
363
364         Unit unit () const {
365                 return _unit;
366         }
367
368         float value_in_foot_lamberts () const;
369
370         void as_xml (xmlpp::Element* parent, std::string ns) const;
371
372         static std::string unit_to_string (Unit u);
373         static Unit string_to_unit (std::string u);
374
375 private:
376         float _value;
377         Unit _unit;
378 };
379
380
381 bool operator== (Luminance const& a, Luminance const& b);
382
383
384 class MainSoundConfiguration
385 {
386 public:
387         explicit MainSoundConfiguration(std::string);
388         MainSoundConfiguration (MCASoundField field_, int channels);
389
390         MCASoundField field () const {
391                 return _field;
392         }
393
394         int channels () const {
395                 return _channels.size();
396         }
397
398         boost::optional<Channel> mapping (int index) const;
399         void set_mapping (int index, Channel channel);
400
401         std::string to_string () const;
402
403 private:
404         MCASoundField _field;
405         std::vector<boost::optional<Channel>> _channels;
406 };
407
408
409 }
410
411
412 #endif