FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/dovi_rpudec.c
Date: 2024-05-03 15:42:48
Exec Total Coverage
Lines: 185 406 45.6%
Functions: 5 9 55.6%
Branches: 97 249 39.0%
Line Branch Exec Source
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
33 9535 int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
34 {
35 AVFrameSideData *sd;
36 AVBufferRef *buf;
37 AVDOVIMetadata *dovi;
38 size_t dovi_size, ext_sz;
39
40
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 9533 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 9535 if (!s->mapping || !s->color)
41 9533 return 0; /* incomplete dovi metadata */
42
43 2 dovi = av_dovi_metadata_alloc(&dovi_size);
44
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!dovi)
45 ✗ return AVERROR(ENOMEM);
46
47 2 buf = av_buffer_create((uint8_t *) dovi, dovi_size, NULL, NULL, 0);
48
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!buf) {
49 ✗ av_free(dovi);
50 ✗ return AVERROR(ENOMEM);
51 }
52
53 2 sd = av_frame_new_side_data_from_buf(frame, AV_FRAME_DATA_DOVI_METADATA, buf);
54
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 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 2 COPY(AVDOVIRpuDataHeader, av_dovi_get_header(dovi), &s->header, disable_residual_flag);
62 2 COPY(AVDOVIDataMapping, av_dovi_get_mapping(dovi), s->mapping, nlq_pivots);
63 2 COPY(AVDOVIColorMetadata, av_dovi_get_color(dovi), s->color, source_diagonal);
64 2 ext_sz = FFMIN(sizeof(AVDOVIDmData), dovi->ext_block_size);
65
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
 4 for (int i = 0; i < s->num_ext_blocks; i++)
