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 225 int16_t custom_q[64];
226 int16_t custom_chroma_q[64];
236 int16_t custom_q[64];
237 int16_t custom_chroma_q[64];
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);
299 bh =
FFMIN(h - y, 16);
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 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;
381 switch_bits = (codebook & 3) + 1;
382 rice_order = codebook >> 5;
383 exp_order = (codebook >> 2) & 7;
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;
421 delta = dc - prev_dc;
423 delta = (delta ^ sign) - sign;
426 codebook = (
code + (
code & 1)) >> 1;
427 codebook =
FFMIN(codebook, 3);
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]];
451 abs_level =
FFABS(level);
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 = mbs_per_slice * blocks_per_mb;
475 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
476 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
482 const int dbits = (abits == 8) ? 4 : 7;
483 const int dsize = 1 << dbits - 1;
484 int diff = cur - prev;
487 if (diff >= (1 << abits) - dsize)
489 if (diff < -dsize || diff > dsize || !diff) {
514 int mbs_per_slice, uint16_t *blocks,
518 const int mask = (1 << abits) - 1;
519 const int num_coeffs = mbs_per_slice * 256;
520 int prev =
mask, cur;
537 }
while (idx < num_coeffs);
551 int slice_width_factor =
av_log2(mbs_per_slice);
552 int num_cblocks, pwidth, line_add;
554 int plane_factor, is_chroma;
556 uint16_t *qmat_chroma;
572 for (i = 0; i < 64; i++) {
579 is_chroma = (i == 1 || i == 2);
580 plane_factor = slice_width_factor + 2;
587 pwidth = avctx->
width;
592 pwidth = avctx->
width >> 1;
596 src = (
const uint16_t*)(pic->
data[i] + yp * linesize +
603 mbs_per_slice, num_cblocks, is_chroma);
606 mbs_per_slice, ctx->
blocks[0],
607 num_cblocks, plane_factor, qmat);
610 mbs_per_slice, ctx->
blocks[0],
611 num_cblocks, plane_factor, qmat_chroma);
628 unsigned int rice_order, exp_order, switch_bits, switch_val;
632 switch_bits = (codebook & 3) + 1;
633 rice_order = codebook >> 5;
634 exp_order = (codebook >> 2) & 7;
636 switch_val = switch_bits << rice_order;
638 if (val >= switch_val) {
639 val -= switch_val - (1 << exp_order);
642 return exponent * 2 - exp_order + switch_bits + 1;
644 return (val >> rice_order) + rice_order + 1;
655 prev_dc = (blocks[0] - 0x4000) / scale;
660 *error +=
FFABS(blocks[0] - 0x4000) % scale;
662 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
663 dc = (blocks[0] - 0x4000) / scale;
664 *error +=
FFABS(blocks[0] - 0x4000) % scale;
665 delta = dc - prev_dc;
667 delta = (delta ^ sign) - sign;
670 codebook = (
code + (
code & 1)) >> 1;
671 codebook =
FFMIN(codebook, 3);
680 int plane_size_factor,
681 const uint8_t *scan,
const int16_t *qmat)
685 int max_coeffs, abs_level;
688 max_coeffs = blocks_per_slice << 6;
693 for (i = 1; i < 64; i++) {
694 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
695 level = blocks[idx] / qmat[scan[
i]];
696 *error +=
FFABS(blocks[idx]) % qmat[scan[
i]];
698 abs_level =
FFABS(level);
716 const uint16_t *
src, ptrdiff_t linesize,
718 int blocks_per_mb,
int plane_size_factor,
721 int blocks_per_slice;
724 blocks_per_slice = mbs_per_slice * blocks_per_mb;
728 plane_size_factor, ctx->
scantable, qmat);
735 const int dbits = (abits == 8) ? 4 : 7;
736 const int dsize = 1 << dbits - 1;
737 int diff = cur - prev;
740 if (diff >= (1 << abits) - dsize)
742 if (diff < -dsize || diff > dsize || !diff)
749 const uint16_t *
src, ptrdiff_t linesize,
750 int mbs_per_slice, int16_t *blocks)
753 const int mask = (1 << abits) - 1;
754 const int num_coeffs = mbs_per_slice * 256;
755 int prev =
mask, cur;
778 }
while (idx < num_coeffs);
791 int trellis_node,
int x,
int y,
int mbs_per_slice,
795 int i, q, pq, xp, yp;
797 int slice_width_factor =
av_log2(mbs_per_slice);
803 int mbs, prev, cur, new_score;
807 uint16_t *qmat_chroma;
808 int linesize[4], line_add;
815 mbs = x + mbs_per_slice;
818 is_chroma[
i] = (i == 1 || i == 2);
819 plane_factor[
i] = slice_width_factor + 2;
826 pwidth = avctx->
width;
831 pwidth = avctx->
width >> 1;
835 src = (
const uint16_t *)(ctx->
pic->
data[i] + yp * linesize[i] +
842 mbs_per_slice, num_cblocks[i], is_chroma[i]);
850 for (q = min_quant; q < max_quant + 2; q++) {
857 mbs_per_slice, td->
blocks[3]);
859 for (q = min_quant; q <=
max_quant; q++) {
865 num_cblocks[0], plane_factor[0],
871 num_cblocks[i], plane_factor[i],
874 if (bits > 65000 * 8)
877 slice_bits[q] =
bits;
878 slice_score[q] =
error;
880 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
881 slice_bits[max_quant + 1] = slice_bits[
max_quant];
882 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
885 for (q = max_quant + 1; q < 128; q++) {
894 for (i = 0; i < 64; i++) {
902 num_cblocks[0], plane_factor[0],
908 num_cblocks[i], plane_factor[i],
911 if (bits <= ctx->bits_per_mb * mbs_per_slice)
915 slice_bits[max_quant + 1] =
bits;
916 slice_score[max_quant + 1] =
error;
919 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
922 for (pq = min_quant; pq < max_quant + 2; pq++) {
925 for (q = min_quant; q < max_quant + 2; q++) {
926 cur = trellis_node + q;
928 bits = td->
nodes[prev].
bits + slice_bits[q];
929 error = slice_score[q];
930 if (bits > bits_limit)
949 for (q = min_quant + 1; q < max_quant + 2; q++) {
950 if (td->
nodes[trellis_node + q].
score <= error) {
952 pq = trellis_node + q;
960 int jobnr,
int threadnr)
965 int x, y = jobnr,
mb, q = 0;
967 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
968 while (ctx->
mb_width - x < mbs_per_slice)
984 const AVFrame *pic,
int *got_packet)
987 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *
tmp;
990 int x, y,
i,
mb, q = 0;
991 int sizes[4] = { 0 };
992 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
1004 orig_buf = pkt->
data;
1008 bytestream_put_be32 (&orig_buf,
FRAME_ID);
1014 bytestream_put_be16 (&buf, 0);
1016 bytestream_put_be16 (&buf, avctx->
width);
1017 bytestream_put_be16 (&buf, avctx->
height);
1022 bytestream_put_byte (&buf, frame_flags);
1024 bytestream_put_byte (&buf, 0);
1026 bytestream_put_byte (&buf, pic->
color_trc);
1028 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
1029 bytestream_put_byte (&buf, 0);
1031 bytestream_put_byte (&buf, 0x03);
1033 for (i = 0; i < 64; i++)
1034 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
1036 for (i = 0; i < 64; i++)
1037 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
1039 bytestream_put_byte (&buf, 0x00);
1041 bytestream_put_be16 (&tmp, buf - orig_buf);
1047 picture_size_pos = buf + 1;
1048 bytestream_put_byte (&buf, 0x40);
1067 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1071 while (ctx->
mb_width - x < mbs_per_slice)
1072 mbs_per_slice >>= 1;
1074 bytestream_put_byte(&buf, slice_hdr_size << 3);
1076 buf += slice_hdr_size - 1;
1077 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1083 max_slice_size - pkt_size;
1085 delta =
FFMAX(delta, 2 * max_slice_size);
1090 "Packet too small: is %i," 1091 " needs %i (slice: %i). " 1092 "Correct allocation",
1093 pkt_size, delta, max_slice_size);
1103 orig_buf = pkt->
data + (orig_buf - start);
1104 buf = pkt->
data + (buf - start);
1105 picture_size_pos = pkt->
data + (picture_size_pos - start);
1106 slice_sizes = pkt->
data + (slice_sizes - start);
1107 slice_hdr = pkt->
data + (slice_hdr - start);
1108 tmp = pkt->
data + (tmp - start);
1116 bytestream_put_byte(&slice_hdr, q);
1117 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1119 bytestream_put_be16(&slice_hdr, sizes[i]);
1120 slice_size += sizes[
i];
1122 bytestream_put_be16(&slice_sizes, slice_size);
1123 buf += slice_size - slice_hdr_size;
1124 if (max_slice_size < slice_size)
1125 max_slice_size = slice_size;
1129 picture_size = buf - (picture_size_pos - 1);
1130 bytestream_put_be32(&picture_size_pos, picture_size);
1134 frame_size = buf - orig_buf;
1135 bytestream_put_be32(&orig_buf, frame_size);
1160 ptrdiff_t linesize, int16_t *
block)
1163 const uint16_t *tsrc =
src;
1165 for (y = 0; y < 8; y++) {
1166 for (x = 0; x < 8; x++)
1167 block[y * 8 + x] = tsrc[x];
1168 tsrc += linesize >> 1;
1182 #if FF_API_CODED_FRAME 1195 if (mps & (mps - 1)) {
1197 "there should be an integer power of two MBs per slice\n");
1207 ?
"4:4:4:4 profile because of the used input colorspace" 1208 :
"HQ profile to keep best quality");
1215 "encode alpha. Override with -profile if needed.\n");
1253 if (strlen(ctx->
vendor) != 4) {
1276 for (j = 0; j < 64; j++) {
1302 for (i = min_quant; i < max_quant + 2; i++) {
1317 for (j = 0; j < 64; j++) {
1346 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1355 #define OFFSET(x) offsetof(ProresContext, x) 1356 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1359 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1365 0, 0,
VE,
"profile" },
1367 0, 0,
VE,
"profile" },
1369 0, 0,
VE,
"profile" },
1371 0, 0,
VE,
"profile" },
1373 0, 0,
VE,
"profile" },
1375 0, 0,
VE,
"profile" },
1377 0, 0,
VE,
"profile" },
1378 {
"vendor",
"vendor ID",
OFFSET(vendor),
1380 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1385 0, 0,
VE,
"quant_mat" },
1387 0, 0,
VE,
"quant_mat" },
1389 0, 0,
VE,
"quant_mat" },
1391 0, 0,
VE,
"quant_mat" },
1393 0, 0,
VE,
"quant_mat" },
1395 0, 0,
VE,
"quant_mat" },
1397 { .i64 = 16 }, 0, 16, VE },
1409 .
name =
"prores_ks",
static const AVClass proresenc_class
#define MAX_MBS_PER_SLICE
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static const unsigned codebook[256][2]
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
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
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)
static void error(const char *err)
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]
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.
The exact code depends on how similar the blocks are and how related they are to the block
#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)
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, int plane_size_factor, const int16_t *qmat)
#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]
static void encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, int mbs_per_slice, uint16_t *blocks, int quant)
unsigned mb_width
width of the current picture in mb
#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 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]
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
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.
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
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 int put_bytes_output(const PutBitContext *s)
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.
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.
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]
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]
Describe the class of an AVClass context structure.
static enum AVPixelFormat pix_fmts[]
int global_quality
Global quality for codecs which cannot change it per frame.
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
#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 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
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
#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.
static double val(void *priv, double ch)
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)