37 #define CFACTOR_Y422 2
38 #define CFACTOR_Y444 3
40 #define MAX_MBS_PER_SLICE 8
66 4, 7, 9, 11, 13, 14, 15, 63,
67 7, 7, 11, 12, 14, 15, 63, 63,
68 9, 11, 13, 14, 15, 63, 63, 63,
69 11, 11, 13, 14, 63, 63, 63, 63,
70 11, 13, 14, 63, 63, 63, 63, 63,
71 13, 14, 63, 63, 63, 63, 63, 63,
72 13, 63, 63, 63, 63, 63, 63, 63,
73 63, 63, 63, 63, 63, 63, 63, 63,
76 4, 7, 9, 11, 13, 14, 63, 63,
77 7, 7, 11, 12, 14, 63, 63, 63,
78 9, 11, 13, 14, 63, 63, 63, 63,
79 11, 11, 13, 14, 63, 63, 63, 63,
80 11, 13, 14, 63, 63, 63, 63, 63,
81 13, 14, 63, 63, 63, 63, 63, 63,
82 13, 63, 63, 63, 63, 63, 63, 63,
83 63, 63, 63, 63, 63, 63, 63, 63
86 4, 5, 6, 7, 9, 11, 13, 15,
87 5, 5, 7, 8, 11, 13, 15, 17,
88 6, 7, 9, 11, 13, 15, 15, 17,
89 7, 7, 9, 11, 13, 15, 17, 19,
90 7, 9, 11, 13, 14, 16, 19, 23,
91 9, 11, 13, 14, 16, 19, 23, 29,
92 9, 11, 13, 15, 17, 21, 28, 35,
93 11, 13, 16, 17, 21, 28, 35, 41,
96 4, 4, 5, 5, 6, 7, 7, 9,
97 4, 4, 5, 6, 7, 7, 9, 9,
98 5, 5, 6, 7, 7, 9, 9, 10,
99 5, 5, 6, 7, 7, 9, 9, 10,
100 5, 6, 7, 7, 8, 9, 10, 12,
101 6, 7, 7, 8, 9, 10, 12, 15,
102 6, 7, 7, 9, 10, 11, 14, 17,
103 7, 7, 9, 10, 11, 14, 17, 21,
106 4, 4, 4, 4, 4, 4, 4, 4,
107 4, 4, 4, 4, 4, 4, 4, 4,
108 4, 4, 4, 4, 4, 4, 4, 4,
109 4, 4, 4, 4, 4, 4, 4, 5,
110 4, 4, 4, 4, 4, 4, 5, 5,
111 4, 4, 4, 4, 4, 5, 5, 6,
112 4, 4, 4, 4, 5, 5, 6, 7,
113 4, 4, 4, 4, 5, 6, 7, 7,
116 2, 2, 2, 2, 2, 2, 2, 2,
117 2, 2, 2, 2, 2, 2, 2, 2,
118 2, 2, 2, 2, 2, 2, 2, 2,
119 2, 2, 2, 2, 2, 2, 2, 3,
120 2, 2, 2, 2, 2, 2, 3, 3,
121 2, 2, 2, 2, 2, 3, 3, 3,
122 2, 2, 2, 2, 3, 3, 3, 4,
123 2, 2, 2, 2, 3, 3, 4, 4,
126 4, 4, 4, 4, 4, 4, 4, 4,
127 4, 4, 4, 4, 4, 4, 4, 4,
128 4, 4, 4, 4, 4, 4, 4, 4,
129 4, 4, 4, 4, 4, 4, 4, 4,
130 4, 4, 4, 4, 4, 4, 4, 4,
131 4, 4, 4, 4, 4, 4, 4, 4,
132 4, 4, 4, 4, 4, 4, 4, 4,
133 4, 4, 4, 4, 4, 4, 4, 4,
137 #define NUM_MB_LIMITS 4
156 .tag =
MKTAG(
'a',
'p',
'c',
'o'),
159 .br_tab = { 300, 242, 220, 194 },
165 .tag =
MKTAG(
'a',
'p',
'c',
's'),
168 .br_tab = { 720, 560, 490, 440 },
173 .full_name =
"standard",
174 .tag =
MKTAG(
'a',
'p',
'c',
'n'),
177 .br_tab = { 1050, 808, 710, 632 },
182 .full_name =
"high quality",
183 .tag =
MKTAG(
'a',
'p',
'c',
'h'),
186 .br_tab = { 1566, 1216, 1070, 950 },
192 .tag =
MKTAG(
'a',
'p',
'4',
'h'),
195 .br_tab = { 2350, 1828, 1600, 1425 },
200 .full_name =
"4444XQ",
201 .tag =
MKTAG(
'a',
'p',
'4',
'x'),
204 .br_tab = { 3525, 2742, 2400, 2137 },
210 #define TRELLIS_WIDTH 16
211 #define SCORE_LIMIT INT_MAX / 2
220 #define MAX_STORED_Q 16
243 ptrdiff_t linesize, int16_t *
block);
274 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
275 int16_t *blocks, uint16_t *emu_buf,
276 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
278 const uint16_t *esrc;
279 const int mb_width = 4 * blocks_per_mb;
283 for (
i = 0;
i < mbs_per_slice;
i++,
src += mb_width) {
285 memset(blocks, 0, 64 * (mbs_per_slice -
i) * blocks_per_mb
289 if (x + mb_width <=
w && y + 16 <=
h) {
291 elinesize = linesize;
296 elinesize = 16 *
sizeof(*emu_buf);
298 bw =
FFMIN(
w - x, mb_width);
301 for (j = 0; j < bh; j++) {
302 memcpy(emu_buf + j * 16,
305 pix = emu_buf[j * 16 + bw - 1];
306 for (k = bw; k < mb_width; k++)
307 emu_buf[j * 16 + k] = pix;
310 memcpy(emu_buf + j * 16,
311 emu_buf + (bh - 1) * 16,
312 mb_width *
sizeof(*emu_buf));
315 ctx->fdct(&
ctx->fdsp, esrc, elinesize, blocks);
317 if (blocks_per_mb > 2) {
318 ctx->fdct(&
ctx->fdsp, esrc + 8, elinesize, blocks);
321 ctx->fdct(&
ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
323 if (blocks_per_mb > 2) {
324 ctx->fdct(&
ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
328 ctx->fdct(&
ctx->fdsp, esrc, elinesize, blocks);
330 ctx->fdct(&
ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
332 if (blocks_per_mb > 2) {
333 ctx->fdct(&
ctx->fdsp, esrc + 8, elinesize, blocks);
335 ctx->fdct(&
ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
345 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
346 int16_t *blocks,
int mbs_per_slice,
int abits)
348 const int slice_width = 16 * mbs_per_slice;
349 int i, j, copy_w, copy_h;
351 copy_w =
FFMIN(
w - x, slice_width);
352 copy_h =
FFMIN(
h - y, 16);
353 for (
i = 0;
i < copy_h;
i++) {
354 memcpy(blocks,
src, copy_w *
sizeof(*
src));
356 for (j = 0; j < copy_w; j++)
359 for (j = 0; j < copy_w; j++)
360 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
361 for (j = copy_w; j < slice_width; j++)
362 blocks[j] = blocks[copy_w - 1];
363 blocks += slice_width;
364 src += linesize >> 1;
366 for (;
i < 16;
i++) {
367 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
368 blocks += slice_width;
377 unsigned int rice_order, exp_order, switch_bits, switch_val;
385 switch_val = switch_bits << rice_order;
387 if (
val >= switch_val) {
388 val -= switch_val - (1 << exp_order);
391 put_bits(pb, exponent - exp_order + switch_bits, 0);
394 exponent =
val >> rice_order;
404 #define GET_SIGN(x) ((x) >> 31)
405 #define MAKE_CODE(x) ((((x)) * 2) ^ GET_SIGN(x))
408 int blocks_per_slice,
int scale)
413 prev_dc = (blocks[0] - 0x4000) / scale;
419 for (
i = 1;
i < blocks_per_slice;
i++, blocks += 64) {
420 dc = (blocks[0] - 0x4000) / scale;
434 int blocks_per_slice,
435 int plane_size_factor,
436 const uint8_t *scan,
const int16_t *qmat)
440 int max_coeffs, abs_level;
442 max_coeffs = blocks_per_slice << 6;
447 for (
i = 1;
i < 64;
i++) {
448 for (idx = scan[
i]; idx < max_coeffs; idx += 64) {
449 level = blocks[idx] / qmat[scan[
i]];
468 const uint16_t *
src, ptrdiff_t linesize,
469 int mbs_per_slice, int16_t *blocks,
470 int blocks_per_mb,
int plane_size_factor,
473 int blocks_per_slice, saved_pos;
476 blocks_per_slice = mbs_per_slice * blocks_per_mb;
478 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
479 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
480 ctx->scantable, qmat);
488 const int dbits = (abits == 8) ? 4 : 7;
489 const int dsize = 1 << dbits - 1;
490 int diff = cur - prev;
493 if (
diff >= (1 << abits) - dsize)
495 if (diff < -dsize || diff > dsize || !
diff) {
520 int mbs_per_slice, uint16_t *blocks,
523 const int abits =
ctx->alpha_bits;
524 const int mask = (1 << abits) - 1;
525 const int num_coeffs = mbs_per_slice * 256;
527 int prev =
mask, cur;
544 }
while (idx < num_coeffs);
560 int slice_width_factor =
av_log2(mbs_per_slice);
561 int num_cblocks, pwidth, line_add;
563 int plane_factor, is_chroma;
565 uint16_t *qmat_chroma;
567 if (
ctx->pictures_per_frame == 1)
572 if (
ctx->force_quant) {
573 qmat =
ctx->quants[0];
574 qmat_chroma =
ctx->quants_chroma[0];
577 qmat_chroma =
ctx->quants_chroma[
quant];
579 qmat =
ctx->custom_q;
580 qmat_chroma =
ctx->custom_chroma_q;
581 for (
i = 0;
i < 64;
i++) {
583 qmat_chroma[
i] =
ctx->quant_chroma_mat[
i] *
quant;
587 for (
i = 0;
i <
ctx->num_planes;
i++) {
588 is_chroma = (
i == 1 ||
i == 2);
589 plane_factor = slice_width_factor + 2;
591 plane_factor +=
ctx->chroma_factor - 3;
596 pwidth = avctx->
width;
601 pwidth = avctx->
width >> 1;
605 src = (
const uint16_t*)(pic->
data[
i] + yp * linesize +
610 pwidth, avctx->
height /
ctx->pictures_per_frame,
611 ctx->blocks[0],
ctx->emu_buf,
612 mbs_per_slice, num_cblocks, is_chroma);
615 mbs_per_slice,
ctx->blocks[0],
616 num_cblocks, plane_factor,
620 mbs_per_slice,
ctx->blocks[0],
621 num_cblocks, plane_factor,
626 pwidth, avctx->
height /
ctx->pictures_per_frame,
627 ctx->blocks[0], mbs_per_slice,
ctx->alpha_bits);
634 "Underestimated required buffer size.\n");
643 unsigned int rice_order, exp_order, switch_bits, switch_val;
651 switch_val = switch_bits << rice_order;
653 if (
val >= switch_val) {
654 val -= switch_val - (1 << exp_order);
657 return exponent * 2 - exp_order + switch_bits + 1;
659 return (
val >> rice_order) + rice_order + 1;
670 prev_dc = (blocks[0] - 0x4000) / scale;
677 for (
i = 1;
i < blocks_per_slice;
i++, blocks += 64) {
678 dc = (blocks[0] - 0x4000) / scale;
695 int plane_size_factor,
696 const uint8_t *scan,
const int16_t *qmat)
700 int max_coeffs, abs_level;
703 max_coeffs = blocks_per_slice << 6;
708 for (
i = 1;
i < 64;
i++) {
709 for (idx = scan[
i]; idx < max_coeffs; idx += 64) {
710 level = blocks[idx] / qmat[scan[
i]];
731 const uint16_t *
src, ptrdiff_t linesize,
733 int blocks_per_mb,
int plane_size_factor,
736 int blocks_per_slice;
739 blocks_per_slice = mbs_per_slice * blocks_per_mb;
743 plane_size_factor,
ctx->scantable, qmat);
750 const int dbits = (abits == 8) ? 4 : 7;
751 const int dsize = 1 << dbits - 1;
752 int diff = cur - prev;
755 if (
diff >= (1 << abits) - dsize)
757 if (diff < -dsize || diff > dsize || !
diff)
764 const uint16_t *
src, ptrdiff_t linesize,
765 int mbs_per_slice, int16_t *blocks)
767 const int abits =
ctx->alpha_bits;
768 const int mask = (1 << abits) - 1;
769 const int num_coeffs = mbs_per_slice * 256;
770 int prev =
mask, cur;
793 }
while (idx < num_coeffs);
806 int trellis_node,
int x,
int y,
int mbs_per_slice,
810 int i, q, pq, xp, yp;
812 int slice_width_factor =
av_log2(mbs_per_slice);
818 int mbs, prev, cur, new_score;
822 uint16_t *qmat_chroma;
823 int linesize[4], line_add;
826 if (
ctx->pictures_per_frame == 1)
829 line_add =
ctx->cur_picture_idx ^ !
ctx->pic->top_field_first;
830 mbs = x + mbs_per_slice;
832 for (
i = 0;
i <
ctx->num_planes;
i++) {
833 is_chroma[
i] = (
i == 1 ||
i == 2);
834 plane_factor[
i] = slice_width_factor + 2;
836 plane_factor[
i] +=
ctx->chroma_factor - 3;
841 pwidth = avctx->
width;
846 pwidth = avctx->
width >> 1;
849 linesize[
i] =
ctx->pic->linesize[
i] *
ctx->pictures_per_frame;
850 src = (
const uint16_t *)(
ctx->pic->data[
i] + yp * linesize[
i] +
851 line_add *
ctx->pic->linesize[
i]) + xp;
855 pwidth, avctx->
height /
ctx->pictures_per_frame,
856 td->blocks[
i],
td->emu_buf,
857 mbs_per_slice, num_cblocks[
i], is_chroma[
i]);
860 pwidth, avctx->
height /
ctx->pictures_per_frame,
861 td->blocks[
i], mbs_per_slice,
ctx->alpha_bits);
866 td->nodes[trellis_node + q].prev_node = -1;
867 td->nodes[trellis_node + q].quant = q;
872 mbs_per_slice,
td->blocks[3]);
880 num_cblocks[0], plane_factor[0],
882 for (
i = 1;
i <
ctx->num_planes - !!
ctx->alpha_bits;
i++) {
886 num_cblocks[
i], plane_factor[
i],
887 ctx->quants_chroma[q],
td);
889 if (
bits > 65000 * 8)
892 slice_bits[q] =
bits;
893 slice_score[q] =
error;
895 if (slice_bits[
max_quant] <=
ctx->bits_per_mb * mbs_per_slice) {
904 qmat =
ctx->quants[q];
905 qmat_chroma =
ctx->quants_chroma[q];
908 qmat_chroma =
td->custom_chroma_q;
909 for (
i = 0;
i < 64;
i++) {
910 qmat[
i] =
ctx->quant_mat[
i] * q;
911 qmat_chroma[
i] =
ctx->quant_chroma_mat[
i] * q;
917 num_cblocks[0], plane_factor[0],
919 for (
i = 1;
i <
ctx->num_planes - !!
ctx->alpha_bits;
i++) {
923 num_cblocks[
i], plane_factor[
i],
926 if (bits <= ctx->bits_per_mb * mbs_per_slice)
934 td->nodes[trellis_node +
max_quant + 1].quant = overquant;
936 bits_limit = mbs *
ctx->bits_per_mb;
941 cur = trellis_node + q;
943 bits =
td->nodes[prev].bits + slice_bits[q];
944 error = slice_score[q];
945 if (
bits > bits_limit)
949 new_score =
td->nodes[prev].score +
error;
952 if (
td->nodes[cur].prev_node == -1 ||
953 td->nodes[cur].score >= new_score) {
955 td->nodes[cur].bits =
bits;
956 td->nodes[cur].score = new_score;
957 td->nodes[cur].prev_node = prev;
965 if (
td->nodes[trellis_node + q].score <=
error) {
966 error =
td->nodes[trellis_node + q].score;
967 pq = trellis_node + q;
975 int jobnr,
int threadnr)
979 int mbs_per_slice =
ctx->mbs_per_slice;
980 int x, y = jobnr,
mb, q = 0;
982 for (x =
mb = 0; x <
ctx->mb_width; x += mbs_per_slice,
mb++) {
983 while (
ctx->mb_width - x < mbs_per_slice)
990 for (x =
ctx->slices_width - 1; x >= 0; x--) {
991 ctx->slice_q[x + y *
ctx->slices_width] =
td->nodes[q].quant;
992 q =
td->nodes[q].prev_node;
999 const AVFrame *pic,
int *got_packet)
1002 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *
tmp;
1005 int x, y,
i,
mb, q = 0;
1006 int sizes[4] = { 0 };
1007 int slice_hdr_size = 2 + 2 * (
ctx->num_planes - 1);
1010 int max_slice_size = (
ctx->frame_size_upper_bound - 200) / (
ctx->pictures_per_frame *
ctx->slices_per_picture + 1);
1014 pkt_size =
ctx->frame_size_upper_bound;
1023 bytestream_put_be32 (&orig_buf,
FRAME_ID);
1029 bytestream_put_be16 (&buf, 0);
1031 bytestream_put_be16 (&buf, avctx->
width);
1032 bytestream_put_be16 (&buf, avctx->
height);
1034 frame_flags =
ctx->chroma_factor << 6;
1037 bytestream_put_byte (&buf, frame_flags);
1039 bytestream_put_byte (&buf, 0);
1041 bytestream_put_byte (&buf, pic->
color_trc);
1043 bytestream_put_byte (&buf, 0x40 | (
ctx->alpha_bits >> 3));
1044 bytestream_put_byte (&buf, 0);
1046 bytestream_put_byte (&buf, 0x03);
1048 for (
i = 0;
i < 64;
i++)
1049 bytestream_put_byte(&buf,
ctx->quant_mat[
i]);
1051 for (
i = 0;
i < 64;
i++)
1052 bytestream_put_byte(&buf,
ctx->quant_mat[
i]);
1054 bytestream_put_byte (&buf, 0x00);
1056 bytestream_put_be16 (&
tmp, buf - orig_buf);
1058 for (
ctx->cur_picture_idx = 0;
1059 ctx->cur_picture_idx <
ctx->pictures_per_frame;
1060 ctx->cur_picture_idx++) {
1062 picture_size_pos = buf + 1;
1063 bytestream_put_byte (&buf, 0x40);
1065 bytestream_put_be16 (&buf,
ctx->slices_per_picture);
1066 bytestream_put_byte (&buf,
av_log2(
ctx->mbs_per_slice) << 4);
1070 buf +=
ctx->slices_per_picture * 2;
1073 if (!
ctx->force_quant) {
1080 for (y = 0; y <
ctx->mb_height; y++) {
1081 int mbs_per_slice =
ctx->mbs_per_slice;
1082 for (x =
mb = 0; x <
ctx->mb_width; x += mbs_per_slice,
mb++) {
1083 q =
ctx->force_quant ?
ctx->force_quant
1084 :
ctx->slice_q[
mb + y *
ctx->slices_width];
1086 while (
ctx->mb_width - x < mbs_per_slice)
1087 mbs_per_slice >>= 1;
1089 bytestream_put_byte(&buf, slice_hdr_size << 3);
1091 buf += slice_hdr_size - 1;
1092 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1096 int delta = 200 + (
ctx->pictures_per_frame *
1097 ctx->slices_per_picture + 1) *
1098 max_slice_size - pkt_size;
1101 ctx->frame_size_upper_bound +=
delta;
1105 "Packet too small: is %i,"
1106 " needs %i (slice: %i). "
1107 "Correct allocation",
1108 pkt_size,
delta, max_slice_size);
1118 orig_buf =
pkt->
data + (orig_buf - start);
1119 buf =
pkt->
data + (buf - start);
1120 picture_size_pos =
pkt->
data + (picture_size_pos - start);
1121 slice_sizes =
pkt->
data + (slice_sizes - start);
1122 slice_hdr =
pkt->
data + (slice_hdr - start);
1131 bytestream_put_byte(&slice_hdr, q);
1132 slice_size = slice_hdr_size +
sizes[
ctx->num_planes - 1];
1133 for (
i = 0;
i <
ctx->num_planes - 1;
i++) {
1134 bytestream_put_be16(&slice_hdr,
sizes[
i]);
1137 bytestream_put_be16(&slice_sizes, slice_size);
1138 buf += slice_size - slice_hdr_size;
1139 if (max_slice_size < slice_size)
1140 max_slice_size = slice_size;
1144 picture_size = buf - (picture_size_pos - 1);
1145 bytestream_put_be32(&picture_size_pos, picture_size);
1175 ptrdiff_t linesize, int16_t *
block)
1178 const uint16_t *tsrc =
src;
1180 for (y = 0; y < 8; y++) {
1181 for (x = 0; x < 8; x++)
1182 block[y * 8 + x] = tsrc[x];
1183 tsrc += linesize >> 1;
1197 #if FF_API_CODED_FRAME
1209 mps =
ctx->mbs_per_slice;
1210 if (mps & (mps - 1)) {
1212 "there should be an integer power of two MBs per slice\n");
1218 !(
desc->log2_chroma_w +
desc->log2_chroma_h))
1222 ?
"4:4:4:4 profile because of the used input colorspace"
1223 :
"HQ profile to keep best quality");
1230 "encode alpha. Override with -profile if needed.\n");
1231 ctx->alpha_bits = 0;
1233 if (
ctx->alpha_bits & 7) {
1239 ctx->alpha_bits = 0;
1246 ctx->num_planes = 3 + !!
ctx->alpha_bits;
1255 ctx->slices_width =
ctx->mb_width / mps;
1257 ctx->slices_per_picture =
ctx->mb_height *
ctx->slices_width;
1260 if (
ctx->quant_sel == -1) {
1268 if (strlen(
ctx->vendor) != 4) {
1274 if (!
ctx->force_quant) {
1275 if (!
ctx->bits_per_mb) {
1278 ctx->pictures_per_frame)
1280 ctx->bits_per_mb =
ctx->profile_info->br_tab[
i];
1281 if (
ctx->alpha_bits)
1282 ctx->bits_per_mb *= 20;
1283 }
else if (
ctx->bits_per_mb < 128) {
1291 for (j = 0; j < 64; j++) {
1292 ctx->quants[
i][j] =
ctx->quant_mat[j] *
i;
1293 ctx->quants_chroma[
i][j] =
ctx->quant_chroma_mat[j] *
i;
1298 if (!
ctx->slice_q) {
1312 *
sizeof(*
ctx->tdata->nodes));
1313 if (!
ctx->tdata[j].nodes) {
1318 ctx->tdata[j].nodes[
i].prev_node = -1;
1319 ctx->tdata[j].nodes[
i].bits = 0;
1320 ctx->tdata[j].nodes[
i].score = 0;
1327 if (
ctx->force_quant > 64) {
1332 for (j = 0; j < 64; j++) {
1333 ctx->quants[0][j] =
ctx->quant_mat[j] *
ctx->force_quant;
1334 ctx->quants_chroma[0][j] =
ctx->quant_chroma_mat[j] *
ctx->force_quant;
1335 ls +=
av_log2((1 << 11) /
ctx->quants[0][j]) * 2 + 1;
1336 ls_chroma +=
av_log2((1 << 11) /
ctx->quants_chroma[0][j]) * 2 + 1;
1339 ctx->bits_per_mb = ls * 4 + ls_chroma * 4;
1341 ctx->bits_per_mb += ls_chroma * 4;
1344 ctx->frame_size_upper_bound = (
ctx->pictures_per_frame *
1345 ctx->slices_per_picture + 1) *
1346 (2 + 2 *
ctx->num_planes +
1347 (mps *
ctx->bits_per_mb) / 8)
1350 if (
ctx->alpha_bits) {
1352 ctx->frame_size_upper_bound += (
ctx->pictures_per_frame *
1353 ctx->slices_per_picture + 1) *
1354 (
ctx->mbs_per_slice * 256 *
1355 (1 +
ctx->alpha_bits + 1) + 7 >> 3);
1361 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1362 ctx->profile,
ctx->slices_per_picture *
ctx->pictures_per_frame,
1365 ctx->frame_size_upper_bound);
1370 #define OFFSET(x) offsetof(ProresContext, x)
1371 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1374 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1380 0, 0,
VE,
"profile" },
1382 0, 0,
VE,
"profile" },
1384 0, 0,
VE,
"profile" },
1386 0, 0,
VE,
"profile" },
1388 0, 0,
VE,
"profile" },
1390 0, 0,
VE,
"profile" },
1392 0, 0,
VE,
"profile" },
1393 {
"vendor",
"vendor ID",
OFFSET(vendor),
1395 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1400 0, 0,
VE,
"quant_mat" },
1402 0, 0,
VE,
"quant_mat" },
1404 0, 0,
VE,
"quant_mat" },
1406 0, 0,
VE,
"quant_mat" },
1408 0, 0,
VE,
"quant_mat" },
1410 0, 0,
VE,
"quant_mat" },
1412 { .i64 = 16 }, 0, 16,
VE },
1424 .
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 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 get_alpha_data(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int x, int y, int w, int h, int16_t *blocks, int mbs_per_slice, int abits)
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)