33 #define CFACTOR_Y422 2
34 #define CFACTOR_Y444 3
36 #define MAX_MBS_PER_SLICE 8
58 4, 7, 9, 11, 13, 14, 15, 63,
59 7, 7, 11, 12, 14, 15, 63, 63,
60 9, 11, 13, 14, 15, 63, 63, 63,
61 11, 11, 13, 14, 63, 63, 63, 63,
62 11, 13, 14, 63, 63, 63, 63, 63,
63 13, 14, 63, 63, 63, 63, 63, 63,
64 13, 63, 63, 63, 63, 63, 63, 63,
65 63, 63, 63, 63, 63, 63, 63, 63,
68 4, 5, 6, 7, 9, 11, 13, 15,
69 5, 5, 7, 8, 11, 13, 15, 17,
70 6, 7, 9, 11, 13, 15, 15, 17,
71 7, 7, 9, 11, 13, 15, 17, 19,
72 7, 9, 11, 13, 14, 16, 19, 23,
73 9, 11, 13, 14, 16, 19, 23, 29,
74 9, 11, 13, 15, 17, 21, 28, 35,
75 11, 13, 16, 17, 21, 28, 35, 41,
78 4, 4, 5, 5, 6, 7, 7, 9,
79 4, 4, 5, 6, 7, 7, 9, 9,
80 5, 5, 6, 7, 7, 9, 9, 10,
81 5, 5, 6, 7, 7, 9, 9, 10,
82 5, 6, 7, 7, 8, 9, 10, 12,
83 6, 7, 7, 8, 9, 10, 12, 15,
84 6, 7, 7, 9, 10, 11, 14, 17,
85 7, 7, 9, 10, 11, 14, 17, 21,
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, 4,
91 4, 4, 4, 4, 4, 4, 4, 5,
92 4, 4, 4, 4, 4, 4, 5, 5,
93 4, 4, 4, 4, 4, 5, 5, 6,
94 4, 4, 4, 4, 5, 5, 6, 7,
95 4, 4, 4, 4, 5, 6, 7, 7,
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,
105 4, 4, 4, 4, 4, 4, 4, 4,
109 #define NUM_MB_LIMITS 4
127 .tag =
MKTAG(
'a',
'p',
'c',
'o'),
130 .br_tab = { 300, 242, 220, 194 },
135 .tag =
MKTAG(
'a',
'p',
'c',
's'),
138 .br_tab = { 720, 560, 490, 440 },
142 .full_name =
"standard",
143 .tag =
MKTAG(
'a',
'p',
'c',
'n'),
146 .br_tab = { 1050, 808, 710, 632 },
150 .full_name =
"high quality",
151 .tag =
MKTAG(
'a',
'p',
'c',
'h'),
154 .br_tab = { 1566, 1216, 1070, 950 },
159 .tag =
MKTAG(
'a',
'p',
'4',
'h'),
162 .br_tab = { 2350, 1828, 1600, 1425 },
167 #define TRELLIS_WIDTH 16
168 #define SCORE_LIMIT INT_MAX / 2
177 #define MAX_STORED_Q 16
224 int linesize,
int x,
int y,
int w,
int h,
225 int16_t *blocks, uint16_t *emu_buf,
226 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
228 const uint16_t *esrc;
229 const int mb_width = 4 * blocks_per_mb;
233 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
235 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
239 if (x + mb_width <= w && y + 16 <= h) {
241 elinesize = linesize;
246 elinesize = 16 *
sizeof(*emu_buf);
248 bw =
FFMIN(w - x, mb_width);
249 bh =
FFMIN(h - y, 16);
251 for (j = 0; j < bh; j++) {
252 memcpy(emu_buf + j * 16,
253 (
const uint8_t*)src + j * linesize,
255 pix = emu_buf[j * 16 + bw - 1];
256 for (k = bw; k < mb_width; k++)
257 emu_buf[j * 16 + k] = pix;
260 memcpy(emu_buf + j * 16,
261 emu_buf + (bh - 1) * 16,
262 mb_width *
sizeof(*emu_buf));
265 ctx->
dsp.
fdct(esrc, elinesize, blocks);
267 if (blocks_per_mb > 2) {
268 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
271 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
273 if (blocks_per_mb > 2) {
274 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
278 ctx->
dsp.
fdct(esrc, elinesize, blocks);
280 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
282 if (blocks_per_mb > 2) {
283 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
285 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
295 int linesize,
int x,
int y,
int w,
int h,
296 int16_t *blocks,
int mbs_per_slice,
int abits)
298 const int slice_width = 16 * mbs_per_slice;
299 int i, j, copy_w, copy_h;
301 copy_w =
FFMIN(w - x, slice_width);
302 copy_h =
FFMIN(h - y, 16);
303 for (i = 0; i < copy_h; i++) {
304 memcpy(blocks, src, copy_w *
sizeof(*src));
306 for (j = 0; j < copy_w; j++)
309 for (j = 0; j < copy_w; j++)
310 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
311 for (j = copy_w; j < slice_width; j++)
312 blocks[j] = blocks[copy_w - 1];
313 blocks += slice_width;
314 src += linesize >> 1;
316 for (; i < 16; i++) {
317 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
318 blocks += slice_width;
327 unsigned int rice_order, exp_order, switch_bits, switch_val;
331 switch_bits = (codebook & 3) + 1;
332 rice_order = codebook >> 5;
333 exp_order = (codebook >> 2) & 7;
335 switch_val = switch_bits << rice_order;
337 if (val >= switch_val) {
338 val -= switch_val - (1 << exp_order);
341 put_bits(pb, exponent - exp_order + switch_bits, 0);
344 exponent = val >> rice_order;
354 #define GET_SIGN(x) ((x) >> 31)
355 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
358 int blocks_per_slice,
int scale)
361 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
363 prev_dc = (blocks[0] - 0x4000) / scale;
369 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
370 dc = (blocks[0] - 0x4000) / scale;
371 delta = dc - prev_dc;
373 delta = (delta ^ sign) - sign;
376 codebook = (code + (code & 1)) >> 1;
377 codebook =
FFMIN(codebook, 3);
384 int blocks_per_slice,
385 int plane_size_factor,
386 const uint8_t *scan,
const int16_t *qmat)
390 int max_coeffs, abs_level;
392 max_coeffs = blocks_per_slice << 6;
397 for (i = 1; i < 64; i++) {
398 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
399 level = blocks[idx] / qmat[scan[i]];
401 abs_level =
FFABS(level);
418 const uint16_t *src,
int linesize,
419 int mbs_per_slice, int16_t *blocks,
420 int blocks_per_mb,
int plane_size_factor,
423 int blocks_per_slice, saved_pos;
426 blocks_per_slice = mbs_per_slice * blocks_per_mb;
428 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
429 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
438 const int mask = (1 << abits) - 1;
439 const int dbits = (abits == 8) ? 4 : 7;
440 const int dsize = 1 << dbits - 1;
441 int diff = cur - prev;
444 if (diff >= (1 << abits) - dsize)
446 if (diff < -dsize || diff > dsize || !diff) {
471 int mbs_per_slice, uint16_t *blocks,
475 const int mask = (1 << abits) - 1;
476 const int num_coeffs = mbs_per_slice * 256;
478 int prev =
mask, cur;
495 }
while (idx < num_coeffs);
511 int slice_width_factor =
av_log2(mbs_per_slice);
512 int num_cblocks, pwidth, linesize, line_add;
513 int plane_factor, is_chroma;
527 for (i = 0; i < 64; i++)
532 is_chroma = (i == 1 || i == 2);
533 plane_factor = slice_width_factor + 2;
540 pwidth = avctx->
width;
545 pwidth = avctx->
width >> 1;
549 src = (
const uint16_t*)(pic->
data[i] + yp * linesize +
556 mbs_per_slice, num_cblocks, is_chroma);
558 mbs_per_slice, ctx->
blocks[0],
559 num_cblocks, plane_factor,
568 total_size += sizes[i];
571 "Underestimated required buffer size.\n");
580 unsigned int rice_order, exp_order, switch_bits, switch_val;
584 switch_bits = (codebook & 3) + 1;
585 rice_order = codebook >> 5;
586 exp_order = (codebook >> 2) & 7;
588 switch_val = switch_bits << rice_order;
590 if (val >= switch_val) {
591 val -= switch_val - (1 << exp_order);
594 return exponent * 2 - exp_order + switch_bits + 1;
596 return (val >> rice_order) + rice_order + 1;
600 static int estimate_dcs(
int *error, int16_t *blocks,
int blocks_per_slice,
604 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
607 prev_dc = (blocks[0] - 0x4000) / scale;
614 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
615 dc = (blocks[0] - 0x4000) / scale;
617 delta = dc - prev_dc;
619 delta = (delta ^ sign) - sign;
622 codebook = (code + (code & 1)) >> 1;
623 codebook =
FFMIN(codebook, 3);
631 static int estimate_acs(
int *error, int16_t *blocks,
int blocks_per_slice,
632 int plane_size_factor,
633 const uint8_t *scan,
const int16_t *qmat)
637 int max_coeffs, abs_level;
640 max_coeffs = blocks_per_slice << 6;
645 for (i = 1; i < 64; i++) {
646 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
647 level = blocks[idx] / qmat[scan[i]];
648 *error +=
FFABS(blocks[idx]) % qmat[scan[i]];
650 abs_level =
FFABS(level);
668 const uint16_t *src,
int linesize,
670 int blocks_per_mb,
int plane_size_factor,
673 int blocks_per_slice;
676 blocks_per_slice = mbs_per_slice * blocks_per_mb;
687 const int mask = (1 << abits) - 1;
688 const int dbits = (abits == 8) ? 4 : 7;
689 const int dsize = 1 << dbits - 1;
690 int diff = cur - prev;
693 if (diff >= (1 << abits) - dsize)
695 if (diff < -dsize || diff > dsize || !diff)
702 const uint16_t *src,
int linesize,
703 int mbs_per_slice,
int quant,
707 const int mask = (1 << abits) - 1;
708 const int num_coeffs = mbs_per_slice * 256;
709 int prev =
mask, cur;
733 }
while (idx < num_coeffs);
746 int trellis_node,
int x,
int y,
int mbs_per_slice,
750 int i, q, pq, xp, yp;
752 int slice_width_factor =
av_log2(mbs_per_slice);
757 int error,
bits, bits_limit;
758 int mbs, prev, cur, new_score;
762 int linesize[4], line_add;
768 mbs = x + mbs_per_slice;
771 is_chroma[i] = (i == 1 || i == 2);
772 plane_factor[i] = slice_width_factor + 2;
779 pwidth = avctx->
width;
784 pwidth = avctx->
width >> 1;
788 src = (
const uint16_t*)(pic->
data[i] + yp * linesize[i] +
795 mbs_per_slice, num_cblocks[i], is_chroma[i]);
803 for (q = min_quant; q < max_quant + 2; q++) {
809 for (q = min_quant; q <=
max_quant; q++) {
816 num_cblocks[i], plane_factor[i],
821 mbs_per_slice, q, td->
blocks[3]);
822 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);
1130 if (mps & (mps - 1)) {
1132 "there should be an integer power of two MBs per slice\n");
1167 if (strlen(ctx->
vendor) != 4) {
1188 for (j = 0; j < 64; j++)
1212 for (i = min_quant; i < max_quant + 2; i++) {
1226 for (j = 0; j < 64; j++) {
1253 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1262 #define OFFSET(x) offsetof(ProresContext, x)
1263 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1266 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1272 0, 0,
VE,
"profile" },
1274 0, 0,
VE,
"profile" },
1276 0, 0,
VE,
"profile" },
1278 0, 0,
VE,
"profile" },
1280 0, 0,
VE,
"profile" },
1281 {
"vendor",
"vendor ID",
OFFSET(vendor),
1283 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1288 0, 0,
VE,
"quant_mat" },
1290 0, 0,
VE,
"quant_mat" },
1292 0, 0,
VE,
"quant_mat" },
1294 0, 0,
VE,
"quant_mat" },
1296 0, 0,
VE,
"quant_mat" },
1298 0, 0,
VE,
"quant_mat" },
1300 { .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)
#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)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
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)
av_cold void ff_proresdsp_init(ProresDSPContext *dsp)
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.
uint8_t dct_permutation[64]
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.
main external API structure.
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').
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
#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)
static const uint16_t scale[4]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int est_alpha_diff(int cur, int prev, int abits)
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.
void(* fdct)(const uint16_t *src, int linesize, int16_t *block)
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)
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=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);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_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
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)