FFmpeg coverage


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