36 #define CFACTOR_Y422 2 37 #define CFACTOR_Y444 3 39 #define MAX_MBS_PER_SLICE 8 65 4, 7, 9, 11, 13, 14, 15, 63,
66 7, 7, 11, 12, 14, 15, 63, 63,
67 9, 11, 13, 14, 15, 63, 63, 63,
68 11, 11, 13, 14, 63, 63, 63, 63,
69 11, 13, 14, 63, 63, 63, 63, 63,
70 13, 14, 63, 63, 63, 63, 63, 63,
71 13, 63, 63, 63, 63, 63, 63, 63,
72 63, 63, 63, 63, 63, 63, 63, 63,
75 4, 7, 9, 11, 13, 14, 63, 63,
76 7, 7, 11, 12, 14, 63, 63, 63,
77 9, 11, 13, 14, 63, 63, 63, 63,
78 11, 11, 13, 14, 63, 63, 63, 63,
79 11, 13, 14, 63, 63, 63, 63, 63,
80 13, 14, 63, 63, 63, 63, 63, 63,
81 13, 63, 63, 63, 63, 63, 63, 63,
82 63, 63, 63, 63, 63, 63, 63, 63
85 4, 5, 6, 7, 9, 11, 13, 15,
86 5, 5, 7, 8, 11, 13, 15, 17,
87 6, 7, 9, 11, 13, 15, 15, 17,
88 7, 7, 9, 11, 13, 15, 17, 19,
89 7, 9, 11, 13, 14, 16, 19, 23,
90 9, 11, 13, 14, 16, 19, 23, 29,
91 9, 11, 13, 15, 17, 21, 28, 35,
92 11, 13, 16, 17, 21, 28, 35, 41,
95 4, 4, 5, 5, 6, 7, 7, 9,
96 4, 4, 5, 6, 7, 7, 9, 9,
97 5, 5, 6, 7, 7, 9, 9, 10,
98 5, 5, 6, 7, 7, 9, 9, 10,
99 5, 6, 7, 7, 8, 9, 10, 12,
100 6, 7, 7, 8, 9, 10, 12, 15,
101 6, 7, 7, 9, 10, 11, 14, 17,
102 7, 7, 9, 10, 11, 14, 17, 21,
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, 4,
108 4, 4, 4, 4, 4, 4, 4, 5,
109 4, 4, 4, 4, 4, 4, 5, 5,
110 4, 4, 4, 4, 4, 5, 5, 6,
111 4, 4, 4, 4, 5, 5, 6, 7,
112 4, 4, 4, 4, 5, 6, 7, 7,
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, 2,
118 2, 2, 2, 2, 2, 2, 2, 3,
119 2, 2, 2, 2, 2, 2, 3, 3,
120 2, 2, 2, 2, 2, 3, 3, 3,
121 2, 2, 2, 2, 3, 3, 3, 4,
122 2, 2, 2, 2, 3, 3, 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,
132 4, 4, 4, 4, 4, 4, 4, 4,
136 #define NUM_MB_LIMITS 4 155 .tag =
MKTAG(
'a',
'p',
'c',
'o'),
158 .br_tab = { 300, 242, 220, 194 },
164 .tag =
MKTAG(
'a',
'p',
'c',
's'),
167 .br_tab = { 720, 560, 490, 440 },
172 .full_name =
"standard",
173 .tag =
MKTAG(
'a',
'p',
'c',
'n'),
176 .br_tab = { 1050, 808, 710, 632 },
181 .full_name =
"high quality",
182 .tag =
MKTAG(
'a',
'p',
'c',
'h'),
185 .br_tab = { 1566, 1216, 1070, 950 },
191 .tag =
MKTAG(
'a',
'p',
'4',
'h'),
194 .br_tab = { 2350, 1828, 1600, 1425 },
199 .full_name =
"4444XQ",
200 .tag =
MKTAG(
'a',
'p',
'4',
'x'),
203 .br_tab = { 3525, 2742, 2400, 2137 },
209 #define TRELLIS_WIDTH 16 210 #define SCORE_LIMIT INT_MAX / 2 219 #define MAX_STORED_Q 16 224 int16_t custom_q[64];
225 int16_t custom_chroma_q[64];
235 int16_t custom_q[64];
236 int16_t custom_chroma_q[64];
242 ptrdiff_t linesize, int16_t *
block);
273 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
274 int16_t *blocks, uint16_t *emu_buf,
275 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
277 const uint16_t *esrc;
278 const int mb_width = 4 * blocks_per_mb;
282 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
284 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
288 if (x + mb_width <= w && y + 16 <= h) {
290 elinesize = linesize;
295 elinesize = 16 *
sizeof(*emu_buf);
297 bw =
FFMIN(w - x, mb_width);
298 bh =
FFMIN(h - y, 16);
300 for (j = 0; j < bh; j++) {
301 memcpy(emu_buf + j * 16,
302 (
const uint8_t*)src + j * linesize,
304 pix = emu_buf[j * 16 + bw - 1];
305 for (k = bw; k < mb_width; k++)
306 emu_buf[j * 16 + k] = pix;
309 memcpy(emu_buf + j * 16,
310 emu_buf + (bh - 1) * 16,
311 mb_width *
sizeof(*emu_buf));
314 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
316 if (blocks_per_mb > 2) {
317 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
320 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
322 if (blocks_per_mb > 2) {
323 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
327 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
329 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
331 if (blocks_per_mb > 2) {
332 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
334 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
344 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
345 int16_t *blocks,
int mbs_per_slice,
int abits)
347 const int slice_width = 16 * mbs_per_slice;
348 int i, j, copy_w, copy_h;
350 copy_w =
FFMIN(w - x, slice_width);
351 copy_h =
FFMIN(h - y, 16);
352 for (i = 0; i < copy_h; i++) {
353 memcpy(blocks, src, copy_w *
sizeof(*src));
355 for (j = 0; j < copy_w; j++)
358 for (j = 0; j < copy_w; j++)
359 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
360 for (j = copy_w; j < slice_width; j++)
361 blocks[j] = blocks[copy_w - 1];
362 blocks += slice_width;
363 src += linesize >> 1;
365 for (; i < 16; i++) {
366 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
367 blocks += slice_width;
376 unsigned int rice_order, exp_order, switch_bits, switch_val;
380 switch_bits = (codebook & 3) + 1;
381 rice_order = codebook >> 5;
382 exp_order = (codebook >> 2) & 7;
384 switch_val = switch_bits << rice_order;
386 if (val >= switch_val) {
387 val -= switch_val - (1 << exp_order);
390 put_bits(pb, exponent - exp_order + switch_bits, 0);
393 exponent = val >> rice_order;
403 #define GET_SIGN(x) ((x) >> 31) 404 #define MAKE_CODE(x) ((((x)) * 2) ^ GET_SIGN(x)) 407 int blocks_per_slice,
int scale)
410 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
412 prev_dc = (blocks[0] - 0x4000) / scale;
418 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
419 dc = (blocks[0] - 0x4000) / scale;
420 delta = dc - prev_dc;
422 delta = (delta ^ sign) - sign;
425 codebook = (code + (code & 1)) >> 1;
426 codebook =
FFMIN(codebook, 3);
433 int blocks_per_slice,
434 int plane_size_factor,
435 const uint8_t *scan,
const int16_t *qmat)
439 int max_coeffs, abs_level;
441 max_coeffs = blocks_per_slice << 6;
446 for (i = 1; i < 64; i++) {
447 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
448 level = blocks[idx] / qmat[scan[
i]];
450 abs_level =
FFABS(level);
467 const uint16_t *
src, ptrdiff_t linesize,
468 int mbs_per_slice, int16_t *blocks,
469 int blocks_per_mb,
int plane_size_factor,
472 int blocks_per_slice, saved_pos;
475 blocks_per_slice = mbs_per_slice * blocks_per_mb;
477 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
478 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
487 const int dbits = (abits == 8) ? 4 : 7;
488 const int dsize = 1 << dbits - 1;
489 int diff = cur - prev;
491 diff = av_mod_uintp2(diff, abits);
492 if (diff >= (1 << abits) - dsize)
494 if (diff < -dsize || diff > dsize || !diff) {
519 int mbs_per_slice, uint16_t *blocks,
523 const int mask = (1 << abits) - 1;
524 const int num_coeffs = mbs_per_slice * 256;
526 int prev =
mask, cur;
543 }
while (idx < num_coeffs);
559 int slice_width_factor =
av_log2(mbs_per_slice);
560 int num_cblocks, pwidth, line_add;
562 int plane_factor, is_chroma;
564 uint16_t *qmat_chroma;
580 for (i = 0; i < 64; i++) {
587 is_chroma = (i == 1 || i == 2);
588 plane_factor = slice_width_factor + 2;
595 pwidth = avctx->
width;
600 pwidth = avctx->
width >> 1;
604 src = (
const uint16_t*)(pic->
data[i] + yp * linesize +
611 mbs_per_slice, num_cblocks, is_chroma);
614 mbs_per_slice, ctx->
blocks[0],
615 num_cblocks, plane_factor,
619 mbs_per_slice, ctx->
blocks[0],
620 num_cblocks, plane_factor,
630 total_size += sizes[
i];
633 "Underestimated required buffer size.\n");
642 unsigned int rice_order, exp_order, switch_bits, switch_val;
646 switch_bits = (codebook & 3) + 1;
647 rice_order = codebook >> 5;
648 exp_order = (codebook >> 2) & 7;
650 switch_val = switch_bits << rice_order;
652 if (val >= switch_val) {
653 val -= switch_val - (1 << exp_order);
656 return exponent * 2 - exp_order + switch_bits + 1;
658 return (val >> rice_order) + rice_order + 1;
666 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
669 prev_dc = (blocks[0] - 0x4000) / scale;
674 *error +=
FFABS(blocks[0] - 0x4000) % scale;
676 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
677 dc = (blocks[0] - 0x4000) / scale;
678 *error +=
FFABS(blocks[0] - 0x4000) % scale;
679 delta = dc - prev_dc;
681 delta = (delta ^ sign) - sign;
684 codebook = (code + (code & 1)) >> 1;
685 codebook =
FFMIN(codebook, 3);
694 int plane_size_factor,
695 const uint8_t *scan,
const int16_t *qmat)
699 int max_coeffs, abs_level;
702 max_coeffs = blocks_per_slice << 6;
707 for (i = 1; i < 64; i++) {
708 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
709 level = blocks[idx] / qmat[scan[
i]];
710 *error +=
FFABS(blocks[idx]) % qmat[scan[
i]];
712 abs_level =
FFABS(level);
730 const uint16_t *
src, ptrdiff_t linesize,
732 int blocks_per_mb,
int plane_size_factor,
735 int blocks_per_slice;
738 blocks_per_slice = mbs_per_slice * blocks_per_mb;
742 plane_size_factor, ctx->
scantable, qmat);
749 const int dbits = (abits == 8) ? 4 : 7;
750 const int dsize = 1 << dbits - 1;
751 int diff = cur - prev;
753 diff = av_mod_uintp2(diff, abits);
754 if (diff >= (1 << abits) - dsize)
756 if (diff < -dsize || diff > dsize || !diff)
763 const uint16_t *
src, ptrdiff_t linesize,
764 int mbs_per_slice, int16_t *blocks)
767 const int mask = (1 << abits) - 1;
768 const int num_coeffs = mbs_per_slice * 256;
769 int prev =
mask, cur;
792 }
while (idx < num_coeffs);
805 int trellis_node,
int x,
int y,
int mbs_per_slice,
809 int i, q, pq, xp, yp;
811 int slice_width_factor =
av_log2(mbs_per_slice);
817 int mbs, prev, cur, new_score;
821 uint16_t *qmat_chroma;
822 int linesize[4], line_add;
829 mbs = x + mbs_per_slice;
832 is_chroma[
i] = (i == 1 || i == 2);
833 plane_factor[
i] = slice_width_factor + 2;
840 pwidth = avctx->
width;
845 pwidth = avctx->
width >> 1;
849 src = (
const uint16_t *)(ctx->
pic->
data[i] + yp * linesize[i] +
856 mbs_per_slice, num_cblocks[i], is_chroma[i]);
864 for (q = min_quant; q < max_quant + 2; q++) {
871 mbs_per_slice, td->
blocks[3]);
873 for (q = min_quant; q <=
max_quant; q++) {
879 num_cblocks[0], plane_factor[0],
885 num_cblocks[i], plane_factor[i],
888 if (bits > 65000 * 8)
891 slice_bits[q] =
bits;
892 slice_score[q] =
error;
894 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
895 slice_bits[max_quant + 1] = slice_bits[
max_quant];
896 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
899 for (q = max_quant + 1; q < 128; q++) {
908 for (i = 0; i < 64; i++) {
916 num_cblocks[0], plane_factor[0],
922 num_cblocks[i], plane_factor[i],
925 if (bits <= ctx->bits_per_mb * mbs_per_slice)
929 slice_bits[max_quant + 1] =
bits;
930 slice_score[max_quant + 1] =
error;
933 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
936 for (pq = min_quant; pq < max_quant + 2; pq++) {
939 for (q = min_quant; q < max_quant + 2; q++) {
940 cur = trellis_node + q;
942 bits = td->
nodes[prev].
bits + slice_bits[q];
943 error = slice_score[q];
944 if (bits > bits_limit)
963 for (q = min_quant + 1; q < max_quant + 2; q++) {
964 if (td->
nodes[trellis_node + q].
score <= error) {
966 pq = trellis_node + q;
974 int jobnr,
int threadnr)
979 int x, y = jobnr,
mb, q = 0;
981 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
982 while (ctx->
mb_width - x < mbs_per_slice)
998 const AVFrame *pic,
int *got_packet)
1004 int x, y,
i,
mb, q = 0;
1005 int sizes[4] = { 0 };
1006 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
1018 orig_buf = pkt->
data;
1022 bytestream_put_be32 (&orig_buf,
FRAME_ID);
1028 bytestream_put_be16 (&buf, 0);
1030 bytestream_put_be16 (&buf, avctx->
width);
1031 bytestream_put_be16 (&buf, avctx->
height);
1036 bytestream_put_byte (&buf, frame_flags);
1038 bytestream_put_byte (&buf, 0);
1040 bytestream_put_byte (&buf, pic->
color_trc);
1042 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
1043 bytestream_put_byte (&buf, 0);
1045 bytestream_put_byte (&buf, 0x03);
1047 for (i = 0; i < 64; i++)
1048 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
1050 for (i = 0; i < 64; i++)
1051 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
1053 bytestream_put_byte (&buf, 0x00);
1055 bytestream_put_be16 (&tmp, buf - orig_buf);
1061 picture_size_pos = buf + 1;
1062 bytestream_put_byte (&buf, 0x40);
1081 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1085 while (ctx->
mb_width - x < mbs_per_slice)
1086 mbs_per_slice >>= 1;
1088 bytestream_put_byte(&buf, slice_hdr_size << 3);
1090 buf += slice_hdr_size - 1;
1091 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1097 max_slice_size - pkt_size;
1099 delta =
FFMAX(delta, 2 * max_slice_size);
1104 "Packet too small: is %i," 1105 " needs %i (slice: %i). " 1106 "Correct allocation",
1107 pkt_size, delta, max_slice_size);
1117 orig_buf = pkt->
data + (orig_buf -
start);
1119 picture_size_pos = pkt->
data + (picture_size_pos -
start);
1120 slice_sizes = pkt->
data + (slice_sizes -
start);
1121 slice_hdr = pkt->
data + (slice_hdr -
start);
1130 bytestream_put_byte(&slice_hdr, q);
1131 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1133 bytestream_put_be16(&slice_hdr, sizes[i]);
1134 slice_size += sizes[
i];
1136 bytestream_put_be16(&slice_sizes, slice_size);
1137 buf += slice_size - slice_hdr_size;
1138 if (max_slice_size < slice_size)
1139 max_slice_size = slice_size;
1143 picture_size = buf - (picture_size_pos - 1);
1144 bytestream_put_be32(&picture_size_pos, picture_size);
1148 frame_size = buf - orig_buf;
1149 bytestream_put_be32(&orig_buf, frame_size);
1174 ptrdiff_t linesize, int16_t *
block)
1177 const uint16_t *tsrc =
src;
1179 for (y = 0; y < 8; y++) {
1180 for (x = 0; x < 8; x++)
1181 block[y * 8 + x] = tsrc[x];
1182 tsrc += linesize >> 1;
1196 #if FF_API_CODED_FRAME 1209 if (mps & (mps - 1)) {
1211 "there should be an integer power of two MBs per slice\n");
1221 ?
"4:4:4:4 profile because of the used input colorspace" 1222 :
"HQ profile to keep best quality");
1229 "encode alpha. Override with -profile if needed.\n");
1267 if (strlen(ctx->
vendor) != 4) {
1290 for (j = 0; j < 64; j++) {
1316 for (i = min_quant; i < max_quant + 2; i++) {
1331 for (j = 0; j < 64; j++) {
1360 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1369 #define OFFSET(x) offsetof(ProresContext, x) 1370 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1373 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
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" },
1391 0, 0,
VE,
"profile" },
1392 {
"vendor",
"vendor ID",
OFFSET(vendor),
1394 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
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 0, 0,
VE,
"quant_mat" },
1411 { .i64 = 16 }, 0, 16, VE },
1423 .
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
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]
const uint8_t * scantable
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.
const AVProfile ff_prores_profiles[]
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)