FFmpeg
dovi_rpuenc.c
Go to the documentation of this file.
1 /*
2  * Dolby Vision RPU encoder
3  *
4  * Copyright (C) 2024 Niklas Haas
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "libavutil/avassert.h"
24 #include "libavutil/crc.h"
25 #include "libavutil/mem.h"
26 
27 #include "avcodec.h"
28 #include "dovi_rpu.h"
29 #include "itut35.h"
30 #include "put_bits.h"
31 #include "put_golomb.h"
32 #include "refstruct.h"
33 
34 static struct {
35  uint64_t pps; // maximum pixels per second
36  int width; // maximum width
37  int main; // maximum bitrate in main tier
38  int high; // maximum bitrate in high tier
39 } dv_levels[] = {
40  [1] = {1280*720*24, 1280, 20, 50},
41  [2] = {1280*720*30, 1280, 20, 50},
42  [3] = {1920*1080*24, 1920, 20, 70},
43  [4] = {1920*1080*30, 2560, 20, 70},
44  [5] = {1920*1080*60, 3840, 20, 70},
45  [6] = {3840*2160*24, 3840, 25, 130},
46  [7] = {3840*2160*30, 3840, 25, 130},
47  [8] = {3840*2160*48, 3840, 40, 130},
48  [9] = {3840*2160*60, 3840, 40, 130},
49  [10] = {3840*2160*120, 3840, 60, 240},
50  [11] = {3840*2160*120, 7680, 60, 240},
51  [12] = {7680*4320*60, 7680, 120, 450},
52  [13] = {7680*4320*120u, 7680, 240, 800},
53 };
54 
56  const AVDOVIMetadata *metadata,
57  enum AVDOVICompression compression,
58  int strict_std_compliance)
59 {
61  const AVDOVIRpuDataHeader *hdr = NULL;
62  int dv_profile, dv_level, bl_compat_id = -1;
63  size_t cfg_size;
64  uint64_t pps;
65 
66  if (!s->enable)
67  goto skip;
68 
69  if (metadata)
70  hdr = av_dovi_get_header(metadata);
71 
72  if (s->enable == FF_DOVI_AUTOMATIC && !hdr)
73  goto skip;
74 
75  if (compression == AV_DOVI_COMPRESSION_RESERVED ||
76  compression > AV_DOVI_COMPRESSION_EXTENDED)
77  return AVERROR(EINVAL);
78 
79  switch (codecpar->codec_id) {
80  case AV_CODEC_ID_AV1: dv_profile = 10; break;
81  case AV_CODEC_ID_H264: dv_profile = 9; break;
82  case AV_CODEC_ID_HEVC:
83  if (hdr) {
84  dv_profile = ff_dovi_guess_profile_hevc(hdr);
85  break;
86  }
87 
88  /* This is likely to be proprietary IPTPQc2 */
89  if (codecpar->color_space == AVCOL_SPC_IPT_C2 ||
90  (codecpar->color_space == AVCOL_SPC_UNSPECIFIED &&
91  codecpar->color_trc == AVCOL_TRC_UNSPECIFIED))
92  dv_profile = 5;
93  else
94  dv_profile = 8;
95  break;
96  default:
97  /* No other encoder should be calling this! */
98  av_assert0(0);
99  return AVERROR_BUG;
100  }
101 
102  if (strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
103  if (dv_profile == 9) {
104  if (codecpar->format != AV_PIX_FMT_YUV420P)
105  dv_profile = 0;
106  } else {
107  if (codecpar->format != AV_PIX_FMT_YUV420P10)
108  dv_profile = 0;
109  }
110  }
111 
112  switch (dv_profile) {
113  case 4: /* HEVC with enhancement layer */
114  case 7:
115  if (s->enable > 0) {
116  av_log(s->logctx, AV_LOG_ERROR, "Coding of Dolby Vision enhancement "
117  "layers is currently unsupported.");
118  return AVERROR_PATCHWELCOME;
119  } else {
120  goto skip;
121  }
122  case 5: /* HEVC with proprietary IPTPQc2 */
123  bl_compat_id = 0;
124  break;
125  case 10:
126  /* FIXME: check for proper H.273 tags once those are added */
127  if (hdr && hdr->bl_video_full_range_flag) {
128  /* AV1 with proprietary IPTPQc2 */
129  bl_compat_id = 0;
130  break;
131  }
132  /* fall through */
133  case 8: /* HEVC (or AV1) with BL compatibility */
134  if (codecpar->color_space == AVCOL_SPC_BT2020_NCL &&
135  codecpar->color_primaries == AVCOL_PRI_BT2020 &&
136  codecpar->color_trc == AVCOL_TRC_SMPTE2084) {
137  bl_compat_id = 1;
138  } else if (codecpar->color_space == AVCOL_SPC_BT2020_NCL &&
139  codecpar->color_primaries == AVCOL_PRI_BT2020 &&
140  codecpar->color_trc == AVCOL_TRC_ARIB_STD_B67) {
141  bl_compat_id = 4;
142  } else if (codecpar->color_space == AVCOL_SPC_BT709 &&
143  codecpar->color_primaries == AVCOL_PRI_BT709 &&
144  codecpar->color_trc == AVCOL_TRC_BT709) {
145  bl_compat_id = 2;
146  }
147  }
148 
149  if (!dv_profile || bl_compat_id < 0) {
150  if (s->enable > 0) {
151  av_log(s->logctx, AV_LOG_ERROR, "Dolby Vision enabled, but could "
152  "not determine profile and compatibility mode. Double-check "
153  "colorspace and format settings for compatibility?\n");
154  return AVERROR(EINVAL);
155  }
156  goto skip;
157  }
158 
159  if (compression != AV_DOVI_COMPRESSION_NONE) {
160  if (dv_profile < 8 && strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
161  av_log(s->logctx, AV_LOG_ERROR, "Dolby Vision metadata compression "
162  "is not permitted for profiles 7 and earlier. (dv_profile: %d, "
163  "compression: %d)\n", dv_profile, compression);
164  return AVERROR(EINVAL);
165  } else if (compression == AV_DOVI_COMPRESSION_EXTENDED &&
166  strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
167  av_log(s->logctx, AV_LOG_ERROR, "Dolby Vision extended metadata "
168  "compression is experimental and not supported by "
169  "devices.");
170  return AVERROR(EINVAL);
171  } else if (dv_profile == 8) {
172  av_log(s->logctx, AV_LOG_WARNING, "Dolby Vision metadata compression "
173  "for profile 8 is known to be unsupported by many devices, "
174  "use with caution.\n");
175  }
176  }
177 
178  pps = codecpar->width * codecpar->height;
179  if (codecpar->framerate.num) {
180  pps = pps * codecpar->framerate.num / codecpar->framerate.den;
181  } else {
182  pps *= 25; /* sanity fallback */
183  }
184 
185  dv_level = 0;
186  for (int i = 1; i < FF_ARRAY_ELEMS(dv_levels); i++) {
187  if (pps > dv_levels[i].pps)
188  continue;
189  if (codecpar->width > dv_levels[i].width)
190  continue;
191  /* In theory, we should also test the bitrate when known, and
192  * distinguish between main and high tier. In practice, just ignore
193  * the bitrate constraints and hope they work out. This would ideally
194  * be handled by either the encoder or muxer directly. */
195  dv_level = i;
196  break;
197  }
198 
199  if (!dv_level) {
200  if (strict_std_compliance >= FF_COMPLIANCE_STRICT) {
201  av_log(s->logctx, AV_LOG_ERROR, "Coded PPS (%"PRIu64") and width (%d) "
202  "exceed Dolby Vision limitations\n", pps, codecpar->width);
203  return AVERROR(EINVAL);
204  } else {
205  av_log(s->logctx, AV_LOG_WARNING, "Coded PPS (%"PRIu64") and width (%d) "
206  "exceed Dolby Vision limitations. Ignoring, resulting file "
207  "may be non-conforming.\n", pps, codecpar->width);
208  dv_level = FF_ARRAY_ELEMS(dv_levels) - 1;
209  }
210  }
211 
212  cfg = av_dovi_alloc(&cfg_size);
213  if (!cfg)
214  return AVERROR(ENOMEM);
215 
217  &codecpar->nb_coded_side_data,
218  AV_PKT_DATA_DOVI_CONF, cfg, cfg_size, 0)) {
219  av_free(cfg);
220  return AVERROR(ENOMEM);
221  }
222 
223  cfg->dv_version_major = 1;
224  cfg->dv_version_minor = 0;
225  cfg->dv_profile = dv_profile;
226  cfg->dv_level = dv_level;
227  cfg->rpu_present_flag = 1;
228  cfg->el_present_flag = 0;
229  cfg->bl_present_flag = 1;
230  cfg->dv_bl_signal_compatibility_id = bl_compat_id;
231  cfg->dv_md_compression = compression;
232 
233  s->cfg = *cfg;
234  return 0;
235 
236 skip:
237  s->cfg = (AVDOVIDecoderConfigurationRecord) {0};
238  return 0;
239 }
240 
242 {
243  int ret;
244  const AVFrameSideData *sd;
245  const AVDOVIMetadata *metadata = NULL;
247  if (!codecpar)
248  return AVERROR(ENOMEM);
249 
250  ret = avcodec_parameters_from_context(codecpar, avctx);
251  if (ret < 0)
252  goto fail;
253 
255  avctx->nb_decoded_side_data,
257  if (sd)
258  metadata = (const AVDOVIMetadata *) sd->data;
259 
260  /* Current encoders cannot handle metadata compression during encoding */
261  ret = ff_dovi_configure_ext(s, codecpar, metadata, AV_DOVI_COMPRESSION_NONE,
262  avctx->strict_std_compliance);
263  if (ret < 0)
264  goto fail;
265 
266  ret = avcodec_parameters_to_context(avctx, codecpar);
267 
268 fail:
269  avcodec_parameters_free(&codecpar);
270  return ret;
271 }
272 
273 /* Compares only the static DM metadata parts of AVDOVIColorMetadata (excluding
274  * dm_metadata_id and scene_refresh_flag) */
275 static int cmp_dm_level0(const AVDOVIColorMetadata *dm1,
276  const AVDOVIColorMetadata *dm2)
277 {
278  int ret;
279  for (int i = 0; i < FF_ARRAY_ELEMS(dm1->ycc_to_rgb_matrix); i++) {
280  if ((ret = av_cmp_q(dm1->ycc_to_rgb_matrix[i], dm2->ycc_to_rgb_matrix[i])))
281  return ret;
282  }
283 
284  for (int i = 0; i < FF_ARRAY_ELEMS(dm1->ycc_to_rgb_offset); i++) {
285  if ((ret = av_cmp_q(dm1->ycc_to_rgb_offset[i], dm2->ycc_to_rgb_offset[i])))
286  return ret;
287  }
288 
289  for (int i = 0; i < FF_ARRAY_ELEMS(dm1->rgb_to_lms_matrix); i++) {
290  if ((ret = av_cmp_q(dm1->rgb_to_lms_matrix[i], dm2->rgb_to_lms_matrix[i])))
291  return ret;
292  }
293 
294  return memcmp(&dm1->signal_eotf, &dm2->signal_eotf,
295  sizeof(AVDOVIColorMetadata) -offsetof(AVDOVIColorMetadata, signal_eotf));
296 }
297 
298 /* Tries to re-use the static ext blocks. May reorder `ext->dm_static` */
299 static int try_reuse_ext(DOVIExt *ext, const AVDOVIMetadata *metadata)
300 {
301  int i, j, idx = 0;
302 
303  for (i = 0; i < metadata->num_ext_blocks; i++) {
304  const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
306  continue;
307 
308  /* Find the first matching ext block and move it to [idx] */
309  for (j = idx; j < ext->num_static; j++) {
310  if (!memcmp(&ext->dm_static[j], dm, sizeof(*dm))) {
311  if (j != idx)
312  FFSWAP(AVDOVIDmData, ext->dm_static[j], ext->dm_static[idx]);
313  idx++;
314  break;
315  }
316  }
317 
318  if (j == ext->num_static) {
319  /* Found no matching ext block */
320  return 0;
321  }
322  }
323 
324  /* If idx is less than ext->num_static, then there are extra unmatched
325  * ext blocks inside ext->dm_static */
326  return idx == ext->num_static;
327 }
328 
329 static inline void put_ue_coef(PutBitContext *pb, const AVDOVIRpuDataHeader *hdr,
330  uint64_t coef)
331 {
332  union { uint32_t u32; float f32; } fpart;
333 
334  switch (hdr->coef_data_type) {
335  case RPU_COEFF_FIXED:
336  set_ue_golomb(pb, coef >> hdr->coef_log2_denom);
337  put_bits64(pb, hdr->coef_log2_denom,
338  coef & ((1LL << hdr->coef_log2_denom) - 1));
339  break;
340  case RPU_COEFF_FLOAT:
341  fpart.f32 = coef / (float) (1LL << hdr->coef_log2_denom);
342  put_bits64(pb, hdr->coef_log2_denom, fpart.u32);
343  break;
344  }
345 }
346 
347 static inline void put_se_coef(PutBitContext *pb, const AVDOVIRpuDataHeader *hdr,
348  uint64_t coef)
349 {
350  union { uint32_t u32; float f32; } fpart;
351 
352  switch (hdr->coef_data_type) {
353  case RPU_COEFF_FIXED:
354  set_se_golomb(pb, coef >> hdr->coef_log2_denom);
355  put_bits64(pb, hdr->coef_log2_denom,
356  coef & ((1LL << hdr->coef_log2_denom) - 1));
357  break;
358  case RPU_COEFF_FLOAT:
359  fpart.f32 = coef / (float) (1LL << hdr->coef_log2_denom);
360  put_bits64(pb, hdr->coef_log2_denom, fpart.u32);
361  break;
362  }
363 }
364 
365 static int av_q2den(AVRational q, int den)
366 {
367  if (!q.den || q.den == den)
368  return q.num;
369  q = av_mul_q(q, av_make_q(den, 1));
370  return (q.num + (q.den >> 1)) / q.den;
371 }
372 
373 static void generate_ext_v1(PutBitContext *pb, const AVDOVIDmData *dm)
374 {
375  int ext_block_length, start_pos, pad_bits;
376 
377  switch (dm->level) {
378  case 1: ext_block_length = 5; break;
379  case 2: ext_block_length = 11; break;
380  case 4: ext_block_length = 3; break;
381  case 5: ext_block_length = 7; break;
382  case 6: ext_block_length = 8; break;
383  case 255: ext_block_length = 6; break;
384  default: return;
385  }
386 
387  set_ue_golomb(pb, ext_block_length);
388  put_bits(pb, 8, dm->level);
389  start_pos = put_bits_count(pb);
390 
391  switch (dm->level) {
392  case 1:
393  put_bits(pb, 12, dm->l1.min_pq);
394  put_bits(pb, 12, dm->l1.max_pq);
395  put_bits(pb, 12, dm->l1.avg_pq);
396  break;
397  case 2:
398  put_bits(pb, 12, dm->l2.target_max_pq);
399  put_bits(pb, 12, dm->l2.trim_slope);
400  put_bits(pb, 12, dm->l2.trim_offset);
401  put_bits(pb, 12, dm->l2.trim_power);
402  put_bits(pb, 12, dm->l2.trim_chroma_weight);
403  put_bits(pb, 12, dm->l2.trim_saturation_gain);
404  put_sbits(pb, 13, dm->l2.ms_weight);
405  break;
406  case 4:
407  put_bits(pb, 12, dm->l4.anchor_pq);
408  put_bits(pb, 12, dm->l4.anchor_power);
409  break;
410  case 5:
411  put_bits(pb, 13, dm->l5.left_offset);
412  put_bits(pb, 13, dm->l5.right_offset);
413  put_bits(pb, 13, dm->l5.top_offset);
414  put_bits(pb, 13, dm->l5.bottom_offset);
415  break;
416  case 6:
417  put_bits(pb, 16, dm->l6.max_luminance);
418  put_bits(pb, 16, dm->l6.min_luminance);
419  put_bits(pb, 16, dm->l6.max_cll);
420  put_bits(pb, 16, dm->l6.max_fall);
421  break;
422  case 255:
423  put_bits(pb, 8, dm->l255.dm_run_mode);
424  put_bits(pb, 8, dm->l255.dm_run_version);
425  for (int i = 0; i < 4; i++)
426  put_bits(pb, 8, dm->l255.dm_debug[i]);
427  break;
428  }
429 
430  pad_bits = ext_block_length * 8 - (put_bits_count(pb) - start_pos);
431  av_assert1(pad_bits >= 0);
432  put_bits(pb, pad_bits, 0);
433 }
434 
435 static void put_cie_xy(PutBitContext *pb, AVCIExy xy)
436 {
437  const int denom = 32767;
438  put_sbits(pb, 16, av_q2den(xy.x, denom));
439  put_sbits(pb, 16, av_q2den(xy.y, denom));
440 }
441 
442 #define ANY6(arr) (arr[0] || arr[1] || arr[2] || arr[3] || arr[4] || arr[5])
443 #define ANY_XY(xy) (xy.x.num || xy.y.num)
444 #define ANY_CSP(csp) (ANY_XY(csp.prim.r) || ANY_XY(csp.prim.g) || \
445  ANY_XY(csp.prim.b) || ANY_XY(csp.wp))
446 
447 static void generate_ext_v2(PutBitContext *pb, const AVDOVIDmData *dm)
448 {
449  int ext_block_length, start_pos, pad_bits;
450 
451  switch (dm->level) {
452  case 3: ext_block_length = 5; break;
453  case 8:
454  if (ANY6(dm->l8.hue_vector_field)) {
455  ext_block_length = 25;
456  } else if (ANY6(dm->l8.saturation_vector_field)) {
457  ext_block_length = 19;
458  } else if (dm->l8.clip_trim) {
459  ext_block_length = 13;
460  } else if (dm->l8.target_mid_contrast) {
461  ext_block_length = 12;
462  } else {
463  ext_block_length = 10;
464  }
465  break;
466  case 9:
468  ext_block_length = 17;
469  } else {
470  ext_block_length = 1;
471  }
472  break;
473  case 10:
475  ext_block_length = 21;
476  } else {
477  ext_block_length = 5;
478  }
479  break;
480  case 11: ext_block_length = 4; break;
481  case 254: ext_block_length = 2; break;
482  default: return;
483  }
484 
485  set_ue_golomb(pb, ext_block_length);
486  put_bits(pb, 8, dm->level);
487  start_pos = put_bits_count(pb);
488 
489  switch (dm->level) {
490  case 3:
491  put_bits(pb, 12, dm->l3.min_pq_offset);
492  put_bits(pb, 12, dm->l3.max_pq_offset);
493  put_bits(pb, 12, dm->l3.avg_pq_offset);
494  break;
495  case 8:
496  put_bits(pb, 8, dm->l8.target_display_index);
497  put_bits(pb, 12, dm->l8.trim_slope);
498  put_bits(pb, 12, dm->l8.trim_offset);
499  put_bits(pb, 12, dm->l8.trim_power);
500  put_bits(pb, 12, dm->l8.trim_chroma_weight);
501  put_bits(pb, 12, dm->l8.trim_saturation_gain);
502  put_bits(pb, 12, dm->l8.ms_weight);
503  if (ext_block_length < 12)
504  break;
505  put_bits(pb, 12, dm->l8.target_mid_contrast);
506  if (ext_block_length < 13)
507  break;
508  put_bits(pb, 12, dm->l8.clip_trim);
509  if (ext_block_length < 19)
510  break;
511  for (int i = 0; i < 6; i++)
512  put_bits(pb, 8, dm->l8.saturation_vector_field[i]);
513  if (ext_block_length < 25)
514  break;
515  for (int i = 0; i < 6; i++)
516  put_bits(pb, 8, dm->l8.hue_vector_field[i]);
517  break;
518  case 9:
519  put_bits(pb, 8, dm->l9.source_primary_index);
520  if (ext_block_length < 17)
521  break;
526  break;
527  case 10:
528  put_bits(pb, 8, dm->l10.target_display_index);
529  put_bits(pb, 12, dm->l10.target_max_pq);
530  put_bits(pb, 12, dm->l10.target_min_pq);
531  put_bits(pb, 8, dm->l10.target_primary_index);
532  if (ext_block_length < 21)
533  break;
538  break;
539  case 11:
540  put_bits(pb, 8, dm->l11.content_type);
541  put_bits(pb, 4, dm->l11.whitepoint);
542  put_bits(pb, 1, dm->l11.reference_mode_flag);
543  put_bits(pb, 3, 0); /* reserved */
544  put_bits(pb, 2, dm->l11.sharpness);
545  put_bits(pb, 2, dm->l11.noise_reduction);
546  put_bits(pb, 2, dm->l11.mpeg_noise_reduction);
547  put_bits(pb, 2, dm->l11.frame_rate_conversion);
548  put_bits(pb, 2, dm->l11.brightness);
549  put_bits(pb, 2, dm->l11.color);
550  break;
551  case 254:
552  put_bits(pb, 8, dm->l254.dm_mode);
553  put_bits(pb, 8, dm->l254.dm_version_index);
554  break;
555  }
556 
557  pad_bits = ext_block_length * 8 - (put_bits_count(pb) - start_pos);
558  av_assert1(pad_bits >= 0);
559  put_bits(pb, pad_bits, 0);
560 }
561 
563  int flags, uint8_t **out_rpu, int *out_size)
564 {
565  PutBitContext *pb = &(PutBitContext){0};
566  const AVDOVIRpuDataHeader *hdr;
567  const AVDOVIDataMapping *mapping;
568  const AVDOVIColorMetadata *color;
569  int vdr_dm_metadata_present, vdr_rpu_id, use_prev_vdr_rpu, profile,
570  buffer_size, rpu_size, pad, zero_run, dm_compression;
571  int num_ext_blocks_v1, num_ext_blocks_v2;
572  int dv_md_compression = s->cfg.dv_md_compression;
573  uint32_t crc;
574  uint8_t *dst;
575  if (!metadata) {
576  *out_rpu = NULL;
577  *out_size = 0;
578  return 0;
579  }
580 
581  hdr = av_dovi_get_header(metadata);
582  mapping = av_dovi_get_mapping(metadata);
583  color = av_dovi_get_color(metadata);
584  av_assert0(s->cfg.dv_profile);
585 
586  if (!(flags & FF_DOVI_COMPRESS_RPU))
587  dv_md_compression = AV_DOVI_COMPRESSION_NONE;
588  else if (dv_md_compression == AV_DOVI_COMPRESSION_RESERVED)
589  return AVERROR(EINVAL);
590 
591  if (hdr->rpu_type != 2) {
592  av_log(s->logctx, AV_LOG_ERROR, "Unhandled RPU type %"PRIu8"\n",
593  hdr->rpu_type);
594  return AVERROR_INVALIDDATA;
595  }
596 
597  if (!(flags & FF_DOVI_COMPRESS_RPU))
598  dv_md_compression = AV_DOVI_COMPRESSION_NONE;
599 
600  vdr_rpu_id = mapping->vdr_rpu_id;
601  use_prev_vdr_rpu = 0;
602 
603  if (!s->vdr[vdr_rpu_id]) {
604  s->vdr[vdr_rpu_id] = ff_refstruct_allocz(sizeof(AVDOVIDataMapping));
605  if (!s->vdr[vdr_rpu_id])
606  return AVERROR(ENOMEM);
607  }
608 
609  switch (dv_md_compression) {
611  /* Limited metadata compression requires vdr_rpi_id == 0 */
612  if (vdr_rpu_id != 0)
613  break;
614  /* fall through */
616  if (s->vdr[vdr_rpu_id])
617  use_prev_vdr_rpu = !memcmp(s->vdr[vdr_rpu_id], mapping, sizeof(*mapping));
618  break;
620  return AVERROR(EINVAL);
621  }
622 
623  if (s->cfg.dv_md_compression != AV_DOVI_COMPRESSION_EXTENDED) {
624  /* Flush VDRs to avoid leaking old state; maintaining multiple VDR
625  * references requires extended compression */
626  for (int i = 0; i <= DOVI_MAX_DM_ID; i++) {
627  if (i != vdr_rpu_id)
628  ff_refstruct_unref(&s->vdr[i]);
629  }
630  }
631 
632  if (metadata->num_ext_blocks && !s->ext_blocks) {
633  s->ext_blocks = ff_refstruct_allocz(sizeof(*s->ext_blocks));
634  if (!s->ext_blocks)
635  return AVERROR(ENOMEM);
636  }
637 
638  vdr_dm_metadata_present = memcmp(color, &ff_dovi_color_default, sizeof(*color));
639  if (metadata->num_ext_blocks)
640  vdr_dm_metadata_present = 1;
641 
642  if (vdr_dm_metadata_present && !s->dm) {
644  if (!s->dm)
645  return AVERROR(ENOMEM);
646  }
647 
648  dm_compression = 0;
649  if (dv_md_compression != AV_DOVI_COMPRESSION_NONE) {
650  if (!cmp_dm_level0(s->dm, color) && try_reuse_ext(s->ext_blocks, metadata))
651  dm_compression = 1;
652  }
653 
654  num_ext_blocks_v1 = num_ext_blocks_v2 = 0;
655  for (int i = 0; i < metadata->num_ext_blocks; i++) {
656  const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
657  if (dm_compression && ff_dovi_rpu_extension_is_static(dm->level))
658  continue;
659 
660  switch (dm->level) {
661  case 1:
662  case 2:
663  case 4:
664  case 5:
665  case 6:
666  case 255:
667  num_ext_blocks_v1++;
668  break;
669  case 3:
670  case 8:
671  case 9:
672  case 10:
673  case 11:
674  case 254:
675  num_ext_blocks_v2++;
676  break;
677  default:
678  av_log(s->logctx, AV_LOG_ERROR, "Invalid ext block level %d\n",
679  dm->level);
680  return AVERROR_INVALIDDATA;
681  }
682  }
683 
684  buffer_size = 12 /* vdr seq info */ + 5 /* CRC32 + terminator */;
685  buffer_size += num_ext_blocks_v1 * 13;
686  buffer_size += num_ext_blocks_v2 * 28;
687  if (!use_prev_vdr_rpu) {
688  buffer_size += 160;
689  for (int c = 0; c < 3; c++) {
690  for (int i = 0; i < mapping->curves[c].num_pivots - 1; i++) {
691  switch (mapping->curves[c].mapping_idc[i]) {
692  case AV_DOVI_MAPPING_POLYNOMIAL: buffer_size += 26; break;
693  case AV_DOVI_MAPPING_MMR: buffer_size += 177; break;
694  }
695  }
696  }
697  }
698  if (vdr_dm_metadata_present)
699  buffer_size += 67;
700 
701  av_fast_padded_malloc(&s->rpu_buf, &s->rpu_buf_sz, buffer_size);
702  if (!s->rpu_buf)
703  return AVERROR(ENOMEM);
704  init_put_bits(pb, s->rpu_buf, s->rpu_buf_sz);
705 
706  /* RPU header */
707  put_bits(pb, 6, hdr->rpu_type);
708  put_bits(pb, 11, hdr->rpu_format);
709  put_bits(pb, 4, hdr->vdr_rpu_profile);
710  put_bits(pb, 4, hdr->vdr_rpu_level);
711  put_bits(pb, 1, 1); /* vdr_seq_info_present */
713  put_bits(pb, 2, hdr->coef_data_type);
714  if (hdr->coef_data_type == RPU_COEFF_FIXED)
715  set_ue_golomb(pb, hdr->coef_log2_denom);
716  put_bits(pb, 2, hdr->vdr_rpu_normalized_idc);
717  put_bits(pb, 1, hdr->bl_video_full_range_flag);
718  if ((hdr->rpu_format & 0x700) == 0) {
719  int ext_mapping_idc = (hdr->ext_mapping_idc_5_7 << 5) | hdr->ext_mapping_idc_0_4;
720  set_ue_golomb(pb, hdr->bl_bit_depth - 8);
721  set_ue_golomb(pb, (ext_mapping_idc << 8) | (hdr->el_bit_depth - 8));
722  set_ue_golomb(pb, hdr->vdr_bit_depth - 8);
724  put_bits(pb, 3, dm_compression);
726  put_bits(pb, 1, hdr->disable_residual_flag);
727  }
728  s->header = *hdr;
729 
730  put_bits(pb, 1, vdr_dm_metadata_present);
731  put_bits(pb, 1, use_prev_vdr_rpu);
732  set_ue_golomb(pb, vdr_rpu_id);
733  s->mapping = s->vdr[vdr_rpu_id];
734 
735  profile = s->cfg.dv_profile ? s->cfg.dv_profile : ff_dovi_guess_profile_hevc(hdr);
736 
737  if (!use_prev_vdr_rpu) {
738  set_ue_golomb(pb, mapping->mapping_color_space);
740  for (int c = 0; c < 3; c++) {
741  const AVDOVIReshapingCurve *curve = &mapping->curves[c];
742  int prev = 0;
743  set_ue_golomb(pb, curve->num_pivots - 2);
744  for (int i = 0; i < curve->num_pivots; i++) {
745  put_bits(pb, hdr->bl_bit_depth, curve->pivots[i] - prev);
746  prev = curve->pivots[i];
747  }
748  }
749 
750  if (mapping->nlq_method_idc != AV_DOVI_NLQ_NONE) {
751  put_bits(pb, 3, mapping->nlq_method_idc);
752  put_bits(pb, hdr->bl_bit_depth, mapping->nlq_pivots[0]);
753  put_bits(pb, hdr->bl_bit_depth, mapping->nlq_pivots[1] - mapping->nlq_pivots[0]);
754  }
755 
756  set_ue_golomb(pb, mapping->num_x_partitions - 1);
757  set_ue_golomb(pb, mapping->num_y_partitions - 1);
758 
759  for (int c = 0; c < 3; c++) {
760  const AVDOVIReshapingCurve *curve = &mapping->curves[c];
761  for (int i = 0; i < curve->num_pivots - 1; i++) {
762  set_ue_golomb(pb, curve->mapping_idc[i]);
763  switch (curve->mapping_idc[i]) {
765  set_ue_golomb(pb, curve->poly_order[i] - 1);
766  if (curve->poly_order[i] == 1)
767  put_bits(pb, 1, 0); /* linear_interp_flag */
768  for (int k = 0; k <= curve->poly_order[i]; k++)
769  put_se_coef(pb, hdr, curve->poly_coef[i][k]);
770  break;
771  }
772  case AV_DOVI_MAPPING_MMR: {
773  put_bits(pb, 2, curve->mmr_order[i] - 1);
774  put_se_coef(pb, hdr, curve->mmr_constant[i]);
775  for (int j = 0; j < curve->mmr_order[i]; j++) {
776  for (int k = 0; k < 7; k++)
777  put_se_coef(pb, hdr, curve->mmr_coef[i][j][k]);
778  }
779  break;
780  }
781  }
782  }
783  }
784 
785  if (mapping->nlq_method_idc != AV_DOVI_NLQ_NONE) {
786  for (int c = 0; c < 3; c++) {
787  const AVDOVINLQParams *nlq = &mapping->nlq[c];
788  put_bits(pb, hdr->el_bit_depth, nlq->nlq_offset);
789  put_ue_coef(pb, hdr, nlq->vdr_in_max);
790  switch (mapping->nlq_method_idc) {
792  put_ue_coef(pb, hdr, nlq->linear_deadzone_slope);
793  put_ue_coef(pb, hdr, nlq->linear_deadzone_threshold);
794  break;
795  }
796  }
797  }
798 
799  memcpy(s->vdr[vdr_rpu_id], mapping, sizeof(*mapping));
800  }
801 
802  if (vdr_dm_metadata_present) {
803  DOVIExt *ext = s->ext_blocks;
804  const int denom = profile == 4 ? (1 << 30) : (1 << 28);
805  set_ue_golomb(pb, color->dm_metadata_id); /* affected_dm_id */
806  set_ue_golomb(pb, color->dm_metadata_id); /* current_dm_id */
807  set_ue_golomb(pb, color->scene_refresh_flag);
808  if (!dm_compression) {
809  for (int i = 0; i < 9; i++)
810  put_sbits(pb, 16, av_q2den(color->ycc_to_rgb_matrix[i], 1 << 13));
811  for (int i = 0; i < 3; i++)
812  put_bits32(pb, av_q2den(color->ycc_to_rgb_offset[i], denom));
813  for (int i = 0; i < 9; i++)
814  put_sbits(pb, 16, av_q2den(color->rgb_to_lms_matrix[i], 1 << 14));
815  put_bits(pb, 16, color->signal_eotf);
816  put_bits(pb, 16, color->signal_eotf_param0);
817  put_bits(pb, 16, color->signal_eotf_param1);
818  put_bits32(pb, color->signal_eotf_param2);
819  put_bits(pb, 5, color->signal_bit_depth);
820  put_bits(pb, 2, color->signal_color_space);
821  put_bits(pb, 2, color->signal_chroma_format);
822  put_bits(pb, 2, color->signal_full_range_flag);
823  put_bits(pb, 12, color->source_min_pq);
824  put_bits(pb, 12, color->source_max_pq);
825  put_bits(pb, 10, color->source_diagonal);
826  }
827 
828  memcpy(s->dm, color, sizeof(*color));
829  s->color = s->dm;
830 
831  /* Extension blocks */
832  set_ue_golomb(pb, num_ext_blocks_v1);
833  align_put_bits(pb);
834  for (int i = 0; i < metadata->num_ext_blocks; i++) {
835  const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
836  if (dm_compression && ff_dovi_rpu_extension_is_static(dm->level))
837  continue;
838  generate_ext_v1(pb, dm);
839  }
840 
841  if (num_ext_blocks_v2) {
842  set_ue_golomb(pb, num_ext_blocks_v2);
843  align_put_bits(pb);
844  for (int i = 0; i < metadata->num_ext_blocks; i++) {
845  const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
846  if (dm_compression && ff_dovi_rpu_extension_is_static(dm->level))
847  continue;
848  generate_ext_v2(pb, av_dovi_get_ext(metadata, i));
849  }
850  }
851 
852  if (ext) {
853  size_t ext_sz = FFMIN(sizeof(AVDOVIDmData), metadata->ext_block_size);
854  ext->num_dynamic = 0;
855  if (!dm_compression)
856  ext->num_static = 0;
857  for (int i = 0; i < metadata->num_ext_blocks; i++) {
858  const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
860  memcpy(&ext->dm_dynamic[ext->num_dynamic++], dm, ext_sz);
861  else if (!dm_compression)
862  memcpy(&ext->dm_static[ext->num_static++], dm, ext_sz);
863  }
864  }
865  } else {
866  s->color = &ff_dovi_color_default;
867  ff_refstruct_unref(&s->ext_blocks);
868  }
869 
870  flush_put_bits(pb);
872  s->rpu_buf, put_bytes_output(pb)));
873  put_bits32(pb, crc);
874  put_bits(pb, 8, 0x80); /* terminator */
875  flush_put_bits(pb);
876 
877  rpu_size = put_bytes_output(pb);
878  if (flags & FF_DOVI_WRAP_T35) {
879  *out_rpu = av_malloc(rpu_size + 15);
880  if (!*out_rpu)
881  return AVERROR(ENOMEM);
882  init_put_bits(pb, *out_rpu, rpu_size + 15);
885  put_bits32(pb, 0x800); /* provider_oriented_code */
886  put_bits(pb, 27, 0x01be6841u); /* fixed EMDF header, see above */
887  if (rpu_size > 0xFF) {
888  av_assert2(rpu_size <= 0x10000);
889  put_bits(pb, 8, (rpu_size >> 8) - 1);
890  put_bits(pb, 1, 1); /* read_more */
891  put_bits(pb, 8, rpu_size & 0xFF);
892  put_bits(pb, 1, 0);
893  } else {
894  put_bits(pb, 8, rpu_size);
895  put_bits(pb, 1, 0);
896  }
897  ff_copy_bits(pb, s->rpu_buf, rpu_size * 8);
898  put_bits(pb, 17, 0x400); /* emdf payload id + emdf_protection */
899 
900  pad = pb->bit_left & 7;
901  put_bits(pb, pad, (1 << pad) - 1); /* pad to next byte with 1 bits */
902  flush_put_bits(pb);
903  *out_size = put_bytes_output(pb);
904  return 0;
905  } else if (flags & FF_DOVI_WRAP_NAL) {
906  *out_rpu = dst = av_malloc(4 + rpu_size * 3 / 2); /* worst case */
907  if (!*out_rpu)
908  return AVERROR(ENOMEM);
909  *dst++ = 25; /* NAL prefix */
910  zero_run = 0;
911  for (int i = 0; i < rpu_size; i++) {
912  if (zero_run < 2) {
913  if (s->rpu_buf[i] == 0) {
914  zero_run++;
915  } else {
916  zero_run = 0;
917  }
918  } else {
919  if ((s->rpu_buf[i] & ~3) == 0) {
920  /* emulation prevention */
921  *dst++ = 3;
922  }
923  zero_run = s->rpu_buf[i] == 0;
924  }
925  *dst++ = s->rpu_buf[i];
926  }
927  *out_size = dst - *out_rpu;
928  return 0;
929  } else {
930  /* Return intermediate buffer directly */
931  *out_rpu = s->rpu_buf;
932  *out_size = rpu_size;
933  s->rpu_buf = NULL;
934  s->rpu_buf_sz = 0;
935  return 0;
936  }
937 }
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVDOVIDataMapping::nlq_method_idc
enum AVDOVINLQMethod nlq_method_idc
Definition: dovi_meta.h:159
AVDOVIDmLevel2::trim_chroma_weight
uint16_t trim_chroma_weight
Definition: dovi_meta.h:216
AVDOVIDmLevel8::trim_power
uint16_t trim_power
Definition: dovi_meta.h:253
AVDOVIDmLevel8::saturation_vector_field
uint8_t saturation_vector_field[6]
Definition: dovi_meta.h:259
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
AVDOVIDmLevel8::trim_offset
uint16_t trim_offset
Definition: dovi_meta.h:252
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:291
align_put_bits
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:420
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2087
ff_dovi_rpu_generate
int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata, int flags, uint8_t **out_rpu, int *out_size)
Synthesize a Dolby Vision RPU reflecting the current state.
Definition: dovi_rpuenc.c:562
AVColorPrimariesDesc::wp
AVWhitepointCoefficients wp
Definition: csp.h:79
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
DOVI_MAX_DM_ID
#define DOVI_MAX_DM_ID
Definition: dovi_rpu.h:33
color
Definition: vf_paletteuse.c:513
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
ANY_CSP
#define ANY_CSP(csp)
Definition: dovi_rpuenc.c:444
AV_DOVI_COMPRESSION_LIMITED
@ AV_DOVI_COMPRESSION_LIMITED
Definition: dovi_meta.h:69
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:208
AVDOVIRpuDataHeader::ext_mapping_idc_0_4
uint8_t ext_mapping_idc_0_4
Definition: dovi_meta.h:103
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
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
AVDOVIDmLevel9::source_display_primaries
AVColorPrimariesDesc source_display_primaries
Definition: dovi_meta.h:266
AVDOVIDmLevel8::trim_saturation_gain
uint16_t trim_saturation_gain
Definition: dovi_meta.h:255
out_size
int out_size
Definition: movenc.c:56
AVDOVIDmLevel5::top_offset
uint16_t top_offset
Definition: dovi_meta.h:236
AVDOVIDmLevel11::frame_rate_conversion
uint8_t frame_rate_conversion
Definition: dovi_meta.h:285
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
av_dovi_get_ext
static av_always_inline AVDOVIDmData * av_dovi_get_ext(const AVDOVIMetadata *data, int index)
Definition: dovi_meta.h:373
ff_dovi_color_default
const AVDOVIColorMetadata ff_dovi_color_default
Definition: dovi_rpu.c:93
AVDOVIReshapingCurve::mmr_coef
int64_t mmr_coef[AV_DOVI_MAX_PIECES][3][7]
Definition: dovi_meta.h:127
put_bits64
static void put_bits64(PutBitContext *s, int n, uint64_t value)
Write up to 64 bits into a bitstream.
Definition: put_bits.h:334
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
AVDOVIDmLevel10::target_primary_index
uint8_t target_primary_index
Definition: dovi_meta.h:274
AV_DOVI_NLQ_NONE
@ AV_DOVI_NLQ_NONE
Definition: dovi_meta.h:131
AVDOVIDmLevel8::ms_weight
uint16_t ms_weight
Definition: dovi_meta.h:256
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: defs.h:59
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:502
high
int high
Definition: dovi_rpuenc.c:38
AVDOVIReshapingCurve::mapping_idc
enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:120
AVCodecParameters::framerate
AVRational framerate
Video only.
Definition: codec_par.h:156
AVDOVIDmLevel6::min_luminance
uint16_t min_luminance
Definition: dovi_meta.h:243
AVDOVIDmLevel10::target_display_index
uint8_t target_display_index
Definition: dovi_meta.h:271
AVDOVIDmLevel1::max_pq
uint16_t max_pq
Definition: dovi_meta.h:206
AVDOVIDmData::l11
AVDOVIDmLevel11 l11
Definition: dovi_meta.h:323
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
AVDOVIRpuDataHeader::rpu_format
uint16_t rpu_format
Definition: dovi_meta.h:89
AVDOVIDataMapping::mapping_color_space
uint8_t mapping_color_space
Definition: dovi_meta.h:154
AVDOVIRpuDataHeader
Dolby Vision RPU data header.
Definition: dovi_meta.h:87
AVDOVIDmLevel8::hue_vector_field
uint8_t hue_vector_field[6]
Definition: dovi_meta.h:260
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_PKT_DATA_DOVI_CONF
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h:280
AVDOVIRpuDataHeader::coef_data_type
uint8_t coef_data_type
Definition: dovi_meta.h:93
crc.h
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
DOVIExt::num_dynamic
int num_dynamic
Definition: dovi_rpu.h:39
ff_copy_bits
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:49
AVDOVIDmLevel11::color
uint8_t color
Definition: dovi_meta.h:287
AVDOVIMetadata::ext_block_size
size_t ext_block_size
Definition: dovi_meta.h:347
AVDOVIDmLevel11::reference_mode_flag
uint8_t reference_mode_flag
Definition: dovi_meta.h:281
AVDOVIDmLevel11::brightness
uint8_t brightness
Definition: dovi_meta.h:286
DOVIContext
Definition: dovi_rpu.h:42
fail
#define fail()
Definition: checkasm.h:193
AV_DOVI_COMPRESSION_EXTENDED
@ AV_DOVI_COMPRESSION_EXTENDED
Definition: dovi_meta.h:71
AVDOVIRpuDataHeader::el_bit_depth
uint8_t el_bit_depth
Definition: dovi_meta.h:98
AVDOVIDecoderConfigurationRecord::dv_md_compression
uint8_t dv_md_compression
Definition: dovi_meta.h:64
AVDOVIDmLevel2::trim_power
uint16_t trim_power
Definition: dovi_meta.h:215
dovi_rpu.h
AVDOVIDmLevel2::trim_slope
uint16_t trim_slope
Definition: dovi_meta.h:213
FF_DOVI_WRAP_T35
@ FF_DOVI_WRAP_T35
wrap inside T.35+EMDF
Definition: dovi_rpu.h:159
AVDOVIColorMetadata::ycc_to_rgb_offset
AVRational ycc_to_rgb_offset[3]
Definition: dovi_meta.h:184
AVDOVIDmLevel2::ms_weight
int16_t ms_weight
Definition: dovi_meta.h:218
AVRational::num
int num
Numerator.
Definition: rational.h:59
refstruct.h
FF_DOVI_AUTOMATIC
#define FF_DOVI_AUTOMATIC
Enable tri-state.
Definition: dovi_rpu.h:49
FF_DOVI_COMPRESS_RPU
@ FF_DOVI_COMPRESS_RPU
enable compression for this RPU
Definition: dovi_rpu.h:160
generate_ext_v1
static void generate_ext_v1(PutBitContext *pb, const AVDOVIDmData *dm)
Definition: dovi_rpuenc.c:373
AVDOVIRpuDataHeader::vdr_rpu_normalized_idc
uint8_t vdr_rpu_normalized_idc
Definition: dovi_meta.h:95
av_dovi_alloc
AVDOVIDecoderConfigurationRecord * av_dovi_alloc(size_t *size)
Allocate a AVDOVIDecoderConfigurationRecord structure and initialize its fields to default values.
Definition: dovi_meta.c:26
AVDOVIRpuDataHeader::el_spatial_resampling_filter_flag
uint8_t el_spatial_resampling_filter_flag
Definition: dovi_meta.h:101
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
AVDOVIDmLevel3::avg_pq_offset
uint16_t avg_pq_offset
Definition: dovi_meta.h:224
AVDOVIDmLevel8::clip_trim
uint16_t clip_trim
Definition: dovi_meta.h:258
AVDOVIDmData
Dolby Vision metadata extension block.
Definition: dovi_meta.h:310
avassert.h
put_golomb.h
exp golomb vlc writing stuff
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVDOVIRpuDataHeader::chroma_resampling_explicit_filter_flag
uint8_t chroma_resampling_explicit_filter_flag
Definition: dovi_meta.h:92
main
int main
Definition: dovi_rpuenc.c:37
RPU_COEFF_FIXED
@ RPU_COEFF_FIXED
Definition: dovi_rpu.h:184
AVDOVIDmLevel6::max_cll
uint16_t max_cll
Definition: dovi_meta.h:244
ff_dovi_configure_ext
int ff_dovi_configure_ext(DOVIContext *s, AVCodecParameters *codecpar, const AVDOVIMetadata *metadata, enum AVDOVICompression compression, int strict_std_compliance)
Configure the encoder for Dolby Vision encoding.
Definition: dovi_rpuenc.c:55
float
float
Definition: af_crystalizer.c:122
AVDOVIRpuDataHeader::vdr_bit_depth
uint8_t vdr_bit_depth
Definition: dovi_meta.h:99
AVDOVIRpuDataHeader::rpu_type
uint8_t rpu_type
Definition: dovi_meta.h:88
AVDOVIMetadata
Combined struct representing a combination of header, mapping and color metadata, for attaching to fr...
Definition: dovi_meta.h:337
AVDOVIDmLevel8::trim_slope
uint16_t trim_slope
Definition: dovi_meta.h:251
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVDOVIDmLevel4::anchor_power
uint16_t anchor_power
Definition: dovi_meta.h:229
AVDOVIReshapingCurve::mmr_order
uint8_t mmr_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:125
AVDOVIDmData::l3
AVDOVIDmLevel3 l3
Definition: dovi_meta.h:315
AVDOVIDmLevel11::noise_reduction
uint8_t noise_reduction
Definition: dovi_meta.h:283
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2088
AVDOVIRpuDataHeader::spatial_resampling_filter_flag
uint8_t spatial_resampling_filter_flag
Definition: dovi_meta.h:100
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AVDOVIDmLevel10::target_min_pq
uint16_t target_min_pq
Definition: dovi_meta.h:273
DOVIExt::dm_static
AVDOVIDmData dm_static[7]
static extension blocks
Definition: dovi_rpu.h:36
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:58
AV_DOVI_MAPPING_POLYNOMIAL
@ AV_DOVI_MAPPING_POLYNOMIAL
Definition: dovi_meta.h:108
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
put_se_coef
static void put_se_coef(PutBitContext *pb, const AVDOVIRpuDataHeader *hdr, uint64_t coef)
Definition: dovi_rpuenc.c:347
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVCOL_SPC_IPT_C2
@ AVCOL_SPC_IPT_C2
SMPTE ST 2128, IPT-C2.
Definition: pixfmt.h:657
RPU_COEFF_FLOAT
@ RPU_COEFF_FLOAT
Definition: dovi_rpu.h:185
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
PutBitContext
Definition: put_bits.h:50
AVDOVIDecoderConfigurationRecord::dv_version_major
uint8_t dv_version_major
Definition: dovi_meta.h:56
av_dovi_get_header
static av_always_inline AVDOVIRpuDataHeader * av_dovi_get_header(const AVDOVIMetadata *data)
Definition: dovi_meta.h:355
AVDOVIReshapingCurve::poly_order
uint8_t poly_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:122
AVDOVINLQParams::linear_deadzone_threshold
uint64_t linear_deadzone_threshold
Definition: dovi_meta.h:144
AVDOVIDmLevel8::target_mid_contrast
uint16_t target_mid_contrast
Definition: dovi_meta.h:257
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
NULL
#define NULL
Definition: coverity.c:32
AVDOVIDecoderConfigurationRecord::dv_level
uint8_t dv_level
Definition: dovi_meta.h:59
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:63
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:284
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
AV_DOVI_MAPPING_MMR
@ AV_DOVI_MAPPING_MMR
Definition: dovi_meta.h:109
AVDOVIDmLevel5::bottom_offset
uint16_t bottom_offset
Definition: dovi_meta.h:237
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:588
AVDOVIDmData::l9
AVDOVIDmLevel9 l9
Definition: dovi_meta.h:321
put_cie_xy
static void put_cie_xy(PutBitContext *pb, AVCIExy xy)
Definition: dovi_rpuenc.c:435
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
AVDOVIColorMetadata::signal_eotf
uint16_t signal_eotf
Extra signal metadata (see Dolby patents for more info).
Definition: dovi_meta.h:190
AVDOVIDmLevel4::anchor_pq
uint16_t anchor_pq
Definition: dovi_meta.h:228
AVDOVIReshapingCurve::mmr_constant
int64_t mmr_constant[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:126
AVDOVIDmLevel9::source_primary_index
uint8_t source_primary_index
Definition: dovi_meta.h:265
AVCIExy
Struct containing chromaticity x and y values for the standard CIE 1931 chromaticity definition.
Definition: csp.h:56
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVDOVIDmLevel2::target_max_pq
uint16_t target_max_pq
Definition: dovi_meta.h:212
AVCOL_PRI_BT2020
@ AVCOL_PRI_BT2020
ITU-R BT2020.
Definition: pixfmt.h:597
AVDOVIDmLevel6::max_luminance
uint16_t max_luminance
Definition: dovi_meta.h:242
AVCIExy::x
AVRational x
Definition: csp.h:57
AVDOVIDmData::l2
AVDOVIDmLevel2 l2
Definition: dovi_meta.h:314
AVDOVIDataMapping::nlq_pivots
uint16_t nlq_pivots[2]
Definition: dovi_meta.h:163
AVCOL_TRC_SMPTE2084
@ AVCOL_TRC_SMPTE2084
SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.
Definition: pixfmt.h:628
AVPrimaryCoefficients::b
AVCIExy b
Definition: csp.h:65
AVDOVIDmLevel6::max_fall
uint16_t max_fall
Definition: dovi_meta.h:245
ITU_T_T35_PROVIDER_CODE_DOLBY
#define ITU_T_T35_PROVIDER_CODE_DOLBY
Definition: itut35.h:28
AVPrimaryCoefficients::r
AVCIExy r
Definition: csp.h:65
AVDOVIDmLevel8::target_display_index
uint8_t target_display_index
Definition: dovi_meta.h:250
AVDOVIDmData::l254
AVDOVIDmLevel254 l254
Definition: dovi_meta.h:324
av_q2den
static int av_q2den(AVRational q, int den)
Definition: dovi_rpuenc.c:365
AVDOVIDmLevel10::target_display_primaries
AVColorPrimariesDesc target_display_primaries
Definition: dovi_meta.h:275
AV_DOVI_NLQ_LINEAR_DZ
@ AV_DOVI_NLQ_LINEAR_DZ
Definition: dovi_meta.h:132
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
AVDOVIRpuDataHeader::vdr_rpu_profile
uint8_t vdr_rpu_profile
Definition: dovi_meta.h:90
av_bswap32
#define av_bswap32
Definition: bswap.h:47
try_reuse_ext
static int try_reuse_ext(DOVIExt *ext, const AVDOVIMetadata *metadata)
Definition: dovi_rpuenc.c:299
AVDOVIDmLevel2::trim_saturation_gain
uint16_t trim_saturation_gain
Definition: dovi_meta.h:217
DOVIExt
Definition: dovi_rpu.h:35
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:94
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AVDOVIDmLevel8::trim_chroma_weight
uint16_t trim_chroma_weight
Definition: dovi_meta.h:254
DOVIExt::dm_dynamic
AVDOVIDmData dm_dynamic[25]
dynamic extension blocks
Definition: dovi_rpu.h:37
AVDOVIDmLevel255::dm_run_mode
uint8_t dm_run_mode
Definition: dovi_meta.h:298
AVDOVIDmLevel1::min_pq
uint16_t min_pq
Definition: dovi_meta.h:205
set_se_golomb
static void set_se_golomb(PutBitContext *pb, int i)
write signed exp golomb code.
Definition: put_golomb.h:86
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
AVPrimaryCoefficients::g
AVCIExy g
Definition: csp.h:65
dv_levels
static struct @108 dv_levels[]
AVDOVIDmLevel11::content_type
uint8_t content_type
Definition: dovi_meta.h:279
AVDOVIDmData::l10
AVDOVIDmLevel10 l10
Definition: dovi_meta.h:322
PutBitContext::bit_left
int bit_left
Definition: put_bits.h:52
AVDOVIRpuDataHeader::coef_log2_denom
uint8_t coef_log2_denom
Definition: dovi_meta.h:94
AVDOVIRpuDataHeader::bl_video_full_range_flag
uint8_t bl_video_full_range_flag
Definition: dovi_meta.h:96
AVDOVIReshapingCurve::poly_coef
int64_t poly_coef[AV_DOVI_MAX_PIECES][3]
Definition: dovi_meta.h:123
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
av_packet_side_data_add
AVPacketSideData * av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size, int flags)
Wrap existing data as packet side data.
Definition: packet.c:699
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:613
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
AVDOVIDmData::l255
AVDOVIDmLevel255 l255
Definition: dovi_meta.h:325
AVDOVIDmData::l8
AVDOVIDmLevel8 l8
Definition: dovi_meta.h:320
AVDOVIDmLevel2::trim_offset
uint16_t trim_offset
Definition: dovi_meta.h:214
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:651
AVDOVIDmLevel10::target_max_pq
uint16_t target_max_pq
Definition: dovi_meta.h:272
AVCodecParameters::height
int height
Definition: codec_par.h:135
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AVDOVIDataMapping::num_y_partitions
uint32_t num_y_partitions
Definition: dovi_meta.h:161
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:52
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:228
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
profile
int profile
Definition: mxfenc.c:2233
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
AVDOVINLQParams
Coefficients of the non-linear inverse quantization.
Definition: dovi_meta.h:139
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
AVDOVIDmData::l4
AVDOVIDmLevel4 l4
Definition: dovi_meta.h:316
set_ue_golomb
static void set_ue_golomb(PutBitContext *pb, int i)
write unsigned exp golomb code.
Definition: put_golomb.h:41
AVDOVIDmData::l1
AVDOVIDmLevel1 l1
Definition: dovi_meta.h:313
AVDOVIDataMapping::curves
AVDOVIReshapingCurve curves[3]
Definition: dovi_meta.h:156
avcodec.h
AVDOVINLQParams::linear_deadzone_slope
uint64_t linear_deadzone_slope
Definition: dovi_meta.h:143
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVDOVIReshapingCurve
Definition: dovi_meta.h:117
generate_ext_v2
static void generate_ext_v2(PutBitContext *pb, const AVDOVIDmData *dm)
Definition: dovi_rpuenc.c:447
ff_dovi_configure
int ff_dovi_configure(DOVIContext *s, AVCodecContext *avctx)
Helper wrapper around ff_dovi_configure_ext which infers the codec parameters from an AVCodecContext.
Definition: dovi_rpuenc.c:241
ret
ret
Definition: filter_design.txt:187
AVDOVIDmLevel11::mpeg_noise_reduction
uint8_t mpeg_noise_reduction
Definition: dovi_meta.h:284
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVDOVIDmLevel11::sharpness
uint8_t sharpness
Definition: dovi_meta.h:282
AVDOVINLQParams::vdr_in_max
uint64_t vdr_in_max
Definition: dovi_meta.h:141
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1389
AVCIExy::y
AVRational y
Definition: csp.h:57
AVDOVIColorMetadata::rgb_to_lms_matrix
AVRational rgb_to_lms_matrix[9]
Definition: dovi_meta.h:185
AVDOVIDmData::l6
AVDOVIDmLevel6 l6
Definition: dovi_meta.h:318
AVDOVIReshapingCurve::num_pivots
uint8_t num_pivots
Definition: dovi_meta.h:118
AVDOVIDmLevel3::min_pq_offset
uint16_t min_pq_offset
Definition: dovi_meta.h:222
AVDOVIRpuDataHeader::vdr_rpu_level
uint8_t vdr_rpu_level
Definition: dovi_meta.h:91
av_dovi_get_color
static av_always_inline AVDOVIColorMetadata * av_dovi_get_color(const AVDOVIMetadata *data)
Definition: dovi_meta.h:367
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVDOVIDmLevel5::left_offset
uint16_t left_offset
Definition: dovi_meta.h:234
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:632
AVDOVIDmData::l5
AVDOVIDmLevel5 l5
Definition: dovi_meta.h:317
itut35.h
AVDOVIDataMapping::mapping_chroma_format_idc
uint8_t mapping_chroma_format_idc
Definition: dovi_meta.h:155
AVDOVIDmLevel5::right_offset
uint16_t right_offset
Definition: dovi_meta.h:235
AVDOVIDmLevel255::dm_run_version
uint8_t dm_run_version
Definition: dovi_meta.h:299
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
FF_DOVI_WRAP_NAL
@ FF_DOVI_WRAP_NAL
wrap inside NAL RBSP
Definition: dovi_rpu.h:158
AVDOVIDmLevel1::avg_pq
uint16_t avg_pq
Definition: dovi_meta.h:207
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVDOVIDecoderConfigurationRecord::bl_present_flag
uint8_t bl_present_flag
Definition: dovi_meta.h:62
AVDOVIRpuDataHeader::bl_bit_depth
uint8_t bl_bit_depth
Definition: dovi_meta.h:97
ff_dovi_rpu_extension_is_static
static int ff_dovi_rpu_extension_is_static(int level)
Definition: dovi_rpu.h:196
AVDOVIColorMetadata
Dolby Vision RPU colorspace metadata parameters.
Definition: dovi_meta.h:171
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:60
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:61
AVDOVICompression
AVDOVICompression
Definition: dovi_meta.h:67
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVDOVIDmData::level
uint8_t level
Definition: dovi_meta.h:311
AVDOVIDmLevel3::max_pq_offset
uint16_t max_pq_offset
Definition: dovi_meta.h:223
AVDOVIDmLevel254::dm_version_index
uint8_t dm_version_index
Definition: dovi_meta.h:293
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:57
AVDOVIDmLevel11::whitepoint
uint8_t whitepoint
Definition: dovi_meta.h:280
AVDOVIDmLevel254::dm_mode
uint8_t dm_mode
Definition: dovi_meta.h:292
mem.h
AVDOVIRpuDataHeader::ext_mapping_idc_5_7
uint8_t ext_mapping_idc_5_7
Definition: dovi_meta.h:104
width
int width
Definition: dovi_rpuenc.c:36
av_dovi_get_mapping
static av_always_inline AVDOVIDataMapping * av_dovi_get_mapping(const AVDOVIMetadata *data)
Definition: dovi_meta.h:361
ITU_T_T35_COUNTRY_CODE_US
#define ITU_T_T35_COUNTRY_CODE_US
Definition: itut35.h:24
AV_DOVI_COMPRESSION_NONE
@ AV_DOVI_COMPRESSION_NONE
Definition: dovi_meta.h:68
avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:137
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
AVCodecParameters::format
int format
Definition: codec_par.h:92
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVDOVIReshapingCurve::pivots
uint16_t pivots[AV_DOVI_MAX_PIECES+1]
Definition: dovi_meta.h:119
AVDOVIColorMetadata::ycc_to_rgb_matrix
AVRational ycc_to_rgb_matrix[9]
Coefficients of the custom Dolby Vision IPT-PQ matrices.
Definition: dovi_meta.h:183
AVColorPrimariesDesc::prim
AVPrimaryCoefficients prim
Definition: csp.h:80
av_frame_side_data_get
static const AVFrameSideData * av_frame_side_data_get(AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conver...
Definition: frame.h:1159
ANY6
#define ANY6(arr)
Definition: dovi_rpuenc.c:442
AVDOVINLQParams::nlq_offset
uint16_t nlq_offset
Definition: dovi_meta.h:140
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVDOVIDataMapping::vdr_rpu_id
uint8_t vdr_rpu_id
Definition: dovi_meta.h:153
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AVDOVIRpuDataHeader::disable_residual_flag
uint8_t disable_residual_flag
Definition: dovi_meta.h:102
DOVIExt::num_static
int num_static
Definition: dovi_rpu.h:38
AV_DOVI_COMPRESSION_RESERVED
@ AV_DOVI_COMPRESSION_RESERVED
Definition: dovi_meta.h:70
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:642
put_bits.h
put_ue_coef
static void put_ue_coef(PutBitContext *pb, const AVDOVIRpuDataHeader *hdr, uint64_t coef)
Definition: dovi_rpuenc.c:329
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:162
AVDOVIDataMapping
Dolby Vision RPU data mapping parameters.
Definition: dovi_meta.h:152
cmp_dm_level0
static int cmp_dm_level0(const AVDOVIColorMetadata *dm1, const AVDOVIColorMetadata *dm2)
Definition: dovi_rpuenc.c:275
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
AVDOVIDataMapping::num_x_partitions
uint32_t num_x_partitions
Definition: dovi_meta.h:160
ff_dovi_guess_profile_hevc
int ff_dovi_guess_profile_hevc(const AVDOVIRpuDataHeader *hdr)
Internal helper function to guess the correct DV profile for HEVC.
Definition: dovi_rpu.c:71
AVDOVIDmLevel255::dm_debug
uint8_t dm_debug[4]
Definition: dovi_meta.h:300
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:55
AVDOVIMetadata::num_ext_blocks
int num_ext_blocks
Definition: dovi_meta.h:348