32 #define CFACTOR_Y422 2
33 #define CFACTOR_Y444 3
35 #define MAX_MBS_PER_SLICE 8
57 4, 7, 9, 11, 13, 14, 15, 63,
58 7, 7, 11, 12, 14, 15, 63, 63,
59 9, 11, 13, 14, 15, 63, 63, 63,
60 11, 11, 13, 14, 63, 63, 63, 63,
61 11, 13, 14, 63, 63, 63, 63, 63,
62 13, 14, 63, 63, 63, 63, 63, 63,
63 13, 63, 63, 63, 63, 63, 63, 63,
64 63, 63, 63, 63, 63, 63, 63, 63,
67 4, 5, 6, 7, 9, 11, 13, 15,
68 5, 5, 7, 8, 11, 13, 15, 17,
69 6, 7, 9, 11, 13, 15, 15, 17,
70 7, 7, 9, 11, 13, 15, 17, 19,
71 7, 9, 11, 13, 14, 16, 19, 23,
72 9, 11, 13, 14, 16, 19, 23, 29,
73 9, 11, 13, 15, 17, 21, 28, 35,
74 11, 13, 16, 17, 21, 28, 35, 41,
77 4, 4, 5, 5, 6, 7, 7, 9,
78 4, 4, 5, 6, 7, 7, 9, 9,
79 5, 5, 6, 7, 7, 9, 9, 10,
80 5, 5, 6, 7, 7, 9, 9, 10,
81 5, 6, 7, 7, 8, 9, 10, 12,
82 6, 7, 7, 8, 9, 10, 12, 15,
83 6, 7, 7, 9, 10, 11, 14, 17,
84 7, 7, 9, 10, 11, 14, 17, 21,
87 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 5,
91 4, 4, 4, 4, 4, 4, 5, 5,
92 4, 4, 4, 4, 4, 5, 5, 6,
93 4, 4, 4, 4, 5, 5, 6, 7,
94 4, 4, 4, 4, 5, 6, 7, 7,
97 4, 4, 4, 4, 4, 4, 4, 4,
98 4, 4, 4, 4, 4, 4, 4, 4,
99 4, 4, 4, 4, 4, 4, 4, 4,
100 4, 4, 4, 4, 4, 4, 4, 4,
101 4, 4, 4, 4, 4, 4, 4, 4,
102 4, 4, 4, 4, 4, 4, 4, 4,
103 4, 4, 4, 4, 4, 4, 4, 4,
104 4, 4, 4, 4, 4, 4, 4, 4,
108 #define NUM_MB_LIMITS 4
126 .tag =
MKTAG(
'a',
'p',
'c',
'o'),
129 .br_tab = { 300, 242, 220, 194 },
134 .tag =
MKTAG(
'a',
'p',
'c',
's'),
137 .br_tab = { 720, 560, 490, 440 },
141 .full_name =
"standard",
142 .tag =
MKTAG(
'a',
'p',
'c',
'n'),
145 .br_tab = { 1050, 808, 710, 632 },
149 .full_name =
"high quality",
150 .tag =
MKTAG(
'a',
'p',
'c',
'h'),
153 .br_tab = { 1566, 1216, 1070, 950 },
158 .tag =
MKTAG(
'a',
'p',
'4',
'h'),
161 .br_tab = { 2350, 1828, 1600, 1425 },
166 #define TRELLIS_WIDTH 16
167 #define SCORE_LIMIT INT_MAX / 2
176 #define MAX_STORED_Q 16
195 int linesize, int16_t *
block);
225 int linesize,
int x,
int y,
int w,
int h,
226 int16_t *blocks, uint16_t *emu_buf,
227 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
229 const uint16_t *esrc;
230 const int mb_width = 4 * blocks_per_mb;
234 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
236 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
240 if (x + mb_width <= w && y + 16 <= h) {
242 elinesize = linesize;
247 elinesize = 16 *
sizeof(*emu_buf);
249 bw =
FFMIN(w - x, mb_width);
250 bh =
FFMIN(h - y, 16);
252 for (j = 0; j < bh; j++) {
253 memcpy(emu_buf + j * 16,
254 (
const uint8_t*)src + j * linesize,
256 pix = emu_buf[j * 16 + bw - 1];
257 for (k = bw; k < mb_width; k++)
258 emu_buf[j * 16 + k] = pix;
261 memcpy(emu_buf + j * 16,
262 emu_buf + (bh - 1) * 16,
263 mb_width *
sizeof(*emu_buf));
266 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
268 if (blocks_per_mb > 2) {
269 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
272 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
274 if (blocks_per_mb > 2) {
275 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
279 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
281 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
283 if (blocks_per_mb > 2) {
284 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
286 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
296 int linesize,
int x,
int y,
int w,
int h,
297 int16_t *blocks,
int mbs_per_slice,
int abits)
299 const int slice_width = 16 * mbs_per_slice;
300 int i, j, copy_w, copy_h;
302 copy_w =
FFMIN(w - x, slice_width);
303 copy_h =
FFMIN(h - y, 16);
304 for (i = 0; i < copy_h; i++) {
305 memcpy(blocks, src, copy_w *
sizeof(*src));
307 for (j = 0; j < copy_w; j++)
310 for (j = 0; j < copy_w; j++)
311 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
312 for (j = copy_w; j < slice_width; j++)
313 blocks[j] = blocks[copy_w - 1];
314 blocks += slice_width;
315 src += linesize >> 1;
317 for (; i < 16; i++) {
318 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
319 blocks += slice_width;
328 unsigned int rice_order, exp_order, switch_bits, switch_val;
332 switch_bits = (codebook & 3) + 1;
333 rice_order = codebook >> 5;
334 exp_order = (codebook >> 2) & 7;
336 switch_val = switch_bits << rice_order;
338 if (val >= switch_val) {
339 val -= switch_val - (1 << exp_order);
342 put_bits(pb, exponent - exp_order + switch_bits, 0);
345 exponent = val >> rice_order;
355 #define GET_SIGN(x) ((x) >> 31)
356 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
359 int blocks_per_slice,
int scale)
362 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
364 prev_dc = (blocks[0] - 0x4000) / scale;
370 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
371 dc = (blocks[0] - 0x4000) / scale;
372 delta = dc - prev_dc;
374 delta = (delta ^ sign) - sign;
377 codebook = (code + (code & 1)) >> 1;
378 codebook =
FFMIN(codebook, 3);
385 int blocks_per_slice,
386 int plane_size_factor,
387 const uint8_t *scan,
const int16_t *qmat)
391 int max_coeffs, abs_level;
393 max_coeffs = blocks_per_slice << 6;
398 for (i = 1; i < 64; i++) {
399 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
400 level = blocks[idx] / qmat[scan[i]];
402 abs_level =
FFABS(level);
419 const uint16_t *src,
int linesize,
420 int mbs_per_slice, int16_t *blocks,
421 int blocks_per_mb,
int plane_size_factor,
424 int blocks_per_slice, saved_pos;
427 blocks_per_slice = mbs_per_slice * blocks_per_mb;
429 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
430 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
439 const int mask = (1 << abits) - 1;
440 const int dbits = (abits == 8) ? 4 : 7;
441 const int dsize = 1 << dbits - 1;
442 int diff = cur - prev;
445 if (diff >= (1 << abits) - dsize)
447 if (diff < -dsize || diff > dsize || !diff) {
472 int mbs_per_slice, uint16_t *blocks,
476 const int mask = (1 << abits) - 1;
477 const int num_coeffs = mbs_per_slice * 256;
479 int prev =
mask, cur;
496 }
while (idx < num_coeffs);
512 int slice_width_factor =
av_log2(mbs_per_slice);
513 int num_cblocks, pwidth, linesize, line_add;
514 int plane_factor, is_chroma;
528 for (i = 0; i < 64; i++)
533 is_chroma = (i == 1 || i == 2);
534 plane_factor = slice_width_factor + 2;
541 pwidth = avctx->
width;
546 pwidth = avctx->
width >> 1;
550 src = (
const uint16_t*)(pic->
data[i] + yp * linesize +
557 mbs_per_slice, num_cblocks, is_chroma);
559 mbs_per_slice, ctx->
blocks[0],
560 num_cblocks, plane_factor,
569 total_size += sizes[i];
572 "Underestimated required buffer size.\n");
581 unsigned int rice_order, exp_order, switch_bits, switch_val;
585 switch_bits = (codebook & 3) + 1;
586 rice_order = codebook >> 5;
587 exp_order = (codebook >> 2) & 7;
589 switch_val = switch_bits << rice_order;
591 if (val >= switch_val) {
592 val -= switch_val - (1 << exp_order);
595 return exponent * 2 - exp_order + switch_bits + 1;
597 return (val >> rice_order) + rice_order + 1;
601 static int estimate_dcs(
int *error, int16_t *blocks,
int blocks_per_slice,
605 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
608 prev_dc = (blocks[0] - 0x4000) / scale;
613 *error +=
FFABS(blocks[0] - 0x4000) % scale;
615 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
616 dc = (blocks[0] - 0x4000) / scale;
617 *error +=
FFABS(blocks[0] - 0x4000) % scale;
618 delta = dc - prev_dc;
620 delta = (delta ^ sign) - sign;
623 codebook = (code + (code & 1)) >> 1;
624 codebook =
FFMIN(codebook, 3);
632 static int estimate_acs(
int *error, int16_t *blocks,
int blocks_per_slice,
633 int plane_size_factor,
634 const uint8_t *scan,
const int16_t *qmat)
638 int max_coeffs, abs_level;
641 max_coeffs = blocks_per_slice << 6;
646 for (i = 1; i < 64; i++) {
647 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
648 level = blocks[idx] / qmat[scan[i]];
649 *error +=
FFABS(blocks[idx]) % qmat[scan[i]];
651 abs_level =
FFABS(level);
669 const uint16_t *src,
int linesize,
671 int blocks_per_mb,
int plane_size_factor,
674 int blocks_per_slice;
677 blocks_per_slice = mbs_per_slice * blocks_per_mb;
681 plane_size_factor, ctx->
scantable, qmat);
688 const int mask = (1 << abits) - 1;
689 const int dbits = (abits == 8) ? 4 : 7;
690 const int dsize = 1 << dbits - 1;
691 int diff = cur - prev;
694 if (diff >= (1 << abits) - dsize)
696 if (diff < -dsize || diff > dsize || !diff)
703 const uint16_t *src,
int linesize,
704 int mbs_per_slice,
int quant,
708 const int mask = (1 << abits) - 1;
709 const int num_coeffs = mbs_per_slice * 256;
710 int prev =
mask, cur;
734 }
while (idx < num_coeffs);
747 int trellis_node,
int x,
int y,
int mbs_per_slice,
751 int i, q, pq, xp, yp;
753 int slice_width_factor =
av_log2(mbs_per_slice);
758 int error,
bits, bits_limit;
759 int mbs, prev, cur, new_score;
763 int linesize[4], line_add;
769 mbs = x + mbs_per_slice;
772 is_chroma[i] = (i == 1 || i == 2);
773 plane_factor[i] = slice_width_factor + 2;
780 pwidth = avctx->
width;
785 pwidth = avctx->
width >> 1;
789 src = (
const uint16_t*)(pic->
data[i] + yp * linesize[i] +
796 mbs_per_slice, num_cblocks[i], is_chroma[i]);
804 for (q = min_quant; q < max_quant + 2; q++) {
810 for (q = min_quant; q <=
max_quant; q++) {
817 num_cblocks[i], plane_factor[i],
822 mbs_per_slice, q, td->
blocks[3]);
823 if (bits > 65000 * 8)
826 slice_bits[q] =
bits;
827 slice_score[q] = error;
829 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
830 slice_bits[max_quant + 1] = slice_bits[
max_quant];
831 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
834 for (q = max_quant + 1; q < 128; q++) {
841 for (i = 0; i < 64; i++)
848 num_cblocks[i], plane_factor[i],
853 mbs_per_slice, q, td->
blocks[3]);
854 if (bits <= ctx->bits_per_mb * mbs_per_slice)
858 slice_bits[max_quant + 1] =
bits;
859 slice_score[max_quant + 1] = error;
862 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
865 for (pq = min_quant; pq < max_quant + 2; pq++) {
868 for (q = min_quant; q < max_quant + 2; q++) {
869 cur = trellis_node + q;
871 bits = td->
nodes[prev].
bits + slice_bits[q];
872 error = slice_score[q];
873 if (bits > bits_limit)
892 for (q = min_quant + 1; q < max_quant + 2; q++) {
893 if (td->
nodes[trellis_node + q].
score <= error) {
895 pq = trellis_node + q;
903 int jobnr,
int threadnr)
908 int x, y = jobnr, mb, q = 0;
910 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
911 while (ctx->
mb_width - x < mbs_per_slice)
927 const AVFrame *pic,
int *got_packet)
930 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
933 int x, y, i, mb, q = 0;
934 int sizes[4] = { 0 };
935 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
937 int pkt_size, ret, max_slice_size = 0;
951 orig_buf = pkt->
data;
955 bytestream_put_be32 (&orig_buf,
FRAME_ID);
961 bytestream_put_be16 (&buf, 0);
963 bytestream_put_be16 (&buf, avctx->
width);
964 bytestream_put_be16 (&buf, avctx->
height);
969 bytestream_put_byte (&buf, frame_flags);
971 bytestream_put_byte (&buf, 0);
973 bytestream_put_byte (&buf, avctx->
color_trc);
974 bytestream_put_byte (&buf, avctx->
colorspace);
975 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
976 bytestream_put_byte (&buf, 0);
978 bytestream_put_byte (&buf, 0x03);
980 for (i = 0; i < 64; i++)
981 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
983 for (i = 0; i < 64; i++)
984 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
986 bytestream_put_byte (&buf, 0x00);
988 bytestream_put_be16 (&tmp, buf - orig_buf);
994 picture_size_pos = buf + 1;
995 bytestream_put_byte (&buf, 0x40);
1014 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1018 while (ctx->
mb_width - x < mbs_per_slice)
1019 mbs_per_slice >>= 1;
1021 bytestream_put_byte(&buf, slice_hdr_size << 3);
1023 buf += slice_hdr_size - 1;
1024 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1032 delta =
FFMAX(delta, 2 * max_slice_size);
1037 "Packet too small: is %i,"
1038 " needs %i (slice: %i). "
1039 "Correct allocation",
1040 pkt_size, delta, max_slice_size);
1050 orig_buf = pkt->
data + (orig_buf - start);
1051 buf = pkt->
data + (buf - start);
1052 picture_size_pos = pkt->
data + (picture_size_pos - start);
1053 slice_sizes = pkt->
data + (slice_sizes - start);
1054 slice_hdr = pkt->
data + (slice_hdr - start);
1055 tmp = pkt->
data + (tmp - start);
1063 bytestream_put_byte(&slice_hdr, q);
1064 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1066 bytestream_put_be16(&slice_hdr, sizes[i]);
1067 slice_size += sizes[i];
1069 bytestream_put_be16(&slice_sizes, slice_size);
1070 buf += slice_size - slice_hdr_size;
1071 if (max_slice_size < slice_size)
1072 max_slice_size = slice_size;
1077 picture_size = buf - picture_size_pos - 6;
1079 picture_size = buf - picture_size_pos + 1;
1080 bytestream_put_be32(&picture_size_pos, picture_size);
1084 frame_size = buf - orig_buf;
1085 bytestream_put_be32(&orig_buf, frame_size);
1112 int linesize, int16_t *
block)
1115 const uint16_t *tsrc = src;
1117 for (y = 0; y < 8; y++) {
1118 for (x = 0; x < 8; x++)
1119 block[y * 8 + x] = tsrc[x];
1120 tsrc += linesize >> 1;
1144 if (mps & (mps - 1)) {
1146 "there should be an integer power of two MBs per slice\n");
1181 if (strlen(ctx->
vendor) != 4) {
1202 for (j = 0; j < 64; j++)
1226 for (i = min_quant; i < max_quant + 2; i++) {
1240 for (j = 0; j < 64; j++) {
1267 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1276 #define OFFSET(x) offsetof(ProresContext, x)
1277 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1280 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1286 0, 0,
VE,
"profile" },
1288 0, 0,
VE,
"profile" },
1290 0, 0,
VE,
"profile" },
1292 0, 0,
VE,
"profile" },
1294 0, 0,
VE,
"profile" },
1295 {
"vendor",
"vendor ID",
OFFSET(vendor),
1297 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1302 0, 0,
VE,
"quant_mat" },
1304 0, 0,
VE,
"quant_mat" },
1306 0, 0,
VE,
"quant_mat" },
1308 0, 0,
VE,
"quant_mat" },
1310 0, 0,
VE,
"quant_mat" },
1312 0, 0,
VE,
"quant_mat" },
1314 { .i64 = 16 }, 0, 16,
VE },
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice, int scale)
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, int linesize, int16_t *block)
#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.
#define MAX_MBS_PER_SLICE
static void put_sbits(PutBitContext *pb, int n, int32_t value)
AVCodec ff_prores_encoder
const uint8_t ff_prores_ac_codebook[7]
AVFrame * coded_frame
the picture in the bitstream
static int estimate_vlc(unsigned codebook, int val)
static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, int mbs_per_slice, uint16_t *blocks, int quant)
#define DECLARE_ALIGNED(n, t, v)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static int find_quant_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
const uint8_t * scantable
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
static int estimate_slice_plane(ProresContext *ctx, int *error, int plane, const uint16_t *src, int linesize, int mbs_per_slice, int blocks_per_mb, int plane_size_factor, const int16_t *qmat, ProresThreadData *td)
int16_t quants[MAX_STORED_Q][64]
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static const int prores_mb_limits[NUM_MB_LIMITS]
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]
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static const uint8_t frame_size[4]
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, int mbs_per_slice)
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
static const struct prores_profile prores_profile_info[5]
static int put_bits_left(PutBitContext *s)
static const uint16_t mask[17]
static const int sizes[][2]
static void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
Write an unsigned rice/exp golomb codeword.
static const uint8_t prores_quant_matrices[][64]
static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
#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
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
int flags
A combination of AV_PKT_FLAG values.
struct TrellisNode * nodes
static int put_bits_count(PutBitContext *s)
static const AVClass proresenc_class
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 void get_slice_data(ProresContext *ctx, const uint16_t *src, int 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)
enum AVPictureType pict_type
Picture type of the frame.
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
int num_chroma_blocks
number of chrominance blocks in a macroblock
int width
picture width / height.
const uint8_t ff_prores_dc_codebook[4]
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
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)
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define AV_PIX_FMT_YUVA444P10
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
static av_cold int encode_init(AVCodecContext *avctx)
static const AVOption options[]
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.
void(* fdct)(int16_t *block)
main external API structure.
static void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
static void close(AVCodecParserContext *s)
const uint8_t ff_prores_progressive_scan[64]
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
#define AVERROR_BUG
Bug detected, please report the issue.
Describe the class of an AVClass context structure.
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
static void get_alpha_data(ProresContext *ctx, const uint16_t *src, int linesize, int x, int y, int w, int h, int16_t *blocks, int mbs_per_slice, int abits)
int global_quality
Global quality for codecs which cannot change it per frame.
#define AV_PIX_FMT_YUV422P10
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int est_alpha_diff(int cur, int prev, int abits)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
int br_tab[NUM_MB_LIMITS]
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int estimate_alpha_plane(ProresContext *ctx, int *error, const uint16_t *src, int linesize, int mbs_per_slice, int quant, int16_t *blocks)
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_cold int init(AVCodecParserContext *s)
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
int top_field_first
If the content is interlaced, is top field displayed first.
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.
static void put_alpha_run(PutBitContext *pb, int run)
int key_frame
1 -> keyframe, 0-> not
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, int linesize, int16_t *block)
const uint8_t * quant_mat
#define MKTAG(a, b, c, d)
int frame_size_upper_bound
static av_cold int encode_close(AVCodecContext *avctx)
AVPixelFormat
Pixel format.
This structure stores compressed data.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb, const uint16_t *src, int linesize, int mbs_per_slice, int16_t *blocks, int blocks_per_mb, int plane_size_factor, const int16_t *qmat)