35 #define CFACTOR_Y422 2 36 #define CFACTOR_Y444 3 38 #define MAX_MBS_PER_SLICE 8 64 4, 7, 9, 11, 13, 14, 15, 63,
65 7, 7, 11, 12, 14, 15, 63, 63,
66 9, 11, 13, 14, 15, 63, 63, 63,
67 11, 11, 13, 14, 63, 63, 63, 63,
68 11, 13, 14, 63, 63, 63, 63, 63,
69 13, 14, 63, 63, 63, 63, 63, 63,
70 13, 63, 63, 63, 63, 63, 63, 63,
71 63, 63, 63, 63, 63, 63, 63, 63,
74 4, 7, 9, 11, 13, 14, 63, 63,
75 7, 7, 11, 12, 14, 63, 63, 63,
76 9, 11, 13, 14, 63, 63, 63, 63,
77 11, 11, 13, 14, 63, 63, 63, 63,
78 11, 13, 14, 63, 63, 63, 63, 63,
79 13, 14, 63, 63, 63, 63, 63, 63,
80 13, 63, 63, 63, 63, 63, 63, 63,
81 63, 63, 63, 63, 63, 63, 63, 63
84 4, 5, 6, 7, 9, 11, 13, 15,
85 5, 5, 7, 8, 11, 13, 15, 17,
86 6, 7, 9, 11, 13, 15, 15, 17,
87 7, 7, 9, 11, 13, 15, 17, 19,
88 7, 9, 11, 13, 14, 16, 19, 23,
89 9, 11, 13, 14, 16, 19, 23, 29,
90 9, 11, 13, 15, 17, 21, 28, 35,
91 11, 13, 16, 17, 21, 28, 35, 41,
94 4, 4, 5, 5, 6, 7, 7, 9,
95 4, 4, 5, 6, 7, 7, 9, 9,
96 5, 5, 6, 7, 7, 9, 9, 10,
97 5, 5, 6, 7, 7, 9, 9, 10,
98 5, 6, 7, 7, 8, 9, 10, 12,
99 6, 7, 7, 8, 9, 10, 12, 15,
100 6, 7, 7, 9, 10, 11, 14, 17,
101 7, 7, 9, 10, 11, 14, 17, 21,
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, 4,
107 4, 4, 4, 4, 4, 4, 4, 5,
108 4, 4, 4, 4, 4, 4, 5, 5,
109 4, 4, 4, 4, 4, 5, 5, 6,
110 4, 4, 4, 4, 5, 5, 6, 7,
111 4, 4, 4, 4, 5, 6, 7, 7,
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, 2,
117 2, 2, 2, 2, 2, 2, 2, 3,
118 2, 2, 2, 2, 2, 2, 3, 3,
119 2, 2, 2, 2, 2, 3, 3, 3,
120 2, 2, 2, 2, 3, 3, 3, 4,
121 2, 2, 2, 2, 3, 3, 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,
131 4, 4, 4, 4, 4, 4, 4, 4,
135 #define NUM_MB_LIMITS 4 154 .tag =
MKTAG(
'a',
'p',
'c',
'o'),
157 .br_tab = { 300, 242, 220, 194 },
163 .tag =
MKTAG(
'a',
'p',
'c',
's'),
166 .br_tab = { 720, 560, 490, 440 },
171 .full_name =
"standard",
172 .tag =
MKTAG(
'a',
'p',
'c',
'n'),
175 .br_tab = { 1050, 808, 710, 632 },
180 .full_name =
"high quality",
181 .tag =
MKTAG(
'a',
'p',
'c',
'h'),
184 .br_tab = { 1566, 1216, 1070, 950 },
190 .tag =
MKTAG(
'a',
'p',
'4',
'h'),
193 .br_tab = { 2350, 1828, 1600, 1425 },
198 .full_name =
"4444XQ",
199 .tag =
MKTAG(
'a',
'p',
'4',
'x'),
202 .br_tab = { 3525, 2742, 2400, 2137 },
208 #define TRELLIS_WIDTH 16 209 #define SCORE_LIMIT INT_MAX / 2 218 #define MAX_STORED_Q 16 223 int16_t custom_q[64];
224 int16_t custom_chroma_q[64];
234 int16_t custom_q[64];
235 int16_t custom_chroma_q[64];
241 ptrdiff_t linesize, int16_t *
block);
272 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
273 int16_t *blocks, uint16_t *emu_buf,
274 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
276 const uint16_t *esrc;
277 const int mb_width = 4 * blocks_per_mb;
281 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
283 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
287 if (x + mb_width <= w && y + 16 <= h) {
289 elinesize = linesize;
294 elinesize = 16 *
sizeof(*emu_buf);
296 bw =
FFMIN(w - x, mb_width);
297 bh =
FFMIN(h - y, 16);
299 for (j = 0; j < bh; j++) {
300 memcpy(emu_buf + j * 16,
301 (
const uint8_t*)src + j * linesize,
303 pix = emu_buf[j * 16 + bw - 1];
304 for (k = bw; k < mb_width; k++)
305 emu_buf[j * 16 + k] = pix;
308 memcpy(emu_buf + j * 16,
309 emu_buf + (bh - 1) * 16,
310 mb_width *
sizeof(*emu_buf));
313 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
315 if (blocks_per_mb > 2) {
316 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
319 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
321 if (blocks_per_mb > 2) {
322 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
326 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
328 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
330 if (blocks_per_mb > 2) {
331 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
333 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
343 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
344 int16_t *blocks,
int mbs_per_slice,
int abits)
346 const int slice_width = 16 * mbs_per_slice;
347 int i, j, copy_w, copy_h;
349 copy_w =
FFMIN(w - x, slice_width);
350 copy_h =
FFMIN(h - y, 16);
351 for (i = 0; i < copy_h; i++) {
352 memcpy(blocks, src, copy_w *
sizeof(*src));
354 for (j = 0; j < copy_w; j++)
357 for (j = 0; j < copy_w; j++)
358 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
359 for (j = copy_w; j < slice_width; j++)
360 blocks[j] = blocks[copy_w - 1];
361 blocks += slice_width;
362 src += linesize >> 1;
364 for (; i < 16; i++) {
365 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
366 blocks += slice_width;
375 unsigned int rice_order, exp_order, switch_bits, switch_val;
379 switch_bits = (codebook & 3) + 1;
380 rice_order = codebook >> 5;
381 exp_order = (codebook >> 2) & 7;
383 switch_val = switch_bits << rice_order;
385 if (val >= switch_val) {
386 val -= switch_val - (1 << exp_order);
389 put_bits(pb, exponent - exp_order + switch_bits, 0);
392 exponent = val >> rice_order;
402 #define GET_SIGN(x) ((x) >> 31) 403 #define MAKE_CODE(x) ((((x)) * 2) ^ GET_SIGN(x)) 406 int blocks_per_slice,
int scale)
409 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
411 prev_dc = (blocks[0] - 0x4000) / scale;
417 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
418 dc = (blocks[0] - 0x4000) / scale;
419 delta = dc - prev_dc;
421 delta = (delta ^ sign) - sign;
424 codebook = (code + (code & 1)) >> 1;
425 codebook =
FFMIN(codebook, 3);
432 int blocks_per_slice,
433 int plane_size_factor,
434 const uint8_t *scan,
const int16_t *qmat)
438 int max_coeffs, abs_level;
440 max_coeffs = blocks_per_slice << 6;
445 for (i = 1; i < 64; i++) {
446 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
447 level = blocks[idx] / qmat[scan[
i]];
449 abs_level =
FFABS(level);
466 const uint16_t *
src, ptrdiff_t linesize,
467 int mbs_per_slice, int16_t *blocks,
468 int blocks_per_mb,
int plane_size_factor,
471 int blocks_per_slice, saved_pos;
474 blocks_per_slice = mbs_per_slice * blocks_per_mb;
476 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
477 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
486 const int dbits = (abits == 8) ? 4 : 7;
487 const int dsize = 1 << dbits - 1;
488 int diff = cur - prev;
490 diff = av_mod_uintp2(diff, abits);
491 if (diff >= (1 << abits) - dsize)
493 if (diff < -dsize || diff > dsize || !diff) {
518 int mbs_per_slice, uint16_t *blocks,
522 const int mask = (1 << abits) - 1;
523 const int num_coeffs = mbs_per_slice * 256;
525 int prev =
mask, cur;
542 }
while (idx < num_coeffs);
558 int slice_width_factor =
av_log2(mbs_per_slice);
559 int num_cblocks, pwidth, line_add;
561 int plane_factor, is_chroma;
563 uint16_t *qmat_chroma;
579 for (i = 0; i < 64; i++) {
586 is_chroma = (i == 1 || i == 2);
587 plane_factor = slice_width_factor + 2;
594 pwidth = avctx->
width;
599 pwidth = avctx->
width >> 1;
603 src = (
const uint16_t*)(pic->
data[i] + yp * linesize +
610 mbs_per_slice, num_cblocks, is_chroma);
613 mbs_per_slice, ctx->
blocks[0],
614 num_cblocks, plane_factor,
618 mbs_per_slice, ctx->
blocks[0],
619 num_cblocks, plane_factor,
629 total_size += sizes[
i];
632 "Underestimated required buffer size.\n");
641 unsigned int rice_order, exp_order, switch_bits, switch_val;
645 switch_bits = (codebook & 3) + 1;
646 rice_order = codebook >> 5;
647 exp_order = (codebook >> 2) & 7;
649 switch_val = switch_bits << rice_order;
651 if (val >= switch_val) {
652 val -= switch_val - (1 << exp_order);
655 return exponent * 2 - exp_order + switch_bits + 1;
657 return (val >> rice_order) + rice_order + 1;
665 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
668 prev_dc = (blocks[0] - 0x4000) / scale;
673 *error +=
FFABS(blocks[0] - 0x4000) % scale;
675 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
676 dc = (blocks[0] - 0x4000) / scale;
677 *error +=
FFABS(blocks[0] - 0x4000) % scale;
678 delta = dc - prev_dc;
680 delta = (delta ^ sign) - sign;
683 codebook = (code + (code & 1)) >> 1;
684 codebook =
FFMIN(codebook, 3);
693 int plane_size_factor,
694 const uint8_t *scan,
const int16_t *qmat)
698 int max_coeffs, abs_level;
701 max_coeffs = blocks_per_slice << 6;
706 for (i = 1; i < 64; i++) {
707 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
708 level = blocks[idx] / qmat[scan[
i]];
709 *error +=
FFABS(blocks[idx]) % qmat[scan[
i]];
711 abs_level =
FFABS(level);
729 const uint16_t *
src, ptrdiff_t linesize,
731 int blocks_per_mb,
int plane_size_factor,
734 int blocks_per_slice;
737 blocks_per_slice = mbs_per_slice * blocks_per_mb;
741 plane_size_factor, ctx->
scantable, qmat);
748 const int dbits = (abits == 8) ? 4 : 7;
749 const int dsize = 1 << dbits - 1;
750 int diff = cur - prev;
752 diff = av_mod_uintp2(diff, abits);
753 if (diff >= (1 << abits) - dsize)
755 if (diff < -dsize || diff > dsize || !diff)
762 const uint16_t *
src, ptrdiff_t linesize,
763 int mbs_per_slice, int16_t *blocks)
766 const int mask = (1 << abits) - 1;
767 const int num_coeffs = mbs_per_slice * 256;
768 int prev =
mask, cur;
791 }
while (idx < num_coeffs);
804 int trellis_node,
int x,
int y,
int mbs_per_slice,
808 int i, q, pq, xp, yp;
810 int slice_width_factor =
av_log2(mbs_per_slice);
815 int error, bits, bits_limit;
816 int mbs, prev, cur, new_score;
820 uint16_t *qmat_chroma;
821 int linesize[4], line_add;
828 mbs = x + mbs_per_slice;
831 is_chroma[
i] = (i == 1 || i == 2);
832 plane_factor[
i] = slice_width_factor + 2;
839 pwidth = avctx->
width;
844 pwidth = avctx->
width >> 1;
848 src = (
const uint16_t *)(ctx->
pic->
data[i] + yp * linesize[i] +
855 mbs_per_slice, num_cblocks[i], is_chroma[i]);
863 for (q = min_quant; q < max_quant + 2; q++) {
870 mbs_per_slice, td->
blocks[3]);
872 for (q = min_quant; q <=
max_quant; q++) {
878 num_cblocks[0], plane_factor[0],
884 num_cblocks[i], plane_factor[i],
887 if (bits > 65000 * 8)
890 slice_bits[q] = bits;
891 slice_score[q] =
error;
893 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
894 slice_bits[max_quant + 1] = slice_bits[
max_quant];
895 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
898 for (q = max_quant + 1; q < 128; q++) {
907 for (i = 0; i < 64; i++) {
915 num_cblocks[0], plane_factor[0],
921 num_cblocks[i], plane_factor[i],
924 if (bits <= ctx->bits_per_mb * mbs_per_slice)
928 slice_bits[max_quant + 1] = bits;
929 slice_score[max_quant + 1] =
error;
932 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
935 for (pq = min_quant; pq < max_quant + 2; pq++) {
938 for (q = min_quant; q < max_quant + 2; q++) {
939 cur = trellis_node + q;
941 bits = td->
nodes[prev].
bits + slice_bits[q];
942 error = slice_score[q];
943 if (bits > bits_limit)
962 for (q = min_quant + 1; q < max_quant + 2; q++) {
963 if (td->
nodes[trellis_node + q].
score <= error) {
965 pq = trellis_node + q;
973 int jobnr,
int threadnr)
978 int x, y = jobnr,
mb, q = 0;
980 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
981 while (ctx->
mb_width - x < mbs_per_slice)
997 const AVFrame *pic,
int *got_packet)
1003 int x, y,
i,
mb, q = 0;
1004 int sizes[4] = { 0 };
1005 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
1017 orig_buf = pkt->
data;
1021 bytestream_put_be32 (&orig_buf,
FRAME_ID);
1027 bytestream_put_be16 (&buf, 0);
1029 bytestream_put_be16 (&buf, avctx->
width);
1030 bytestream_put_be16 (&buf, avctx->
height);
1035 bytestream_put_byte (&buf, frame_flags);
1037 bytestream_put_byte (&buf, 0);
1039 bytestream_put_byte (&buf, pic->
color_trc);
1041 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
1042 bytestream_put_byte (&buf, 0);
1044 bytestream_put_byte (&buf, 0x03);
1046 for (i = 0; i < 64; i++)
1047 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
1049 for (i = 0; i < 64; i++)
1050 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
1052 bytestream_put_byte (&buf, 0x00);
1054 bytestream_put_be16 (&tmp, buf - orig_buf);
1060 picture_size_pos = buf + 1;
1061 bytestream_put_byte (&buf, 0x40);
1080 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1084 while (ctx->
mb_width - x < mbs_per_slice)
1085 mbs_per_slice >>= 1;
1087 bytestream_put_byte(&buf, slice_hdr_size << 3);
1089 buf += slice_hdr_size - 1;
1090 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1096 max_slice_size - pkt_size;
1098 delta =
FFMAX(delta, 2 * max_slice_size);
1103 "Packet too small: is %i," 1104 " needs %i (slice: %i). " 1105 "Correct allocation",
1106 pkt_size, delta, max_slice_size);
1116 orig_buf = pkt->
data + (orig_buf -
start);
1118 picture_size_pos = pkt->
data + (picture_size_pos -
start);
1119 slice_sizes = pkt->
data + (slice_sizes -
start);
1120 slice_hdr = pkt->
data + (slice_hdr -
start);
1129 bytestream_put_byte(&slice_hdr, q);
1130 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1132 bytestream_put_be16(&slice_hdr, sizes[i]);
1133 slice_size += sizes[
i];
1135 bytestream_put_be16(&slice_sizes, slice_size);
1136 buf += slice_size - slice_hdr_size;
1137 if (max_slice_size < slice_size)
1138 max_slice_size = slice_size;
1142 picture_size = buf - (picture_size_pos - 1);
1143 bytestream_put_be32(&picture_size_pos, picture_size);
1147 frame_size = buf - orig_buf;
1148 bytestream_put_be32(&orig_buf, frame_size);
1173 ptrdiff_t linesize, int16_t *
block)
1176 const uint16_t *tsrc =
src;
1178 for (y = 0; y < 8; y++) {
1179 for (x = 0; x < 8; x++)
1180 block[y * 8 + x] = tsrc[x];
1181 tsrc += linesize >> 1;
1195 #if FF_API_CODED_FRAME 1208 if (mps & (mps - 1)) {
1210 "there should be an integer power of two MBs per slice\n");
1220 ?
"4:4:4:4 profile because of the used input colorspace" 1221 :
"HQ profile to keep best quality");
1228 "encode alpha. Override with -profile if needed.\n");
1266 if (strlen(ctx->
vendor) != 4) {
1289 for (j = 0; j < 64; j++) {
1315 for (i = min_quant; i < max_quant + 2; i++) {
1330 for (j = 0; j < 64; j++) {
1359 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1368 #define OFFSET(x) offsetof(ProresContext, x) 1369 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1372 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1378 0, 0,
VE,
"profile" },
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" },
1391 {
"vendor",
"vendor ID",
OFFSET(vendor),
1393 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1398 0, 0,
VE,
"quant_mat" },
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 { .i64 = 16 }, 0, 16, VE },
1422 .
name =
"prores_ks",
static const AVClass proresenc_class
#define MAX_MBS_PER_SLICE
const char const char void * val
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
int16_t quants_chroma[MAX_STORED_Q][64]
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static av_cold int encode_init(AVCodecContext *avctx)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
const uint8_t ff_prores_ac_codebook[7]
static av_cold int init(AVCodecContext *avctx)
#define avpriv_request_sample(...)
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)
int16_t custom_chroma_q[64]
const char * av_default_item_name(void *ptr)
Return the context name.
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
unsigned mb_height
height of the current picture in mb
const uint8_t * scantable
static const AVOption options[]
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static av_cold int encode_close(AVCodecContext *avctx)
const uint8_t * quant_chroma_mat
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
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)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
int16_t quants[MAX_STORED_Q][64]
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
static int estimate_vlc(unsigned codebook, int val)
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, int mbs_per_slice)
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
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]
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
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 int estimate_alpha_plane(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int16_t *blocks)
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
static int est_alpha_diff(int cur, int prev, int abits)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
unsigned mb_width
width of the current picture in mb
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int16_t custom_chroma_q[64]
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
static int put_bits_left(PutBitContext *s)
static const uint16_t mask[17]
static const int sizes[][2]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
const struct prores_profile * profile_info
int flags
AV_CODEC_FLAG_*.
enum AVColorSpace colorspace
YUV colorspace type.
static const struct prores_profile prores_profile_info[6]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
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)
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
static const int prores_mb_limits[NUM_MB_LIMITS]
int flags
A combination of AV_PKT_FLAG values.
struct TrellisNode * nodes
static int put_bits_count(PutBitContext *s)
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
static void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
Write an unsigned rice/exp golomb codeword.
enum AVPictureType pict_type
Picture type of the frame.
int width
picture width / height.
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)
const uint8_t ff_prores_dc_codebook[4]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
void(* fdct)(int16_t *block)
#define AV_PIX_FMT_YUVA444P10
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
static void error(const char *err)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
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.
#define AV_LOG_INFO
Standard information.
const uint8_t ff_prores_interlaced_scan[64]
Libavcodec external API header.
typedef void(RENAME(mix_any_func_type))
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
main external API structure.
const uint8_t ff_prores_progressive_scan[64]
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Describe the class of an AVClass context structure.
static enum AVPixelFormat pix_fmts[]
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)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
int global_quality
Global quality for codecs which cannot change it per frame.
#define AV_PIX_FMT_YUV422P10
static int find_slice_quant(AVCodecContext *avctx, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int br_tab[NUM_MB_LIMITS]
static void put_alpha_run(PutBitContext *pb, int run)
#define FF_DISABLE_DEPRECATION_WARNINGS
static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, int mbs_per_slice, uint16_t *blocks, int quant)
static const uint8_t prores_quant_matrices[][64]
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int find_quant_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define FF_ENABLE_DEPRECATION_WARNINGS
int top_field_first
If the content is interlaced, is top field displayed first.
int key_frame
1 -> keyframe, 0-> not
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
enum AVColorPrimaries color_primaries
enum AVColorTransferCharacteristic color_trc
AVCodec ff_prores_ks_encoder
const uint8_t * quant_mat
#define MKTAG(a, b, c, d)
int frame_size_upper_bound
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)
AVPixelFormat
Pixel format.
This structure stores compressed data.
static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice, int scale)
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)