* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
- * ac prediction encoding & b-frame support by Michael Niedermayer <michaelni@gmx.at>
+ * ac prediction encoding, b-frame support, error resilience, optimizations,
+ * qpel decoding, gmc decoding, interlaced decoding,
+ * by Michael Niedermayer <michaelni@gmx.at>
*/
//#define DEBUG
#include "h263data.h"
#include "mpeg4data.h"
+//#undef NDEBUG
+//#include <assert.h>
+
//rounded divison & shift
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
-#define PRINT_MB_TYPE(a) ;
-//#define PRINT_MB_TYPE(a) printf(a);
+#if 1
+#define PRINT_MB_TYPE(a) {}
+#else
+#define PRINT_MB_TYPE(a) printf(a)
+#endif
+
+#define INTRA_MCBPC_VLC_BITS 6
+#define INTER_MCBPC_VLC_BITS 6
+#define CBPY_VLC_BITS 6
+#define MV_VLC_BITS 9
+#define DC_VLC_BITS 9
+#define SPRITE_TRAJ_VLC_BITS 6
+#define MB_TYPE_B_VLC_BITS 4
+#define TEX_VLC_BITS 9
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
int n);
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
static void h263p_encode_umotion(MpegEncContext * s, int val);
-static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
+static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
int n, int dc, UINT8 *scan_table,
PutBitContext *dc_pb, PutBitContext *ac_pb);
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
int n, int coded);
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
- int n, int coded);
+ int n, int coded, int intra);
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
-static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
int dir);
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
static UINT16 uni_DCtab_lum [512][2];
static UINT16 uni_DCtab_chrom[512][2];
+static UINT32 uni_mpeg4_intra_rl_bits[64*64*2*2];
+static UINT8 uni_mpeg4_intra_rl_len [64*64*2*2];
+static UINT32 uni_mpeg4_inter_rl_bits[64*64*2*2];
+static UINT8 uni_mpeg4_inter_rl_len [64*64*2*2];
+#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
+//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
+
+/* mpeg4
+inter
+max level: 24/6
+max run: 53/63
+
+intra
+max level: 53/16
+max run: 29/41
+*/
int h263_get_picture_format(int width, int height)
{
/* Custom Picture Format (CPFMT) */
if (s->aspect_ratio_info)
- put_bits(&s->pb,4,s->aspect_ratio_info);
+ put_bits(&s->pb,4,s->aspect_ratio_info);
else
- put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
+ put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
put_bits(&s->pb,9,(s->width >> 2) - 1);
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
put_bits(&s->pb,9,(s->height >> 2));
+ if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
+ {
+ put_bits(&s->pb, 8, s->aspected_width);
+ put_bits(&s->pb, 8, s->aspected_height);
+ }
}
/* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
}
put_bits(&s->pb, 1, 0); /* no PEI */
+
+ if(s->h263_aic){
+ s->y_dc_scale_table=
+ s->c_dc_scale_table= h263_aic_dc_scale_table;
+ }else{
+ s->y_dc_scale_table=
+ s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
+ }
}
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
ac_val1= ac_val;
if(dir[n]){
+ const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
+ /* top prediction */
ac_val-= s->block_wrap[n]*16;
- for(i=1; i<8; i++){
- const int level= block[n][block_permute_op(i )];
- score0+= ABS(level);
- score1+= ABS(level - ac_val[i+8]);
- ac_val1[i ]= block[n][block_permute_op(i<<3)];
- ac_val1[i+8]= level;
+ if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
+ /* same qscale */
+ for(i=1; i<8; i++){
+ const int level= block[n][block_permute_op(i )];
+ score0+= ABS(level);
+ score1+= ABS(level - ac_val[i+8]);
+ ac_val1[i ]= block[n][block_permute_op(i<<3)];
+ ac_val1[i+8]= level;
+ }
+ }else{
+ /* different qscale, we must rescale */
+ for(i=1; i<8; i++){
+ const int level= block[n][block_permute_op(i )];
+ score0+= ABS(level);
+ score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale));
+ ac_val1[i ]= block[n][block_permute_op(i<<3)];
+ ac_val1[i+8]= level;
+ }
}
}else{
+ const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
+ /* left prediction */
ac_val-= 16;
- for(i=1; i<8; i++){
- const int level= block[n][block_permute_op(i<<3)];
- score0+= ABS(level);
- score1+= ABS(level - ac_val[i]);
- ac_val1[i ]= level;
- ac_val1[i+8]= block[n][block_permute_op(i )];
+ if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
+ /* same qscale */
+ for(i=1; i<8; i++){
+ const int level= block[n][block_permute_op(i<<3)];
+ score0+= ABS(level);
+ score1+= ABS(level - ac_val[i]);
+ ac_val1[i ]= level;
+ ac_val1[i+8]= block[n][block_permute_op(i )];
+ }
+ }else{
+ /* different qscale, we must rescale */
+ for(i=1; i<8; i++){
+ const int level= block[n][block_permute_op(i<<3)];
+ score0+= ABS(level);
+ score1+= ABS(level - ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale));
+ ac_val1[i ]= level;
+ ac_val1[i+8]= block[n][block_permute_op(i )];
+ }
}
}
}
return score0 > score1 ? 1 : 0;
}
+void ff_clean_h263_qscales(MpegEncContext *s){
+ int i;
+
+ for(i=1; i<s->mb_num; i++){
+ if(s->qscale_table[i] - s->qscale_table[i-1] >2)
+ s->qscale_table[i]= s->qscale_table[i-1]+2;
+ }
+ for(i=s->mb_num-2; i>=0; i--){
+ if(s->qscale_table[i] - s->qscale_table[i+1] >2)
+ s->qscale_table[i]= s->qscale_table[i+1]+2;
+ }
+}
+
+void ff_clean_mpeg4_qscales(MpegEncContext *s){
+ int i;
+
+ ff_clean_h263_qscales(s);
+
+ for(i=1; i<s->mb_num; i++){
+ if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
+ s->mb_type[i]&= ~MB_TYPE_INTER4V;
+ s->mb_type[i]|= MB_TYPE_INTER;
+ }
+ }
+
+ if(s->pict_type== B_TYPE){
+ int odd=0;
+ /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
+ for the actual adaptive quantization */
+
+ for(i=0; i<s->mb_num; i++){
+ odd += s->qscale_table[i]&1;
+ }
+
+ if(2*odd > s->mb_num) odd=1;
+ else odd=0;
+
+ for(i=0; i<s->mb_num; i++){
+ if((s->qscale_table[i]&1) != odd)
+ s->qscale_table[i]++;
+ if(s->qscale_table[i] > 31)
+ s->qscale_table[i]= 31;
+ }
+
+ for(i=1; i<s->mb_num; i++){
+ if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
+ s->mb_type[i]&= ~MB_TYPE_DIRECT;
+ s->mb_type[i]|= MB_TYPE_BIDIR;
+ }
+ }
+ }
+}
+
void mpeg4_encode_mb(MpegEncContext * s,
DCTELEM block[6][64],
int motion_x, int motion_y)
PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
+ const int dquant_code[5]= {1,0,9,2,3};
// printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
if (!s->mb_intra) {
s->last_mv[1][0][0]=
s->last_mv[1][0][1]= 0;
}
+
+ assert(s->dquant>=-2 && s->dquant<=2);
+ assert((s->dquant&1)==0);
+ assert(mb_type>=0);
/* nothing to do if this MB was skiped in the next P Frame */
- if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){
+ if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
s->skip_count++;
s->mv[0][0][0]=
s->mv[0][0][1]=
s->mv[1][0][0]=
s->mv[1][0][1]= 0;
s->mv_dir= MV_DIR_FORWARD; //doesnt matter
+ s->qscale -= s->dquant;
return;
}
if ((cbp | motion_x | motion_y | mb_type) ==0) {
/* direct MB with MV={0,0} */
+ assert(s->dquant==0);
+
put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
if(interleaved_stats){
put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
if(cbp) put_bits(&s->pb, 6, cbp);
- if(cbp && mb_type)
- put_bits(&s->pb, 1, 0); /* no q-scale change */
+ if(cbp && mb_type){
+ if(s->dquant)
+ put_bits(&s->pb, 2, (s->dquant>>2)+3);
+ else
+ put_bits(&s->pb, 1, 0);
+ }else
+ s->qscale -= s->dquant;
+
+ if(!s->progressive_sequence){
+ if(cbp)
+ put_bits(&s->pb, 1, s->interlaced_dct);
+ if(mb_type) // not diect mode
+ put_bits(&s->pb, 1, 0); // no interlaced ME yet
+ }
if(interleaved_stats){
bits= get_bit_count(&s->pb);
case 0: /* direct */
h263_encode_motion(s, motion_x, 1);
h263_encode_motion(s, motion_y, 1);
+ s->b_count++;
+ s->f_count++;
break;
case 1: /* bidir */
h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
s->last_mv[0][0][1]= s->mv[0][0][1];
s->last_mv[1][0][0]= s->mv[1][0][0];
s->last_mv[1][0][1]= s->mv[1][0][1];
+ s->b_count++;
+ s->f_count++;
break;
case 2: /* backward */
h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
s->last_mv[1][0][0]= motion_x;
s->last_mv[1][0][1]= motion_y;
+ s->b_count++;
break;
case 3: /* forward */
h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
s->last_mv[0][0][0]= motion_x;
s->last_mv[0][0][1]= motion_y;
+ s->f_count++;
break;
default:
printf("unknown mb type\n");
s->last_bits=bits;
}
}else{ /* s->pict_type==B_TYPE */
- if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
+ if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
/* check if the B frames can skip it too, as we must skip it if we skip here
why didnt they just compress the skip-mb bits instead of reusing them ?! */
if(s->max_b_frames>0){
put_bits(&s->pb, 1, 0); /* mb coded */
if(s->mv_type==MV_TYPE_16X16){
cbpc = cbp & 3;
+ if(s->dquant) cbpc+= 8;
put_bits(&s->pb,
inter_MCBPC_bits[cbpc],
inter_MCBPC_code[cbpc]);
+
cbpy = cbp >> 2;
cbpy ^= 0xf;
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
+ if(s->dquant)
+ put_bits(pb2, 2, dquant_code[s->dquant+2]);
+
+ if(!s->progressive_sequence){
+ if(cbp)
+ put_bits(pb2, 1, s->interlaced_dct);
+ put_bits(pb2, 1, 0); // no interlaced ME yet
+ }
if(interleaved_stats){
bits= get_bit_count(&s->pb);
s->p_tex_bits+= bits - s->last_bits;
s->last_bits=bits;
}
- s->p_count++;
+ s->f_count++;
}
} else {
int cbp;
const int level= block[i][0];
UINT16 *dc_ptr;
- dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
+ dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
if (i < 4) {
*dc_ptr = level * s->y_dc_scale;
} else {
cbpc = cbp & 3;
if (s->pict_type == I_TYPE) {
+ if(s->dquant) cbpc+=4;
put_bits(&s->pb,
intra_MCBPC_bits[cbpc],
intra_MCBPC_code[cbpc]);
} else {
+ if(s->dquant) cbpc+=8;
put_bits(&s->pb, 1, 0); /* mb coded */
put_bits(&s->pb,
inter_MCBPC_bits[cbpc + 4],
put_bits(pb2, 1, s->ac_pred);
cbpy = cbp >> 2;
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
+ if(s->dquant)
+ put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
+
+ if(!s->progressive_sequence){
+ put_bits(dc_pb, 1, s->interlaced_dct);
+ }
if(interleaved_stats){
bits= get_bit_count(&s->pb);
INT16 pred_dc;
INT16 rec_intradc[6];
UINT16 *dc_ptr[6];
+ const int dquant_code[5]= {1,0,9,2,3};
//printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
if (!s->mb_intra) {
if (s->block_last_index[i] >= 0)
cbp |= 1 << (5 - i);
}
- if ((cbp | motion_x | motion_y) == 0) {
+ if ((cbp | motion_x | motion_y | s->dquant) == 0) {
/* skip macroblock */
put_bits(&s->pb, 1, 1);
return;
}
put_bits(&s->pb, 1, 0); /* mb coded */
cbpc = cbp & 3;
+ if(s->dquant) cbpc+= 8;
put_bits(&s->pb,
inter_MCBPC_bits[cbpc],
inter_MCBPC_code[cbpc]);
cbpy = cbp >> 2;
cbpy ^= 0xf;
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
+ if(s->dquant)
+ put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
/* motion vectors: 16x16 mode only now */
h263_pred_motion(s, 0, &pred_x, &pred_y);
cbpc = cbp & 3;
if (s->pict_type == I_TYPE) {
+ if(s->dquant) cbpc+=4;
put_bits(&s->pb,
intra_MCBPC_bits[cbpc],
intra_MCBPC_code[cbpc]);
} else {
+ if(s->dquant) cbpc+=8;
put_bits(&s->pb, 1, 0); /* mb coded */
put_bits(&s->pb,
inter_MCBPC_bits[cbpc + 4],
}
cbpy = cbp >> 2;
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
+ if(s->dquant)
+ put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
}
for(i=0; i<6; i++) {
} else if (val >= l) {
val -= m;
}
+ assert(val>=-l && val<l);
if (val >= 0) {
sign = 0;
}
}
-static void init_uni_dc_tab()
+static void init_uni_dc_tab(void)
{
int level, uni_code, uni_len;
}
}
+static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
+ int slevel, run, last;
+
+ assert(MAX_LEVEL >= 64);
+ assert(MAX_RUN >= 63);
+
+ for(slevel=-64; slevel<64; slevel++){
+ if(slevel==0) continue;
+ for(run=0; run<64; run++){
+ for(last=0; last<=1; last++){
+ const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
+ int level= slevel < 0 ? -slevel : slevel;
+ int sign= slevel < 0 ? 1 : 0;
+ int bits, len, code;
+ int level1, run1;
+
+ len_tab[index]= 100;
+
+ /* ESC0 */
+ code= get_rl_index(rl, last, run, level);
+ bits= rl->table_vlc[code][0];
+ len= rl->table_vlc[code][1];
+ bits=bits*2+sign; len++;
+
+ if(code!=rl->n && len < len_tab[index]){
+ bits_tab[index]= bits;
+ len_tab [index]= len;
+ }
+#if 1
+ /* ESC1 */
+ bits= rl->table_vlc[rl->n][0];
+ len= rl->table_vlc[rl->n][1];
+ bits=bits*2; len++; //esc1
+ level1= level - rl->max_level[last][run];
+ if(level1>0){
+ code= get_rl_index(rl, last, run, level1);
+ bits<<= rl->table_vlc[code][1];
+ len += rl->table_vlc[code][1];
+ bits += rl->table_vlc[code][0];
+ bits=bits*2+sign; len++;
+
+ if(code!=rl->n && len < len_tab[index]){
+ bits_tab[index]= bits;
+ len_tab [index]= len;
+ }
+ }
+#endif
+#if 1
+ /* ESC2 */
+ bits= rl->table_vlc[rl->n][0];
+ len= rl->table_vlc[rl->n][1];
+ bits=bits*4+2; len+=2; //esc2
+ run1 = run - rl->max_run[last][level] - 1;
+ if(run1>=0){
+ code= get_rl_index(rl, last, run1, level);
+ bits<<= rl->table_vlc[code][1];
+ len += rl->table_vlc[code][1];
+ bits += rl->table_vlc[code][0];
+ bits=bits*2+sign; len++;
+
+ if(code!=rl->n && len < len_tab[index]){
+ bits_tab[index]= bits;
+ len_tab [index]= len;
+ }
+ }
+#endif
+ /* ESC3 */
+ bits= rl->table_vlc[rl->n][0];
+ len = rl->table_vlc[rl->n][1];
+ bits=bits*4+3; len+=2; //esc3
+ bits=bits*2+last; len++;
+ bits=bits*64+run; len+=6;
+ bits=bits*2+1; len++; //marker
+ bits=bits*4096+(slevel&0xfff); len+=12;
+ bits=bits*2+1; len++; //marker
+
+ if(len < len_tab[index]){
+ bits_tab[index]= bits;
+ len_tab [index]= len;
+ }
+ }
+ }
+ }
+}
+
void h263_encode_init(MpegEncContext *s)
{
static int done = 0;
init_rl(&rl_inter);
init_rl(&rl_intra);
init_rl(&rl_intra_aic);
+
+ init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
+ init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
init_mv_penalty_and_fcode(s);
}
s->min_qcoeff= -128;
s->max_qcoeff= 127;
break;
+ //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
default: //nothing needed default table allready set in mpegvideo.c
s->min_qcoeff= -128;
s->max_qcoeff= 127;
+ s->y_dc_scale_table=
+ s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
}
- /* h263 type bias */
- //FIXME mpeg4 mpeg quantizer
- s->intra_quant_bias=0;
- s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
+ if(s->mpeg_quant){
+ s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
+ s->inter_quant_bias= 0;
+ }else{
+ s->intra_quant_bias=0;
+ s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
+ }
}
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
}
-
- s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
+
+ if(s->avctx->pts)
+ s->time= (s->avctx->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
+ else
+ s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
time_div= s->time/s->time_increment_resolution;
time_mod= s->time%s->time_increment_resolution;
if(s->pict_type==B_TYPE){
- s->bp_time= s->last_non_b_time - s->time;
+ s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
}else{
s->last_time_base= s->time_base;
s->time_base= time_div;
put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
else
put_bits(&s->pb, 4, 1); /* aspect ratio info= sqare pixel */
+ if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
+ {
+ put_bits(&s->pb, 8, s->aspected_width);
+ put_bits(&s->pb, 8, s->aspected_height);
+ }
if(s->low_delay){
put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
put_bits(&s->pb, 1, 1); /* marker bit */
put_bits(&s->pb, 13, s->height); /* vol height */
put_bits(&s->pb, 1, 1); /* marker bit */
- put_bits(&s->pb, 1, 0); /* interlace */
+ put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
put_bits(&s->pb, 1, 1); /* obmc disable */
if (vo_ver_id == 1) {
put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
}
put_bits(&s->pb, 1, 0); /* not 8 bit */
- put_bits(&s->pb, 1, 0); /* quant type= h263 style*/
+ put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
+ if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
+
if (vo_ver_id != 1)
put_bits(&s->pb, 1, s->quarter_sample=0);
put_bits(&s->pb, 1, 1); /* complexity estimation disable */
put_bits(&s->pb, 1, 0); /* reduced res vop */
}
put_bits(&s->pb, 1, 0); /* scalability */
-
+
ff_mpeg4_stuffing(&s->pb);
- put_bits(&s->pb, 16, 0);
- put_bits(&s->pb, 16, 0x1B2); /* user_data */
- sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
- put_string(&s->pb, buf);
- ff_mpeg4_stuffing(&s->pb);
+ /* user data */
+ if(!ff_bit_exact){
+ put_bits(&s->pb, 16, 0);
+ put_bits(&s->pb, 16, 0x1B2); /* user_data */
+ sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
+ put_string(&s->pb, buf);
+ ff_mpeg4_stuffing(&s->pb);
+ }
}
/* write mpeg4 VOP header */
put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
}
put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
+ if(!s->progressive_sequence){
+ put_bits(&s->pb, 1, s->top_field_first);
+ put_bits(&s->pb, 1, s->alternate_scan);
+ }
//FIXME sprite stuff
put_bits(&s->pb, 5, s->qscale);
if (s->pict_type == B_TYPE)
put_bits(&s->pb, 3, s->b_code); /* fcode_back */
// printf("****frame %d\n", picture_number);
+
+ s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
+ s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
+ s->h_edge_pos= s->width;
+ s->v_edge_pos= s->height;
}
-void h263_dc_scale(MpegEncContext * s)
+static void change_qscale(MpegEncContext * s, int dquant)
{
-#if 1
- const static UINT8 y_tab[32]={
- // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
- 0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
- };
- const static UINT8 c_tab[32]={
- // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
- 0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
- };
- s->y_dc_scale = y_tab[s->qscale];
- s->c_dc_scale = c_tab[s->qscale];
-#else
- int quant;
- quant = s->qscale;
- /* luminance */
- if (quant < 5)
- s->y_dc_scale = 8;
- else if (quant > 4 && quant < 9)
- s->y_dc_scale = (2 * quant);
- else if (quant > 8 && quant < 25)
- s->y_dc_scale = (quant + 8);
- else
- s->y_dc_scale = (2 * quant - 16);
- /* chrominance */
- if (quant < 5)
- s->c_dc_scale = 8;
- else if (quant > 4 && quant < 25)
- s->c_dc_scale = ((quant + 13) / 2);
- else
- s->c_dc_scale = (quant - 6);
-#endif
+ s->qscale += dquant;
+
+ if (s->qscale < 1)
+ s->qscale = 1;
+ else if (s->qscale > 31)
+ s->qscale = 31;
+
+ s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
+ s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
}
-static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
+inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
{
int a, b, c, wrap, pred, scale;
UINT16 *dc_val;
ac_val1 = ac_val;
if (s->ac_pred) {
if (dir == 0) {
+ const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
/* left prediction */
ac_val -= 16;
- for(i=1;i<8;i++) {
- block[block_permute_op(i*8)] += ac_val[i];
+
+ if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
+ /* same qscale */
+ for(i=1;i<8;i++) {
+ block[block_permute_op(i*8)] += ac_val[i];
+ }
+ }else{
+ /* different qscale, we must rescale */
+ for(i=1;i<8;i++) {
+ block[block_permute_op(i*8)] += ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
+ }
}
} else {
+ const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
/* top prediction */
ac_val -= 16 * s->block_wrap[n];
- for(i=1;i<8;i++) {
- block[block_permute_op(i)] += ac_val[i + 8];
+
+ if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
+ /* same qscale */
+ for(i=1;i<8;i++) {
+ block[block_permute_op(i)] += ac_val[i + 8];
+ }
+ }else{
+ /* different qscale, we must rescale */
+ for(i=1;i<8;i++) {
+ block[block_permute_op(i)] += ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
+ }
}
}
}
/* left copy */
for(i=1;i<8;i++)
ac_val1[i] = block[block_permute_op(i * 8)];
+
/* top copy */
for(i=1;i<8;i++)
ac_val1[8 + i] = block[block_permute_op(i)];
+
}
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
if (dir == 0) {
+ const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
/* left prediction */
ac_val -= 16;
- for(i=1;i<8;i++) {
- block[block_permute_op(i*8)] -= ac_val[i];
+ if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
+ /* same qscale */
+ for(i=1;i<8;i++) {
+ block[block_permute_op(i*8)] -= ac_val[i];
+ }
+ }else{
+ /* different qscale, we must rescale */
+ for(i=1;i<8;i++) {
+ block[block_permute_op(i*8)] -= ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
+ }
}
} else {
+ const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
/* top prediction */
ac_val -= 16 * s->block_wrap[n];
- for(i=1;i<8;i++) {
- block[block_permute_op(i)] -= ac_val[i + 8];
+ if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
+ /* same qscale */
+ for(i=1;i<8;i++) {
+ block[block_permute_op(i)] -= ac_val[i + 8];
+ }
+ }else{
+ /* different qscale, we must rescale */
+ for(i=1;i<8;i++) {
+ block[block_permute_op(i)] -= ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
+ }
}
}
}
#endif
}
-static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
+static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
{
- int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
+ int last, i, last_non_zero, sign;
int code;
const RLTable *rl;
+ UINT32 *bits_tab;
+ UINT8 *len_tab;
+ const int last_index = s->block_last_index[n];
- if (s->mb_intra) {
+ if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
/* mpeg4 based DC predictor */
mpeg4_encode_dc(dc_pb, intra_dc, n);
+ if(last_index<1) return;
i = 1;
rl = &rl_intra;
+ bits_tab= uni_mpeg4_intra_rl_bits;
+ len_tab = uni_mpeg4_intra_rl_len;
} else {
+ if(last_index<0) return;
i = 0;
rl = &rl_inter;
+ bits_tab= uni_mpeg4_inter_rl_bits;
+ len_tab = uni_mpeg4_inter_rl_len;
}
/* AC coefs */
- last_index = s->block_last_index[n];
last_non_zero = i - 1;
- for (; i <= last_index; i++) {
- j = scan_table[i];
- level = block[j];
+#if 1
+ for (; i < last_index; i++) {
+ int level = block[ scan_table[i] ];
if (level) {
- run = i - last_non_zero - 1;
+ int run = i - last_non_zero - 1;
+ level+=64;
+ if((level&(~127)) == 0){
+ const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
+ put_bits(ac_pb, len_tab[index], bits_tab[index]);
+ }else{ //ESC3
+ put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
+ }
+ last_non_zero = i;
+ }
+ }
+ /*if(i<=last_index)*/{
+ int level = block[ scan_table[i] ];
+ int run = i - last_non_zero - 1;
+ level+=64;
+ if((level&(~127)) == 0){
+ const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
+ put_bits(ac_pb, len_tab[index], bits_tab[index]);
+ }else{ //ESC3
+ put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
+ }
+ }
+#else
+ for (; i <= last_index; i++) {
+ const int slevel = block[ scan_table[i] ];
+ if (slevel) {
+ int level;
+ int run = i - last_non_zero - 1;
last = (i == last_index);
sign = 0;
- slevel = level;
+ level = slevel;
if (level < 0) {
sign = 1;
level = -level;
last_non_zero = i;
}
}
+#endif
}
void init_vlc_rl(RLTable *rl)
{
+ int i, q;
+
init_vlc(&rl->vlc, 9, rl->n + 1,
&rl->table_vlc[0][1], 4, 2,
&rl->table_vlc[0][0], 4, 2);
+
+
+ for(q=0; q<32; q++){
+ int qmul= q*2;
+ int qadd= (q-1)|1;
+
+ if(q==0){
+ qmul=1;
+ qadd=0;
+ }
+
+ rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
+ for(i=0; i<rl->vlc.table_size; i++){
+ int code= rl->vlc.table[i][0];
+ int len = rl->vlc.table[i][1];
+ int level, run;
+
+ if(len==0){ // illegal code
+ run= 66;
+ level= MAX_LEVEL;
+ }else if(len<0){ //more bits needed
+ run= 0;
+ level= code;
+ }else{
+ if(code==rl->n){ //esc
+ run= 66;
+ level= 0;
+ }else{
+ run= rl->table_run [code] + 1;
+ level= rl->table_level[code] * qmul + qadd;
+ if(code >= rl->last) run+=192;
+ }
+ }
+ rl->rl_vlc[q][i].len= len;
+ rl->rl_vlc[q][i].level= level;
+ rl->rl_vlc[q][i].run= run;
+ }
+ }
}
/* init vlcs */
if (!done) {
done = 1;
- init_vlc(&intra_MCBPC_vlc, 6, 8,
+ init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
intra_MCBPC_bits, 1, 1,
intra_MCBPC_code, 1, 1);
- init_vlc(&inter_MCBPC_vlc, 9, 25,
+ init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
inter_MCBPC_bits, 1, 1,
inter_MCBPC_code, 1, 1);
- init_vlc(&cbpy_vlc, 6, 16,
+ init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
&cbpy_tab[0][1], 2, 1,
&cbpy_tab[0][0], 2, 1);
- init_vlc(&mv_vlc, 9, 33,
+ init_vlc(&mv_vlc, MV_VLC_BITS, 33,
&mvtab[0][1], 2, 1,
&mvtab[0][0], 2, 1);
init_rl(&rl_inter);
init_vlc_rl(&rl_inter);
init_vlc_rl(&rl_intra);
init_vlc_rl(&rl_intra_aic);
- init_vlc(&dc_lum, 9, 13,
+ init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
&DCtab_lum[0][1], 2, 1,
&DCtab_lum[0][0], 2, 1);
- init_vlc(&dc_chrom, 9, 13,
+ init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
&DCtab_chrom[0][1], 2, 1,
&DCtab_chrom[0][0], 2, 1);
- init_vlc(&sprite_trajectory, 9, 15,
+ init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
&sprite_trajectory_tab[0][1], 4, 2,
&sprite_trajectory_tab[0][0], 4, 2);
- init_vlc(&mb_type_b_vlc, 4, 4,
+ init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
&mb_type_b_tab[0][1], 2, 1,
&mb_type_b_tab[0][0], 2, 1);
}
+
+ s->progressive_sequence=1; // set to most likely for the case of incomplete headers
}
int h263_decode_gob_header(MpegEncContext *s)
if(header_extension){
int time_increment;
int time_incr=0;
- printf("header extension not supported\n");
- return -1;
while (get_bits1(gb) != 0)
time_incr++;
check_marker(gb, "before time_increment in video packed header");
time_increment= get_bits(gb, s->time_increment_bits);
- if(s->pict_type!=B_TYPE){
- s->last_time_base= s->time_base;
- s->time_base+= time_incr;
- s->time= s->time_base*s->time_increment_resolution + time_increment;
- s->pp_time= s->time - s->last_non_b_time;
- s->last_non_b_time= s->time;
- }else{
- s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
- s->bp_time= s->last_non_b_time - s->time;
- }
check_marker(gb, "before vop_coding_type in video packed header");
skip_bits(gb, 2); /* vop coding type */
if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
mpeg4_decode_sprite_trajectory(s);
+ fprintf(stderr, "untested\n");
}
//FIXME reduced res stuff here
if (s->pict_type != I_TYPE) {
- s->f_code = get_bits(gb, 3); /* fcode_for */
- if(s->f_code==0){
- printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
- return -1; // makes no sense to continue, as the MV decoding will break very quickly
+ int f_code = get_bits(gb, 3); /* fcode_for */
+ if(f_code==0){
+ printf("Error, video packet header damaged (f_code=0)\n");
}
}
if (s->pict_type == B_TYPE) {
- s->b_code = get_bits(gb, 3);
+ int b_code = get_bits(gb, 3);
+ if(b_code==0){
+ printf("Error, video packet header damaged (b_code=0)\n");
+ }
}
}
}
int i;
PRINT_MB_TYPE("I");
- cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
+ cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
if (cbpc < 0){
fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
return DECODING_DESYNC;
s->mb_intra = 1;
if(cbpc & 4) {
- s->qscale += quant_tab[get_bits(&s->gb, 2)];
- if (s->qscale < 1)
- s->qscale = 1;
- else if (s->qscale > 31)
- s->qscale = 31;
- h263_dc_scale(s);
+ change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
}
s->qscale_table[xy]= s->qscale;
continue;
}
- cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
+ cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
if (cbpc < 0){
fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
return DECODING_DESYNC;
if(s->pict_type==I_TYPE){
int ac_pred= get_bits1(&s->gb);
- int cbpy = get_vlc(&s->gb, &cbpy_vlc);
+ int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
if(cbpy<0){
fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
return DECODING_AC_LOST;
if(s->mb_type[xy]&MB_TYPE_INTRA){
int dir=0,i;
int ac_pred = get_bits1(&s->gb);
- int cbpy = get_vlc(&s->gb, &cbpy_vlc);
+ int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
if(cbpy<0){
fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
}
if(s->cbp_table[xy] & 8) {
- s->qscale += quant_tab[get_bits(&s->gb, 2)];
- if (s->qscale < 1)
- s->qscale = 1;
- else if (s->qscale > 31)
- s->qscale = 31;
- h263_dc_scale(s);
+ change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
}
s->qscale_table[xy]= s->qscale;
s->qscale_table[xy]= s->qscale;
s->cbp_table[xy]= 0;
}else{
- int cbpy = get_vlc(&s->gb, &cbpy_vlc);
+ int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
if(cbpy<0){
fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
}
if(s->cbp_table[xy] & 8) {
-//fprintf(stderr, "dquant\n");
- s->qscale += quant_tab[get_bits(&s->gb, 2)];
- if (s->qscale < 1)
- s->qscale = 1;
- else if (s->qscale > 31)
- s->qscale = 31;
- h263_dc_scale(s);
+ change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
}
s->qscale_table[xy]= s->qscale;
s->mb_x= s->resync_mb_x;
s->mb_y= s->resync_mb_y;
s->qscale= qscale;
- h263_dc_scale(s);
+ s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
+ s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
if(s->decoding_error==DECODING_DESYNC) return -1;
}
if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){
s->qscale= s->qscale_table[xy];
- h263_dc_scale(s);
+ s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
+ s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
}
if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
/* decode each block */
for (i = 0; i < 6; i++) {
- int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
+ int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1);
if(ret==DECODING_AC_LOST){
fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
s->decoding_error=DECODING_AC_LOST;
if(s->decoding_error==0 && cbp){
/* decode each block */
for (i = 0; i < 6; i++) {
- int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
+ int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 0);
if(ret==DECODING_AC_LOST){
fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
s->decoding_error=DECODING_AC_LOST;
/* decode each block */
for (i = 0; i < 6; i++) {
- int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
+ int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1);
if(ret==DECODING_AC_LOST){
fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
s->decoding_error=DECODING_AC_LOST;
return 0;
}
+#if 0
+static inline void decode_interlaced_info(MpegEncContext *s, int cbp, int mb_type){
+ s->mv_type= 0;
+ if(!s->progressive_sequence){
+ if(cbp || s->mb_intra)
+ s->interlaced_dct= get_bits1(&s->gb);
+
+ if(!s->mb_intra){
+ if( s->pict_type==P_TYPE //FIXME check that 4MV is forbidden
+ || (s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && !s->mcsel)
+ || (s->pict_type==B_TYPE && mb_type!=0) ){
+
+ if(get_bits1(&s->gb)){
+ s->mv_type= MV_TYPE_FIELD;
+ if( s->pict_type==P_TYPE
+ || (s->pict_type==B_TYPE && mb_type!=2)){
+ s->field_select[0][0]= get_bits1(&s->gb);
+ s->field_select[0][1]= get_bits1(&s->gb);
+ }
+ if(s->pict_type==B_TYPE && mb_type!=3){
+ s->field_select[1][0]= get_bits1(&s->gb);
+ s->field_select[1][1]= get_bits1(&s->gb);
+ }
+ }else
+ s->mv_type= 0;
+ }
+ }
+ }
+}
+#endif
int h263_decode_mb(MpegEncContext *s,
DCTELEM block[6][64])
INT16 *mot_val;
static INT8 quant_tab[4] = { -1, -2, 1, 2 };
- if(s->mb_x==0) PRINT_MB_TYPE("\n")
+ if(s->mb_x==0) PRINT_MB_TYPE("\n");
if(s->resync_marker){
if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
}
return 0;
}
- cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
+ cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
//fprintf(stderr, "\tCBPC: %d", cbpc);
if (cbpc < 0)
return -1;
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
s->mcsel= get_bits1(&s->gb);
else s->mcsel= 0;
- cbpy = get_vlc(&s->gb, &cbpy_vlc);
+ cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
if (dquant) {
- s->qscale += quant_tab[get_bits(&s->gb, 2)];
- if (s->qscale < 1)
- s->qscale = 1;
- else if (s->qscale > 31)
- s->qscale = 31;
- h263_dc_scale(s);
+ change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
}
+ if((!s->progressive_sequence) && (cbp || s->workaround_bugs==2))
+ s->interlaced_dct= get_bits1(&s->gb);
+
s->mv_dir = MV_DIR_FORWARD;
if ((cbpc & 16) == 0) {
- PRINT_MB_TYPE("P");
- /* 16x16 motion prediction */
- s->mv_type = MV_TYPE_16X16;
- h263_pred_motion(s, 0, &pred_x, &pred_y);
- if (s->umvplus_dec)
- mx = h263p_decode_umotion(s, pred_x);
- else if(!s->mcsel)
- mx = h263_decode_motion(s, pred_x, s->f_code);
- else {
- const int a= s->sprite_warping_accuracy;
+ if(s->mcsel){
+ const int a= s->sprite_warping_accuracy;
+ PRINT_MB_TYPE("G");
+ /* 16x16 global motion prediction */
+ s->mv_type = MV_TYPE_16X16;
// int l = (1 << (s->f_code - 1)) * 32;
if(s->divx_version==500 && s->divx_build==413){
mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
+ my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
}else{
mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
+ my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
}
-// if (mx < -l) mx= -l, printf("C");
-// else if (mx >= l) mx= l-1, printf("C");
- }
- if (mx >= 0xffff)
- return -1;
-
- if (s->umvplus_dec)
- my = h263p_decode_umotion(s, pred_y);
- else if(!s->mcsel)
- my = h263_decode_motion(s, pred_y, s->f_code);
- else{
- const int a= s->sprite_warping_accuracy;
// int l = (1 << (s->f_code - 1)) * 32;
- if(s->divx_version==500 && s->divx_build==413){
- my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
- }else{
- my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
+ s->mv[0][0][0] = mx;
+ s->mv[0][0][1] = my;
+ }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
+ PRINT_MB_TYPE("f");
+ /* 16x8 field motion prediction */
+ s->mv_type= MV_TYPE_FIELD;
+
+ s->field_select[0][0]= get_bits1(&s->gb);
+ s->field_select[0][1]= get_bits1(&s->gb);
+
+ h263_pred_motion(s, 0, &pred_x, &pred_y);
+
+ for(i=0; i<2; i++){
+ mx = h263_decode_motion(s, pred_x, s->f_code);
+ if (mx >= 0xffff)
+ return -1;
+
+ my = h263_decode_motion(s, pred_y/2, s->f_code);
+ if (my >= 0xffff)
+ return -1;
+
+ s->mv[0][i][0] = mx;
+ s->mv[0][i][1] = my;
}
-// if (my < -l) my= -l, printf("C");
-// else if (my >= l) my= l-1, printf("C");
+ }else{
+ PRINT_MB_TYPE("P");
+ /* 16x16 motion prediction */
+ s->mv_type = MV_TYPE_16X16;
+ h263_pred_motion(s, 0, &pred_x, &pred_y);
+ if (s->umvplus_dec)
+ mx = h263p_decode_umotion(s, pred_x);
+ else
+ mx = h263_decode_motion(s, pred_x, s->f_code);
+
+ if (mx >= 0xffff)
+ return -1;
+
+ if (s->umvplus_dec)
+ my = h263p_decode_umotion(s, pred_y);
+ else
+ my = h263_decode_motion(s, pred_y, s->f_code);
+
+ if (my >= 0xffff)
+ return -1;
+ s->mv[0][0][0] = mx;
+ s->mv[0][0][1] = my;
+
+ if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
+ skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
}
- if (my >= 0xffff)
- return -1;
- s->mv[0][0][0] = mx;
- s->mv[0][0][1] = my;
- /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
- fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
- fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
- if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
- skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
-
} else {
PRINT_MB_TYPE("4");
s->mv_type = MV_TYPE_8X8;
s->mcsel=0; // ... true gmc blocks
if(s->mb_x==0){
- s->last_mv[0][0][0]=
- s->last_mv[0][0][1]=
- s->last_mv[1][0][0]=
- s->last_mv[1][0][1]= 0;
+ for(i=0; i<2; i++){
+ s->last_mv[i][0][0]=
+ s->last_mv[i][0][1]=
+ s->last_mv[i][1][0]=
+ s->last_mv[i][1][1]= 0;
+ }
}
/* if we skipped it in the future P Frame than skip it now too */
s->mv[0][0][1] = 0;
s->mv[1][0][0] = 0;
s->mv[1][0][1] = 0;
-//FIXME is this correct?
-/* s->last_mv[0][0][0]=
- s->last_mv[0][0][1]=0;*/
- PRINT_MB_TYPE("s")
+ PRINT_MB_TYPE("s");
return 0;
}
- modb1= get_bits1(&s->gb);
- if(modb1==0){
+ modb1= get_bits1(&s->gb);
+ if(modb1){
+ mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
+ cbp=0;
+ }else{
+ int field_mv;
+
modb2= get_bits1(&s->gb);
- mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
- if(modb2==0) cbp= get_bits(&s->gb, 6);
- else cbp=0;
- if (mb_type && cbp) {
+ mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
+ if(modb2) cbp= 0;
+ else cbp= get_bits(&s->gb, 6);
+
+ if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
if(get_bits1(&s->gb)){
- s->qscale +=get_bits1(&s->gb)*4 - 2;
- if (s->qscale < 1)
- s->qscale = 1;
- else if (s->qscale > 31)
- s->qscale = 31;
- h263_dc_scale(s);
+ change_qscale(s, get_bits1(&s->gb)*4 - 2);
}
}
- }else{
- mb_type=4; //like 0 but no vectors coded
- cbp=0;
+ field_mv=0;
+
+ if(!s->progressive_sequence){
+ if(cbp)
+ s->interlaced_dct= get_bits1(&s->gb);
+
+ if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
+ field_mv=1;
+
+ if(mb_type!=MB_TYPE_B_BACKW){
+ s->field_select[0][0]= get_bits1(&s->gb);
+ s->field_select[0][1]= get_bits1(&s->gb);
+ }
+ if(mb_type!=MB_TYPE_B_FORW){
+ s->field_select[1][0]= get_bits1(&s->gb);
+ s->field_select[1][1]= get_bits1(&s->gb);
+ }
+ }
+ }
+
+ s->mv_dir = 0;
+ if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
+ s->mv_type= MV_TYPE_16X16;
+ if(mb_type!=MB_TYPE_B_BACKW){
+ s->mv_dir = MV_DIR_FORWARD;
+
+ mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
+ my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
+ s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
+ s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
+ }
+
+ if(mb_type!=MB_TYPE_B_FORW){
+ s->mv_dir |= MV_DIR_BACKWARD;
+
+ mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
+ my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
+ s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
+ s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
+ }
+ if(mb_type!=MB_TYPE_B_DIRECT)
+ PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
+ }else if(mb_type!=MB_TYPE_B_DIRECT){
+ s->mv_type= MV_TYPE_FIELD;
+
+ if(mb_type!=MB_TYPE_B_BACKW){
+ s->mv_dir = MV_DIR_FORWARD;
+
+ for(i=0; i<2; i++){
+ mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
+ my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
+ s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
+ s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
+ }
+ }
+
+ if(mb_type!=MB_TYPE_B_FORW){
+ s->mv_dir |= MV_DIR_BACKWARD;
+
+ for(i=0; i<2; i++){
+ mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
+ my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
+ s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
+ s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
+ }
+ }
+ if(mb_type!=MB_TYPE_B_DIRECT)
+ PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
+ }
}
- s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
- mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
- switch(mb_type)
- {
- case 0: /* direct */
- mx = h263_decode_motion(s, 0, 1);
- my = h263_decode_motion(s, 0, 1);
- case 4: /* direct with mx=my=0 */
+
+ if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
+ int mb_index= s->mb_x + s->mb_y*s->mb_width;
+ int i;
+
+ if(mb_type==4)
+ mx=my=0;
+ else{
+ mx = h263_decode_motion(s, 0, 1);
+ my = h263_decode_motion(s, 0, 1);
+ }
+
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
xy= s->block_index[0];
time_pp= s->pp_time;
- time_pb= time_pp - s->bp_time;
-//if(time_pp>3000 )printf("%d %d ", time_pp, time_pb);
- //FIXME 4MV
+ time_pb= s->pb_time;
+
//FIXME avoid divides
- s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
- s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
- s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
- : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
- s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
- : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
-/* s->mv[0][0][0] =
- s->mv[0][0][1] =
- s->mv[1][0][0] =
- s->mv[1][0][1] = 1000;*/
- PRINT_MB_TYPE("D");
- break;
- case 1:
- s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
- mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
- my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
- s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
- s->last_mv[0][0][1]= s->mv[0][0][1] = my;
-
- mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
- my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
- s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
- s->last_mv[1][0][1]= s->mv[1][0][1] = my;
- PRINT_MB_TYPE("i");
- break;
- case 2:
- s->mv_dir = MV_DIR_BACKWARD;
- mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
- my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
- s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
- s->last_mv[1][0][1]= s->mv[1][0][1] = my;
- PRINT_MB_TYPE("B");
- break;
- case 3:
- s->mv_dir = MV_DIR_FORWARD;
- mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
- my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
- s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
- s->last_mv[0][0][1]= s->mv[0][0][1] = my;
- PRINT_MB_TYPE("F");
- break;
- default:
+ switch(s->co_located_type_table[mb_index]){
+ case 0:
+ s->mv_type= MV_TYPE_16X16;
+ s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
+ s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
+ s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
+ : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
+ s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
+ : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
+ PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
+ break;
+ case CO_LOCATED_TYPE_4MV:
+ s->mv_type = MV_TYPE_8X8;
+ for(i=0; i<4; i++){
+ xy= s->block_index[i];
+ s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
+ s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
+ s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
+ : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
+ s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
+ : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
+ }
+ PRINT_MB_TYPE("4");
+ break;
+ case CO_LOCATED_TYPE_FIELDMV:
+ s->mv_type = MV_TYPE_FIELD;
+ for(i=0; i<2; i++){
+ if(s->top_field_first){
+ time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
+ time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
+ }else{
+ time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
+ time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
+ }
+ s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
+ s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
+ s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
+ : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
+ s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
+ : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
+ }
+ PRINT_MB_TYPE("=");
+ break;
+ }
+ }
+
+ if(mb_type<0 || mb_type>4){
printf("illegal MB_type\n");
return -1;
}
} else { /* I-Frame */
- cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
+ cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
if (cbpc < 0)
return -1;
dquant = cbpc & 4;
s->mb_intra = 1;
intra:
- PRINT_MB_TYPE("I");
s->ac_pred = 0;
if (s->h263_pred || s->h263_aic) {
s->ac_pred = get_bits1(&s->gb);
if (s->ac_pred && s->h263_aic)
s->h263_aic_dir = get_bits1(&s->gb);
}
- if (s->h263_aic) {
- s->y_dc_scale = 2 * s->qscale;
- s->c_dc_scale = 2 * s->qscale;
- }
- cbpy = get_vlc(&s->gb, &cbpy_vlc);
+ PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
+
+ cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
if(cbpy<0) return -1;
cbp = (cbpc & 3) | (cbpy << 2);
if (dquant) {
- s->qscale += quant_tab[get_bits(&s->gb, 2)];
- if (s->qscale < 1)
- s->qscale = 1;
- else if (s->qscale > 31)
- s->qscale = 31;
- h263_dc_scale(s);
+ change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
}
+ if(!s->progressive_sequence)
+ s->interlaced_dct= get_bits1(&s->gb);
+
+ /* decode each block */
+ if (s->h263_pred) {
+ for (i = 0; i < 6; i++) {
+ if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1) < 0)
+ return -1;
+ }
+ } else {
+ for (i = 0; i < 6; i++) {
+ if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
+ return -1;
+ }
+ }
+ return 0;
}
/* decode each block */
if (s->h263_pred) {
- for (i = 0; i < 6; i++) {
- if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
+ for (i = 0; i < 6; i++) {
+ if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 0) < 0)
return -1;
- }
+ }
} else {
- for (i = 0; i < 6; i++) {
- if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
+ for (i = 0; i < 6; i++) {
+ if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
return -1;
- }
+ }
}
return 0;
}
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
{
- int code, val, sign, shift, l, m;
+ int code, val, sign, shift, l;
- code = get_vlc(&s->gb, &mv_vlc);
+ code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
if (code < 0)
return 0xffff;
if (sign)
val = -val;
val += pred;
-
+
/* modulo decoding */
if (!s->h263_long_vectors) {
l = (1 << (f_code - 1)) * 32;
- m = 2 * l;
if (val < -l) {
- val += m;
+ val += l<<1;
} else if (val >= l) {
- val -= m;
+ val -= l<<1;
}
} else {
/* horrible h263 long vector mode */
}
for(;;) {
- code = get_vlc(&s->gb, &rl->vlc);
+ code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
if (code < 0)
return -1;
if (code == rl->n) {
if (s->h263_rv10 && level == -128) {
/* XXX: should patch encoder too */
level = get_bits(&s->gb, 12);
- level = (level << 20) >> 20;
+ level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
}
} else {
run = rl->table_run[code];
UINT16 *dc_val;
if (n < 4)
- code = get_vlc(&s->gb, &dc_lum);
+ code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
else
- code = get_vlc(&s->gb, &dc_chrom);
+ code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
if (code < 0 || code > 9 /* && s->nbit<9 */){
fprintf(stderr, "illegal dc vlc\n");
return -1;
}
}
- pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
+ pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
level += pred;
if (level < 0)
level = 0;
* returns DECODING_ACDC_LOST if an error was detected during DC decoding
*/
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
- int n, int coded)
+ int n, int coded, int intra)
{
- int code, level, i, j, last, run;
+ int level, i, last, run;
int dc_pred_dir;
- RLTable *rl;
- const UINT8 *scan_table;
+ RLTable * rl;
+ RL_VLC_ELEM * rl_vlc;
+ const UINT8 * scan_table;
+ int qmul, qadd;
- if (s->mb_intra) {
+ if(intra) {
/* DC coef */
if(s->data_partitioning && s->pict_type!=B_TYPE){
level = s->dc_val[0][ s->block_index[n] ];
return DECODING_ACDC_LOST;
}
block[0] = level;
- i = 1;
+ i = 0;
if (!coded)
goto not_coded;
rl = &rl_intra;
- if (s->ac_pred) {
+ rl_vlc = rl_intra.rl_vlc[0];
+ if(s->alternate_scan)
+ scan_table = ff_alternate_vertical_scan; /* left */
+ else if (s->ac_pred) {
if (dc_pred_dir == 0)
scan_table = ff_alternate_vertical_scan; /* left */
else
} else {
scan_table = zigzag_direct;
}
+ qmul=1;
+ qadd=0;
} else {
- i = 0;
+ i = -1;
if (!coded) {
- s->block_last_index[n] = i - 1;
+ s->block_last_index[n] = i;
return 0;
}
rl = &rl_inter;
- scan_table = zigzag_direct;
- }
+
+ if(s->alternate_scan)
+ scan_table = ff_alternate_vertical_scan; /* left */
+ else
+ scan_table = zigzag_direct;
+ if(s->mpeg_quant){
+ qmul=1;
+ qadd=0;
+ rl_vlc = rl_inter.rl_vlc[0];
+ }else{
+ qmul = s->qscale << 1;
+ qadd = (s->qscale - 1) | 1;
+ rl_vlc = rl_inter.rl_vlc[s->qscale];
+ }
+ }
+ {
+ OPEN_READER(re, &s->gb);
for(;;) {
- code = get_vlc(&s->gb, &rl->vlc);
- if (code < 0)
- return DECODING_AC_LOST;
- if (code == rl->n) {
+ UPDATE_CACHE(re, &s->gb);
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
+ if (level==0) {
+ int cache;
+ cache= GET_CACHE(re, &s->gb);
/* escape */
- if (get_bits1(&s->gb) != 0) {
- if (get_bits1(&s->gb) != 0) {
+ if (cache&0x80000000) {
+ if (cache&0x40000000) {
/* third escape */
- last = get_bits1(&s->gb);
- run = get_bits(&s->gb, 6);
- if(get_bits1(&s->gb)==0){
+ SKIP_CACHE(re, &s->gb, 2);
+ last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
+ run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
+ SKIP_COUNTER(re, &s->gb, 2+1+6);
+ UPDATE_CACHE(re, &s->gb);
+
+ if(SHOW_UBITS(re, &s->gb, 1)==0){
fprintf(stderr, "1. marker bit missing in 3. esc\n");
return DECODING_AC_LOST;
- }
- level = get_bits(&s->gb, 12);
- level = (level << 20) >> 20; /* sign extend */
- if(get_bits1(&s->gb)==0){
+ }; SKIP_CACHE(re, &s->gb, 1);
+
+ level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
+
+ if(SHOW_UBITS(re, &s->gb, 1)==0){
fprintf(stderr, "2. marker bit missing in 3. esc\n");
return DECODING_AC_LOST;
- }
- if(level>512 || level<-512){ //FIXME check that QP=1 is ok with this too
- fprintf(stderr, "|level| overflow in 3. esc\n");
+ }; LAST_SKIP_CACHE(re, &s->gb, 1);
+
+ SKIP_COUNTER(re, &s->gb, 1+12+1);
+
+ if(level*s->qscale>1024 || level*s->qscale<-1024){
+ fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
return DECODING_AC_LOST;
}
#if 1
{
const int abs_level= ABS(level);
- const int run1= run - rl->max_run[last][abs_level] - 1;
if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){
+ const int run1= run - rl->max_run[last][abs_level] - 1;
if(abs_level <= rl->max_level[last][run]){
fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
return DECODING_AC_LOST;
fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
return DECODING_AC_LOST;
}
- if(abs_level <= rl->max_level[last][run1]){
+ if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
return DECODING_AC_LOST;
}
}
}
#endif
+ if (level>0) level= level * qmul + qadd;
+ else level= level * qmul - qadd;
+
+ i+= run + 1;
+ if(last) i+=192;
} else {
/* second escape */
- code = get_vlc(&s->gb, &rl->vlc);
- if (code < 0 || code >= rl->n)
- return DECODING_AC_LOST;
- run = rl->table_run[code];
- level = rl->table_level[code];
- last = code >= rl->last;
- run += rl->max_run[last][level] + 1;
- if (get_bits1(&s->gb))
- level = -level;
+#if MIN_CACHE_BITS < 20
+ LAST_SKIP_BITS(re, &s->gb, 2);
+ UPDATE_CACHE(re, &s->gb);
+#else
+ SKIP_BITS(re, &s->gb, 2);
+#endif
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
+ i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+ LAST_SKIP_BITS(re, &s->gb, 1);
}
} else {
/* first escape */
- code = get_vlc(&s->gb, &rl->vlc);
- if (code < 0 || code >= rl->n)
- return DECODING_AC_LOST;
- run = rl->table_run[code];
- level = rl->table_level[code];
- last = code >= rl->last;
- level += rl->max_level[last][run];
- if (get_bits1(&s->gb))
- level = -level;
+#if MIN_CACHE_BITS < 19
+ LAST_SKIP_BITS(re, &s->gb, 1);
+ UPDATE_CACHE(re, &s->gb);
+#else
+ SKIP_BITS(re, &s->gb, 1);
+#endif
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
+ i+= run;
+ level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+ LAST_SKIP_BITS(re, &s->gb, 1);
}
} else {
- run = rl->table_run[code];
- level = rl->table_level[code];
- last = code >= rl->last;
- if (get_bits1(&s->gb))
- level = -level;
+ i+= run;
+ level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
+ LAST_SKIP_BITS(re, &s->gb, 1);
}
- i += run;
- if (i >= 64)
- return DECODING_AC_LOST;
- j = scan_table[i];
- block[j] = level;
- i++;
- if (last)
+ if (i > 62){
+ i-= 192;
+ if(i&(~63)){
+ fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
+ return DECODING_AC_LOST;
+ }
+
+ block[scan_table[i]] = level;
break;
+ }
+
+ block[scan_table[i]] = level;
}
+ CLOSE_READER(re, &s->gb);
+ }
not_coded:
if (s->mb_intra) {
mpeg4_pred_ac(s, block, n, dc_pred_dir);
if (s->ac_pred) {
- i = 64; /* XXX: not optimal */
+ i = 63; /* XXX: not optimal */
}
}
- s->block_last_index[n] = i - 1;
+ s->block_last_index[n] = i;
return 0;
}
skip_bits1(&s->gb);
height = get_bits(&s->gb, 9) * 4;
dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
- if (s->aspect_ratio_info == EXTENDED_PAR) {
+ if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
/* aspected dimensions */
- skip_bits(&s->gb, 8); /* width */
- skip_bits(&s->gb, 8); /* height */
+ s->aspected_width = get_bits(&s->gb, 8);
+ s->aspected_height = get_bits(&s->gb, 8);
}
} else {
width = h263_format[format][0];
skip_bits(&s->gb, 8);
}
s->f_code = 1;
+
+ if(s->h263_aic){
+ s->y_dc_scale_table=
+ s->c_dc_scale_table= h263_aic_dc_scale_table;
+ }else{
+ s->y_dc_scale_table=
+ s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
+ }
+
return 0;
}
}
//printf("vo type:%d\n",s->vo_type);
s->aspect_ratio_info= get_bits(&s->gb, 4);
- if(s->aspect_ratio_info == EXTENDED_PAR){
- skip_bits(&s->gb, 8); //par_width
- skip_bits(&s->gb, 8); // par_height
+ if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
+ s->aspected_width = get_bits(&s->gb, 8); // par_width
+ s->aspected_height = get_bits(&s->gb, 8); // par_height
}
if ((s->vol_control_parameters=get_bits1(&s->gb))) { /* vol control parameter */
}
s->low_delay= get_bits1(&s->gb);
if(get_bits1(&s->gb)){ /* vbv parameters */
- printf("vbv parameters not supported\n");
- return -1;
+ get_bits(&s->gb, 15); /* first_half_bitrate */
+ skip_bits1(&s->gb); /* marker */
+ get_bits(&s->gb, 15); /* latter_half_bitrate */
+ skip_bits1(&s->gb); /* marker */
+ get_bits(&s->gb, 15); /* first_half_vbv_buffer_size */
+ skip_bits1(&s->gb); /* marker */
+ get_bits(&s->gb, 3); /* latter_half_vbv_buffer_size */
+ get_bits(&s->gb, 11); /* first_half_vbv_occupancy */
+ skip_bits1(&s->gb); /* marker */
+ get_bits(&s->gb, 15); /* latter_half_vbv_occupancy */
+ skip_bits1(&s->gb); /* marker */
}
}else{
- s->low_delay=0;
+ // set low delay flag only once so the smart? low delay detection wont be overriden
+ if(s->picture_number==0)
+ s->low_delay=0;
}
s->shape = get_bits(&s->gb, 2); /* vol shape */
skip_bits1(&s->gb); /* marker */
s->time_increment_resolution = get_bits(&s->gb, 16);
+
s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
if (s->time_increment_bits < 1)
s->time_increment_bits = 1;
}
}
- if(get_bits1(&s->gb)) printf("interlaced not supported\n"); /* interlaced */
+ s->progressive_sequence= get_bits1(&s->gb)^1;
if(!get_bits1(&s->gb)) printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
if (vo_ver_id == 1) {
s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
// FIXME a bunch of grayscale shape things
- if(get_bits1(&s->gb)){ /* vol_quant_type */
+ if((s->mpeg_quant=get_bits1(&s->gb))){ /* vol_quant_type */
int i, j, v;
+
/* load default matrixes */
for(i=0; i<64; i++){
v= ff_mpeg4_default_intra_matrix[i];
}
}
- s->dct_unquantize= s->dct_unquantize_mpeg2;
-
// FIXME a bunch of grayscale shape things
- }else
- s->dct_unquantize= s->dct_unquantize_h263;
+ }
if(vo_ver_id != 1)
s->quarter_sample= get_bits1(&s->gb);
}
s->scalability= get_bits1(&s->gb);
+ if(s->workaround_bugs==1) s->scalability=0;
if (s->scalability) {
+ int dummy= s->hierachy_type= get_bits1(&s->gb);
+ int ref_layer_id= get_bits(&s->gb, 4);
+ int ref_layer_sampling_dir= get_bits1(&s->gb);
+ int h_sampling_factor_n= get_bits(&s->gb, 5);
+ int h_sampling_factor_m= get_bits(&s->gb, 5);
+ int v_sampling_factor_n= get_bits(&s->gb, 5);
+ int v_sampling_factor_m= get_bits(&s->gb, 5);
+ s->enhancement_type= get_bits1(&s->gb);
+ // bin shape stuff FIXME
printf("scalability not supported\n");
}
}
printf("This file was encoded with DivX%d Build%d\n", ver, build);
if(ver==500 && build==413){
printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
-#if 0
- }else{
- printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
- "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
-#endif
}
}
}
printf("low_delay flag set, but shouldnt, clearing it\n");
s->low_delay=0;
}
-// printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample);
-//printf("%d", s->pict_type);
+// printf("pic: %d, qpel:%d part:%d resync:%d\n", s->pict_type, s->quarter_sample, s->data_partitioning, s->resync_marker);
+
+ if(s->time_increment_resolution==0){
+ s->time_increment_resolution=1;
+// fprintf(stderr, "time_increment_resolution is illegal\n");
+ }
time_incr=0;
while (get_bits1(&s->gb) != 0)
time_incr++;
check_marker(&s->gb, "before time_increment");
time_increment= get_bits(&s->gb, s->time_increment_bits);
-//printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
+//printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
if(s->pict_type!=B_TYPE){
s->last_time_base= s->time_base;
s->time_base+= time_incr;
s->time= s->time_base*s->time_increment_resolution + time_increment;
+ if(s->time < s->last_non_b_time && s->workaround_bugs==3){
+ fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
+ s->time_base++;
+ s->time+= s->time_increment_resolution;
+ }
s->pp_time= s->time - s->last_non_b_time;
s->last_non_b_time= s->time;
}else{
s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
- s->bp_time= s->last_non_b_time - s->time;
- if(s->pp_time <=s->bp_time){
+ s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
+ if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
// printf("messed up order, seeking?, skiping current b frame\n");
return FRAME_SKIPED;
}
+
+ if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
+ if(s->t_frame==0) s->t_frame=1; // 1/0 protection
+//printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
+ s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
+ - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
+ s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
+ - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
}
-
+
+ s->avctx->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
+
if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
/* vop coded */
if (get_bits1(&s->gb) != 1)
goto redo;
-//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
-//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);
+//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
+//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
/* rounding type for motion estimation */
int t;
t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
//printf("threshold %d\n", t);
- //FIXME interlaced specific bits
+ if(!s->progressive_sequence){
+ s->top_field_first= get_bits1(&s->gb);
+ s->alternate_scan= get_bits1(&s->gb);
+ }else
+ s->alternate_scan= 0;
}
if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
return -1; // makes no sense to continue, as the MV decoding will break very quickly
}
- }
+ }else
+ s->f_code=1;
+
if (s->pict_type == B_TYPE) {
s->b_code = get_bits(&s->gb, 3);
-//printf("b-code %d\n", s->b_code);
- }
-//printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
+ }else
+ s->b_code=1;
+#if 0
+printf("qp:%d fc:%d bc:%d type:%s size:%d pro:%d alt:%d top:%d qpel:%d part:%d resync:%d\n",
+ s->qscale, s->f_code, s->b_code,
+ s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
+ s->gb.size,s->progressive_sequence, s->alternate_scan, s->top_field_first,
+ s->quarter_sample, s->data_partitioning, s->resync_marker);
+#endif
if(!s->scalability){
if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
skip_bits1(&s->gb); // vop shape coding type
}
+ }else{
+ if(s->enhancement_type){
+ int load_backward_shape= get_bits1(&s->gb);
+ if(load_backward_shape){
+ printf("load backward shape isnt supported\n");
+ }
+ }
+ skip_bits(&s->gb, 2); //ref_select_code
}
}
/* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
}
s->picture_number++; // better than pic number==0 allways ;)
-//printf("done\n");
+ s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
+ s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
+
+ if(s->divx_version==0 || s->divx_version < 500){
+ s->h_edge_pos= s->width;
+ s->v_edge_pos= s->height;
+ }
return 0;
}
projects / ffmpeg / blobdiff