FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/dovi_rpuenc.c
Date: 2026-09-28 11:37:26
Exec Total Coverage
Lines: 0 644 0.0%
Functions: 0 17 0.0%
Branches: 0 469 0.0%
Line Branch Exec Source
1 /*
2 * Dolby Vision RPU encoder
3 *
4 * Copyright (C) 2024 Niklas Haas
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include "libavutil/attributes.h"
24 #include "libavutil/avassert.h"
25 #include "libavutil/crc.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/refstruct.h"
28
29 #include "avcodec.h"
30 #include "dovi_rpu.h"
31 #include "itut35.h"
32 #include "put_bits.h"
33 #include "put_golomb.h"
34
35 static const struct {
36 uint64_t pps; // maximum pixels per second
37 int width; // maximum width
38 int main; // maximum bitrate in main tier
39 int high; // maximum bitrate in high tier
40 } dv_levels[] = {
41 [1] = {1280*720*24, 1280, 20, 50},
42 [2] = {1280*720*30, 1280, 20, 50},
43 [3] = {1920*1080*24, 1920, 20, 70},
44 [4] = {1920*1080*30, 2560, 20, 70},
45 [5] = {1920*1080*60, 3840, 20, 70},
46 [6] = {3840*2160*24, 3840, 25, 130},
47 [7] = {3840*2160*30, 3840, 25, 130},
48 [8] = {3840*2160*48, 3840, 40, 130},
49 [9] = {3840*2160*60, 3840, 40, 130},
50 [10] = {3840*2160*120, 3840, 60, 240},
51 [11] = {3840*2160*120, 7680, 60, 240},
52 [12] = {7680*4320*60, 7680, 120, 450},
53 [13] = {7680*4320*120u, 7680, 240, 800},
54 };
55
56 ✗ static av_cold int dovi_configure_ext(DOVIContext *s, enum AVCodecID codec_id,
57 const AVDOVIMetadata *metadata,
58 enum AVDOVICompression compression,
59 int strict_std_compliance,
60 int width, int height,
61 AVRational framerate,
62 enum AVPixelFormat pix_format,
63 enum AVColorSpace color_space,
64 enum AVColorPrimaries color_primaries,
65 enum AVColorTransferCharacteristic color_trc,
66 AVPacketSideData **coded_side_data,
67 int *nb_coded_side_data)
68 {
69 AVDOVIDecoderConfigurationRecord *cfg;
70 ✗ const AVDOVIRpuDataHeader *hdr = NULL;
71 ✗ int dv_profile, dv_level, bl_compat_id = -1;
72 size_t cfg_size;
73 uint64_t pps;
74
75 ✗ if (!s->enable)
76 ✗ goto skip;
77
78 ✗ if (metadata)
79 ✗ hdr = av_dovi_get_header(metadata);
80
81 ✗ if (s->enable == FF_DOVI_AUTOMATIC && !hdr)
82 ✗ goto skip;
83
84 ✗ if (compression == AV_DOVI_COMPRESSION_RESERVED ||
85 compression > AV_DOVI_COMPRESSION_EXTENDED)
86 ✗ return AVERROR(EINVAL);
87
88 ✗ switch (codec_id) {
89 ✗ case AV_CODEC_ID_AV1: dv_profile = 10; break;
90 ✗ case AV_CODEC_ID_H264: dv_profile = 9; break;
91 ✗ case AV_CODEC_ID_HEVC:
92 ✗ if (hdr) {
93 ✗ dv_profile = ff_dovi_guess_profile_hevc(hdr);
94 ✗ break;
95 }
96
97 /* This is likely to be proprietary IPTPQc2 */
98 ✗ if (color_space == AVCOL_SPC_IPT_C2 ||
99 ✗ (color_space == AVCOL_SPC_UNSPECIFIED &&
100 color_trc == AVCOL_TRC_UNSPECIFIED))
101 ✗ dv_profile = 5;
102 else
103 ✗ dv_profile = 8;
104 ✗ break;
105 ✗ default:
106 ✗ av_unreachable("ff_dovi_configure only used with AV1, H.264 and HEVC");
107 }
108
109 ✗ if (strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
110 ✗ if (dv_profile == 9) {
111 ✗ if (pix_format != AV_PIX_FMT_YUV420P)
112 ✗ dv_profile = 0;
113 } else {
114 ✗ if (pix_format != AV_PIX_FMT_YUV420P10)
115 ✗ dv_profile = 0;
116 }
117 }
118
119 ✗ switch (dv_profile) {
120 ✗ case 4: /* HEVC with enhancement layer */
121 case 7:
122 ✗ if (s->enable > 0) {
123 ✗ av_log(s->logctx, AV_LOG_ERROR, "Coding of Dolby Vision enhancement "
124 "layers is currently unsupported.");
125 ✗ return AVERROR_PATCHWELCOME;
126 } else {
127 ✗ goto skip;
128 }
129 ✗ case 5: /* HEVC with proprietary IPTPQc2 */
130 ✗ bl_compat_id = 0;
131 ✗ break;
132 ✗ case 10:
133 /* FIXME: check for proper H.273 tags once those are added */
134 ✗ if (hdr && hdr->bl_video_full_range_flag) {
135 /* AV1 with proprietary IPTPQc2 */
136 ✗ bl_compat_id = 0;
137 ✗ break;
138 }
139 av_fallthrough;
140 case 8: /* HEVC (or AV1) with BL compatibility */
141 ✗ if (color_space == AVCOL_SPC_BT2020_NCL &&
142 ✗ color_primaries == AVCOL_PRI_BT2020 &&
143 color_trc == AVCOL_TRC_SMPTE2084) {
144 ✗ bl_compat_id = 1;
145 ✗ } else if (color_space == AVCOL_SPC_BT2020_NCL &&
146 ✗ color_primaries == AVCOL_PRI_BT2020 &&
147 color_trc == AVCOL_TRC_ARIB_STD_B67) {
148 ✗ bl_compat_id = 4;
149 ✗ } else if (color_space == AVCOL_SPC_BT709 &&
150 ✗ color_primaries == AVCOL_PRI_BT709 &&
151 color_trc == AVCOL_TRC_BT709) {
152 ✗ bl_compat_id = 2;
153 }
154 }
155
156 ✗ if (!dv_profile || bl_compat_id < 0) {
157 ✗ if (s->enable > 0) {
158 ✗ av_log(s->logctx, AV_LOG_ERROR, "Dolby Vision enabled, but could "
159 "not determine profile and compatibility mode. Double-check "
160 "colorspace and format settings for compatibility?\n");
161 ✗ return AVERROR(EINVAL);
162 }
163 ✗ goto skip;
164 }
165
166 ✗ if (compression != AV_DOVI_COMPRESSION_NONE) {
167 ✗ if (dv_profile < 8 && strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
168 ✗ av_log(s->logctx, AV_LOG_ERROR, "Dolby Vision metadata compression "
169 "is not permitted for profiles 7 and earlier. (dv_profile: %d, "
170 "compression: %d)\n", dv_profile, compression);
171 ✗ return AVERROR(EINVAL);
172 ✗ } else if (compression == AV_DOVI_COMPRESSION_EXTENDED &&
173 strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
174 ✗ av_log(s->logctx, AV_LOG_ERROR, "Dolby Vision extended metadata "
175 "compression is experimental and not supported by "
176 "devices.");
177 ✗ return AVERROR(EINVAL);
178 ✗ } else if (dv_profile == 8) {
179 ✗ av_log(s->logctx, AV_LOG_WARNING, "Dolby Vision metadata compression "
180 "for profile 8 is known to be unsupported by many devices, "
181 "use with caution.\n");
182 }
183 }
184
185 ✗ pps = width * height;
186 ✗ if (framerate.num) {
187 ✗ pps = pps * framerate.num / framerate.den;
188 } else {
189 ✗ pps *= 25; /* sanity fallback */
190 }
191
192 ✗ dv_level = 0;
193 ✗ for (int i = 1; i < FF_ARRAY_ELEMS(dv_levels); i++) {
194 ✗ if (pps > dv_levels[i].pps)
195 ✗ continue;
196 ✗ if (width > dv_levels[i].width)
197 ✗ continue;
198 /* In theory, we should also test the bitrate when known, and
199 * distinguish between main and high tier. In practice, just ignore
200 * the bitrate constraints and hope they work out. This would ideally
201 * be handled by either the encoder or muxer directly. */
202 ✗ dv_level = i;
203 ✗ break;
204 }
205
206 ✗ if (!dv_level) {
207 ✗ if (strict_std_compliance >= FF_COMPLIANCE_STRICT) {
208 ✗ av_log(s->logctx, AV_LOG_ERROR, "Coded PPS (%"PRIu64") and width (%d) "
209 "exceed Dolby Vision limitations\n", pps, width);
210 ✗ return AVERROR(EINVAL);
211 } else {
212 ✗ av_log(s->logctx, AV_LOG_WARNING, "Coded PPS (%"PRIu64") and width (%d) "
213 "exceed Dolby Vision limitations. Ignoring, resulting file "
214 "may be non-conforming.\n", pps, width);
215 ✗ dv_level = FF_ARRAY_ELEMS(dv_levels) - 1;
216 }
217 }
218
219 ✗ cfg = av_dovi_alloc(&cfg_size);
220 ✗ if (!cfg)
221 ✗ return AVERROR(ENOMEM);
222
223 ✗ if (!av_packet_side_data_add(coded_side_data,
224 nb_coded_side_data,
225 AV_PKT_DATA_DOVI_CONF, cfg, cfg_size, 0)) {
226 ✗ av_free(cfg);
227 ✗ return AVERROR(ENOMEM);
228 }
229
230 ✗ cfg->dv_version_major = 1;
231 ✗ cfg->dv_version_minor = 0;
232 ✗ cfg->dv_profile = dv_profile;
233 ✗ cfg->dv_level = dv_level;
234 ✗ cfg->rpu_present_flag = 1;
235 ✗ cfg->el_present_flag = 0;
236 ✗ cfg->bl_present_flag = 1;
237 ✗ cfg->dv_bl_signal_compatibility_id = bl_compat_id;
238 ✗ cfg->dv_md_compression = compression;
239
240 ✗ s->cfg = *cfg;
241 ✗ return 0;
242
243 ✗ skip:
244 ✗ s->cfg = (AVDOVIDecoderConfigurationRecord) {0};
245 ✗ return 0;
246 }
247
248 ✗ av_cold int ff_dovi_configure_from_codedpar(DOVIContext *s, AVCodecParameters *par,
249 const AVDOVIMetadata *metadata,
250 enum AVDOVICompression compression,
251 int strict_std_compliance)
252 {
253 ✗ return dovi_configure_ext(s, par->codec_id, metadata, compression,
254 strict_std_compliance, par->width, par->height,
255 ✗ par->framerate, par->format, par->color_space,
256 par->color_primaries, par->color_trc,
257 &par->coded_side_data, &par->nb_coded_side_data);
258 }
259
260 ✗ av_cold int ff_dovi_configure(DOVIContext *s, AVCodecContext *avctx)
261 {
262 ✗ const AVDOVIMetadata *metadata = NULL;
263 const AVFrameSideData *sd;
264 ✗ sd = av_frame_side_data_get(avctx->decoded_side_data,
265 avctx->nb_decoded_side_data,
266 AV_FRAME_DATA_DOVI_METADATA);
267 ✗ if (sd)
268 ✗ metadata = (const AVDOVIMetadata *) sd->data;
269
270 /* Current encoders cannot handle metadata compression during encoding */
271 ✗ return dovi_configure_ext(s, avctx->codec_id, metadata, AV_DOVI_COMPRESSION_NONE,
272 avctx->strict_std_compliance, avctx->width,
273 avctx->height, avctx->framerate, avctx->pix_fmt,
274 avctx->colorspace, avctx->color_primaries, avctx->color_trc,
275 &avctx->coded_side_data, &avctx->nb_coded_side_data);
276 }
277
278 /* Compares only the static DM metadata parts of AVDOVIColorMetadata (excluding
279 * dm_metadata_id and scene_refresh_flag) */
280 ✗ static int cmp_dm_level0(const AVDOVIColorMetadata *dm1,
281 const AVDOVIColorMetadata *dm2)
282 {
283 int ret;
284 ✗ for (int i = 0; i < FF_ARRAY_ELEMS(dm1->ycc_to_rgb_matrix); i++) {
285 ✗ if ((ret = av_cmp_q(dm1->ycc_to_rgb_matrix[i], dm2->ycc_to_rgb_matrix[i])))
286 ✗ return ret;
287 }
288
289 ✗ for (int i = 0; i < FF_ARRAY_ELEMS(dm1->ycc_to_rgb_offset); i++) {
290 ✗ if ((ret = av_cmp_q(dm1->ycc_to_rgb_offset[i], dm2->ycc_to_rgb_offset[i])))
291 ✗ return ret;
292 }
293
294 ✗ for (int i = 0; i < FF_ARRAY_ELEMS(dm1->rgb_to_lms_matrix); i++) {
295 ✗ if ((ret = av_cmp_q(dm1->rgb_to_lms_matrix[i], dm2->rgb_to_lms_matrix[i])))
296 ✗ return ret;
297 }
298
299 ✗ return memcmp(&dm1->signal_eotf, &dm2->signal_eotf,
300 sizeof(AVDOVIColorMetadata) -offsetof(AVDOVIColorMetadata, signal_eotf));
301 }
302
303 /* Tries to reuse the static ext blocks. May reorder `ext->dm_static` */
304 ✗ static int try_reuse_ext(DOVIExt *ext, const AVDOVIMetadata *metadata)
305 {
306 ✗ int i, j, idx = 0;
307
308 ✗ for (i = 0; i < metadata->num_ext_blocks; i++) {
309 ✗ const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
310 ✗ if (!ff_dovi_rpu_extension_is_static(dm->level))
311 ✗ continue;
312
313 /* Find the first matching ext block and move it to [idx] */
314 ✗ for (j = idx; j < ext->num_static; j++) {
315 ✗ if (!memcmp(&ext->dm_static[j], dm, sizeof(*dm))) {
316 ✗ if (j != idx)
317 ✗ FFSWAP(AVDOVIDmData, ext->dm_static[j], ext->dm_static[idx]);
318 ✗ idx++;
319 ✗ break;
320 }
321 }
322
323 ✗ if (j == ext->num_static) {
324 /* Found no matching ext block */
325 ✗ return 0;
326 }
327 }
328
329 /* If idx is less than ext->num_static, then there are extra unmatched
330 * ext blocks inside ext->dm_static */
331 ✗ return idx == ext->num_static;
332 }
333
334 ✗ static inline void put_ue_coef(PutBitContext *pb, const AVDOVIRpuDataHeader *hdr,
335 uint64_t coef)
336 {
337 union { uint32_t u32; float f32; } fpart;
338
339 ✗ switch (hdr->coef_data_type) {
340 ✗ case RPU_COEFF_FIXED:
341 ✗ set_ue_golomb(pb, coef >> hdr->coef_log2_denom);
342 ✗ put_bits63(pb, hdr->coef_log2_denom,
343 ✗ coef & ((1LL << hdr->coef_log2_denom) - 1));
344 ✗ break;
345 ✗ case RPU_COEFF_FLOAT:
346 ✗ fpart.f32 = coef / (float) (1LL << hdr->coef_log2_denom);
347 ✗ put_bits63(pb, hdr->coef_log2_denom, fpart.u32);
348 ✗ break;
349 }
350 ✗ }
351
352 ✗ static inline void put_se_coef(PutBitContext *pb, const AVDOVIRpuDataHeader *hdr,
353 uint64_t coef)
354 {
355 union { uint32_t u32; float f32; } fpart;
356
357 ✗ switch (hdr->coef_data_type) {
358 ✗ case RPU_COEFF_FIXED:
359 ✗ set_se_golomb(pb, coef >> hdr->coef_log2_denom);
360 ✗ put_bits63(pb, hdr->coef_log2_denom,
361 ✗ coef & ((1LL << hdr->coef_log2_denom) - 1));
362 ✗ break;
363 ✗ case RPU_COEFF_FLOAT:
364 ✗ fpart.f32 = coef / (float) (1LL << hdr->coef_log2_denom);
365 ✗ put_bits63(pb, hdr->coef_log2_denom, fpart.u32);
366 ✗ break;
367 }
368 ✗ }
369
370 ✗ static int validate_ue_golomb_value(uint64_t value)
371 {
372 ✗ return value <= 0xFFFE;
373 }
374
375 ✗ static int validate_se_golomb_value(int64_t value)
376 {
377 ✗ return value >= -0x7FFF && value <= 0x7FFF;
378 }
379
380 ✗ static int validate_ue_coef(const AVDOVIRpuDataHeader *hdr, uint64_t coef)
381 {
382 ✗ if (hdr->coef_log2_denom >= 63)
383 ✗ return 0;
384 ✗ return validate_ue_golomb_value(coef >> hdr->coef_log2_denom);
385 }
386
387 ✗ static int validate_se_coef(const AVDOVIRpuDataHeader *hdr, int64_t coef)
388 {
389 ✗ if (hdr->coef_log2_denom >= 63)
390 ✗ return 0;
391 ✗ return validate_se_golomb_value(coef >> hdr->coef_log2_denom);
392 }
393
394 ✗ static int validate_mapping_for_generation(const AVDOVIRpuDataHeader *hdr,
395 const AVDOVIDataMapping *mapping)
396 {
397 ✗ if (!mapping->num_x_partitions || mapping->num_x_partitions > 0xFFFF ||
398 ✗ !mapping->num_y_partitions || mapping->num_y_partitions > 0xFFFF)
399 ✗ return 0;
400
401 ✗ for (int c = 0; c < 3; c++) {
402 ✗ const AVDOVIReshapingCurve *curve = &mapping->curves[c];
403
404 ✗ if (curve->num_pivots < 2 || curve->num_pivots > AV_DOVI_MAX_PIECES + 1)
405 ✗ return 0;
406
407 ✗ for (int i = 1; i < curve->num_pivots; i++)
408 ✗ if (curve->pivots[i] < curve->pivots[i - 1])
409 ✗ return 0;
410
411 ✗ for (int i = 0; i < curve->num_pivots - 1; i++) {
412 ✗ switch (curve->mapping_idc[i]) {
413 ✗ case AV_DOVI_MAPPING_POLYNOMIAL:
414 ✗ if (curve->poly_order[i] < 1 || curve->poly_order[i] > 2)
415 ✗ return 0;
416 ✗ for (int k = 0; k <= curve->poly_order[i]; k++)
417 ✗ if (!validate_se_coef(hdr, curve->poly_coef[i][k]))
418 ✗ return 0;
419 ✗ break;
420 ✗ case AV_DOVI_MAPPING_MMR:
421 ✗ if (curve->mmr_order[i] < 1 || curve->mmr_order[i] > 3)
422 ✗ return 0;
423 ✗ if (!validate_se_coef(hdr, curve->mmr_constant[i]))
424 ✗ return 0;
425 ✗ for (int j = 0; j < curve->mmr_order[i]; j++)
426 ✗ for (int k = 0; k < 7; k++)
427 ✗ if (!validate_se_coef(hdr, curve->mmr_coef[i][j][k]))
428 ✗ return 0;
429 ✗ break;
430 ✗ default:
431 ✗ return 0;
432 }
433 }
434 }
435
436 ✗ if (mapping->nlq_method_idc != AV_DOVI_NLQ_NONE) {
437 ✗ if (mapping->nlq_method_idc != AV_DOVI_NLQ_LINEAR_DZ)
438 ✗ return 0;
439 ✗ for (int c = 0; c < 3; c++) {
440 ✗ const AVDOVINLQParams *nlq = &mapping->nlq[c];
441 ✗ if (!validate_ue_coef(hdr, nlq->vdr_in_max) ||
442 ✗ !validate_ue_coef(hdr, nlq->linear_deadzone_slope) ||
443 ✗ !validate_ue_coef(hdr, nlq->linear_deadzone_threshold))
444 ✗ return 0;
445 }
446 }
447
448 ✗ return 1;
449 }
450
451 ✗ static int av_q2den(AVRational q, int den)
452 {
453 ✗ if (!q.den || q.den == den)
454 ✗ return q.num;
455 ✗ q = av_mul_q(q, av_make_q(den, 1));
456 ✗ return (q.num + (q.den >> 1)) / q.den;
457 }
458
459 ✗ static void generate_ext_v1(PutBitContext *pb, const AVDOVIDmData *dm)
460 {
461 int ext_block_length, start_pos, pad_bits;
462
463 ✗ switch (dm->level) {
464 ✗ case 1: ext_block_length = 5; break;
465 ✗ case 2: ext_block_length = 11; break;
466 ✗ case 4: ext_block_length = 3; break;
467 ✗ case 5: ext_block_length = 7; break;
468 ✗ case 6: ext_block_length = 8; break;
469 ✗ case 255: ext_block_length = 6; break;
470 ✗ default: return;
471 }
472
473 ✗ set_ue_golomb(pb, ext_block_length);
474 ✗ put_bits(pb, 8, dm->level);
475 ✗ start_pos = put_bits_count(pb);
476
477 ✗ switch (dm->level) {
478 ✗ case 1:
479 ✗ put_bits(pb, 12, dm->l1.min_pq);
480 ✗ put_bits(pb, 12, dm->l1.max_pq);
481 ✗ put_bits(pb, 12, dm->l1.avg_pq);
482 ✗ break;
483 ✗ case 2:
484 ✗ put_bits(pb, 12, dm->l2.target_max_pq);
485 ✗ put_bits(pb, 12, dm->l2.trim_slope);
486 ✗ put_bits(pb, 12, dm->l2.trim_offset);
487 ✗ put_bits(pb, 12, dm->l2.trim_power);
488 ✗ put_bits(pb, 12, dm->l2.trim_chroma_weight);
489 ✗ put_bits(pb, 12, dm->l2.trim_saturation_gain);
490 ✗ put_sbits(pb, 13, dm->l2.ms_weight);
491 ✗ break;
492 ✗ case 4:
493 ✗ put_bits(pb, 12, dm->l4.anchor_pq);
494 ✗ put_bits(pb, 12, dm->l4.anchor_power);
495 ✗ break;
496 ✗ case 5:
497 ✗ put_bits(pb, 13, dm->l5.left_offset);
498 ✗ put_bits(pb, 13, dm->l5.right_offset);
499 ✗ put_bits(pb, 13, dm->l5.top_offset);
500 ✗ put_bits(pb, 13, dm->l5.bottom_offset);
501 ✗ break;
502 ✗ case 6:
503 ✗ put_bits(pb, 16, dm->l6.max_luminance);
504 ✗ put_bits(pb, 16, dm->l6.min_luminance);
505 ✗ put_bits(pb, 16, dm->l6.max_cll);
506 ✗ put_bits(pb, 16, dm->l6.max_fall);
507 ✗ break;
508 ✗ case 255:
509 ✗ put_bits(pb, 8, dm->l255.dm_run_mode);
510 ✗ put_bits(pb, 8, dm->l255.dm_run_version);
511 ✗ for (int i = 0; i < 4; i++)
512 ✗ put_bits(pb, 8, dm->l255.dm_debug[i]);
513 ✗ break;
514 }
515
516 ✗ pad_bits = ext_block_length * 8 - (put_bits_count(pb) - start_pos);
517 av_assert1(pad_bits >= 0);
518 ✗ put_bits(pb, pad_bits, 0);
519 }
520
521 ✗ static void put_cie_xy(PutBitContext *pb, AVCIExy xy)
522 {
523 ✗ const int denom = 32767;
524 ✗ put_sbits(pb, 16, av_q2den(xy.x, denom));
525 ✗ put_sbits(pb, 16, av_q2den(xy.y, denom));
526 ✗ }
527
528 #define ANY6(arr) (arr[0] || arr[1] || arr[2] || arr[3] || arr[4] || arr[5])
529 #define ANY_XY(xy) (xy.x.num || xy.y.num)
530 #define ANY_CSP(csp) (ANY_XY(csp.prim.r) || ANY_XY(csp.prim.g) || \
531 ANY_XY(csp.prim.b) || ANY_XY(csp.wp))
532
533 ✗ static void generate_ext_v2(PutBitContext *pb, const AVDOVIDmData *dm)
534 {
535 int ext_block_length, start_pos, pad_bits;
536
537 ✗ switch (dm->level) {
538 ✗ case 3: ext_block_length = 5; break;
539 ✗ case 8:
540 ✗ if (ANY6(dm->l8.hue_vector_field)) {
541 ✗ ext_block_length = 25;
542 ✗ } else if (ANY6(dm->l8.saturation_vector_field)) {
543 ✗ ext_block_length = 19;
544 ✗ } else if (dm->l8.clip_trim) {
545 ✗ ext_block_length = 13;
546 ✗ } else if (dm->l8.target_mid_contrast) {
547 ✗ ext_block_length = 12;
548 } else {
549 ✗ ext_block_length = 10;
550 }
551 ✗ break;
552 ✗ case 9:
553 ✗ if (ANY_CSP(dm->l9.source_display_primaries)) {
554 ✗ ext_block_length = 17;
555 } else {
556 ✗ ext_block_length = 1;
557 }
558 ✗ break;
559 ✗ case 10:
560 ✗ if (ANY_CSP(dm->l10.target_display_primaries)) {
561 ✗ ext_block_length = 21;
562 } else {
563 ✗ ext_block_length = 5;
564 }
565 ✗ break;
566 ✗ case 11: ext_block_length = 4; break;
567 ✗ case 254: ext_block_length = 2; break;
568 ✗ default: return;
569 }
570
571 ✗ set_ue_golomb(pb, ext_block_length);
572 ✗ put_bits(pb, 8, dm->level);
573 ✗ start_pos = put_bits_count(pb);
574
575 ✗ switch (dm->level) {
576 ✗ case 3:
577 ✗ put_bits(pb, 12, dm->l3.min_pq_offset);
578 ✗ put_bits(pb, 12, dm->l3.max_pq_offset);
579 ✗ put_bits(pb, 12, dm->l3.avg_pq_offset);
580 ✗ break;
581 ✗ case 8:
582 ✗ put_bits(pb, 8, dm->l8.target_display_index);
583 ✗ put_bits(pb, 12, dm->l8.trim_slope);
584 ✗ put_bits(pb, 12, dm->l8.trim_offset);
585 ✗ put_bits(pb, 12, dm->l8.trim_power);
586 ✗ put_bits(pb, 12, dm->l8.trim_chroma_weight);
587 ✗ put_bits(pb, 12, dm->l8.trim_saturation_gain);
588 ✗ put_bits(pb, 12, dm->l8.ms_weight);
589 ✗ if (ext_block_length < 12)
590 ✗ break;
591 ✗ put_bits(pb, 12, dm->l8.target_mid_contrast);
592 ✗ if (ext_block_length < 13)
593 ✗ break;
594 ✗ put_bits(pb, 12, dm->l8.clip_trim);
595 ✗ if (ext_block_length < 19)
596 ✗ break;
597 ✗ for (int i = 0; i < 6; i++)
598 ✗ put_bits(pb, 8, dm->l8.saturation_vector_field[i]);
599 ✗ if (ext_block_length < 25)
600 ✗ break;
601 ✗ for (int i = 0; i < 6; i++)
602 ✗ put_bits(pb, 8, dm->l8.hue_vector_field[i]);
603 ✗ break;
604 ✗ case 9:
605 ✗ put_bits(pb, 8, dm->l9.source_primary_index);
606 ✗ if (ext_block_length < 17)
607 ✗ break;
608 ✗ put_cie_xy(pb, dm->l9.source_display_primaries.prim.r);
609 ✗ put_cie_xy(pb, dm->l9.source_display_primaries.prim.g);
610 ✗ put_cie_xy(pb, dm->l9.source_display_primaries.prim.b);
611 ✗ put_cie_xy(pb, dm->l9.source_display_primaries.wp);
612 ✗ break;
613 ✗ case 10:
614 ✗ put_bits(pb, 8, dm->l10.target_display_index);
615 ✗ put_bits(pb, 12, dm->l10.target_max_pq);
616 ✗ put_bits(pb, 12, dm->l10.target_min_pq);
617 ✗ put_bits(pb, 8, dm->l10.target_primary_index);
618 ✗ if (ext_block_length < 21)
619 ✗ break;
620 ✗ put_cie_xy(pb, dm->l10.target_display_primaries.prim.r);
621 ✗ put_cie_xy(pb, dm->l10.target_display_primaries.prim.g);
622 ✗ put_cie_xy(pb, dm->l10.target_display_primaries.prim.b);
623 ✗ put_cie_xy(pb, dm->l10.target_display_primaries.wp);
624 ✗ break;
625 ✗ case 11:
626 ✗ put_bits(pb, 8, dm->l11.content_type);
627 ✗ put_bits(pb, 4, dm->l11.whitepoint);
628 ✗ put_bits(pb, 1, dm->l11.reference_mode_flag);
629 ✗ put_bits(pb, 3, 0); /* reserved */
630 ✗ put_bits(pb, 8, 0); /* reserved */
631 ✗ put_bits(pb, 8, 0); /* reserved */
632 ✗ break;
633 ✗ case 254:
634 ✗ put_bits(pb, 8, dm->l254.dm_mode);
635 ✗ put_bits(pb, 8, dm->l254.dm_version_index);
636 ✗ break;
637 }
638
639 ✗ pad_bits = ext_block_length * 8 - (put_bits_count(pb) - start_pos);
640 av_assert1(pad_bits >= 0);
641 ✗ put_bits(pb, pad_bits, 0);
642 }
643
644 ✗ int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata,
645 int flags, uint8_t **out_rpu, int *out_size)
646 {
647 ✗ PutBitContext *pb = &(PutBitContext){0};
648 const AVDOVIRpuDataHeader *hdr;
649 const AVDOVIDataMapping *mapping;
650 const AVDOVIColorMetadata *color;
651 int vdr_dm_metadata_present, vdr_rpu_id, use_prev_vdr_rpu, profile,
652 buffer_size, rpu_size, pad, zero_run, dm_compression;
653 int num_ext_blocks_v1, num_ext_blocks_v2;
654 ✗ int dv_md_compression = s->cfg.dv_md_compression;
655 uint32_t crc;
656 uint8_t *dst;
657 ✗ if (!metadata) {
658 ✗ *out_rpu = NULL;
659 ✗ *out_size = 0;
660 ✗ return 0;
661 }
662
663 ✗ hdr = av_dovi_get_header(metadata);
664 ✗ mapping = av_dovi_get_mapping(metadata);
665 ✗ color = av_dovi_get_color(metadata);
666 ✗ av_assert0(s->cfg.dv_profile);
667
668 ✗ if (!(flags & FF_DOVI_COMPRESS_RPU))
669 ✗ dv_md_compression = AV_DOVI_COMPRESSION_NONE;
670 ✗ else if (dv_md_compression == AV_DOVI_COMPRESSION_RESERVED)
671 ✗ return AVERROR(EINVAL);
672
673 ✗ if (hdr->rpu_type != 2) {
674 ✗ av_log(s->logctx, AV_LOG_ERROR, "Unhandled RPU type %"PRIu8"\n",
675 ✗ hdr->rpu_type);
676 ✗ return AVERROR_INVALIDDATA;
677 }
678
679 ✗ if (!validate_mapping_for_generation(hdr, mapping)) {
680 ✗ av_log(s->logctx, AV_LOG_ERROR, "Coefficient out of range for RPU\n");
681 ✗ return AVERROR_INVALIDDATA;
682 }
683
684 ✗ if (!(flags & FF_DOVI_COMPRESS_RPU))
685 ✗ dv_md_compression = AV_DOVI_COMPRESSION_NONE;
686
687 ✗ vdr_rpu_id = mapping->vdr_rpu_id;
688 ✗ if (vdr_rpu_id < 0 || vdr_rpu_id > DOVI_MAX_DM_ID) {
689 ✗ av_log(s->logctx, AV_LOG_ERROR, "Invalid VDR RPU id %d\n", vdr_rpu_id);
690 ✗ return AVERROR_INVALIDDATA;
691 }
692 ✗ use_prev_vdr_rpu = 0;
693
694 ✗ if (!s->vdr[vdr_rpu_id]) {
695 ✗ s->vdr[vdr_rpu_id] = av_refstruct_allocz(sizeof(AVDOVIDataMapping));
696 ✗ if (!s->vdr[vdr_rpu_id])
697 ✗ return AVERROR(ENOMEM);
698 }
699
700 ✗ switch (dv_md_compression) {
701 ✗ case AV_DOVI_COMPRESSION_LIMITED:
702 /* Limited metadata compression requires vdr_rpi_id == 0 */
703 ✗ if (vdr_rpu_id != 0)
704 ✗ break;
705 av_fallthrough;
706 case AV_DOVI_COMPRESSION_EXTENDED:
707 ✗ if (s->vdr[vdr_rpu_id])
708 ✗ use_prev_vdr_rpu = !memcmp(s->vdr[vdr_rpu_id], mapping, sizeof(*mapping));
709 ✗ break;
710 ✗ case AV_DOVI_COMPRESSION_RESERVED:
711 ✗ return AVERROR(EINVAL);
712 }
713
714 ✗ if (s->cfg.dv_md_compression != AV_DOVI_COMPRESSION_EXTENDED) {
715 /* Flush VDRs to avoid leaking old state; maintaining multiple VDR
716 * references requires extended compression */
717 ✗ for (int i = 0; i <= DOVI_MAX_DM_ID; i++) {
718 ✗ if (i != vdr_rpu_id)
719 ✗ av_refstruct_unref(&s->vdr[i]);
720 }
721 }
722
723 ✗ if (metadata->num_ext_blocks && !s->ext_blocks) {
724 ✗ s->ext_blocks = av_refstruct_allocz(sizeof(*s->ext_blocks));
725 ✗ if (!s->ext_blocks)
726 ✗ return AVERROR(ENOMEM);
727 }
728
729 ✗ vdr_dm_metadata_present = !!memcmp(color, &ff_dovi_color_default, sizeof(*color));
730 ✗ if (metadata->num_ext_blocks)
731 ✗ vdr_dm_metadata_present = 1;
732
733 ✗ if (vdr_dm_metadata_present && !s->dm) {
734 ✗ s->dm = av_refstruct_allocz(sizeof(AVDOVIColorMetadata));
735 ✗ if (!s->dm)
736 ✗ return AVERROR(ENOMEM);
737 }
738
739 ✗ dm_compression = 0;
740 ✗ if (dv_md_compression != AV_DOVI_COMPRESSION_NONE) {
741 ✗ if (s->dm && !cmp_dm_level0(s->dm, color) && try_reuse_ext(s->ext_blocks, metadata))
742 ✗ dm_compression = 1;
743 }
744
745 ✗ num_ext_blocks_v1 = num_ext_blocks_v2 = 0;
746 ✗ for (int i = 0; i < metadata->num_ext_blocks; i++) {
747 ✗ const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
748 ✗ if (dm_compression && ff_dovi_rpu_extension_is_static(dm->level))
749 ✗ continue;
750
751 ✗ switch (dm->level) {
752 ✗ case 1:
753 case 2:
754 case 4:
755 case 5:
756 case 6:
757 case 255:
758 ✗ num_ext_blocks_v1++;
759 ✗ break;
760 ✗ case 3:
761 case 8:
762 case 9:
763 case 10:
764 case 11:
765 case 254:
766 ✗ num_ext_blocks_v2++;
767 ✗ break;
768 ✗ default:
769 ✗ av_log(s->logctx, AV_LOG_ERROR, "Invalid ext block level %d\n",
770 ✗ dm->level);
771 ✗ return AVERROR_INVALIDDATA;
772 }
773 }
774
775 ✗ buffer_size = 12 /* vdr seq info */ + 5 /* CRC32 + terminator */;
776 ✗ buffer_size += num_ext_blocks_v1 * 13;
777 ✗ buffer_size += num_ext_blocks_v2 * 28;
778 ✗ if (!use_prev_vdr_rpu) {
779 ✗ buffer_size += 160;
780 ✗ for (int c = 0; c < 3; c++) {
781 ✗ for (int i = 0; i < mapping->curves[c].num_pivots - 1; i++) {
782 ✗ switch (mapping->curves[c].mapping_idc[i]) {
783 ✗ case AV_DOVI_MAPPING_POLYNOMIAL: buffer_size += 26; break;
784 ✗ case AV_DOVI_MAPPING_MMR: buffer_size += 177; break;
785 }
786 }
787 }
788 }
789 ✗ if (vdr_dm_metadata_present)
790 ✗ buffer_size += 67;
791
792 ✗ av_fast_padded_malloc(&s->rpu_buf, &s->rpu_buf_sz, buffer_size);
793 ✗ if (!s->rpu_buf)
794 ✗ return AVERROR(ENOMEM);
795 ✗ init_put_bits(pb, s->rpu_buf, s->rpu_buf_sz);
796
797 /* RPU header */
798 ✗ put_bits(pb, 6, hdr->rpu_type);
799 ✗ put_bits(pb, 11, hdr->rpu_format);
800 ✗ put_bits(pb, 4, hdr->vdr_rpu_profile);
801 ✗ put_bits(pb, 4, hdr->vdr_rpu_level);
802 ✗ put_bits(pb, 1, 1); /* vdr_seq_info_present */
803 ✗ put_bits(pb, 1, hdr->chroma_resampling_explicit_filter_flag);
804 ✗ put_bits(pb, 2, hdr->coef_data_type);
805 ✗ if (hdr->coef_data_type == RPU_COEFF_FIXED)
806 ✗ set_ue_golomb(pb, hdr->coef_log2_denom);
807 ✗ put_bits(pb, 2, hdr->vdr_rpu_normalized_idc);
808 ✗ put_bits(pb, 1, hdr->bl_video_full_range_flag);
809 ✗ if ((hdr->rpu_format & 0x700) == 0) {
810 ✗ int ext_mapping_idc = (hdr->ext_mapping_idc_5_7 << 5) | hdr->ext_mapping_idc_0_4;
811 ✗ set_ue_golomb(pb, hdr->bl_bit_depth - 8);
812 ✗ set_ue_golomb(pb, (ext_mapping_idc << 8) | (hdr->el_bit_depth - 8));
813 ✗ set_ue_golomb(pb, hdr->vdr_bit_depth - 8);
814 ✗ put_bits(pb, 1, hdr->spatial_resampling_filter_flag);
815 ✗ put_bits(pb, 3, dm_compression);
816 ✗ put_bits(pb, 1, hdr->el_spatial_resampling_filter_flag);
817 ✗ put_bits(pb, 1, hdr->disable_residual_flag);
818 }
819 ✗ s->header = *hdr;
820
821 ✗ put_bits(pb, 1, vdr_dm_metadata_present);
822 ✗ put_bits(pb, 1, use_prev_vdr_rpu);
823 ✗ set_ue_golomb(pb, vdr_rpu_id);
824 ✗ s->mapping = s->vdr[vdr_rpu_id];
825
826 ✗ profile = s->cfg.dv_profile ? s->cfg.dv_profile : ff_dovi_guess_profile_hevc(hdr);
827
828 ✗ if (!use_prev_vdr_rpu) {
829 ✗ set_ue_golomb(pb, mapping->mapping_color_space);
830 ✗ set_ue_golomb(pb, mapping->mapping_chroma_format_idc);
831 ✗ for (int c = 0; c < 3; c++) {
832 ✗ const AVDOVIReshapingCurve *curve = &mapping->curves[c];
833 ✗ int prev = 0;
834 ✗ set_ue_golomb(pb, curve->num_pivots - 2);
835 ✗ for (int i = 0; i < curve->num_pivots; i++) {
836 ✗ put_bits(pb, hdr->bl_bit_depth, curve->pivots[i] - prev);
837 ✗ prev = curve->pivots[i];
838 }
839 }
840
841 ✗ if (mapping->nlq_method_idc != AV_DOVI_NLQ_NONE) {
842 ✗ put_bits(pb, 3, mapping->nlq_method_idc);
843 ✗ put_bits(pb, hdr->bl_bit_depth, mapping->nlq_pivots[0]);
844 ✗ put_bits(pb, hdr->bl_bit_depth, mapping->nlq_pivots[1] - mapping->nlq_pivots[0]);
845 }
846
847 ✗ set_ue_golomb(pb, mapping->num_x_partitions - 1);
848 ✗ set_ue_golomb(pb, mapping->num_y_partitions - 1);
849
850 ✗ for (int c = 0; c < 3; c++) {
851 ✗ const AVDOVIReshapingCurve *curve = &mapping->curves[c];
852 ✗ for (int i = 0; i < curve->num_pivots - 1; i++) {
853 ✗ set_ue_golomb(pb, curve->mapping_idc[i]);
854 ✗ switch (curve->mapping_idc[i]) {
855 ✗ case AV_DOVI_MAPPING_POLYNOMIAL: {
856 ✗ set_ue_golomb(pb, curve->poly_order[i] - 1);
857 ✗ if (curve->poly_order[i] == 1)
858 ✗ put_bits(pb, 1, 0); /* linear_interp_flag */
859 ✗ for (int k = 0; k <= curve->poly_order[i]; k++)
860 ✗ put_se_coef(pb, hdr, curve->poly_coef[i][k]);
861 ✗ break;
862 }
863 ✗ case AV_DOVI_MAPPING_MMR: {
864 ✗ put_bits(pb, 2, curve->mmr_order[i] - 1);
865 ✗ put_se_coef(pb, hdr, curve->mmr_constant[i]);
866 ✗ for (int j = 0; j < curve->mmr_order[i]; j++) {
867 ✗ for (int k = 0; k < 7; k++)
868 ✗ put_se_coef(pb, hdr, curve->mmr_coef[i][j][k]);
869 }
870 ✗ break;
871 }
872 }
873 }
874 }
875
876 ✗ if (mapping->nlq_method_idc != AV_DOVI_NLQ_NONE) {
877 ✗ for (int c = 0; c < 3; c++) {
878 ✗ const AVDOVINLQParams *nlq = &mapping->nlq[c];
879 ✗ put_bits(pb, hdr->el_bit_depth, nlq->nlq_offset);
880 ✗ put_ue_coef(pb, hdr, nlq->vdr_in_max);
881 ✗ switch (mapping->nlq_method_idc) {
882 ✗ case AV_DOVI_NLQ_LINEAR_DZ:
883 ✗ put_ue_coef(pb, hdr, nlq->linear_deadzone_slope);
884 ✗ put_ue_coef(pb, hdr, nlq->linear_deadzone_threshold);
885 ✗ break;
886 }
887 }
888 }
889
890 ✗ memcpy(s->vdr[vdr_rpu_id], mapping, sizeof(*mapping));
891 }
892
893 ✗ if (vdr_dm_metadata_present) {
894 ✗ DOVIExt *ext = s->ext_blocks;
895 ✗ const int denom = profile == 4 ? (1 << 30) : (1 << 28);
896 ✗ set_ue_golomb(pb, color->dm_metadata_id); /* affected_dm_id */
897 ✗ set_ue_golomb(pb, color->dm_metadata_id); /* current_dm_id */
898 ✗ set_ue_golomb(pb, color->scene_refresh_flag);
899 ✗ if (!dm_compression) {
900 ✗ for (int i = 0; i < 9; i++)
901 ✗ put_sbits(pb, 16, av_q2den(color->ycc_to_rgb_matrix[i], 1 << 13));
902 ✗ for (int i = 0; i < 3; i++)
903 ✗ put_bits32(pb, av_q2den(color->ycc_to_rgb_offset[i], denom));
904 ✗ for (int i = 0; i < 9; i++)
905 ✗ put_sbits(pb, 16, av_q2den(color->rgb_to_lms_matrix[i], 1 << 14));
906 ✗ put_bits(pb, 16, color->signal_eotf);
907 ✗ put_bits(pb, 16, color->signal_eotf_param0);
908 ✗ put_bits(pb, 16, color->signal_eotf_param1);
909 ✗ put_bits32(pb, color->signal_eotf_param2);
910 ✗ put_bits(pb, 5, color->signal_bit_depth);
911 ✗ put_bits(pb, 2, color->signal_color_space);
912 ✗ put_bits(pb, 2, color->signal_chroma_format);
913 ✗ put_bits(pb, 2, color->signal_full_range_flag);
914 ✗ put_bits(pb, 12, color->source_min_pq);
915 ✗ put_bits(pb, 12, color->source_max_pq);
916 ✗ put_bits(pb, 10, color->source_diagonal);
917 }
918
919 ✗ memcpy(s->dm, color, sizeof(*color));
920 ✗ s->color = s->dm;
921
922 /* Extension blocks */
923 ✗ set_ue_golomb(pb, num_ext_blocks_v1);
924 ✗ align_put_bits(pb);
925 ✗ for (int i = 0; i < metadata->num_ext_blocks; i++) {
926 ✗ const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
927 ✗ if (dm_compression && ff_dovi_rpu_extension_is_static(dm->level))
928 ✗ continue;
929 ✗ generate_ext_v1(pb, dm);
930 }
931
932 ✗ if (num_ext_blocks_v2) {
933 ✗ set_ue_golomb(pb, num_ext_blocks_v2);
934 ✗ align_put_bits(pb);
935 ✗ for (int i = 0; i < metadata->num_ext_blocks; i++) {
936 ✗ const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
937 ✗ if (dm_compression && ff_dovi_rpu_extension_is_static(dm->level))
938 ✗ continue;
939 ✗ generate_ext_v2(pb, av_dovi_get_ext(metadata, i));
940 }
941 }
942
943 ✗ if (ext) {
944 ✗ size_t ext_sz = FFMIN(sizeof(AVDOVIDmData), metadata->ext_block_size);
945 ✗ ext->num_dynamic = 0;
946 ✗ if (!dm_compression)
947 ✗ ext->num_static = 0;
948 ✗ for (int i = 0; i < metadata->num_ext_blocks; i++) {
949 ✗ const AVDOVIDmData *dm = av_dovi_get_ext(metadata, i);
950 ✗ if (!ff_dovi_rpu_extension_is_static(dm->level))
951 ✗ memcpy(&ext->dm_dynamic[ext->num_dynamic++], dm, ext_sz);
952 ✗ else if (!dm_compression)
953 ✗ memcpy(&ext->dm_static[ext->num_static++], dm, ext_sz);
954 }
955 }
956 } else {
957 ✗ s->color = &ff_dovi_color_default;
958 ✗ av_refstruct_unref(&s->ext_blocks);
959 }
960
961 ✗ flush_put_bits(pb);
962 ✗ crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1,
963 ✗ s->rpu_buf, put_bytes_output(pb)));
964 ✗ put_bits32(pb, crc);
965 ✗ put_bits(pb, 8, 0x80); /* terminator */
966 ✗ flush_put_bits(pb);
967
968 ✗ rpu_size = put_bytes_output(pb);
969 ✗ if (flags & FF_DOVI_WRAP_T35) {
970 ✗ *out_rpu = av_malloc(rpu_size + 15);
971 ✗ if (!*out_rpu)
972 ✗ return AVERROR(ENOMEM);
973 ✗ init_put_bits(pb, *out_rpu, rpu_size + 15);
974 ✗ put_bits(pb, 8, ITU_T_T35_COUNTRY_CODE_US);
975 ✗ put_bits(pb, 16, ITU_T_T35_PROVIDER_CODE_DOLBY);
976 ✗ put_bits32(pb, 0x800); /* provider_oriented_code */
977 ✗ put_bits(pb, 27, 0x01be6841u); /* fixed EMDF header, see above */
978 ✗ if (rpu_size > 0xFF) {
979 av_assert2(rpu_size <= 0x10000);
980 ✗ put_bits(pb, 8, (rpu_size >> 8) - 1);
981 ✗ put_bits(pb, 1, 1); /* read_more */
982 ✗ put_bits(pb, 8, rpu_size & 0xFF);
983 ✗ put_bits(pb, 1, 0);
984 } else {
985 ✗ put_bits(pb, 8, rpu_size);
986 ✗ put_bits(pb, 1, 0);
987 }
988 ✗ ff_copy_bits(pb, s->rpu_buf, rpu_size * 8);
989 ✗ put_bits(pb, 17, 0x400); /* emdf payload id + emdf_protection */
990
991 ✗ pad = pb->bit_left & 7;
992 ✗ put_bits(pb, pad, (1 << pad) - 1); /* pad to next byte with 1 bits */
993 ✗ flush_put_bits(pb);
994 ✗ *out_size = put_bytes_output(pb);
995 ✗ return 0;
996 ✗ } else if (flags & FF_DOVI_WRAP_NAL) {
997 ✗ *out_rpu = dst = av_malloc(4 + rpu_size * 3 / 2); /* worst case */
998 ✗ if (!*out_rpu)
999 ✗ return AVERROR(ENOMEM);
1000 ✗ *dst++ = 25; /* NAL prefix */
1001 ✗ zero_run = 0;
1002 ✗ for (int i = 0; i < rpu_size; i++) {
1003 ✗ if (zero_run < 2) {
1004 ✗ if (s->rpu_buf[i] == 0) {
1005 ✗ zero_run++;
1006 } else {
1007 ✗ zero_run = 0;
1008 }
1009 } else {
1010 ✗ if ((s->rpu_buf[i] & ~3) == 0) {
1011 /* emulation prevention */
1012 ✗ *dst++ = 3;
1013 }
1014 ✗ zero_run = s->rpu_buf[i] == 0;
1015 }
1016 ✗ *dst++ = s->rpu_buf[i];
1017 }
1018 ✗ *out_size = dst - *out_rpu;
1019 ✗ return 0;
1020 } else {
1021 /* Return intermediate buffer directly */
1022 ✗ *out_rpu = s->rpu_buf;
1023 ✗ *out_size = rpu_size;
1024 ✗ s->rpu_buf = NULL;
1025 ✗ s->rpu_buf_sz = 0;
1026 ✗ return 0;
1027 }
1028 }
1029