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
223 int linesize,
int x,
int y,
int w,
int h,
224 int16_t *blocks, uint16_t *emu_buf,
225 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
227 const uint16_t *esrc;
228 const int mb_width = 4 * blocks_per_mb;
232 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
234 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
238 if (x + mb_width <= w && y + 16 <= h) {
240 elinesize = linesize;
245 elinesize = 16 *
sizeof(*emu_buf);
247 bw =
FFMIN(w - x, mb_width);
248 bh =
FFMIN(h - y, 16);
250 for (j = 0; j < bh; j++) {
251 memcpy(emu_buf + j * 16,
252 (
const uint8_t*)src + j * linesize,
254 pix = emu_buf[j * 16 + bw - 1];
255 for (k = bw; k < mb_width; k++)
256 emu_buf[j * 16 + k] = pix;
259 memcpy(emu_buf + j * 16,
260 emu_buf + (bh - 1) * 16,
261 mb_width *
sizeof(*emu_buf));
264 ctx->
dsp.
fdct(esrc, elinesize, blocks);
266 if (blocks_per_mb > 2) {
267 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
270 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
272 if (blocks_per_mb > 2) {
273 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
277 ctx->
dsp.
fdct(esrc, elinesize, blocks);
279 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
281 if (blocks_per_mb > 2) {
282 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
284 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
294 int linesize,
int x,
int y,
int w,
int h,
295 int16_t *blocks,
int mbs_per_slice,
int abits)
297 const int slice_width = 16 * mbs_per_slice;
298 int i, j, copy_w, copy_h;
300 copy_w =
FFMIN(w - x, slice_width);
301 copy_h =
FFMIN(h - y, 16);
302 for (i = 0; i < copy_h; i++) {
303 memcpy(blocks, src, copy_w *
sizeof(*src));
305 for (j = 0; j < copy_w; j++)
308 for (j = 0; j < copy_w; j++)
309 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
310 for (j = copy_w; j < slice_width; j++)
311 blocks[j] = blocks[copy_w - 1];
312 blocks += slice_width;
313 src += linesize >> 1;
315 for (; i < 16; i++) {
316 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
317 blocks += slice_width;
326 unsigned int rice_order, exp_order, switch_bits, switch_val;
330 switch_bits = (codebook & 3) + 1;
331 rice_order = codebook >> 5;
332 exp_order = (codebook >> 2) & 7;
334 switch_val = switch_bits << rice_order;
336 if (val >= switch_val) {
337 val -= switch_val - (1 << exp_order);
340 put_bits(pb, exponent - exp_order + switch_bits, 0);
343 exponent = val >> rice_order;
353 #define GET_SIGN(x) ((x) >> 31)
354 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
357 int blocks_per_slice,
int scale)
360 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
362 prev_dc = (blocks[0] - 0x4000) / scale;
368 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
369 dc = (blocks[0] - 0x4000) / scale;
370 delta = dc - prev_dc;
372 delta = (delta ^ sign) - sign;
375 codebook = (code + (code & 1)) >> 1;
376 codebook =
FFMIN(codebook, 3);
383 int blocks_per_slice,
384 int plane_size_factor,
385 const uint8_t *scan,
const int16_t *qmat)
389 int max_coeffs, abs_level;
391 max_coeffs = blocks_per_slice << 6;
396 for (i = 1; i < 64; i++) {
397 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
398 level = blocks[idx] / qmat[scan[i]];
400 abs_level =
FFABS(level);
417 const uint16_t *src,
int linesize,
418 int mbs_per_slice, int16_t *blocks,
419 int blocks_per_mb,
int plane_size_factor,
422 int blocks_per_slice, saved_pos;
425 blocks_per_slice = mbs_per_slice * blocks_per_mb;
427 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
428 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
437 const int mask = (1 << abits) - 1;
438 const int dbits = (abits == 8) ? 4 : 7;
439 const int dsize = 1 << dbits - 1;
440 int diff = cur - prev;
443 if (diff >= (1 << abits) - dsize)
445 if (diff < -dsize || diff > dsize || !diff) {
470 const uint16_t *src,
int linesize,
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,
566 mbs_per_slice, ctx->
blocks[0],
569 total_size += sizes[i];
576 unsigned int rice_order, exp_order, switch_bits, switch_val;
580 switch_bits = (codebook & 3) + 1;
581 rice_order = codebook >> 5;
582 exp_order = (codebook >> 2) & 7;
584 switch_val = switch_bits << rice_order;
586 if (val >= switch_val) {
587 val -= switch_val - (1 << exp_order);
590 return exponent * 2 - exp_order + switch_bits + 1;
592 return (val >> rice_order) + rice_order + 1;
596 static int estimate_dcs(
int *error, int16_t *blocks,
int blocks_per_slice,
600 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
603 prev_dc = (blocks[0] - 0x4000) / scale;
610 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
611 dc = (blocks[0] - 0x4000) / scale;
613 delta = dc - prev_dc;
615 delta = (delta ^ sign) - sign;
618 codebook = (code + (code & 1)) >> 1;
619 codebook =
FFMIN(codebook, 3);
627 static int estimate_acs(
int *error, int16_t *blocks,
int blocks_per_slice,
628 int plane_size_factor,
629 const uint8_t *scan,
const int16_t *qmat)
633 int max_coeffs, abs_level;
636 max_coeffs = blocks_per_slice << 6;
641 for (i = 1; i < 64; i++) {
642 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
643 level = blocks[idx] / qmat[scan[i]];
644 *error +=
FFABS(blocks[idx]) % qmat[scan[i]];
646 abs_level =
FFABS(level);
664 const uint16_t *src,
int linesize,
666 int blocks_per_mb,
int plane_size_factor,
669 int blocks_per_slice;
672 blocks_per_slice = mbs_per_slice * blocks_per_mb;
683 const int mask = (1 << abits) - 1;
684 const int dbits = (abits == 8) ? 4 : 7;
685 const int dsize = 1 << dbits - 1;
686 int diff = cur - prev;
689 if (diff >= (1 << abits) - dsize)
691 if (diff < -dsize || diff > dsize || !diff)
698 const uint16_t *src,
int linesize,
699 int mbs_per_slice,
int quant,
703 const int mask = (1 << abits) - 1;
704 const int num_coeffs = mbs_per_slice * 256;
705 int prev =
mask, cur;
729 }
while (idx < num_coeffs);
742 int trellis_node,
int x,
int y,
int mbs_per_slice,
746 int i, q, pq, xp, yp;
748 int slice_width_factor =
av_log2(mbs_per_slice);
753 int error,
bits, bits_limit;
754 int mbs, prev, cur, new_score;
758 int linesize[4], line_add;
764 mbs = x + mbs_per_slice;
767 is_chroma[i] = (i == 1 || i == 2);
768 plane_factor[i] = slice_width_factor + 2;
775 pwidth = avctx->
width;
780 pwidth = avctx->
width >> 1;
784 src = (
const uint16_t*)(pic->
data[i] + yp * linesize[i] +
791 mbs_per_slice, num_cblocks[i], is_chroma[i]);
799 for (q = min_quant; q < max_quant + 2; q++) {
805 for (q = min_quant; q <=
max_quant; q++) {
812 num_cblocks[i], plane_factor[i],
817 mbs_per_slice, q, td->
blocks[3]);
818 if (bits > 65000 * 8) {
822 slice_bits[q] =
bits;
823 slice_score[q] = error;
825 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
826 slice_bits[max_quant + 1] = slice_bits[
max_quant];
827 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
830 for (q = max_quant + 1; q < 128; q++) {
837 for (i = 0; i < 64; i++)
844 num_cblocks[i], plane_factor[i],
849 mbs_per_slice, q, td->
blocks[3]);
850 if (bits <= ctx->bits_per_mb * mbs_per_slice)
854 slice_bits[max_quant + 1] =
bits;
855 slice_score[max_quant + 1] = error;
858 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
861 for (pq = min_quant; pq < max_quant + 2; pq++) {
864 for (q = min_quant; q < max_quant + 2; q++) {
865 cur = trellis_node + q;
867 bits = td->
nodes[prev].
bits + slice_bits[q];
868 error = slice_score[q];
869 if (bits > bits_limit)
888 for (q = min_quant + 1; q < max_quant + 2; q++) {
889 if (td->
nodes[trellis_node + q].
score <= error) {
891 pq = trellis_node + q;
899 int jobnr,
int threadnr)
904 int x, y = jobnr, mb, q = 0;
906 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
907 while (ctx->
mb_width - x < mbs_per_slice)
923 const AVFrame *pic,
int *got_packet)
926 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
929 int x, y, i, mb, q = 0;
930 int sizes[4] = { 0 };
931 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
947 orig_buf = pkt->
data;
951 bytestream_put_be32 (&orig_buf,
FRAME_ID);
957 bytestream_put_be16 (&buf, 0);
959 bytestream_put_be16 (&buf, avctx->
width);
960 bytestream_put_be16 (&buf, avctx->
height);
965 bytestream_put_byte (&buf, frame_flags);
967 bytestream_put_byte (&buf, 0);
969 bytestream_put_byte (&buf, avctx->
color_trc);
970 bytestream_put_byte (&buf, avctx->
colorspace);
971 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
972 bytestream_put_byte (&buf, 0);
974 bytestream_put_byte (&buf, 0x03);
976 for (i = 0; i < 64; i++)
977 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
979 for (i = 0; i < 64; i++)
980 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
982 bytestream_put_byte (&buf, 0x00);
984 bytestream_put_be16 (&tmp, buf - orig_buf);
990 picture_size_pos = buf + 1;
991 bytestream_put_byte (&buf, 0x40);
1010 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1014 while (ctx->
mb_width - x < mbs_per_slice)
1015 mbs_per_slice >>= 1;
1017 bytestream_put_byte(&buf, slice_hdr_size << 3);
1019 buf += slice_hdr_size - 1;
1021 encode_slice(avctx, pic, &pb, sizes, x, y, q, mbs_per_slice);
1023 bytestream_put_byte(&slice_hdr, q);
1024 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1026 bytestream_put_be16(&slice_hdr, sizes[i]);
1027 slice_size += sizes[i];
1029 bytestream_put_be16(&slice_sizes, slice_size);
1030 buf += slice_size - slice_hdr_size;
1035 picture_size = buf - picture_size_pos - 6;
1037 picture_size = buf - picture_size_pos + 1;
1038 bytestream_put_be32(&picture_size_pos, picture_size);
1042 frame_size = buf - orig_buf;
1043 bytestream_put_be32(&orig_buf, frame_size);
1088 if (mps & (mps - 1)) {
1090 "there should be an integer power of two MBs per slice\n");
1125 if (strlen(ctx->
vendor) != 4) {
1146 for (j = 0; j < 64; j++)
1170 for (i = min_quant; i < max_quant + 2; i++) {
1184 for (j = 0; j < 64; j++) {
1205 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1214 #define OFFSET(x) offsetof(ProresContext, x)
1215 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1218 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1224 0, 0,
VE,
"profile" },
1226 0, 0,
VE,
"profile" },
1228 0, 0,
VE,
"profile" },
1230 0, 0,
VE,
"profile" },
1232 0, 0,
VE,
"profile" },
1233 {
"vendor",
"vendor ID",
OFFSET(vendor),
1235 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1240 0, 0,
VE,
"quant_mat" },
1242 0, 0,
VE,
"quant_mat" },
1244 0, 0,
VE,
"quant_mat" },
1246 0, 0,
VE,
"quant_mat" },
1248 0, 0,
VE,
"quant_mat" },
1250 0, 0,
VE,
"quant_mat" },
1252 { .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)
#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...
#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 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]
static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, const uint16_t *src, int linesize, int mbs_per_slice, uint16_t *blocks, int quant)
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)
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)
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)