66 2 memcpy(av_dovi_get_ext(dovi, i), &s->ext_blocks[i], ext_sz);
67 2 dovi->num_ext_blocks = s->num_ext_blocks;
68 2 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 136 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
1/3
✓ Branch 0 taken 136 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 136 switch (hdr->coef_data_type) {
96 136 case RPU_COEFF_FIXED:
97 136 ipart = get_se_golomb_long(gb);
98 136 fpart.u32 = get_bits_long(gb, hdr->coef_log2_denom);
99 136 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
130 2 static void parse_ext_v1(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm)
131 {
132
1/7
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 2 switch (dm->level) {
133 2 case 1:
134 2 dm->l1.min_pq = get_bits(gb, 12);
135 2 dm->l1.max_pq = get_bits(gb, 12);
136 2 dm->l1.avg_pq = get_bits(gb, 12);
137 2 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_bits(gb, 13) - 8192;
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 2 }
174
175 ✗ static AVCIExy get_cie_xy(GetBitContext *gb)
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
184 ✗ static void parse_ext_v2(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm,
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) - 8192;
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;
220 ✗ dm->l9.source_display_primaries.prim.r = get_cie_xy(gb);
221 ✗ dm->l9.source_display_primaries.prim.g = get_cie_xy(gb);
222 ✗ dm->l9.source_display_primaries.prim.b = get_cie_xy(gb);
223 ✗ dm->l9.source_display_primaries.wp = get_cie_xy(gb);
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;
232 ✗ dm->l10.target_display_primaries.prim.r = get_cie_xy(gb);
233 ✗ dm->l10.target_display_primaries.prim.g = get_cie_xy(gb);
234 ✗ dm->l10.target_display_primaries.prim.b = get_cie_xy(gb);
235 ✗ dm->l10.target_display_primaries.wp = get_cie_xy(gb);
236 ✗ break;
237 ✗ case 11:
238 ✗ dm->l11.content_type = get_bits(gb, 8);
239 ✗ dm->l11.whitepoint = get_bits(gb, 4);
240 ✗ dm->l11.reference_mode_flag = get_bits1(gb);
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 2 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 2 num_ext_blocks = get_ue_golomb_31(gb);
264 2 align_get_bits(gb);
265
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (s->num_ext_blocks + num_ext_blocks > AV_DOVI_MAX_EXT_BLOCKS)
266 ✗ return AVERROR_INVALIDDATA;
267
268
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (!s->ext_blocks) {
269 1 s->ext_blocks = ff_refstruct_allocz(sizeof(AVDOVIDmData) * AV_DOVI_MAX_EXT_BLOCKS);
270
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!s->ext_blocks)
271 ✗ return AVERROR(ENOMEM);
272 }
273
274
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
 4 while (num_ext_blocks--) {
275 2 AVDOVIDmData *dm = &s->ext_blocks[s->num_ext_blocks++];
276 2 ext_block_length = get_ue_golomb_31(gb);
277 2 dm->level = get_bits(gb, 8);
278 2 start_pos = get_bits_count(gb);
279
280
1/3
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 2 switch (ver) {
281 2 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 2 parsed_bits = get_bits_count(gb) - start_pos;
286
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (parsed_bits > ext_block_length * 8)
287 ✗ return AVERROR_INVALIDDATA;
288 2 skip_bits(gb, ext_block_length * 8 - parsed_bits);
289 }
290
291 2 return 0;
292 }
293
294 2 int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
295 int err_recognition)
296 {
297 2 AVDOVIRpuDataHeader *hdr = &s->header;
298 2 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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (rpu_size < 5)
310 ✗ goto fail;
311
312 /* Container */
313
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 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
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(rpu[0], 25, 25); /* NAL prefix */
356 2 rpu++;
357 2 rpu_size--;
358 /* Strip trailing padding bytes */
359
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 while (rpu_size && rpu[rpu_size - 1] == 0)
360 ✗ rpu_size--;
361 }
362
363
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 if (!rpu_size || rpu[rpu_size - 1] != 0x80)
364 ✗ goto fail;
365
366
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (err_recognition & AV_EF_CRCCHECK) {
367 ✗ uint32_t crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE),
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
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
377 ✗ return ret;
378
379 /* RPU header */
380 2 rpu_type = get_bits(gb, 6);
381
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 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 2 hdr->rpu_type = rpu_type;
388 2 hdr->rpu_format = get_bits(gb, 11);
389
390 /* Values specific to RPU type 2 */
391 2 hdr->vdr_rpu_profile = get_bits(gb, 4);
392 2 hdr->vdr_rpu_level = get_bits(gb, 4);
393
394 2 vdr_seq_info_present = get_bits1(gb);
395
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (vdr_seq_info_present) {
396 2 hdr->chroma_resampling_explicit_filter_flag = get_bits1(gb);
397 2 hdr->coef_data_type = get_bits(gb, 2);
398
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 VALIDATE(hdr->coef_data_type, RPU_COEFF_FIXED, RPU_COEFF_FLOAT);
399
1/3
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 2 switch (hdr->coef_data_type) {
400 2 case RPU_COEFF_FIXED:
401 2 hdr->coef_log2_denom = get_ue_golomb(gb);
402
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(hdr->coef_log2_denom, 13, 32);
403 2 break;
404 ✗ case RPU_COEFF_FLOAT:
405 ✗ hdr->coef_log2_denom = 32; /* arbitrary, choose maximum precision */
406 ✗ break;
407 }
408
409 2 hdr->vdr_rpu_normalized_idc = get_bits(gb, 2);
410 2 hdr->bl_video_full_range_flag = get_bits1(gb);
411
412
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if ((hdr->rpu_format & 0x700) == 0) {
413 2 int bl_bit_depth_minus8 = get_ue_golomb_31(gb);
414 2 int el_bit_depth_minus8 = get_ue_golomb_31(gb);
415 2 int vdr_bit_depth_minus8 = get_ue_golomb_31(gb);
416
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(bl_bit_depth_minus8, 0, 8);
417
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(el_bit_depth_minus8, 0, 8);
418
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(vdr_bit_depth_minus8, 0, 8);
419 2 hdr->bl_bit_depth = bl_bit_depth_minus8 + 8;
420 2 hdr->el_bit_depth = el_bit_depth_minus8 + 8;
421 2 hdr->vdr_bit_depth = vdr_bit_depth_minus8 + 8;
422 2 hdr->spatial_resampling_filter_flag = get_bits1(gb);
423 2 skip_bits(gb, 3); /* reserved_zero_3bits */
424 2 hdr->el_spatial_resampling_filter_flag = get_bits1(gb);
425 2 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");
430 ✗ ff_dovi_ctx_unref(s);
431 ✗ return AVERROR_PATCHWELCOME;
432 }
433
434 2 vdr_dm_metadata_present = get_bits1(gb);
435 2 use_prev_vdr_rpu = get_bits1(gb);
436
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 use_nlq = (hdr->rpu_format & 0x700) == 0 && !hdr->disable_residual_flag;
437
438
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 profile = s->cfg.dv_profile ? s->cfg.dv_profile : ff_dovi_guess_profile_hevc(hdr);
439
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 2 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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 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 2 int vdr_rpu_id = get_ue_golomb_31(gb);
456
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(vdr_rpu_id, 0, DOVI_MAX_DM_ID);
457
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (!s->vdr[vdr_rpu_id]) {
458 1 s->vdr[vdr_rpu_id] = ff_refstruct_allocz(sizeof(DOVIVdr));
459
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!s->vdr[vdr_rpu_id])
460 ✗ return AVERROR(ENOMEM);
461 }
462
463 2 vdr = s->vdr[vdr_rpu_id];
464 2 s->mapping = &vdr->mapping;
465
466 2 vdr->mapping.vdr_rpu_id = vdr_rpu_id;
467 2 vdr->mapping.mapping_color_space = get_ue_golomb_31(gb);
468 2 vdr->mapping.mapping_chroma_format_idc = get_ue_golomb_31(gb);
469
470
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2 times.
 8 for (int c = 0; c < 3; c++) {
471 6 AVDOVIReshapingCurve *curve = &vdr->mapping.curves[c];
472 6 int num_pivots_minus_2 = get_ue_golomb_31(gb);
473 6 int pivot = 0;
474
475
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
 6 VALIDATE(num_pivots_minus_2, 0, AV_DOVI_MAX_PIECES - 1);
476 6 curve->num_pivots = num_pivots_minus_2 + 2;
477
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 6 times.
 32 for (int i = 0; i < curve->num_pivots; i++) {
478 26 pivot += get_bits(gb, hdr->bl_bit_depth);
479 26 curve->pivots[i] = av_clip_uint16(pivot);
480 }
481 }
482
483
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 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 */
496 ✗ VALIDATE(vdr->mapping.nlq_method_idc, 0, AV_DOVI_NLQ_LINEAR_DZ);
497 } else {
498 2 vdr->mapping.nlq_method_idc = AV_DOVI_NLQ_NONE;
499 }
500
501 2 vdr->mapping.num_x_partitions = get_ue_golomb_long(gb) + 1;
502 2 vdr->mapping.num_y_partitions = get_ue_golomb_long(gb) + 1;
503 /* End of rpu_data_header(), start of vdr_rpu_data_payload() */
504
505
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2 times.
 8 for (int c = 0; c < 3; c++) {
506 6 AVDOVIReshapingCurve *curve = &vdr->mapping.curves[c];
507
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 6 times.
 26 for (int i = 0; i < curve->num_pivots - 1; i++) {
508 20 int mapping_idc = get_ue_golomb_31(gb);
509
2/4
✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 20 times.
 20 VALIDATE(mapping_idc, 0, 1);
510 20 curve->mapping_idc[i] = mapping_idc;
511
2/3
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
 20 switch (mapping_idc) {
512 16 case AV_DOVI_MAPPING_POLYNOMIAL: {
513 16 int poly_order_minus1 = get_ue_golomb_31(gb);
514
2/4
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
 16 VALIDATE(poly_order_minus1, 0, 1);
515 16 curve->poly_order[i] = poly_order_minus1 + 1;
516
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 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");
522 ✗ ff_dovi_ctx_unref(s);
523 ✗ return AVERROR_PATCHWELCOME;
524 }
525 }
526
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 16 times.
 64 for (int k = 0; k <= curve->poly_order[i]; k++)
527 48 curve->poly_coef[i][k] = get_se_coef(gb, hdr);
528 16 break;
529 }
530 4 case AV_DOVI_MAPPING_MMR: {
531 4 int mmr_order_minus1 = get_bits(gb, 2);
532
2/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 4 VALIDATE(mmr_order_minus1, 0, 2);
533 4 curve->mmr_order[i] = mmr_order_minus1 + 1;
534 4 curve->mmr_constant[i] = get_se_coef(gb, hdr);
535
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 4 times.
 16 for (int j = 0; j < curve->mmr_order[i]; j++) {
536
2/2
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 12 times.
 96 for (int k = 0; k < 7; k++)
537 84 curve->mmr_coef[i][j][k] = get_se_coef(gb, hdr);
538 }
539 4 break;
540 }
541 }
542 }
543 }
544
545
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 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) {
551 ✗ case AV_DOVI_NLQ_LINEAR_DZ:
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
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (vdr_dm_metadata_present) {
561 AVDOVIColorMetadata *color;
562 2 int affected_dm_id = get_ue_golomb_31(gb);
563 2 int current_dm_id = get_ue_golomb_31(gb);
564
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(affected_dm_id, 0, DOVI_MAX_DM_ID);
565
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(current_dm_id, 0, DOVI_MAX_DM_ID);
566
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 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 2 vdr = s->vdr[current_dm_id];
580 2 s->color = &vdr->color;
581
582 /* Update values of affected_dm_id */
583 2 vdr = s->vdr[affected_dm_id];
584 2 color = &vdr->color;
585 2 color->dm_metadata_id = affected_dm_id;
586 2 color->scene_refresh_flag = get_ue_golomb_31(gb);
587
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 2 times.
 20 for (int i = 0; i < 9; i++)
588 18 color->ycc_to_rgb_matrix[i] = av_make_q(get_sbits(gb, 16), 1 << 13);
589
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2 times.
 8 for (int i = 0; i < 3; i++) {
590
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 int denom = profile == 4 ? (1 << 30) : (1 << 28);
591 6 unsigned offset = get_bits_long(gb, 32);
592
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (offset > INT_MAX) {
593 /* Ensure the result fits inside AVRational */
594 ✗ offset >>= 1;
595 ✗ denom >>= 1;
596 }
597 6 color->ycc_to_rgb_offset[i] = av_make_q(offset, denom);
598 }
599
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 2 times.
 20 for (int i = 0; i < 9; i++)
600 18 color->rgb_to_lms_matrix[i] = av_make_q(get_sbits(gb, 16), 1 << 14);
601
602 2 color->signal_eotf = get_bits(gb, 16);
603 2 color->signal_eotf_param0 = get_bits(gb, 16);
604 2 color->signal_eotf_param1 = get_bits(gb, 16);
605 2 color->signal_eotf_param2 = get_bits_long(gb, 32);
606 2 color->signal_bit_depth = get_bits(gb, 5);
607
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 VALIDATE(color->signal_bit_depth, 8, 16);
608 2 color->signal_color_space = get_bits(gb, 2);
609 2 color->signal_chroma_format = get_bits(gb, 2);
610 2 color->signal_full_range_flag = get_bits(gb, 2);
611 2 color->source_min_pq = get_bits(gb, 12);
612 2 color->source_max_pq = get_bits(gb, 12);
613 2 color->source_diagonal = get_bits(gb, 10);
614 }
615
616 /* Parse extension blocks */
617 2 s->num_ext_blocks = 0;
618
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if ((ret = parse_ext_blocks(s, gb, 1)) < 0) {
619 ✗ ff_dovi_ctx_unref(s);
620 ✗ return ret;
621 }
622
623
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (get_bits_left(gb) > 48 /* padding + CRC32 + terminator */) {
624 ✗ if ((ret = parse_ext_blocks(s, gb, 2)) < 0) {
625 ✗ ff_dovi_ctx_unref(s);
626 ✗ return ret;
627 }
628 }
629
630 2 return 0;
631
632 ✗ fail:
633 ✗ ff_dovi_ctx_unref(s); /* don't leak potentially invalid state */
634 ✗ return AVERROR_INVALIDDATA;
635 }
636