48 #define V2_INTRA_CBPC_VLC_BITS 3
49 #define V2_MB_TYPE_VLC_BITS 7
51 #define V2_MV_VLC_BITS 9
52 #define TEX_VLC_BITS 9
54 #define II_BITRATE 128*1024
55 #define MBAC_BITRATE 50*1024
57 #define DEFAULT_INTER_INDEX 3
67 #if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
69 #endif //CONFIG_ENCODERS
77 int level, uni_code, uni_len;
79 for(level=-256; level<256; level++){
90 l= (-
level) ^ ((1 << size) - 1);
97 uni_code ^= (1<<uni_len)-1;
100 uni_code<<=
size; uni_code|=l;
103 uni_code<<=1; uni_code|=1;
113 uni_code ^= (1<<uni_len)-1;
116 uni_code<<=
size; uni_code|=l;
119 uni_code<<=1; uni_code|=1;
131 static int initialized=0;
153 #if CONFIG_VC1_DECODER
190 for(i=0;i<tab->n;i++) {
210 int run_diff= intra ? 0 : 1;
250 static int init_done=0;
269 for (level = 1; level <=
MAX_LEVEL; level++) {
271 for(run=0; run<=
MAX_RUN; run++){
273 for(last=0; last<2; last++){
274 rl_length[i][
level][
run][last]= get_size_of_code(s, &
rl_table[ i], last, run, level, 0);
285 int best =-1, best_size =9999999;
286 int chroma_best=-1, best_chroma_size=9999999;
299 for(run=0; run<=
MAX_RUN; run++){
301 const int last_size= size + chroma_size;
302 for(last=0; last<2; last++){
308 size += intra_luma_count *rl_length[i ][
level][
run][last];
309 chroma_size+= intra_chroma_count*rl_length[i+3][
level][
run][last];
311 size+= intra_luma_count *rl_length[i ][
level][
run][last]
312 +intra_chroma_count*rl_length[i+3][
level][
run][last]
313 +inter_count *rl_length[i+3][
level][
run][last];
316 if(last_size == size+chroma_size)
break;
323 if(chroma_size<best_chroma_size){
324 best_chroma_size= chroma_size;
421 #endif //CONFIG_ENCODERS
473 if ((
unsigned)mx >= 64 ||
505 int range, bit_size, sign, code,
bits;
513 range = 1 << bit_size;
526 code = (val >> bit_size) + 1;
527 bits = val & (range - 1);
538 int motion_x,
int motion_y)
540 int cbp, coded_cbp, i;
542 uint8_t *coded_block;
549 for (i = 0; i < 6; i++) {
569 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
579 msmpeg4v2_encode_motion(s, motion_x - pred_x);
580 msmpeg4v2_encode_motion(s, motion_y - pred_y);
596 for (i = 0; i < 6; i++) {
604 for (i = 0; i < 6; i++) {
607 cbp |= val << (5 - i);
614 coded_cbp |= val << (5 - i);
651 for (i = 0; i < 6; i++) {
659 #endif //CONFIG_ENCODERS
662 int32_t **dc_val_ptr)
686 return FASTDIV((sum + (scale>>1)), scale);
691 int16_t **dc_val_ptr,
int *dir_ptr)
710 b = dc_val[ - 1 -
wrap];
721 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
723 "movl %3, %%eax \n\t"
724 "shrl $1, %%eax \n\t"
725 "addl %%eax, %2 \n\t"
726 "addl %%eax, %1 \n\t"
727 "addl %0, %%eax \n\t"
729 "movl %%edx, %0 \n\t"
730 "movl %1, %%eax \n\t"
732 "movl %%edx, %1 \n\t"
733 "movl %2, %%eax \n\t"
735 "movl %%edx, %2 \n\t"
736 :
"+b" (
a),
"+c" (b),
"+D" (c)
746 a = (a + (8 >> 1)) / 8;
747 b = (b + (8 >> 1)) / 8;
748 c = (c + (8 >> 1)) / 8;
750 a =
FASTDIV((a + (scale >> 1)), scale);
751 b =
FASTDIV((b + (scale >> 1)), scale);
752 c =
FASTDIV((c + (scale >> 1)), scale);
769 if (abs(a - b) < abs(b - c)) {
784 if(s->
mb_x==0) a= (1024 + (scale>>1))/
scale;
785 else a=
get_dc(dest-8, wrap, scale*8);
786 if(s->
mb_y==0) c= (1024 + (scale>>1))/
scale;
787 else c=
get_dc(dest-8*wrap, wrap, scale*8);
814 if (abs(a - b) < abs(b - c)) {
823 if (abs(a - b) <= abs(b - c)) {
833 *dc_val_ptr = &dc_val[0];
879 extquant = (level + 3) & 0x3;
880 code = ((level+3)>>2);
881 }
else if( s->
qscale == 2 ) {
882 extquant = (level + 1) & 0x1;
883 code = ((level+1)>>1);
902 extrabits = 3 - s->
qscale;
906 else if(extrabits > 0)
920 int level,
run, last, i, j, last_index;
921 int last_non_zero, sign, slevel;
922 int code, run_diff, dc_pred_dir;
924 const uint8_t *scantable;
948 for(last_index=63; last_index>=0; last_index--){
949 if(block[scantable[last_index]])
break;
955 last_non_zero = i - 1;
956 for (; i <= last_index; i++) {
960 run = i - last_non_zero - 1;
961 last = (i == last_index);
1052 int code, val, sign, shift;
1065 val = (val - 1) << shift;
1105 if(code<0 || code>7){
1143 s->
mv[0][0][0] = mx;
1144 s->
mv[0][0][1] = my;
1157 for (i = 0; i < 6; i++) {
1206 int val = ((code >> (5 - i)) & 1);
1212 cbp |= val << (5 - i);
1228 s->
mv[0][0][0] = mx;
1229 s->
mv[0][0][1] = my;
1246 for (i = 0; i < 6; i++) {
1261 static int done = 0;
1372 if(start_code!=0x00000100){
1390 if(!had_i)
return -1;
1525 if(left>=length && left<length+8)
1536 else if(left<length+8)
1578 }
else if (level != 0) {
1609 int n,
int coded,
const uint8_t *scan_table)
1650 if (dc_pred_dir == 0)
1660 qadd = (s->
qscale - 1) | 1;
1729 if(sign) level= -
level;
1732 #if 0 // waste of time / this will detect very few errors
1734 const int abs_level=
FFABS(level);
1735 const int run1= run - rl->
max_run[last][abs_level] - run_diff;
1737 if(abs_level <= rl->max_level[last][run]){
1739 return DECODING_AC_LOST;
1741 if(abs_level <= rl->max_level[last][run]*2){
1743 return DECODING_AC_LOST;
1745 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1747 return DECODING_AC_LOST;
1753 if (level>0) level= level * qmul + qadd;
1754 else level= level * qmul - qadd;
1755 #if 0 // waste of time too :(
1756 if(level>2048 || level<-2048){
1758 return DECODING_AC_LOST;
1763 #ifdef ERROR_DETAILS
1766 else if((i>62 && i<192) || i>192+63)
1773 i+= run + rl->
max_run[run>>7][level/qmul] + run_diff;
1776 #ifdef ERROR_DETAILS
1779 else if((i>62 && i<192) || i>192+63)
1788 level = level + rl->
max_level[run>>7][(run-1)&63] * qmul;
1791 #ifdef ERROR_DETAILS
1794 else if((i>62 && i<192) || i>192+63)
1802 #ifdef ERROR_DETAILS
1805 else if((i>62 && i<192) || i>192+63)
1822 block[scan_table[i]] =
level;
1826 block[scan_table[i]] =
level;
1844 int *mx_ptr,
int *my_ptr)
1856 if (code == mv->
n) {
1883 .
name =
"msmpeg4v1",
1897 .
name =
"msmpeg4v2",
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
ScanTable intra_v_scantable
const uint8_t ff_mpeg4_c_dc_scale_table[32]
struct MpegEncContext MpegEncContext
MpegEncContext.
void msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
const uint32_t ff_table0_dc_lum[120][2]
VLC ff_h263_intra_MCBPC_vlc
#define SKIP_COUNTER(name, gb, num)
const uint8_t ff_h263_cbpy_tab[16][2]
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
void ff_init_rl(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
AVCodec ff_msmpeg4v2_decoder
const uint8_t v2_mb_type[8][2]
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
const uint32_t(*const [WMV2_INTER_CBP_TABLE_COUNT] wmv2_inter_table)[2]
int ff_msmpeg4_decode_block(MpegEncContext *s, DCTELEM *block, int n, int coded, const uint8_t *scan_table)
void msmpeg4_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
int min_qcoeff
minimum encodable coefficient
#define DEFAULT_INTER_INDEX
int msmpeg4_decode_picture_header(MpegEncContext *s)
#define MB_NON_INTRA_VLC_BITS
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
void ff_mpeg4_clean_buffers(MpegEncContext *s)
int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
int8_t * max_run[2]
encoding & decoding
VLC ff_mb_non_intra_vlc[4]
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
RLTable rl_table[NB_RL_TABLES]
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
#define FF_DEBUG_PICT_INFO
const uint8_t ff_mvtab[33][2]
int misc_bits
cbp, mb_type
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Picture current_picture
copy of the current picture structure.
const uint8_t ff_mpeg4_DCtab_chrom[13][2]
static uint32_t v2_dc_chroma_table[512][2]
static int msmpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
int ff_wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
static int get_bits_count(const GetBitContext *s)
int8_t * max_level[2]
encoding & decoding
uint8_t idct_permutation[64]
idct input permutation.
const uint32_t ff_table0_dc_chroma[120][2]
int mb_height
number of MBs horizontally & vertically
enum PixelFormat ff_pixfmt_list_420[]
int max_qcoeff
maximum encodable coefficient
static int init(AVCodecParserContext *s)
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static int get_bits_diff(MpegEncContext *s)
static int get_bits_left(GetBitContext *gb)
int16_t * dc_val[3]
used for mpeg4 DC prediction, all 3 arrays must be continuous
int last_non_b_pict_type
used for mpeg4 gmc b-frames & ratecontrol
#define UPDATE_CACHE(name, gb)
const uint16_t ff_msmp4_mb_i_table[64][2]
int last_dc[3]
last DC values for MPEG1
static uint32_t v2_dc_lum_table[512][2]
int rl_chroma_table_index
int mb_skipped
MUST BE SET only during DECODING.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
const uint32_t ff_inverse[257]
#define INTER_MCBPC_VLC_BITS
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
#define CLOSE_READER(name, gb)
static int msmpeg4v1_pred_dc(MpegEncContext *s, int n, int32_t **dc_val_ptr)
#define INIT_VLC_RL(rl, static_size)
#define V2_MB_TYPE_VLC_BITS
#define SKIP_BITS(name, gb, num)
void mpeg4_pred_ac(MpegEncContext *s, DCTELEM *block, int n, int dir)
Predict the ac.
int(* decode_mb)(struct MpegEncContext *s, DCTELEM block[6][64])
int ff_h263_decode_init(AVCodecContext *avctx)
const uint8_t ff_mpeg4_DCtab_lum[13][2]
int n
number of entries of table_vlc minus 1
VLC ff_h263_inter_MCBPC_vlc
const uint8_t v2_intra_cbpc[4][2]
const uint8_t * table_mvx
const uint8_t ff_mpeg4_y_dc_scale_table[32]
const uint16_t(* table_vlc)[2]
#define V2_INTRA_CBPC_VLC_BITS
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
void ff_msmpeg4_encode_init(MpegEncContext *s)
const uint8_t * table_mv_bits
void msmpeg4_encode_ext_header(MpegEncContext *s)
#define LAST_SKIP_BITS(name, gb, num)
int(* ac_stats)[2][MAX_LEVEL+1][MAX_RUN+1][2]
[mb_intra][isChroma][level][run][last]
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
int block_last_index[12]
last non zero coefficient in block
const uint32_t ff_table1_dc_chroma[120][2]
uint16_t * table_mv_index
RL_VLC_ELEM * rl_vlc[32]
decoding only
#define SHOW_UBITS(name, gb, num)
void ff_msmpeg4_encode_motion(MpegEncContext *s, int mx, int my)
int block_index[6]
index to current MB in block based arrays with edges
static const float pred[4]
static const int8_t mv[256][2]
uint32_t * mb_type
macroblock type table mb_type_base + mb_width + 2
#define MV_TYPE_16X16
1 vector for the whole mb
int first_slice_line
used in mpeg4 too to handle resync markers
AVCodec ff_msmpeg4v1_decoder
const uint8_t wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
static void msmpeg4_encode_dc(MpegEncContext *s, int level, int n, int *dir_ptr)
static av_cold void common_init(MpegEncContext *s)
const uint8_t wmv3_dc_scale_table[32]
main external API structure.
static void close(AVCodecParserContext *s)
ScanTable intra_scantable
uint8_t * coded_block
used for coded block pattern prediction (msmpeg4v3, wmv1)
int height
picture size. must be a multiple of 16
const uint8_t old_ff_y_dc_scale_table[32]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define OPEN_READER(name, gb)
const uint16_t * table_mv_code
const uint8_t ff_mpeg1_dc_scale_table[128]
const uint32_t ff_table1_dc_lum[120][2]
static unsigned int get_bits1(GetBitContext *s)
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
ScanTable intra_h_scantable
static void skip_bits(GetBitContext *s, int n)
#define CODEC_CAP_DRAW_HORIZ_BAND
int ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
#define GET_CACHE(name, gb)
#define MB_INTRA_VLC_BITS
int slice_height
in macroblocks
DSPContext dsp
pointers for accelerated dsp functions
const uint8_t wmv1_c_dc_scale_table[32]
#define SKIP_CACHE(name, gb, num)
const uint8_t table_inter_intra[4][2]
int f_code
forward MV resolution
static int msmpeg4v2_decode_motion(MpegEncContext *s, int pred, int f_code)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
void ff_msmpeg4_handle_slices(MpegEncContext *s)
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
int bit_rate
wanted bit rate
DCTELEM(* block)[64]
points to one of the following blocks
static const uint16_t scale[4]
const uint8_t wmv1_y_dc_scale_table[32]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
void(* clear_blocks)(DCTELEM *blocks)
struct AVCodecContext * avctx
PutBitContext pb
bit output
#define SHOW_SBITS(name, gb, num)
void ff_msmpeg4_code012(PutBitContext *pb, int n)
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
const uint32_t table_mb_non_intra[128][2]
static int get_rl_index(const RLTable *rl, int last, int run, int level)
int msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
int ff_h263_decode_end(AVCodecContext *avctx)
int last_bits
temp var used for calculating the above vars
static uint8_t static_rl_table_store[NB_RL_TABLES][2][2 *MAX_RUN+MAX_LEVEL+3]
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
static int decode012(GetBitContext *gb)
VLC_TYPE(* table)[2]
code, bits
static VLC v2_intra_cbpc_vlc
int linesize
line size, in bytes, may be different from width
static const struct @46 tab
TwinVQ codebooks.
int chroma_qscale
chroma QP
#define INTER_INTRA_VLC_BITS
const uint8_t * table_mvy
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
ScanTable inter_scantable
if inter == intra then intra should be used to reduce tha cache usage
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
int h263_aic_dir
AIC direction: 0 = left, 1 = top.
int uvlinesize
line size, for chroma in bytes, may be different from width
static av_cold void init_h263_dc_for_msmpeg4(void)
static int msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
AVCodec ff_msmpeg4v3_decoder
static VLC v2_dc_chroma_vlc
static VLC v2_mb_type_vlc
VLC ff_msmp4_dc_luma_vlc[2]
#define INTRA_MCBPC_VLC_BITS
void ff_msmpeg4_encode_block(MpegEncContext *s, DCTELEM *block, int n)
VLC ff_msmp4_dc_chroma_vlc[2]
static int get_dc(uint8_t *src, int stride, int scale)