41 *
size = hdr_plus ?
sizeof(*hdr_plus) : 0;
86 if (
s->num_windows < 1 ||
s->num_windows > 3) {
93 for (
int w = 1;
w <
s->num_windows;
w++) {
97 params->window_upper_left_corner_x =
99 params->window_upper_left_corner_y =
101 params->window_lower_right_corner_x =
103 params->window_lower_right_corner_y =
118 s->targeted_system_display_maximum_luminance =
120 s->targeted_system_display_actual_peak_luminance_flag =
get_bits1(gb);
122 if (
s->targeted_system_display_actual_peak_luminance_flag) {
128 if (((rows < 2) || (rows > 25)) || ((cols < 2) || (cols > 25))) {
131 s->num_rows_targeted_system_display_actual_peak_luminance = rows;
132 s->num_cols_targeted_system_display_actual_peak_luminance = cols;
137 for (
int i = 0;
i < rows;
i++) {
138 for (
int j = 0; j < cols; j++) {
139 s->targeted_system_display_actual_peak_luminance[
i][j] =
144 for (
int w = 0;
w <
s->num_windows;
w++) {
149 for (
int i = 0;
i < 3;
i++) {
158 (
params->num_distribution_maxrgb_percentiles * 24))
161 for (
int i = 0;
i <
params->num_distribution_maxrgb_percentiles;
i++) {
163 params->distribution_maxrgb[
i].percentile =
174 s->mastering_display_actual_peak_luminance_flag =
get_bits1(gb);
175 if (
s->mastering_display_actual_peak_luminance_flag) {
181 if (((rows < 2) || (rows > 25)) || ((cols < 2) || (cols > 25))) {
184 s->num_rows_mastering_display_actual_peak_luminance = rows;
185 s->num_cols_mastering_display_actual_peak_luminance = cols;
190 for (
int i = 0;
i < rows;
i++) {
191 for (
int j = 0; j < cols; j++) {
192 s->mastering_display_actual_peak_luminance[
i][j] =
198 for (
int w = 0;
w <
s->num_windows;
w++) {
204 if (
params->tone_mapping_flag) {
217 for (
int i = 0;
i <
params->num_bezier_curve_anchors;
i++) {
218 params->bezier_curve_anchors[
i] =
226 if (
params->color_saturation_mapping_flag) {
229 params->color_saturation_weight =
240 size_t size_bits, size_bytes;
251 for (
int w = 0;
w <
s->num_windows;
w++) {
254 if (p->num_distribution_maxrgb_percentiles >
259 if (p->tone_mapping_flag &&
260 p->num_bezier_curve_anchors >
267 if (
s->targeted_system_display_actual_peak_luminance_flag) {
268 if (
s->num_rows_targeted_system_display_actual_peak_luminance >
270 s->num_cols_targeted_system_display_actual_peak_luminance >
275 if (
s->mastering_display_actual_peak_luminance_flag) {
276 if (
s->num_rows_mastering_display_actual_peak_luminance >
278 s->num_cols_mastering_display_actual_peak_luminance >
301 for (
int w = 1;
w <
s->num_windows;
w++)
307 if (
s->targeted_system_display_actual_peak_luminance_flag)
309 s->num_rows_targeted_system_display_actual_peak_luminance *
310 s->num_cols_targeted_system_display_actual_peak_luminance * 4;
312 for (
int w = 0;
w <
s->num_windows;
w++)
313 size_bits += 72 +
s->params[
w].num_distribution_maxrgb_percentiles * 24 + 10;
316 if (
s->mastering_display_actual_peak_luminance_flag)
318 s->num_rows_mastering_display_actual_peak_luminance *
319 s->num_cols_mastering_display_actual_peak_luminance * 4;
321 for (
int w = 0;
w <
s->num_windows;
w++) {
323 if (
s->params[
w].tone_mapping_flag)
324 size_bits += 28 +
s->params[
w].num_bezier_curve_anchors * 10;
327 if (
s->params[
w].color_saturation_mapping_flag)
331 size_bytes = (size_bits + 7) / 8;
339 if (*
size < size_bytes)
356 for (
int w = 1;
w <
s->num_windows;
w++) {
357 put_bits(pb, 16,
s->params[
w].window_upper_left_corner_x.num /
s->params[
w].window_upper_left_corner_x.den);
358 put_bits(pb, 16,
s->params[
w].window_upper_left_corner_y.num /
s->params[
w].window_upper_left_corner_y.den);
359 put_bits(pb, 16,
s->params[
w].window_lower_right_corner_x.num /
s->params[
w].window_lower_right_corner_x.den);
360 put_bits(pb, 16,
s->params[
w].window_lower_right_corner_y.num /
s->params[
w].window_lower_right_corner_y.den);
361 put_bits(pb, 16,
s->params[
w].center_of_ellipse_x);
362 put_bits(pb, 16,
s->params[
w].center_of_ellipse_y);
364 put_bits(pb, 16,
s->params[
w].semimajor_axis_internal_ellipse);
365 put_bits(pb, 16,
s->params[
w].semimajor_axis_external_ellipse);
366 put_bits(pb, 16,
s->params[
w].semiminor_axis_external_ellipse);
367 put_bits(pb, 1,
s->params[
w].overlap_process_option);
371 s->targeted_system_display_maximum_luminance.den);
372 put_bits(pb, 1,
s->targeted_system_display_actual_peak_luminance_flag);
373 if (
s->targeted_system_display_actual_peak_luminance_flag) {
374 put_bits(pb, 5,
s->num_rows_targeted_system_display_actual_peak_luminance);
375 put_bits(pb, 5,
s->num_cols_targeted_system_display_actual_peak_luminance);
376 for (
int i = 0;
i <
s->num_rows_targeted_system_display_actual_peak_luminance;
i++) {
377 for (
int j = 0; j <
s->num_cols_targeted_system_display_actual_peak_luminance; j++)
379 s->targeted_system_display_actual_peak_luminance[
i][j].den);
383 for (
int w = 0;
w <
s->num_windows;
w++) {
384 for (
int i = 0;
i < 3;
i++)
386 put_bits(pb, 17,
s->params[
w].average_maxrgb.num *
rgb_den /
s->params[
w].average_maxrgb.den);
387 put_bits(pb, 4,
s->params[
w].num_distribution_maxrgb_percentiles);
388 for (
int i = 0;
i <
s->params[
w].num_distribution_maxrgb_percentiles;
i++) {
389 put_bits(pb, 7,
s->params[
w].distribution_maxrgb[
i].percentage);
391 s->params[
w].distribution_maxrgb[
i].percentile.den);
394 s->params[
w].fraction_bright_pixels.den);
397 put_bits(pb, 1,
s->mastering_display_actual_peak_luminance_flag);
398 if (
s->mastering_display_actual_peak_luminance_flag) {
399 put_bits(pb, 5,
s->num_rows_mastering_display_actual_peak_luminance);
400 put_bits(pb, 5,
s->num_cols_mastering_display_actual_peak_luminance);
401 for (
int i = 0;
i <
s->num_rows_mastering_display_actual_peak_luminance;
i++) {
402 for (
int j = 0; j <
s->num_cols_mastering_display_actual_peak_luminance; j++)
404 s->mastering_display_actual_peak_luminance[
i][j].den);
408 for (
int w = 0;
w <
s->num_windows;
w++) {
409 put_bits(pb, 1,
s->params[
w].tone_mapping_flag);
410 if (
s->params[
w].tone_mapping_flag) {
413 put_bits(pb, 4,
s->params[
w].num_bezier_curve_anchors);
414 for (
int i = 0;
i <
s->params[
w].num_bezier_curve_anchors;
i++)
416 s->params[
w].bezier_curve_anchors[
i].den);
418 put_bits(pb, 1,
s->params[
w].color_saturation_mapping_flag);
419 if (
s->params[
w].color_saturation_mapping_flag)
421 s->params[
w].color_saturation_weight.den);
437 *
size = smpte2094_app5 ?
sizeof(*smpte2094_app5) : 0;
439 return smpte2094_app5;
455#define GET_BITS_OR_FAIL(var, n) \
457 if (get_bits_left(gb) < n) { \
458 ret = AVERROR_INVALIDDATA; \
461 var = get_bits(gb, n); \
468 int ret, reserved_zero;
474 uint8_t *padded_data =
av_mallocz(padded_size);
500 if (
s->has_custom_hdr_reference_white_flag)
502 if (!
s->has_adaptive_tone_map_flag) {
510 if (
s->use_reference_white_tone_mapping_flag) {
516 if (
s->num_alternate_images > 4) {
523 if (
s->gain_application_space_chromaticities_flag == 3)
524 for (
int r = 0;
r < 8;
r++)
527 for (
int a = 0;
a <
s->num_alternate_images;
a++) {
531 if (!
a || !
s->has_common_component_mix_params_flag) {
533 if (
s->component_mixing_type[
a] != 3) {
540 for (
int k = 0; k < 6; k++)
542 for (
int k = 0; k < 6; k++) {
543 if (
s->has_component_mixing_coefficient_flag[
a][k]) {
546 s->component_mixing_coefficient[
a][k] = 0;
551 s->component_mixing_type[
a] =
s->component_mixing_type[0];
552 if (
s->component_mixing_type[
a] == 3) {
553 for (
int k = 0; k < 6; k++) {
554 s->has_component_mixing_coefficient_flag[
a][k] =
555 s->has_component_mixing_coefficient_flag[0][k];
556 s->component_mixing_coefficient[
a][k] =
s->component_mixing_coefficient[0][k];
562 if (!
a || !
s->has_common_curve_params_flag) {
564 if (
s->gain_curve_num_control_points_minus_1[
a] > 31) {
574 for (
int c = 0;
c <=
s->gain_curve_num_control_points_minus_1[
a];
c++) {
578 s->gain_curve_num_control_points_minus_1[
a] =
579 s->gain_curve_num_control_points_minus_1[0];
580 s->gain_curve_use_pchip_slope_flag[
a] =
s->gain_curve_use_pchip_slope_flag[0];
581 for (
int c = 0;
c <=
s->gain_curve_num_control_points_minus_1[
a];
c++) {
582 s->gain_curve_control_points_x[
a][
c] =
s->gain_curve_control_points_x[0][
c];
585 for (
int c = 0;
c <=
s->gain_curve_num_control_points_minus_1[
a];
c++)
587 if (!
s->gain_curve_use_pchip_slope_flag[
a]) {
588 for (
int c = 0;
c <=
s->gain_curve_num_control_points_minus_1[
a];
c++)
602 size_t size_bytes, size_bits;
610 if (
s->application_version >= 8 ||
s->minimum_application_version >= 3)
613 size_bits += 3 + 3 + 2;
614 size_bits += 1 + 1 + 6;
615 if (
s->has_custom_hdr_reference_white_flag)
617 if (
s->has_adaptive_tone_map_flag) {
619 if (
s->use_reference_white_tone_mapping_flag) {
622 size_bits += 3 + 2 + 1 + 1;
623 if (
s->gain_application_space_chromaticities_flag == 3)
625 if (
s->num_alternate_images > 4)
627 for (
int a = 0;
a <
s->num_alternate_images;
a++) {
629 if (!
a || !
s->has_common_component_mix_params_flag) {
631 if (
s->component_mixing_type[
a] != 3) {
635 for (
int k = 0; k < 6; k++)
636 if (
s->has_component_mixing_coefficient_flag[
a][k])
640 if (!
a || !
s->has_common_curve_params_flag) {
641 size_bits += 5 + 1 + 2;
642 if (
s->gain_curve_num_control_points_minus_1[
a] > 31)
644 size_bits += 16 * (
s->gain_curve_num_control_points_minus_1[
a] + 1);
646 size_bits += 16 * (
s->gain_curve_num_control_points_minus_1[
a] + 1);
647 if (!
s->gain_curve_use_pchip_slope_flag[
a])
648 size_bits += 16 * (
s->gain_curve_num_control_points_minus_1[
a] + 1);
654 size_bytes = size_bits >> 3;
660 if (*
size < size_bytes)
673 put_bits(pb, 3,
s->minimum_application_version);
677 put_bits(pb, 1,
s->has_custom_hdr_reference_white_flag);
678 put_bits(pb, 1,
s->has_adaptive_tone_map_flag);
681 if (
s->has_custom_hdr_reference_white_flag)
682 put_bits(pb, 16,
s->hdr_reference_white);
684 if (
s->has_adaptive_tone_map_flag) {
686 put_bits(pb, 16,
s->baseline_hdr_headroom);
687 put_bits(pb, 1,
s->use_reference_white_tone_mapping_flag);
688 if (
s->use_reference_white_tone_mapping_flag) {
691 put_bits(pb, 3,
s->num_alternate_images);
692 put_bits(pb, 2,
s->gain_application_space_chromaticities_flag);
693 put_bits(pb, 1,
s->has_common_component_mix_params_flag);
694 put_bits(pb, 1,
s->has_common_curve_params_flag);
696 if (
s->gain_application_space_chromaticities_flag == 3)
697 for (
int r = 0;
r < 8;
r++)
698 put_bits(pb, 16,
s->gain_application_space_chromaticities[
r]);
700 for (
int a = 0;
a <
s->num_alternate_images;
a++) {
701 put_bits(pb, 16,
s->alternate_hdr_headrooms[
a]);
704 if (!
a || !
s->has_common_component_mix_params_flag) {
706 if (
s->component_mixing_type[
a] != 3) {
709 for (
int k = 0; k < 6; k++)
710 put_bits(pb, 1,
s->has_component_mixing_coefficient_flag[
a][k]);
711 for (
int k = 0; k < 6; k++)
712 if (
s->has_component_mixing_coefficient_flag[
a][k])
713 put_bits(pb, 16,
s->component_mixing_coefficient[
a][k]);
718 if (!
a || !
s->has_common_curve_params_flag) {
719 put_bits(pb, 5,
s->gain_curve_num_control_points_minus_1[
a]);
720 put_bits(pb, 1,
s->gain_curve_use_pchip_slope_flag[
a]);
722 for (
int c = 0;
c <=
s->gain_curve_num_control_points_minus_1[
a];
c++)
723 put_bits(pb, 16,
s->gain_curve_control_points_x[
a][
c]);
725 for (
int c = 0;
c <=
s->gain_curve_num_control_points_minus_1[
a];
c++)
726 put_bits(pb, 16,
s->gain_curve_control_points_y[
a][
c]);
727 if (!
s->gain_curve_use_pchip_slope_flag[
a]) {
728 for (
int c = 0;
c <=
s->gain_curve_num_control_points_minus_1[
a];
c++)
729 put_bits(pb, 16,
s->gain_curve_control_points_theta[
a][
c]);
SwsAArch64OpImplParams params
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define i(width, name, range_min, range_max)
Misc types and constants that do not belong anywhere else.
bitstream reader API header.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static int get_bits_left(GetBitContext *gb)
static unsigned int get_bits1(GetBitContext *s)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
#define AVERROR_BUFFER_TOO_SMALL
Buffer too small.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
@ AV_FRAME_DATA_DYNAMIC_HDR_SMPTE_2094_APP5
HDR dynamic metadata associated with a video frame.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Memory handling functions.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
#define FF_ARRAY_ELEMS(a)
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
This struct represents dynamic metadata for color volume transform as specified in the SMPTE 2094-50 ...
Structure to hold side data for an AVFrame.
This structure describes decoded (raw) audio or video data.
Rational number (pair of numerator and denominator).