66 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
69 1, 2, 3, 5, 4, 10, 9, 8,
70 11, 15, 17, 16, 23, 22, 21, 20,
71 19, 18, 25, 24, 27, 26, 11, 7,
72 6, 1, 2, 13, 2, 2, 2, 2,
73 6, 12, 3, 9, 1, 3, 4, 3,
74 7, 4, 1, 1, 5, 5, 14, 6,
75 1, 7, 1, 8, 1, 1, 1, 1,
76 10, 1, 1, 5, 9, 17, 25, 24,
77 29, 33, 32, 41, 2, 23, 28, 31,
78 3, 22, 30, 4, 27, 40, 8, 26,
79 6, 39, 7, 38, 16, 37, 15, 10,
80 11, 12, 13, 14, 1, 21, 20, 18,
105 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
106 int best_clock_code=1;
108 int best_error= INT_MAX;
114 div= av_clip(div, 1, 127);
116 if(error < best_error){
123 s->
custom_pcf= best_clock_code!=1 || best_divisor!=60;
124 coded_frame_rate= 1800000;
125 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
272 for(i=1; i<s->
mb_num; i++){
276 for(i=s->
mb_num-2; i>=0; i--){
282 for(i=1; i<s->
mb_num; i++){
301 int level,
run, last, i, j, last_index, last_non_zero, sign, slevel, code;
314 else if (level < 1) {
330 int inter_vlc_bits=0;
335 last_non_zero = i - 1;
336 for (; i <= last_index; i++) {
340 run = i - last_non_zero - 1;
341 last = (i == last_index);
343 if(level<0) level= -
level;
347 inter_vlc_bits += rl->
table_vlc[code][1]+1;
351 inter_vlc_bits += 1+6+8-1;
354 aic_vlc_bits += 1+6+8-1;
355 wrong_pos += run + 1;
362 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
369 last_non_zero = i - 1;
370 for (; i <= last_index; i++) {
374 run = i - last_non_zero - 1;
375 last = (i == last_index);
385 if(!CONFIG_FLV_ENCODER || s->
h263_flv <= 1){
427 sval = ((val < 0) ? (
short)(-
val):(
short)
val);
430 while (temp_val != 0) {
431 temp_val = temp_val >> 1;
437 tcode = (sval & (1 << (i-1))) >> (i-1);
438 tcode = (tcode << 1) | 1;
439 code = (code << 2) | tcode;
442 code = ((code << 1) | (val < 0)) << 1;
448 int16_t
block[6][64],
449 int motion_x,
int motion_y)
451 int cbpc, cbpy, i, cbp, pred_x, pred_y;
453 int16_t rec_intradc[6];
459 cbp=
get_p_cbp(s, block, motion_x, motion_y);
464 if(interleaved_stats){
488 if(interleaved_stats){
497 motion_y - pred_y, 1);
502 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
514 if(interleaved_stats){
526 motion_y - pred_y, 1);
531 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
538 if(interleaved_stats){
548 int16_t
level = block[i][0];
558 level = (level + (scale>>1))/scale;
560 level = (level - (scale>>1))/scale;
565 else if (level > 127)
571 rec_intradc[i] = scale*level +
pred_dc;
577 if (rec_intradc[i] < 0)
579 else if (rec_intradc[i] > 2047)
580 rec_intradc[i] = 2047;
583 *dc_ptr[i] = rec_intradc[i];
619 if(interleaved_stats){
630 block[i][0] = rec_intradc[i];
635 if(interleaved_stats){
648 int range, bit_size, sign, code,
bits;
655 bit_size = f_code - 1;
656 range = 1 << bit_size;
660 val= (val^sign)-sign;
664 code = (val >> bit_size) + 1;
665 bits = val & (range - 1);
679 for(f_code=1; f_code<=
MAX_FCODE; f_code++){
685 int val, bit_size, code;
687 bit_size = f_code - 1;
693 code = (val >> bit_size) + 1;
695 len=
ff_mvtab[code][1] + 1 + bit_size;
705 for(f_code=
MAX_FCODE; f_code>0; f_code--){
706 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
711 for(mv=0; mv<
MAX_MV*2+1; mv++){
719 int slevel,
run, last;
724 for(slevel=-64; slevel<64; slevel++){
725 if(slevel==0)
continue;
726 for(run=0; run<64; run++){
727 for(last=0; last<=1; last++){
729 int level= slevel < 0 ? -slevel : slevel;
730 int sign= slevel < 0 ? 1 : 0;
739 bits=bits*2+sign; len++;
741 if(code!=rl->
n && len < len_tab[index]){
748 bits=bits*2+last; len++;
749 bits=bits*64+
run; len+=6;
750 bits=bits*256+(level&0xff); len+=8;
752 if(len < len_tab[index]){
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Table of number of bits a motion vector component needs.
static const int dquant_code[5]
const char const char void * val
av_cold void ff_h263_encode_init(MpegEncContext *s)
uint8_t * fcode_tab
smallest fcode needed for each MV
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
const uint16_t ff_mba_max[6]
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
int obmc
overlapped block motion compensation
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
int min_qcoeff
minimum encodable coefficient
#define UNI_MPEG4_ENC_INDEX(last, run, level)
const uint16_t ff_h263_format[8][2]
#define FF_ASPECT_EXTENDED
uint8_t * intra_ac_vlc_length
int mb_num
number of MBs of a picture
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
uint8_t(* mv_penalty)[MAX_DMV *2+1]
bit amount needed to encode a MV
void ff_h263_encode_mba(MpegEncContext *s)
int h263_aic
Advanced INTRA Coding (AIC)
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Macro definitions for various function/variable attributes.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
static uint8_t uni_h263_inter_rl_len[64 *64 *2 *2]
#define CANDIDATE_MB_TYPE_INTER
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int alt_inter_vlc
alternative inter vlc
const uint8_t ff_mpeg1_dc_scale_table[128]
static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define CANDIDATE_MB_TYPE_INTER4V
int misc_bits
cbp, mb_type
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
Picture current_picture
copy of the current picture structure.
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
const uint8_t ff_h263_intra_MCBPC_bits[9]
int ff_h263_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr)
const uint8_t ff_mba_length[7]
int max_qcoeff
maximum encodable coefficient
int dquant
qscale difference to prev qscale
static int get_bits_diff(MpegEncContext *s)
int h263_plus
H.263+ headers.
uint8_t ff_h263_static_rl_table_store[2][2][2 *MAX_RUN+MAX_LEVEL+3]
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
const uint8_t ff_h263_inter_MCBPC_code[28]
uint8_t * inter_ac_vlc_last_length
void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, int last)
static uint8_t fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need.
int flags
AV_CODEC_FLAG_*.
int h263_slice_structured
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
static void h263_encode_block(MpegEncContext *s, int16_t *block, int n)
Encode an 8x8 block.
uint8_t * intra_ac_vlc_last_length
int n
number of entries of table_vlc minus 1
const uint8_t ff_h263_inter_MCBPC_bits[28]
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
const uint16_t(* table_vlc)[2]
int umvplus
== H.263+ && unrestricted_mv
int16_t(*[2] motion_val)[2]
static void FUNC() pred_dc(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int log2_size, int c_idx)
void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int block_last_index[12]
last non zero coefficient in block
int ac_esc_length
num of bits needed to encode the longest esc
static void error(const char *err)
#define FF_ARRAY_ELEMS(a)
int block_index[6]
index to current MB in block based arrays with edges
static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
static const int8_t mv[256][2]
#define MV_TYPE_16X16
1 vector for the whole mb
const uint8_t ff_aic_dc_scale_table[32]
Libavcodec external API header.
int h263_flv
use flv H.263 header
static uint8_t umv_fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need in umv.
const uint8_t ff_h263_intra_MCBPC_code[9]
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
ScanTable intra_scantable
int height
picture size. must be a multiple of 16
av_cold int ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
uint8_t * inter_ac_vlc_length
static const uint8_t wrong_run[102]
static const char * format
Rational number (pair of numerator and denominator).
static void ff_h263_encode_motion_vector(MpegEncContext *s, int x, int y, int f_code)
static uint8_t uni_h263_intra_aic_rl_len[64 *64 *2 *2]
const uint8_t ff_h263_cbpy_tab[16][2]
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
static av_const int sign_extend(int val, unsigned bits)
const AVRational ff_h263_pixel_aspect[16]
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
struct AVCodecContext * avctx
PutBitContext pb
bit output
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
common internal api header.
static void h263p_encode_umotion(PutBitContext *pb, int val)
av_const int ff_h263_aspect_to_info(AVRational aspect)
Return the 4 bit value that specifies the given aspect ratio.
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
static int get_rl_index(const RLTable *rl, int last, int run, int level)
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is actually possible in H.263 (limit difference to -2...
int last_bits
temp var used for calculating the above vars
static int get_p_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
Return the index into tab at which {a,b} match elements {[0],[1]} of tab.
const uint8_t ff_mvtab[33][2]