49 #define UNI_MPEG4_ENC_INDEX(last, run, level) ((last) * 128 * 64 + (run) * 128 + (level))
66 int block_last_index,
uint8_t scantable[64])
72 for (j = 1; j <= block_last_index; j++) {
73 const int index = scantable[j];
77 if ((
level & (~127)) == 0) {
78 if (j < block_last_index)
83 rate +=
s->ac_esc_length;
101 const int dir[6],
uint8_t *st[6],
102 const int zigzag_last_index[6])
105 memcpy(
s->block_last_index, zigzag_last_index,
sizeof(
int) * 6);
107 for (n = 0; n < 6; n++) {
108 int16_t *ac_val = &
s->ac_val[0][0][0] +
s->block_index[n] * 16;
110 st[n] =
s->intra_scantable.permutated;
113 for (
i = 1;
i < 8;
i++)
114 block[n][
s->idsp.idct_permutation[
i]] = ac_val[
i + 8];
117 for (
i = 1;
i < 8;
i++)
118 block[n][
s->idsp.idct_permutation[
i << 3]] = ac_val[
i];
132 const int dir[6],
uint8_t *st[6],
133 int zigzag_last_index[6])
137 int8_t *
const qscale_table =
s->current_picture.qscale_table;
139 memcpy(zigzag_last_index,
s->block_last_index,
sizeof(
int) * 6);
141 for (n = 0; n < 6; n++) {
142 int16_t *ac_val, *ac_val1;
145 s->intra_scantable.permutated);
147 ac_val = &
s->ac_val[0][0][0] +
s->block_index[n] * 16;
150 const int xy =
s->mb_x +
s->mb_y *
s->mb_stride -
s->mb_stride;
152 ac_val -=
s->block_wrap[n] * 16;
153 if (
s->mb_y == 0 ||
s->qscale == qscale_table[xy] || n == 2 || n == 3) {
155 for (
i = 1;
i < 8;
i++) {
156 const int level =
block[n][
s->idsp.idct_permutation[
i]];
157 block[n][
s->idsp.idct_permutation[
i]] =
level - ac_val[
i + 8];
158 ac_val1[
i] =
block[n][
s->idsp.idct_permutation[
i << 3]];
163 for (
i = 1;
i < 8;
i++) {
164 const int level =
block[n][
s->idsp.idct_permutation[
i]];
166 ac_val1[
i] =
block[n][
s->idsp.idct_permutation[
i << 3]];
170 st[n] =
s->intra_h_scantable.permutated;
172 const int xy =
s->mb_x - 1 +
s->mb_y *
s->mb_stride;
175 if (
s->mb_x == 0 ||
s->qscale == qscale_table[xy] || n == 1 || n == 3) {
177 for (
i = 1;
i < 8;
i++) {
178 const int level =
block[n][
s->idsp.idct_permutation[
i << 3]];
179 block[n][
s->idsp.idct_permutation[
i << 3]] =
level - ac_val[
i];
181 ac_val1[
i + 8] =
block[n][
s->idsp.idct_permutation[
i]];
185 for (
i = 1;
i < 8;
i++) {
186 const int level =
block[n][
s->idsp.idct_permutation[
i << 3]];
189 ac_val1[
i + 8] =
block[n][
s->idsp.idct_permutation[
i]];
192 st[n] =
s->intra_v_scantable.permutated;
195 for (
i = 63;
i > 0;
i--)
198 s->block_last_index[n] =
i;
217 int8_t *
const qscale_table =
s->current_picture.qscale_table;
226 for (
i = 0;
i <
s->mb_num;
i++) {
227 int mb_xy =
s->mb_index2xy[
i];
228 odd += qscale_table[mb_xy] & 1;
231 if (2 * odd >
s->mb_num)
236 for (
i = 0;
i <
s->mb_num;
i++) {
237 int mb_xy =
s->mb_index2xy[
i];
238 if ((qscale_table[mb_xy] & 1) != odd)
239 qscale_table[mb_xy]++;
240 if (qscale_table[mb_xy] > 31)
241 qscale_table[mb_xy] = 31;
244 for (
i = 1;
i <
s->mb_num;
i++) {
245 int mb_xy =
s->mb_index2xy[
i];
246 if (qscale_table[mb_xy] != qscale_table[
s->mb_index2xy[
i - 1]] &&
284 int16_t *
block,
int n,
int intra_dc,
288 int i, last_non_zero;
291 const int last_index =
s->block_last_index[n];
310 last_non_zero =
i - 1;
311 for (;
i < last_index;
i++) {
314 int run =
i - last_non_zero - 1;
316 if ((
level & (~127)) == 0) {
321 7 + 2 + 1 + 6 + 1 + 12 + 1,
322 (3 << 23) + (3 << 21) + (0 << 20) + (
run << 14) +
323 (1 << 13) + (((
level - 64) & 0xfff) << 1) + 1);
330 int run =
i - last_non_zero - 1;
332 if ((
level & (~127)) == 0) {
337 7 + 2 + 1 + 6 + 1 + 12 + 1,
338 (3 << 23) + (3 << 21) + (1 << 20) + (
run << 14) +
339 (1 << 13) + (((
level - 64) & 0xfff) << 1) + 1);
345 int16_t *
block,
int n,
346 int intra_dc,
uint8_t *scan_table)
348 int i, last_non_zero;
350 const int last_index =
s->block_last_index[n];
368 last_non_zero =
i - 1;
369 for (;
i < last_index;
i++) {
372 int run =
i - last_non_zero - 1;
374 if ((
level & (~127)) == 0) {
378 len += 7 + 2 + 1 + 6 + 1 + 12 + 1;
385 int run =
i - last_non_zero - 1;
387 if ((
level & (~127)) == 0) {
391 len += 7 + 2 + 1 + 6 + 1 + 12 + 1;
399 int intra_dc[6],
uint8_t **scan_table,
407 for (
i = 0;
i < 6;
i++)
410 intra_dc[
i], scan_table[
i]));
413 for (
i = 0;
i < 6;
i++)
415 intra_dc[
i], scan_table[
i], dc_pb, ac_pb);
419 for (
i = 0;
i < 6;
i++)
422 s->intra_scantable.permutated));
425 for (
i = 0;
i < 6;
i++)
427 s->intra_scantable.permutated, dc_pb, ac_pb);
433 int motion_x,
int motion_y,
int mb_type)
441 for (
i = 0;
i < 6;
i++) {
442 if (
s->coded_score[
i] < 0) {
443 score +=
s->coded_score[
i];
450 if ((motion_x | motion_y |
s->dquant | mb_type) == 0)
453 zero_score *= lambda;
454 if (zero_score <= score)
458 for (
i = 0;
i < 6;
i++) {
459 if (
s->block_last_index[
i] >= 0 && ((cbp >> (5 -
i)) & 1) == 0) {
460 s->block_last_index[
i] = -1;
461 s->bdsp.clear_block(
s->block[
i]);
465 for (
i = 0;
i < 6;
i++) {
466 if (
s->block_last_index[
i] >= 0)
477 int motion_x,
int motion_y)
479 int cbpc, cbpy, pred_x, pred_y;
483 const int interleaved_stats = (
s->avctx->flags &
AV_CODEC_FLAG_PASS1) && !
s->data_partitioning ? 1 : 0;
490 static const int mb_type_table[8] = { -1, 3, 2, 1, -1, -1, -1, 0 };
491 int mb_type = mb_type_table[
s->mv_dir];
494 for (
i = 0;
i < 2;
i++)
495 s->last_mv[
i][0][0] =
496 s->last_mv[
i][0][1] =
497 s->last_mv[
i][1][0] =
498 s->last_mv[
i][1][1] = 0;
506 if (
s->next_picture.mbskip_table[
s->mb_y *
s->mb_stride +
s->mb_x]) {
513 s->qscale -=
s->dquant;
521 if ((cbp | motion_x | motion_y | mb_type) == 0) {
527 if (interleaved_stats) {
541 if (cbp && mb_type) {
547 s->qscale -=
s->dquant;
549 if (!
s->progressive_sequence) {
556 if (interleaved_stats)
569 s->mv[0][0][0] -
s->last_mv[0][0][0],
570 s->mv[0][0][1] -
s->last_mv[0][0][1],
572 s->last_mv[0][0][0] =
573 s->last_mv[0][1][0] =
s->mv[0][0][0];
574 s->last_mv[0][0][1] =
575 s->last_mv[0][1][1] =
s->mv[0][0][1];
580 s->mv[1][0][0] -
s->last_mv[1][0][0],
581 s->mv[1][0][1] -
s->last_mv[1][0][1],
583 s->last_mv[1][0][0] =
584 s->last_mv[1][1][0] =
s->mv[1][0][0];
585 s->last_mv[1][0][1] =
586 s->last_mv[1][1][1] =
s->mv[1][0][1];
599 for (
i = 0;
i < 2;
i++) {
601 s->mv[0][
i][0] -
s->last_mv[0][
i][0],
602 s->mv[0][
i][1] -
s->last_mv[0][
i][1] / 2,
604 s->last_mv[0][
i][0] =
s->mv[0][
i][0];
605 s->last_mv[0][
i][1] =
s->mv[0][
i][1] * 2;
610 for (
i = 0;
i < 2;
i++) {
612 s->mv[1][
i][0] -
s->last_mv[1][
i][0],
613 s->mv[1][
i][1] -
s->last_mv[1][
i][1] / 2,
615 s->last_mv[1][
i][0] =
s->mv[1][
i][0];
616 s->last_mv[1][
i][1] =
s->mv[1][
i][1] * 2;
623 if (interleaved_stats)
628 if (interleaved_stats)
633 if ((cbp | motion_x | motion_y |
s->dquant) == 0 &&
638 if (
s->max_b_frames > 0) {
647 p_pic =
s->new_picture.f->data[0] +
offset;
650 for (
i = 0;
i <
s->max_b_frames;
i++) {
653 Picture *pic =
s->reordered_input_picture[
i + 1];
662 if (x + 16 >
s->width || y + 16 >
s->height) {
664 int xe =
FFMIN(16,
s->width - x);
665 int ye =
FFMIN(16,
s->height - y);
667 for (y1 = 0; y1 < ye; y1++) {
668 for (x1 = 0; x1 < xe; x1++) {
669 diff +=
FFABS(p_pic[x1 + y1 *
s->linesize] - b_pic[x1 + y1 *
s->linesize]);
674 diff =
s->mecc.sad[0](
NULL, p_pic, b_pic,
s->linesize, 16);
676 if (
diff >
s->qscale * 70) {
684 if (
s->mb_skipped == 1) {
688 if (interleaved_stats) {
713 if (!
s->progressive_sequence) {
719 if (interleaved_stats)
745 if (interleaved_stats)
756 s->mv[0][0][0] - pred_x,
757 s->mv[0][0][1] - pred_y,
760 s->mv[0][1][0] - pred_x,
761 s->mv[0][1][1] - pred_y,
770 if (!
s->progressive_sequence && cbp)
773 if (interleaved_stats)
776 for (
i = 0;
i < 4;
i++) {
781 s->current_picture.motion_val[0][
s->block_index[
i]][0] - pred_x,
782 s->current_picture.motion_val[0][
s->block_index[
i]][1] - pred_y,
787 if (interleaved_stats)
792 if (interleaved_stats)
801 int zigzag_last_index[6];
805 for (
i = 0;
i < 6;
i++)
811 for (
i = 0;
i < 6;
i++)
812 scan_table[
i] =
s->intra_scantable.permutated;
817 for (
i = 0;
i < 6;
i++)
818 if (
s->block_last_index[
i] >= 1)
842 if (!
s->progressive_sequence)
845 if (interleaved_stats)
850 if (interleaved_stats)
870 put_bits(pbc, length, (1 << length) - 1);
879 s->last_time_base =
s->time_base;
880 s->time_base =
FFUDIV(
s->time,
s->avctx->time_base.den);
886 int64_t hours, minutes, seconds;
892 time =
s->current_picture_ptr->f->pts;
893 if (
s->reordered_input_picture[1])
894 time =
FFMIN(time,
s->reordered_input_picture[1]->f->pts);
895 time = time *
s->avctx->time_base.num;
896 s->last_time_base =
FFUDIV(time,
s->avctx->time_base.den);
898 seconds =
FFUDIV(time,
s->avctx->time_base.den);
899 minutes =
FFUDIV(seconds, 60); seconds =
FFUMOD(seconds, 60);
900 hours =
FFUDIV(minutes, 60); minutes =
FFUMOD(minutes, 60);
901 hours =
FFUMOD(hours , 24);
916 int profile_and_level_indication;
920 profile_and_level_indication =
s->avctx->profile << 4;
921 }
else if (
s->max_b_frames ||
s->quarter_sample) {
922 profile_and_level_indication = 0xF0;
924 profile_and_level_indication = 0x00;
928 profile_and_level_indication |=
s->avctx->level;
930 profile_and_level_indication |= 1;
932 if (profile_and_level_indication >> 4 == 0xF)
942 put_bits(&
s->pb, 8, profile_and_level_indication);
964 if (
s->max_b_frames ||
s->quarter_sample) {
975 put_bits(&
s->pb, 16, 0x120 + vol_number);
991 av_reduce(&
s->avctx->sample_aspect_ratio.num, &
s->avctx->sample_aspect_ratio.den,
992 s->avctx->sample_aspect_ratio.num,
s->avctx->sample_aspect_ratio.den, 255);
993 put_bits(&
s->pb, 8,
s->avctx->sample_aspect_ratio.num);
994 put_bits(&
s->pb, 8,
s->avctx->sample_aspect_ratio.den);
1009 put_bits(&
s->pb, 16,
s->avctx->time_base.den);
1010 if (
s->time_increment_bits < 1)
1011 s->time_increment_bits = 1;
1019 put_bits(&
s->pb, 1,
s->progressive_sequence ? 0 : 1);
1029 if (
s->mpeg_quant) {
1038 put_bits(&
s->pb, 1,
s->data_partitioning ? 1 : 0);
1039 if (
s->data_partitioning)
1042 if (vo_ver_id != 1) {
1062 int64_t time_div, time_mod;
1081 time_div =
FFUDIV(
s->time,
s->avctx->time_base.den);
1082 time_mod =
FFUMOD(
s->time,
s->avctx->time_base.den);
1083 time_incr = time_div -
s->last_time_base;
1086 if (time_incr > 3600) {
1096 put_bits(&
s->pb,
s->time_increment_bits, time_mod);
1103 if (!
s->progressive_sequence) {
1104 put_bits(&
s->pb, 1,
s->current_picture_ptr->f->top_field_first);
1121 int level, uni_code, uni_len;
1177 int slevel,
run, last;
1182 for (slevel = -64; slevel < 64; slevel++) {
1186 for (last = 0; last <= 1; last++) {
1188 int level = slevel < 0 ? -slevel : slevel;
1189 int sign = slevel < 0 ? 1 : 0;
1193 len_tab[
index] = 100;
1255 bits =
bits * 4096 + (slevel & 0xfff);
1273 static int done = 0;
1275 if (avctx->
width >= (1<<13) || avctx->
height >= (1<<13)) {
1294 s->min_qcoeff = -2048;
1295 s->max_qcoeff = 2047;
1301 s->ac_esc_length = 7 + 2 + 1 + 6 + 1 + 12 + 1;
1307 if (!
s->avctx->extradata)
1326 int size = end - start;
1327 int pb_size = (((intptr_t)start +
size / 3) & (~3)) - (intptr_t)start;
1328 int tex_size = (
size - 2 * pb_size) & (~3);
1343 s->misc_bits += 19 + pb2_len +
bits -
s->last_bits;
1344 s->i_tex_bits += tex_pb_len;
1347 s->misc_bits += 17 + pb2_len;
1348 s->mv_bits +=
bits -
s->last_bits;
1349 s->p_tex_bits += tex_pb_len;
1363 int mb_num_bits =
av_log2(
s->mb_num - 1) + 1;
1368 put_bits(&
s->pb, mb_num_bits,
s->mb_x +
s->mb_y *
s->mb_width);
1373 #define OFFSET(x) offsetof(MpegEncContext, x)
1374 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1376 {
"data_partitioning",
"Use data partitioning.",
OFFSET(data_partitioning),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
1377 {
"alternate_scan",
"Enable alternate scantable.",
OFFSET(alternate_scan),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
Macro definitions for various function/variable attributes.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define FF_PROFILE_UNKNOWN
#define FF_BUG_MS
Work around various bugs in Microsoft's broken decoders.
#define FF_COMPLIANCE_VERY_STRICT
Strictly conform to an older more strict version of the spec or reference software.
static av_cold int init(AVCodecContext *avctx)
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
#define ROUNDED_DIV(a, b)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
#define AV_CODEC_FLAG2_NO_OUTPUT
Skip bitstream encoding.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
#define LIBAVUTIL_VERSION_INT
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is actually possible in H.263 (limit difference to -2....
#define FF_ASPECT_EXTENDED
static void ff_h263_encode_motion_vector(MpegEncContext *s, int x, int y, int f_code)
av_const int ff_h263_aspect_to_info(AVRational aspect)
Return the 4 bit value that specifies the given aspect ratio.
static int get_p_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
const uint8_t ff_h263_intra_MCBPC_bits[9]
const uint8_t ff_h263_inter_MCBPC_code[28]
const uint8_t ff_h263_inter_MCBPC_bits[28]
const uint8_t ff_h263_intra_MCBPC_code[9]
const uint8_t ff_h263_cbpy_tab[16][2]
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static enum AVPixelFormat pix_fmts[]
const uint8_t ff_mpeg4_DCtab_lum[13][2]
RLTable ff_mpeg4_rl_intra
const uint8_t ff_mpeg4_c_dc_scale_table[32]
const uint8_t ff_mpeg4_y_dc_scale_table[32]
const uint8_t ff_mpeg4_DCtab_chrom[13][2]
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s)
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
uint8_t ff_mpeg4_static_rl_table_store[3][2][2 *MAX_RUN+MAX_LEVEL+3]
#define ADV_SIMPLE_VO_TYPE
static int ff_mpeg4_pred_dc(MpegEncContext *s, int n, int level, int *dir_ptr, int encoding)
Predict the dc.
#define VISUAL_OBJ_STARTCODE
static int mpeg4_get_block_length(MpegEncContext *s, int16_t *block, int n, int intra_dc, uint8_t *scan_table)
static void mpeg4_encode_block(MpegEncContext *s, int16_t *block, int n, int intra_dc, uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
Encode an 8x8 block.
void ff_mpeg4_stuffing(PutBitContext *pbc)
add MPEG-4 stuffing bits (01...1)
void ff_mpeg4_merge_partitions(MpegEncContext *s)
static void mpeg4_encode_gop_header(MpegEncContext *s)
static uint8_t uni_DCtab_lum_len[512]
static const AVClass mpeg4enc_class
static uint16_t uni_DCtab_chrom_bits[512]
static uint8_t uni_mpeg4_intra_rl_len[64 *64 *2 *2]
static const AVOption options[]
void ff_clean_mpeg4_qscales(MpegEncContext *s)
modify mb_type & qscale so that encoding is actually possible in MPEG-4
static av_cold void init_uni_dc_tab(void)
static void mpeg4_encode_dc(PutBitContext *s, int level, int n)
Encode the dc value.
static uint16_t uni_DCtab_lum_bits[512]
static av_cold int encode_init(AVCodecContext *avctx)
static void restore_ac_coeffs(MpegEncContext *s, int16_t block[6][64], const int dir[6], uint8_t *st[6], const int zigzag_last_index[6])
Restore the ac coefficients in block that have been changed by decide_ac_pred().
static void mpeg4_encode_blocks(MpegEncContext *s, int16_t block[6][64], int intra_dc[6], uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
static void mpeg4_encode_visual_object_header(MpegEncContext *s)
static int decide_ac_pred(MpegEncContext *s, int16_t block[6][64], const int dir[6], uint8_t *st[6], int zigzag_last_index[6])
Return the optimal value (0 or 1) for the ac_pred element for the given MB in MPEG-4.
#define UNI_MPEG4_ENC_INDEX(last, run, level)
static uint32_t uni_mpeg4_inter_rl_bits[64 *64 *2 *2]
int ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
static const int dquant_code[5]
static int get_b_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y, int mb_type)
static uint32_t uni_mpeg4_intra_rl_bits[64 *64 *2 *2]
static int mpeg4_get_dc_length(int level, int n)
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
static void mpeg4_encode_vol_header(MpegEncContext *s, int vo_number, int vol_number)
static uint8_t uni_mpeg4_inter_rl_len[64 *64 *2 *2]
void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
static av_cold void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab)
void ff_set_mpeg4_time(MpegEncContext *s)
static int get_block_rate(MpegEncContext *s, int16_t block[64], int block_last_index, uint8_t scantable[64])
Return the number of bits that encoding the 8x8 block in block would need.
void ff_mpeg4_init_partitions(MpegEncContext *s)
static uint8_t uni_DCtab_chrom_len[512]
#define CANDIDATE_MB_TYPE_DIRECT
#define CANDIDATE_MB_TYPE_BIDIR
#define FF_MPV_FLAG_CBP_RD
int ff_mpv_encode_end(AVCodecContext *avctx)
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
static int get_bits_diff(MpegEncContext *s)
#define MV_TYPE_FIELD
2 vectors, one per field
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
#define UNI_AC_ENC_INDEX(run, level)
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
#define FF_MPV_COMMON_OPTS
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4)
#define MV_TYPE_16X16
1 vector for the whole mb
int ff_mpv_encode_init(AVCodecContext *avctx)
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FF_MPEG4_PROFILE_OPTS
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static void set_put_bits_buffer_size(PutBitContext *s, int size)
Change the end of the buffer.
static void skip_put_bits(PutBitContext *s, int n)
Skip the given number of bits.
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
static int put_bits_count(PutBitContext *s)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
int width
picture width / height.
const char * name
Name of the codec implementation.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
enum AVPictureType pict_type
Picture type of the frame.
int n
number of entries of table_vlc minus 1
int8_t * max_run[2]
encoding & decoding
const uint16_t(* table_vlc)[2]
int8_t * max_level[2]
encoding & decoding
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const uint8_t offset[127][2]