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);
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->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
267 if (blocks_per_mb > 2) {
268 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
271 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
273 if (blocks_per_mb > 2) {
274 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
278 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
280 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
282 if (blocks_per_mb > 2) {
283 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
285 ctx->
fdct(&ctx->
fdsp, 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 const uint16_t *src,
int linesize,
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,
567 mbs_per_slice, ctx->
blocks[0],
570 total_size += sizes[i];
577 unsigned int rice_order, exp_order, switch_bits, switch_val;
581 switch_bits = (codebook & 3) + 1;
582 rice_order = codebook >> 5;
583 exp_order = (codebook >> 2) & 7;
585 switch_val = switch_bits << rice_order;
587 if (val >= switch_val) {
588 val -= switch_val - (1 << exp_order);
591 return exponent * 2 - exp_order + switch_bits + 1;
593 return (val >> rice_order) + rice_order + 1;
597 static int estimate_dcs(
int *error, int16_t *blocks,
int blocks_per_slice,
601 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
604 prev_dc = (blocks[0] - 0x4000) / scale;
609 *error +=
FFABS(blocks[0] - 0x4000) % scale;
611 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
612 dc = (blocks[0] - 0x4000) / scale;
613 *error +=
FFABS(blocks[0] - 0x4000) % scale;
614 delta = dc - prev_dc;
616 delta = (delta ^ sign) - sign;
619 codebook = (code + (code & 1)) >> 1;
620 codebook =
FFMIN(codebook, 3);
628 static int estimate_acs(
int *error, int16_t *blocks,
int blocks_per_slice,
629 int plane_size_factor,
630 const uint8_t *scan,
const int16_t *qmat)
634 int max_coeffs, abs_level;
637 max_coeffs = blocks_per_slice << 6;
642 for (i = 1; i < 64; i++) {
643 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
644 level = blocks[idx] / qmat[scan[i]];
645 *error +=
FFABS(blocks[idx]) % qmat[scan[i]];
647 abs_level =
FFABS(level);
665 const uint16_t *src,
int linesize,
667 int blocks_per_mb,
int plane_size_factor,
670 int blocks_per_slice;
673 blocks_per_slice = mbs_per_slice * blocks_per_mb;
677 plane_size_factor, ctx->
scantable, qmat);
684 const int mask = (1 << abits) - 1;
685 const int dbits = (abits == 8) ? 4 : 7;
686 const int dsize = 1 << dbits - 1;
687 int diff = cur - prev;
690 if (diff >= (1 << abits) - dsize)
692 if (diff < -dsize || diff > dsize || !diff)
699 const uint16_t *src,
int linesize,
700 int mbs_per_slice,
int quant,
704 const int mask = (1 << abits) - 1;
705 const int num_coeffs = mbs_per_slice * 256;
706 int prev =
mask, cur;
730 }
while (idx < num_coeffs);
743 int trellis_node,
int x,
int y,
int mbs_per_slice,
747 int i, q, pq, xp, yp;
749 int slice_width_factor =
av_log2(mbs_per_slice);
754 int error,
bits, bits_limit;
755 int mbs, prev, cur, new_score;
759 int linesize[4], line_add;
765 mbs = x + mbs_per_slice;
768 is_chroma[i] = (i == 1 || i == 2);
769 plane_factor[i] = slice_width_factor + 2;
776 pwidth = avctx->
width;
781 pwidth = avctx->
width >> 1;
785 src = (
const uint16_t*)(pic->
data[i] + yp * linesize[i] +
792 mbs_per_slice, num_cblocks[i], is_chroma[i]);
800 for (q = min_quant; q < max_quant + 2; q++) {
806 for (q = min_quant; q <=
max_quant; q++) {
813 num_cblocks[i], plane_factor[i],
818 mbs_per_slice, q, td->
blocks[3]);
819 if (bits > 65000 * 8) {
823 slice_bits[q] =
bits;
824 slice_score[q] = error;
826 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
827 slice_bits[max_quant + 1] = slice_bits[
max_quant];
828 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
831 for (q = max_quant + 1; q < 128; q++) {
838 for (i = 0; i < 64; i++)
845 num_cblocks[i], plane_factor[i],
850 mbs_per_slice, q, td->
blocks[3]);
851 if (bits <= ctx->bits_per_mb * mbs_per_slice)
855 slice_bits[max_quant + 1] =
bits;
856 slice_score[max_quant + 1] = error;
859 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
862 for (pq = min_quant; pq < max_quant + 2; pq++) {
865 for (q = min_quant; q < max_quant + 2; q++) {
866 cur = trellis_node + q;
868 bits = td->
nodes[prev].
bits + slice_bits[q];
869 error = slice_score[q];
870 if (bits > bits_limit)
889 for (q = min_quant + 1; q < max_quant + 2; q++) {
890 if (td->
nodes[trellis_node + q].
score <= error) {
892 pq = trellis_node + q;
900 int jobnr,
int threadnr)
905 int x, y = jobnr, mb, q = 0;
907 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
908 while (ctx->
mb_width - x < mbs_per_slice)
924 const AVFrame *pic,
int *got_packet)
927 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
930 int x, y, i, mb, q = 0;
931 int sizes[4] = { 0 };
932 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
948 orig_buf = pkt->
data;
952 bytestream_put_be32 (&orig_buf,
FRAME_ID);
958 bytestream_put_be16 (&buf, 0);
960 bytestream_put_be16 (&buf, avctx->
width);
961 bytestream_put_be16 (&buf, avctx->
height);
966 bytestream_put_byte (&buf, frame_flags);
968 bytestream_put_byte (&buf, 0);
970 bytestream_put_byte (&buf, avctx->
color_trc);
971 bytestream_put_byte (&buf, avctx->
colorspace);
972 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
973 bytestream_put_byte (&buf, 0);
975 bytestream_put_byte (&buf, 0x03);
977 for (i = 0; i < 64; i++)
978 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
980 for (i = 0; i < 64; i++)
981 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
983 bytestream_put_byte (&buf, 0x00);
985 bytestream_put_be16 (&tmp, buf - orig_buf);
991 picture_size_pos = buf + 1;
992 bytestream_put_byte (&buf, 0x40);
1011 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1015 while (ctx->
mb_width - x < mbs_per_slice)
1016 mbs_per_slice >>= 1;
1018 bytestream_put_byte(&buf, slice_hdr_size << 3);
1020 buf += slice_hdr_size - 1;
1022 encode_slice(avctx, pic, &pb, sizes, x, y, q, mbs_per_slice);
1024 bytestream_put_byte(&slice_hdr, q);
1025 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1027 bytestream_put_be16(&slice_hdr, sizes[i]);
1028 slice_size += sizes[i];
1030 bytestream_put_be16(&slice_sizes, slice_size);
1031 buf += slice_size - slice_hdr_size;
1036 picture_size = buf - picture_size_pos - 6;
1038 picture_size = buf - picture_size_pos + 1;
1039 bytestream_put_be32(&picture_size_pos, picture_size);
1043 frame_size = buf - orig_buf;
1044 bytestream_put_be32(&orig_buf, frame_size);
1071 int linesize, int16_t *
block)
1074 const uint16_t *tsrc = src;
1076 for (y = 0; y < 8; y++) {
1077 for (x = 0; x < 8; x++)
1078 block[y * 8 + x] = tsrc[x];
1079 tsrc += linesize >> 1;
1103 if (mps & (mps - 1)) {
1105 "there should be an integer power of two MBs per slice\n");
1140 if (strlen(ctx->
vendor) != 4) {
1161 for (j = 0; j < 64; j++)
1185 for (i = min_quant; i < max_quant + 2; i++) {
1199 for (j = 0; j < 64; j++) {
1220 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1229 #define OFFSET(x) offsetof(ProresContext, x)
1230 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1233 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1239 0, 0,
VE,
"profile" },
1241 0, 0,
VE,
"profile" },
1243 0, 0,
VE,
"profile" },
1245 0, 0,
VE,
"profile" },
1247 0, 0,
VE,
"profile" },
1248 {
"vendor",
"vendor ID",
OFFSET(vendor),
1250 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1255 0, 0,
VE,
"quant_mat" },
1257 0, 0,
VE,
"quant_mat" },
1259 0, 0,
VE,
"quant_mat" },
1261 0, 0,
VE,
"quant_mat" },
1263 0, 0,
VE,
"quant_mat" },
1265 0, 0,
VE,
"quant_mat" },
1267 { .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)
#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...
#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 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.
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').
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)
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)