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  av_log(s->logctx, AV_LOG_WARNING,
192  "Unknown Dolby Vision DM v1 level: %u\n", dm->level);
193  }
194 
195  return 0;
196 }
197 
198 static AVCIExy get_cie_xy(GetBitContext *gb)
199 {
200  AVCIExy xy;
201  const int denom = 32767;
202  xy.x = av_make_q(get_sbits(gb, 16), denom);
203  xy.y = av_make_q(get_sbits(gb, 16), denom);
204  return xy;
205 }
206 
207 static int parse_ext_v2(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm,
208  int ext_block_length)
209 {
210  switch (dm->level) {
211  case 3:
212  dm->l3.min_pq_offset = get_bits(gb, 12);
213  dm->l3.max_pq_offset = get_bits(gb, 12);
214  dm->l3.avg_pq_offset = get_bits(gb, 12);
215  break;
216  case 8:
217  dm->l8.target_display_index = get_bits(gb, 8);
218  dm->l8.trim_slope = get_bits(gb, 12);
219  dm->l8.trim_offset = get_bits(gb, 12);
220  dm->l8.trim_power = get_bits(gb, 12);
221  dm->l8.trim_chroma_weight = get_bits(gb, 12);
222  dm->l8.trim_saturation_gain = get_bits(gb, 12);
223  dm->l8.ms_weight = get_bits(gb, 12);
224  if (ext_block_length < 12)
225  break;
226  dm->l8.target_mid_contrast = get_bits(gb, 12);
227  if (ext_block_length < 13)
228  break;
229  dm->l8.clip_trim = get_bits(gb, 12);
230  if (ext_block_length < 19)
231  break;
232  for (int i = 0; i < 6; i++)
233  dm->l8.saturation_vector_field[i] = get_bits(gb, 8);
234  if (ext_block_length < 25)
235  break;
236  for (int i = 0; i < 6; i++)
237  dm->l8.hue_vector_field[i] = get_bits(gb, 8);
238  break;
239  case 9:
240  dm->l9.source_primary_index = get_bits(gb, 8);
241  if (ext_block_length < 17)
242  break;
243  dm->l9.source_display_primaries.prim.r = get_cie_xy(gb);
244  dm->l9.source_display_primaries.prim.g = get_cie_xy(gb);
245  dm->l9.source_display_primaries.prim.b = get_cie_xy(gb);
246  dm->l9.source_display_primaries.wp = get_cie_xy(gb);
247  break;
248  case 10:
249  dm->l10.target_display_index = get_bits(gb, 8);
250  dm->l10.target_max_pq = get_bits(gb, 12);
251  dm->l10.target_min_pq = get_bits(gb, 12);
252  dm->l10.target_primary_index = get_bits(gb, 8);
253  if (ext_block_length < 21)
254  break;
255  dm->l10.target_display_primaries.prim.r = get_cie_xy(gb);
256  dm->l10.target_display_primaries.prim.g = get_cie_xy(gb);
257  dm->l10.target_display_primaries.prim.b = get_cie_xy(gb);
258  dm->l10.target_display_primaries.wp = get_cie_xy(gb);
259  break;
260  case 11:
261  dm->l11.content_type = get_bits(gb, 8);
262  dm->l11.whitepoint = get_bits(gb, 4);
263  dm->l11.reference_mode_flag = get_bits1(gb);
264  skip_bits(gb, 3); /* reserved */
265  dm->l11.sharpness = get_bits(gb, 2);
266  dm->l11.noise_reduction = get_bits(gb, 2);
267  dm->l11.mpeg_noise_reduction = get_bits(gb, 2);
268  dm->l11.frame_rate_conversion = get_bits(gb, 2);
269  dm->l11.brightness = get_bits(gb, 2);
270  dm->l11.color = get_bits(gb, 2);
271  break;
272  case 254:
273  dm->l254.dm_mode = get_bits(gb, 8);
274  dm->l254.dm_version_index = get_bits(gb, 8);
275  break;
276  default:
277  av_log(s->logctx, AV_LOG_WARNING,
278  "Unknown Dolby Vision DM v2 level: %u\n", dm->level);
279  }
280 
281  return 0;
282 }
283 
284 static int parse_ext_blocks(DOVIContext *s, GetBitContext *gb, int ver,
285  int compression, int err_recognition)
286 {
287  int num_ext_blocks, ext_block_length, start_pos, parsed_bits, ret;
288  DOVIExt *ext = s->ext_blocks;
289 
290  num_ext_blocks = get_ue_golomb_31(gb);
291  align_get_bits(gb);
292 
293  if (num_ext_blocks && !ext) {
294  ext = s->ext_blocks = av_refstruct_allocz(sizeof(*s->ext_blocks));
295  if (!ext)
296  return AVERROR(ENOMEM);
297  }
298 
299  while (num_ext_blocks--) {
300  AVDOVIDmData dummy;
301  AVDOVIDmData *dm;
302  uint8_t level;
303 
304  ext_block_length = get_ue_golomb_31(gb);
305  level = get_bits(gb, 8);
306  start_pos = get_bits_count(gb);
307 
308  if (ff_dovi_rpu_extension_is_static(level)) {
309  if (compression) {
310  av_log(s->logctx, AV_LOG_WARNING, "Compressed DM RPU contains "
311  "static extension block level %d\n", level);
312  if (err_recognition & (AV_EF_AGGRESSIVE | AV_EF_EXPLODE))
313  return AVERROR_INVALIDDATA;
314  dm = &dummy;
315  } else {
316  if (ext->num_static >= FF_ARRAY_ELEMS(ext->dm_static))
317  return AVERROR_INVALIDDATA;
318  dm = &ext->dm_static[ext->num_static++];
319  }
320  } else {
321  if (ext->num_dynamic >= FF_ARRAY_ELEMS(ext->dm_dynamic))
322  return AVERROR_INVALIDDATA;
323  dm = &ext->dm_dynamic[ext->num_dynamic++];
324  }
325 
326  memset(dm, 0, sizeof(*dm));
327  dm->level = level;
328  switch (ver) {
329  case 1: ret = parse_ext_v1(s, gb, dm); break;
330  case 2: ret = parse_ext_v2(s, gb, dm, ext_block_length); break;
331  default: return AVERROR_BUG;
332  }
333 
334  if (ret < 0)
335  return ret;
336 
337  parsed_bits = get_bits_count(gb) - start_pos;
338  if (parsed_bits > ext_block_length * 8)
339  return AVERROR_INVALIDDATA;
340  skip_bits(gb, ext_block_length * 8 - parsed_bits);
341  }
342 
343  return 0;
344 }
345 
346 int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
347  int err_recognition)
348 {
349  AVDOVIRpuDataHeader *hdr = &s->header;
350  GetBitContext *gb = &(GetBitContext){0};
351  int ret;
352 
353  uint8_t rpu_type;
354  uint8_t vdr_seq_info_present;
355  uint8_t vdr_dm_metadata_present;
356  uint8_t dm_compression = 0;
357  uint8_t use_prev_vdr_rpu;
358  uint8_t use_nlq;
359  uint8_t profile;
360  uint8_t compression = s->cfg.dv_profile ? s->cfg.dv_md_compression : 0;
361 
362  if (rpu_size < 5)
363  return AVERROR_INVALIDDATA;
364 
365  /* Container */
366  if (s->cfg.dv_profile == 10 /* dav1.10 */) {
367  /* DV inside AV1 re-uses an EMDF container skeleton, but with fixed
368  * values - so we can effectively treat this as a magic byte sequence.
369  *
370  * The exact fields are, as follows:
371  * emdf_version : f(2) = 0
372  * key_id : f(3) = 6
373  * emdf_payload_id : f(5) = 31
374  * emdf_payload_id_ext : var(5) = 225
375  * smploffste : f(1) = 0
376  * duratione : f(1) = 0
377  * groupide : f(1) = 0
378  * codecdatae : f(1) = 0
379  * discard_unknown_payload : f(1) = 1
380  */
381  const unsigned header_magic = 0x01be6841u;
382  unsigned emdf_header, emdf_payload_size, emdf_protection;
383  if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
384  return ret;
385  emdf_header = get_bits_long(gb, 27);
386  VALIDATE(emdf_header, header_magic, header_magic);
387  emdf_payload_size = get_variable_bits(gb, 8);
388  VALIDATE(emdf_payload_size, 6, 512);
389  if (emdf_payload_size * 8 > get_bits_left(gb))
390  return AVERROR_INVALIDDATA;
391 
392  /* The payload is not byte-aligned (off by *one* bit, curse Dolby),
393  * so copy into a fresh buffer to preserve byte alignment of the
394  * RPU struct */
395  av_fast_padded_malloc(&s->rpu_buf, &s->rpu_buf_sz, emdf_payload_size);
396  if (!s->rpu_buf)
397  return AVERROR(ENOMEM);
398  for (int i = 0; i < emdf_payload_size; i++)
399  s->rpu_buf[i] = get_bits(gb, 8);
400  rpu = s->rpu_buf;
401  rpu_size = emdf_payload_size;
402 
403  /* Validate EMDF footer */
404  emdf_protection = get_bits(gb, 5 + 12);
405  VALIDATE(emdf_protection, 0x400, 0x400);
406  } else {
407  /* NAL unit with prefix and trailing zeroes */
408  VALIDATE(rpu[0], 25, 25); /* NAL prefix */
409  rpu++;
410  rpu_size--;
411  /* Strip trailing padding bytes */
412  while (rpu_size && rpu[rpu_size - 1] == 0)
413  rpu_size--;
414  }
415 
416  if (!rpu_size || rpu[rpu_size - 1] != 0x80)
417  return AVERROR_INVALIDDATA;
418 
419  if (err_recognition & AV_EF_CRCCHECK) {
420  uint32_t crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE),
421  -1, rpu, rpu_size - 1)); /* exclude 0x80 */
422  if (crc) {
423  av_log(s->logctx, AV_LOG_ERROR, "RPU CRC mismatch: %X\n", crc);
424  if (err_recognition & AV_EF_EXPLODE)
425  return AVERROR_INVALIDDATA;
426  }
427  }
428 
429  if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
430  return ret;
431 
432  /* RPU header */
433  rpu_type = get_bits(gb, 6);
434  if (rpu_type != 2) {
435  av_log(s->logctx, AV_LOG_WARNING, "Unrecognized RPU type "
436  "%"PRIu8", ignoring\n", rpu_type);
437  return 0;
438  }
439 
440  hdr->rpu_type = rpu_type;
441  hdr->rpu_format = get_bits(gb, 11);
442 
443  /* Values specific to RPU type 2 */
444  hdr->vdr_rpu_profile = get_bits(gb, 4);
445  hdr->vdr_rpu_level = get_bits(gb, 4);
446 
447  vdr_seq_info_present = get_bits1(gb);
448  if (vdr_seq_info_present) {
449  hdr->chroma_resampling_explicit_filter_flag = get_bits1(gb);
450  hdr->coef_data_type = get_bits(gb, 2);
451  VALIDATE(hdr->coef_data_type, RPU_COEFF_FIXED, RPU_COEFF_FLOAT);
452  switch (hdr->coef_data_type) {
453  case RPU_COEFF_FIXED:
454  hdr->coef_log2_denom = get_ue_golomb(gb);
455  VALIDATE(hdr->coef_log2_denom, 13, 32);
456  break;
457  case RPU_COEFF_FLOAT:
458  hdr->coef_log2_denom = 32; /* arbitrary, choose maximum precision */
459  break;
460  }
461 
462  hdr->vdr_rpu_normalized_idc = get_bits(gb, 2);
463  hdr->bl_video_full_range_flag = get_bits1(gb);
464 
465  if ((hdr->rpu_format & 0x700) == 0) {
466  int bl_bit_depth_minus8 = get_ue_golomb_31(gb);
467  int el_bit_depth_minus8 = get_ue_golomb_long(gb);
468  int vdr_bit_depth_minus8 = get_ue_golomb_31(gb);
469  /* ext_mapping_idc is in the upper 8 bits of el_bit_depth_minus8 */
470  int ext_mapping_idc = el_bit_depth_minus8 >> 8;
471  el_bit_depth_minus8 = el_bit_depth_minus8 & 0xFF;
472  VALIDATE(bl_bit_depth_minus8, 0, 8);
473  VALIDATE(el_bit_depth_minus8, 0, 8);
474  VALIDATE(ext_mapping_idc, 0, 0xFF);
475  VALIDATE(vdr_bit_depth_minus8, 0, 8);
476  hdr->bl_bit_depth = bl_bit_depth_minus8 + 8;
477  hdr->el_bit_depth = el_bit_depth_minus8 + 8;
478  hdr->ext_mapping_idc_0_4 = ext_mapping_idc & 0x1f; /* 5 bits */
479  hdr->ext_mapping_idc_5_7 = ext_mapping_idc >> 5;
480  hdr->vdr_bit_depth = vdr_bit_depth_minus8 + 8;
481  hdr->spatial_resampling_filter_flag = get_bits1(gb);
482  dm_compression = get_bits(gb, 3);
483  hdr->el_spatial_resampling_filter_flag = get_bits1(gb);
484  hdr->disable_residual_flag = get_bits1(gb);
485  } else {
486  avpriv_request_sample(s->logctx, "Unsupported RPU format 0x%x\n", hdr->rpu_format);
487  ff_dovi_ctx_unref(s);
488  return AVERROR_PATCHWELCOME;
489  }
490  } else {
491  /* lack of documentation/samples */
492  avpriv_request_sample(s->logctx, "Missing RPU VDR sequence info\n");
493  ff_dovi_ctx_unref(s);
494  return AVERROR_PATCHWELCOME;
495  }
496 
497  vdr_dm_metadata_present = get_bits1(gb);
498  if (dm_compression > 1) {
499  /* It seems no device supports this */
500  av_log(s->logctx, AV_LOG_ERROR, "Dynamic metadata compression is not "
501  "yet implemented");
502  return AVERROR_PATCHWELCOME;
503  } else if (dm_compression && !vdr_dm_metadata_present) {
504  av_log(s->logctx, AV_LOG_ERROR, "Nonzero DM metadata compression method "
505  "but no DM metadata present");
506  return AVERROR_INVALIDDATA;
507  }
508 
509  use_prev_vdr_rpu = get_bits1(gb);
510  use_nlq = (hdr->rpu_format & 0x700) == 0 && !hdr->disable_residual_flag;
511 
512  profile = s->cfg.dv_profile ? s->cfg.dv_profile : ff_dovi_guess_profile_hevc(hdr);
513  if (profile == 5 && use_nlq) {
514  av_log(s->logctx, AV_LOG_ERROR, "Profile 5 RPUs should not use NLQ\n");
515  ff_dovi_ctx_unref(s);
516  return AVERROR_INVALIDDATA;
517  }
518 
519  if (err_recognition & (AV_EF_COMPLIANT | AV_EF_CAREFUL)) {
520  if (profile < 8 && compression) {
521  av_log(s->logctx, AV_LOG_ERROR, "Profile %d RPUs should not use "
522  "metadata compression.", profile);
523  return AVERROR_INVALIDDATA;
524  }
525 
526  if (use_prev_vdr_rpu && !compression) {
527  av_log(s->logctx, AV_LOG_ERROR, "Uncompressed RPUs should not have "
528  "use_prev_vdr_rpu=1\n");
529  return AVERROR_INVALIDDATA;
530  }
531 
532  if (dm_compression && !compression) {
533  av_log(s->logctx, AV_LOG_ERROR, "Uncompressed RPUs should not use "
534  "dm_compression=%d\n", dm_compression);
535  return AVERROR_INVALIDDATA;
536  }
537  }
538 
539  if (use_prev_vdr_rpu) {
540  int prev_vdr_rpu_id = get_ue_golomb_31(gb);
541  VALIDATE(prev_vdr_rpu_id, 0, DOVI_MAX_DM_ID);
542  if (!s->vdr[prev_vdr_rpu_id])
543  prev_vdr_rpu_id = 0;
544  if (!s->vdr[prev_vdr_rpu_id]) {
545  /* FIXME: Technically, the spec says that in this case we should
546  * synthesize "neutral" vdr metadata, but easier to just error
547  * out as this corner case is not hit in practice */
548  av_log(s->logctx, AV_LOG_ERROR, "Unknown previous RPU ID: %u\n",
549  prev_vdr_rpu_id);
550  ff_dovi_ctx_unref(s);
551  return AVERROR_INVALIDDATA;
552  }
553  s->mapping = s->vdr[prev_vdr_rpu_id];
554  } else {
555  AVDOVIDataMapping *mapping;
556  int vdr_rpu_id = get_ue_golomb_31(gb);
557  VALIDATE(vdr_rpu_id, 0, DOVI_MAX_DM_ID);
558  if (!s->vdr[vdr_rpu_id]) {
559  s->vdr[vdr_rpu_id] = av_refstruct_allocz(sizeof(AVDOVIDataMapping));
560  if (!s->vdr[vdr_rpu_id]) {
561  ff_dovi_ctx_unref(s);
562  return AVERROR(ENOMEM);
563  }
564  }
565 
566  s->mapping = mapping = s->vdr[vdr_rpu_id];
567  mapping->vdr_rpu_id = vdr_rpu_id;
568  mapping->mapping_color_space = get_ue_golomb_31(gb);
569  mapping->mapping_chroma_format_idc = get_ue_golomb_31(gb);
570 
571  for (int c = 0; c < 3; c++) {
572  AVDOVIReshapingCurve *curve = &mapping->curves[c];
573  int num_pivots_minus_2 = get_ue_golomb_31(gb);
574  int pivot = 0;
575 
576  VALIDATE(num_pivots_minus_2, 0, AV_DOVI_MAX_PIECES - 1);
577  curve->num_pivots = num_pivots_minus_2 + 2;
578  for (int i = 0; i < curve->num_pivots; i++) {
579  pivot += get_bits(gb, hdr->bl_bit_depth);
580  curve->pivots[i] = av_clip_uint16(pivot);
581  }
582  }
583 
584  if (use_nlq) {
585  int nlq_pivot = 0;
586  mapping->nlq_method_idc = get_bits(gb, 3);
587 
588  for (int i = 0; i < 2; i++) {
589  nlq_pivot += get_bits(gb, hdr->bl_bit_depth);
590  mapping->nlq_pivots[i] = av_clip_uint16(nlq_pivot);
591  }
592 
593  /**
594  * The patent mentions another legal value, NLQ_MU_LAW, but it's
595  * not documented anywhere how to parse or apply that type of NLQ.
596  */
597  VALIDATE(mapping->nlq_method_idc, 0, AV_DOVI_NLQ_LINEAR_DZ);
598  } else {
599  mapping->nlq_method_idc = AV_DOVI_NLQ_NONE;
600  }
601 
602  mapping->num_x_partitions = get_ue_golomb_long(gb) + 1;
603  mapping->num_y_partitions = get_ue_golomb_long(gb) + 1;
604  /* End of rpu_data_header(), start of vdr_rpu_data_payload() */
605 
606  for (int c = 0; c < 3; c++) {
607  AVDOVIReshapingCurve *curve = &mapping->curves[c];
608  for (int i = 0; i < curve->num_pivots - 1; i++) {
609  int mapping_idc = get_ue_golomb_31(gb);
610  VALIDATE(mapping_idc, 0, 1);
611  curve->mapping_idc[i] = mapping_idc;
612  switch (mapping_idc) {
613  case AV_DOVI_MAPPING_POLYNOMIAL: {
614  int poly_order_minus1 = get_ue_golomb_31(gb);
615  VALIDATE(poly_order_minus1, 0, 1);
616  curve->poly_order[i] = poly_order_minus1 + 1;
617  if (poly_order_minus1 == 0) {
618  int linear_interp_flag = get_bits1(gb);
619  if (linear_interp_flag) {
620  /* lack of documentation/samples */
621  avpriv_request_sample(s->logctx, "Dolby Vision "
622  "linear interpolation");
623  ff_dovi_ctx_unref(s);
624  return AVERROR_PATCHWELCOME;
625  }
626  }
627  for (int k = 0; k <= curve->poly_order[i]; k++)
628  curve->poly_coef[i][k] = get_se_coef(gb, hdr);
629  break;
630  }
631  case AV_DOVI_MAPPING_MMR: {
632  int mmr_order_minus1 = get_bits(gb, 2);
633  VALIDATE(mmr_order_minus1, 0, 2);
634  curve->mmr_order[i] = mmr_order_minus1 + 1;
635  curve->mmr_constant[i] = get_se_coef(gb, hdr);
636  for (int j = 0; j < curve->mmr_order[i]; j++) {
637  for (int k = 0; k < 7; k++)
638  curve->mmr_coef[i][j][k] = get_se_coef(gb, hdr);
639  }
640  break;
641  }
642  }
643  }
644  }
645 
646  if (use_nlq) {
647  for (int c = 0; c < 3; c++) {
648  AVDOVINLQParams *nlq = &mapping->nlq[c];
649  nlq->nlq_offset = get_bits(gb, hdr->el_bit_depth);
650  nlq->vdr_in_max = get_ue_coef(gb, hdr);
651  switch (mapping->nlq_method_idc) {
652  case AV_DOVI_NLQ_LINEAR_DZ:
653  nlq->linear_deadzone_slope = get_ue_coef(gb, hdr);
654  nlq->linear_deadzone_threshold = get_ue_coef(gb, hdr);
655  break;
656  }
657  }
658  }
659  }
660 
661  if (vdr_dm_metadata_present) {
662  AVDOVIColorMetadata *color;
663  int affected_dm_id = get_ue_golomb_31(gb);
664  int current_dm_id = get_ue_golomb_31(gb);
665  VALIDATE(affected_dm_id, 0, DOVI_MAX_DM_ID);
666  VALIDATE(current_dm_id, 0, DOVI_MAX_DM_ID);
667  if (affected_dm_id != current_dm_id) {
668  /* The spec does not explain these fields at all, and there is
669  * a lack of samples to understand how they're supposed to work,
670  * so just assert them being equal for now */
671  avpriv_request_sample(s->logctx, "affected/current_dm_metadata_id "
672  "mismatch? %u != %u\n", affected_dm_id, current_dm_id);
673  ff_dovi_ctx_unref(s);
674  return AVERROR_PATCHWELCOME;
675  }
676 
677  if (!s->dm) {
678  s->dm = av_refstruct_allocz(sizeof(AVDOVIColorMetadata));
679  if (!s->dm) {
680  ff_dovi_ctx_unref(s);
681  return AVERROR(ENOMEM);
682  }
683  }
684 
685  s->color = color = s->dm;
686  color->dm_metadata_id = affected_dm_id;
687  color->scene_refresh_flag = get_ue_golomb_31(gb);
688  if (!dm_compression) {
689  for (int i = 0; i < 9; i++)
690  color->ycc_to_rgb_matrix[i] = av_make_q(get_sbits(gb, 16), 1 << 13);
691  for (int i = 0; i < 3; i++) {
692  int denom = profile == 4 ? (1 << 30) : (1 << 28);
693  unsigned offset = get_bits_long(gb, 32);
694  if (offset > INT_MAX) {
695  /* Ensure the result fits inside AVRational */
696  offset >>= 1;
697  denom >>= 1;
698  }
699  color->ycc_to_rgb_offset[i] = av_make_q(offset, denom);
700  }
701  for (int i = 0; i < 9; i++)
702  color->rgb_to_lms_matrix[i] = av_make_q(get_sbits(gb, 16), 1 << 14);
703 
704  color->signal_eotf = get_bits(gb, 16);
705  color->signal_eotf_param0 = get_bits(gb, 16);
706  color->signal_eotf_param1 = get_bits(gb, 16);
707  color->signal_eotf_param2 = get_bits_long(gb, 32);
708  color->signal_bit_depth = get_bits(gb, 5);
709  VALIDATE(color->signal_bit_depth, 8, 16);
710  color->signal_color_space = get_bits(gb, 2);
711  color->signal_chroma_format = get_bits(gb, 2);
712  color->signal_full_range_flag = get_bits(gb, 2);
713  color->source_min_pq = get_bits(gb, 12);
714  color->source_max_pq = get_bits(gb, 12);
715  color->source_diagonal = get_bits(gb, 10);
716  }
717 
718  /* Parse extension blocks */
719  if (s->ext_blocks) {
720  DOVIExt *ext = s->ext_blocks;
721  if (!dm_compression)
722  ext->num_static = 0;
723  ext->num_dynamic = 0;
724  }
725  if ((ret = parse_ext_blocks(s, gb, 1, dm_compression, err_recognition)) < 0) {
726  ff_dovi_ctx_unref(s);
727  return ret;
728  }
729 
730  if (get_bits_left(gb) > 48 /* padding + CRC32 + terminator */) {
731  if ((ret = parse_ext_blocks(s, gb, 2, dm_compression, err_recognition)) < 0) {
732  ff_dovi_ctx_unref(s);
733  return ret;
734  }
735  }
736  } else {
737  s->color = &ff_dovi_color_default;
738  av_refstruct_unref(&s->ext_blocks);
739  }
740 
741  return 0;
742 }
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
level
uint8_t level
Definition: svq3.c:205
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:695
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
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
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
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:421
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:266
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:389
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
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:284
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:207
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:381
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:335
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:108
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:346
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
RPU_COEFF_FIXED
@ RPU_COEFF_FIXED
Definition: dovi_rpu.h:184
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
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:320
get_bits.h
AV_DOVI_MAPPING_POLYNOMIAL
@ AV_DOVI_MAPPING_POLYNOMIAL
Definition: dovi_meta.h:108
RPU_COEFF_FLOAT
@ RPU_COEFF_FLOAT
Definition: dovi_rpu.h:185
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:388
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:802
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: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
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:52
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:198
profile
int profile
Definition: mxfenc.c:2233
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:264
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:561
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
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
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:36
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
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
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
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:162
AVDOVIDataMapping
Dolby Vision RPU data mapping parameters.
Definition: dovi_meta.h:152
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 Fri Dec 20 2024 19:21:33 for FFmpeg by   doxygen 1.8.17