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
224 int linesize,
int x,
int y,
int w,
int h,
225 int16_t *blocks, uint16_t *emu_buf,
226 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
228 const uint16_t *esrc;
229 const int mb_width = 4 * blocks_per_mb;
233 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
235 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
239 if (x + mb_width <= w && y + 16 <= h) {
241 elinesize = linesize;
246 elinesize = 16 *
sizeof(*emu_buf);
248 bw =
FFMIN(w - x, mb_width);
249 bh =
FFMIN(h - y, 16);
251 for (j = 0; j < bh; j++) {
252 memcpy(emu_buf + j * 16,
253 (
const uint8_t*)src + j * linesize,
255 pix = emu_buf[j * 16 + bw - 1];
256 for (k = bw; k < mb_width; k++)
257 emu_buf[j * 16 + k] = pix;
260 memcpy(emu_buf + j * 16,
261 emu_buf + (bh - 1) * 16,
262 mb_width *
sizeof(*emu_buf));
265 ctx->
dsp.
fdct(esrc, elinesize, blocks);
267 if (blocks_per_mb > 2) {
268 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
271 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
273 if (blocks_per_mb > 2) {
274 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
278 ctx->
dsp.
fdct(esrc, elinesize, blocks);
280 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
282 if (blocks_per_mb > 2) {
283 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
285 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
295 int linesize,
int x,
int y,
int w,
int h,
296 int16_t *blocks,
int mbs_per_slice,
int abits)
298 const int slice_width = 16 * mbs_per_slice;
299 int i, j, copy_w, copy_h;
301 copy_w =
FFMIN(w - x, slice_width);
302 copy_h =
FFMIN(h - y, 16);
303 for (i = 0; i < copy_h; i++) {
304 memcpy(blocks, src, copy_w *
sizeof(*src));
306 for (j = 0; j < copy_w; j++)
309 for (j = 0; j < copy_w; j++)
310 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
311 for (j = copy_w; j < slice_width; j++)
312 blocks[j] = blocks[copy_w - 1];
313 blocks += slice_width;
314 src += linesize >> 1;
316 for (; i < 16; i++) {
317 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
318 blocks += slice_width;
327 unsigned int rice_order, exp_order, switch_bits, switch_val;
331 switch_bits = (codebook & 3) + 1;
332 rice_order = codebook >> 5;
333 exp_order = (codebook >> 2) & 7;
335 switch_val = switch_bits << rice_order;
337 if (val >= switch_val) {
338 val -= switch_val - (1 << exp_order);
341 put_bits(pb, exponent - exp_order + switch_bits, 0);
344 exponent = val >> rice_order;
354 #define GET_SIGN(x) ((x) >> 31)
355 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
358 int blocks_per_slice,
int scale)
361 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
363 prev_dc = (blocks[0] - 0x4000) / scale;
369 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
370 dc = (blocks[0] - 0x4000) / scale;
371 delta = dc - prev_dc;
373 delta = (delta ^ sign) - sign;
376 codebook = (code + (code & 1)) >> 1;
377 codebook =
FFMIN(codebook, 3);
384 int blocks_per_slice,
385 int plane_size_factor,
386 const uint8_t *scan,
const int16_t *qmat)
390 int max_coeffs, abs_level;
392 max_coeffs = blocks_per_slice << 6;
397 for (i = 1; i < 64; i++) {
398 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
399 level = blocks[idx] / qmat[scan[i]];
401 abs_level =
FFABS(level);
418 const uint16_t *src,
int linesize,
419 int mbs_per_slice, int16_t *blocks,
420 int blocks_per_mb,
int plane_size_factor,
423 int blocks_per_slice, saved_pos;
426 blocks_per_slice = mbs_per_slice * blocks_per_mb;
428 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
429 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
438 const int mask = (1 << abits) - 1;
439 const int dbits = (abits == 8) ? 4 : 7;
440 const int dsize = 1 << dbits - 1;
441 int diff = cur - prev;
444 if (diff >= (1 << abits) - dsize)
446 if (diff < -dsize || diff > dsize || !diff) {
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,
568 total_size += sizes[i];
571 "Underestimated required buffer size.\n");
580 unsigned int rice_order, exp_order, switch_bits, switch_val;
584 switch_bits = (codebook & 3) + 1;
585 rice_order = codebook >> 5;
586 exp_order = (codebook >> 2) & 7;
588 switch_val = switch_bits << rice_order;
590 if (val >= switch_val) {
591 val -= switch_val - (1 << exp_order);
594 return exponent * 2 - exp_order + switch_bits + 1;
596 return (val >> rice_order) + rice_order + 1;
600 static int estimate_dcs(
int *error, int16_t *blocks,
int blocks_per_slice,
604 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
607 prev_dc = (blocks[0] - 0x4000) / scale;
614 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
615 dc = (blocks[0] - 0x4000) / scale;
617 delta = dc - prev_dc;
619 delta = (delta ^ sign) - sign;
622 codebook = (code + (code & 1)) >> 1;
623 codebook =
FFMIN(codebook, 3);
631 static int estimate_acs(
int *error, int16_t *blocks,
int blocks_per_slice,
632 int plane_size_factor,
633 const uint8_t *scan,
const int16_t *qmat)
637 int max_coeffs, abs_level;
640 max_coeffs = blocks_per_slice << 6;
645 for (i = 1; i < 64; i++) {
646 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
647 level = blocks[idx] / qmat[scan[i]];
648 *error +=
FFABS(blocks[idx]) % qmat[scan[i]];
650 abs_level =
FFABS(level);
668 const uint16_t *src,
int linesize,
670 int blocks_per_mb,
int plane_size_factor,
673 int blocks_per_slice;
676 blocks_per_slice = mbs_per_slice * blocks_per_mb;
687 const int mask = (1 << abits) - 1;
688 const int dbits = (abits == 8) ? 4 : 7;
689 const int dsize = 1 << dbits - 1;
690 int diff = cur - prev;
693 if (diff >= (1 << abits) - dsize)
695 if (diff < -dsize || diff > dsize || !diff)
702 const uint16_t *src,
int linesize,
703 int mbs_per_slice,
int quant,
707 const int mask = (1 << abits) - 1;
708 const int num_coeffs = mbs_per_slice * 256;
709 int prev =
mask, cur;
733 }
while (idx < num_coeffs);
746 int trellis_node,
int x,
int y,
int mbs_per_slice,
750 int i, q, pq, xp, yp;
752 int slice_width_factor =
av_log2(mbs_per_slice);
757 int error,
bits, bits_limit;
758 int mbs, prev, cur, new_score;
762 int linesize[4], line_add;
768 mbs = x + mbs_per_slice;
771 is_chroma[i] = (i == 1 || i == 2);
772 plane_factor[i] = slice_width_factor + 2;
779 pwidth = avctx->
width;
784 pwidth = avctx->
width >> 1;
788 src = (
const uint16_t*)(pic->
data[i] + yp * linesize[i] +
795 mbs_per_slice, num_cblocks[i], is_chroma[i]);
803 for (q = min_quant; q < max_quant + 2; q++) {
809 for (q = min_quant; q <=
max_quant; q++) {
816 num_cblocks[i], plane_factor[i],
821 mbs_per_slice, q, td->
blocks[3]);
822 if (bits > 65000 * 8) {
826 slice_bits[q] =
bits;
827 slice_score[q] = error;
829 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
830 slice_bits[max_quant + 1] = slice_bits[
max_quant];
831 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
834 for (q = max_quant + 1; q < 128; q++) {
841 for (i = 0; i < 64; i++)
848 num_cblocks[i], plane_factor[i],
853 mbs_per_slice, q, td->
blocks[3]);
854 if (bits <= ctx->bits_per_mb * mbs_per_slice)
858 slice_bits[max_quant + 1] =
bits;
859 slice_score[max_quant + 1] = error;
862 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
865 for (pq = min_quant; pq < max_quant + 2; pq++) {
868 for (q = min_quant; q < max_quant + 2; q++) {
869 cur = trellis_node + q;
871 bits = td->
nodes[prev].
bits + slice_bits[q];
872 error = slice_score[q];
873 if (bits > bits_limit)
892 for (q = min_quant + 1; q < max_quant + 2; q++) {
893 if (td->
nodes[trellis_node + q].
score <= error) {
895 pq = trellis_node + q;
903 int jobnr,
int threadnr)
908 int x, y = jobnr, mb, q = 0;
910 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
911 while (ctx->
mb_width - x < mbs_per_slice)
927 const AVFrame *pic,
int *got_packet)
930 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
933 int x, y, i, mb, q = 0;
934 int sizes[4] = { 0 };
935 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
937 int pkt_size, ret, max_slice_size = 0;
951 orig_buf = pkt->
data;
955 bytestream_put_be32 (&orig_buf,
FRAME_ID);
961 bytestream_put_be16 (&buf, 0);
963 bytestream_put_be16 (&buf, avctx->
width);
964 bytestream_put_be16 (&buf, avctx->
height);
969 bytestream_put_byte (&buf, frame_flags);
971 bytestream_put_byte (&buf, 0);
973 bytestream_put_byte (&buf, avctx->
color_trc);
974 bytestream_put_byte (&buf, avctx->
colorspace);
975 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
976 bytestream_put_byte (&buf, 0);
978 bytestream_put_byte (&buf, 0x03);
980 for (i = 0; i < 64; i++)
981 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
983 for (i = 0; i < 64; i++)
984 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
986 bytestream_put_byte (&buf, 0x00);
988 bytestream_put_be16 (&tmp, buf - orig_buf);
994 picture_size_pos = buf + 1;
995 bytestream_put_byte (&buf, 0x40);
1014 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1018 while (ctx->
mb_width - x < mbs_per_slice)
1019 mbs_per_slice >>= 1;
1021 bytestream_put_byte(&buf, slice_hdr_size << 3);
1023 buf += slice_hdr_size - 1;
1024 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1032 delta =
FFMAX(delta, 2 * max_slice_size);
1037 "Packet too small: is %i,"
1038 " needs %i (slice: %i). "
1039 "Correct allocation",
1040 pkt_size, delta, max_slice_size);
1050 orig_buf = pkt->
data + (orig_buf - start);
1051 buf = pkt->
data + (buf - start);
1052 picture_size_pos = pkt->
data + (picture_size_pos - start);
1053 slice_sizes = pkt->
data + (slice_sizes - start);
1054 slice_hdr = pkt->
data + (slice_hdr - start);
1055 tmp = pkt->
data + (tmp - start);
1063 bytestream_put_byte(&slice_hdr, q);
1064 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1066 bytestream_put_be16(&slice_hdr, sizes[i]);
1067 slice_size += sizes[i];
1069 bytestream_put_be16(&slice_sizes, slice_size);
1070 buf += slice_size - slice_hdr_size;
1071 if (max_slice_size < slice_size)
1072 max_slice_size = slice_size;
1077 picture_size = buf - picture_size_pos - 6;
1079 picture_size = buf - picture_size_pos + 1;
1080 bytestream_put_be32(&picture_size_pos, picture_size);
1084 frame_size = buf - orig_buf;
1085 bytestream_put_be32(&orig_buf, frame_size);
1130 if (mps & (mps - 1)) {
1132 "there should be an integer power of two MBs per slice\n");
1167 if (strlen(ctx->
vendor) != 4) {
1188 for (j = 0; j < 64; j++)
1212 for (i = min_quant; i < max_quant + 2; i++) {
1226 for (j = 0; j < 64; j++) {
1253 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1262 #define OFFSET(x) offsetof(ProresContext, x)
1263 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1266 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1272 0, 0,
VE,
"profile" },
1274 0, 0,
VE,
"profile" },
1276 0, 0,
VE,
"profile" },
1278 0, 0,
VE,
"profile" },
1280 0, 0,
VE,
"profile" },
1281 {
"vendor",
"vendor ID",
OFFSET(vendor),
1283 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1288 0, 0,
VE,
"quant_mat" },
1290 0, 0,
VE,
"quant_mat" },
1292 0, 0,
VE,
"quant_mat" },
1294 0, 0,
VE,
"quant_mat" },
1296 0, 0,
VE,
"quant_mat" },
1298 0, 0,
VE,
"quant_mat" },
1300 { .i64 = 16 }, 0, 16,
VE },