34 #define CFACTOR_Y422 2
35 #define CFACTOR_Y444 3
37 #define MAX_MBS_PER_SLICE 8
63 4, 7, 9, 11, 13, 14, 15, 63,
64 7, 7, 11, 12, 14, 15, 63, 63,
65 9, 11, 13, 14, 15, 63, 63, 63,
66 11, 11, 13, 14, 63, 63, 63, 63,
67 11, 13, 14, 63, 63, 63, 63, 63,
68 13, 14, 63, 63, 63, 63, 63, 63,
69 13, 63, 63, 63, 63, 63, 63, 63,
70 63, 63, 63, 63, 63, 63, 63, 63,
73 4, 7, 9, 11, 13, 14, 63, 63,
74 7, 7, 11, 12, 14, 63, 63, 63,
75 9, 11, 13, 14, 63, 63, 63, 63,
76 11, 11, 13, 14, 63, 63, 63, 63,
77 11, 13, 14, 63, 63, 63, 63, 63,
78 13, 14, 63, 63, 63, 63, 63, 63,
79 13, 63, 63, 63, 63, 63, 63, 63,
80 63, 63, 63, 63, 63, 63, 63, 63
83 4, 5, 6, 7, 9, 11, 13, 15,
84 5, 5, 7, 8, 11, 13, 15, 17,
85 6, 7, 9, 11, 13, 15, 15, 17,
86 7, 7, 9, 11, 13, 15, 17, 19,
87 7, 9, 11, 13, 14, 16, 19, 23,
88 9, 11, 13, 14, 16, 19, 23, 29,
89 9, 11, 13, 15, 17, 21, 28, 35,
90 11, 13, 16, 17, 21, 28, 35, 41,
93 4, 4, 5, 5, 6, 7, 7, 9,
94 4, 4, 5, 6, 7, 7, 9, 9,
95 5, 5, 6, 7, 7, 9, 9, 10,
96 5, 5, 6, 7, 7, 9, 9, 10,
97 5, 6, 7, 7, 8, 9, 10, 12,
98 6, 7, 7, 8, 9, 10, 12, 15,
99 6, 7, 7, 9, 10, 11, 14, 17,
100 7, 7, 9, 10, 11, 14, 17, 21,
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,
106 4, 4, 4, 4, 4, 4, 4, 5,
107 4, 4, 4, 4, 4, 4, 5, 5,
108 4, 4, 4, 4, 4, 5, 5, 6,
109 4, 4, 4, 4, 5, 5, 6, 7,
110 4, 4, 4, 4, 5, 6, 7, 7,
113 2, 2, 2, 2, 2, 2, 2, 2,
114 2, 2, 2, 2, 2, 2, 2, 2,
115 2, 2, 2, 2, 2, 2, 2, 2,
116 2, 2, 2, 2, 2, 2, 2, 3,
117 2, 2, 2, 2, 2, 2, 3, 3,
118 2, 2, 2, 2, 2, 3, 3, 3,
119 2, 2, 2, 2, 3, 3, 3, 4,
120 2, 2, 2, 2, 3, 3, 4, 4,
123 4, 4, 4, 4, 4, 4, 4, 4,
124 4, 4, 4, 4, 4, 4, 4, 4,
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,
134 #define NUM_MB_LIMITS 4
153 .tag =
MKTAG(
'a',
'p',
'c',
'o'),
156 .br_tab = { 300, 242, 220, 194 },
162 .tag =
MKTAG(
'a',
'p',
'c',
's'),
165 .br_tab = { 720, 560, 490, 440 },
170 .full_name =
"standard",
171 .tag =
MKTAG(
'a',
'p',
'c',
'n'),
174 .br_tab = { 1050, 808, 710, 632 },
179 .full_name =
"high quality",
180 .tag =
MKTAG(
'a',
'p',
'c',
'h'),
183 .br_tab = { 1566, 1216, 1070, 950 },
189 .tag =
MKTAG(
'a',
'p',
'4',
'h'),
192 .br_tab = { 2350, 1828, 1600, 1425 },
197 .full_name =
"4444XQ",
198 .tag =
MKTAG(
'a',
'p',
'4',
'x'),
201 .br_tab = { 3525, 2742, 2400, 2137 },
207 #define TRELLIS_WIDTH 16
208 #define SCORE_LIMIT INT_MAX / 2
217 #define MAX_STORED_Q 16
240 ptrdiff_t linesize, int16_t *
block);
271 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
272 int16_t *blocks, uint16_t *emu_buf,
273 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
275 const uint16_t *esrc;
276 const int mb_width = 4 * blocks_per_mb;
280 for (
i = 0;
i < mbs_per_slice;
i++,
src += mb_width) {
282 memset(blocks, 0, 64 * (mbs_per_slice -
i) * blocks_per_mb
286 if (x + mb_width <=
w && y + 16 <=
h) {
288 elinesize = linesize;
293 elinesize = 16 *
sizeof(*emu_buf);
295 bw =
FFMIN(
w - x, mb_width);
298 for (j = 0; j < bh; j++) {
299 memcpy(emu_buf + j * 16,
302 pix = emu_buf[j * 16 + bw - 1];
303 for (k = bw; k < mb_width; k++)
304 emu_buf[j * 16 + k] = pix;
307 memcpy(emu_buf + j * 16,
308 emu_buf + (bh - 1) * 16,
309 mb_width *
sizeof(*emu_buf));
312 ctx->fdct(&
ctx->fdsp, esrc, elinesize, blocks);
314 if (blocks_per_mb > 2) {
315 ctx->fdct(&
ctx->fdsp, esrc + 8, elinesize, blocks);
318 ctx->fdct(&
ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
320 if (blocks_per_mb > 2) {
321 ctx->fdct(&
ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
325 ctx->fdct(&
ctx->fdsp, esrc, elinesize, blocks);
327 ctx->fdct(&
ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
329 if (blocks_per_mb > 2) {
330 ctx->fdct(&
ctx->fdsp, esrc + 8, elinesize, blocks);
332 ctx->fdct(&
ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
342 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
343 uint16_t *blocks,
int mbs_per_slice,
int abits)
345 const int slice_width = 16 * mbs_per_slice;
346 int i, j, copy_w, copy_h;
348 copy_w =
FFMIN(
w - x, slice_width);
349 copy_h =
FFMIN(
h - y, 16);
350 for (
i = 0;
i < copy_h;
i++) {
351 memcpy(blocks,
src, copy_w *
sizeof(*
src));
353 for (j = 0; j < copy_w; j++)
356 for (j = 0; j < copy_w; j++)
357 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
358 for (j = copy_w; j < slice_width; j++)
359 blocks[j] = blocks[copy_w - 1];
360 blocks += slice_width;
361 src += linesize >> 1;
363 for (;
i < 16;
i++) {
364 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
365 blocks += slice_width;
374 unsigned int rice_order, exp_order, switch_bits, switch_val;
382 switch_val = switch_bits << rice_order;
384 if (
val >= switch_val) {
385 val -= switch_val - (1 << exp_order);
388 put_bits(pb, exponent - exp_order + switch_bits, 0);
391 exponent =
val >> rice_order;
401 #define GET_SIGN(x) ((x) >> 31)
402 #define MAKE_CODE(x) ((((x)) * 2) ^ GET_SIGN(x))
405 int blocks_per_slice,
int scale)
410 prev_dc = (blocks[0] - 0x4000) / scale;
416 for (
i = 1;
i < blocks_per_slice;
i++, blocks += 64) {
417 dc = (blocks[0] - 0x4000) / scale;
431 int blocks_per_slice,
432 int plane_size_factor,
433 const uint8_t *scan,
const int16_t *qmat)
437 int max_coeffs, abs_level;
439 max_coeffs = blocks_per_slice << 6;
444 for (
i = 1;
i < 64;
i++) {
445 for (idx = scan[
i]; idx < max_coeffs; idx += 64) {
446 level = blocks[idx] / qmat[scan[
i]];
465 const uint16_t *
src, ptrdiff_t linesize,
466 int mbs_per_slice, int16_t *blocks,
467 int blocks_per_mb,
int plane_size_factor,
470 int blocks_per_slice, saved_pos;
473 blocks_per_slice = mbs_per_slice * blocks_per_mb;
475 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
476 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
477 ctx->scantable, qmat);
485 const int dbits = (abits == 8) ? 4 : 7;
486 const int dsize = 1 << dbits - 1;
487 int diff = cur - prev;
490 if (
diff >= (1 << abits) - dsize)
492 if (diff < -dsize || diff > dsize || !
diff) {
517 int mbs_per_slice, uint16_t *blocks,
520 const int abits =
ctx->alpha_bits;
521 const int mask = (1 << abits) - 1;
522 const int num_coeffs = mbs_per_slice * 256;
524 int prev =
mask, cur;
541 }
while (idx < num_coeffs);
557 int slice_width_factor =
av_log2(mbs_per_slice);
558 int num_cblocks, pwidth, line_add;
560 int plane_factor, is_chroma;
562 uint16_t *qmat_chroma;
564 if (
ctx->pictures_per_frame == 1)
569 if (
ctx->force_quant) {
570 qmat =
ctx->quants[0];
571 qmat_chroma =
ctx->quants_chroma[0];
574 qmat_chroma =
ctx->quants_chroma[
quant];
576 qmat =
ctx->custom_q;
577 qmat_chroma =
ctx->custom_chroma_q;
578 for (
i = 0;
i < 64;
i++) {
580 qmat_chroma[
i] =
ctx->quant_chroma_mat[
i] *
quant;
584 for (
i = 0;
i <
ctx->num_planes;
i++) {
585 is_chroma = (
i == 1 ||
i == 2);
586 plane_factor = slice_width_factor + 2;
588 plane_factor +=
ctx->chroma_factor - 3;
593 pwidth = avctx->
width;
598 pwidth = avctx->
width >> 1;
602 src = (
const uint16_t*)(pic->
data[
i] + yp * linesize +
607 pwidth, avctx->
height /
ctx->pictures_per_frame,
608 ctx->blocks[0],
ctx->emu_buf,
609 mbs_per_slice, num_cblocks, is_chroma);
612 mbs_per_slice,
ctx->blocks[0],
613 num_cblocks, plane_factor,
617 mbs_per_slice,
ctx->blocks[0],
618 num_cblocks, plane_factor,
623 pwidth, avctx->
height /
ctx->pictures_per_frame,
624 ctx->blocks[0], mbs_per_slice,
ctx->alpha_bits);
631 "Underestimated required buffer size.\n");
640 unsigned int rice_order, exp_order, switch_bits, switch_val;
648 switch_val = switch_bits << rice_order;
650 if (
val >= switch_val) {
651 val -= switch_val - (1 << exp_order);
654 return exponent * 2 - exp_order + switch_bits + 1;
656 return (
val >> rice_order) + rice_order + 1;
667 prev_dc = (blocks[0] - 0x4000) / scale;
674 for (
i = 1;
i < blocks_per_slice;
i++, blocks += 64) {
675 dc = (blocks[0] - 0x4000) / scale;
692 int plane_size_factor,
693 const uint8_t *scan,
const int16_t *qmat)
697 int max_coeffs, abs_level;
700 max_coeffs = blocks_per_slice << 6;
705 for (
i = 1;
i < 64;
i++) {
706 for (idx = scan[
i]; idx < max_coeffs; idx += 64) {
707 level = blocks[idx] / qmat[scan[
i]];
728 const uint16_t *
src, ptrdiff_t linesize,
730 int blocks_per_mb,
int plane_size_factor,
733 int blocks_per_slice;
736 blocks_per_slice = mbs_per_slice * blocks_per_mb;
740 plane_size_factor,
ctx->scantable, qmat);
747 const int dbits = (abits == 8) ? 4 : 7;
748 const int dsize = 1 << dbits - 1;
749 int diff = cur - prev;
752 if (
diff >= (1 << abits) - dsize)
754 if (diff < -dsize || diff > dsize || !
diff)
761 const uint16_t *
src, ptrdiff_t linesize,
762 int mbs_per_slice, int16_t *blocks)
764 const int abits =
ctx->alpha_bits;
765 const int mask = (1 << abits) - 1;
766 const int num_coeffs = mbs_per_slice * 256;
767 int prev =
mask, cur;
790 }
while (idx < num_coeffs);
803 int trellis_node,
int x,
int y,
int mbs_per_slice,
807 int i, q, pq, xp, yp;
809 int slice_width_factor =
av_log2(mbs_per_slice);
815 int mbs, prev, cur, new_score;
819 uint16_t *qmat_chroma;
820 int linesize[4], line_add;
823 if (
ctx->pictures_per_frame == 1)
826 line_add =
ctx->cur_picture_idx ^ !
ctx->pic->top_field_first;
827 mbs = x + mbs_per_slice;
829 for (
i = 0;
i <
ctx->num_planes;
i++) {
830 is_chroma[
i] = (
i == 1 ||
i == 2);
831 plane_factor[
i] = slice_width_factor + 2;
833 plane_factor[
i] +=
ctx->chroma_factor - 3;
838 pwidth = avctx->
width;
843 pwidth = avctx->
width >> 1;
846 linesize[
i] =
ctx->pic->linesize[
i] *
ctx->pictures_per_frame;
847 src = (
const uint16_t *)(
ctx->pic->data[
i] + yp * linesize[
i] +
848 line_add *
ctx->pic->linesize[
i]) + xp;
852 pwidth, avctx->
height /
ctx->pictures_per_frame,
853 td->blocks[
i],
td->emu_buf,
854 mbs_per_slice, num_cblocks[
i], is_chroma[
i]);
857 pwidth, avctx->
height /
ctx->pictures_per_frame,
858 td->blocks[
i], mbs_per_slice,
ctx->alpha_bits);
863 td->nodes[trellis_node + q].prev_node = -1;
864 td->nodes[trellis_node + q].quant = q;
869 mbs_per_slice,
td->blocks[3]);
877 num_cblocks[0], plane_factor[0],
879 for (
i = 1;
i <
ctx->num_planes - !!
ctx->alpha_bits;
i++) {
883 num_cblocks[
i], plane_factor[
i],
884 ctx->quants_chroma[q],
td);
886 if (
bits > 65000 * 8)
889 slice_bits[q] =
bits;
890 slice_score[q] =
error;
892 if (slice_bits[
max_quant] <=
ctx->bits_per_mb * mbs_per_slice) {
901 qmat =
ctx->quants[q];
902 qmat_chroma =
ctx->quants_chroma[q];
905 qmat_chroma =
td->custom_chroma_q;
906 for (
i = 0;
i < 64;
i++) {
907 qmat[
i] =
ctx->quant_mat[
i] * q;
908 qmat_chroma[
i] =
ctx->quant_chroma_mat[
i] * q;
914 num_cblocks[0], plane_factor[0],
916 for (
i = 1;
i <
ctx->num_planes - !!
ctx->alpha_bits;
i++) {
920 num_cblocks[
i], plane_factor[
i],
923 if (bits <= ctx->bits_per_mb * mbs_per_slice)
931 td->nodes[trellis_node +
max_quant + 1].quant = overquant;
933 bits_limit = mbs *
ctx->bits_per_mb;
938 cur = trellis_node + q;
940 bits =
td->nodes[prev].bits + slice_bits[q];
941 error = slice_score[q];
942 if (
bits > bits_limit)
946 new_score =
td->nodes[prev].score +
error;
949 if (
td->nodes[cur].prev_node == -1 ||
950 td->nodes[cur].score >= new_score) {
952 td->nodes[cur].bits =
bits;
953 td->nodes[cur].score = new_score;
954 td->nodes[cur].prev_node = prev;
962 if (
td->nodes[trellis_node + q].score <=
error) {
963 error =
td->nodes[trellis_node + q].score;
964 pq = trellis_node + q;
972 int jobnr,
int threadnr)
976 int mbs_per_slice =
ctx->mbs_per_slice;
977 int x, y = jobnr,
mb, q = 0;
979 for (x =
mb = 0; x <
ctx->mb_width; x += mbs_per_slice,
mb++) {
980 while (
ctx->mb_width - x < mbs_per_slice)
987 for (x =
ctx->slices_width - 1; x >= 0; x--) {
988 ctx->slice_q[x + y *
ctx->slices_width] =
td->nodes[q].quant;
989 q =
td->nodes[q].prev_node;
996 const AVFrame *pic,
int *got_packet)
999 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *
tmp;
1002 int x, y,
i,
mb, q = 0;
1003 int sizes[4] = { 0 };
1004 int slice_hdr_size = 2 + 2 * (
ctx->num_planes - 1);
1007 int max_slice_size = (
ctx->frame_size_upper_bound - 200) / (
ctx->pictures_per_frame *
ctx->slices_per_picture + 1);
1011 pkt_size =
ctx->frame_size_upper_bound;
1020 bytestream_put_be32 (&orig_buf,
FRAME_ID);
1026 bytestream_put_be16 (&buf, 0);
1028 bytestream_put_be16 (&buf, avctx->
width);
1029 bytestream_put_be16 (&buf, avctx->
height);
1031 frame_flags =
ctx->chroma_factor << 6;
1034 bytestream_put_byte (&buf, frame_flags);
1036 bytestream_put_byte (&buf, 0);
1038 bytestream_put_byte (&buf, pic->
color_trc);
1040 bytestream_put_byte (&buf, 0x40 | (
ctx->alpha_bits >> 3));
1041 bytestream_put_byte (&buf, 0);
1043 bytestream_put_byte (&buf, 0x03);
1045 for (
i = 0;
i < 64;
i++)
1046 bytestream_put_byte(&buf,
ctx->quant_mat[
i]);
1048 for (
i = 0;
i < 64;
i++)
1049 bytestream_put_byte(&buf,
ctx->quant_mat[
i]);
1051 bytestream_put_byte (&buf, 0x00);
1053 bytestream_put_be16 (&
tmp, buf - orig_buf);
1055 for (
ctx->cur_picture_idx = 0;
1056 ctx->cur_picture_idx <
ctx->pictures_per_frame;
1057 ctx->cur_picture_idx++) {
1059 picture_size_pos = buf + 1;
1060 bytestream_put_byte (&buf, 0x40);
1062 bytestream_put_be16 (&buf,
ctx->slices_per_picture);
1063 bytestream_put_byte (&buf,
av_log2(
ctx->mbs_per_slice) << 4);
1067 buf +=
ctx->slices_per_picture * 2;
1070 if (!
ctx->force_quant) {
1077 for (y = 0; y <
ctx->mb_height; y++) {
1078 int mbs_per_slice =
ctx->mbs_per_slice;
1079 for (x =
mb = 0; x <
ctx->mb_width; x += mbs_per_slice,
mb++) {
1080 q =
ctx->force_quant ?
ctx->force_quant
1081 :
ctx->slice_q[
mb + y *
ctx->slices_width];
1083 while (
ctx->mb_width - x < mbs_per_slice)
1084 mbs_per_slice >>= 1;
1086 bytestream_put_byte(&buf, slice_hdr_size << 3);
1088 buf += slice_hdr_size - 1;
1089 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1093 int delta = 200 + (
ctx->pictures_per_frame *
1094 ctx->slices_per_picture + 1) *
1095 max_slice_size - pkt_size;
1098 ctx->frame_size_upper_bound +=
delta;
1102 "Packet too small: is %i,"
1103 " needs %i (slice: %i). "
1104 "Correct allocation",
1105 pkt_size,
delta, max_slice_size);
1115 orig_buf =
pkt->
data + (orig_buf - start);
1116 buf =
pkt->
data + (buf - start);
1117 picture_size_pos =
pkt->
data + (picture_size_pos - start);
1118 slice_sizes =
pkt->
data + (slice_sizes - start);
1119 slice_hdr =
pkt->
data + (slice_hdr - start);
1128 bytestream_put_byte(&slice_hdr, q);
1129 slice_size = slice_hdr_size +
sizes[
ctx->num_planes - 1];
1130 for (
i = 0;
i <
ctx->num_planes - 1;
i++) {
1131 bytestream_put_be16(&slice_hdr,
sizes[
i]);
1134 bytestream_put_be16(&slice_sizes, slice_size);
1135 buf += slice_size - slice_hdr_size;
1136 if (max_slice_size < slice_size)
1137 max_slice_size = slice_size;
1141 picture_size = buf - (picture_size_pos - 1);
1142 bytestream_put_be32(&picture_size_pos, picture_size);
1172 ptrdiff_t linesize, int16_t *
block)
1175 const uint16_t *tsrc =
src;
1177 for (y = 0; y < 8; y++) {
1178 for (x = 0; x < 8; x++)
1179 block[y * 8 + x] = tsrc[x];
1180 tsrc += linesize >> 1;
1194 #if FF_API_CODED_FRAME
1206 mps =
ctx->mbs_per_slice;
1207 if (mps & (mps - 1)) {
1209 "there should be an integer power of two MBs per slice\n");
1215 !(
desc->log2_chroma_w +
desc->log2_chroma_h))
1219 ?
"4:4:4:4 profile because of the used input colorspace"
1220 :
"HQ profile to keep best quality");
1227 "encode alpha. Override with -profile if needed.\n");
1228 ctx->alpha_bits = 0;
1230 if (
ctx->alpha_bits & 7) {
1236 ctx->alpha_bits = 0;
1243 ctx->num_planes = 3 + !!
ctx->alpha_bits;
1252 ctx->slices_width =
ctx->mb_width / mps;
1254 ctx->slices_per_picture =
ctx->mb_height *
ctx->slices_width;
1257 if (
ctx->quant_sel == -1) {
1265 if (strlen(
ctx->vendor) != 4) {
1271 if (!
ctx->force_quant) {
1272 if (!
ctx->bits_per_mb) {
1275 ctx->pictures_per_frame)
1277 ctx->bits_per_mb =
ctx->profile_info->br_tab[
i];
1278 if (
ctx->alpha_bits)
1279 ctx->bits_per_mb *= 20;
1280 }
else if (
ctx->bits_per_mb < 128) {
1288 for (j = 0; j < 64; j++) {
1289 ctx->quants[
i][j] =
ctx->quant_mat[j] *
i;
1290 ctx->quants_chroma[
i][j] =
ctx->quant_chroma_mat[j] *
i;
1295 if (!
ctx->slice_q) {
1309 *
sizeof(*
ctx->tdata->nodes));
1310 if (!
ctx->tdata[j].nodes) {
1315 ctx->tdata[j].nodes[
i].prev_node = -1;
1316 ctx->tdata[j].nodes[
i].bits = 0;
1317 ctx->tdata[j].nodes[
i].score = 0;
1324 if (
ctx->force_quant > 64) {
1329 for (j = 0; j < 64; j++) {
1330 ctx->quants[0][j] =
ctx->quant_mat[j] *
ctx->force_quant;
1331 ctx->quants_chroma[0][j] =
ctx->quant_chroma_mat[j] *
ctx->force_quant;
1332 ls +=
av_log2((1 << 11) /
ctx->quants[0][j]) * 2 + 1;
1333 ls_chroma +=
av_log2((1 << 11) /
ctx->quants_chroma[0][j]) * 2 + 1;
1336 ctx->bits_per_mb = ls * 4 + ls_chroma * 4;
1338 ctx->bits_per_mb += ls_chroma * 4;
1341 ctx->frame_size_upper_bound = (
ctx->pictures_per_frame *
1342 ctx->slices_per_picture + 1) *
1343 (2 + 2 *
ctx->num_planes +
1344 (mps *
ctx->bits_per_mb) / 8)
1347 if (
ctx->alpha_bits) {
1349 ctx->frame_size_upper_bound += (
ctx->pictures_per_frame *
1350 ctx->slices_per_picture + 1) *
1351 (
ctx->mbs_per_slice * 256 *
1352 (1 +
ctx->alpha_bits + 1) + 7 >> 3);
1358 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1359 ctx->profile,
ctx->slices_per_picture *
ctx->pictures_per_frame,
1362 ctx->frame_size_upper_bound);
1367 #define OFFSET(x) offsetof(ProresContext, x)
1368 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1371 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1377 0, 0,
VE,
"profile" },
1379 0, 0,
VE,
"profile" },
1381 0, 0,
VE,
"profile" },
1383 0, 0,
VE,
"profile" },
1385 0, 0,
VE,
"profile" },
1387 0, 0,
VE,
"profile" },
1389 0, 0,
VE,
"profile" },
1390 {
"vendor",
"vendor ID",
OFFSET(vendor),
1392 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1397 0, 0,
VE,
"quant_mat" },
1399 0, 0,
VE,
"quant_mat" },
1401 0, 0,
VE,
"quant_mat" },
1403 0, 0,
VE,
"quant_mat" },
1405 0, 0,
VE,
"quant_mat" },
1407 0, 0,
VE,
"quant_mat" },
1409 { .i64 = 16 }, 0, 16,
VE },
1421 .
name =
"prores_ks",
static double val(void *priv, double ch)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
static const unsigned codebook[256][2]
#define MKTAG(a, b, c, d)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
@ AV_PICTURE_TYPE_I
Intra.
#define LIBAVUTIL_VERSION_INT
static const int sizes[][2]
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_DISABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
static enum AVPixelFormat pix_fmts[]
static const uint16_t mask[17]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
#define AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUV422P10
AVPixelFormat
Pixel format.
#define AV_PIX_FMT_YUV444P10
const AVProfile ff_prores_profiles[]
const uint8_t ff_prores_ac_codebook[7]
const uint8_t ff_prores_dc_codebook[4]
const uint8_t ff_prores_progressive_scan[64]
const uint8_t ff_prores_run_to_cb_index[16]
Lookup tables for adaptive switching between codebooks according with previous run/level value.
const uint8_t ff_prores_lev_to_cb_index[10]
const uint8_t ff_prores_interlaced_scan[64]
static int est_alpha_diff(int cur, int prev, int abits)
static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, int mbs_per_slice, uint16_t *blocks, int quant)
static const AVClass proresenc_class
static int estimate_alpha_plane(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int16_t *blocks)
@ PRORES_PROFILE_STANDARD
static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice, int plane_size_factor, const uint8_t *scan, const int16_t *qmat)
static const AVOption options[]
static void encode_acs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int plane_size_factor, const uint8_t *scan, const int16_t *qmat)
static av_cold int encode_init(AVCodecContext *avctx)
static av_cold int encode_close(AVCodecContext *avctx)
static void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
Write an unsigned rice/exp golomb codeword.
static void put_alpha_run(PutBitContext *pb, int run)
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, int mbs_per_slice)
static const int prores_mb_limits[NUM_MB_LIMITS]
static const struct prores_profile prores_profile_info[6]
static void get_alpha_data(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int x, int y, int w, int h, uint16_t *blocks, int mbs_per_slice, int abits)
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
static int estimate_vlc(unsigned codebook, int val)
static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice, int scale)
#define MAX_MBS_PER_SLICE
static int find_slice_quant(AVCodecContext *avctx, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
static void get_slice_data(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int x, int y, int w, int h, int16_t *blocks, uint16_t *emu_buf, int mbs_per_slice, int blocks_per_mb, int is_chroma)
AVCodec ff_prores_ks_encoder
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
static int estimate_slice_plane(ProresContext *ctx, int *error, int plane, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int blocks_per_mb, int plane_size_factor, const int16_t *qmat, ProresThreadData *td)
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
static const uint8_t prores_quant_matrices[][64]
static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int16_t *blocks, int blocks_per_mb, int plane_size_factor, const int16_t *qmat)
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
static int find_quant_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static int put_bits_count(PutBitContext *s)
static int put_bits_left(PutBitContext *s)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
typedef void(RENAME(mix_any_func_type))
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
int global_quality
Global quality for codecs which cannot change it per frame.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
int flags
AV_CODEC_FLAG_*.
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int key_frame
1 -> keyframe, 0-> not
enum AVColorPrimaries color_primaries
int top_field_first
If the content is interlaced, is top field displayed first.
enum AVColorSpace colorspace
YUV colorspace type.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVColorTransferCharacteristic color_trc
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
void(* fdct)(int16_t *block)
const struct prores_profile * profile_info
int16_t quants[MAX_STORED_Q][64]
const uint8_t * quant_mat
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
int16_t quants_chroma[MAX_STORED_Q][64]
int frame_size_upper_bound
const uint8_t * quant_chroma_mat
const uint8_t * scantable
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
unsigned mb_width
width of the current picture in mb
int16_t custom_chroma_q[64]
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
int16_t custom_chroma_q[64]
struct TrellisNode * nodes
int br_tab[NUM_MB_LIMITS]
#define avpriv_request_sample(...)
static void error(const char *err)
static av_always_inline int diff(const uint32_t a, const uint32_t b)