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 181 int16_t custom_q[64];
190 int16_t custom_q[64];
195 ptrdiff_t linesize, int16_t *
block);
201 int num_chroma_blocks, chroma_factor;
226 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
227 int16_t *blocks, uint16_t *emu_buf,
228 int mbs_per_slice,
int blocks_per_mb,
int is_chroma)
230 const uint16_t *esrc;
231 const int mb_width = 4 * blocks_per_mb;
235 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
237 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
241 if (x + mb_width <= w && y + 16 <= h) {
243 elinesize = linesize;
248 elinesize = 16 *
sizeof(*emu_buf);
250 bw =
FFMIN(w - x, mb_width);
251 bh =
FFMIN(h - y, 16);
253 for (j = 0; j < bh; j++) {
254 memcpy(emu_buf + j * 16,
255 (
const uint8_t*)src + j * linesize,
257 pix = emu_buf[j * 16 + bw - 1];
258 for (k = bw; k < mb_width; k++)
259 emu_buf[j * 16 + k] = pix;
262 memcpy(emu_buf + j * 16,
263 emu_buf + (bh - 1) * 16,
264 mb_width *
sizeof(*emu_buf));
267 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
269 if (blocks_per_mb > 2) {
270 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
273 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
275 if (blocks_per_mb > 2) {
276 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
280 ctx->
fdct(&ctx->
fdsp, esrc, elinesize, blocks);
282 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4, elinesize, blocks);
284 if (blocks_per_mb > 2) {
285 ctx->
fdct(&ctx->
fdsp, esrc + 8, elinesize, blocks);
287 ctx->
fdct(&ctx->
fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
297 ptrdiff_t linesize,
int x,
int y,
int w,
int h,
298 int16_t *blocks,
int mbs_per_slice,
int abits)
300 const int slice_width = 16 * mbs_per_slice;
301 int i, j, copy_w, copy_h;
303 copy_w =
FFMIN(w - x, slice_width);
304 copy_h =
FFMIN(h - y, 16);
305 for (i = 0; i < copy_h; i++) {
306 memcpy(blocks, src, copy_w *
sizeof(*src));
308 for (j = 0; j < copy_w; j++)
311 for (j = 0; j < copy_w; j++)
312 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
313 for (j = copy_w; j < slice_width; j++)
314 blocks[j] = blocks[copy_w - 1];
315 blocks += slice_width;
316 src += linesize >> 1;
318 for (; i < 16; i++) {
319 memcpy(blocks, blocks - slice_width, slice_width *
sizeof(*blocks));
320 blocks += slice_width;
329 unsigned int rice_order, exp_order, switch_bits, switch_val;
333 switch_bits = (codebook & 3) + 1;
334 rice_order = codebook >> 5;
335 exp_order = (codebook >> 2) & 7;
337 switch_val = switch_bits << rice_order;
339 if (val >= switch_val) {
340 val -= switch_val - (1 << exp_order);
343 put_bits(pb, exponent - exp_order + switch_bits, 0);
346 exponent = val >> rice_order;
356 #define GET_SIGN(x) ((x) >> 31) 357 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x)) 360 int blocks_per_slice,
int scale)
363 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
365 prev_dc = (blocks[0] - 0x4000) / scale;
371 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
372 dc = (blocks[0] - 0x4000) / scale;
373 delta = dc - prev_dc;
375 delta = (delta ^ sign) - sign;
378 codebook = (code + (code & 1)) >> 1;
379 codebook =
FFMIN(codebook, 3);
386 int blocks_per_slice,
387 int plane_size_factor,
388 const uint8_t *scan,
const int16_t *qmat)
392 int max_coeffs, abs_level;
394 max_coeffs = blocks_per_slice << 6;
399 for (i = 1; i < 64; i++) {
400 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
401 level = blocks[idx] / qmat[scan[i]];
403 abs_level =
FFABS(level);
420 const uint16_t *
src, ptrdiff_t linesize,
421 int mbs_per_slice, int16_t *blocks,
422 int blocks_per_mb,
int plane_size_factor,
425 int blocks_per_slice, saved_pos;
428 blocks_per_slice = mbs_per_slice * blocks_per_mb;
430 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
431 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
440 const int mask = (1 << abits) - 1;
441 const int dbits = (abits == 8) ? 4 : 7;
442 const int dsize = 1 << dbits - 1;
443 int diff = cur - prev;
446 if (diff >= (1 << abits) - dsize)
448 if (diff < -dsize || diff > dsize || !diff) {
473 int mbs_per_slice, uint16_t *blocks,
477 const int mask = (1 << abits) - 1;
478 const int num_coeffs = mbs_per_slice * 256;
480 int prev =
mask, cur;
497 }
while (idx < num_coeffs);
513 int slice_width_factor =
av_log2(mbs_per_slice);
514 int num_cblocks, pwidth, line_add;
516 int plane_factor, is_chroma;
530 for (i = 0; i < 64; i++)
535 is_chroma = (i == 1 || i == 2);
536 plane_factor = slice_width_factor + 2;
543 pwidth = avctx->
width;
548 pwidth = avctx->
width >> 1;
552 src = (
const uint16_t*)(pic->
data[i] + yp * linesize +
559 mbs_per_slice, num_cblocks, is_chroma);
561 mbs_per_slice, ctx->
blocks[0],
562 num_cblocks, plane_factor,
571 total_size += sizes[i];
574 "Underestimated required buffer size.\n");
583 unsigned int rice_order, exp_order, switch_bits, switch_val;
587 switch_bits = (codebook & 3) + 1;
588 rice_order = codebook >> 5;
589 exp_order = (codebook >> 2) & 7;
591 switch_val = switch_bits << rice_order;
593 if (val >= switch_val) {
594 val -= switch_val - (1 << exp_order);
597 return exponent * 2 - exp_order + switch_bits + 1;
599 return (val >> rice_order) + rice_order + 1;
603 static int estimate_dcs(
int *error, int16_t *blocks,
int blocks_per_slice,
607 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
610 prev_dc = (blocks[0] - 0x4000) / scale;
615 *error +=
FFABS(blocks[0] - 0x4000) % scale;
617 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
618 dc = (blocks[0] - 0x4000) / scale;
619 *error +=
FFABS(blocks[0] - 0x4000) % scale;
620 delta = dc - prev_dc;
622 delta = (delta ^ sign) - sign;
625 codebook = (code + (code & 1)) >> 1;
626 codebook =
FFMIN(codebook, 3);
634 static int estimate_acs(
int *error, int16_t *blocks,
int blocks_per_slice,
635 int plane_size_factor,
636 const uint8_t *scan,
const int16_t *qmat)
640 int max_coeffs, abs_level;
643 max_coeffs = blocks_per_slice << 6;
648 for (i = 1; i < 64; i++) {
649 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
650 level = blocks[idx] / qmat[scan[i]];
651 *error +=
FFABS(blocks[idx]) % qmat[scan[i]];
653 abs_level =
FFABS(level);
671 const uint16_t *
src, ptrdiff_t linesize,
673 int blocks_per_mb,
int plane_size_factor,
676 int blocks_per_slice;
679 blocks_per_slice = mbs_per_slice * blocks_per_mb;
683 plane_size_factor, ctx->
scantable, qmat);
690 const int mask = (1 << abits) - 1;
691 const int dbits = (abits == 8) ? 4 : 7;
692 const int dsize = 1 << dbits - 1;
693 int diff = cur - prev;
696 if (diff >= (1 << abits) - dsize)
698 if (diff < -dsize || diff > dsize || !diff)
705 const uint16_t *
src, ptrdiff_t linesize,
706 int mbs_per_slice,
int quant,
710 const int mask = (1 << abits) - 1;
711 const int num_coeffs = mbs_per_slice * 256;
712 int prev =
mask, cur;
736 }
while (idx < num_coeffs);
749 int trellis_node,
int x,
int y,
int mbs_per_slice,
753 int i, q, pq, xp, yp;
755 int slice_width_factor =
av_log2(mbs_per_slice);
760 int error,
bits, bits_limit;
761 int mbs, prev, cur, new_score;
765 int linesize[4], line_add;
771 mbs = x + mbs_per_slice;
774 is_chroma[i] = (i == 1 || i == 2);
775 plane_factor[i] = slice_width_factor + 2;
782 pwidth = avctx->
width;
787 pwidth = avctx->
width >> 1;
791 src = (
const uint16_t *)(ctx->
pic->
data[i] + yp * linesize[i] +
798 mbs_per_slice, num_cblocks[i], is_chroma[i]);
806 for (q = min_quant; q < max_quant + 2; q++) {
812 for (q = min_quant; q <=
max_quant; q++) {
819 num_cblocks[i], plane_factor[i],
824 mbs_per_slice, q, td->
blocks[3]);
825 if (bits > 65000 * 8)
828 slice_bits[q] =
bits;
829 slice_score[q] = error;
831 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
832 slice_bits[max_quant + 1] = slice_bits[
max_quant];
833 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
836 for (q = max_quant + 1; q < 128; q++) {
843 for (i = 0; i < 64; i++)
850 num_cblocks[i], plane_factor[i],
855 mbs_per_slice, q, td->
blocks[3]);
856 if (bits <= ctx->bits_per_mb * mbs_per_slice)
860 slice_bits[max_quant + 1] =
bits;
861 slice_score[max_quant + 1] = error;
864 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
867 for (pq = min_quant; pq < max_quant + 2; pq++) {
870 for (q = min_quant; q < max_quant + 2; q++) {
871 cur = trellis_node + q;
873 bits = td->
nodes[prev].
bits + slice_bits[q];
874 error = slice_score[q];
875 if (bits > bits_limit)
894 for (q = min_quant + 1; q < max_quant + 2; q++) {
895 if (td->
nodes[trellis_node + q].
score <= error) {
897 pq = trellis_node + q;
905 int jobnr,
int threadnr)
910 int x, y = jobnr, mb, q = 0;
912 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
913 while (ctx->
mb_width - x < mbs_per_slice)
929 const AVFrame *pic,
int *got_packet)
932 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *
tmp;
935 int x, y, i, mb, q = 0;
936 int sizes[4] = { 0 };
937 int slice_hdr_size = 2 + 2 * (ctx->
num_planes - 1);
939 int pkt_size, ret, max_slice_size = 0;
943 #if FF_API_CODED_FRAME 957 orig_buf = pkt->
data;
961 bytestream_put_be32 (&orig_buf,
FRAME_ID);
967 bytestream_put_be16 (&buf, 0);
969 bytestream_put_be16 (&buf, avctx->
width);
970 bytestream_put_be16 (&buf, avctx->
height);
975 bytestream_put_byte (&buf, frame_flags);
977 bytestream_put_byte (&buf, 0);
979 bytestream_put_byte (&buf, avctx->
color_trc);
980 bytestream_put_byte (&buf, avctx->
colorspace);
981 bytestream_put_byte (&buf, 0x40 | (ctx->
alpha_bits >> 3));
982 bytestream_put_byte (&buf, 0);
984 bytestream_put_byte (&buf, 0x03);
986 for (i = 0; i < 64; i++)
987 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
989 for (i = 0; i < 64; i++)
990 bytestream_put_byte(&buf, ctx->
quant_mat[i]);
992 bytestream_put_byte (&buf, 0x00);
994 bytestream_put_be16 (&tmp, buf - orig_buf);
1000 picture_size_pos = buf + 1;
1001 bytestream_put_byte (&buf, 0x40);
1020 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
1024 while (ctx->
mb_width - x < mbs_per_slice)
1025 mbs_per_slice >>= 1;
1027 bytestream_put_byte(&buf, slice_hdr_size << 3);
1029 buf += slice_hdr_size - 1;
1030 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1038 delta =
FFMAX(delta, 2 * max_slice_size);
1043 "Packet too small: is %i," 1044 " needs %i (slice: %i). " 1045 "Correct allocation",
1046 pkt_size, delta, max_slice_size);
1056 orig_buf = pkt->
data + (orig_buf - start);
1057 buf = pkt->
data + (buf - start);
1058 picture_size_pos = pkt->
data + (picture_size_pos - start);
1059 slice_sizes = pkt->
data + (slice_sizes - start);
1060 slice_hdr = pkt->
data + (slice_hdr - start);
1061 tmp = pkt->
data + (tmp - start);
1069 bytestream_put_byte(&slice_hdr, q);
1070 slice_size = slice_hdr_size + sizes[ctx->
num_planes - 1];
1072 bytestream_put_be16(&slice_hdr, sizes[i]);
1073 slice_size += sizes[i];
1075 bytestream_put_be16(&slice_sizes, slice_size);
1076 buf += slice_size - slice_hdr_size;
1077 if (max_slice_size < slice_size)
1078 max_slice_size = slice_size;
1083 picture_size = buf - picture_size_pos - 6;
1085 picture_size = buf - picture_size_pos + 1;
1086 bytestream_put_be32(&picture_size_pos, picture_size);
1090 frame_size = buf - orig_buf;
1091 bytestream_put_be32(&orig_buf, frame_size);
1116 ptrdiff_t linesize, int16_t *
block)
1119 const uint16_t *tsrc =
src;
1121 for (y = 0; y < 8; y++) {
1122 for (x = 0; x < 8; x++)
1123 block[y * 8 + x] = tsrc[x];
1124 tsrc += linesize >> 1;
1145 if (mps & (mps - 1)) {
1147 "there should be an integer power of two MBs per slice\n");
1183 if (strlen(ctx->
vendor) != 4) {
1204 for (j = 0; j < 64; j++)
1228 for (i = min_quant; i < max_quant + 2; i++) {
1242 for (j = 0; j < 64; j++) {
1269 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1278 #define OFFSET(x) offsetof(ProresContext, x) 1279 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1282 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1288 0, 0,
VE,
"profile" },
1290 0, 0,
VE,
"profile" },
1292 0, 0,
VE,
"profile" },
1294 0, 0,
VE,
"profile" },
1296 0, 0,
VE,
"profile" },
1297 {
"vendor",
"vendor ID",
OFFSET(vendor),
1299 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
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 0, 0,
VE,
"quant_mat" },
1316 { .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 AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#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]
static const uint8_t frame_size[4]
static int estimate_vlc(unsigned codebook, int val)
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
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)
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.
static const int prores_mb_limits[NUM_MB_LIMITS]
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
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]
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
static int estimate_slice_plane(ProresContext *ctx, int *error, int plane, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int blocks_per_mb, int plane_size_factor, const int16_t *qmat, ProresThreadData *td)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
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.
static void get_alpha_data(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int x, int y, int w, int h, int16_t *blocks, int mbs_per_slice, int abits)
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 int encode_slice_plane(ProresContext *ctx, PutBitContext *pb, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int16_t *blocks, int blocks_per_mb, int plane_size_factor, const int16_t *qmat)
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]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
const struct prores_profile * profile_info
int flags
AV_CODEC_FLAG_*.
static int estimate_alpha_plane(ProresContext *ctx, int *error, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int quant, int16_t *blocks)
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
static void get_slice_data(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int x, int y, int w, int h, int16_t *blocks, uint16_t *emu_buf, int mbs_per_slice, int blocks_per_mb, int is_chroma)
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)
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
enum AVPictureType pict_type
Picture type of the frame.
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.
void(* fdct)(int16_t *block)
#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)
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
static const AVOption options[]
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.
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(WINAPI *cond_broadcast)(pthread_cond_t *cond)
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 enum AVPixelFormat pix_fmts[]
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;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);return NULL;} return ac;} 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;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->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);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
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)
int br_tab[NUM_MB_LIMITS]
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static av_cold int init(AVCodecParserContext *s)
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
#define FF_ENABLE_DEPRECATION_WARNINGS
int top_field_first
If the content is interlaced, is top field displayed first.
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 int find_slice_quant(AVCodecContext *avctx, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
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 ...
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)