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 "refstruct.h"
32 
34 {
35  AVFrameSideData *sd;
36  AVBufferRef *buf;
37  AVDOVIMetadata *dovi;
38  size_t dovi_size, ext_sz;
39 
40  if (!s->mapping || !s->color)
41  return 0; /* incomplete dovi metadata */
42 
43  dovi = av_dovi_metadata_alloc(&dovi_size);
44  if (!dovi)
45  return AVERROR(ENOMEM);
46 
47  buf = av_buffer_create((uint8_t *) dovi, dovi_size, NULL, NULL, 0);
48  if (!buf) {
49  av_free(dovi);
50  return AVERROR(ENOMEM);
51  }
52 
54  if (!sd) {
55  av_buffer_unref(&buf);
56  return AVERROR(ENOMEM);
57  }
58 
59  /* Copy only the parts of these structs known to us at compiler-time. */
60 #define COPY(t, a, b, last) memcpy(a, b, offsetof(t, last) + sizeof((b)->last))
61  COPY(AVDOVIRpuDataHeader, av_dovi_get_header(dovi), &s->header, disable_residual_flag);
62  COPY(AVDOVIDataMapping, av_dovi_get_mapping(dovi), s->mapping, nlq_pivots);
63  COPY(AVDOVIColorMetadata, av_dovi_get_color(dovi), s->color, source_diagonal);
64  ext_sz = FFMIN(sizeof(AVDOVIDmData), dovi->ext_block_size);
65  for (int i = 0; i < s->num_ext_blocks; i++)
66  memcpy(av_dovi_get_ext(dovi, i), &s->ext_blocks[i], ext_sz);
67  dovi->num_ext_blocks = s->num_ext_blocks;
68  return 0;
69 }
70 
71 static inline uint64_t get_ue_coef(GetBitContext *gb, const AVDOVIRpuDataHeader *hdr)
72 {
73  uint64_t ipart;
74  union { uint32_t u32; float f32; } fpart;
75 
76  switch (hdr->coef_data_type) {
77  case RPU_COEFF_FIXED:
78  ipart = get_ue_golomb_long(gb);
79  fpart.u32 = get_bits_long(gb, hdr->coef_log2_denom);
80  return (ipart << hdr->coef_log2_denom) | fpart.u32;
81 
82  case RPU_COEFF_FLOAT:
83  fpart.u32 = get_bits_long(gb, 32);
84  return fpart.f32 * (1LL << hdr->coef_log2_denom);
85  }
86 
87  return 0; /* unreachable */
88 }
89 
90 static inline int64_t get_se_coef(GetBitContext *gb, const AVDOVIRpuDataHeader *hdr)
91 {
92  int64_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_se_golomb_long(gb);
98  fpart.u32 = get_bits_long(gb, hdr->coef_log2_denom);
99  return ipart * (1LL << 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 unsigned get_variable_bits(GetBitContext *gb, int n)
110 {
111  unsigned int value = get_bits(gb, n);
112  int read_more = get_bits1(gb);
113  while (read_more) {
114  value = (value + 1) << n;
115  value |= get_bits(gb, n);
116  read_more = get_bits1(gb);
117  }
118  return value;
119 }
120 
121 #define VALIDATE(VAR, MIN, MAX) \
122  do { \
123  if (VAR < MIN || VAR > MAX) { \
124  av_log(s->logctx, AV_LOG_ERROR, "RPU validation failed: " \
125  #MIN" <= "#VAR" = %d <= "#MAX"\n", (int) VAR); \
126  goto fail; \
127  } \
128  } while (0)
129 
131 {
132  switch (dm->level) {
133  case 1:
134  dm->l1.min_pq = get_bits(gb, 12);
135  dm->l1.max_pq = get_bits(gb, 12);
136  dm->l1.avg_pq = get_bits(gb, 12);
137  break;
138  case 2:
139  dm->l2.target_max_pq = get_bits(gb, 12);
140  dm->l2.trim_slope = get_bits(gb, 12);
141  dm->l2.trim_offset = get_bits(gb, 12);
142  dm->l2.trim_power = get_bits(gb, 12);
143  dm->l2.trim_chroma_weight = get_bits(gb, 12);
144  dm->l2.trim_saturation_gain = get_bits(gb, 12);
145  dm->l2.ms_weight = get_sbits(gb, 13);
146  break;
147  case 4:
148  dm->l4.anchor_pq = get_bits(gb, 12);
149  dm->l4.anchor_power = get_bits(gb, 12);
150  break;
151  case 5:
152  dm->l5.left_offset = get_bits(gb, 13);
153  dm->l5.right_offset = get_bits(gb, 13);
154  dm->l5.top_offset = get_bits(gb, 13);
155  dm->l5.bottom_offset = get_bits(gb, 13);
156  break;
157  case 6:
158  dm->l6.max_luminance = get_bits(gb, 16);
159  dm->l6.min_luminance = get_bits(gb, 16);
160  dm->l6.max_cll = get_bits(gb, 16);
161  dm->l6.max_fall = get_bits(gb, 16);
162  break;
163  case 255:
164  dm->l255.dm_run_mode = get_bits(gb, 8);
165  dm->l255.dm_run_version = get_bits(gb, 8);
166  for (int i = 0; i < 4; i++)
167  dm->l255.dm_debug[i] = get_bits(gb, 8);
168  break;
169  default:
170  av_log(s->logctx, AV_LOG_WARNING,
171  "Unknown Dolby Vision DM v1 level: %u\n", dm->level);
172  }
173 }
174 
176 {
177  AVCIExy xy;
178  const int denom = 32767;
179  xy.x = av_make_q(get_sbits(gb, 16), denom);
180  xy.y = av_make_q(get_sbits(gb, 16), denom);
181  return xy;
182 }
183 
185  int ext_block_length)
186 {
187  switch (dm->level) {
188  case 3:
189  dm->l3.min_pq_offset = get_bits(gb, 12);
190  dm->l3.max_pq_offset = get_bits(gb, 12);
191  dm->l3.avg_pq_offset = get_bits(gb, 12);
192  break;
193  case 8:
194  dm->l8.target_display_index = get_bits(gb, 8);
195  dm->l8.trim_slope = get_bits(gb, 12);
196  dm->l8.trim_offset = get_bits(gb, 12);
197  dm->l8.trim_power = get_bits(gb, 12);
198  dm->l8.trim_chroma_weight = get_bits(gb, 12);
199  dm->l8.trim_saturation_gain = get_bits(gb, 12);
200  dm->l8.ms_weight = get_bits(gb, 12);
201  if (ext_block_length < 12)
202  break;
203  dm->l8.target_mid_contrast = get_bits(gb, 12);
204  if (ext_block_length < 13)
205  break;
206  dm->l8.clip_trim = get_bits(gb, 12);
207  if (ext_block_length < 19)
208  break;
209  for (int i = 0; i < 6; i++)
210  dm->l8.saturation_vector_field[i] = get_bits(gb, 8);
211  if (ext_block_length < 25)
212  break;
213  for (int i = 0; i < 6; i++)
214  dm->l8.hue_vector_field[i] = get_bits(gb, 8);
215  break;
216  case 9:
217  dm->l9.source_primary_index = get_bits(gb, 8);
218  if (ext_block_length < 17)
219  break;
224  break;
225  case 10:
226  dm->l10.target_display_index = get_bits(gb, 8);
227  dm->l10.target_max_pq = get_bits(gb, 12);
228  dm->l10.target_min_pq = get_bits(gb, 12);
229  dm->l10.target_primary_index = get_bits(gb, 8);
230  if (ext_block_length < 21)
231  break;
236  break;
237  case 11:
238  dm->l11.content_type = get_bits(gb, 8);
239  dm->l11.whitepoint = get_bits(gb, 4);
241  skip_bits(gb, 3); /* reserved */
242  dm->l11.sharpness = get_bits(gb, 2);
243  dm->l11.noise_reduction = get_bits(gb, 2);
244  dm->l11.mpeg_noise_reduction = get_bits(gb, 2);
245  dm->l11.frame_rate_conversion = get_bits(gb, 2);
246  dm->l11.brightness = get_bits(gb, 2);
247  dm->l11.color = get_bits(gb, 2);
248  break;
249  case 254:
250  dm->l254.dm_mode = get_bits(gb, 8);
251  dm->l254.dm_version_index = get_bits(gb, 8);
252  break;
253  default:
254  av_log(s->logctx, AV_LOG_WARNING,
255  "Unknown Dolby Vision DM v2 level: %u\n", dm->level);
256  }
257 }
258 
259 static int parse_ext_blocks(DOVIContext *s, GetBitContext *gb, int ver)
260 {
261  int num_ext_blocks, ext_block_length, start_pos, parsed_bits;
262 
263  num_ext_blocks = get_ue_golomb_31(gb);
264  align_get_bits(gb);
265  if (s->num_ext_blocks + num_ext_blocks > AV_DOVI_MAX_EXT_BLOCKS)
266  return AVERROR_INVALIDDATA;
267 
268  if (!s->ext_blocks) {
269  s->ext_blocks = ff_refstruct_allocz(sizeof(AVDOVIDmData) * AV_DOVI_MAX_EXT_BLOCKS);
270  if (!s->ext_blocks)
271  return AVERROR(ENOMEM);
272  }
273 
274  while (num_ext_blocks--) {
275  AVDOVIDmData *dm = &s->ext_blocks[s->num_ext_blocks++];
276  ext_block_length = get_ue_golomb_31(gb);
277  dm->level = get_bits(gb, 8);
278  start_pos = get_bits_count(gb);
279 
280  switch (ver) {
281  case 1: parse_ext_v1(s, gb, dm); break;
282  case 2: parse_ext_v2(s, gb, dm, ext_block_length); break;
283  }
284 
285  parsed_bits = get_bits_count(gb) - start_pos;
286  if (parsed_bits > ext_block_length * 8)
287  return AVERROR_INVALIDDATA;
288  skip_bits(gb, ext_block_length * 8 - parsed_bits);
289  }
290 
291  return 0;
292 }
293 
294 int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
295  int err_recognition)
296 {
297  AVDOVIRpuDataHeader *hdr = &s->header;
298  GetBitContext *gb = &(GetBitContext){0};
299  DOVIVdr *vdr;
300  int ret;
301 
302  uint8_t rpu_type;
303  uint8_t vdr_seq_info_present;
304  uint8_t vdr_dm_metadata_present;
305  uint8_t use_prev_vdr_rpu;
306  uint8_t use_nlq;
307  uint8_t profile;
308 
309  if (rpu_size < 5)
310  goto fail;
311 
312  /* Container */
313  if (s->cfg.dv_profile == 10 /* dav1.10 */) {
314  /* DV inside AV1 re-uses an EMDF container skeleton, but with fixed
315  * values - so we can effectively treat this as a magic byte sequence.
316  *
317  * The exact fields are, as follows:
318  * emdf_version : f(2) = 0
319  * key_id : f(3) = 6
320  * emdf_payload_id : f(5) = 31
321  * emdf_payload_id_ext : var(5) = 225
322  * smploffste : f(1) = 0
323  * duratione : f(1) = 0
324  * groupide : f(1) = 0
325  * codecdatae : f(1) = 0
326  * discard_unknown_payload : f(1) = 1
327  */
328  const unsigned header_magic = 0x01be6841u;
329  unsigned emdf_header, emdf_payload_size, emdf_protection;
330  if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
331  return ret;
332  emdf_header = get_bits_long(gb, 27);
333  VALIDATE(emdf_header, header_magic, header_magic);
334  emdf_payload_size = get_variable_bits(gb, 8);
335  VALIDATE(emdf_payload_size, 6, 512);
336  if (emdf_payload_size * 8 > get_bits_left(gb))
337  return AVERROR_INVALIDDATA;
338 
339  /* The payload is not byte-aligned (off by *one* bit, curse Dolby),
340  * so copy into a fresh buffer to preserve byte alignment of the
341  * RPU struct */
342  av_fast_padded_malloc(&s->rpu_buf, &s->rpu_buf_sz, emdf_payload_size);
343  if (!s->rpu_buf)
344  return AVERROR(ENOMEM);
345  for (int i = 0; i < emdf_payload_size; i++)
346  s->rpu_buf[i] = get_bits(gb, 8);
347  rpu = s->rpu_buf;
348  rpu_size = emdf_payload_size;
349 
350  /* Validate EMDF footer */
351  emdf_protection = get_bits(gb, 5 + 12);
352  VALIDATE(emdf_protection, 0x400, 0x400);
353  } else {
354  /* NAL RBSP with prefix and trailing zeroes */
355  VALIDATE(rpu[0], 25, 25); /* NAL prefix */
356  rpu++;
357  rpu_size--;
358  /* Strip trailing padding bytes */
359  while (rpu_size && rpu[rpu_size - 1] == 0)
360  rpu_size--;
361  }
362 
363  if (!rpu_size || rpu[rpu_size - 1] != 0x80)
364  goto fail;
365 
366  if (err_recognition & AV_EF_CRCCHECK) {
368  -1, rpu, rpu_size - 1)); /* exclude 0x80 */
369  if (crc) {
370  av_log(s->logctx, AV_LOG_ERROR, "RPU CRC mismatch: %X\n", crc);
371  if (err_recognition & AV_EF_EXPLODE)
372  goto fail;
373  }
374  }
375 
376  if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
377  return ret;
378 
379  /* RPU header */
380  rpu_type = get_bits(gb, 6);
381  if (rpu_type != 2) {
382  av_log(s->logctx, AV_LOG_WARNING, "Unrecognized RPU type "
383  "%"PRIu8", ignoring\n", rpu_type);
384  return 0;
385  }
386 
387  hdr->rpu_type = rpu_type;
388  hdr->rpu_format = get_bits(gb, 11);
389 
390  /* Values specific to RPU type 2 */
391  hdr->vdr_rpu_profile = get_bits(gb, 4);
392  hdr->vdr_rpu_level = get_bits(gb, 4);
393 
394  vdr_seq_info_present = get_bits1(gb);
395  if (vdr_seq_info_present) {
397  hdr->coef_data_type = get_bits(gb, 2);
399  switch (hdr->coef_data_type) {
400  case RPU_COEFF_FIXED:
401  hdr->coef_log2_denom = get_ue_golomb(gb);
402  VALIDATE(hdr->coef_log2_denom, 13, 32);
403  break;
404  case RPU_COEFF_FLOAT:
405  hdr->coef_log2_denom = 32; /* arbitrary, choose maximum precision */
406  break;
407  }
408 
409  hdr->vdr_rpu_normalized_idc = get_bits(gb, 2);
411 
412  if ((hdr->rpu_format & 0x700) == 0) {
413  int bl_bit_depth_minus8 = get_ue_golomb_31(gb);
414  int el_bit_depth_minus8 = get_ue_golomb_31(gb);
415  int vdr_bit_depth_minus8 = get_ue_golomb_31(gb);
416  VALIDATE(bl_bit_depth_minus8, 0, 8);
417  VALIDATE(el_bit_depth_minus8, 0, 8);
418  VALIDATE(vdr_bit_depth_minus8, 0, 8);
419  hdr->bl_bit_depth = bl_bit_depth_minus8 + 8;
420  hdr->el_bit_depth = el_bit_depth_minus8 + 8;
421  hdr->vdr_bit_depth = vdr_bit_depth_minus8 + 8;
423  skip_bits(gb, 3); /* reserved_zero_3bits */
425  hdr->disable_residual_flag = get_bits1(gb);
426  }
427  } else {
428  /* lack of documentation/samples */
429  avpriv_request_sample(s->logctx, "Missing RPU VDR sequence info\n");
431  return AVERROR_PATCHWELCOME;
432  }
433 
434  vdr_dm_metadata_present = get_bits1(gb);
435  use_prev_vdr_rpu = get_bits1(gb);
436  use_nlq = (hdr->rpu_format & 0x700) == 0 && !hdr->disable_residual_flag;
437 
438  profile = s->cfg.dv_profile ? s->cfg.dv_profile : ff_dovi_guess_profile_hevc(hdr);
439  if (profile == 5 && use_nlq) {
440  av_log(s->logctx, AV_LOG_ERROR, "Profile 5 RPUs should not use NLQ\n");
441  goto fail;
442  }
443 
444  if (use_prev_vdr_rpu) {
445  int prev_vdr_rpu_id = get_ue_golomb_31(gb);
446  VALIDATE(prev_vdr_rpu_id, 0, DOVI_MAX_DM_ID);
447  if (!s->vdr[prev_vdr_rpu_id]) {
448  av_log(s->logctx, AV_LOG_ERROR, "Unknown previous RPU ID: %u\n",
449  prev_vdr_rpu_id);
450  goto fail;
451  }
452  vdr = s->vdr[prev_vdr_rpu_id];
453  s->mapping = &vdr->mapping;
454  } else {
455  int vdr_rpu_id = get_ue_golomb_31(gb);
456  VALIDATE(vdr_rpu_id, 0, DOVI_MAX_DM_ID);
457  if (!s->vdr[vdr_rpu_id]) {
458  s->vdr[vdr_rpu_id] = ff_refstruct_allocz(sizeof(DOVIVdr));
459  if (!s->vdr[vdr_rpu_id])
460  return AVERROR(ENOMEM);
461  }
462 
463  vdr = s->vdr[vdr_rpu_id];
464  s->mapping = &vdr->mapping;
465 
466  vdr->mapping.vdr_rpu_id = vdr_rpu_id;
469 
470  for (int c = 0; c < 3; c++) {
471  AVDOVIReshapingCurve *curve = &vdr->mapping.curves[c];
472  int num_pivots_minus_2 = get_ue_golomb_31(gb);
473  int pivot = 0;
474 
475  VALIDATE(num_pivots_minus_2, 0, AV_DOVI_MAX_PIECES - 1);
476  curve->num_pivots = num_pivots_minus_2 + 2;
477  for (int i = 0; i < curve->num_pivots; i++) {
478  pivot += get_bits(gb, hdr->bl_bit_depth);
479  curve->pivots[i] = av_clip_uint16(pivot);
480  }
481  }
482 
483  if (use_nlq) {
484  int nlq_pivot = 0;
485  vdr->mapping.nlq_method_idc = get_bits(gb, 3);
486 
487  for (int i = 0; i < 2; i++) {
488  nlq_pivot += get_bits(gb, hdr->bl_bit_depth);
489  vdr->mapping.nlq_pivots[i] = av_clip_uint16(nlq_pivot);
490  }
491 
492  /**
493  * The patent mentions another legal value, NLQ_MU_LAW, but it's
494  * not documented anywhere how to parse or apply that type of NLQ.
495  */
497  } else {
499  }
500 
503  /* End of rpu_data_header(), start of vdr_rpu_data_payload() */
504 
505  for (int c = 0; c < 3; c++) {
506  AVDOVIReshapingCurve *curve = &vdr->mapping.curves[c];
507  for (int i = 0; i < curve->num_pivots - 1; i++) {
508  int mapping_idc = get_ue_golomb_31(gb);
509  VALIDATE(mapping_idc, 0, 1);
510  curve->mapping_idc[i] = mapping_idc;
511  switch (mapping_idc) {
513  int poly_order_minus1 = get_ue_golomb_31(gb);
514  VALIDATE(poly_order_minus1, 0, 1);
515  curve->poly_order[i] = poly_order_minus1 + 1;
516  if (poly_order_minus1 == 0) {
517  int linear_interp_flag = get_bits1(gb);
518  if (linear_interp_flag) {
519  /* lack of documentation/samples */
520  avpriv_request_sample(s->logctx, "Dolby Vision "
521  "linear interpolation");
523  return AVERROR_PATCHWELCOME;
524  }
525  }
526  for (int k = 0; k <= curve->poly_order[i]; k++)
527  curve->poly_coef[i][k] = get_se_coef(gb, hdr);
528  break;
529  }
530  case AV_DOVI_MAPPING_MMR: {
531  int mmr_order_minus1 = get_bits(gb, 2);
532  VALIDATE(mmr_order_minus1, 0, 2);
533  curve->mmr_order[i] = mmr_order_minus1 + 1;
534  curve->mmr_constant[i] = get_se_coef(gb, hdr);
535  for (int j = 0; j < curve->mmr_order[i]; j++) {
536  for (int k = 0; k < 7; k++)
537  curve->mmr_coef[i][j][k] = get_se_coef(gb, hdr);
538  }
539  break;
540  }
541  }
542  }
543  }
544 
545  if (use_nlq) {
546  for (int c = 0; c < 3; c++) {
547  AVDOVINLQParams *nlq = &vdr->mapping.nlq[c];
548  nlq->nlq_offset = get_bits(gb, hdr->el_bit_depth);
549  nlq->vdr_in_max = get_ue_coef(gb, hdr);
550  switch (vdr->mapping.nlq_method_idc) {
552  nlq->linear_deadzone_slope = get_ue_coef(gb, hdr);
553  nlq->linear_deadzone_threshold = get_ue_coef(gb, hdr);
554  break;
555  }
556  }
557  }
558  }
559 
560  if (vdr_dm_metadata_present) {
562  int affected_dm_id = get_ue_golomb_31(gb);
563  int current_dm_id = get_ue_golomb_31(gb);
564  VALIDATE(affected_dm_id, 0, DOVI_MAX_DM_ID);
565  VALIDATE(current_dm_id, 0, DOVI_MAX_DM_ID);
566  if (!s->vdr[affected_dm_id]) {
567  s->vdr[affected_dm_id] = ff_refstruct_allocz(sizeof(DOVIVdr));
568  if (!s->vdr[affected_dm_id])
569  return AVERROR(ENOMEM);
570  }
571 
572  if (!s->vdr[current_dm_id]) {
573  av_log(s->logctx, AV_LOG_ERROR, "Unknown previous RPU DM ID: %u\n",
574  current_dm_id);
575  goto fail;
576  }
577 
578  /* Update current pointer based on current_dm_id */
579  vdr = s->vdr[current_dm_id];
580  s->color = &vdr->color;
581 
582  /* Update values of affected_dm_id */
583  vdr = s->vdr[affected_dm_id];
584  color = &vdr->color;
585  color->dm_metadata_id = affected_dm_id;
586  color->scene_refresh_flag = get_ue_golomb_31(gb);
587  for (int i = 0; i < 9; i++)
588  color->ycc_to_rgb_matrix[i] = av_make_q(get_sbits(gb, 16), 1 << 13);
589  for (int i = 0; i < 3; i++) {
590  int denom = profile == 4 ? (1 << 30) : (1 << 28);
591  unsigned offset = get_bits_long(gb, 32);
592  if (offset > INT_MAX) {
593  /* Ensure the result fits inside AVRational */
594  offset >>= 1;
595  denom >>= 1;
596  }
597  color->ycc_to_rgb_offset[i] = av_make_q(offset, denom);
598  }
599  for (int i = 0; i < 9; i++)
600  color->rgb_to_lms_matrix[i] = av_make_q(get_sbits(gb, 16), 1 << 14);
601 
602  color->signal_eotf = get_bits(gb, 16);
603  color->signal_eotf_param0 = get_bits(gb, 16);
604  color->signal_eotf_param1 = get_bits(gb, 16);
605  color->signal_eotf_param2 = get_bits_long(gb, 32);
606  color->signal_bit_depth = get_bits(gb, 5);
607  VALIDATE(color->signal_bit_depth, 8, 16);
608  color->signal_color_space = get_bits(gb, 2);
609  color->signal_chroma_format = get_bits(gb, 2);
610  color->signal_full_range_flag = get_bits(gb, 2);
611  color->source_min_pq = get_bits(gb, 12);
612  color->source_max_pq = get_bits(gb, 12);
613  color->source_diagonal = get_bits(gb, 10);
614  }
615 
616  /* Parse extension blocks */
617  s->num_ext_blocks = 0;
618  if ((ret = parse_ext_blocks(s, gb, 1)) < 0) {
620  return ret;
621  }
622 
623  if (get_bits_left(gb) > 48 /* padding + CRC32 + terminator */) {
624  if ((ret = parse_ext_blocks(s, gb, 2)) < 0) {
626  return ret;
627  }
628  }
629 
630  return 0;
631 
632 fail:
633  ff_dovi_ctx_unref(s); /* don't leak potentially invalid state */
634  return AVERROR_INVALIDDATA;
635 }
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVDOVIDataMapping::nlq_method_idc
enum AVDOVINLQMethod nlq_method_idc
Definition: dovi_meta.h:148
AVDOVIDmLevel2::trim_chroma_weight
uint16_t trim_chroma_weight
Definition: dovi_meta.h: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:242
AVDOVIDmLevel8::saturation_vector_field
uint8_t saturation_vector_field[6]
Definition: dovi_meta.h:248
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:241
AVColorPrimariesDesc::wp
AVWhitepointCoefficients wp
Definition: csp.h:79
DOVI_MAX_DM_ID
#define DOVI_MAX_DM_ID
Definition: dovi_rpu.h:31
color
Definition: vf_paletteuse.c:512
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
AV_DOVI_MAX_EXT_BLOCKS
#define AV_DOVI_MAX_EXT_BLOCKS
Definition: dovi_meta.h:338
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
AVDOVIDmLevel9::source_display_primaries
AVColorPrimariesDesc source_display_primaries
Definition: dovi_meta.h:255
parse_ext_blocks
static int parse_ext_blocks(DOVIContext *s, GetBitContext *gb, int ver)
Definition: dovi_rpudec.c:259
AVDOVIDmLevel8::trim_saturation_gain
uint16_t trim_saturation_gain
Definition: dovi_meta.h:244
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:225
AVDOVIDmLevel11::frame_rate_conversion
uint8_t frame_rate_conversion
Definition: dovi_meta.h:274
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
av_dovi_get_ext
static av_always_inline AVDOVIDmData * av_dovi_get_ext(const AVDOVIMetadata *data, int index)
Definition: dovi_meta.h:360
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:116
AVDOVIDmLevel10::target_primary_index
uint8_t target_primary_index
Definition: dovi_meta.h:263
AV_DOVI_NLQ_NONE
@ AV_DOVI_NLQ_NONE
Definition: dovi_meta.h:120
AVDOVIDmLevel8::ms_weight
uint16_t ms_weight
Definition: dovi_meta.h:245
AVDOVIReshapingCurve::mapping_idc
enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:109
AVDOVIDmLevel6::min_luminance
uint16_t min_luminance
Definition: dovi_meta.h:232
AVDOVIDmLevel10::target_display_index
uint8_t target_display_index
Definition: dovi_meta.h:260
AVDOVIDmLevel1::max_pq
uint16_t max_pq
Definition: dovi_meta.h:195
AVDOVIDmData::l11
AVDOVIDmLevel11 l11
Definition: dovi_meta.h:310
AVDOVIRpuDataHeader::rpu_format
uint16_t rpu_format
Definition: dovi_meta.h:80
AVDOVIDataMapping::mapping_color_space
uint8_t mapping_color_space
Definition: dovi_meta.h:143
AVDOVIRpuDataHeader
Dolby Vision RPU data header.
Definition: dovi_meta.h:78
AVDOVIDmLevel8::hue_vector_field
uint8_t hue_vector_field[6]
Definition: dovi_meta.h:249
AVDOVIRpuDataHeader::coef_data_type
uint8_t coef_data_type
Definition: dovi_meta.h:84
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
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:276
AVDOVIDmLevel11::reference_mode_flag
uint8_t reference_mode_flag
Definition: dovi_meta.h:270
AVDOVIDmLevel11::brightness
uint8_t brightness
Definition: dovi_meta.h:275
DOVIContext
Definition: dovi_rpu.h:32
fail
#define fail()
Definition: checkasm.h:184
AVDOVIRpuDataHeader::el_bit_depth
uint8_t el_bit_depth
Definition: dovi_meta.h:89
GetBitContext
Definition: get_bits.h:108
AVDOVIDmLevel2::trim_power
uint16_t trim_power
Definition: dovi_meta.h:204
dovi_rpu.h
AVDOVIDmLevel2::trim_slope
uint16_t trim_slope
Definition: dovi_meta.h:202
AVDOVIDmLevel2::ms_weight
int16_t ms_weight
Definition: dovi_meta.h:207
refstruct.h
AVDOVIRpuDataHeader::vdr_rpu_normalized_idc
uint8_t vdr_rpu_normalized_idc
Definition: dovi_meta.h:86
AVDOVIRpuDataHeader::el_spatial_resampling_filter_flag
uint8_t el_spatial_resampling_filter_flag
Definition: dovi_meta.h:92
AVDOVIDmLevel8::clip_trim
uint16_t clip_trim
Definition: dovi_meta.h:247
AVDOVIDmLevel3::avg_pq_offset
uint16_t avg_pq_offset
Definition: dovi_meta.h:213
RPU_COEFF_FLOAT
@ RPU_COEFF_FLOAT
Definition: dovi_rpu.h:136
AVDOVIDmData
Dolby Vision metadata extension block.
Definition: dovi_meta.h:297
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 Dovi RPU NAL and update the parsed values in the DOVIContext struct.
Definition: dovi_rpudec.c:294
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVDOVIRpuDataHeader::chroma_resampling_explicit_filter_flag
uint8_t chroma_resampling_explicit_filter_flag
Definition: dovi_meta.h:83
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:233
AVDOVIRpuDataHeader::vdr_bit_depth
uint8_t vdr_bit_depth
Definition: dovi_meta.h:90
AVDOVIRpuDataHeader::rpu_type
uint8_t rpu_type
Definition: dovi_meta.h:79
AVDOVIMetadata
Combined struct representing a combination of header, mapping and color metadata, for attaching to fr...
Definition: dovi_meta.h:324
AVDOVIDmLevel8::trim_slope
uint16_t trim_slope
Definition: dovi_meta.h:240
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVDOVIDmLevel4::anchor_power
uint16_t anchor_power
Definition: dovi_meta.h:218
AVDOVIReshapingCurve::mmr_order
uint8_t mmr_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:114
AVDOVIDmData::l3
AVDOVIDmLevel3 l3
Definition: dovi_meta.h:302
AVDOVIDmLevel11::noise_reduction
uint8_t noise_reduction
Definition: dovi_meta.h:272
AVDOVIRpuDataHeader::spatial_resampling_filter_flag
uint8_t spatial_resampling_filter_flag
Definition: dovi_meta.h:91
AVDOVIDmLevel10::target_min_pq
uint16_t target_min_pq
Definition: dovi_meta.h:262
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:97
av_dovi_get_header
static av_always_inline AVDOVIRpuDataHeader * av_dovi_get_header(const AVDOVIMetadata *data)
Definition: dovi_meta.h:342
AVDOVIReshapingCurve::poly_order
uint8_t poly_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:111
AVDOVINLQParams::linear_deadzone_threshold
uint64_t linear_deadzone_threshold
Definition: dovi_meta.h:133
AVDOVIDmLevel8::target_mid_contrast
uint16_t target_mid_contrast
Definition: dovi_meta.h:246
get_se_coef
static int64_t get_se_coef(GetBitContext *gb, const AVDOVIRpuDataHeader *hdr)
Definition: dovi_rpudec.c:90
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:98
parse_ext_v2
static void parse_ext_v2(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm, int ext_block_length)
Definition: dovi_rpudec.c:184
AVDOVIDmLevel5::bottom_offset
uint16_t bottom_offset
Definition: dovi_meta.h:226
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
AVDOVIDmData::l9
AVDOVIDmLevel9 l9
Definition: dovi_meta.h:308
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
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:786
AVDOVIDmLevel4::anchor_pq
uint16_t anchor_pq
Definition: dovi_meta.h:217
AVDOVIReshapingCurve::mmr_constant
int64_t mmr_constant[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:115
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:254
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:201
AVDOVIDmLevel6::max_luminance
uint16_t max_luminance
Definition: dovi_meta.h:231
AVCIExy::x
AVRational x
Definition: csp.h:57
AVDOVIDmData::l2
AVDOVIDmLevel2 l2
Definition: dovi_meta.h:301
AVDOVIDataMapping::nlq_pivots
uint16_t nlq_pivots[2]
Definition: dovi_meta.h:152
AVPrimaryCoefficients::b
AVCIExy b
Definition: csp.h:65
AVDOVIDmLevel6::max_fall
uint16_t max_fall
Definition: dovi_meta.h:234
AVPrimaryCoefficients::r
AVCIExy r
Definition: csp.h:65
AVDOVIDmLevel8::target_display_index
uint8_t target_display_index
Definition: dovi_meta.h:239
AVDOVIDmData::l254
AVDOVIDmLevel254 l254
Definition: dovi_meta.h:311
AVDOVIDmLevel10::target_display_primaries
AVColorPrimariesDesc target_display_primaries
Definition: dovi_meta.h:264
DOVIVdr::mapping
AVDOVIDataMapping mapping
Definition: dovi_rpu.h:132
AV_DOVI_NLQ_LINEAR_DZ
@ AV_DOVI_NLQ_LINEAR_DZ
Definition: dovi_meta.h:121
AVDOVIRpuDataHeader::vdr_rpu_profile
uint8_t vdr_rpu_profile
Definition: dovi_meta.h:81
av_bswap32
#define av_bswap32
Definition: bswap.h:47
AVDOVIDmLevel2::trim_saturation_gain
uint16_t trim_saturation_gain
Definition: dovi_meta.h:206
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:243
AVDOVIDmLevel255::dm_run_mode
uint8_t dm_run_mode
Definition: dovi_meta.h:287
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:194
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:33
AVPrimaryCoefficients::g
AVCIExy g
Definition: csp.h:65
AVDOVIDmLevel11::content_type
uint8_t content_type
Definition: dovi_meta.h:268
AVDOVIDmData::l10
AVDOVIDmLevel10 l10
Definition: dovi_meta.h:309
AVDOVIRpuDataHeader::coef_log2_denom
uint8_t coef_log2_denom
Definition: dovi_meta.h:85
AVDOVIRpuDataHeader::bl_video_full_range_flag
uint8_t bl_video_full_range_flag
Definition: dovi_meta.h:87
AVDOVIReshapingCurve::poly_coef
int64_t poly_coef[AV_DOVI_MAX_PIECES][3]
Definition: dovi_meta.h:112
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
AVDOVIDmData::l255
AVDOVIDmLevel255 l255
Definition: dovi_meta.h:312
AVDOVIDmData::l8
AVDOVIDmLevel8 l8
Definition: dovi_meta.h:307
AVDOVIDmLevel2::trim_offset
uint16_t trim_offset
Definition: dovi_meta.h:203
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:261
AVDOVIDataMapping::num_y_partitions
uint32_t num_y_partitions
Definition: dovi_meta.h:150
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:175
profile
int profile
Definition: mxfenc.c:2227
AVDOVINLQParams
Coefficients of the non-linear inverse quantization.
Definition: dovi_meta.h:128
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
AVDOVIDmData::l4
AVDOVIDmLevel4 l4
Definition: dovi_meta.h:303
AVDOVIDmData::l1
AVDOVIDmLevel1 l1
Definition: dovi_meta.h:300
AVDOVIDataMapping::curves
AVDOVIReshapingCurve curves[3]
Definition: dovi_meta.h:145
avcodec.h
AVDOVINLQParams::linear_deadzone_slope
uint64_t linear_deadzone_slope
Definition: dovi_meta.h:132
AVDOVIReshapingCurve
Definition: dovi_meta.h:106
ret
ret
Definition: filter_design.txt:187
AVDOVIDmLevel11::mpeg_noise_reduction
uint8_t mpeg_noise_reduction
Definition: dovi_meta.h:273
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
DOVIVdr
Definition: dovi_rpu.h:129
AVDOVIDmLevel11::sharpness
uint8_t sharpness
Definition: dovi_meta.h:271
AVDOVINLQParams::vdr_in_max
uint64_t vdr_in_max
Definition: dovi_meta.h:130
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
COPY
#define COPY(t, a, b, last)
AVDOVIDmData::l6
AVDOVIDmLevel6 l6
Definition: dovi_meta.h:305
AVDOVIReshapingCurve::num_pivots
uint8_t num_pivots
Definition: dovi_meta.h:107
AVDOVIDmLevel3::min_pq_offset
uint16_t min_pq_offset
Definition: dovi_meta.h:211
get_ue_coef
static uint64_t get_ue_coef(GetBitContext *gb, const AVDOVIRpuDataHeader *hdr)
Definition: dovi_rpudec.c:71
AVDOVIRpuDataHeader::vdr_rpu_level
uint8_t vdr_rpu_level
Definition: dovi_meta.h:82
av_dovi_get_color
static av_always_inline AVDOVIColorMetadata * av_dovi_get_color(const AVDOVIMetadata *data)
Definition: dovi_meta.h:354
AVDOVIDmLevel5::left_offset
uint16_t left_offset
Definition: dovi_meta.h:223
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:304
AVDOVIDataMapping::mapping_chroma_format_idc
uint8_t mapping_chroma_format_idc
Definition: dovi_meta.h:144
AVDOVIDmLevel5::right_offset
uint16_t right_offset
Definition: dovi_meta.h:224
RPU_COEFF_FIXED
@ RPU_COEFF_FIXED
Definition: dovi_rpu.h:135
AVDOVIDmLevel255::dm_run_version
uint8_t dm_run_version
Definition: dovi_meta.h:288
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:196
AVDOVIRpuDataHeader::bl_bit_depth
uint8_t bl_bit_depth
Definition: dovi_meta.h:88
VALIDATE
#define VALIDATE(VAR, MIN, MAX)
Definition: dovi_rpudec.c:121
AVDOVIColorMetadata
Dolby Vision RPU colorspace metadata parameters.
Definition: dovi_meta.h:160
AVDOVIDmData::level
uint8_t level
Definition: dovi_meta.h:298
DOVIVdr::color
AVDOVIColorMetadata color
Definition: dovi_rpu.h:133
av_clip_uint16
#define av_clip_uint16
Definition: common.h:112
AVDOVIDmLevel3::max_pq_offset
uint16_t max_pq_offset
Definition: dovi_meta.h:212
AVDOVIDmLevel254::dm_version_index
uint8_t dm_version_index
Definition: dovi_meta.h:282
get_variable_bits
static unsigned get_variable_bits(GetBitContext *gb, int n)
Definition: dovi_rpudec.c:109
AVDOVIDmLevel11::whitepoint
uint8_t whitepoint
Definition: dovi_meta.h:269
AVDOVIDmLevel254::dm_mode
uint8_t dm_mode
Definition: dovi_meta.h:281
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
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:348
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
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:108
AVColorPrimariesDesc::prim
AVPrimaryCoefficients prim
Definition: csp.h:80
parse_ext_v1
static void parse_ext_v1(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm)
Definition: dovi_rpudec.c:130
AVDOVINLQParams::nlq_offset
uint16_t nlq_offset
Definition: dovi_meta.h:129
AVDOVIDataMapping::vdr_rpu_id
uint8_t vdr_rpu_id
Definition: dovi_meta.h:142
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:93
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:151
AVDOVIDataMapping
Dolby Vision RPU data mapping parameters.
Definition: dovi_meta.h:141
AV_DOVI_MAX_PIECES
#define AV_DOVI_MAX_PIECES
Coefficients of a piece-wise function.
Definition: dovi_meta.h:105
AVDOVIDataMapping::num_x_partitions
uint32_t num_x_partitions
Definition: dovi_meta.h:149
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:68
AVDOVIDmLevel255::dm_debug
uint8_t dm_debug[4]
Definition: dovi_meta.h:289