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;
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++){
687 bit_size = f_code - 1;
693 code = (val >> bit_size) + 1;
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]
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
av_cold void ff_h263_encode_init(MpegEncContext *s)
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
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]
uint8_t * intra_ac_vlc_length
static void error(const char *err)
int mb_num
number of MBs of a picture
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
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)
const uint8_t(* mv_penalty)[MAX_DMV *2+1]
bit amount needed to encode a MV
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]
The exact code depends on how similar the blocks are and how related they are to the block
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
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
#define FF_ARRAY_ELEMS(a)
const uint8_t * fcode_tab
smallest fcode needed for each MV
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]
#define FF_ASPECT_EXTENDED
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
uint8_t * inter_ac_vlc_length
static const uint8_t wrong_run[102]
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)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
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)
static double val(void *priv, double ch)
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]