26 #include "libavutil/opt.h"
27 #include "libavutil/pixdesc.h"
36 #define CFACTOR_Y422 2
37 #define CFACTOR_Y444 3
39 #define MAX_MBS_PER_SLICE 8
61 4, 7, 9, 11, 13, 14, 15, 63,
62 7, 7, 11, 12, 14, 15, 63, 63,
63 9, 11, 13, 14, 15, 63, 63, 63,
64 11, 11, 13, 14, 63, 63, 63, 63,
65 11, 13, 14, 63, 63, 63, 63, 63,
66 13, 14, 63, 63, 63, 63, 63, 63,
67 13, 63, 63, 63, 63, 63, 63, 63,
68 63, 63, 63, 63, 63, 63, 63, 63,
71 4, 5, 6, 7, 9, 11, 13, 15,
72 5, 5, 7, 8, 11, 13, 15, 17,
73 6, 7, 9, 11, 13, 15, 15, 17,
74 7, 7, 9, 11, 13, 15, 17, 19,
75 7, 9, 11, 13, 14, 16, 19, 23,
76 9, 11, 13, 14, 16, 19, 23, 29,
77 9, 11, 13, 15, 17, 21, 28, 35,
78 11, 13, 16, 17, 21, 28, 35, 41,
81 4, 4, 5, 5, 6, 7, 7, 9,
82 4, 4, 5, 6, 7, 7, 9, 9,
83 5, 5, 6, 7, 7, 9, 9, 10,
84 5, 5, 6, 7, 7, 9, 9, 10,
85 5, 6, 7, 7, 8, 9, 10, 12,
86 6, 7, 7, 8, 9, 10, 12, 15,
87 6, 7, 7, 9, 10, 11, 14, 17,
88 7, 7, 9, 10, 11, 14, 17, 21,
91 4, 4, 4, 4, 4, 4, 4, 4,
92 4, 4, 4, 4, 4, 4, 4, 4,
93 4, 4, 4, 4, 4, 4, 4, 4,
94 4, 4, 4, 4, 4, 4, 4, 5,
95 4, 4, 4, 4, 4, 4, 5, 5,
96 4, 4, 4, 4, 4, 5, 5, 6,
97 4, 4, 4, 4, 5, 5, 6, 7,
98 4, 4, 4, 4, 5, 6, 7, 7,
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,
106 4, 4, 4, 4, 4, 4, 4, 4,
107 4, 4, 4, 4, 4, 4, 4, 4,
108 4, 4, 4, 4, 4, 4, 4, 4,
112 #define NUM_MB_LIMITS 4
130 .tag =
MKTAG(
'a',
'p',
'c',
'o'),
133 .br_tab = { 300, 242, 220, 194 },
138 .tag =
MKTAG(
'a',
'p',
'c',
's'),
141 .br_tab = { 720, 560, 490, 440 },
145 .full_name =
"standard",
146 .tag =
MKTAG(
'a',
'p',
'c',
'n'),
149 .br_tab = { 1050, 808, 710, 632 },
153 .full_name =
"high quality",
154 .tag =
MKTAG(
'a',
'p',
'c',
'h'),
157 .br_tab = { 1566, 1216, 1070, 950 },
162 .tag =
MKTAG(
'a',
'p',
'4',
'h'),
165 .br_tab = { 2350, 1828, 1600, 1425 },
170 #define TRELLIS_WIDTH 16
171 #define SCORE_LIMIT INT_MAX / 2
180 #define MAX_STORED_Q 16
226 int 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->
dsp.
fdct(esrc, elinesize, blocks);
269 if (blocks_per_mb > 2) {
270 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
273 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
275 if (blocks_per_mb > 2) {
276 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
280 ctx->
dsp.
fdct(esrc, elinesize, blocks);
282 ctx->
dsp.
fdct(esrc + elinesize * 4, elinesize, blocks);
284 if (blocks_per_mb > 2) {
285 ctx->
dsp.
fdct(esrc + 8, elinesize, blocks);
287 ctx->
dsp.
fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
297 int 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,
int 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 const uint16_t *
src,
int linesize,
474 int mbs_per_slice, uint16_t *blocks,
478 const int mask = (1 << abits) - 1;
479 const int num_coeffs = mbs_per_slice * 256;
481 int prev =
mask, cur;
498 }
while (idx < num_coeffs);
514 int slice_width_factor =
av_log2(mbs_per_slice);
515 int num_cblocks, pwidth, linesize, 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,
569 mbs_per_slice, ctx->
blocks[0],
572 total_size += sizes[i];
579 unsigned int rice_order, exp_order, switch_bits, switch_val;
583 switch_bits = (codebook & 3) + 1;
584 rice_order = codebook >> 5;
585 exp_order = (codebook >> 2) & 7;
587 switch_val = switch_bits << rice_order;
589 if (val >= switch_val) {
590 val -= switch_val - (1 << exp_order);
593 return exponent * 2 - exp_order + switch_bits + 1;
595 return (val >> rice_order) + rice_order + 1;
599 static int estimate_dcs(
int *error, int16_t *blocks,
int blocks_per_slice,
603 int codebook = 3, code,
dc, prev_dc,
delta, sign, new_sign;
606 prev_dc = (blocks[0] - 0x4000) / scale;
613 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
614 dc = (blocks[0] - 0x4000) / scale;
616 delta = dc - prev_dc;
618 delta = (delta ^ sign) - sign;
621 codebook = (code + (code & 1)) >> 1;
622 codebook =
FFMIN(codebook, 3);
630 static int estimate_acs(
int *error, int16_t *blocks,
int blocks_per_slice,
631 int plane_size_factor,
632 const uint8_t *scan,
const int16_t *qmat)
636 int max_coeffs, abs_level;
639 max_coeffs = blocks_per_slice << 6;
644 for (i = 1; i < 64; i++) {
645 for (idx = scan[i]; idx < max_coeffs; idx += 64) {
646 level = blocks[idx] / qmat[scan[i]];
647 *error +=
FFABS(blocks[idx]) % qmat[scan[i]];
649 abs_level =
FFABS(level);
667 const uint16_t *
src,
int linesize,
669 int blocks_per_mb,
int plane_size_factor,
672 int blocks_per_slice;
675 blocks_per_slice = mbs_per_slice * blocks_per_mb;
686 const int mask = (1 << abits) - 1;
687 const int dbits = (abits == 8) ? 4 : 7;
688 const int dsize = 1 << dbits - 1;
689 int diff = cur - prev;
692 if (diff >= (1 << abits) - dsize)
694 if (diff < -dsize || diff > dsize || !diff)
701 const uint16_t *
src,
int linesize,
702 int mbs_per_slice,
int quant,
706 const int mask = (1 << abits) - 1;
707 const int num_coeffs = mbs_per_slice * 256;
708 int prev =
mask, cur;
732 }
while (idx < num_coeffs);
745 int trellis_node,
int x,
int y,
int mbs_per_slice,
749 int i, q, pq, xp, yp;
751 int slice_width_factor =
av_log2(mbs_per_slice);
756 int error,
bits, bits_limit;
757 int mbs, prev, cur, new_score;
761 int linesize[4], line_add;
767 mbs = x + mbs_per_slice;
770 is_chroma[i] = (i == 1 || i == 2);
771 plane_factor[i] = slice_width_factor + 2;
778 pwidth = avctx->
width;
783 pwidth = avctx->
width >> 1;
787 src = (
const uint16_t*)(pic->
data[i] + yp * linesize[i] +
794 mbs_per_slice, num_cblocks[i], is_chroma[i]);
802 for (q = min_quant; q < max_quant + 2; q++) {
808 for (q = min_quant; q <=
max_quant; q++) {
815 num_cblocks[i], plane_factor[i],
820 mbs_per_slice, q, td->
blocks[3]);
821 if (bits > 65000 * 8) {
825 slice_bits[q] =
bits;
826 slice_score[q] = error;
828 if (slice_bits[max_quant] <= ctx->
bits_per_mb * mbs_per_slice) {
829 slice_bits[max_quant + 1] = slice_bits[
max_quant];
830 slice_score[max_quant + 1] = slice_score[
max_quant] + 1;
833 for (q = max_quant + 1; q < 128; q++) {
840 for (i = 0; i < 64; i++)
847 num_cblocks[i], plane_factor[i],
852 mbs_per_slice, q, td->
blocks[3]);
853 if (bits <= ctx->bits_per_mb * mbs_per_slice)
857 slice_bits[max_quant + 1] =
bits;
858 slice_score[max_quant + 1] = error;
861 td->
nodes[trellis_node + max_quant + 1].
quant = overquant;
864 for (pq = min_quant; pq < max_quant + 2; pq++) {
867 for (q = min_quant; q < max_quant + 2; q++) {
868 cur = trellis_node + q;
870 bits = td->
nodes[prev].
bits + slice_bits[q];
871 error = slice_score[q];
872 if (bits > bits_limit)
891 for (q = min_quant + 1; q < max_quant + 2; q++) {
892 if (td->
nodes[trellis_node + q].
score <= error) {
894 pq = trellis_node + q;
902 int jobnr,
int threadnr)
907 int x,
y = jobnr,
mb, q = 0;
909 for (x = mb = 0; x < ctx->
mb_width; x += mbs_per_slice, mb++) {
910 while (ctx->
mb_width - x < mbs_per_slice)
926 const AVFrame *pic,
int *got_packet)
929 uint8_t *orig_buf, *
buf, *slice_hdr, *slice_sizes, *tmp;
932 int x,
y, i,
mb, q = 0;
933 int sizes[4] = { 0 };
934 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;
1035 picture_size = buf - (picture_size_pos - 1);
1036 bytestream_put_be32(&picture_size_pos, picture_size);
1040 frame_size = buf - orig_buf;
1041 bytestream_put_be32(&orig_buf, frame_size);
1086 if (mps & (mps - 1)) {
1088 "there should be an integer power of two MBs per slice\n");
1123 if (strlen(ctx->
vendor) != 4) {
1144 for (j = 0; j < 64; j++)
1168 for (i = min_quant; i < max_quant + 2; i++) {
1182 for (j = 0; j < 64; j++) {
1203 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1212 #define OFFSET(x) offsetof(ProresContext, x)
1213 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1216 {
"mbs_per_slice",
"macroblocks per slice",
OFFSET(mbs_per_slice),
1222 0, 0,
VE,
"profile" },
1224 0, 0,
VE,
"profile" },
1226 0, 0,
VE,
"profile" },
1228 0, 0,
VE,
"profile" },
1230 0, 0,
VE,
"profile" },
1231 {
"vendor",
"vendor ID",
OFFSET(vendor),
1233 {
"bits_per_mb",
"desired bits per macroblock",
OFFSET(bits_per_mb),
1238 0, 0,
VE,
"quant_mat" },
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 { .i64 = 16 }, 0, 16,
VE },
1262 .
name =
"prores_ks",
static const AVClass proresenc_class
#define MAX_MBS_PER_SLICE
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
const char const char void * val
This structure describes decoded (raw) audio or video data.
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)
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static av_cold int encode_init(AVCodecContext *avctx)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define LIBAVUTIL_VERSION_INT
const uint8_t ff_prores_ac_codebook[7]
static av_cold int init(AVCodecContext *avctx)
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
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)
av_cold void ff_proresdsp_init(ProresDSPContext *dsp, AVCodecContext *avctx)
#define DECLARE_ALIGNED(n, t, v)
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
unsigned mb_height
height of the current picture in mb
static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static av_cold int encode_close(AVCodecContext *avctx)
int16_t quants[MAX_STORED_Q][64]
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, const uint16_t *src, int linesize, int mbs_per_slice, uint16_t *blocks, int quant)
#define AV_PIX_FMT_YUVA444P10
const char * av_default_item_name(void *ctx)
Return the context name.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static int estimate_vlc(unsigned codebook, int val)
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, int mbs_per_slice)
const char * name
Name of the codec implementation.
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]
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)
const OptionDef options[]
static int est_alpha_diff(int cur, int prev, int abits)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static const uint8_t frame_size[4]
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
unsigned mb_width
width of the current picture in mb
#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(). ...
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){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));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);ff_audio_convert_init_arm(ac);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
static const uint16_t mask[17]
static const int sizes[][2]
struct prores_profile * profile_info
#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.
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)
Libavcodec external API header.
AVPixelFormat
Pixel format.
static const int prores_mb_limits[NUM_MB_LIMITS]
int flags
A combination of AV_PKT_FLAG values.
struct TrellisNode * nodes
static int put_bits_count(PutBitContext *s)
static void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
Write an unsigned rice/exp golomb codeword.
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.
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
const uint8_t ff_prores_dc_codebook[4]
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
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)
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
int AC3_NAME() encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
static int estimate_alpha_plane(ProresContext *ctx, int *error, const uint16_t *src, int linesize, int mbs_per_slice, int quant, int16_t *blocks)
const uint8_t ff_prores_interlaced_scan[64]
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.
#define MKTAG(a, b, c, d)
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
AVFrame * coded_frame
the picture in the bitstream
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static struct prores_profile prores_profile_info[5]
int global_quality
Global quality for codecs which cannot change it per frame.
static const uint16_t scale[4]
int br_tab[NUM_MB_LIMITS]
static void put_alpha_run(PutBitContext *pb, int run)
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
static const uint8_t prores_quant_matrices[][64]
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
#define AV_PIX_FMT_YUV444P10
static int find_quant_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
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)
#define AVERROR_INVALIDDATA
int top_field_first
If the content is interlaced, is top field displayed first.
void(* fdct)(int16_t *block)
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.
int key_frame
1 -> keyframe, 0-> not
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
#define AV_PIX_FMT_YUV422P10
AVCodec ff_prores_ks_encoder
const uint8_t * quant_mat
int frame_size_upper_bound
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
This structure stores compressed data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice, int scale)
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...