Go to the documentation of this file.
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,
303 (
const uint8_t*)
src + j * linesize,
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 uint16_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;
418 for (
i = 1;
i < blocks_per_slice;
i++, blocks += 64) {
419 dc = (blocks[0] - 0x4000) /
scale;
432 int blocks_per_slice,
433 const uint8_t *scan,
const int16_t *qmat)
439 int max_coeffs, abs_level;
441 max_coeffs = blocks_per_slice << 6;
443 for (
i = 1;
i < 64;
i++) {
444 for (idx = scan[
i]; idx < max_coeffs; idx += 64) {
445 level = blocks[idx] / qmat[scan[
i]];
453 prev_level =
FFMIN(abs_level, 9);
463 const uint16_t *
src, ptrdiff_t linesize,
464 int mbs_per_slice, int16_t *blocks,
468 int blocks_per_slice = mbs_per_slice * blocks_per_mb;
470 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
471 encode_acs(pb, blocks, blocks_per_slice,
ctx->scantable, qmat);
476 const int dbits = (abits == 8) ? 4 : 7;
477 const int dsize = 1 << dbits - 1;
478 int diff = cur - prev;
481 if (
diff >= (1 << abits) - dsize)
483 if (diff < -dsize || diff > dsize || !
diff) {
508 int mbs_per_slice, uint16_t *blocks,
511 const int abits =
ctx->alpha_bits;
512 const int mask = (1 << abits) - 1;
513 const int num_coeffs = mbs_per_slice * 256;
514 int prev =
mask, cur;
531 }
while (idx < num_coeffs);
544 int num_cblocks, pwidth, line_add;
548 uint16_t *qmat_chroma;
550 if (
ctx->pictures_per_frame == 1)
555 if (
ctx->force_quant) {
556 qmat =
ctx->quants[0];
557 qmat_chroma =
ctx->quants_chroma[0];
560 qmat_chroma =
ctx->quants_chroma[
quant];
562 qmat =
ctx->custom_q;
563 qmat_chroma =
ctx->custom_chroma_q;
564 for (
i = 0;
i < 64;
i++) {
566 qmat_chroma[
i] =
ctx->quant_chroma_mat[
i] *
quant;
570 for (
i = 0;
i <
ctx->num_planes;
i++) {
571 is_chroma = (
i == 1 ||
i == 2);
576 pwidth = avctx->
width;
581 pwidth = avctx->
width >> 1;
585 src = (
const uint16_t*)(pic->
data[
i] + yp * linesize +
590 pwidth, avctx->
height /
ctx->pictures_per_frame,
591 ctx->blocks[0],
ctx->emu_buf,
592 mbs_per_slice, num_cblocks, is_chroma);
595 mbs_per_slice,
ctx->blocks[0],
599 mbs_per_slice,
ctx->blocks[0],
600 num_cblocks, qmat_chroma);
604 pwidth, avctx->
height /
ctx->pictures_per_frame,
605 ctx->blocks[0], mbs_per_slice,
ctx->alpha_bits);
617 unsigned int rice_order, exp_order, switch_bits, switch_val;
625 switch_val = switch_bits << rice_order;
627 if (
val >= switch_val) {
628 val -= switch_val - (1 << exp_order);
631 return exponent * 2 - exp_order + switch_bits + 1;
633 return (
val >> rice_order) + rice_order + 1;
644 prev_dc = (blocks[0] - 0x4000) /
scale;
650 for (
i = 1;
i < blocks_per_slice;
i++, blocks += 64) {
651 dc = (blocks[0] - 0x4000) /
scale;
667 const uint8_t *scan,
const int16_t *qmat)
673 int max_coeffs, abs_level;
676 max_coeffs = blocks_per_slice << 6;
679 for (
i = 1;
i < 64;
i++) {
680 for (idx = scan[
i]; idx < max_coeffs; idx += 64) {
681 level = blocks[idx] / qmat[scan[
i]];
690 prev_level =
FFMIN(abs_level, 9);
702 const uint16_t *
src, ptrdiff_t linesize,
707 int blocks_per_slice;
710 blocks_per_slice = mbs_per_slice * blocks_per_mb;
720 const int dbits = (abits == 8) ? 4 : 7;
721 const int dsize = 1 << dbits - 1;
722 int diff = cur - prev;
725 if (
diff >= (1 << abits) - dsize)
727 if (diff < -dsize || diff > dsize || !
diff)
734 const uint16_t *
src, ptrdiff_t linesize,
735 int mbs_per_slice, int16_t *blocks)
737 const int abits =
ctx->alpha_bits;
738 const int mask = (1 << abits) - 1;
739 const int num_coeffs = mbs_per_slice * 256;
740 int prev =
mask, cur;
763 }
while (idx < num_coeffs);
776 int trellis_node,
int x,
int y,
int mbs_per_slice,
780 int i, q, pq, xp, yp;
787 int mbs, prev, cur, new_score;
791 uint16_t *qmat_chroma;
792 int linesize[4], line_add;
795 if (
ctx->pictures_per_frame == 1)
799 mbs = x + mbs_per_slice;
801 for (
i = 0;
i <
ctx->num_planes;
i++) {
802 is_chroma[
i] = (
i == 1 ||
i == 2);
807 pwidth = avctx->
width;
812 pwidth = avctx->
width >> 1;
815 linesize[
i] =
ctx->pic->linesize[
i] *
ctx->pictures_per_frame;
816 src = (
const uint16_t *)(
ctx->pic->data[
i] + yp * linesize[
i] +
817 line_add *
ctx->pic->linesize[
i]) + xp;
821 pwidth, avctx->
height /
ctx->pictures_per_frame,
823 mbs_per_slice, num_cblocks[
i], is_chroma[
i]);
826 pwidth, avctx->
height /
ctx->pictures_per_frame,
827 td->
blocks[
i], mbs_per_slice,
ctx->alpha_bits);
838 mbs_per_slice, td->
blocks[3]);
848 for (
i = 1;
i <
ctx->num_planes - !!
ctx->alpha_bits;
i++) {
853 ctx->quants_chroma[q], td);
855 if (
bits > 65000 * 8)
858 slice_bits[q] =
bits;
859 slice_score[q] =
error;
861 if (slice_bits[
max_quant] <=
ctx->bits_per_mb * mbs_per_slice) {
870 qmat =
ctx->quants[q];
871 qmat_chroma =
ctx->quants_chroma[q];
875 for (
i = 0;
i < 64;
i++) {
876 qmat[
i] =
ctx->quant_mat[
i] * q;
877 qmat_chroma[
i] =
ctx->quant_chroma_mat[
i] * q;
885 for (
i = 1;
i <
ctx->num_planes - !!
ctx->alpha_bits;
i++) {
892 if (bits <= ctx->bits_per_mb * mbs_per_slice)
902 bits_limit = mbs *
ctx->bits_per_mb;
907 cur = trellis_node + q;
910 error = slice_score[q];
911 if (
bits > bits_limit)
933 pq = trellis_node + q;
941 int jobnr,
int threadnr)
945 int mbs_per_slice =
ctx->mbs_per_slice;
946 int x, y = jobnr,
mb, q = 0;
948 for (x =
mb = 0; x <
ctx->mb_width; x += mbs_per_slice,
mb++) {
949 while (
ctx->mb_width - x < mbs_per_slice)
956 for (x =
ctx->slices_width - 1; x >= 0; x--) {
965 const AVFrame *pic,
int *got_packet)
968 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *
tmp;
969 uint8_t *picture_size_pos;
971 int x, y,
i,
mb, q = 0;
972 int sizes[4] = { 0 };
973 int slice_hdr_size = 2 + 2 * (
ctx->num_planes - 1);
976 int max_slice_size = (
ctx->frame_size_upper_bound - 200) / (
ctx->pictures_per_frame *
ctx->slices_per_picture + 1);
980 pkt_size =
ctx->frame_size_upper_bound;
989 bytestream_put_be32 (&orig_buf,
FRAME_ID);
995 bytestream_put_be16 (&buf,
ctx->chroma_factor !=
CFACTOR_Y422 ||
ctx->alpha_bits ? 1 : 0);
997 bytestream_put_be16 (&buf, avctx->
width);
998 bytestream_put_be16 (&buf, avctx->
height);
1000 frame_flags =
ctx->chroma_factor << 6;
1003 bytestream_put_byte (&buf, frame_flags);
1005 bytestream_put_byte (&buf, 0);
1007 bytestream_put_byte (&buf, pic->
color_trc);
1009 bytestream_put_byte (&buf,
ctx->alpha_bits >> 3);
1010 bytestream_put_byte (&buf, 0);
1012 bytestream_put_byte (&buf, 0x03);
1016 bytestream_put_byte (&buf, 0x00);
1018 bytestream_put_be16 (&
tmp, buf - orig_buf);
1020 for (
ctx->cur_picture_idx = 0;
1021 ctx->cur_picture_idx <
ctx->pictures_per_frame;
1022 ctx->cur_picture_idx++) {
1024 picture_size_pos = buf + 1;
1025 bytestream_put_byte (&buf, 0x40);
1027 bytestream_put_be16 (&buf,
ctx->slices_per_picture);
1028 bytestream_put_byte (&buf,
av_log2(
ctx->mbs_per_slice) << 4);
1032 buf +=
ctx->slices_per_picture * 2;
1035 if (!
ctx->force_quant) {
1042 for (y = 0; y <
ctx->mb_height; y++) {
1043 int mbs_per_slice =
ctx->mbs_per_slice;
1044 for (x =
mb = 0; x <
ctx->mb_width; x += mbs_per_slice,
mb++) {
1045 q =
ctx->force_quant ?
ctx->force_quant
1046 :
ctx->slice_q[
mb + y *
ctx->slices_width];
1048 while (
ctx->mb_width - x < mbs_per_slice)
1049 mbs_per_slice >>= 1;
1051 bytestream_put_byte(&buf, slice_hdr_size << 3);
1053 buf += slice_hdr_size - 1;
1054 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1058 int delta = 200 + (
ctx->pictures_per_frame *
1059 ctx->slices_per_picture + 1) *
1060 max_slice_size - pkt_size;
1063 ctx->frame_size_upper_bound +=
delta;
1067 "Packet too small: is %i,"
1068 " needs %i (slice: %i). "
1069 "Correct allocation",
1070 pkt_size,
delta, max_slice_size);
1080 orig_buf =
pkt->
data + (orig_buf - start);
1081 buf =
pkt->
data + (buf - start);
1082 picture_size_pos =
pkt->
data + (picture_size_pos - start);
1083 slice_sizes =
pkt->
data + (slice_sizes - start);
1084 slice_hdr =
pkt->
data + (slice_hdr - start);
1093 bytestream_put_byte(&slice_hdr, q);
1094 slice_size = slice_hdr_size +
sizes[
ctx->num_planes - 1];
1095 for (
i = 0;
i <
ctx->num_planes - 1;
i++) {
1096 bytestream_put_be16(&slice_hdr,
sizes[
i]);
1099 bytestream_put_be16(&slice_sizes, slice_size);
1100 buf += slice_size - slice_hdr_size;
1101 if (max_slice_size < slice_size)
1102 max_slice_size = slice_size;
1106 picture_size = buf - (picture_size_pos - 1);
1107 bytestream_put_be32(&picture_size_pos, picture_size);
1136 ptrdiff_t linesize, int16_t *
block)
1139 const uint16_t *tsrc =
src;
1141 for (y = 0; y < 8; y++) {
1142 for (x = 0; x < 8; x++)
1143 block[y * 8 + x] = tsrc[x];
1144 tsrc += linesize >> 1;
1164 mps =
ctx->mbs_per_slice;
1165 if (mps & (mps - 1)) {
1167 "there should be an integer power of two MBs per slice\n");
1173 !(
desc->log2_chroma_w +
desc->log2_chroma_h))
1177 ?
"4:4:4:4 profile because of the used input colorspace"
1178 :
"HQ profile to keep best quality");
1185 "encode alpha. Override with -profile if needed.\n");
1186 ctx->alpha_bits = 0;
1188 if (
ctx->alpha_bits & 7) {
1194 ctx->alpha_bits = 0;
1201 ctx->num_planes = 3 + !!
ctx->alpha_bits;
1210 ctx->slices_width =
ctx->mb_width / mps;
1212 ctx->slices_per_picture =
ctx->mb_height *
ctx->slices_width;
1215 if (
ctx->quant_sel == -1) {
1223 if (strlen(
ctx->vendor) != 4) {
1229 if (!
ctx->force_quant) {
1230 if (!
ctx->bits_per_mb) {
1233 ctx->pictures_per_frame)
1235 ctx->bits_per_mb =
ctx->profile_info->br_tab[
i];
1236 if (
ctx->alpha_bits)
1237 ctx->bits_per_mb *= 20;
1238 }
else if (
ctx->bits_per_mb < 128) {
1246 for (j = 0; j < 64; j++) {
1247 ctx->quants[
i][j] =
ctx->quant_mat[j] *
i;
1248 ctx->quants_chroma[
i][j] =
ctx->quant_chroma_mat[j] *
i;
1263 *
sizeof(*
ctx->tdata->nodes));
1264 if (!
ctx->tdata[j].nodes)
1267 ctx->tdata[j].nodes[
i].prev_node = -1;
1268 ctx->tdata[j].nodes[
i].bits = 0;
1269 ctx->tdata[j].nodes[
i].score = 0;
1276 if (
ctx->force_quant > 64) {
1281 for (j = 0; j < 64; j++) {
1282 ctx->quants[0][j] =
ctx->quant_mat[j] *
ctx->force_quant;
1283 ctx->quants_chroma[0][j] =
ctx->quant_chroma_mat[j] *
ctx->force_quant;
1284 ls +=
av_log2((1 << 11) /
ctx->quants[0][j]) * 2 + 1;
1285 ls_chroma +=
av_log2((1 << 11) /
ctx->quants_chroma[0][j]) * 2 + 1;
1288 ctx->bits_per_mb = ls * 4 + ls_chroma * 4;
1290 ctx->bits_per_mb += ls_chroma * 4;
1293 ctx->frame_size_upper_bound = (
ctx->pictures_per_frame *
1294 ctx->slices_per_picture + 1) *
1295 (2 + 2 *
ctx->num_planes +
1296 (mps *
ctx->bits_per_mb) / 8)
1299 if (
ctx->alpha_bits) {
1301 ctx->frame_size_upper_bound += (
ctx->pictures_per_frame *
1302 ctx->slices_per_picture + 1) *
1303 (
ctx->mbs_per_slice * 256 *
1304 (1 +
ctx->alpha_bits + 1) + 7 >> 3);
1311 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1312 ctx->profile,
ctx->slices_per_picture *
ctx->pictures_per_frame,
1315 ctx->frame_size_upper_bound);
1320 #define OFFSET(x) offsetof(ProresContext, x)
1321 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1324 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1330 0, 0,
VE, .unit =
"profile" },
1332 0, 0,
VE, .unit =
"profile" },
1334 0, 0,
VE, .unit =
"profile" },
1336 0, 0,
VE, .unit =
"profile" },
1338 0, 0,
VE, .unit =
"profile" },
1340 0, 0,
VE, .unit =
"profile" },
1342 0, 0,
VE, .unit =
"profile" },
1343 {
"vendor",
"vendor ID",
OFFSET(vendor),
1345 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1350 0, 0,
VE, .unit =
"quant_mat" },
1352 0, 0,
VE, .unit =
"quant_mat" },
1354 0, 0,
VE, .unit =
"quant_mat" },
1356 0, 0,
VE, .unit =
"quant_mat" },
1358 0, 0,
VE, .unit =
"quant_mat" },
1360 0, 0,
VE, .unit =
"quant_mat" },
1362 { .i64 = 16 }, 0, 16,
VE },
1374 .
p.
name =
"prores_ks",
static void error(const char *err)
const uint8_t * quant_chroma_mat
enum AVColorTransferCharacteristic color_trc
#define AV_LOG_WARNING
Something somehow does not look correct.
static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice, int scale)
AVPixelFormat
Pixel format.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
static int put_bytes_output(const PutBitContext *s)
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
const AVProfile ff_prores_profiles[]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
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.
enum AVColorPrimaries color_primaries
int16_t quants_chroma[MAX_STORED_Q][64]
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, const int16_t *qmat, ProresThreadData *td)
enum AVColorSpace colorspace
YUV colorspace type.
This structure describes decoded (raw) audio or video data.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static void encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, int mbs_per_slice, uint16_t *blocks, int quant)
const FFCodec ff_prores_ks_encoder
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
@ PRORES_PROFILE_STANDARD
static void put_alpha_run(PutBitContext *pb, int run)
const uint8_t ff_prores_progressive_scan[64]
const uint8_t ff_prores_level_to_cb[10]
static const uint8_t prores_quant_matrices[][64]
#define FF_INPUT_BUFFER_MIN_SIZE
Used by some encoders as upper bound for the length of headers.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
const struct prores_profile * profile_info
AVCodec p
The public AVCodec.
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
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 const int prores_mb_limits[NUM_MB_LIMITS]
int flags
AV_CODEC_FLAG_*.
int16_t custom_chroma_q[64]
static double val(void *priv, double ch)
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
static int estimate_alpha_plane(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int16_t *blocks)
#define FF_CODEC_ENCODE_CB(func)
struct TrellisNode * nodes
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
static void 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, const int16_t *qmat)
#define AV_PIX_FMT_YUV444P10
static const uint8_t quant[64]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const struct prores_profile prores_profile_info[6]
static const uint16_t mask[17]
int16_t custom_chroma_q[64]
int global_quality
Global quality for codecs which cannot change it per frame.
int flags
Flags modifying the (de)muxer behaviour.
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
int16_t quants[MAX_STORED_Q][64]
const uint8_t ff_prores_interlaced_scan[64]
static int find_quant_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
#define CODEC_LONG_NAME(str)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define MAX_MBS_PER_SLICE
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
const uint8_t ff_prores_run_to_cb[16]
static const int sizes[][2]
static av_cold int encode_init(AVCodecContext *avctx)
const char * av_default_item_name(void *ptr)
Return the context name.
static int find_slice_quant(AVCodecContext *avctx, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
#define AV_PIX_FMT_YUV422P10
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
int br_tab[NUM_MB_LIMITS]
int(* init)(AVBSFContext *ctx)
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
const uint8_t * scantable
#define DECLARE_ALIGNED(n, t, v)
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice, const uint8_t *scan, const int16_t *qmat)
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_PIX_FMT_YUVA444P10
const uint8_t ff_prores_dc_codebook[7]
#define AV_LOG_INFO
Standard information.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
static const AVOption options[]
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
#define i(width, name, range_min, range_max)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
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)
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
int frame_size_upper_bound
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
#define av_malloc_array(a, b)
static void encode_acs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, const uint8_t *scan, const int16_t *qmat)
static int est_alpha_diff(int cur, int prev, int abits)
const char * name
Name of the codec implementation.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void * av_calloc(size_t nmemb, size_t size)
static const AVClass proresenc_class
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
const uint8_t * quant_mat
main external API structure.
@ AV_OPT_TYPE_INT
Underlying C type is int.
void(* fdct)(int16_t *block)
#define avpriv_request_sample(...)
static int estimate_vlc(unsigned codebook, int val)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, int mbs_per_slice)
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
static void scale(int *out, const int *in, const int w, const int h, const int shift)
This structure stores compressed data.
static void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
Write an unsigned rice/exp golomb codeword.
int width
picture width / height.
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
The exact code depends on how similar the blocks are and how related they are to the block
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
#define MKTAG(a, b, c, d)
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
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.
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
static av_cold int encode_close(AVCodecContext *avctx)
static const unsigned codebook[256][2]
unsigned mb_height
height of the current picture in mb