FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/proresenc_kostya.c
Date: 2024-07-14 13:34:57
Exec Total Coverage
Lines: 455 641 71.0%
Functions: 16 22 72.7%
Branches: 174 296 58.8%

Line Branch Exec Source
1 /*
2 * Apple ProRes encoder
3 *
4 * Copyright (c) 2011 Anatoliy Wasserman
5 * Copyright (c) 2012 Konstantin Shishkov
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/mem_internal.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/pixdesc.h"
28 #include "avcodec.h"
29 #include "codec_internal.h"
30 #include "encode.h"
31 #include "fdctdsp.h"
32 #include "put_bits.h"
33 #include "profiles.h"
34 #include "bytestream.h"
35 #include "proresdata.h"
36
37 #define CFACTOR_Y422 2
38 #define CFACTOR_Y444 3
39
40 #define MAX_MBS_PER_SLICE 8
41
42 #define MAX_PLANES 4
43
44 enum {
45 PRORES_PROFILE_AUTO = -1,
46 PRORES_PROFILE_PROXY = 0,
47 PRORES_PROFILE_LT,
48 PRORES_PROFILE_STANDARD,
49 PRORES_PROFILE_HQ,
50 PRORES_PROFILE_4444,
51 PRORES_PROFILE_4444XQ,
52 };
53
54 enum {
55 QUANT_MAT_PROXY = 0,
56 QUANT_MAT_PROXY_CHROMA,
57 QUANT_MAT_LT,
58 QUANT_MAT_STANDARD,
59 QUANT_MAT_HQ,
60 QUANT_MAT_XQ_LUMA,
61 QUANT_MAT_DEFAULT,
62 };
63
64 static const uint8_t prores_quant_matrices[][64] = {
65 { // proxy
66 4, 7, 9, 11, 13, 14, 15, 63,
67 7, 7, 11, 12, 14, 15, 63, 63,
68 9, 11, 13, 14, 15, 63, 63, 63,
69 11, 11, 13, 14, 63, 63, 63, 63,
70 11, 13, 14, 63, 63, 63, 63, 63,
71 13, 14, 63, 63, 63, 63, 63, 63,
72 13, 63, 63, 63, 63, 63, 63, 63,
73 63, 63, 63, 63, 63, 63, 63, 63,
74 },
75 { // proxy chromas
76 4, 7, 9, 11, 13, 14, 63, 63,
77 7, 7, 11, 12, 14, 63, 63, 63,
78 9, 11, 13, 14, 63, 63, 63, 63,
79 11, 11, 13, 14, 63, 63, 63, 63,
80 11, 13, 14, 63, 63, 63, 63, 63,
81 13, 14, 63, 63, 63, 63, 63, 63,
82 13, 63, 63, 63, 63, 63, 63, 63,
83 63, 63, 63, 63, 63, 63, 63, 63
84 },
85 { // LT
86 4, 5, 6, 7, 9, 11, 13, 15,
87 5, 5, 7, 8, 11, 13, 15, 17,
88 6, 7, 9, 11, 13, 15, 15, 17,
89 7, 7, 9, 11, 13, 15, 17, 19,
90 7, 9, 11, 13, 14, 16, 19, 23,
91 9, 11, 13, 14, 16, 19, 23, 29,
92 9, 11, 13, 15, 17, 21, 28, 35,
93 11, 13, 16, 17, 21, 28, 35, 41,
94 },
95 { // standard
96 4, 4, 5, 5, 6, 7, 7, 9,
97 4, 4, 5, 6, 7, 7, 9, 9,
98 5, 5, 6, 7, 7, 9, 9, 10,
99 5, 5, 6, 7, 7, 9, 9, 10,
100 5, 6, 7, 7, 8, 9, 10, 12,
101 6, 7, 7, 8, 9, 10, 12, 15,
102 6, 7, 7, 9, 10, 11, 14, 17,
103 7, 7, 9, 10, 11, 14, 17, 21,
104 },
105 { // high quality
106 4, 4, 4, 4, 4, 4, 4, 4,
107 4, 4, 4, 4, 4, 4, 4, 4,
108 4, 4, 4, 4, 4, 4, 4, 4,
109 4, 4, 4, 4, 4, 4, 4, 5,
110 4, 4, 4, 4, 4, 4, 5, 5,
111 4, 4, 4, 4, 4, 5, 5, 6,
112 4, 4, 4, 4, 5, 5, 6, 7,
113 4, 4, 4, 4, 5, 6, 7, 7,
114 },
115 { // XQ luma
116 2, 2, 2, 2, 2, 2, 2, 2,
117 2, 2, 2, 2, 2, 2, 2, 2,
118 2, 2, 2, 2, 2, 2, 2, 2,
119 2, 2, 2, 2, 2, 2, 2, 3,
120 2, 2, 2, 2, 2, 2, 3, 3,
121 2, 2, 2, 2, 2, 3, 3, 3,
122 2, 2, 2, 2, 3, 3, 3, 4,
123 2, 2, 2, 2, 3, 3, 4, 4,
124 },
125 { // codec default
126 4, 4, 4, 4, 4, 4, 4, 4,
127 4, 4, 4, 4, 4, 4, 4, 4,
128 4, 4, 4, 4, 4, 4, 4, 4,
129 4, 4, 4, 4, 4, 4, 4, 4,
130 4, 4, 4, 4, 4, 4, 4, 4,
131 4, 4, 4, 4, 4, 4, 4, 4,
132 4, 4, 4, 4, 4, 4, 4, 4,
133 4, 4, 4, 4, 4, 4, 4, 4,
134 },
135 };
136
137 #define NUM_MB_LIMITS 4
138 static const int prores_mb_limits[NUM_MB_LIMITS] = {
139 1620, // up to 720x576
140 2700, // up to 960x720
141 6075, // up to 1440x1080
142 9216, // up to 2048x1152
143 };
144
145 static const struct prores_profile {
146 const char *full_name;
147 uint32_t tag;
148 int min_quant;
149 int max_quant;
150 int br_tab[NUM_MB_LIMITS];
151 int quant;
152 int quant_chroma;
153 } prores_profile_info[6] = {
154 {
155 .full_name = "proxy",
156 .tag = MKTAG('a', 'p', 'c', 'o'),
157 .min_quant = 4,
158 .max_quant = 8,
159 .br_tab = { 300, 242, 220, 194 },
160 .quant = QUANT_MAT_PROXY,
161 .quant_chroma = QUANT_MAT_PROXY_CHROMA,
162 },
163 {
164 .full_name = "LT",
165 .tag = MKTAG('a', 'p', 'c', 's'),
166 .min_quant = 1,
167 .max_quant = 9,
168 .br_tab = { 720, 560, 490, 440 },
169 .quant = QUANT_MAT_LT,
170 .quant_chroma = QUANT_MAT_LT,
171 },
172 {
173 .full_name = "standard",
174 .tag = MKTAG('a', 'p', 'c', 'n'),
175 .min_quant = 1,
176 .max_quant = 6,
177 .br_tab = { 1050, 808, 710, 632 },
178 .quant = QUANT_MAT_STANDARD,
179 .quant_chroma = QUANT_MAT_STANDARD,
180 },
181 {
182 .full_name = "high quality",
183 .tag = MKTAG('a', 'p', 'c', 'h'),
184 .min_quant = 1,
185 .max_quant = 6,
186 .br_tab = { 1566, 1216, 1070, 950 },
187 .quant = QUANT_MAT_HQ,
188 .quant_chroma = QUANT_MAT_HQ,
189 },
190 {
191 .full_name = "4444",
192 .tag = MKTAG('a', 'p', '4', 'h'),
193 .min_quant = 1,
194 .max_quant = 6,
195 .br_tab = { 2350, 1828, 1600, 1425 },
196 .quant = QUANT_MAT_HQ,
197 .quant_chroma = QUANT_MAT_HQ,
198 },
199 {
200 .full_name = "4444XQ",
201 .tag = MKTAG('a', 'p', '4', 'x'),
202 .min_quant = 1,
203 .max_quant = 6,
204 .br_tab = { 3525, 2742, 2400, 2137 },
205 .quant = QUANT_MAT_HQ, /* Fix me : use QUANT_MAT_XQ_LUMA */
206 .quant_chroma = QUANT_MAT_HQ,
207 }
208 };
209
210 #define TRELLIS_WIDTH 16
211 #define SCORE_LIMIT INT_MAX / 2
212
213 struct TrellisNode {
214 int prev_node;
215 int quant;
216 int bits;
217 int score;
218 };
219
220 #define MAX_STORED_Q 16
221
222 typedef struct ProresThreadData {
223 DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
224 DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
225 int16_t custom_q[64];
226 int16_t custom_chroma_q[64];
227 struct TrellisNode *nodes;
228 } ProresThreadData;
229
230 typedef struct ProresContext {
231 AVClass *class;
232 DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
233 DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
234 int16_t quants[MAX_STORED_Q][64];
235 int16_t quants_chroma[MAX_STORED_Q][64];
236 int16_t custom_q[64];
237 int16_t custom_chroma_q[64];
238 const uint8_t *quant_mat;
239 const uint8_t *quant_chroma_mat;
240 const uint8_t *scantable;
241
242 void (*fdct)(FDCTDSPContext *fdsp, const uint16_t *src,
243 ptrdiff_t linesize, int16_t *block);
244 FDCTDSPContext fdsp;
245
246 const AVFrame *pic;
247 int mb_width, mb_height;
248 int mbs_per_slice;
249 int num_chroma_blocks, chroma_factor;
250 int slices_width;
251 int slices_per_picture;
252 int pictures_per_frame; // 1 for progressive, 2 for interlaced
253 int cur_picture_idx;
254 int num_planes;
255 int bits_per_mb;
256 int force_quant;
257 int alpha_bits;
258 int warn;
259
260 char *vendor;
261 int quant_sel;
262
263 int frame_size_upper_bound;
264
265 int profile;
266 const struct prores_profile *profile_info;
267
268 int *slice_q;
269
270 ProresThreadData *tdata;
271 } ProresContext;
272
273 66600 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
274 ptrdiff_t linesize, int x, int y, int w, int h,
275 int16_t *blocks, uint16_t *emu_buf,
276 int mbs_per_slice, int blocks_per_mb, int is_chroma)
277 {
278 const uint16_t *esrc;
279 66600 const int mb_width = 4 * blocks_per_mb;
280 ptrdiff_t elinesize;
281 int i, j, k;
282
283
2/2
✓ Branch 0 taken 359100 times.
✓ Branch 1 taken 66600 times.
425700 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
284
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 359100 times.
359100 if (x >= w) {
285 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
286 * sizeof(*blocks));
287 return;
288 }
289
4/4
✓ Branch 0 taken 358200 times.
✓ Branch 1 taken 900 times.
✓ Branch 2 taken 357600 times.
✓ Branch 3 taken 600 times.
359100 if (x + mb_width <= w && y + 16 <= h) {
290 357600 esrc = src;
291 357600 elinesize = linesize;
292 } else {
293 int bw, bh, pix;
294
295 1500 esrc = emu_buf;
296 1500 elinesize = 16 * sizeof(*emu_buf);
297
298 1500 bw = FFMIN(w - x, mb_width);
299 1500 bh = FFMIN(h - y, 16);
300
301
2/2
✓ Branch 0 taken 11400 times.
✓ Branch 1 taken 1500 times.
12900 for (j = 0; j < bh; j++) {
302 11400 memcpy(emu_buf + j * 16,
303 11400 (const uint8_t*)src + j * linesize,
304 bw * sizeof(*src));
305 11400 pix = emu_buf[j * 16 + bw - 1];
306
2/2
✓ Branch 0 taken 95200 times.
✓ Branch 1 taken 11400 times.
106600 for (k = bw; k < mb_width; k++)
307 95200 emu_buf[j * 16 + k] = pix;
308 }
309
2/2
✓ Branch 0 taken 12600 times.
✓ Branch 1 taken 1500 times.
14100 for (; j < 16; j++)
310 12600 memcpy(emu_buf + j * 16,
311 12600 emu_buf + (bh - 1) * 16,
312 mb_width * sizeof(*emu_buf));
313 }
314
2/2
✓ Branch 0 taken 119700 times.
✓ Branch 1 taken 239400 times.
359100 if (!is_chroma) {
315 119700 ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
316 119700 blocks += 64;
317
1/2
✓ Branch 0 taken 119700 times.
✗ Branch 1 not taken.
119700 if (blocks_per_mb > 2) {
318 119700 ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
319 119700 blocks += 64;
320 }
321 119700 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
322 119700 blocks += 64;
323
1/2
✓ Branch 0 taken 119700 times.
✗ Branch 1 not taken.
119700 if (blocks_per_mb > 2) {
324 119700 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
325 119700 blocks += 64;
326 }
327 } else {
328 239400 ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
329 239400 blocks += 64;
330 239400 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
331 239400 blocks += 64;
332
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 239400 times.
239400 if (blocks_per_mb > 2) {
333 ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
334 blocks += 64;
335 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
336 blocks += 64;
337 }
338 }
339
340 359100 x += mb_width;
341 }
342 }
343
344 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
345 ptrdiff_t linesize, int x, int y, int w, int h,
346 uint16_t *blocks, int mbs_per_slice, int abits)
347 {
348 const int slice_width = 16 * mbs_per_slice;
349 int i, j, copy_w, copy_h;
350
351 copy_w = FFMIN(w - x, slice_width);
352 copy_h = FFMIN(h - y, 16);
353 for (i = 0; i < copy_h; i++) {
354 memcpy(blocks, src, copy_w * sizeof(*src));
355 if (abits == 8)
356 for (j = 0; j < copy_w; j++)
357 blocks[j] >>= 2;
358 else
359 for (j = 0; j < copy_w; j++)
360 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
361 for (j = copy_w; j < slice_width; j++)
362 blocks[j] = blocks[copy_w - 1];
363 blocks += slice_width;
364 src += linesize >> 1;
365 }
366 for (; i < 16; i++) {
367 memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));
368 blocks += slice_width;
369 }
370 }
371
372 /**
373 * Write an unsigned rice/exp golomb codeword.
374 */
375 26885174 static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
376 {
377 unsigned int rice_order, exp_order, switch_bits, switch_val;
378 int exponent;
379
380 /* number of prefix bits to switch between Rice and expGolomb */
381 26885174 switch_bits = (codebook & 3) + 1;
382 26885174 rice_order = codebook >> 5; /* rice code order */
383 26885174 exp_order = (codebook >> 2) & 7; /* exp golomb code order */
384
385 26885174 switch_val = switch_bits << rice_order;
386
387
2/2
✓ Branch 0 taken 8074309 times.
✓ Branch 1 taken 18810865 times.
26885174 if (val >= switch_val) {
388 8074309 val -= switch_val - (1 << exp_order);
389 8074309 exponent = av_log2(val);
390
391 8074309 put_bits(pb, exponent - exp_order + switch_bits, 0);
392 8074309 put_bits(pb, exponent + 1, val);
393 } else {
394 18810865 exponent = val >> rice_order;
395
396
2/2
✓ Branch 0 taken 4838901 times.
✓ Branch 1 taken 13971964 times.
18810865 if (exponent)
397 4838901 put_bits(pb, exponent, 0);
398 18810865 put_bits(pb, 1, 1);
399
2/2
✓ Branch 0 taken 1904515 times.
✓ Branch 1 taken 16906350 times.
18810865 if (rice_order)
400 1904515 put_sbits(pb, rice_order, val);
401 }
402 26885174 }
403
404 #define GET_SIGN(x) ((x) >> 31)
405 #define MAKE_CODE(x) (((x) * 2) ^ GET_SIGN(x))
406
407 33300 static void encode_dcs(PutBitContext *pb, int16_t *blocks,
408 int blocks_per_slice, int scale)
409 {
410 int i;
411 33300 int codebook = 5, code, dc, prev_dc, delta, sign, new_sign;
412
413 33300 prev_dc = (blocks[0] - 0x4000) / scale;
414 33300 encode_vlc_codeword(pb, FIRST_DC_CB, MAKE_CODE(prev_dc));
415 33300 sign = 0;
416 33300 blocks += 64;
417
418
2/2
✓ Branch 0 taken 445500 times.
✓ Branch 1 taken 33300 times.
478800 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
419 445500 dc = (blocks[0] - 0x4000) / scale;
420 445500 delta = dc - prev_dc;
421 445500 new_sign = GET_SIGN(delta);
422 445500 delta = (delta ^ sign) - sign;
423 445500 code = MAKE_CODE(delta);
424 445500 encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
425 445500 codebook = FFMIN(code, 6);
426 445500 sign = new_sign;
427 445500 prev_dc = dc;
428 }
429 33300 }
430
431 33300 static void encode_acs(PutBitContext *pb, int16_t *blocks,
432 int blocks_per_slice,
433 const uint8_t *scan, const int16_t *qmat)
434 {
435 int idx, i;
436 33300 int prev_run = 4;
437 33300 int prev_level = 2;
438 33300 int run = 0, level;
439 int max_coeffs, abs_level;
440
441 33300 max_coeffs = blocks_per_slice << 6;
442
443
2/2
✓ Branch 0 taken 2097900 times.
✓ Branch 1 taken 33300 times.
2131200 for (i = 1; i < 64; i++) {
444
2/2
✓ Branch 0 taken 30164400 times.
✓ Branch 1 taken 2097900 times.
32262300 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
445 30164400 level = blocks[idx] / qmat[scan[i]];
446
2/2
✓ Branch 0 taken 13203187 times.
✓ Branch 1 taken 16961213 times.
30164400 if (level) {
447 13203187 abs_level = FFABS(level);
448 13203187 encode_vlc_codeword(pb, ff_prores_run_to_cb[prev_run], run);
449 13203187 encode_vlc_codeword(pb, ff_prores_level_to_cb[prev_level], abs_level - 1);
450 13203187 put_sbits(pb, 1, GET_SIGN(level));
451
452 13203187 prev_run = FFMIN(run, 15);
453 13203187 prev_level = FFMIN(abs_level, 9);
454 13203187 run = 0;
455 } else {
456 16961213 run++;
457 }
458 }
459 }
460 33300 }
461
462 33300 static void encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
463 const uint16_t *src, ptrdiff_t linesize,
464 int mbs_per_slice, int16_t *blocks,
465 int blocks_per_mb,
466 const int16_t *qmat)
467 {
468 33300 int blocks_per_slice = mbs_per_slice * blocks_per_mb;
469
470 33300 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
471 33300 encode_acs(pb, blocks, blocks_per_slice, ctx->scantable, qmat);
472 33300 }
473
474 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
475 {
476 const int dbits = (abits == 8) ? 4 : 7;
477 const int dsize = 1 << dbits - 1;
478 int diff = cur - prev;
479
480 diff = av_zero_extend(diff, abits);
481 if (diff >= (1 << abits) - dsize)
482 diff -= 1 << abits;
483 if (diff < -dsize || diff > dsize || !diff) {
484 put_bits(pb, 1, 1);
485 put_bits(pb, abits, diff);
486 } else {
487 put_bits(pb, 1, 0);
488 put_bits(pb, dbits - 1, FFABS(diff) - 1);
489 put_bits(pb, 1, diff < 0);
490 }
491 }
492
493 static void put_alpha_run(PutBitContext *pb, int run)
494 {
495 if (run) {
496 put_bits(pb, 1, 0);
497 if (run < 0x10)
498 put_bits(pb, 4, run);
499 else
500 put_bits(pb, 15, run);
501 } else {
502 put_bits(pb, 1, 1);
503 }
504 }
505
506 // todo alpha quantisation for high quants
507 static void encode_alpha_plane(ProresContext *ctx, PutBitContext *pb,
508 int mbs_per_slice, uint16_t *blocks,
509 int quant)
510 {
511 const int abits = ctx->alpha_bits;
512 const int mask = (1 << abits) - 1;
513 const int num_coeffs = mbs_per_slice * 256;
514 int prev = mask, cur;
515 int idx = 0;
516 int run = 0;
517
518 cur = blocks[idx++];
519 put_alpha_diff(pb, cur, prev, abits);
520 prev = cur;
521 do {
522 cur = blocks[idx++];
523 if (cur != prev) {
524 put_alpha_run (pb, run);
525 put_alpha_diff(pb, cur, prev, abits);
526 prev = cur;
527 run = 0;
528 } else {
529 run++;
530 }
531 } while (idx < num_coeffs);
532 put_alpha_run(pb, run);
533 }
534
535 11100 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
536 PutBitContext *pb,
537 int sizes[4], int x, int y, int quant,
538 int mbs_per_slice)
539 {
540 11100 ProresContext *ctx = avctx->priv_data;
541 int i, xp, yp;
542 11100 int total_size = 0;
543 const uint16_t *src;
544 int num_cblocks, pwidth, line_add;
545 ptrdiff_t linesize;
546 int is_chroma;
547 uint16_t *qmat;
548 uint16_t *qmat_chroma;
549
550
1/2
✓ Branch 0 taken 11100 times.
✗ Branch 1 not taken.
11100 if (ctx->pictures_per_frame == 1)
551 11100 line_add = 0;
552 else
553 line_add = ctx->cur_picture_idx ^ !(pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
554
555
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11100 times.
11100 if (ctx->force_quant) {
556 qmat = ctx->quants[0];
557 qmat_chroma = ctx->quants_chroma[0];
558
2/2
✓ Branch 0 taken 8353 times.
✓ Branch 1 taken 2747 times.
11100 } else if (quant < MAX_STORED_Q) {
559 8353 qmat = ctx->quants[quant];
560 8353 qmat_chroma = ctx->quants_chroma[quant];
561 } else {
562 2747 qmat = ctx->custom_q;
563 2747 qmat_chroma = ctx->custom_chroma_q;
564
2/2
✓ Branch 0 taken 175808 times.
✓ Branch 1 taken 2747 times.
178555 for (i = 0; i < 64; i++) {
565 175808 qmat[i] = ctx->quant_mat[i] * quant;
566 175808 qmat_chroma[i] = ctx->quant_chroma_mat[i] * quant;
567 }
568 }
569
570
2/2
✓ Branch 0 taken 33300 times.
✓ Branch 1 taken 11100 times.
44400 for (i = 0; i < ctx->num_planes; i++) {
571
4/4
✓ Branch 0 taken 22200 times.
✓ Branch 1 taken 11100 times.
✓ Branch 2 taken 11100 times.
✓ Branch 3 taken 11100 times.
33300 is_chroma = (i == 1 || i == 2);
572
3/4
✓ Branch 0 taken 22200 times.
✓ Branch 1 taken 11100 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 22200 times.
33300 if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
573 11100 xp = x << 4;
574 11100 yp = y << 4;
575 11100 num_cblocks = 4;
576 11100 pwidth = avctx->width;
577 } else {
578 22200 xp = x << 3;
579 22200 yp = y << 4;
580 22200 num_cblocks = 2;
581 22200 pwidth = avctx->width >> 1;
582 }
583
584 33300 linesize = pic->linesize[i] * ctx->pictures_per_frame;
585 33300 src = (const uint16_t*)(pic->data[i] + yp * linesize +
586 33300 line_add * pic->linesize[i]) + xp;
587
588
1/2
✓ Branch 0 taken 33300 times.
✗ Branch 1 not taken.
33300 if (i < 3) {
589 33300 get_slice_data(ctx, src, linesize, xp, yp,
590 33300 pwidth, avctx->height / ctx->pictures_per_frame,
591 33300 ctx->blocks[0], ctx->emu_buf,
592 mbs_per_slice, num_cblocks, is_chroma);
593
2/2
✓ Branch 0 taken 11100 times.
✓ Branch 1 taken 22200 times.
33300 if (!is_chroma) {/* luma quant */
594 11100 encode_slice_plane(ctx, pb, src, linesize,
595 11100 mbs_per_slice, ctx->blocks[0],
596 num_cblocks, qmat);
597 } else { /* chroma plane */
598 22200 encode_slice_plane(ctx, pb, src, linesize,
599 22200 mbs_per_slice, ctx->blocks[0],
600 num_cblocks, qmat_chroma);
601 }
602 } else {
603 get_alpha_data(ctx, src, linesize, xp, yp,
604 pwidth, avctx->height / ctx->pictures_per_frame,
605 ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
606 encode_alpha_plane(ctx, pb, mbs_per_slice, ctx->blocks[0], quant);
607 }
608 33300 flush_put_bits(pb);
609 33300 sizes[i] = put_bytes_output(pb) - total_size;
610 33300 total_size = put_bytes_output(pb);
611 }
612 11100 return total_size;
613 }
614
615 390320122 static inline int estimate_vlc(unsigned codebook, int val)
616 {
617 unsigned int rice_order, exp_order, switch_bits, switch_val;
618 int exponent;
619
620 /* number of prefix bits to switch between Rice and expGolomb */
621 390320122 switch_bits = (codebook & 3) + 1;
622 390320122 rice_order = codebook >> 5; /* rice code order */
623 390320122 exp_order = (codebook >> 2) & 7; /* exp golomb code order */
624
625 390320122 switch_val = switch_bits << rice_order;
626
627
2/2
✓ Branch 0 taken 135366530 times.
✓ Branch 1 taken 254953592 times.
390320122 if (val >= switch_val) {
628 135366530 val -= switch_val - (1 << exp_order);
629 135366530 exponent = av_log2(val);
630
631 135366530 return exponent * 2 - exp_order + switch_bits + 1;
632 } else {
633 254953592 return (val >> rice_order) + rice_order + 1;
634 }
635 }
636
637 379686 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
638 int scale)
639 {
640 int i;
641 379686 int codebook = 5, code, dc, prev_dc, delta, sign, new_sign;
642 int bits;
643
644 379686 prev_dc = (blocks[0] - 0x4000) / scale;
645 379686 bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
646 379686 sign = 0;
647 379686 blocks += 64;
648
2/2
✓ Branch 0 taken 199846 times.
✓ Branch 1 taken 179840 times.
379686 *error += FFABS(blocks[0] - 0x4000) % scale;
649
650
2/2
✓ Branch 0 taken 5069986 times.
✓ Branch 1 taken 379686 times.
5449672 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
651 5069986 dc = (blocks[0] - 0x4000) / scale;
652
2/2
✓ Branch 0 taken 2618934 times.
✓ Branch 1 taken 2451052 times.
5069986 *error += FFABS(blocks[0] - 0x4000) % scale;
653 5069986 delta = dc - prev_dc;
654 5069986 new_sign = GET_SIGN(delta);
655 5069986 delta = (delta ^ sign) - sign;
656 5069986 code = MAKE_CODE(delta);
657 5069986 bits += estimate_vlc(ff_prores_dc_codebook[codebook], code);
658 5069986 codebook = FFMIN(code, 6);
659 5069986 sign = new_sign;
660 5069986 prev_dc = dc;
661 }
662
663 379686 return bits;
664 }
665
666 379686 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
667 const uint8_t *scan, const int16_t *qmat)
668 {
669 int idx, i;
670 379686 int prev_run = 4;
671 379686 int prev_level = 2;
672 int run, level;
673 int max_coeffs, abs_level;
674 379686 int bits = 0;
675
676 379686 max_coeffs = blocks_per_slice << 6;
677 379686 run = 0;
678
679
2/2
✓ Branch 0 taken 23920218 times.
✓ Branch 1 taken 379686 times.
24299904 for (i = 1; i < 64; i++) {
680
2/2
✓ Branch 0 taken 343329336 times.
✓ Branch 1 taken 23920218 times.
367249554 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
681 343329336 level = blocks[idx] / qmat[scan[i]];
682 343329336 *error += FFABS(blocks[idx]) % qmat[scan[i]];
683
2/2
✓ Branch 0 taken 192435225 times.
✓ Branch 1 taken 150894111 times.
343329336 if (level) {
684 192435225 abs_level = FFABS(level);
685 192435225 bits += estimate_vlc(ff_prores_run_to_cb[prev_run], run);
686 192435225 bits += estimate_vlc(ff_prores_level_to_cb[prev_level],
687 192435225 abs_level - 1) + 1;
688
689 192435225 prev_run = FFMIN(run, 15);
690 192435225 prev_level = FFMIN(abs_level, 9);
691 192435225 run = 0;
692 } else {
693 150894111 run++;
694 }
695 }
696 }
697
698 379686 return bits;
699 }
700
701 379686 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
702 const uint16_t *src, ptrdiff_t linesize,
703 int mbs_per_slice,
704 int blocks_per_mb,
705 const int16_t *qmat, ProresThreadData *td)
706 {
707 int blocks_per_slice;
708 int bits;
709
710 379686 blocks_per_slice = mbs_per_slice * blocks_per_mb;
711
712 379686 bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
713 379686 bits += estimate_acs(error, td->blocks[plane], blocks_per_slice, ctx->scantable, qmat);
714
715 379686 return FFALIGN(bits, 8);
716 }
717
718 static int est_alpha_diff(int cur, int prev, int abits)
719 {
720 const int dbits = (abits == 8) ? 4 : 7;
721 const int dsize = 1 << dbits - 1;
722 int diff = cur - prev;
723
724 diff = av_zero_extend(diff, abits);
725 if (diff >= (1 << abits) - dsize)
726 diff -= 1 << abits;
727 if (diff < -dsize || diff > dsize || !diff)
728 return abits + 1;
729 else
730 return dbits + 1;
731 }
732
733 static int estimate_alpha_plane(ProresContext *ctx,
734 const uint16_t *src, ptrdiff_t linesize,
735 int mbs_per_slice, int16_t *blocks)
736 {
737 const int abits = ctx->alpha_bits;
738 const int mask = (1 << abits) - 1;
739 const int num_coeffs = mbs_per_slice * 256;
740 int prev = mask, cur;
741 int idx = 0;
742 int run = 0;
743 int bits;
744
745 cur = blocks[idx++];
746 bits = est_alpha_diff(cur, prev, abits);
747 prev = cur;
748 do {
749 cur = blocks[idx++];
750 if (cur != prev) {
751 if (!run)
752 bits++;
753 else if (run < 0x10)
754 bits += 4;
755 else
756 bits += 15;
757 bits += est_alpha_diff(cur, prev, abits);
758 prev = cur;
759 run = 0;
760 } else {
761 run++;
762 }
763 } while (idx < num_coeffs);
764
765 if (run) {
766 if (run < 0x10)
767 bits += 4;
768 else
769 bits += 15;
770 }
771
772 return bits;
773 }
774
775 11100 static int find_slice_quant(AVCodecContext *avctx,
776 int trellis_node, int x, int y, int mbs_per_slice,
777 ProresThreadData *td)
778 {
779 11100 ProresContext *ctx = avctx->priv_data;
780 int i, q, pq, xp, yp;
781 const uint16_t *src;
782 int num_cblocks[MAX_PLANES], pwidth;
783 int is_chroma[MAX_PLANES];
784 11100 const int min_quant = ctx->profile_info->min_quant;
785 11100 const int max_quant = ctx->profile_info->max_quant;
786 int error, bits, bits_limit;
787 int mbs, prev, cur, new_score;
788 int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
789 int overquant;
790 uint16_t *qmat;
791 uint16_t *qmat_chroma;
792 int linesize[4], line_add;
793 11100 int alpha_bits = 0;
794
795
1/2
✓ Branch 0 taken 11100 times.
✗ Branch 1 not taken.
11100 if (ctx->pictures_per_frame == 1)
796 11100 line_add = 0;
797 else
798 line_add = ctx->cur_picture_idx ^ !(ctx->pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
799 11100 mbs = x + mbs_per_slice;
800
801
2/2
✓ Branch 0 taken 33300 times.
✓ Branch 1 taken 11100 times.
44400 for (i = 0; i < ctx->num_planes; i++) {
802
4/4
✓ Branch 0 taken 22200 times.
✓ Branch 1 taken 11100 times.
✓ Branch 2 taken 11100 times.
✓ Branch 3 taken 11100 times.
33300 is_chroma[i] = (i == 1 || i == 2);
803
3/4
✓ Branch 0 taken 22200 times.
✓ Branch 1 taken 11100 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 22200 times.
33300 if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
804 11100 xp = x << 4;
805 11100 yp = y << 4;
806 11100 num_cblocks[i] = 4;
807 11100 pwidth = avctx->width;
808 } else {
809 22200 xp = x << 3;
810 22200 yp = y << 4;
811 22200 num_cblocks[i] = 2;
812 22200 pwidth = avctx->width >> 1;
813 }
814
815 33300 linesize[i] = ctx->pic->linesize[i] * ctx->pictures_per_frame;
816 33300 src = (const uint16_t *)(ctx->pic->data[i] + yp * linesize[i] +
817 33300 line_add * ctx->pic->linesize[i]) + xp;
818
819
1/2
✓ Branch 0 taken 33300 times.
✗ Branch 1 not taken.
33300 if (i < 3) {
820 33300 get_slice_data(ctx, src, linesize[i], xp, yp,
821 33300 pwidth, avctx->height / ctx->pictures_per_frame,
822 33300 td->blocks[i], td->emu_buf,
823 mbs_per_slice, num_cblocks[i], is_chroma[i]);
824 } else {
825 get_alpha_data(ctx, src, linesize[i], xp, yp,
826 pwidth, avctx->height / ctx->pictures_per_frame,
827 td->blocks[i], mbs_per_slice, ctx->alpha_bits);
828 }
829 }
830
831
2/2
✓ Branch 0 taken 77700 times.
✓ Branch 1 taken 11100 times.
88800 for (q = min_quant; q < max_quant + 2; q++) {
832 77700 td->nodes[trellis_node + q].prev_node = -1;
833 77700 td->nodes[trellis_node + q].quant = q;
834 }
835
836
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11100 times.
11100 if (ctx->alpha_bits)
837 alpha_bits = estimate_alpha_plane(ctx, src, linesize[3],
838 mbs_per_slice, td->blocks[3]);
839 // todo: maybe perform coarser quantising to fit into frame size when needed
840
2/2
✓ Branch 0 taken 66600 times.
✓ Branch 1 taken 11100 times.
77700 for (q = min_quant; q <= max_quant; q++) {
841 66600 bits = alpha_bits;
842 66600 error = 0;
843 133200 bits += estimate_slice_plane(ctx, &error, 0,
844 66600 src, linesize[0],
845 mbs_per_slice,
846 num_cblocks[0],
847 66600 ctx->quants[q], td); /* estimate luma plane */
848
2/2
✓ Branch 0 taken 133200 times.
✓ Branch 1 taken 66600 times.
199800 for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
849 133200 bits += estimate_slice_plane(ctx, &error, i,
850 133200 src, linesize[i],
851 mbs_per_slice,
852 num_cblocks[i],
853 133200 ctx->quants_chroma[q], td);
854 }
855
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 66600 times.
66600 if (bits > 65000 * 8)
856 error = SCORE_LIMIT;
857
858 66600 slice_bits[q] = bits;
859 66600 slice_score[q] = error;
860 }
861
2/2
✓ Branch 0 taken 3643 times.
✓ Branch 1 taken 7457 times.
11100 if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
862 3643 slice_bits[max_quant + 1] = slice_bits[max_quant];
863 3643 slice_score[max_quant + 1] = slice_score[max_quant] + 1;
864 3643 overquant = max_quant;
865 } else {
866
1/2
✓ Branch 0 taken 59962 times.
✗ Branch 1 not taken.
59962 for (q = max_quant + 1; q < 128; q++) {
867 59962 bits = alpha_bits;
868 59962 error = 0;
869
2/2
✓ Branch 0 taken 44939 times.
✓ Branch 1 taken 15023 times.
59962 if (q < MAX_STORED_Q) {
870 44939 qmat = ctx->quants[q];
871 44939 qmat_chroma = ctx->quants_chroma[q];
872 } else {
873 15023 qmat = td->custom_q;
874 15023 qmat_chroma = td->custom_chroma_q;
875
2/2
✓ Branch 0 taken 961472 times.
✓ Branch 1 taken 15023 times.
976495 for (i = 0; i < 64; i++) {
876 961472 qmat[i] = ctx->quant_mat[i] * q;
877 961472 qmat_chroma[i] = ctx->quant_chroma_mat[i] * q;
878 }
879 }
880 119924 bits += estimate_slice_plane(ctx, &error, 0,
881 59962 src, linesize[0],
882 mbs_per_slice,
883 num_cblocks[0],
884 qmat, td);/* estimate luma plane */
885
2/2
✓ Branch 0 taken 119924 times.
✓ Branch 1 taken 59962 times.
179886 for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
886 119924 bits += estimate_slice_plane(ctx, &error, i,
887 119924 src, linesize[i],
888 mbs_per_slice,
889 num_cblocks[i],
890 qmat_chroma, td);
891 }
892
2/2
✓ Branch 0 taken 7457 times.
✓ Branch 1 taken 52505 times.
59962 if (bits <= ctx->bits_per_mb * mbs_per_slice)
893 7457 break;
894 }
895
896 7457 slice_bits[max_quant + 1] = bits;
897 7457 slice_score[max_quant + 1] = error;
898 7457 overquant = q;
899 }
900 11100 td->nodes[trellis_node + max_quant + 1].quant = overquant;
901
902 11100 bits_limit = mbs * ctx->bits_per_mb;
903
2/2
✓ Branch 0 taken 77700 times.
✓ Branch 1 taken 11100 times.
88800 for (pq = min_quant; pq < max_quant + 2; pq++) {
904 77700 prev = trellis_node - TRELLIS_WIDTH + pq;
905
906
2/2
✓ Branch 0 taken 543900 times.
✓ Branch 1 taken 77700 times.
621600 for (q = min_quant; q < max_quant + 2; q++) {
907 543900 cur = trellis_node + q;
908
909 543900 bits = td->nodes[prev].bits + slice_bits[q];
910 543900 error = slice_score[q];
911
2/2
✓ Branch 0 taken 438632 times.
✓ Branch 1 taken 105268 times.
543900 if (bits > bits_limit)
912 438632 error = SCORE_LIMIT;
913
914
4/4
✓ Branch 0 taken 268352 times.
✓ Branch 1 taken 275548 times.
✓ Branch 2 taken 98480 times.
✓ Branch 3 taken 169872 times.
543900 if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
915 98480 new_score = td->nodes[prev].score + error;
916 else
917 445420 new_score = SCORE_LIMIT;
918
2/2
✓ Branch 0 taken 466200 times.
✓ Branch 1 taken 77700 times.
543900 if (td->nodes[cur].prev_node == -1 ||
919
2/2
✓ Branch 0 taken 427864 times.
✓ Branch 1 taken 38336 times.
466200 td->nodes[cur].score >= new_score) {
920
921 505564 td->nodes[cur].bits = bits;
922 505564 td->nodes[cur].score = new_score;
923 505564 td->nodes[cur].prev_node = prev;
924 }
925 }
926 }
927
928 11100 error = td->nodes[trellis_node + min_quant].score;
929 11100 pq = trellis_node + min_quant;
930
2/2
✓ Branch 0 taken 66600 times.
✓ Branch 1 taken 11100 times.
77700 for (q = min_quant + 1; q < max_quant + 2; q++) {
931
2/2
✓ Branch 0 taken 52033 times.
✓ Branch 1 taken 14567 times.
66600 if (td->nodes[trellis_node + q].score <= error) {
932 52033 error = td->nodes[trellis_node + q].score;
933 52033 pq = trellis_node + q;
934 }
935 }
936
937 11100 return pq;
938 }
939
940 2850 static int find_quant_thread(AVCodecContext *avctx, void *arg,
941 int jobnr, int threadnr)
942 {
943 2850 ProresContext *ctx = avctx->priv_data;
944 2850 ProresThreadData *td = ctx->tdata + threadnr;
945 2850 int mbs_per_slice = ctx->mbs_per_slice;
946 2850 int x, y = jobnr, mb, q = 0;
947
948
2/2
✓ Branch 0 taken 11100 times.
✓ Branch 1 taken 2850 times.
13950 for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
949
2/2
✓ Branch 0 taken 5850 times.
✓ Branch 1 taken 11100 times.
16950 while (ctx->mb_width - x < mbs_per_slice)
950 5850 mbs_per_slice >>= 1;
951 11100 q = find_slice_quant(avctx,
952 11100 (mb + 1) * TRELLIS_WIDTH, x, y,
953 mbs_per_slice, td);
954 }
955
956
2/2
✓ Branch 0 taken 11100 times.
✓ Branch 1 taken 2850 times.
13950 for (x = ctx->slices_width - 1; x >= 0; x--) {
957 11100 ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
958 11100 q = td->nodes[q].prev_node;
959 }
960
961 2850 return 0;
962 }
963
964 200 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
965 const AVFrame *pic, int *got_packet)
966 {
967 200 ProresContext *ctx = avctx->priv_data;
968 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
969 uint8_t *picture_size_pos;
970 PutBitContext pb;
971 200 int x, y, i, mb, q = 0;
972 200 int sizes[4] = { 0 };
973 200 int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
974 int frame_size, picture_size, slice_size;
975 int pkt_size, ret;
976 200 int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);
977 uint8_t frame_flags;
978
979 200 ctx->pic = pic;
980 200 pkt_size = ctx->frame_size_upper_bound;
981
982
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 200 times.
200 if ((ret = ff_alloc_packet(avctx, pkt, pkt_size + FF_INPUT_BUFFER_MIN_SIZE)) < 0)
983 return ret;
984
985 200 orig_buf = pkt->data;
986
987 // frame atom
988 200 orig_buf += 4; // frame size
989 200 bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID
990 200 buf = orig_buf;
991
992 // frame header
993 200 tmp = buf;
994 200 buf += 2; // frame header size will be stored here
995
2/4
✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 200 times.
200 bytestream_put_be16 (&buf, ctx->chroma_factor != CFACTOR_Y422 || ctx->alpha_bits ? 1 : 0);
996 200 bytestream_put_buffer(&buf, ctx->vendor, 4);
997 200 bytestream_put_be16 (&buf, avctx->width);
998 200 bytestream_put_be16 (&buf, avctx->height);
999
1000 200 frame_flags = ctx->chroma_factor << 6;
1001
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
200 if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
1002 frame_flags |= (pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 0x04 : 0x08;
1003 200 bytestream_put_byte (&buf, frame_flags);
1004
1005 200 bytestream_put_byte (&buf, 0); // reserved
1006 200 bytestream_put_byte (&buf, pic->color_primaries);
1007 200 bytestream_put_byte (&buf, pic->color_trc);
1008 200 bytestream_put_byte (&buf, pic->colorspace);
1009 200 bytestream_put_byte (&buf, ctx->alpha_bits >> 3);
1010 200 bytestream_put_byte (&buf, 0); // reserved
1011
1/2
✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
200 if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
1012 200 bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present
1013 200 bytestream_put_buffer(&buf, ctx->quant_mat, 64); // luma quantisation matrix
1014 200 bytestream_put_buffer(&buf, ctx->quant_chroma_mat, 64); // chroma quantisation matrix
1015 } else {
1016 bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used
1017 }
1018 200 bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size
1019
1020 200 for (ctx->cur_picture_idx = 0;
1021
2/2
✓ Branch 0 taken 200 times.
✓ Branch 1 taken 200 times.
400 ctx->cur_picture_idx < ctx->pictures_per_frame;
1022 200 ctx->cur_picture_idx++) {
1023 // picture header
1024 200 picture_size_pos = buf + 1;
1025 200 bytestream_put_byte (&buf, 0x40); // picture header size (in bits)
1026 200 buf += 4; // picture data size will be stored here
1027 200 bytestream_put_be16 (&buf, ctx->slices_per_picture);
1028 200 bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
1029
1030 // seek table - will be filled during slice encoding
1031 200 slice_sizes = buf;
1032 200 buf += ctx->slices_per_picture * 2;
1033
1034 // slices
1035
1/2
✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
200 if (!ctx->force_quant) {
1036 200 ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,
1037 ctx->mb_height);
1038
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
200 if (ret)
1039 return ret;
1040 }
1041
1042
2/2
✓ Branch 0 taken 2850 times.
✓ Branch 1 taken 200 times.
3050 for (y = 0; y < ctx->mb_height; y++) {
1043 2850 int mbs_per_slice = ctx->mbs_per_slice;
1044
2/2
✓ Branch 0 taken 11100 times.
✓ Branch 1 taken 2850 times.
13950 for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1045 22200 q = ctx->force_quant ? ctx->force_quant
1046
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11100 times.
11100 : ctx->slice_q[mb + y * ctx->slices_width];
1047
1048
2/2
✓ Branch 0 taken 5850 times.
✓ Branch 1 taken 11100 times.
16950 while (ctx->mb_width - x < mbs_per_slice)
1049 5850 mbs_per_slice >>= 1;
1050
1051 11100 bytestream_put_byte(&buf, slice_hdr_size << 3);
1052 11100 slice_hdr = buf;
1053 11100 buf += slice_hdr_size - 1;
1054
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11100 times.
11100 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1055 uint8_t *start = pkt->data;
1056 // Recompute new size according to max_slice_size
1057 // and deduce delta
1058 int delta = 200 + (ctx->pictures_per_frame *
1059 ctx->slices_per_picture + 1) *
1060 max_slice_size - pkt_size;
1061
1062 delta = FFMAX(delta, 2 * max_slice_size);
1063 ctx->frame_size_upper_bound += delta;
1064
1065 if (!ctx->warn) {
1066 avpriv_request_sample(avctx,
1067 "Packet too small: is %i,"
1068 " needs %i (slice: %i). "
1069 "Correct allocation",
1070 pkt_size, delta, max_slice_size);
1071 ctx->warn = 1;
1072 }
1073
1074 ret = av_grow_packet(pkt, delta);
1075 if (ret < 0)
1076 return ret;
1077
1078 pkt_size += delta;
1079 // restore pointers
1080 orig_buf = pkt->data + (orig_buf - start);
1081 buf = pkt->data + (buf - start);
1082 picture_size_pos = pkt->data + (picture_size_pos - start);
1083 slice_sizes = pkt->data + (slice_sizes - start);
1084 slice_hdr = pkt->data + (slice_hdr - start);
1085 tmp = pkt->data + (tmp - start);
1086 }
1087 11100 init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1088 11100 ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1089 mbs_per_slice);
1090
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11100 times.
11100 if (ret < 0)
1091 return ret;
1092
1093 11100 bytestream_put_byte(&slice_hdr, q);
1094 11100 slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1095
2/2
✓ Branch 0 taken 22200 times.
✓ Branch 1 taken 11100 times.
33300 for (i = 0; i < ctx->num_planes - 1; i++) {
1096 22200 bytestream_put_be16(&slice_hdr, sizes[i]);
1097 22200 slice_size += sizes[i];
1098 }
1099 11100 bytestream_put_be16(&slice_sizes, slice_size);
1100 11100 buf += slice_size - slice_hdr_size;
1101
2/2
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 10884 times.
11100 if (max_slice_size < slice_size)
1102 216 max_slice_size = slice_size;
1103 }
1104 }
1105
1106 200 picture_size = buf - (picture_size_pos - 1);
1107 200 bytestream_put_be32(&picture_size_pos, picture_size);
1108 }
1109
1110 200 orig_buf -= 8;
1111 200 frame_size = buf - orig_buf;
1112 200 bytestream_put_be32(&orig_buf, frame_size);
1113
1114 200 pkt->size = frame_size;
1115 200 *got_packet = 1;
1116
1117 200 return 0;
1118 }
1119
1120 4 static av_cold int encode_close(AVCodecContext *avctx)
1121 {
1122 4 ProresContext *ctx = avctx->priv_data;
1123 int i;
1124
1125
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (ctx->tdata) {
1126
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
8 for (i = 0; i < avctx->thread_count; i++)
1127 4 av_freep(&ctx->tdata[i].nodes);
1128 }
1129 4 av_freep(&ctx->tdata);
1130 4 av_freep(&ctx->slice_q);
1131
1132 4 return 0;
1133 }
1134
1135 957600 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1136 ptrdiff_t linesize, int16_t *block)
1137 {
1138 int x, y;
1139 957600 const uint16_t *tsrc = src;
1140
1141
2/2
✓ Branch 0 taken 7660800 times.
✓ Branch 1 taken 957600 times.
8618400 for (y = 0; y < 8; y++) {
1142
2/2
✓ Branch 0 taken 61286400 times.
✓ Branch 1 taken 7660800 times.
68947200 for (x = 0; x < 8; x++)
1143 61286400 block[y * 8 + x] = tsrc[x];
1144 7660800 tsrc += linesize >> 1;
1145 }
1146 957600 fdsp->fdct(block);
1147 957600 }
1148
1149 4 static av_cold int encode_init(AVCodecContext *avctx)
1150 {
1151 4 ProresContext *ctx = avctx->priv_data;
1152 int mps;
1153 int i, j;
1154 int min_quant, max_quant;
1155 4 int interlaced = !!(avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT);
1156
1157 4 avctx->bits_per_raw_sample = 10;
1158
1159 4 ctx->fdct = prores_fdct;
1160 4 ctx->scantable = interlaced ? ff_prores_interlaced_scan
1161
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 : ff_prores_progressive_scan;
1162 4 ff_fdctdsp_init(&ctx->fdsp, avctx);
1163
1164 4 mps = ctx->mbs_per_slice;
1165
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (mps & (mps - 1)) {
1166 av_log(avctx, AV_LOG_ERROR,
1167 "there should be an integer power of two MBs per slice\n");
1168 return AVERROR(EINVAL);
1169 }
1170
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (ctx->profile == PRORES_PROFILE_AUTO) {
1171 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
1172 ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||
1173 !(desc->log2_chroma_w + desc->log2_chroma_h))
1174 ? PRORES_PROFILE_4444 : PRORES_PROFILE_HQ;
1175 av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "
1176 "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444
1177 ? "4:4:4:4 profile because of the used input colorspace"
1178 : "HQ profile to keep best quality");
1179 }
1180
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
4 if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {
1181 if (ctx->profile != PRORES_PROFILE_4444 &&
1182 ctx->profile != PRORES_PROFILE_4444XQ) {
1183 // force alpha and warn
1184 av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
1185 "encode alpha. Override with -profile if needed.\n");
1186 ctx->alpha_bits = 0;
1187 }
1188 if (ctx->alpha_bits & 7) {
1189 av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1190 return AVERROR(EINVAL);
1191 }
1192 avctx->bits_per_coded_sample = 32;
1193 } else {
1194 4 ctx->alpha_bits = 0;
1195 }
1196
1197 8 ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1198 ? CFACTOR_Y422
1199
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 : CFACTOR_Y444;
1200 4 ctx->profile_info = prores_profile_info + ctx->profile;
1201
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 ctx->num_planes = 3 + !!ctx->alpha_bits;
1202
1203 4 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
1204
1205
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (interlaced)
1206 ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1207 else
1208 4 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1209
1210 4 ctx->slices_width = ctx->mb_width / mps;
1211 4 ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1212 4 ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1213 4 ctx->pictures_per_frame = 1 + interlaced;
1214
1215
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (ctx->quant_sel == -1) {
1216 4 ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
1217 4 ctx->quant_chroma_mat = prores_quant_matrices[ctx->profile_info->quant_chroma];
1218 } else {
1219 ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
1220 ctx->quant_chroma_mat = prores_quant_matrices[ctx->quant_sel];
1221 }
1222
1223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (strlen(ctx->vendor) != 4) {
1224 av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1225 return AVERROR_INVALIDDATA;
1226 }
1227
1228 4 ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1229
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (!ctx->force_quant) {
1230
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (!ctx->bits_per_mb) {
1231
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1232 4 if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1233
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 ctx->pictures_per_frame)
1234 4 break;
1235 4 ctx->bits_per_mb = ctx->profile_info->br_tab[i];
1236
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (ctx->alpha_bits)
1237 ctx->bits_per_mb *= 20;
1238 } else if (ctx->bits_per_mb < 128) {
1239 av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1240 return AVERROR_INVALIDDATA;
1241 }
1242
1243 4 min_quant = ctx->profile_info->min_quant;
1244 4 max_quant = ctx->profile_info->max_quant;
1245
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 4 times.
64 for (i = min_quant; i < MAX_STORED_Q; i++) {
1246
2/2
✓ Branch 0 taken 3840 times.
✓ Branch 1 taken 60 times.
3900 for (j = 0; j < 64; j++) {
1247 3840 ctx->quants[i][j] = ctx->quant_mat[j] * i;
1248 3840 ctx->quants_chroma[i][j] = ctx->quant_chroma_mat[j] * i;
1249 }
1250 }
1251
1252 4 ctx->slice_q = av_malloc_array(ctx->slices_per_picture, sizeof(*ctx->slice_q));
1253
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (!ctx->slice_q)
1254 return AVERROR(ENOMEM);
1255
1256 4 ctx->tdata = av_calloc(avctx->thread_count, sizeof(*ctx->tdata));
1257
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (!ctx->tdata)
1258 return AVERROR(ENOMEM);
1259
1260
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
8 for (j = 0; j < avctx->thread_count; j++) {
1261 4 ctx->tdata[j].nodes = av_malloc_array(ctx->slices_width + 1,
1262 TRELLIS_WIDTH
1263 * sizeof(*ctx->tdata->nodes));
1264
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (!ctx->tdata[j].nodes)
1265 return AVERROR(ENOMEM);
1266
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 4 times.
32 for (i = min_quant; i < max_quant + 2; i++) {
1267 28 ctx->tdata[j].nodes[i].prev_node = -1;
1268 28 ctx->tdata[j].nodes[i].bits = 0;
1269 28 ctx->tdata[j].nodes[i].score = 0;
1270 }
1271 }
1272 } else {
1273 int ls = 0;
1274 int ls_chroma = 0;
1275
1276 if (ctx->force_quant > 64) {
1277 av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1278 return AVERROR_INVALIDDATA;
1279 }
1280
1281 for (j = 0; j < 64; j++) {
1282 ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1283 ctx->quants_chroma[0][j] = ctx->quant_chroma_mat[j] * ctx->force_quant;
1284 ls += av_log2((1 << 11) / ctx->quants[0][j]) * 2 + 1;
1285 ls_chroma += av_log2((1 << 11) / ctx->quants_chroma[0][j]) * 2 + 1;
1286 }
1287
1288 ctx->bits_per_mb = ls * 4 + ls_chroma * 4;
1289 if (ctx->chroma_factor == CFACTOR_Y444)
1290 ctx->bits_per_mb += ls_chroma * 4;
1291 }
1292
1293 4 ctx->frame_size_upper_bound = (ctx->pictures_per_frame *
1294 4 ctx->slices_per_picture + 1) *
1295 4 (2 + 2 * ctx->num_planes +
1296 4 (mps * ctx->bits_per_mb) / 8)
1297 4 + 200;
1298
1299
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (ctx->alpha_bits) {
1300 // The alpha plane is run-coded and might exceed the bit budget.
1301 ctx->frame_size_upper_bound += (ctx->pictures_per_frame *
1302 ctx->slices_per_picture + 1) *
1303 /* num pixels per slice */ (ctx->mbs_per_slice * 256 *
1304 /* bits per pixel */ (1 + ctx->alpha_bits + 1) + 7 >> 3);
1305 }
1306
1307 4 avctx->codec_tag = ctx->profile_info->tag;
1308 4 avctx->profile = ctx->profile;
1309
1310
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 av_log(avctx, AV_LOG_DEBUG,
1311 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1312 4 ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1313 interlaced ? "yes" : "no", ctx->bits_per_mb);
1314 4 av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1315 ctx->frame_size_upper_bound);
1316
1317 4 return 0;
1318 }
1319
1320 #define OFFSET(x) offsetof(ProresContext, x)
1321 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1322
1323 static const AVOption options[] = {
1324 { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1325 AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1326 { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1327 { .i64 = PRORES_PROFILE_AUTO },
1328 PRORES_PROFILE_AUTO, PRORES_PROFILE_4444XQ, VE, .unit = "profile" },
1329 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },
1330 0, 0, VE, .unit = "profile" },
1331 { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1332 0, 0, VE, .unit = "profile" },
1333 { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1334 0, 0, VE, .unit = "profile" },
1335 { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1336 0, 0, VE, .unit = "profile" },
1337 { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1338 0, 0, VE, .unit = "profile" },
1339 { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1340 0, 0, VE, .unit = "profile" },
1341 { "4444xq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444XQ },
1342 0, 0, VE, .unit = "profile" },
1343 { "vendor", "vendor ID", OFFSET(vendor),
1344 AV_OPT_TYPE_STRING, { .str = "Lavc" }, 0, 0, VE },
1345 { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1346 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1347 { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1348 { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, .unit = "quant_mat" },
1349 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1350 0, 0, VE, .unit = "quant_mat" },
1351 { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1352 0, 0, VE, .unit = "quant_mat" },
1353 { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1354 0, 0, VE, .unit = "quant_mat" },
1355 { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1356 0, 0, VE, .unit = "quant_mat" },
1357 { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1358 0, 0, VE, .unit = "quant_mat" },
1359 { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1360 0, 0, VE, .unit = "quant_mat" },
1361 { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1362 { .i64 = 16 }, 0, 16, VE },
1363 { NULL }
1364 };
1365
1366 static const AVClass proresenc_class = {
1367 .class_name = "ProRes encoder",
1368 .item_name = av_default_item_name,
1369 .option = options,
1370 .version = LIBAVUTIL_VERSION_INT,
1371 };
1372
1373 const FFCodec ff_prores_ks_encoder = {
1374 .p.name = "prores_ks",
1375 CODEC_LONG_NAME("Apple ProRes (iCodec Pro)"),
1376 .p.type = AVMEDIA_TYPE_VIDEO,
1377 .p.id = AV_CODEC_ID_PRORES,
1378 .priv_data_size = sizeof(ProresContext),
1379 .init = encode_init,
1380 .close = encode_close,
1381 FF_CODEC_ENCODE_CB(encode_frame),
1382 .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS |
1383 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1384 .p.pix_fmts = (const enum AVPixelFormat[]) {
1385 AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1386 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
1387 },
1388 .p.priv_class = &proresenc_class,
1389 .p.profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
1390 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1391 };
1392