FFmpeg
hdr_dynamic_metadata.c
Go to the documentation of this file.
1 /**
2  * Copyright (c) 2018 Mohammad Izadi <moh.izadi at gmail.com>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg 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 GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "avassert.h"
22 #include "hdr_dynamic_metadata.h"
23 #include "mem.h"
24 #include "libavcodec/defs.h"
25 #include "libavcodec/get_bits.h"
26 #include "libavcodec/put_bits.h"
27 
28 static const int64_t luminance_den = 1;
29 static const int32_t peak_luminance_den = 15;
30 static const int64_t rgb_den = 100000;
31 static const int32_t fraction_pixel_den = 1000;
32 static const int32_t knee_point_den = 4095;
33 static const int32_t bezier_anchor_den = 1023;
34 static const int32_t saturation_weight_den = 8;
35 
37 {
38  AVDynamicHDRPlus *hdr_plus = av_mallocz(sizeof(AVDynamicHDRPlus));
39  if (!hdr_plus)
40  return NULL;
41 
42  if (size)
43  *size = sizeof(*hdr_plus);
44 
45  return hdr_plus;
46 }
47 
49 {
52  sizeof(AVDynamicHDRPlus));
53  if (!side_data)
54  return NULL;
55 
56  memset(side_data->data, 0, sizeof(AVDynamicHDRPlus));
57 
58  return (AVDynamicHDRPlus *)side_data->data;
59 }
60 
62  size_t size)
63 {
65  GetBitContext gbc, *gb = &gbc;
66  int ret;
67 
68  if (!s)
69  return AVERROR(ENOMEM);
70 
72  return AVERROR(EINVAL);
73 
74  memcpy(padded_buf, data, size);
75  // Zero-initialize the buffer padding to avoid overreads into uninitialized data.
76  memset(padded_buf + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
77 
78  ret = init_get_bits8(gb, padded_buf, size);
79  if (ret < 0)
80  return ret;
81 
82  if (get_bits_left(gb) < 10)
83  return AVERROR_INVALIDDATA;
84 
85  s->application_version = get_bits(gb, 8);
86  s->num_windows = get_bits(gb, 2);
87 
88  if (s->num_windows < 1 || s->num_windows > 3) {
89  return AVERROR_INVALIDDATA;
90  }
91 
92  if (get_bits_left(gb) < ((19 * 8 + 1) * (s->num_windows - 1)))
93  return AVERROR_INVALIDDATA;
94 
95  for (int w = 1; w < s->num_windows; w++) {
96  // The corners are set to absolute coordinates here. They should be
97  // converted to the relative coordinates (in [0, 1]) in the decoder.
98  AVHDRPlusColorTransformParams *params = &s->params[w];
100  (AVRational){get_bits(gb, 16), 1};
102  (AVRational){get_bits(gb, 16), 1};
104  (AVRational){get_bits(gb, 16), 1};
106  (AVRational){get_bits(gb, 16), 1};
107 
108  params->center_of_ellipse_x = get_bits(gb, 16);
109  params->center_of_ellipse_y = get_bits(gb, 16);
110  params->rotation_angle = get_bits(gb, 8);
111  params->semimajor_axis_internal_ellipse = get_bits(gb, 16);
112  params->semimajor_axis_external_ellipse = get_bits(gb, 16);
113  params->semiminor_axis_external_ellipse = get_bits(gb, 16);
114  params->overlap_process_option = get_bits1(gb);
115  }
116 
117  if (get_bits_left(gb) < 28)
118  return AVERROR_INVALIDDATA;
119 
120  s->targeted_system_display_maximum_luminance =
122  s->targeted_system_display_actual_peak_luminance_flag = get_bits1(gb);
123 
124  if (s->targeted_system_display_actual_peak_luminance_flag) {
125  int rows, cols;
126  if (get_bits_left(gb) < 10)
127  return AVERROR_INVALIDDATA;
128  rows = get_bits(gb, 5);
129  cols = get_bits(gb, 5);
130  if (((rows < 2) || (rows > 25)) || ((cols < 2) || (cols > 25))) {
131  return AVERROR_INVALIDDATA;
132  }
133  s->num_rows_targeted_system_display_actual_peak_luminance = rows;
134  s->num_cols_targeted_system_display_actual_peak_luminance = cols;
135 
136  if (get_bits_left(gb) < (rows * cols * 4))
137  return AVERROR_INVALIDDATA;
138 
139  for (int i = 0; i < rows; i++) {
140  for (int j = 0; j < cols; j++) {
141  s->targeted_system_display_actual_peak_luminance[i][j] =
143  }
144  }
145  }
146  for (int w = 0; w < s->num_windows; w++) {
147  AVHDRPlusColorTransformParams *params = &s->params[w];
148  if (get_bits_left(gb) < (3 * 17 + 17 + 4))
149  return AVERROR_INVALIDDATA;
150 
151  for (int i = 0; i < 3; i++) {
152  params->maxscl[i] =
153  (AVRational){get_bits(gb, 17), rgb_den};
154  }
155  params->average_maxrgb =
156  (AVRational){get_bits(gb, 17), rgb_den};
158 
159  if (get_bits_left(gb) <
161  return AVERROR_INVALIDDATA;
162 
163  for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {
164  params->distribution_maxrgb[i].percentage = get_bits(gb, 7);
165  params->distribution_maxrgb[i].percentile =
166  (AVRational){get_bits(gb, 17), rgb_den};
167  }
168 
169  if (get_bits_left(gb) < 10)
170  return AVERROR_INVALIDDATA;
171 
173  }
174  if (get_bits_left(gb) < 1)
175  return AVERROR_INVALIDDATA;
176  s->mastering_display_actual_peak_luminance_flag = get_bits1(gb);
177  if (s->mastering_display_actual_peak_luminance_flag) {
178  int rows, cols;
179  if (get_bits_left(gb) < 10)
180  return AVERROR_INVALIDDATA;
181  rows = get_bits(gb, 5);
182  cols = get_bits(gb, 5);
183  if (((rows < 2) || (rows > 25)) || ((cols < 2) || (cols > 25))) {
184  return AVERROR_INVALIDDATA;
185  }
186  s->num_rows_mastering_display_actual_peak_luminance = rows;
187  s->num_cols_mastering_display_actual_peak_luminance = cols;
188 
189  if (get_bits_left(gb) < (rows * cols * 4))
190  return AVERROR_INVALIDDATA;
191 
192  for (int i = 0; i < rows; i++) {
193  for (int j = 0; j < cols; j++) {
194  s->mastering_display_actual_peak_luminance[i][j] =
196  }
197  }
198  }
199 
200  for (int w = 0; w < s->num_windows; w++) {
201  AVHDRPlusColorTransformParams *params = &s->params[w];
202  if (get_bits_left(gb) < 1)
203  return AVERROR_INVALIDDATA;
204 
205  params->tone_mapping_flag = get_bits1(gb);
206  if (params->tone_mapping_flag) {
207  if (get_bits_left(gb) < 28)
208  return AVERROR_INVALIDDATA;
209 
210  params->knee_point_x =
211  (AVRational){get_bits(gb, 12), knee_point_den};
212  params->knee_point_y =
213  (AVRational){get_bits(gb, 12), knee_point_den};
214  params->num_bezier_curve_anchors = get_bits(gb, 4);
215 
216  if (get_bits_left(gb) < (params->num_bezier_curve_anchors * 10))
217  return AVERROR_INVALIDDATA;
218 
219  for (int i = 0; i < params->num_bezier_curve_anchors; i++) {
220  params->bezier_curve_anchors[i] =
222  }
223  }
224 
225  if (get_bits_left(gb) < 1)
226  return AVERROR_INVALIDDATA;
228  if (params->color_saturation_mapping_flag) {
229  if (get_bits_left(gb) < 6)
230  return AVERROR_INVALIDDATA;
231  params->color_saturation_weight =
233  }
234  }
235 
236  return 0;
237 }
238 
239 int av_dynamic_hdr_plus_to_t35(const AVDynamicHDRPlus *s, uint8_t **data, size_t *size)
240 {
241  uint8_t *buf;
242  size_t size_bits, size_bytes;
243  PutBitContext pbc, *pb = &pbc;
244 
245  if (!s)
246  return AVERROR(EINVAL);
247  if ((!data || *data) && !size)
248  return AVERROR(EINVAL);
249 
250  /**
251  * Buffer size per CTA-861-H p.253-254:
252  * 48 header bits (excluded from the serialized payload)
253  * 8 bits for application_mode
254  * 2 bits for num_windows
255  * 153 bits for window geometry, for each window above 1
256  * 27 bits for targeted_system_display_maximum_luminance
257  * 1-2511 bits for targeted system display peak luminance information
258  * 82-442 bits per window for pixel distribution information
259  * 1-2511 bits for mastering display peak luminance information
260  * 1-179 bits per window for tonemapping information
261  * 1-7 bits per window for color saturation mapping information
262  * Total: 123-7249 bits, excluding trimmed header bits
263  */
264  size_bits = 8;
265 
266  size_bits += 2;
267 
268  for (int w = 1; w < s->num_windows; w++)
269  size_bits += 153;
270 
271  size_bits += 27;
272 
273  size_bits += 1;
274  if (s->targeted_system_display_actual_peak_luminance_flag)
275  size_bits += 10 +
276  s->num_rows_targeted_system_display_actual_peak_luminance *
277  s->num_cols_targeted_system_display_actual_peak_luminance * 4;
278 
279  for (int w = 0; w < s->num_windows; w++)
280  size_bits += 72 + s->params[w].num_distribution_maxrgb_percentiles * 24 + 10;
281 
282  size_bits += 1;
283  if (s->mastering_display_actual_peak_luminance_flag)
284  size_bits += 10 +
285  s->num_rows_mastering_display_actual_peak_luminance *
286  s->num_cols_mastering_display_actual_peak_luminance * 4;
287 
288  for (int w = 0; w < s->num_windows; w++) {
289  size_bits += 1;
290  if (s->params[w].tone_mapping_flag)
291  size_bits += 28 + s->params[w].num_bezier_curve_anchors * 10;
292 
293  size_bits += 1;
294  if (s->params[w].color_saturation_mapping_flag)
295  size_bits += 6;
296  }
297 
298  size_bytes = (size_bits + 7) / 8;
299 
301 
302  if (!data) {
303  *size = size_bytes;
304  return 0;
305  } else if (*data) {
306  if (*size < size_bytes)
308  buf = *data;
309  } else {
310  buf = av_malloc(size_bytes);
311  if (!buf)
312  return AVERROR(ENOMEM);
313  }
314 
315  init_put_bits(pb, buf, size_bytes);
316 
317  // application_mode is set to Application Version 1
318  put_bits(pb, 8, 1);
319 
320  // Payload as per CTA-861-H p.253-254
321  put_bits(pb, 2, s->num_windows);
322 
323  for (int w = 1; w < s->num_windows; w++) {
324  put_bits(pb, 16, s->params[w].window_upper_left_corner_x.num / s->params[w].window_upper_left_corner_x.den);
325  put_bits(pb, 16, s->params[w].window_upper_left_corner_y.num / s->params[w].window_upper_left_corner_y.den);
326  put_bits(pb, 16, s->params[w].window_lower_right_corner_x.num / s->params[w].window_lower_right_corner_x.den);
327  put_bits(pb, 16, s->params[w].window_lower_right_corner_y.num / s->params[w].window_lower_right_corner_y.den);
328  put_bits(pb, 16, s->params[w].center_of_ellipse_x);
329  put_bits(pb, 16, s->params[w].center_of_ellipse_y);
330  put_bits(pb, 8, s->params[w].rotation_angle);
331  put_bits(pb, 16, s->params[w].semimajor_axis_internal_ellipse);
332  put_bits(pb, 16, s->params[w].semimajor_axis_external_ellipse);
333  put_bits(pb, 16, s->params[w].semiminor_axis_external_ellipse);
334  put_bits(pb, 1, s->params[w].overlap_process_option);
335  }
336 
337  put_bits(pb, 27, s->targeted_system_display_maximum_luminance.num * luminance_den /
338  s->targeted_system_display_maximum_luminance.den);
339  put_bits(pb, 1, s->targeted_system_display_actual_peak_luminance_flag);
340  if (s->targeted_system_display_actual_peak_luminance_flag) {
341  put_bits(pb, 5, s->num_rows_targeted_system_display_actual_peak_luminance);
342  put_bits(pb, 5, s->num_cols_targeted_system_display_actual_peak_luminance);
343  for (int i = 0; i < s->num_rows_targeted_system_display_actual_peak_luminance; i++) {
344  for (int j = 0; j < s->num_cols_targeted_system_display_actual_peak_luminance; j++)
345  put_bits(pb, 4, s->targeted_system_display_actual_peak_luminance[i][j].num * peak_luminance_den /
346  s->targeted_system_display_actual_peak_luminance[i][j].den);
347  }
348  }
349 
350  for (int w = 0; w < s->num_windows; w++) {
351  for (int i = 0; i < 3; i++)
352  put_bits(pb, 17, s->params[w].maxscl[i].num * rgb_den / s->params[w].maxscl[i].den);
353  put_bits(pb, 17, s->params[w].average_maxrgb.num * rgb_den / s->params[w].average_maxrgb.den);
354  put_bits(pb, 4, s->params[w].num_distribution_maxrgb_percentiles);
355  for (int i = 0; i < s->params[w].num_distribution_maxrgb_percentiles; i++) {
356  put_bits(pb, 7, s->params[w].distribution_maxrgb[i].percentage);
357  put_bits(pb, 17, s->params[w].distribution_maxrgb[i].percentile.num * rgb_den /
358  s->params[w].distribution_maxrgb[i].percentile.den);
359  }
360  put_bits(pb, 10, s->params[w].fraction_bright_pixels.num * fraction_pixel_den /
361  s->params[w].fraction_bright_pixels.den);
362  }
363 
364  put_bits(pb, 1, s->mastering_display_actual_peak_luminance_flag);
365  if (s->mastering_display_actual_peak_luminance_flag) {
366  put_bits(pb, 5, s->num_rows_mastering_display_actual_peak_luminance);
367  put_bits(pb, 5, s->num_cols_mastering_display_actual_peak_luminance);
368  for (int i = 0; i < s->num_rows_mastering_display_actual_peak_luminance; i++) {
369  for (int j = 0; j < s->num_cols_mastering_display_actual_peak_luminance; j++)
370  put_bits(pb, 4, s->mastering_display_actual_peak_luminance[i][j].num * peak_luminance_den /
371  s->mastering_display_actual_peak_luminance[i][j].den);
372  }
373  }
374 
375  for (int w = 0; w < s->num_windows; w++) {
376  put_bits(pb, 1, s->params[w].tone_mapping_flag);
377  if (s->params[w].tone_mapping_flag) {
378  put_bits(pb, 12, s->params[w].knee_point_x.num * knee_point_den / s->params[w].knee_point_x.den);
379  put_bits(pb, 12, s->params[w].knee_point_y.num * knee_point_den / s->params[w].knee_point_y.den);
380  put_bits(pb, 4, s->params[w].num_bezier_curve_anchors);
381  for (int i = 0; i < s->params[w].num_bezier_curve_anchors; i++)
382  put_bits(pb, 10, s->params[w].bezier_curve_anchors[i].num * bezier_anchor_den /
383  s->params[w].bezier_curve_anchors[i].den);
384  put_bits(pb, 1, s->params[w].color_saturation_mapping_flag);
385  if (s->params[w].color_saturation_mapping_flag)
386  put_bits(pb, 6, s->params[w].color_saturation_weight.num * saturation_weight_den /
387  s->params[w].color_saturation_weight.den);
388  }
389  }
390 
391  flush_put_bits(pb);
392 
393  *data = buf;
394  if (size)
395  *size = size_bytes;
396  return 0;
397 }
AVHDRPlusColorTransformParams::average_maxrgb
AVRational average_maxrgb
The average of linearized maxRGB values in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:164
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVHDRPlusColorTransformParams::rotation_angle
uint8_t rotation_angle
The clockwise rotation angle in degree of arc with respect to the positive direction of the x-axis of...
Definition: hdr_dynamic_metadata.h:118
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:795
AVHDRPlusPercentile::percentile
AVRational percentile
The linearized maxRGB value at a specific percentile in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:52
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
AVHDRPlusColorTransformParams::semimajor_axis_external_ellipse
uint16_t semimajor_axis_external_ellipse
The semi-major axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:134
AVHDRPlusColorTransformParams
Color transform parameters at a processing window in a dynamic metadata for SMPTE 2094-40.
Definition: hdr_dynamic_metadata.h:59
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
w
uint8_t w
Definition: llviddspenc.c:38
av_dynamic_hdr_plus_to_t35
int av_dynamic_hdr_plus_to_t35(const AVDynamicHDRPlus *s, uint8_t **data, size_t *size)
Serialize dynamic HDR10+ metadata to a user data registered ITU-T T.35 buffer, excluding the first 48...
Definition: hdr_dynamic_metadata.c:239
data
const char data[16]
Definition: mxf.c:148
AVHDRPlusColorTransformParams::tone_mapping_flag
uint8_t tone_mapping_flag
This flag indicates that the metadata for the tone mapping function in the processing window is prese...
Definition: hdr_dynamic_metadata.h:189
luminance_den
static const int64_t luminance_den
Copyright (c) 2018 Mohammad Izadi <moh.izadi at gmail.com>
Definition: hdr_dynamic_metadata.c:28
AVHDRPlusColorTransformParams::distribution_maxrgb
AVHDRPlusPercentile distribution_maxrgb[15]
The linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:176
AVHDRPlusColorTransformParams::knee_point_x
AVRational knee_point_x
The x coordinate of the separation point between the linear part and the curved part of the tone mapp...
Definition: hdr_dynamic_metadata.h:196
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
AVHDRPlusColorTransformParams::color_saturation_mapping_flag
uint8_t color_saturation_mapping_flag
This flag shall be equal to 0 in bitstreams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:222
AVHDRPlusColorTransformParams::center_of_ellipse_x
uint16_t center_of_ellipse_x
The x coordinate of the center position of the concentric internal and external ellipses of the ellip...
Definition: hdr_dynamic_metadata.h:102
GetBitContext
Definition: get_bits.h:108
AVERROR_BUFFER_TOO_SMALL
#define AVERROR_BUFFER_TOO_SMALL
Buffer too small.
Definition: error.h:53
AVHDRPlusColorTransformParams::knee_point_y
AVRational knee_point_y
The y coordinate of the separation point between the linear part and the curved part of the tone mapp...
Definition: hdr_dynamic_metadata.h:203
AVHDRPlusColorTransformParams::num_bezier_curve_anchors
uint8_t num_bezier_curve_anchors
The number of the intermediate anchor parameters of the tone mapping function in the processing windo...
Definition: hdr_dynamic_metadata.h:209
avassert.h
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVHDRPlusColorTransformParams::semiminor_axis_external_ellipse
uint16_t semiminor_axis_external_ellipse
The semi-minor axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:141
AVHDRPlusColorTransformParams::window_upper_left_corner_y
AVRational window_upper_left_corner_y
The relative y coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:76
AVHDRPlusColorTransformParams::window_lower_right_corner_x
AVRational window_lower_right_corner_x
The relative x coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:85
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
get_bits.h
PutBitContext
Definition: put_bits.h:50
AVHDRPlusPercentile::percentage
uint8_t percentage
The percentage value corresponding to a specific percentile linearized RGB value in the processing wi...
Definition: hdr_dynamic_metadata.h:45
if
if(ret)
Definition: filter_design.txt:179
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
AVHDRPlusColorTransformParams::fraction_bright_pixels
AVRational fraction_bright_pixels
The fraction of selected pixels in the image that contains the brightest pixel in the scene.
Definition: hdr_dynamic_metadata.h:183
AVHDRPlusColorTransformParams::color_saturation_weight
AVRational color_saturation_weight
The color saturation gain in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:229
size
int size
Definition: twinvq_data.h:10344
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
AVHDRPlusColorTransformParams::window_lower_right_corner_y
AVRational window_lower_right_corner_y
The relative y coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:94
AVHDRPlusColorTransformParams::window_upper_left_corner_x
AVRational window_upper_left_corner_x
The relative x coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:67
AVHDRPlusColorTransformParams::semimajor_axis_internal_ellipse
uint16_t semimajor_axis_internal_ellipse
The semi-major axis value of the internal ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:125
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
fraction_pixel_den
static const int32_t fraction_pixel_den
Definition: hdr_dynamic_metadata.c:31
AVHDRPlusColorTransformParams::overlap_process_option
enum AVHDRPlusOverlapProcessOption overlap_process_option
Overlap process option indicates one of the two methods of combining rendered pixels in the processin...
Definition: hdr_dynamic_metadata.h:149
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
av_dynamic_hdr_plus_create_side_data
AVDynamicHDRPlus * av_dynamic_hdr_plus_create_side_data(AVFrame *frame)
Allocate a complete AVDynamicHDRPlus and add it to the frame.
Definition: hdr_dynamic_metadata.c:48
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
knee_point_den
static const int32_t knee_point_den
Definition: hdr_dynamic_metadata.c:32
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:159
AV_HDR_PLUS_MAX_PAYLOAD_SIZE
#define AV_HDR_PLUS_MAX_PAYLOAD_SIZE
Definition: hdr_dynamic_metadata.h:356
defs.h
peak_luminance_den
static const int32_t peak_luminance_den
Definition: hdr_dynamic_metadata.c:29
AVHDRPlusColorTransformParams::num_distribution_maxrgb_percentiles
uint8_t num_distribution_maxrgb_percentiles
The number of linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:170
AVHDRPlusColorTransformParams::maxscl
AVRational maxscl[3]
The maximum of the color components of linearized RGB values in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:157
hdr_dynamic_metadata.h
AVHDRPlusColorTransformParams::center_of_ellipse_y
uint16_t center_of_ellipse_y
The y coordinate of the center position of the concentric internal and external ellipses of the ellip...
Definition: hdr_dynamic_metadata.h:110
mem.h
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
rgb_den
static const int64_t rgb_den
Definition: hdr_dynamic_metadata.c:30
av_dynamic_hdr_plus_alloc
AVDynamicHDRPlus * av_dynamic_hdr_plus_alloc(size_t *size)
Allocate an AVDynamicHDRPlus structure and set its fields to default values.
Definition: hdr_dynamic_metadata.c:36
av_dynamic_hdr_plus_from_t35
int av_dynamic_hdr_plus_from_t35(AVDynamicHDRPlus *s, const uint8_t *data, size_t size)
Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus).
Definition: hdr_dynamic_metadata.c:61
int32_t
int32_t
Definition: audioconvert.c:56
bezier_anchor_den
static const int32_t bezier_anchor_den
Definition: hdr_dynamic_metadata.c:33
saturation_weight_den
static const int32_t saturation_weight_den
Definition: hdr_dynamic_metadata.c:34
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
put_bits.h
AVHDRPlusColorTransformParams::bezier_curve_anchors
AVRational bezier_curve_anchors[15]
The intermediate anchor parameters of the tone mapping function in the processing window in the scene...
Definition: hdr_dynamic_metadata.h:216