33 #define CFACTOR_Y422 2
34 #define CFACTOR_Y444 3
36 #define MAX_MBS_PER_SLICE 8
58 4, 7, 9, 11, 13, 14, 15, 63,
59 7, 7, 11, 12, 14, 15, 63, 63,
60 9, 11, 13, 14, 15, 63, 63, 63,
61 11, 11, 13, 14, 63, 63, 63, 63,
62 11, 13, 14, 63, 63, 63, 63, 63,
63 13, 14, 63, 63, 63, 63, 63, 63,
64 13, 63, 63, 63, 63, 63, 63, 63,
65 63, 63, 63, 63, 63, 63, 63, 63,
68 4, 5, 6, 7, 9, 11, 13, 15,
69 5, 5, 7, 8, 11, 13, 15, 17,
70 6, 7, 9, 11, 13, 15, 15, 17,
71 7, 7, 9, 11, 13, 15, 17, 19,
72 7, 9, 11, 13, 14, 16, 19, 23,
73 9, 11, 13, 14, 16, 19, 23, 29,
74 9, 11, 13, 15, 17, 21, 28, 35,
75 11, 13, 16, 17, 21, 28, 35, 41,
78 4, 4, 5, 5, 6, 7, 7, 9,
79 4, 4, 5, 6, 7, 7, 9, 9,
80 5, 5, 6, 7, 7, 9, 9, 10,
81 5, 5, 6, 7, 7, 9, 9, 10,
82 5, 6, 7, 7, 8, 9, 10, 12,
83 6, 7, 7, 8, 9, 10, 12, 15,
84 6, 7, 7, 9, 10, 11, 14, 17,
85 7, 7, 9, 10, 11, 14, 17, 21,
88 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 5,
92 4, 4, 4, 4, 4, 4, 5, 5,
93 4, 4, 4, 4, 4, 5, 5, 6,
94 4, 4, 4, 4, 5, 5, 6, 7,
95 4, 4, 4, 4, 5, 6, 7, 7,
98 4, 4, 4, 4, 4, 4, 4, 4,
99 4, 4, 4, 4, 4, 4, 4, 4,
100 4, 4, 4, 4, 4, 4, 4, 4,
101 4, 4, 4, 4, 4, 4, 4, 4,
102 4, 4, 4, 4, 4, 4, 4, 4,
103 4, 4, 4, 4, 4, 4, 4, 4,
104 4, 4, 4, 4, 4, 4, 4, 4,
105 4, 4, 4, 4, 4, 4, 4, 4,
109 #define NUM_MB_LIMITS 4
127 .tag =
MKTAG(
'a',
'p',
'c',
'o'),
130 .br_tab = { 300, 242, 220, 194 },
135 .tag =
MKTAG(
'a',
'p',
'c',
's'),
138 .br_tab = { 720, 560, 490, 440 },
142 .full_name =
"standard",
143 .tag =
MKTAG(
'a',
'p',
'c',
'n'),
146 .br_tab = { 1050, 808, 710, 632 },
150 .full_name =
"high quality",
151 .tag =
MKTAG(
'a',
'p',
'c',
'h'),
154 .br_tab = { 1566, 1216, 1070, 950 },
159 .tag =
MKTAG(
'a',
'p',
'4',
'h'),
162 .br_tab = { 2350, 1828, 1600, 1425 },
167 #define TRELLIS_WIDTH 16
168 #define SCORE_LIMIT INT_MAX / 2
177 #define MAX_STORED_Q 16
223 int linesize,
int x,
int y,
int w,
int h,
224 int16_t *blocks, uint16_t *emu_buf,
225 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
227 const uint16_t *esrc;
228 const int mb_width = 4 * blocks_per_mb;
232 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
234 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
238 if (x + mb_width <= w && y + 16 <= h) {
240 elinesize = linesize;
245 elinesize = 16 *
sizeof(*emu_buf);
247 bw =
FFMIN(w - x, mb_width);
248 bh =
FFMIN(h - y, 16);
250 for (j = 0; j < bh; j++) {
251 memcpy(emu_buf + j * 16,
252 (
const uint8_t*)src + j * linesize,
254 pix = emu_buf[j * 16 + bw - 1];
255 for (k = bw; k < mb_width; k++)
256 emu_buf[j * 16 + k] = pix;
259 memcpy(emu_buf + j * 16,
260 emu_buf + (bh - 1) * 16,
261 mb_width *
sizeof(*emu_buf));
264 ctx->
dsp.
fdct(esrc, elinesize, blocks);
266 if (blocks_per_mb > 2) {
267 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
270 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
272 if (blocks_per_mb > 2) {
273 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
277 ctx->
dsp.
fdct(esrc, elinesize, blocks);
279 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
281 if (blocks_per_mb > 2) {
282 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
284 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
294 int linesize,
int x,
int y,
int w,
int h,
295 int16_t *blocks,
int mbs_per_slice,
int abits)
297 const int slice_width = 16 * mbs_per_slice;
298 int i, j, copy_w, copy_h;
300 copy_w =
FFMIN(w - x, slice_width);
301 copy_h =
FFMIN(h - y, 16);
302 for (i = 0; i < copy_h; i++) {
303 memcpy(blocks, src, copy_w *
sizeof(*src));
305 for (j = 0; j < copy_w; j++)
308 for (j = 0; j < copy_w; j++)
309 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
310 for (j = copy_w; j < slice_width; j++)
311 blocks[j] = blocks[copy_w - 1];
312 blocks += slice_width;
313 src += linesize >> 1;
315 for (; i < 16; i++) {
316 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
317 blocks += slice_width;
326 unsigned int rice_order, exp_order, switch_bits, switch_val;
330 switch_bits = (codebook & 3) + 1;
331 rice_order = codebook >> 5;
332 exp_order = (codebook >> 2) & 7;
334 switch_val = switch_bits << rice_order;
336 if (val >= switch_val) {
337 val -= switch_val - (1 << exp_order);
340 put_bits(pb, exponent - exp_order + switch_bits, 0);
343 exponent = val >> rice_order;
353 #define GET_SIGN(x) ((x) >> 31)
354 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
357 int blocks_per_slice,
int scale)
360 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
362 prev_dc = (blocks[0] - 0x4000) / scale;
368 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
369 dc = (blocks[0] - 0x4000) / scale;
370 delta = dc - prev_dc;
372 delta = (delta ^ sign) - sign;
375 codebook = (code + (code & 1)) >> 1;
376 codebook =
FFMIN(codebook, 3);
383 int blocks_per_slice,
384 int plane_size_factor,
385 const uint8_t *scan,
const int16_t *qmat)
389 int max_coeffs, abs_level;
391 max_coeffs = blocks_per_slice << 6;
396 for (i = 1; i < 64; i++) {
397 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
398 level = blocks[idx] / qmat[scan[i]];
400 abs_level =
FFABS(level);
417 const uint16_t *src,
int linesize,
418 int mbs_per_slice, int16_t *blocks,
419 int blocks_per_mb,
int plane_size_factor,
422 int blocks_per_slice, saved_pos;
425 blocks_per_slice = mbs_per_slice * blocks_per_mb;
427 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
428 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
437 const int mask = (1 << abits) - 1;
438 const int dbits = (abits == 8) ? 4 : 7;
439 const int dsize = 1 << dbits - 1;
440 int diff = cur - prev;
443 if (diff >= (1 << abits) - dsize)
445 if (diff < -dsize || diff > dsize || !diff) {
470 const uint16_t *src,
int linesize,
471 int mbs_per_slice, uint16_t *blocks,
475 const int mask = (1 << abits) - 1;
476 const int num_coeffs = mbs_per_slice * 256;
478 int prev =
mask, cur;
495 }
while (idx < num_coeffs);
511 int slice_width_factor =
av_log2(mbs_per_slice);
512 int num_cblocks, pwidth, linesize, line_add;
513 int plane_factor, is_chroma;
527 for (i = 0; i < 64; i++)
532 is_chroma = (i == 1 || i == 2);
533 plane_factor = slice_width_factor + 2;
540 pwidth = avctx->
width;
545 pwidth = avctx->
width >> 1;
549 src = (
const uint16_t*)(pic->
data[i] + yp * linesize +
556 mbs_per_slice, num_cblocks, is_chroma);
558 mbs_per_slice, ctx->
blocks[0],
559 num_cblocks, plane_factor,
566 mbs_per_slice, ctx->
blocks[0],
569 total_size += sizes[i];
576 unsigned int rice_order, exp_order, switch_bits, switch_val;
580 switch_bits = (codebook & 3) + 1;
581 rice_order = codebook >> 5;
582 exp_order = (codebook >> 2) & 7;
584 switch_val = switch_bits << rice_order;
586 if (val >= switch_val) {
587 val -= switch_val - (1 << exp_order);
590 return exponent * 2 - exp_order + switch_bits + 1;
592 return (val >> rice_order) + rice_order + 1;
596 static int estimate_dcs(
int *error, int16_t *blocks,
int blocks_per_slice,
600 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
603 prev_dc = (blocks[0] - 0x4000) / scale;
610 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
611 dc = (blocks[0] - 0x4000) / scale;
613 delta = dc - prev_dc;
615 delta = (delta ^ sign) - sign;
618 codebook = (code + (code & 1)) >> 1;
619 codebook =
FFMIN(codebook, 3);
627 static int estimate_acs(
int *error, int16_t *blocks,
int blocks_per_slice,
628 int plane_size_factor,
629 const uint8_t *scan,
const int16_t *qmat)
633 int max_coeffs, abs_level;
636 max_coeffs = blocks_per_slice << 6;
641 for (i = 1; i < 64; i++) {
642 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
643 level = blocks[idx] / qmat[scan[i]];
644 *error +=
FFABS(blocks[idx]) % qmat[scan[i]];
646 abs_level =
FFABS(level);
664 const uint16_t *src,
int linesize,
666 int blocks_per_mb,
int plane_size_factor,
669 int blocks_per_slice;
672 blocks_per_slice = mbs_per_slice * blocks_per_mb;
683 const int mask = (1 << abits) - 1;
684 const int dbits = (abits == 8) ? 4 : 7;
685 const int dsize = 1 << dbits - 1;
686 int diff = cur - prev;
689 if (diff >= (1 << abits) - dsize)
691 if (diff < -dsize || diff > dsize || !diff)
698 const uint16_t *src,
int linesize,
699 int mbs_per_slice,
int quant,
703 const int mask = (1 << abits) - 1;
704 const int num_coeffs = mbs_per_slice * 256;
705 int prev =
mask, cur;
729 }
while (idx < num_coeffs);
742 int trellis_node,
int x,
int y,
int mbs_per_slice,
746 int i, q, pq, xp, yp;
748 int slice_width_factor =
av_log2(mbs_per_slice);
753 int error,
bits, bits_limit;
754 int mbs, prev, cur, new_score;
758 int linesize[4], line_add;
764 mbs = x + mbs_per_slice;
767 is_chroma[i] = (i == 1 || i == 2);
768 plane_factor[i] = slice_width_factor + 2;
775 pwidth = avctx->
width;
780 pwidth = avctx->
width >> 1;
784 src = (
const uint16_t*)(pic->
data[i] + yp * linesize[i] +
791 mbs_per_slice, num_cblocks[i], is_chroma[i]);
799 for (q = min_quant; q < max_quant + 2; q++) {
805 for (q = min_quant; q <=
max_quant; q++) {
812 num_cblocks[i], plane_factor[i],
817 mbs_per_slice, q, td->
blocks[3]);
818 if (bits > 65000 * 8) {
822 slice_bits[q] =
bits;
823 slice_score[q] = error;
825 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
826 slice_bits[max_quant + 1] = slice_bits[
max_quant];
827 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
830 for (q = max_quant + 1; q < 128; q++) {
837 for (i = 0; i < 64; i++)
844 num_cblocks[i], plane_factor[i],
849 mbs_per_slice, q, td->
blocks[3]);
850 if (bits <= ctx->bits_per_mb * mbs_per_slice)
854 slice_bits[max_quant + 1] =
bits;
855 slice_score[max_quant + 1] = error;
858 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
861 for (pq = min_quant; pq < max_quant + 2; pq++) {
864 for (q = min_quant; q < max_quant + 2; q++) {
865 cur = trellis_node + q;
867 bits = td->
nodes[prev].
bits + slice_bits[q];
868 error = slice_score[q];
869 if (bits > bits_limit)
888 for (q = min_quant + 1; q < max_quant + 2; q++) {
889 if (td->
nodes[trellis_node + q].
score <= error) {
891 pq = trellis_node + q;
899 int jobnr,
int threadnr)
904 int x, y = jobnr, mb, q = 0;
906 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
907 while (ctx->
mb_width - x < mbs_per_slice)
923 const AVFrame *pic,
int *got_packet)
926 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
929 int x, y, i, mb, q = 0;
930 int sizes[4] = { 0 };
931 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
947 orig_buf = pkt->
data;
951 bytestream_put_be32 (&orig_buf,
FRAME_ID);
957 bytestream_put_be16 (&buf, 0);
959 bytestream_put_be16 (&buf, avctx->
width);
960 bytestream_put_be16 (&buf, avctx->
height);
965 bytestream_put_byte (&buf, frame_flags);
967 bytestream_put_byte (&buf, 0);
969 bytestream_put_byte (&buf, avctx->
color_trc);
970 bytestream_put_byte (&buf, avctx->
colorspace);
971 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
972 bytestream_put_byte (&buf, 0);
974 bytestream_put_byte (&buf, 0x03);
976 for (i = 0; i < 64; i++)
977 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
979 for (i = 0; i < 64; i++)
980 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
982 bytestream_put_byte (&buf, 0x00);
984 bytestream_put_be16 (&tmp, buf - orig_buf);
990 picture_size_pos = buf + 1;
991 bytestream_put_byte (&buf, 0x40);
1010 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1014 while (ctx->
mb_width - x < mbs_per_slice)
1015 mbs_per_slice >>= 1;
1017 bytestream_put_byte(&buf, slice_hdr_size << 3);
1019 buf += slice_hdr_size - 1;
1021 encode_slice(avctx, pic, &pb, sizes, x, y, q, mbs_per_slice);
1023 bytestream_put_byte(&slice_hdr, q);
1024 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1026 bytestream_put_be16(&slice_hdr, sizes[i]);
1027 slice_size += sizes[i];
1029 bytestream_put_be16(&slice_sizes, slice_size);
1030 buf += slice_size - slice_hdr_size;
1035 picture_size = buf - picture_size_pos - 6;
1037 picture_size = buf - picture_size_pos + 1;
1038 bytestream_put_be32(&picture_size_pos, picture_size);
1042 frame_size = buf - orig_buf;
1043 bytestream_put_be32(&orig_buf, frame_size);
1088 if (mps & (mps - 1)) {
1090 "there should be an integer power of two MBs per slice\n");
1125 if (strlen(ctx->
vendor) != 4) {
1146 for (j = 0; j < 64; j++)
1170 for (i = min_quant; i < max_quant + 2; i++) {
1184 for (j = 0; j < 64; j++) {
1205 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1214 #define OFFSET(x) offsetof(ProresContext, x)
1215 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1218 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1224 0, 0,
VE,
"profile" },
1226 0, 0,
VE,
"profile" },
1228 0, 0,
VE,
"profile" },
1230 0, 0,
VE,
"profile" },
1232 0, 0,
VE,
"profile" },
1233 {
"vendor",
"vendor ID",
OFFSET(vendor),
1235 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1240 0, 0,
VE,
"quant_mat" },
1242 0, 0,
VE,
"quant_mat" },
1244 0, 0,
VE,
"quant_mat" },
1246 0, 0,
VE,
"quant_mat" },
1248 0, 0,
VE,
"quant_mat" },
1250 0, 0,
VE,
"quant_mat" },
1252 { .i64 = 16 }, 0, 16,
VE },