|
Lines 2862-3073
Link Here
|
| 2862 |
static VLC h263_mbtype_b_vlc; |
2862 |
static VLC h263_mbtype_b_vlc; |
| 2863 |
static VLC cbpc_b_vlc; |
2863 |
static VLC cbpc_b_vlc; |
| 2864 |
|
2864 |
|
| 2865 |
void init_vlc_rl(RLTable *rl, int use_static) |
2865 |
/** |
|
|
2866 |
* decodes the dc value. |
| 2867 |
* @param n block index (0-3 are luma, 4-5 are chroma) |
| 2868 |
* @param dir_ptr the prediction direction will be stored here |
| 2869 |
* @return the quantized dc |
| 2870 |
*/ |
| 2871 |
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
| 2866 |
{ |
2872 |
{ |
| 2867 |
int i, q; |
2873 |
int level, code; |
| 2868 |
|
|
|
| 2869 |
/* Return if static table is already initialized */ |
| 2870 |
if(use_static && rl->rl_vlc[0]) |
| 2871 |
return; |
| 2872 |
|
| 2873 |
init_vlc(&rl->vlc, 9, rl->n + 1, |
| 2874 |
&rl->table_vlc[0][1], 4, 2, |
| 2875 |
&rl->table_vlc[0][0], 4, 2, use_static); |
| 2876 |
|
2874 |
|
| 2877 |
|
2875 |
if (n < 4) |
| 2878 |
for(q=0; q<32; q++){ |
2876 |
code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
| 2879 |
int qmul= q*2; |
2877 |
else |
| 2880 |
int qadd= (q-1)|1; |
2878 |
code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
| 2881 |
|
2879 |
if (code < 0 || code > 9 /* && s->nbit<9 */){ |
| 2882 |
if(q==0){ |
2880 |
av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
| 2883 |
qmul=1; |
2881 |
return -1; |
| 2884 |
qadd=0; |
2882 |
} |
|
|
2883 |
if (code == 0) { |
| 2884 |
level = 0; |
| 2885 |
} else { |
| 2886 |
if(IS_3IV1){ |
| 2887 |
if(code==1) |
| 2888 |
level= 2*get_bits1(&s->gb)-1; |
| 2889 |
else{ |
| 2890 |
if(get_bits1(&s->gb)) |
| 2891 |
level = get_bits(&s->gb, code-1) + (1<<(code-1)); |
| 2892 |
else |
| 2893 |
level = -get_bits(&s->gb, code-1) - (1<<(code-1)); |
| 2894 |
} |
| 2895 |
}else{ |
| 2896 |
level = get_xbits(&s->gb, code); |
| 2885 |
} |
2897 |
} |
| 2886 |
if(use_static) |
2898 |
|
| 2887 |
rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); |
2899 |
if (code > 8){ |
| 2888 |
else |
2900 |
if(get_bits1(&s->gb)==0){ /* marker */ |
| 2889 |
rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); |
2901 |
if(s->error_resilience>=2){ |
| 2890 |
for(i=0; i<rl->vlc.table_size; i++){ |
2902 |
av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n"); |
| 2891 |
int code= rl->vlc.table[i][0]; |
2903 |
return -1; |
| 2892 |
int len = rl->vlc.table[i][1]; |
|
|
| 2893 |
int level, run; |
| 2894 |
|
| 2895 |
if(len==0){ // illegal code |
| 2896 |
run= 66; |
| 2897 |
level= MAX_LEVEL; |
| 2898 |
}else if(len<0){ //more bits needed |
| 2899 |
run= 0; |
| 2900 |
level= code; |
| 2901 |
}else{ |
| 2902 |
if(code==rl->n){ //esc |
| 2903 |
run= 66; |
| 2904 |
level= 0; |
| 2905 |
}else{ |
| 2906 |
run= rl->table_run [code] + 1; |
| 2907 |
level= rl->table_level[code] * qmul + qadd; |
| 2908 |
if(code >= rl->last) run+=192; |
| 2909 |
} |
2904 |
} |
| 2910 |
} |
2905 |
} |
| 2911 |
rl->rl_vlc[q][i].len= len; |
|
|
| 2912 |
rl->rl_vlc[q][i].level= level; |
| 2913 |
rl->rl_vlc[q][i].run= run; |
| 2914 |
} |
2906 |
} |
| 2915 |
} |
2907 |
} |
| 2916 |
} |
|
|
| 2917 |
|
| 2918 |
/* init vlcs */ |
| 2919 |
|
| 2920 |
/* XXX: find a better solution to handle static init */ |
| 2921 |
void h263_decode_init_vlc(MpegEncContext *s) |
| 2922 |
{ |
| 2923 |
static int done = 0; |
| 2924 |
|
| 2925 |
if (!done) { |
| 2926 |
done = 1; |
| 2927 |
|
| 2928 |
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
| 2929 |
intra_MCBPC_bits, 1, 1, |
| 2930 |
intra_MCBPC_code, 1, 1, 1); |
| 2931 |
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, |
| 2932 |
inter_MCBPC_bits, 1, 1, |
| 2933 |
inter_MCBPC_code, 1, 1, 1); |
| 2934 |
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16, |
| 2935 |
&cbpy_tab[0][1], 2, 1, |
| 2936 |
&cbpy_tab[0][0], 2, 1, 1); |
| 2937 |
init_vlc(&mv_vlc, MV_VLC_BITS, 33, |
| 2938 |
&mvtab[0][1], 2, 1, |
| 2939 |
&mvtab[0][0], 2, 1, 1); |
| 2940 |
init_rl(&rl_inter, 1); |
| 2941 |
init_rl(&rl_intra, 1); |
| 2942 |
init_rl(&rvlc_rl_inter, 1); |
| 2943 |
init_rl(&rvlc_rl_intra, 1); |
| 2944 |
init_rl(&rl_intra_aic, 1); |
| 2945 |
init_vlc_rl(&rl_inter, 1); |
| 2946 |
init_vlc_rl(&rl_intra, 1); |
| 2947 |
init_vlc_rl(&rvlc_rl_inter, 1); |
| 2948 |
init_vlc_rl(&rvlc_rl_intra, 1); |
| 2949 |
init_vlc_rl(&rl_intra_aic, 1); |
| 2950 |
init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
| 2951 |
&DCtab_lum[0][1], 2, 1, |
| 2952 |
&DCtab_lum[0][0], 2, 1, 1); |
| 2953 |
init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, |
| 2954 |
&DCtab_chrom[0][1], 2, 1, |
| 2955 |
&DCtab_chrom[0][0], 2, 1, 1); |
| 2956 |
init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15, |
| 2957 |
&sprite_trajectory_tab[0][1], 4, 2, |
| 2958 |
&sprite_trajectory_tab[0][0], 4, 2, 1); |
| 2959 |
init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, |
| 2960 |
&mb_type_b_tab[0][1], 2, 1, |
| 2961 |
&mb_type_b_tab[0][0], 2, 1, 1); |
| 2962 |
init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, |
| 2963 |
&h263_mbtype_b_tab[0][1], 2, 1, |
| 2964 |
&h263_mbtype_b_tab[0][0], 2, 1, 1); |
| 2965 |
init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, |
| 2966 |
&cbpc_b_tab[0][1], 2, 1, |
| 2967 |
&cbpc_b_tab[0][0], 2, 1, 1); |
| 2968 |
} |
| 2969 |
} |
| 2970 |
|
| 2971 |
/** |
| 2972 |
* Get the GOB height based on picture height. |
| 2973 |
*/ |
| 2974 |
int ff_h263_get_gob_height(MpegEncContext *s){ |
| 2975 |
if (s->height <= 400) |
| 2976 |
return 1; |
| 2977 |
else if (s->height <= 800) |
| 2978 |
return 2; |
| 2979 |
else |
| 2980 |
return 4; |
| 2981 |
} |
| 2982 |
|
| 2983 |
int ff_h263_decode_mba(MpegEncContext *s) |
| 2984 |
{ |
| 2985 |
int i, mb_pos; |
| 2986 |
|
| 2987 |
for(i=0; i<6; i++){ |
| 2988 |
if(s->mb_num-1 <= ff_mba_max[i]) break; |
| 2989 |
} |
| 2990 |
mb_pos= get_bits(&s->gb, ff_mba_length[i]); |
| 2991 |
s->mb_x= mb_pos % s->mb_width; |
| 2992 |
s->mb_y= mb_pos / s->mb_width; |
| 2993 |
|
| 2994 |
return mb_pos; |
| 2995 |
} |
| 2996 |
|
2908 |
|
| 2997 |
void ff_h263_encode_mba(MpegEncContext *s) |
2909 |
return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); |
| 2998 |
{ |
|
|
| 2999 |
int i, mb_pos; |
| 3000 |
|
| 3001 |
for(i=0; i<6; i++){ |
| 3002 |
if(s->mb_num-1 <= ff_mba_max[i]) break; |
| 3003 |
} |
| 3004 |
mb_pos= s->mb_x + s->mb_width*s->mb_y; |
| 3005 |
put_bits(&s->pb, ff_mba_length[i], mb_pos); |
| 3006 |
} |
2910 |
} |
| 3007 |
|
2911 |
|
| 3008 |
/** |
2912 |
/** |
| 3009 |
* decodes the group of blocks header or slice header. |
2913 |
* decodes a block. |
| 3010 |
* @return <0 if an error occured |
2914 |
* @return <0 if an error occured |
| 3011 |
*/ |
2915 |
*/ |
| 3012 |
static int h263_decode_gob_header(MpegEncContext *s) |
2916 |
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, |
|
|
2917 |
int n, int coded, int intra, int rvlc) |
| 3013 |
{ |
2918 |
{ |
| 3014 |
unsigned int val, gfid, gob_number; |
2919 |
int level, i, last, run; |
| 3015 |
int left; |
2920 |
int dc_pred_dir; |
| 3016 |
|
2921 |
RLTable * rl; |
| 3017 |
/* Check for GOB Start Code */ |
2922 |
RL_VLC_ELEM * rl_vlc; |
| 3018 |
val = show_bits(&s->gb, 16); |
2923 |
const uint8_t * scan_table; |
| 3019 |
if(val) |
2924 |
int qmul, qadd; |
| 3020 |
return -1; |
|
|
| 3021 |
|
| 3022 |
/* We have a GBSC probably with GSTUFF */ |
| 3023 |
skip_bits(&s->gb, 16); /* Drop the zeros */ |
| 3024 |
left= s->gb.size_in_bits - get_bits_count(&s->gb); |
| 3025 |
//MN: we must check the bits left or we might end in a infinite loop (or segfault) |
| 3026 |
for(;left>13; left--){ |
| 3027 |
if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ |
| 3028 |
} |
| 3029 |
if(left<=13) |
| 3030 |
return -1; |
| 3031 |
|
| 3032 |
if(s->h263_slice_structured){ |
| 3033 |
if(get_bits1(&s->gb)==0) |
| 3034 |
return -1; |
| 3035 |
|
| 3036 |
ff_h263_decode_mba(s); |
| 3037 |
|
2925 |
|
| 3038 |
if(s->mb_num > 1583) |
2926 |
//Note intra & rvlc should be optimized away if this is inlined |
| 3039 |
if(get_bits1(&s->gb)==0) |
2927 |
|
|
|
2928 |
if(intra) { |
| 2929 |
if(s->qscale < s->intra_dc_threshold){ |
| 2930 |
/* DC coef */ |
| 2931 |
if(s->partitioned_frame){ |
| 2932 |
level = s->dc_val[0][ s->block_index[n] ]; |
| 2933 |
if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); |
| 2934 |
else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); |
| 2935 |
dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
| 2936 |
}else{ |
| 2937 |
level = mpeg4_decode_dc(s, n, &dc_pred_dir); |
| 2938 |
if (level < 0) |
| 3040 |
return -1; |
2939 |
return -1; |
|
|
2940 |
} |
| 2941 |
block[0] = level; |
| 2942 |
i = 0; |
| 2943 |
}else{ |
| 2944 |
i = -1; |
| 2945 |
} |
| 2946 |
if (!coded) |
| 2947 |
goto not_coded; |
| 3041 |
|
2948 |
|
| 3042 |
s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
2949 |
if(rvlc){ |
| 3043 |
if(get_bits1(&s->gb)==0) |
2950 |
rl = &rvlc_rl_intra; |
| 3044 |
return -1; |
2951 |
rl_vlc = rvlc_rl_intra.rl_vlc[0]; |
| 3045 |
gfid = get_bits(&s->gb, 2); /* GFID */ |
2952 |
}else{ |
| 3046 |
}else{ |
2953 |
rl = &rl_intra; |
| 3047 |
gob_number = get_bits(&s->gb, 5); /* GN */ |
2954 |
rl_vlc = rl_intra.rl_vlc[0]; |
| 3048 |
s->mb_x= 0; |
2955 |
} |
| 3049 |
s->mb_y= s->gob_index* gob_number; |
2956 |
if (s->ac_pred) { |
| 3050 |
gfid = get_bits(&s->gb, 2); /* GFID */ |
2957 |
if (dc_pred_dir == 0) |
| 3051 |
s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
2958 |
scan_table = s->intra_v_scantable.permutated; /* left */ |
| 3052 |
} |
2959 |
else |
| 3053 |
|
2960 |
scan_table = s->intra_h_scantable.permutated; /* top */ |
| 3054 |
if(s->mb_y >= s->mb_height) |
2961 |
} else { |
| 3055 |
return -1; |
2962 |
scan_table = s->intra_scantable.permutated; |
| 3056 |
|
2963 |
} |
| 3057 |
if(s->qscale==0) |
2964 |
qmul=1; |
| 3058 |
return -1; |
2965 |
qadd=0; |
| 3059 |
|
2966 |
} else { |
| 3060 |
return 0; |
2967 |
i = -1; |
| 3061 |
} |
2968 |
if (!coded) { |
| 3062 |
|
2969 |
s->block_last_index[n] = i; |
| 3063 |
static inline void memsetw(short *tab, int val, int n) |
2970 |
return 0; |
| 3064 |
{ |
2971 |
} |
| 3065 |
int i; |
2972 |
if(rvlc) rl = &rvlc_rl_inter; |
| 3066 |
for(i=0;i<n;i++) |
2973 |
else rl = &rl_inter; |
| 3067 |
tab[i] = val; |
2974 |
|
| 3068 |
} |
2975 |
scan_table = s->intra_scantable.permutated; |
| 3069 |
|
2976 |
|
| 3070 |
#ifdef CONFIG_ENCODERS |
2977 |
if(s->mpeg_quant){ |
|
|
2978 |
qmul=1; |
| 2979 |
qadd=0; |
| 2980 |
if(rvlc){ |
| 2981 |
rl_vlc = rvlc_rl_inter.rl_vlc[0]; |
| 2982 |
}else{ |
| 2983 |
rl_vlc = rl_inter.rl_vlc[0]; |
| 2984 |
} |
| 2985 |
}else{ |
| 2986 |
qmul = s->qscale << 1; |
| 2987 |
qadd = (s->qscale - 1) | 1; |
| 2988 |
if(rvlc){ |
| 2989 |
rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; |
| 2990 |
}else{ |
| 2991 |
rl_vlc = rl_inter.rl_vlc[s->qscale]; |
| 2992 |
} |
| 2993 |
} |
| 2994 |
} |
| 2995 |
{ |
| 2996 |
OPEN_READER(re, &s->gb); |
| 2997 |
for(;;) { |
| 2998 |
UPDATE_CACHE(re, &s->gb); |
| 2999 |
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
| 3000 |
if (level==0) { |
| 3001 |
/* escape */ |
| 3002 |
if(rvlc){ |
| 3003 |
if(SHOW_UBITS(re, &s->gb, 1)==0){ |
| 3004 |
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); |
| 3005 |
return -1; |
| 3006 |
}; SKIP_CACHE(re, &s->gb, 1); |
| 3007 |
|
| 3008 |
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
| 3009 |
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); |
| 3010 |
SKIP_COUNTER(re, &s->gb, 1+1+6); |
| 3011 |
UPDATE_CACHE(re, &s->gb); |
| 3012 |
|
| 3013 |
if(SHOW_UBITS(re, &s->gb, 1)==0){ |
| 3014 |
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); |
| 3015 |
return -1; |
| 3016 |
}; SKIP_CACHE(re, &s->gb, 1); |
| 3017 |
|
| 3018 |
level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); |
| 3019 |
|
| 3020 |
if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ |
| 3021 |
av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); |
| 3022 |
return -1; |
| 3023 |
}; SKIP_CACHE(re, &s->gb, 5); |
| 3024 |
|
| 3025 |
level= level * qmul + qadd; |
| 3026 |
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); |
| 3027 |
SKIP_COUNTER(re, &s->gb, 1+11+5+1); |
| 3028 |
|
| 3029 |
i+= run + 1; |
| 3030 |
if(last) i+=192; |
| 3031 |
}else{ |
| 3032 |
int cache; |
| 3033 |
cache= GET_CACHE(re, &s->gb); |
| 3034 |
|
| 3035 |
if(IS_3IV1) |
| 3036 |
cache ^= 0xC0000000; |
| 3037 |
|
| 3038 |
if (cache&0x80000000) { |
| 3039 |
if (cache&0x40000000) { |
| 3040 |
/* third escape */ |
| 3041 |
SKIP_CACHE(re, &s->gb, 2); |
| 3042 |
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
| 3043 |
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); |
| 3044 |
SKIP_COUNTER(re, &s->gb, 2+1+6); |
| 3045 |
UPDATE_CACHE(re, &s->gb); |
| 3046 |
|
| 3047 |
if(IS_3IV1){ |
| 3048 |
level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12); |
| 3049 |
}else{ |
| 3050 |
if(SHOW_UBITS(re, &s->gb, 1)==0){ |
| 3051 |
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n"); |
| 3052 |
return -1; |
| 3053 |
}; SKIP_CACHE(re, &s->gb, 1); |
| 3054 |
|
| 3055 |
level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); |
| 3056 |
|
| 3057 |
if(SHOW_UBITS(re, &s->gb, 1)==0){ |
| 3058 |
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n"); |
| 3059 |
return -1; |
| 3060 |
}; LAST_SKIP_CACHE(re, &s->gb, 1); |
| 3061 |
|
| 3062 |
SKIP_COUNTER(re, &s->gb, 1+12+1); |
| 3063 |
} |
| 3064 |
|
| 3065 |
#if 0 |
| 3066 |
if(s->error_resilience >= FF_ER_COMPLIANT){ |
| 3067 |
const int abs_level= ABS(level); |
| 3068 |
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
| 3069 |
const int run1= run - rl->max_run[last][abs_level] - 1; |
| 3070 |
if(abs_level <= rl->max_level[last][run]){ |
| 3071 |
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); |
| 3072 |
return -1; |
| 3073 |
} |
| 3074 |
if(s->error_resilience > FF_ER_COMPLIANT){ |
| 3075 |
if(abs_level <= rl->max_level[last][run]*2){ |
| 3076 |
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); |
| 3077 |
return -1; |
| 3078 |
} |
| 3079 |
if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ |
| 3080 |
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); |
| 3081 |
return -1; |
| 3082 |
} |
| 3083 |
} |
| 3084 |
} |
| 3085 |
} |
| 3086 |
#endif |
| 3087 |
if (level>0) level= level * qmul + qadd; |
| 3088 |
else level= level * qmul - qadd; |
| 3089 |
|
| 3090 |
if((unsigned)(level + 2048) > 4095){ |
| 3091 |
if(s->error_resilience > FF_ER_COMPLIANT){ |
| 3092 |
if(level > 2560 || level<-2560){ |
| 3093 |
av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); |
| 3094 |
return -1; |
| 3095 |
} |
| 3096 |
} |
| 3097 |
level= level<0 ? -2048 : 2047; |
| 3098 |
} |
| 3099 |
|
| 3100 |
i+= run + 1; |
| 3101 |
if(last) i+=192; |
| 3102 |
} else { |
| 3103 |
/* second escape */ |
| 3104 |
#if MIN_CACHE_BITS < 20 |
| 3105 |
LAST_SKIP_BITS(re, &s->gb, 2); |
| 3106 |
UPDATE_CACHE(re, &s->gb); |
| 3107 |
#else |
| 3108 |
SKIP_BITS(re, &s->gb, 2); |
| 3109 |
#endif |
| 3110 |
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
| 3111 |
i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing |
| 3112 |
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); |
| 3113 |
LAST_SKIP_BITS(re, &s->gb, 1); |
| 3114 |
} |
| 3115 |
} else { |
| 3116 |
/* first escape */ |
| 3117 |
#if MIN_CACHE_BITS < 19 |
| 3118 |
LAST_SKIP_BITS(re, &s->gb, 1); |
| 3119 |
UPDATE_CACHE(re, &s->gb); |
| 3120 |
#else |
| 3121 |
SKIP_BITS(re, &s->gb, 1); |
| 3122 |
#endif |
| 3123 |
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
| 3124 |
i+= run; |
| 3125 |
level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing |
| 3126 |
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); |
| 3127 |
LAST_SKIP_BITS(re, &s->gb, 1); |
| 3128 |
} |
| 3129 |
} |
| 3130 |
} else { |
| 3131 |
i+= run; |
| 3132 |
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); |
| 3133 |
LAST_SKIP_BITS(re, &s->gb, 1); |
| 3134 |
} |
| 3135 |
if (i > 62){ |
| 3136 |
i-= 192; |
| 3137 |
if(i&(~63)){ |
| 3138 |
av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
| 3139 |
return -1; |
| 3140 |
} |
| 3141 |
|
| 3142 |
block[scan_table[i]] = level; |
| 3143 |
break; |
| 3144 |
} |
| 3145 |
|
| 3146 |
block[scan_table[i]] = level; |
| 3147 |
} |
| 3148 |
CLOSE_READER(re, &s->gb); |
| 3149 |
} |
| 3150 |
not_coded: |
| 3151 |
if (intra) { |
| 3152 |
if(s->qscale >= s->intra_dc_threshold){ |
| 3153 |
block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); |
| 3154 |
|
| 3155 |
if(i == -1) i=0; |
| 3156 |
} |
| 3157 |
|
| 3158 |
mpeg4_pred_ac(s, block, n, dc_pred_dir); |
| 3159 |
if (s->ac_pred) { |
| 3160 |
i = 63; /* XXX: not optimal */ |
| 3161 |
} |
| 3162 |
} |
| 3163 |
s->block_last_index[n] = i; |
| 3164 |
return 0; |
| 3165 |
} |
| 3166 |
|
| 3167 |
void init_vlc_rl(RLTable *rl, int use_static) |
| 3168 |
{ |
| 3169 |
int i, q; |
| 3170 |
|
| 3171 |
/* Return if static table is already initialized */ |
| 3172 |
if(use_static && rl->rl_vlc[0]) |
| 3173 |
return; |
| 3174 |
|
| 3175 |
init_vlc(&rl->vlc, 9, rl->n + 1, |
| 3176 |
&rl->table_vlc[0][1], 4, 2, |
| 3177 |
&rl->table_vlc[0][0], 4, 2, use_static); |
| 3178 |
|
| 3179 |
|
| 3180 |
for(q=0; q<32; q++){ |
| 3181 |
int qmul= q*2; |
| 3182 |
int qadd= (q-1)|1; |
| 3183 |
|
| 3184 |
if(q==0){ |
| 3185 |
qmul=1; |
| 3186 |
qadd=0; |
| 3187 |
} |
| 3188 |
if(use_static) |
| 3189 |
rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); |
| 3190 |
else |
| 3191 |
rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); |
| 3192 |
for(i=0; i<rl->vlc.table_size; i++){ |
| 3193 |
int code= rl->vlc.table[i][0]; |
| 3194 |
int len = rl->vlc.table[i][1]; |
| 3195 |
int level, run; |
| 3196 |
|
| 3197 |
if(len==0){ // illegal code |
| 3198 |
run= 66; |
| 3199 |
level= MAX_LEVEL; |
| 3200 |
}else if(len<0){ //more bits needed |
| 3201 |
run= 0; |
| 3202 |
level= code; |
| 3203 |
}else{ |
| 3204 |
if(code==rl->n){ //esc |
| 3205 |
run= 66; |
| 3206 |
level= 0; |
| 3207 |
}else{ |
| 3208 |
run= rl->table_run [code] + 1; |
| 3209 |
level= rl->table_level[code] * qmul + qadd; |
| 3210 |
if(code >= rl->last) run+=192; |
| 3211 |
} |
| 3212 |
} |
| 3213 |
rl->rl_vlc[q][i].len= len; |
| 3214 |
rl->rl_vlc[q][i].level= level; |
| 3215 |
rl->rl_vlc[q][i].run= run; |
| 3216 |
} |
| 3217 |
} |
| 3218 |
} |
| 3219 |
|
| 3220 |
/* init vlcs */ |
| 3221 |
|
| 3222 |
/* XXX: find a better solution to handle static init */ |
| 3223 |
void h263_decode_init_vlc(MpegEncContext *s) |
| 3224 |
{ |
| 3225 |
static int done = 0; |
| 3226 |
|
| 3227 |
if (!done) { |
| 3228 |
done = 1; |
| 3229 |
|
| 3230 |
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
| 3231 |
intra_MCBPC_bits, 1, 1, |
| 3232 |
intra_MCBPC_code, 1, 1, 1); |
| 3233 |
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, |
| 3234 |
inter_MCBPC_bits, 1, 1, |
| 3235 |
inter_MCBPC_code, 1, 1, 1); |
| 3236 |
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16, |
| 3237 |
&cbpy_tab[0][1], 2, 1, |
| 3238 |
&cbpy_tab[0][0], 2, 1, 1); |
| 3239 |
init_vlc(&mv_vlc, MV_VLC_BITS, 33, |
| 3240 |
&mvtab[0][1], 2, 1, |
| 3241 |
&mvtab[0][0], 2, 1, 1); |
| 3242 |
init_rl(&rl_inter, 1); |
| 3243 |
init_rl(&rl_intra, 1); |
| 3244 |
init_rl(&rvlc_rl_inter, 1); |
| 3245 |
init_rl(&rvlc_rl_intra, 1); |
| 3246 |
init_rl(&rl_intra_aic, 1); |
| 3247 |
init_vlc_rl(&rl_inter, 1); |
| 3248 |
init_vlc_rl(&rl_intra, 1); |
| 3249 |
init_vlc_rl(&rvlc_rl_inter, 1); |
| 3250 |
init_vlc_rl(&rvlc_rl_intra, 1); |
| 3251 |
init_vlc_rl(&rl_intra_aic, 1); |
| 3252 |
init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
| 3253 |
&DCtab_lum[0][1], 2, 1, |
| 3254 |
&DCtab_lum[0][0], 2, 1, 1); |
| 3255 |
init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, |
| 3256 |
&DCtab_chrom[0][1], 2, 1, |
| 3257 |
&DCtab_chrom[0][0], 2, 1, 1); |
| 3258 |
init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15, |
| 3259 |
&sprite_trajectory_tab[0][1], 4, 2, |
| 3260 |
&sprite_trajectory_tab[0][0], 4, 2, 1); |
| 3261 |
init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, |
| 3262 |
&mb_type_b_tab[0][1], 2, 1, |
| 3263 |
&mb_type_b_tab[0][0], 2, 1, 1); |
| 3264 |
init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, |
| 3265 |
&h263_mbtype_b_tab[0][1], 2, 1, |
| 3266 |
&h263_mbtype_b_tab[0][0], 2, 1, 1); |
| 3267 |
init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, |
| 3268 |
&cbpc_b_tab[0][1], 2, 1, |
| 3269 |
&cbpc_b_tab[0][0], 2, 1, 1); |
| 3270 |
} |
| 3271 |
} |
| 3272 |
|
| 3273 |
/** |
| 3274 |
* Get the GOB height based on picture height. |
| 3275 |
*/ |
| 3276 |
int ff_h263_get_gob_height(MpegEncContext *s){ |
| 3277 |
if (s->height <= 400) |
| 3278 |
return 1; |
| 3279 |
else if (s->height <= 800) |
| 3280 |
return 2; |
| 3281 |
else |
| 3282 |
return 4; |
| 3283 |
} |
| 3284 |
|
| 3285 |
int ff_h263_decode_mba(MpegEncContext *s) |
| 3286 |
{ |
| 3287 |
int i, mb_pos; |
| 3288 |
|
| 3289 |
for(i=0; i<6; i++){ |
| 3290 |
if(s->mb_num-1 <= ff_mba_max[i]) break; |
| 3291 |
} |
| 3292 |
mb_pos= get_bits(&s->gb, ff_mba_length[i]); |
| 3293 |
s->mb_x= mb_pos % s->mb_width; |
| 3294 |
s->mb_y= mb_pos / s->mb_width; |
| 3295 |
|
| 3296 |
return mb_pos; |
| 3297 |
} |
| 3298 |
|
| 3299 |
void ff_h263_encode_mba(MpegEncContext *s) |
| 3300 |
{ |
| 3301 |
int i, mb_pos; |
| 3302 |
|
| 3303 |
for(i=0; i<6; i++){ |
| 3304 |
if(s->mb_num-1 <= ff_mba_max[i]) break; |
| 3305 |
} |
| 3306 |
mb_pos= s->mb_x + s->mb_width*s->mb_y; |
| 3307 |
put_bits(&s->pb, ff_mba_length[i], mb_pos); |
| 3308 |
} |
| 3309 |
|
| 3310 |
/** |
| 3311 |
* decodes the group of blocks header or slice header. |
| 3312 |
* @return <0 if an error occured |
| 3313 |
*/ |
| 3314 |
static int h263_decode_gob_header(MpegEncContext *s) |
| 3315 |
{ |
| 3316 |
unsigned int val, gfid, gob_number; |
| 3317 |
int left; |
| 3318 |
|
| 3319 |
/* Check for GOB Start Code */ |
| 3320 |
val = show_bits(&s->gb, 16); |
| 3321 |
if(val) |
| 3322 |
return -1; |
| 3323 |
|
| 3324 |
/* We have a GBSC probably with GSTUFF */ |
| 3325 |
skip_bits(&s->gb, 16); /* Drop the zeros */ |
| 3326 |
left= s->gb.size_in_bits - get_bits_count(&s->gb); |
| 3327 |
//MN: we must check the bits left or we might end in a infinite loop (or segfault) |
| 3328 |
for(;left>13; left--){ |
| 3329 |
if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ |
| 3330 |
} |
| 3331 |
if(left<=13) |
| 3332 |
return -1; |
| 3333 |
|
| 3334 |
if(s->h263_slice_structured){ |
| 3335 |
if(get_bits1(&s->gb)==0) |
| 3336 |
return -1; |
| 3337 |
|
| 3338 |
ff_h263_decode_mba(s); |
| 3339 |
|
| 3340 |
if(s->mb_num > 1583) |
| 3341 |
if(get_bits1(&s->gb)==0) |
| 3342 |
return -1; |
| 3343 |
|
| 3344 |
s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
| 3345 |
if(get_bits1(&s->gb)==0) |
| 3346 |
return -1; |
| 3347 |
gfid = get_bits(&s->gb, 2); /* GFID */ |
| 3348 |
}else{ |
| 3349 |
gob_number = get_bits(&s->gb, 5); /* GN */ |
| 3350 |
s->mb_x= 0; |
| 3351 |
s->mb_y= s->gob_index* gob_number; |
| 3352 |
gfid = get_bits(&s->gb, 2); /* GFID */ |
| 3353 |
s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
| 3354 |
} |
| 3355 |
|
| 3356 |
if(s->mb_y >= s->mb_height) |
| 3357 |
return -1; |
| 3358 |
|
| 3359 |
if(s->qscale==0) |
| 3360 |
return -1; |
| 3361 |
|
| 3362 |
return 0; |
| 3363 |
} |
| 3364 |
|
| 3365 |
static inline void memsetw(short *tab, int val, int n) |
| 3366 |
{ |
| 3367 |
int i; |
| 3368 |
for(i=0;i<n;i++) |
| 3369 |
tab[i] = val; |
| 3370 |
} |
| 3371 |
|
| 3372 |
#ifdef CONFIG_ENCODERS |
| 3071 |
|
3373 |
|
| 3072 |
void ff_mpeg4_init_partitions(MpegEncContext *s) |
3374 |
void ff_mpeg4_init_partitions(MpegEncContext *s) |
| 3073 |
{ |
3375 |
{ |
|
Lines 4563-4978
Link Here
|
| 4563 |
scan_table = s->intra_v_scantable.permutated; /* left */ |
4865 |
scan_table = s->intra_v_scantable.permutated; /* left */ |
| 4564 |
else |
4866 |
else |
| 4565 |
scan_table = s->intra_h_scantable.permutated; /* top */ |
4867 |
scan_table = s->intra_h_scantable.permutated; /* top */ |
| 4566 |
} |
4868 |
} |
| 4567 |
} else if (s->mb_intra) { |
4869 |
} else if (s->mb_intra) { |
| 4568 |
/* DC coef */ |
4870 |
/* DC coef */ |
| 4569 |
if(s->codec_id == CODEC_ID_RV10){ |
4871 |
if(s->codec_id == CODEC_ID_RV10){ |
| 4570 |
#ifdef CONFIG_RV10_DECODER |
4872 |
#ifdef CONFIG_RV10_DECODER |
| 4571 |
if (s->rv10_version == 3 && s->pict_type == I_TYPE) { |
4873 |
if (s->rv10_version == 3 && s->pict_type == I_TYPE) { |
| 4572 |
int component, diff; |
4874 |
int component, diff; |
| 4573 |
component = (n <= 3 ? 0 : n - 4 + 1); |
4875 |
component = (n <= 3 ? 0 : n - 4 + 1); |
| 4574 |
level = s->last_dc[component]; |
4876 |
level = s->last_dc[component]; |
| 4575 |
if (s->rv10_first_dc_coded[component]) { |
4877 |
if (s->rv10_first_dc_coded[component]) { |
| 4576 |
diff = rv_decode_dc(s, n); |
4878 |
diff = rv_decode_dc(s, n); |
| 4577 |
if (diff == 0xffff) |
4879 |
if (diff == 0xffff) |
| 4578 |
return -1; |
4880 |
return -1; |
| 4579 |
level += diff; |
4881 |
level += diff; |
| 4580 |
level = level & 0xff; /* handle wrap round */ |
4882 |
level = level & 0xff; /* handle wrap round */ |
| 4581 |
s->last_dc[component] = level; |
4883 |
s->last_dc[component] = level; |
| 4582 |
} else { |
4884 |
} else { |
| 4583 |
s->rv10_first_dc_coded[component] = 1; |
4885 |
s->rv10_first_dc_coded[component] = 1; |
| 4584 |
} |
|
|
| 4585 |
} else { |
| 4586 |
level = get_bits(&s->gb, 8); |
| 4587 |
if (level == 255) |
| 4588 |
level = 128; |
| 4589 |
} |
| 4590 |
#endif |
| 4591 |
}else{ |
| 4592 |
level = get_bits(&s->gb, 8); |
| 4593 |
if((level&0x7F) == 0){ |
| 4594 |
av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
| 4595 |
if(s->error_resilience >= FF_ER_COMPLIANT) |
| 4596 |
return -1; |
| 4597 |
} |
| 4598 |
if (level == 255) |
| 4599 |
level = 128; |
| 4600 |
} |
| 4601 |
block[0] = level; |
| 4602 |
i = 1; |
| 4603 |
} else { |
| 4604 |
i = 0; |
| 4605 |
} |
| 4606 |
if (!coded) { |
| 4607 |
if (s->mb_intra && s->h263_aic) |
| 4608 |
goto not_coded; |
| 4609 |
s->block_last_index[n] = i - 1; |
| 4610 |
return 0; |
| 4611 |
} |
| 4612 |
retry: |
| 4613 |
for(;;) { |
| 4614 |
code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); |
| 4615 |
if (code < 0){ |
| 4616 |
av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
| 4617 |
return -1; |
| 4618 |
} |
| 4619 |
if (code == rl->n) { |
| 4620 |
/* escape */ |
| 4621 |
if (s->h263_flv > 1) { |
| 4622 |
int is11 = get_bits1(&s->gb); |
| 4623 |
last = get_bits1(&s->gb); |
| 4624 |
run = get_bits(&s->gb, 6); |
| 4625 |
if(is11){ |
| 4626 |
level = get_sbits(&s->gb, 11); |
| 4627 |
} else { |
| 4628 |
level = get_sbits(&s->gb, 7); |
| 4629 |
} |
| 4630 |
} else { |
| 4631 |
last = get_bits1(&s->gb); |
| 4632 |
run = get_bits(&s->gb, 6); |
| 4633 |
level = (int8_t)get_bits(&s->gb, 8); |
| 4634 |
if(level == -128){ |
| 4635 |
if (s->codec_id == CODEC_ID_RV10) { |
| 4636 |
/* XXX: should patch encoder too */ |
| 4637 |
level = get_sbits(&s->gb, 12); |
| 4638 |
}else{ |
| 4639 |
level = get_bits(&s->gb, 5); |
| 4640 |
level |= get_sbits(&s->gb, 6)<<5; |
| 4641 |
} |
| 4642 |
} |
| 4643 |
} |
| 4644 |
} else { |
| 4645 |
run = rl->table_run[code]; |
| 4646 |
level = rl->table_level[code]; |
| 4647 |
last = code >= rl->last; |
| 4648 |
if (get_bits1(&s->gb)) |
| 4649 |
level = -level; |
| 4650 |
} |
| 4651 |
i += run; |
| 4652 |
if (i >= 64){ |
| 4653 |
if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ |
| 4654 |
//looks like a hack but no, it's the way its supposed to work ... |
| 4655 |
rl = &rl_intra_aic; |
| 4656 |
i = 0; |
| 4657 |
s->gb= gb; |
| 4658 |
memset(block, 0, sizeof(DCTELEM)*64); |
| 4659 |
goto retry; |
| 4660 |
} |
| 4661 |
av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); |
| 4662 |
return -1; |
| 4663 |
} |
| 4664 |
j = scan_table[i]; |
| 4665 |
block[j] = level; |
| 4666 |
if (last) |
| 4667 |
break; |
| 4668 |
i++; |
| 4669 |
} |
| 4670 |
not_coded: |
| 4671 |
if (s->mb_intra && s->h263_aic) { |
| 4672 |
h263_pred_acdc(s, block, n); |
| 4673 |
i = 63; |
| 4674 |
} |
| 4675 |
s->block_last_index[n] = i; |
| 4676 |
return 0; |
| 4677 |
} |
| 4678 |
|
| 4679 |
/** |
| 4680 |
* decodes the dc value. |
| 4681 |
* @param n block index (0-3 are luma, 4-5 are chroma) |
| 4682 |
* @param dir_ptr the prediction direction will be stored here |
| 4683 |
* @return the quantized dc |
| 4684 |
*/ |
| 4685 |
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
| 4686 |
{ |
| 4687 |
int level, code; |
| 4688 |
|
| 4689 |
if (n < 4) |
| 4690 |
code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
| 4691 |
else |
| 4692 |
code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
| 4693 |
if (code < 0 || code > 9 /* && s->nbit<9 */){ |
| 4694 |
av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
| 4695 |
return -1; |
| 4696 |
} |
| 4697 |
if (code == 0) { |
| 4698 |
level = 0; |
| 4699 |
} else { |
| 4700 |
if(IS_3IV1){ |
| 4701 |
if(code==1) |
| 4702 |
level= 2*get_bits1(&s->gb)-1; |
| 4703 |
else{ |
| 4704 |
if(get_bits1(&s->gb)) |
| 4705 |
level = get_bits(&s->gb, code-1) + (1<<(code-1)); |
| 4706 |
else |
| 4707 |
level = -get_bits(&s->gb, code-1) - (1<<(code-1)); |
| 4708 |
} |
| 4709 |
}else{ |
| 4710 |
level = get_xbits(&s->gb, code); |
| 4711 |
} |
| 4712 |
|
| 4713 |
if (code > 8){ |
| 4714 |
if(get_bits1(&s->gb)==0){ /* marker */ |
| 4715 |
if(s->error_resilience>=2){ |
| 4716 |
av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n"); |
| 4717 |
return -1; |
| 4718 |
} |
| 4719 |
} |
| 4720 |
} |
| 4721 |
} |
| 4722 |
|
| 4723 |
return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); |
| 4724 |
} |
| 4725 |
|
| 4726 |
/** |
| 4727 |
* decodes a block. |
| 4728 |
* @return <0 if an error occured |
| 4729 |
*/ |
| 4730 |
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, |
| 4731 |
int n, int coded, int intra, int rvlc) |
| 4732 |
{ |
| 4733 |
int level, i, last, run; |
| 4734 |
int dc_pred_dir; |
| 4735 |
RLTable * rl; |
| 4736 |
RL_VLC_ELEM * rl_vlc; |
| 4737 |
const uint8_t * scan_table; |
| 4738 |
int qmul, qadd; |
| 4739 |
|
| 4740 |
//Note intra & rvlc should be optimized away if this is inlined |
| 4741 |
|
| 4742 |
if(intra) { |
| 4743 |
if(s->qscale < s->intra_dc_threshold){ |
| 4744 |
/* DC coef */ |
| 4745 |
if(s->partitioned_frame){ |
| 4746 |
level = s->dc_val[0][ s->block_index[n] ]; |
| 4747 |
if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); |
| 4748 |
else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); |
| 4749 |
dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
| 4750 |
}else{ |
| 4751 |
level = mpeg4_decode_dc(s, n, &dc_pred_dir); |
| 4752 |
if (level < 0) |
| 4753 |
return -1; |
| 4754 |
} |
| 4755 |
block[0] = level; |
| 4756 |
i = 0; |
| 4757 |
}else{ |
| 4758 |
i = -1; |
| 4759 |
} |
| 4760 |
if (!coded) |
| 4761 |
goto not_coded; |
| 4762 |
|
| 4763 |
if(rvlc){ |
| 4764 |
rl = &rvlc_rl_intra; |
| 4765 |
rl_vlc = rvlc_rl_intra.rl_vlc[0]; |
| 4766 |
}else{ |
| 4767 |
rl = &rl_intra; |
| 4768 |
rl_vlc = rl_intra.rl_vlc[0]; |
| 4769 |
} |
| 4770 |
if (s->ac_pred) { |
| 4771 |
if (dc_pred_dir == 0) |
| 4772 |
scan_table = s->intra_v_scantable.permutated; /* left */ |
| 4773 |
else |
| 4774 |
scan_table = s->intra_h_scantable.permutated; /* top */ |
| 4775 |
} else { |
| 4776 |
scan_table = s->intra_scantable.permutated; |
| 4777 |
} |
| 4778 |
qmul=1; |
| 4779 |
qadd=0; |
| 4780 |
} else { |
| 4781 |
i = -1; |
| 4782 |
if (!coded) { |
| 4783 |
s->block_last_index[n] = i; |
| 4784 |
return 0; |
| 4785 |
} |
| 4786 |
if(rvlc) rl = &rvlc_rl_inter; |
| 4787 |
else rl = &rl_inter; |
| 4788 |
|
| 4789 |
scan_table = s->intra_scantable.permutated; |
| 4790 |
|
| 4791 |
if(s->mpeg_quant){ |
| 4792 |
qmul=1; |
| 4793 |
qadd=0; |
| 4794 |
if(rvlc){ |
| 4795 |
rl_vlc = rvlc_rl_inter.rl_vlc[0]; |
| 4796 |
}else{ |
| 4797 |
rl_vlc = rl_inter.rl_vlc[0]; |
| 4798 |
} |
4886 |
} |
|
|
4887 |
} else { |
| 4888 |
level = get_bits(&s->gb, 8); |
| 4889 |
if (level == 255) |
| 4890 |
level = 128; |
| 4891 |
} |
| 4892 |
#endif |
| 4799 |
}else{ |
4893 |
}else{ |
| 4800 |
qmul = s->qscale << 1; |
4894 |
level = get_bits(&s->gb, 8); |
| 4801 |
qadd = (s->qscale - 1) | 1; |
4895 |
if((level&0x7F) == 0){ |
| 4802 |
if(rvlc){ |
4896 |
av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
| 4803 |
rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; |
4897 |
if(s->error_resilience >= FF_ER_COMPLIANT) |
| 4804 |
}else{ |
4898 |
return -1; |
| 4805 |
rl_vlc = rl_inter.rl_vlc[s->qscale]; |
|
|
| 4806 |
} |
4899 |
} |
|
|
4900 |
if (level == 255) |
| 4901 |
level = 128; |
| 4807 |
} |
4902 |
} |
|
|
4903 |
block[0] = level; |
| 4904 |
i = 1; |
| 4905 |
} else { |
| 4906 |
i = 0; |
| 4808 |
} |
4907 |
} |
| 4809 |
{ |
4908 |
if (!coded) { |
| 4810 |
OPEN_READER(re, &s->gb); |
4909 |
if (s->mb_intra && s->h263_aic) |
|
|
4910 |
goto not_coded; |
| 4911 |
s->block_last_index[n] = i - 1; |
| 4912 |
return 0; |
| 4913 |
} |
| 4914 |
retry: |
| 4811 |
for(;;) { |
4915 |
for(;;) { |
| 4812 |
UPDATE_CACHE(re, &s->gb); |
4916 |
code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); |
| 4813 |
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
4917 |
if (code < 0){ |
| 4814 |
if (level==0) { |
4918 |
av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
| 4815 |
/* escape */ |
4919 |
return -1; |
| 4816 |
if(rvlc){ |
4920 |
} |
| 4817 |
if(SHOW_UBITS(re, &s->gb, 1)==0){ |
4921 |
if (code == rl->n) { |
| 4818 |
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); |
4922 |
/* escape */ |
| 4819 |
return -1; |
4923 |
if (s->h263_flv > 1) { |
| 4820 |
}; SKIP_CACHE(re, &s->gb, 1); |
4924 |
int is11 = get_bits1(&s->gb); |
| 4821 |
|
4925 |
last = get_bits1(&s->gb); |
| 4822 |
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
4926 |
run = get_bits(&s->gb, 6); |
| 4823 |
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); |
4927 |
if(is11){ |
| 4824 |
SKIP_COUNTER(re, &s->gb, 1+1+6); |
4928 |
level = get_sbits(&s->gb, 11); |
| 4825 |
UPDATE_CACHE(re, &s->gb); |
|
|
| 4826 |
|
| 4827 |
if(SHOW_UBITS(re, &s->gb, 1)==0){ |
| 4828 |
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); |
| 4829 |
return -1; |
| 4830 |
}; SKIP_CACHE(re, &s->gb, 1); |
| 4831 |
|
| 4832 |
level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); |
| 4833 |
|
| 4834 |
if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ |
| 4835 |
av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); |
| 4836 |
return -1; |
| 4837 |
}; SKIP_CACHE(re, &s->gb, 5); |
| 4838 |
|
| 4839 |
level= level * qmul + qadd; |
| 4840 |
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); |
| 4841 |
SKIP_COUNTER(re, &s->gb, 1+11+5+1); |
| 4842 |
|
| 4843 |
i+= run + 1; |
| 4844 |
if(last) i+=192; |
| 4845 |
}else{ |
| 4846 |
int cache; |
| 4847 |
cache= GET_CACHE(re, &s->gb); |
| 4848 |
|
| 4849 |
if(IS_3IV1) |
| 4850 |
cache ^= 0xC0000000; |
| 4851 |
|
| 4852 |
if (cache&0x80000000) { |
| 4853 |
if (cache&0x40000000) { |
| 4854 |
/* third escape */ |
| 4855 |
SKIP_CACHE(re, &s->gb, 2); |
| 4856 |
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
| 4857 |
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); |
| 4858 |
SKIP_COUNTER(re, &s->gb, 2+1+6); |
| 4859 |
UPDATE_CACHE(re, &s->gb); |
| 4860 |
|
| 4861 |
if(IS_3IV1){ |
| 4862 |
level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12); |
| 4863 |
}else{ |
| 4864 |
if(SHOW_UBITS(re, &s->gb, 1)==0){ |
| 4865 |
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n"); |
| 4866 |
return -1; |
| 4867 |
}; SKIP_CACHE(re, &s->gb, 1); |
| 4868 |
|
| 4869 |
level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); |
| 4870 |
|
| 4871 |
if(SHOW_UBITS(re, &s->gb, 1)==0){ |
| 4872 |
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n"); |
| 4873 |
return -1; |
| 4874 |
}; LAST_SKIP_CACHE(re, &s->gb, 1); |
| 4875 |
|
| 4876 |
SKIP_COUNTER(re, &s->gb, 1+12+1); |
| 4877 |
} |
| 4878 |
|
| 4879 |
#if 0 |
| 4880 |
if(s->error_resilience >= FF_ER_COMPLIANT){ |
| 4881 |
const int abs_level= ABS(level); |
| 4882 |
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
| 4883 |
const int run1= run - rl->max_run[last][abs_level] - 1; |
| 4884 |
if(abs_level <= rl->max_level[last][run]){ |
| 4885 |
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); |
| 4886 |
return -1; |
| 4887 |
} |
| 4888 |
if(s->error_resilience > FF_ER_COMPLIANT){ |
| 4889 |
if(abs_level <= rl->max_level[last][run]*2){ |
| 4890 |
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); |
| 4891 |
return -1; |
| 4892 |
} |
| 4893 |
if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ |
| 4894 |
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); |
| 4895 |
return -1; |
| 4896 |
} |
| 4897 |
} |
| 4898 |
} |
| 4899 |
} |
| 4900 |
#endif |
| 4901 |
if (level>0) level= level * qmul + qadd; |
| 4902 |
else level= level * qmul - qadd; |
| 4903 |
|
| 4904 |
if((unsigned)(level + 2048) > 4095){ |
| 4905 |
if(s->error_resilience > FF_ER_COMPLIANT){ |
| 4906 |
if(level > 2560 || level<-2560){ |
| 4907 |
av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); |
| 4908 |
return -1; |
| 4909 |
} |
| 4910 |
} |
| 4911 |
level= level<0 ? -2048 : 2047; |
| 4912 |
} |
| 4913 |
|
| 4914 |
i+= run + 1; |
| 4915 |
if(last) i+=192; |
| 4916 |
} else { |
4929 |
} else { |
| 4917 |
/* second escape */ |
4930 |
level = get_sbits(&s->gb, 7); |
| 4918 |
#if MIN_CACHE_BITS < 20 |
|
|
| 4919 |
LAST_SKIP_BITS(re, &s->gb, 2); |
| 4920 |
UPDATE_CACHE(re, &s->gb); |
| 4921 |
#else |
| 4922 |
SKIP_BITS(re, &s->gb, 2); |
| 4923 |
#endif |
| 4924 |
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
| 4925 |
i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing |
| 4926 |
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); |
| 4927 |
LAST_SKIP_BITS(re, &s->gb, 1); |
| 4928 |
} |
4931 |
} |
| 4929 |
} else { |
4932 |
} else { |
| 4930 |
/* first escape */ |
4933 |
last = get_bits1(&s->gb); |
| 4931 |
#if MIN_CACHE_BITS < 19 |
4934 |
run = get_bits(&s->gb, 6); |
| 4932 |
LAST_SKIP_BITS(re, &s->gb, 1); |
4935 |
level = (int8_t)get_bits(&s->gb, 8); |
| 4933 |
UPDATE_CACHE(re, &s->gb); |
4936 |
if(level == -128){ |
| 4934 |
#else |
4937 |
if (s->codec_id == CODEC_ID_RV10) { |
| 4935 |
SKIP_BITS(re, &s->gb, 1); |
4938 |
/* XXX: should patch encoder too */ |
| 4936 |
#endif |
4939 |
level = get_sbits(&s->gb, 12); |
| 4937 |
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
4940 |
}else{ |
| 4938 |
i+= run; |
4941 |
level = get_bits(&s->gb, 5); |
| 4939 |
level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing |
4942 |
level |= get_sbits(&s->gb, 6)<<5; |
| 4940 |
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); |
4943 |
} |
| 4941 |
LAST_SKIP_BITS(re, &s->gb, 1); |
4944 |
} |
| 4942 |
} |
4945 |
} |
| 4943 |
} |
|
|
| 4944 |
} else { |
4946 |
} else { |
| 4945 |
i+= run; |
4947 |
run = rl->table_run[code]; |
| 4946 |
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); |
4948 |
level = rl->table_level[code]; |
| 4947 |
LAST_SKIP_BITS(re, &s->gb, 1); |
4949 |
last = code >= rl->last; |
|
|
4950 |
if (get_bits1(&s->gb)) |
| 4951 |
level = -level; |
| 4948 |
} |
4952 |
} |
| 4949 |
if (i > 62){ |
4953 |
i += run; |
| 4950 |
i-= 192; |
4954 |
if (i >= 64){ |
| 4951 |
if(i&(~63)){ |
4955 |
if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ |
| 4952 |
av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
4956 |
//looks like a hack but no, it's the way its supposed to work ... |
| 4953 |
return -1; |
4957 |
rl = &rl_intra_aic; |
|
|
4958 |
i = 0; |
| 4959 |
s->gb= gb; |
| 4960 |
memset(block, 0, sizeof(DCTELEM)*64); |
| 4961 |
goto retry; |
| 4954 |
} |
4962 |
} |
| 4955 |
|
4963 |
av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); |
| 4956 |
block[scan_table[i]] = level; |
4964 |
return -1; |
| 4957 |
break; |
|
|
| 4958 |
} |
4965 |
} |
| 4959 |
|
4966 |
j = scan_table[i]; |
| 4960 |
block[scan_table[i]] = level; |
4967 |
block[j] = level; |
|
|
4968 |
if (last) |
| 4969 |
break; |
| 4970 |
i++; |
| 4961 |
} |
4971 |
} |
| 4962 |
CLOSE_READER(re, &s->gb); |
4972 |
not_coded: |
| 4963 |
} |
4973 |
if (s->mb_intra && s->h263_aic) { |
| 4964 |
not_coded: |
4974 |
h263_pred_acdc(s, block, n); |
| 4965 |
if (intra) { |
4975 |
i = 63; |
| 4966 |
if(s->qscale >= s->intra_dc_threshold){ |
|
|
| 4967 |
block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); |
| 4968 |
|
| 4969 |
if(i == -1) i=0; |
| 4970 |
} |
| 4971 |
|
| 4972 |
mpeg4_pred_ac(s, block, n, dc_pred_dir); |
| 4973 |
if (s->ac_pred) { |
| 4974 |
i = 63; /* XXX: not optimal */ |
| 4975 |
} |
| 4976 |
} |
4976 |
} |
| 4977 |
s->block_last_index[n] = i; |
4977 |
s->block_last_index[n] = i; |
| 4978 |
return 0; |
4978 |
return 0; |
