FFmpeg
dovi_rpudec.c
Go to the documentation of this file.
1 /*
2  * Dolby Vision RPU decoder
3  *
4  * Copyright (C) 2021 Jan Ekström
5  * Copyright (C) 2021-2024 Niklas Haas
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include "libavutil/mem.h"
25 #include "libavutil/crc.h"
26 
27 #include "avcodec.h"
28 #include "dovi_rpu.h"
29 #include "golomb.h"
30 #include "get_bits.h"
31 #include "libavutil/refstruct.h"
32 
33 int ff_dovi_get_metadata(DOVIContext *s, AVDOVIMetadata **out_metadata)
34 {
35  AVDOVIMetadata *dovi;
36  size_t dovi_size;
37 
38  if (!s->mapping || !s->color)
39  return 0; /* incomplete dovi metadata */
40 
41  dovi = av_dovi_metadata_alloc(&dovi_size);
42  if (!dovi)
43  return AVERROR(ENOMEM);
44 
45  /* Copy only the parts of these structs known to us at compiler-time. */
46 #define COPY(t, a, b, last) memcpy(a, b, offsetof(t, last) + sizeof((b)->last))
47  COPY(AVDOVIRpuDataHeader, av_dovi_get_header(dovi), &s->header, ext_mapping_idc_5_7);
48  COPY(AVDOVIDataMapping, av_dovi_get_mapping(dovi), s->mapping, nlq_pivots);
49  COPY(AVDOVIColorMetadata, av_dovi_get_color(dovi), s->color, source_diagonal);
50 
51  if (s->ext_blocks) {
52  const DOVIExt *ext = s->ext_blocks;
53  size_t ext_sz = FFMIN(sizeof(AVDOVIDmData), dovi->ext_block_size);
54  for (int i = 0; i < ext->num_static; i++)
55  memcpy(av_dovi_get_ext(dovi, dovi->num_ext_blocks++), &ext->dm_static[i], ext_sz);
56  for (int i = 0; i < ext->num_dynamic; i++)
57  memcpy(av_dovi_get_ext(dovi, dovi->num_ext_blocks++), &ext->dm_dynamic[i], ext_sz);
58  }
59 
60  *out_metadata = dovi;
61  return dovi_size;
62 }
63 
64 int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
65 {
66  AVFrameSideData *sd;
67  AVDOVIMetadata *dovi;
68  AVBufferRef *buf;
69  int size;
70 
71  size = ff_dovi_get_metadata(s, &dovi);
72  if (size <= 0)
73  return size;
74 
75  buf = av_buffer_create((uint8_t *) dovi, size, NULL, NULL, 0);
76  if (!buf) {
77  av_free(dovi);
78  return AVERROR(ENOMEM);
79  }
80 
81  sd = av_frame_new_side_data_from_buf(frame, AV_FRAME_DATA_DOVI_METADATA, buf);
82  if (!sd) {
83  av_buffer_unref(&buf);
84  return AVERROR(ENOMEM);
85  }
86 
87  return 0;
88 }
89 
90 static inline uint64_t get_ue_coef(GetBitContext *gb, const AVDOVIRpuDataHeader *hdr)
91 {
92  uint64_t ipart;
93  union { uint32_t u32; float f32; } fpart;
94 
95  switch (hdr->coef_data_type) {
96  case RPU_COEFF_FIXED:
97  ipart = get_ue_golomb_long(gb);
98  fpart.u32 = get_bits_long(gb, hdr->coef_log2_denom);
99  return (ipart << hdr->coef_log2_denom) | fpart.u32;
100 
101  case RPU_COEFF_FLOAT:
102  fpart.u32 = get_bits_long(gb, 32);
103  return fpart.f32 * (1LL << hdr->coef_log2_denom);
104  }
105 
106  return 0; /* unreachable */
107 }
108 
109 static inline int64_t get_se_coef(GetBitContext *gb, const AVDOVIRpuDataHeader *hdr)
110 {
111  int64_t ipart;
112  union { uint32_t u32; float f32; } fpart;
113 
114  switch (hdr->coef_data_type) {
115  case RPU_COEFF_FIXED:
116  ipart = get_se_golomb_long(gb);
117  fpart.u32 = get_bits_long(gb, hdr->coef_log2_denom);
118  return ipart * (1LL << hdr->coef_log2_denom) | fpart.u32;
119 
120  case RPU_COEFF_FLOAT:
121  fpart.u32 = get_bits_long(gb, 32);
122  return fpart.f32 * (1LL << hdr->coef_log2_denom);
123  }
124 
125  return 0; /* unreachable */
126 }
127 
128 static inline unsigned get_variable_bits(GetBitContext *gb, int n)
129 {
130  unsigned int value = get_bits(gb, n);
131  int read_more = get_bits1(gb);
132  while (read_more) {
133  value = (value + 1) << n;
134  value |= get_bits(gb, n);
135  read_more = get_bits1(gb);
136  }
137  return value;
138 }
139 
140 #define VALIDATE(VAR, MIN, MAX) \
141  do { \
142  if (VAR < MIN || VAR > MAX) { \
143  av_log(s->logctx, AV_LOG_ERROR, "RPU validation failed: " \
144  #MIN" <= "#VAR" = %d <= "#MAX"\n", (int) VAR); \
145  ff_dovi_ctx_unref(s); \
146  return AVERROR_INVALIDDATA; \
147  } \
148  } while (0)
149 
150 static int parse_ext_v1(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm)
151 {
152  switch (dm->level) {
153  case 1:
154  dm->l1.min_pq = get_bits(gb, 12);
155  dm->l1.max_pq = get_bits(gb, 12);
156  dm->l1.avg_pq = get_bits(gb, 12);
157  break;
158  case 2:
159  dm->l2.target_max_pq = get_bits(gb, 12);
160  dm->l2.trim_slope = get_bits(gb, 12);
161  dm->l2.trim_offset = get_bits(gb, 12);
162  dm->l2.trim_power = get_bits(gb, 12);
163  dm->l2.trim_chroma_weight = get_bits(gb, 12);
164  dm->l2.trim_saturation_gain = get_bits(gb, 12);
165  dm->l2.ms_weight = get_sbits(gb, 13);
166  VALIDATE(dm->l2.ms_weight, -1, 4095);
167  break;
168  case 4:
169  dm->l4.anchor_pq = get_bits(gb, 12);
170  dm->l4.anchor_power = get_bits(gb, 12);
171  break;
172  case 5:
173  dm->l5.left_offset = get_bits(gb, 13);
174  dm->l5.right_offset = get_bits(gb, 13);
175  dm->l5.top_offset = get_bits(gb, 13);
176  dm->l5.bottom_offset = get_bits(gb, 13);
177  break;
178  case 6:
179  dm->l6.max_luminance = get_bits(gb, 16);
180  dm->l6.min_luminance = get_bits(gb, 16);
181  dm->l6.max_cll = get_bits(gb, 16);
182  dm->l6.max_fall = get_bits(gb, 16);
183  break;
184  case 255:
185  dm->l255.dm_run_mode = get_bits(gb, 8);
186  dm->l255.dm_run_version = get_bits(gb, 8);
187  for (int i = 0; i < 4; i++)
188  dm->l255.dm_debug[i] = get_bits(gb, 8);
189  break;
190  default:
191  avpriv_request_sample(s->logctx, "Dolby Vision DM v1 level %u", dm->level);
192  }
193 
194  return 0;
195 }
196 
197 static AVCIExy get_cie_xy(GetBitContext *gb)
198 {
199  AVCIExy xy;
200  const int denom = 32767;
201  xy.x = av_make_q(get_sbits(gb, 16), denom);
202  xy.y = av_make_q(get_sbits(gb, 16), denom);
203  return xy;
204 }
205 
206 static int parse_ext_v2(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm,
207  int ext_block_length)
208 {
209  switch (dm->level) {
210  case 3:
211  dm->l3.min_pq_offset = get_bits(gb, 12);
212  dm->l3.max_pq_offset = get_bits(gb, 12);
213  dm->l3.avg_pq_offset = get_bits(gb, 12);
214  break;
215  case 8:
216  dm->l8.target_display_index = get_bits(gb, 8);
217  dm->l8.trim_slope = get_bits(gb, 12);
218  dm->l8.trim_offset = get_bits(gb, 12);
219  dm->l8.trim_power = get_bits(gb, 12);
220  dm->l8.trim_chroma_weight = get_bits(gb, 12);
221  dm->l8.trim_saturation_gain = get_bits(gb, 12);
222  dm->l8.ms_weight = get_bits(gb, 12);
223  if (ext_block_length < 12)
224  break;
225  dm->l8.target_mid_contrast = get_bits(gb, 12);
226  if (ext_block_length < 13)
227  break;
228  dm->l8.clip_trim = get_bits(gb, 12);
229  if (ext_block_length < 19)
230  break;
231  for (int i = 0; i < 6; i++)
232  dm->l8.saturation_vector_field[i] = get_bits(gb, 8);
233  if (ext_block_length < 25)
234  break;
235  for (int i = 0; i < 6; i++)
236  dm->l8.hue_vector_field[i] = get_bits(gb, 8);
237  break;
238  case 9:
239  dm->l9.source_primary_index = get_bits(gb, 8);
240  if (ext_block_length < 17)
241  break;
242  dm->l9.source_display_primaries.prim.r = get_cie_xy(gb);
243  dm->l9.source_display_primaries.prim.g = get_cie_xy(gb);
244  dm->l9.source_display_primaries.prim.b = get_cie_xy(gb);
245  dm->l9.source_display_primaries.wp = get_cie_xy(gb);
246  break;
247  case 10:
248  dm->l10.target_display_index = get_bits(gb, 8);
249  dm->l10.target_max_pq = get_bits(gb, 12);
250  dm->l10.target_min_pq = get_bits(gb, 12);
251  dm->l10.target_primary_index = get_bits(gb, 8);
252  if (ext_block_length < 21)
253  break;
254  dm->l10.target_display_primaries.prim.r = get_cie_xy(gb);
255  dm->l10.target_display_primaries.prim.g = get_cie_xy(gb);
256  dm->l10.target_display_primaries.prim.b = get_cie_xy(gb);
257  dm->l10.target_display_primaries.wp = get_cie_xy(gb);
258  break;
259  case 11:
260  dm->l11.content_type = get_bits(gb, 8);
261  dm->l11.whitepoint = get_bits(gb, 4);
262  dm->l11.reference_mode_flag = get_bits1(gb);
263  skip_bits(gb, 3); /* reserved */
264  dm->l11.sharpness = get_bits(gb, 2);
265  dm->l11.noise_reduction = get_bits(gb, 2);
266  dm->l11.mpeg_noise_reduction = get_bits(gb, 2);
267  dm->l11.frame_rate_conversion = get_bits(gb, 2);
268  dm->l11.brightness = get_bits(gb, 2);
269  dm->l11.color = get_bits(gb, 2);
270  break;
271  case 254:
272  dm->l254.dm_mode = get_bits(gb, 8);
273  dm->l254.dm_version_index = get_bits(gb, 8);
274  break;
275  default:
276  avpriv_request_sample(s->logctx, "Dolby Vision DM v2 level %u", dm->level);
277  }
278 
279  return 0;
280 }
281 
282 static int parse_ext_blocks(DOVIContext *s, GetBitContext *gb, int ver,
283  int compression, int err_recognition)
284 {
285  int num_ext_blocks, ext_block_length, start_pos, parsed_bits, ret;
286  DOVIExt *ext = s->ext_blocks;
287 
288  num_ext_blocks = get_ue_golomb_31(gb);
289  align_get_bits(gb);
290 
291  if (num_ext_blocks && !ext) {
292  ext = s->ext_blocks = av_refstruct_allocz(sizeof(*s->ext_blocks));
293  if (!ext)
294  return AVERROR(ENOMEM);
295  }
296 
297  while (num_ext_blocks--) {
298  AVDOVIDmData dummy;
299  AVDOVIDmData *dm;
300  uint8_t level;
301 
302  ext_block_length = get_ue_golomb_31(gb);
303  level = get_bits(gb, 8);
304  start_pos = get_bits_count(gb);
305 
306  if (ff_dovi_rpu_extension_is_static(level)) {
307  if (compression) {
308  av_log(s->logctx, AV_LOG_WARNING, "Compressed DM RPU contains "
309  "static extension block level %d\n", level);
310  if (err_recognition & (AV_EF_AGGRESSIVE | AV_EF_EXPLODE))
311  return AVERROR_INVALIDDATA;
312  dm = &dummy;
313  } else {
314  if (ext->num_static >= FF_ARRAY_ELEMS(ext->dm_static))
315  return AVERROR_INVALIDDATA;
316  dm = &ext->dm_static[ext->num_static++];
317  }
318  } else {
319  if (ext->num_dynamic >= FF_ARRAY_ELEMS(ext->dm_dynamic))
320  return AVERROR_INVALIDDATA;
321  dm = &ext->dm_dynamic[ext->num_dynamic++];
322  }
323 
324  memset(dm, 0, sizeof(*dm));
325  dm->level = level;
326  switch (ver) {
327  case 1: ret = parse_ext_v1(s, gb, dm); break;
328  case 2: ret = parse_ext_v2(s, gb, dm, ext_block_length); break;
329  default:
330  avpriv_request_sample(s->logctx, "Dolby Vision DM v%d", ver);
331  goto skip;
332  }
333 
334  if (ret < 0)
335  return ret;
336 
337 skip:
338  parsed_bits = get_bits_count(gb) - start_pos;
339  if (parsed_bits > ext_block_length * 8)
340  return AVERROR_INVALIDDATA;
341  skip_bits(gb, ext_block_length * 8 - parsed_bits);
342  }
343 
344  return 0;
345 }
346 
347 int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
348  int err_recognition)
349 {
350  AVDOVIRpuDataHeader *hdr = &s->header;
351  GetBitContext *gb = &(GetBitContext){0};
352  int ret;
353 
354  uint8_t rpu_type;
355  uint8_t vdr_seq_info_present;
356  uint8_t vdr_dm_metadata_present;
357  uint8_t dm_compression = 0;
358  uint8_t use_prev_vdr_rpu;
359  uint8_t use_nlq;
360  uint8_t profile;
361  uint8_t compression = s->cfg.dv_profile ? s->cfg.dv_md_compression : 0;
362 
363  if (rpu_size < 5)
364  return AVERROR_INVALIDDATA;
365 
366  /* Container */
367  if (s->cfg.dv_profile == 10 /* dav1.10 */) {
368  /* DV inside AV1 reuses an EMDF container skeleton, but with fixed
369  * values - so we can effectively treat this as a magic byte sequence.
370  *
371  * The exact fields are, as follows:
372  * emdf_version : f(2) = 0
373  * key_id : f(3) = 6
374  * emdf_payload_id : f(5) = 31
375  * emdf_payload_id_ext : var(5) = 225
376  * smploffste : f(1) = 0
377  * duratione : f(1) = 0
378  * groupide : f(1) = 0
379  * codecdatae : f(1) = 0
380  * discard_unknown_payload : f(1) = 1
381  */
382  const unsigned header_magic = 0x01be6841u;
383  unsigned emdf_header, emdf_payload_size, emdf_protection;
384  if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
385  return ret;
386  emdf_header = get_bits_long(gb, 27);
387  VALIDATE(emdf_header, header_magic, header_magic);
388  emdf_payload_size = get_variable_bits(gb, 8);
389  VALIDATE(emdf_payload_size, 6, 512);
390  if (emdf_payload_size * 8 > get_bits_left(gb))
391  return AVERROR_INVALIDDATA;
392 
393  /* The payload is not byte-aligned (off by *one* bit, curse Dolby),
394  * so copy into a fresh buffer to preserve byte alignment of the
395  * RPU struct */
396  av_fast_padded_malloc(&s->rpu_buf, &s->rpu_buf_sz, emdf_payload_size);
397  if (!s->rpu_buf)
398  return AVERROR(ENOMEM);
399  for (int i = 0; i < emdf_payload_size; i++)
400  s->rpu_buf[i] = get_bits(gb, 8);
401  rpu = s->rpu_buf;
402  rpu_size = emdf_payload_size;
403 
404  /* Validate EMDF footer */
405  emdf_protection = get_bits(gb, 5 + 12);
406  VALIDATE(emdf_protection, 0x400, 0x400);
407  } else {
408  /* NAL unit with prefix and trailing zeroes */
409  VALIDATE(rpu[0], 25, 25); /* NAL prefix */
410  rpu++;
411  rpu_size--;
412  }
413 
414  if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
415  return ret;
416 
417  /* RPU header */
418  rpu_type = get_bits(gb, 6);
419  if (rpu_type != 2) {
420  av_log(s->logctx, AV_LOG_WARNING, "Unrecognized RPU type "
421  "%"PRIu8", ignoring\n", rpu_type);
422  return 0;
423  }
424 
425  hdr->rpu_type = rpu_type;
426  hdr->rpu_format = get_bits(gb, 11);
427 
428  /* Values specific to RPU type 2 */
429  hdr->vdr_rpu_profile = get_bits(gb, 4);
430  hdr->vdr_rpu_level = get_bits(gb, 4);
431 
432  vdr_seq_info_present = get_bits1(gb);
433  if (vdr_seq_info_present) {
434  hdr->chroma_resampling_explicit_filter_flag = get_bits1(gb);
435  hdr->coef_data_type = get_bits(gb, 2);
436  VALIDATE(hdr->coef_data_type, RPU_COEFF_FIXED, RPU_COEFF_FLOAT);
437  switch (hdr->coef_data_type) {
438  case RPU_COEFF_FIXED:
439  hdr->coef_log2_denom = get_ue_golomb(gb);
440  VALIDATE(hdr->coef_log2_denom, 13, 32);
441  break;
442  case RPU_COEFF_FLOAT:
443  hdr->coef_log2_denom = 32; /* arbitrary, choose maximum precision */
444  break;
445  }
446 
447  hdr->vdr_rpu_normalized_idc = get_bits(gb, 2);
448  hdr->bl_video_full_range_flag = get_bits1(gb);
449 
450  if ((hdr->rpu_format & 0x700) == 0) {
451  int bl_bit_depth_minus8 = get_ue_golomb_31(gb);
452  int el_bit_depth_minus8 = get_ue_golomb_long(gb);
453  int vdr_bit_depth_minus8 = get_ue_golomb_31(gb);
454  /* ext_mapping_idc is in the upper 8 bits of el_bit_depth_minus8 */
455  int ext_mapping_idc = el_bit_depth_minus8 >> 8;
456  el_bit_depth_minus8 = el_bit_depth_minus8 & 0xFF;
457  VALIDATE(bl_bit_depth_minus8, 0, 8);
458  VALIDATE(el_bit_depth_minus8, 0, 8);
459  VALIDATE(ext_mapping_idc, 0, 0xFF);
460  VALIDATE(vdr_bit_depth_minus8, 0, 8);
461  hdr->bl_bit_depth = bl_bit_depth_minus8 + 8;
462  hdr->el_bit_depth = el_bit_depth_minus8 + 8;
463  hdr->ext_mapping_idc_0_4 = ext_mapping_idc & 0x1f; /* 5 bits */
464  hdr->ext_mapping_idc_5_7 = ext_mapping_idc >> 5;
465  hdr->vdr_bit_depth = vdr_bit_depth_minus8 + 8;
466  hdr->spatial_resampling_filter_flag = get_bits1(gb);
467  dm_compression = get_bits(gb, 3);
468  hdr->el_spatial_resampling_filter_flag = get_bits1(gb);
469  hdr->disable_residual_flag = get_bits1(gb);
470  } else {
471  avpriv_request_sample(s->logctx, "Unsupported RPU format 0x%x\n", hdr->rpu_format);
472  ff_dovi_ctx_unref(s);
473  return AVERROR_PATCHWELCOME;
474  }
475  } else {
476  /* lack of documentation/samples */
477  avpriv_request_sample(s->logctx, "Missing RPU VDR sequence info\n");
478  ff_dovi_ctx_unref(s);
479  return AVERROR_PATCHWELCOME;
480  }
481 
482  vdr_dm_metadata_present = get_bits1(gb);
483  if (dm_compression > 1) {
484  /* It seems no device supports this */
485  av_log(s->logctx, AV_LOG_ERROR, "Dynamic metadata compression is not "
486  "yet implemented");
487  return AVERROR_PATCHWELCOME;
488  } else if (dm_compression && !vdr_dm_metadata_present) {
489  av_log(s->logctx, AV_LOG_ERROR, "Nonzero DM metadata compression method "
490  "but no DM metadata present");
491  return AVERROR_INVALIDDATA;
492  }
493 
494  use_prev_vdr_rpu = get_bits1(gb);
495  use_nlq = (hdr->rpu_format & 0x700) == 0 && !hdr->disable_residual_flag;
496 
497  profile = s->cfg.dv_profile ? s->cfg.dv_profile : ff_dovi_guess_profile_hevc(hdr);
498  if (profile == 5 && use_nlq) {
499  av_log(s->logctx, AV_LOG_ERROR, "Profile 5 RPUs should not use NLQ\n");
500  ff_dovi_ctx_unref(s);
501  return AVERROR_INVALIDDATA;
502  }
503 
504  if (err_recognition & (AV_EF_COMPLIANT | AV_EF_CAREFUL)) {
505  if (profile < 8 && compression) {
506  av_log(s->logctx, AV_LOG_ERROR, "Profile %d RPUs should not use "
507  "metadata compression.", profile);
508  return AVERROR_INVALIDDATA;
509  }
510 
511  if (use_prev_vdr_rpu && !compression) {
512  av_log(s->logctx, AV_LOG_ERROR, "Uncompressed RPUs should not have "
513  "use_prev_vdr_rpu=1\n");
514  return AVERROR_INVALIDDATA;
515  }
516 
517  if (dm_compression && !compression) {
518  av_log(s->logctx, AV_LOG_ERROR, "Uncompressed RPUs should not use "
519  "dm_compression=%d\n", dm_compression);
520  return AVERROR_INVALIDDATA;
521  }
522  }
523 
524  if (use_prev_vdr_rpu) {
525  int prev_vdr_rpu_id = get_ue_golomb_31(gb);
526  VALIDATE(prev_vdr_rpu_id, 0, DOVI_MAX_DM_ID);
527  if (!s->vdr[prev_vdr_rpu_id])
528  prev_vdr_rpu_id = 0;
529  if (!s->vdr[prev_vdr_rpu_id]) {
530  /* FIXME: Technically, the spec says that in this case we should
531  * synthesize "neutral" vdr metadata, but easier to just error
532  * out as this corner case is not hit in practice */
533  av_log(s->logctx, AV_LOG_ERROR, "Unknown previous RPU ID: %u\n",
534  prev_vdr_rpu_id);
535  ff_dovi_ctx_unref(s);
536  return AVERROR_INVALIDDATA;
537  }
538  s->mapping = s->vdr[prev_vdr_rpu_id];
539  } else {
540  AVDOVIDataMapping *mapping;
541  int vdr_rpu_id = get_ue_golomb_31(gb);
542  VALIDATE(vdr_rpu_id, 0, DOVI_MAX_DM_ID);
543  if (!s->vdr[vdr_rpu_id]) {
544  s->vdr[vdr_rpu_id] = av_refstruct_allocz(sizeof(AVDOVIDataMapping));
545  if (!s->vdr[vdr_rpu_id]) {
546  ff_dovi_ctx_unref(s);
547  return AVERROR(ENOMEM);
548  }
549  }
550 
551  s->mapping = mapping = s->vdr[vdr_rpu_id];
552  mapping->vdr_rpu_id = vdr_rpu_id;
553  mapping->mapping_color_space = get_ue_golomb_31(gb);
554  mapping->mapping_chroma_format_idc = get_ue_golomb_31(gb);
555 
556  for (int c = 0; c < 3; c++) {
557  AVDOVIReshapingCurve *curve = &mapping->curves[c];
558  int num_pivots_minus_2 = get_ue_golomb_31(gb);
559  int pivot = 0;
560 
561  VALIDATE(num_pivots_minus_2, 0, AV_DOVI_MAX_PIECES - 1);
562  curve->num_pivots = num_pivots_minus_2 + 2;
563  for (int i = 0; i < curve->num_pivots; i++) {
564  pivot += get_bits(gb, hdr->bl_bit_depth);
565  curve->pivots[i] = av_clip_uint16(pivot);
566  }
567  }
568 
569  if (use_nlq) {
570  int nlq_pivot = 0;
571  mapping->nlq_method_idc = get_bits(gb, 3);
572 
573  for (int i = 0; i < 2; i++) {
574  nlq_pivot += get_bits(gb, hdr->bl_bit_depth);
575  mapping->nlq_pivots[i] = av_clip_uint16(nlq_pivot);
576  }
577 
578  /**
579  * The patent mentions another legal value, NLQ_MU_LAW, but it's
580  * not documented anywhere how to parse or apply that type of NLQ.
581  */
582  VALIDATE(mapping->nlq_method_idc, 0, AV_DOVI_NLQ_LINEAR_DZ);
583  } else {
584  mapping->nlq_method_idc = AV_DOVI_NLQ_NONE;
585  }
586 
587  mapping->num_x_partitions = get_ue_golomb_long(gb) + 1;
588  mapping->num_y_partitions = get_ue_golomb_long(gb) + 1;
589  /* End of rpu_data_header(), start of vdr_rpu_data_payload() */
590 
591  for (int c = 0; c < 3; c++) {
592  AVDOVIReshapingCurve *curve = &mapping->curves[c];
593  for (int i = 0; i < curve->num_pivots - 1; i++) {
594  int mapping_idc = get_ue_golomb_31(gb);
595  VALIDATE(mapping_idc, 0, 1);
596  curve->mapping_idc[i] = mapping_idc;
597  switch (mapping_idc) {
598  case AV_DOVI_MAPPING_POLYNOMIAL: {
599  int poly_order_minus1 = get_ue_golomb_31(gb);
600  VALIDATE(poly_order_minus1, 0, 1);
601  curve->poly_order[i] = poly_order_minus1 + 1;
602  if (poly_order_minus1 == 0) {
603  int linear_interp_flag = get_bits1(gb);
604  if (linear_interp_flag) {
605  /* lack of documentation/samples */
606  avpriv_request_sample(s->logctx, "Dolby Vision "
607  "linear interpolation");
608  ff_dovi_ctx_unref(s);
609  return AVERROR_PATCHWELCOME;
610  }
611  }
612  for (int k = 0; k <= curve->poly_order[i]; k++)
613  curve->poly_coef[i][k] = get_se_coef(gb, hdr);
614  break;
615  }
616  case AV_DOVI_MAPPING_MMR: {
617  int mmr_order_minus1 = get_bits(gb, 2);
618  VALIDATE(mmr_order_minus1, 0, 2);
619  curve->mmr_order[i] = mmr_order_minus1 + 1;
620  curve->mmr_constant[i] = get_se_coef(gb, hdr);
621  for (int j = 0; j < curve->mmr_order[i]; j++) {
622  for (int k = 0; k < 7; k++)
623  curve->mmr_coef[i][j][k] = get_se_coef(gb, hdr);
624  }
625  break;
626  }
627  }
628  }
629  }
630 
631  if (use_nlq) {
632  for (int c = 0; c < 3; c++) {
633  AVDOVINLQParams *nlq = &mapping->nlq[c];
634  nlq->nlq_offset = get_bits(gb, hdr->el_bit_depth);
635  nlq->vdr_in_max = get_ue_coef(gb, hdr);
636  switch (mapping->nlq_method_idc) {
637  case AV_DOVI_NLQ_LINEAR_DZ:
638  nlq->linear_deadzone_slope = get_ue_coef(gb, hdr);
639  nlq->linear_deadzone_threshold = get_ue_coef(gb, hdr);
640  break;
641  }
642  }
643  }
644  }
645 
646  if (vdr_dm_metadata_present) {
647  AVDOVIColorMetadata *color;
648  int affected_dm_id = get_ue_golomb_31(gb);
649  int current_dm_id = get_ue_golomb_31(gb);
650  VALIDATE(affected_dm_id, 0, DOVI_MAX_DM_ID);
651  VALIDATE(current_dm_id, 0, DOVI_MAX_DM_ID);
652  if (affected_dm_id != current_dm_id) {
653  /* The spec does not explain these fields at all, and there is
654  * a lack of samples to understand how they're supposed to work,
655  * so just assert them being equal for now */
656  avpriv_request_sample(s->logctx, "affected/current_dm_metadata_id "
657  "mismatch? %u != %u\n", affected_dm_id, current_dm_id);
658  ff_dovi_ctx_unref(s);
659  return AVERROR_PATCHWELCOME;
660  }
661 
662  if (!s->dm) {
663  s->dm = av_refstruct_allocz(sizeof(AVDOVIColorMetadata));
664  if (!s->dm) {
665  ff_dovi_ctx_unref(s);
666  return AVERROR(ENOMEM);
667  }
668  }
669 
670  s->color = color = s->dm;
671  color->dm_metadata_id = affected_dm_id;
672  color->scene_refresh_flag = get_ue_golomb_31(gb);
673  if (!dm_compression) {
674  for (int i = 0; i < 9; i++)
675  color->ycc_to_rgb_matrix[i] = av_make_q(get_sbits(gb, 16), 1 << 13);
676  for (int i = 0; i < 3; i++) {
677  int denom = profile == 4 ? (1 << 30) : (1 << 28);
678  unsigned offset = get_bits_long(gb, 32);
679  if (offset > INT_MAX) {
680  /* Ensure the result fits inside AVRational */
681  offset >>= 1;
682  denom >>= 1;
683  }
684  color->ycc_to_rgb_offset[i] = av_make_q(offset, denom);
685  }
686  for (int i = 0; i < 9; i++)
687  color->rgb_to_lms_matrix[i] = av_make_q(get_sbits(gb, 16), 1 << 14);
688 
689  color->signal_eotf = get_bits(gb, 16);
690  color->signal_eotf_param0 = get_bits(gb, 16);
691  color->signal_eotf_param1 = get_bits(gb, 16);
692  color->signal_eotf_param2 = get_bits_long(gb, 32);
693  color->signal_bit_depth = get_bits(gb, 5);
694  VALIDATE(color->signal_bit_depth, 8, 16);
695  color->signal_color_space = get_bits(gb, 2);
696  color->signal_chroma_format = get_bits(gb, 2);
697  color->signal_full_range_flag = get_bits(gb, 2);
698  color->source_min_pq = get_bits(gb, 12);
699  color->source_max_pq = get_bits(gb, 12);
700  color->source_diagonal = get_bits(gb, 10);
701  }
702 
703  /* Parse extension blocks */
704  if (s->ext_blocks) {
705  DOVIExt *ext = s->ext_blocks;
706  if (!dm_compression)
707  ext->num_static = 0;
708  ext->num_dynamic = 0;
709  }
710  if ((ret = parse_ext_blocks(s, gb, 1, dm_compression, err_recognition)) < 0) {
711  ff_dovi_ctx_unref(s);
712  return ret;
713  }
714 
715  if (get_bits_left(gb) > 48 /* padding + CRC32 + terminator */) {
716  if ((ret = parse_ext_blocks(s, gb, 2, dm_compression, err_recognition)) < 0) {
717  ff_dovi_ctx_unref(s);
718  return ret;
719  }
720  }
721  } else {
722  s->color = &ff_dovi_color_default;
723  av_refstruct_unref(&s->ext_blocks);
724  }
725 
726  align_get_bits(gb);
727  skip_bits(gb, 32); /* CRC32 */
728  if (get_bits(gb, 8) != 0x80) {
729  avpriv_request_sample(s->logctx, "Unexpected RPU format");
730  ff_dovi_ctx_unref(s);
731  return AVERROR_PATCHWELCOME;
732  }
733 
734  if (err_recognition & AV_EF_CRCCHECK) {
735  rpu_size = get_bits_count(gb) / 8;
736  uint32_t crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE),
737  -1, rpu, rpu_size - 1)); /* exclude 0x80 */
738  if (crc) {
739  av_log(s->logctx, AV_LOG_ERROR, "RPU CRC mismatch: %X\n", crc);
740  if (err_recognition & AV_EF_EXPLODE) {
741  ff_dovi_ctx_unref(s);
742  return AVERROR_INVALIDDATA;
743  }
744  }
745  }
746 
747  return 0;
748 }
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
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
level
uint8_t level
Definition: svq3.c:208
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
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
AV_EF_CAREFUL
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
Definition: defs.h:54
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:689
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
ff_dovi_ctx_unref
void ff_dovi_ctx_unref(DOVIContext *s)
Completely reset a DOVIContext, preserving only logctx.
Definition: dovi_rpu.c:29
AVDOVIDmLevel8::trim_offset
uint16_t trim_offset
Definition: dovi_meta.h:252
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: defs.h:55
AVColorPrimariesDesc::wp
AVWhitepointCoefficients wp
Definition: csp.h:79
DOVI_MAX_DM_ID
#define DOVI_MAX_DM_ID
Definition: dovi_rpu.h:33
color
Definition: vf_paletteuse.c:513
get_se_golomb_long
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:419
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
int64_t
long long int64_t
Definition: coverity.c:34
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
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:250
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
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
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
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:83
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
AVDOVIReshapingCurve::mmr_coef
int64_t mmr_coef[AV_DOVI_MAX_PIECES][3][7]
Definition: dovi_meta.h:127
ff_dovi_get_metadata
int ff_dovi_get_metadata(DOVIContext *s, AVDOVIMetadata **out_metadata)
Get the decoded AVDOVIMetadata.
Definition: dovi_rpudec.c:33
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
AVDOVIReshapingCurve::mapping_idc
enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:120
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
AVDOVIRpuDataHeader::rpu_format
uint16_t rpu_format
Definition: dovi_meta.h:89
parse_ext_blocks
static int parse_ext_blocks(DOVIContext *s, GetBitContext *gb, int ver, int compression, int err_recognition)
Definition: dovi_rpudec.c:282
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
parse_ext_v2
static int parse_ext_v2(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm, int ext_block_length)
Definition: dovi_rpudec.c:206
AVDOVIDmLevel8::hue_vector_field
uint8_t hue_vector_field[6]
Definition: dovi_meta.h:260
AVDOVIRpuDataHeader::coef_data_type
uint8_t coef_data_type
Definition: dovi_meta.h:93
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:379
DOVIExt::num_dynamic
int num_dynamic
Definition: dovi_rpu.h:39
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:333
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
AVDOVIRpuDataHeader::el_bit_depth
uint8_t el_bit_depth
Definition: dovi_meta.h:98
dummy
int dummy
Definition: motion.c:66
GetBitContext
Definition: get_bits.h:109
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
AVDOVIDmLevel2::ms_weight
int16_t ms_weight
Definition: dovi_meta.h:218
refstruct.h
AVDOVIRpuDataHeader::vdr_rpu_normalized_idc
uint8_t vdr_rpu_normalized_idc
Definition: dovi_meta.h:95
AVDOVIRpuDataHeader::el_spatial_resampling_filter_flag
uint8_t el_spatial_resampling_filter_flag
Definition: dovi_meta.h:101
av_refstruct_allocz
static void * av_refstruct_allocz(size_t size)
Equivalent to av_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
AVDOVIDmLevel8::clip_trim
uint16_t clip_trim
Definition: dovi_meta.h:258
AVDOVIDmLevel3::avg_pq_offset
uint16_t avg_pq_offset
Definition: dovi_meta.h:224
AVDOVIDmData
Dolby Vision metadata extension block.
Definition: dovi_meta.h:310
ff_dovi_rpu_parse
int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size, int err_recognition)
Parse the contents of a Dolby Vision RPU and update the parsed values in the DOVIContext struct.
Definition: dovi_rpudec.c:347
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
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
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:539
AVDOVIDmLevel6::max_cll
uint16_t max_cll
Definition: dovi_meta.h:244
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
AVDOVIRpuDataHeader::spatial_resampling_filter_flag
uint8_t spatial_resampling_filter_flag
Definition: dovi_meta.h:100
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
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:318
get_bits.h
RPU_COEFF_FLOAT
@ RPU_COEFF_FLOAT
Definition: dovi_rpu.h:186
AV_DOVI_MAPPING_POLYNOMIAL
@ AV_DOVI_MAPPING_POLYNOMIAL
Definition: dovi_meta.h:108
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
get_se_coef
static int64_t get_se_coef(GetBitContext *gb, const AVDOVIRpuDataHeader *hdr)
Definition: dovi_rpudec.c:109
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
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
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:386
AVDOVIDmData::l9
AVDOVIDmLevel9 l9
Definition: dovi_meta.h:321
av_frame_new_side_data_from_buf
AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)
Add a new side data to a frame from an existing AVBufferRef.
Definition: frame.c:636
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
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: defs.h:48
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
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AVDOVIDmLevel2::target_max_pq
uint16_t target_max_pq
Definition: dovi_meta.h:212
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
AVPrimaryCoefficients::b
AVCIExy b
Definition: csp.h:65
AVDOVIDmLevel6::max_fall
uint16_t max_fall
Definition: dovi_meta.h:245
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
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
AVDOVIRpuDataHeader::vdr_rpu_profile
uint8_t vdr_rpu_profile
Definition: dovi_meta.h:90
av_bswap32
#define av_bswap32
Definition: bswap.h:47
AVDOVIDmLevel2::trim_saturation_gain
uint16_t trim_saturation_gain
Definition: dovi_meta.h:217
DOVIExt
Definition: dovi_rpu.h:35
size
int size
Definition: twinvq_data.h:10344
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:97
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
av_dovi_metadata_alloc
AVDOVIMetadata * av_dovi_metadata_alloc(size_t *size)
Allocate an AVDOVIMetadata structure and initialize its fields to default values.
Definition: dovi_meta.c:47
AVDOVIDmLevel1::min_pq
uint16_t min_pq
Definition: dovi_meta.h:205
ff_dovi_attach_side_data
int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
Attach the decoded AVDOVIMetadata as side data to an AVFrame.
Definition: dovi_rpudec.c:64
AVPrimaryCoefficients::g
AVCIExy g
Definition: csp.h:65
AVDOVIDmLevel11::content_type
uint8_t content_type
Definition: dovi_meta.h:279
AVDOVIDmData::l10
AVDOVIDmLevel10 l10
Definition: dovi_meta.h:322
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
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVDOVIDmLevel10::target_max_pq
uint16_t target_max_pq
Definition: dovi_meta.h:272
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:53
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
get_cie_xy
static AVCIExy get_cie_xy(GetBitContext *gb)
Definition: dovi_rpudec.c:197
profile
int profile
Definition: mxfenc.c:2276
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
AVDOVIDmData::l4
AVDOVIDmLevel4 l4
Definition: dovi_meta.h:316
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
AVDOVIReshapingCurve
Definition: dovi_meta.h:117
ret
ret
Definition: filter_design.txt:187
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder/muxer should not do as an error
Definition: defs.h:56
AVDOVIDmLevel11::mpeg_noise_reduction
uint8_t mpeg_noise_reduction
Definition: dovi_meta.h:284
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:265
AVDOVIDmLevel11::sharpness
uint8_t sharpness
Definition: dovi_meta.h:282
AVDOVINLQParams::vdr_in_max
uint64_t vdr_in_max
Definition: dovi_meta.h:141
AVCIExy::y
AVRational y
Definition: csp.h:57
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:555
parse_ext_v1
static int parse_ext_v1(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm)
Definition: dovi_rpudec.c:150
COPY
#define COPY(t, a, b, last)
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
get_ue_coef
static uint64_t get_ue_coef(GetBitContext *gb, const AVDOVIRpuDataHeader *hdr)
Definition: dovi_rpudec.c:90
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
AVDOVIDmLevel5::left_offset
uint16_t left_offset
Definition: dovi_meta.h:234
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
AVDOVIDmData::l5
AVDOVIDmLevel5 l5
Definition: dovi_meta.h:317
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
AVDOVIDmLevel1::avg_pq
uint16_t avg_pq
Definition: dovi_meta.h:207
RPU_COEFF_FIXED
@ RPU_COEFF_FIXED
Definition: dovi_rpu.h:185
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:197
VALIDATE
#define VALIDATE(VAR, MIN, MAX)
Definition: dovi_rpudec.c:140
AVDOVIColorMetadata
Dolby Vision RPU colorspace metadata parameters.
Definition: dovi_meta.h:171
AVDOVIDmData::level
uint8_t level
Definition: dovi_meta.h:311
av_clip_uint16
#define av_clip_uint16
Definition: common.h:112
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
get_variable_bits
static unsigned get_variable_bits(GetBitContext *gb, int n)
Definition: dovi_rpudec.c:128
AVDOVIDmLevel11::whitepoint
uint8_t whitepoint
Definition: dovi_meta.h:280
AVDOVIDmLevel254::dm_mode
uint8_t dm_mode
Definition: dovi_meta.h:292
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVDOVIRpuDataHeader::ext_mapping_idc_5_7
uint8_t ext_mapping_idc_5_7
Definition: dovi_meta.h:104
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
av_dovi_get_mapping
static av_always_inline AVDOVIDataMapping * av_dovi_get_mapping(const AVDOVIMetadata *data)
Definition: dovi_meta.h:361
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:276
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDOVIReshapingCurve::pivots
uint16_t pivots[AV_DOVI_MAX_PIECES+1]
Definition: dovi_meta.h:119
AVColorPrimariesDesc::prim
AVPrimaryCoefficients prim
Definition: csp.h:80
AVDOVINLQParams::nlq_offset
uint16_t nlq_offset
Definition: dovi_meta.h:140
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
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:162
AVDOVIDataMapping
Dolby Vision RPU data mapping parameters.
Definition: dovi_meta.h:152
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:383
AV_DOVI_MAX_PIECES
#define AV_DOVI_MAX_PIECES
Coefficients of a piece-wise function.
Definition: dovi_meta.h:116
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
AVDOVIMetadata::num_ext_blocks
int num_ext_blocks
Definition: dovi_meta.h:348
Generated on Sun Aug 3 2025 19:21:56 for FFmpeg by   doxygen 1.8.17