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 intra, int rvlc);
+static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
+ uint8_t *scan_table);
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
#ifdef CONFIG_ENCODERS
static void mpeg4_encode_visual_object_header(MpegEncContext * s);
const int wrap = s->b8_stride;
const int xy = s->block_index[0];
- s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
+ s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
if(s->mv_type != MV_TYPE_8X8){
int motion_x, motion_y;
#ifdef CONFIG_ENCODERS
+static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
+ int l, bit_size, code;
+
+ if (val == 0) {
+ return mvtab[0][1];
+ } else {
+ bit_size = f_code - 1;
+ /* modulo encoding */
+ l= INT_BIT - 6 - bit_size;
+ val = (val<<l)>>l;
+ val--;
+ code = (val >> bit_size) + 1;
+
+ return mvtab[code][1] + 1 + bit_size;
+ }
+}
+
+static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
+ if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
+ skip_put_bits(&s->pb,
+ h263_get_motion_length(s, x, f_code)
+ +h263_get_motion_length(s, y, f_code));
+ }else{
+ ff_h263_encode_motion(s, x, f_code);
+ ff_h263_encode_motion(s, y, f_code);
+ }
+}
+
static inline int get_p_cbp(MpegEncContext * s,
DCTELEM block[6][64],
int motion_x, int motion_y){
return cbp;
}
+static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
+ uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
+ int i;
+
+ if(scan_table){
+ if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
+ for (i = 0; i < 6; i++) {
+ skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
+ }
+ }else{
+ /* encode each block */
+ for (i = 0; i < 6; i++) {
+ mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
+ }
+ }
+ }else{
+ if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
+ for (i = 0; i < 6; i++) {
+ skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
+ }
+ }else{
+ /* encode each block */
+ for (i = 0; i < 6; i++) {
+ mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
+ }
+ }
+ }
+}
+
void mpeg4_encode_mb(MpegEncContext * s,
DCTELEM block[6][64],
int motion_x, int motion_y)
assert((s->dquant&1)==0);
assert(mb_type>=0);
- /* nothing to do if this MB was skiped in the next P Frame */
+ /* nothing to do if this MB was skipped in the next P Frame */
if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
s->skip_count++;
s->mv[0][0][0]=
s->mv[1][0][1]= 0;
s->mv_dir= MV_DIR_FORWARD; //doesnt matter
s->qscale -= s->dquant;
-// s->mb_skiped=1;
+// s->mb_skipped=1;
return;
}
if(mb_type == 0){
assert(s->mv_dir & MV_DIRECT);
- ff_h263_encode_motion(s, motion_x, 1);
- ff_h263_encode_motion(s, motion_y, 1);
+ ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
s->b_count++;
s->f_count++;
}else{
assert(mb_type > 0 && mb_type < 4);
if(s->mv_type != MV_TYPE_FIELD){
if(s->mv_dir & MV_DIR_FORWARD){
- ff_h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
- ff_h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
+ ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
+ s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
s->f_count++;
}
if(s->mv_dir & MV_DIR_BACKWARD){
- ff_h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
- ff_h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
+ ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
+ s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
s->b_count++;
}
if(s->mv_dir & MV_DIR_FORWARD){
for(i=0; i<2; i++){
- ff_h263_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code);
- ff_h263_encode_motion(s, s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
+ ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
+ s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
s->last_mv[0][i][0]= s->mv[0][i][0];
s->last_mv[0][i][1]= s->mv[0][i][1]*2;
}
}
if(s->mv_dir & MV_DIR_BACKWARD){
for(i=0; i<2; i++){
- ff_h263_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code);
- ff_h263_encode_motion(s, s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
+ ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
+ s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
s->last_mv[1][i][0]= s->mv[1][i][0];
s->last_mv[1][i][1]= s->mv[1][i][1]*2;
}
s->mv_bits+= get_bits_diff(s);
}
- /* encode each block */
- for (i = 0; i < 6; i++) {
- mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
- }
+ mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
if(interleaved_stats){
s->p_tex_bits+= get_bits_diff(s);
offset= x + y*s->linesize;
p_pic= s->new_picture.data[0] + offset;
- s->mb_skiped=1;
+ s->mb_skipped=1;
for(i=0; i<s->max_b_frames; i++){
uint8_t *b_pic;
int diff;
b_pic= pic->data[0] + offset + 16; //FIXME +16
diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
if(diff>s->qscale*70){ //FIXME check that 70 is optimal
- s->mb_skiped=0;
+ s->mb_skipped=0;
break;
}
}
}else
- s->mb_skiped=1;
+ s->mb_skipped=1;
- if(s->mb_skiped==1){
+ if(s->mb_skipped==1){
/* skip macroblock */
put_bits(&s->pb, 1, 1);
/* motion vectors: 16x16 mode */
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
- ff_h263_encode_motion(s, motion_x - pred_x, s->f_code);
- ff_h263_encode_motion(s, motion_y - pred_y, s->f_code);
+ ff_h263_encode_motion_vector(s, motion_x - pred_x,
+ motion_y - pred_y, s->f_code);
}else if(s->mv_type==MV_TYPE_FIELD){
if(s->dquant) cbpc+= 8;
put_bits(&s->pb,
put_bits(&s->pb, 1, s->field_select[0][0]);
put_bits(&s->pb, 1, s->field_select[0][1]);
- ff_h263_encode_motion(s, s->mv[0][0][0] - pred_x, s->f_code);
- ff_h263_encode_motion(s, s->mv[0][0][1] - pred_y, s->f_code);
- ff_h263_encode_motion(s, s->mv[0][1][0] - pred_x, s->f_code);
- ff_h263_encode_motion(s, s->mv[0][1][1] - pred_y, s->f_code);
+ ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
+ s->mv[0][0][1] - pred_y, s->f_code);
+ ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
+ s->mv[0][1][1] - pred_y, s->f_code);
}else{
assert(s->mv_type==MV_TYPE_8X8);
put_bits(&s->pb,
/* motion vectors: 8x8 mode*/
h263_pred_motion(s, i, 0, &pred_x, &pred_y);
- ff_h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code);
- ff_h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
+ ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
+ s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
}
}
s->mv_bits+= get_bits_diff(s);
}
- /* encode each block */
- for (i = 0; i < 6; i++) {
- mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
- }
+ mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
if(interleaved_stats){
s->p_tex_bits+= get_bits_diff(s);
s->misc_bits+= get_bits_diff(s);
}
- /* encode each block */
- for (i = 0; i < 6; i++) {
- mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
- }
+ mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
if(interleaved_stats){
s->i_tex_bits+= get_bits_diff(s);
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
if (!s->umvplus) {
- ff_h263_encode_motion(s, motion_x - pred_x, 1);
- ff_h263_encode_motion(s, motion_y - pred_y, 1);
+ ff_h263_encode_motion_vector(s, motion_x - pred_x,
+ motion_y - pred_y, 1);
}
else {
h263p_encode_umotion(s, motion_x - pred_x);
motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
if (!s->umvplus) {
- ff_h263_encode_motion(s, motion_x - pred_x, 1);
- ff_h263_encode_motion(s, motion_y - pred_y, 1);
+ ff_h263_encode_motion_vector(s, motion_x - pred_x,
+ motion_y - pred_y, 1);
}
else {
h263p_encode_umotion(s, motion_x - pred_x);
put_bits(&s->pb, bit_size, bits);
}
}
-
}
/* Encode MV differences on H.263+ with Unrestricted MV mode */
int level= slevel < 0 ? -slevel : slevel;
int sign= slevel < 0 ? 1 : 0;
int bits, len, code;
- int level1, run1;
len_tab[index]= 100;
init_uni_dc_tab();
- init_rl(&rl_inter);
- init_rl(&rl_intra);
- init_rl(&rl_intra_aic);
+ init_rl(&rl_inter, 1);
+ init_rl(&rl_intra, 1);
+ init_rl(&rl_intra_aic, 1);
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);
s->avctx->extradata= av_malloc(1024);
init_put_bits(&s->pb, s->avctx->extradata, 1024);
- mpeg4_encode_visual_object_header(s);
+ if(!(s->workaround_bugs & FF_BUG_MS))
+ mpeg4_encode_visual_object_header(s);
mpeg4_encode_vol_header(s, 0, 0);
// ff_mpeg4_stuffing(&s->pb); ?
s->time_base= time_div;
s->pp_time= s->time - s->last_non_b_time;
s->last_non_b_time= s->time;
- assert(s->pp_time > 0);
+ assert(picture_number==0 || s->pp_time > 0);
}
}
put_bits(&s->pb, 1, 0); /* random access vol */
put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
- put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
- put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
- put_bits(&s->pb, 3, 1); /* is obj layer priority */
+ if(s->workaround_bugs & FF_BUG_MS) {
+ put_bits(&s->pb, 1, 0); /* is obj layer id= no */
+ } else {
+ put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
+ put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
+ put_bits(&s->pb, 3, 1); /* is obj layer priority */
+ }
aspect_to_info(s, s->avctx->sample_aspect_ratio);
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
}
- put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
- put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
- put_bits(&s->pb, 1, s->low_delay);
- put_bits(&s->pb, 1, 0); /* vbv parameters= no */
+ if(s->workaround_bugs & FF_BUG_MS) { //
+ put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
+ } else {
+ put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
+ put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
+ put_bits(&s->pb, 1, s->low_delay);
+ put_bits(&s->pb, 1, 0); /* vbv parameters= no */
+ }
put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
put_bits(&s->pb, 1, 1); /* marker bit */
if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
mpeg4_encode_vol_header(s, 0, 0);
}
- mpeg4_encode_gop_header(s);
+ if(!(s->workaround_bugs & FF_BUG_MS))
+ mpeg4_encode_gop_header(s);
}
s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
#endif
}
+static inline int mpeg4_get_dc_length(int level, int n){
+ if (n < 4) {
+ return uni_DCtab_lum_len[level + 256];
+ } else {
+ return uni_DCtab_chrom_len[level + 256];
+ }
+}
+
/**
* encodes a 8x8 block
* @param n block index (0-3 are luma, 4-5 are chroma)
#endif
}
-static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
+static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
uint8_t *scan_table)
{
int i, last_non_zero;
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); //FIXME
+ len += mpeg4_get_dc_length(intra_dc, n);
if(last_index<1) return len;
i = 1;
rl = &rl_intra;
static VLC h263_mbtype_b_vlc;
static VLC cbpc_b_vlc;
-void init_vlc_rl(RLTable *rl)
+void init_vlc_rl(RLTable *rl, int use_static)
{
int i, q;
-
+
+ /* Return if static table is already initialized */
+ if(use_static && rl->rl_vlc[0])
+ return;
+
init_vlc(&rl->vlc, 9, rl->n + 1,
&rl->table_vlc[0][1], 4, 2,
- &rl->table_vlc[0][0], 4, 2);
+ &rl->table_vlc[0][0], 4, 2, use_static);
for(q=0; q<32; q++){
qmul=1;
qadd=0;
}
-
- rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
+ if(use_static)
+ rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
+ else
+ 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];
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
intra_MCBPC_bits, 1, 1,
- intra_MCBPC_code, 1, 1);
+ intra_MCBPC_code, 1, 1, 1);
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
inter_MCBPC_bits, 1, 1,
- inter_MCBPC_code, 1, 1);
+ inter_MCBPC_code, 1, 1, 1);
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
&cbpy_tab[0][1], 2, 1,
- &cbpy_tab[0][0], 2, 1);
+ &cbpy_tab[0][0], 2, 1, 1);
init_vlc(&mv_vlc, MV_VLC_BITS, 33,
&mvtab[0][1], 2, 1,
- &mvtab[0][0], 2, 1);
- init_rl(&rl_inter);
- init_rl(&rl_intra);
- init_rl(&rvlc_rl_inter);
- init_rl(&rvlc_rl_intra);
- init_rl(&rl_intra_aic);
- init_vlc_rl(&rl_inter);
- init_vlc_rl(&rl_intra);
- init_vlc_rl(&rvlc_rl_inter);
- init_vlc_rl(&rvlc_rl_intra);
- init_vlc_rl(&rl_intra_aic);
+ &mvtab[0][0], 2, 1, 1);
+ init_rl(&rl_inter, 1);
+ init_rl(&rl_intra, 1);
+ init_rl(&rvlc_rl_inter, 1);
+ init_rl(&rvlc_rl_intra, 1);
+ init_rl(&rl_intra_aic, 1);
+ init_vlc_rl(&rl_inter, 1);
+ init_vlc_rl(&rl_intra, 1);
+ init_vlc_rl(&rvlc_rl_inter, 1);
+ init_vlc_rl(&rvlc_rl_intra, 1);
+ init_vlc_rl(&rl_intra_aic, 1);
init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
&DCtab_lum[0][1], 2, 1,
- &DCtab_lum[0][0], 2, 1);
+ &DCtab_lum[0][0], 2, 1, 1);
init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
&DCtab_chrom[0][1], 2, 1,
- &DCtab_chrom[0][0], 2, 1);
+ &DCtab_chrom[0][0], 2, 1, 1);
init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
&sprite_trajectory_tab[0][1], 4, 2,
- &sprite_trajectory_tab[0][0], 4, 2);
+ &sprite_trajectory_tab[0][0], 4, 2, 1);
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);
+ &mb_type_b_tab[0][0], 2, 1, 1);
init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
&h263_mbtype_b_tab[0][1], 2, 1,
- &h263_mbtype_b_tab[0][0], 2, 1);
+ &h263_mbtype_b_tab[0][0], 2, 1, 1);
init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
&cbpc_b_tab[0][1], 2, 1,
- &cbpc_b_tab[0][0], 2, 1);
+ &cbpc_b_tab[0][0], 2, 1, 1);
}
}
uint8_t *start= pbBufPtr(&s->pb);
uint8_t *end= s->pb.buf_end;
int size= end - start;
- int pb_size = (((int)start + size/3)&(~3)) - (int)start;
+ int pb_size = (((long)start + size/3)&(~3)) - (long)start;
int tex_size= (size - 2*pb_size)&(~3);
set_put_bits_buffer_size(&s->pb, pb_size);
}
if(s->pict_type == B_TYPE){
while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
- if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
+ if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
}
s->mb_x= mb_num % s->mb_width;
s->mv_type = MV_TYPE_16X16;
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
s->mcsel=1;
- s->mb_skiped = 0;
+ s->mb_skipped = 0;
}else{
s->mcsel=0;
- s->mb_skiped = 1;
+ s->mb_skipped = 1;
}
}else if(s->mb_intra){
s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
s->mv[0][0][0] = 0;
s->mv[0][0][1] = 0;
- s->mb_skiped = !(s->obmc | s->loop_filter);
+ s->mb_skipped = !(s->obmc | s->loop_filter);
goto end;
}
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
s->mv[0][0][0]= get_amv(s, 0);
s->mv[0][0][1]= get_amv(s, 1);
- s->mb_skiped = 0;
+ s->mb_skipped = 0;
}else{
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
s->mcsel=0;
s->mv[0][0][0] = 0;
s->mv[0][0][1] = 0;
- s->mb_skiped = 1;
+ s->mb_skipped = 1;
}
goto end;
}
}
/* if we skipped it in the future P Frame than skip it now too */
- s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
+ s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
- if(s->mb_skiped){
+ if(s->mb_skipped){
/* skip mb */
for(i=0;i<6;i++)
s->block_last_index[i] = -1;
memset(block, 0, sizeof(DCTELEM)*64);
goto retry;
}
- av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
+ av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
return -1;
}
j = scan_table[i];
OPEN_READER(re, &s->gb);
for(;;) {
UPDATE_CACHE(re, &s->gb);
- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
if (level==0) {
/* escape */
if(rvlc){
#else
SKIP_BITS(re, &s->gb, 2);
#endif
- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
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
SKIP_BITS(re, &s->gb, 1);
#endif
- GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
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);
skip_bits1(gb); /* marker */
height = get_bits(gb, 13);
skip_bits1(gb); /* marker */
- if(width && height){ /* they should be non zero but who knows ... */
+ if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
s->width = width;
s->height = height;
// printf("width/height: %d %d\n", width, height);
if (get_bits1(gb) == 1) { /* not_8_bit */
s->quant_precision = get_bits(gb, 4); /* quant_precision */
if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
- if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precission %d\n", s->quant_precision);
+ if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
} else {
s->quant_precision = 5;
}
s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
- av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set, but shouldnt, clearing it\n");
+ av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
s->low_delay=0;
}
check_marker(gb, "before time_increment");
if(s->time_increment_bits==0){
- av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
+ av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
if(show_bits(gb, s->time_increment_bits+1)&1) break;
s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
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;
+// printf("messed up order, maybe after seeking? skipping current b frame\n");
+ return FRAME_SKIPPED;
}
if(s->t_frame==0) s->t_frame= s->pb_time;
if (get_bits1(gb) != 1){
if(s->avctx->debug&FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
- return FRAME_SKIPED;
+ return FRAME_SKIPPED;
}
//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);
/* search next start code */
align_get_bits(gb);
+
+ if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
+ skip_bits(gb, 24);
+ if(get_bits(gb, 8) == 0xF0)
+ return decode_vop_header(s, gb);
+ }
+
startcode = 0xff;
for(;;) {
v = get_bits(gb, 8);
startcode = ((startcode << 8) | v) & 0xffffffff;
if(get_bits_count(gb) >= gb->size_in_bits){
- if(gb->size_in_bits==8 && s->divx_version){
+ if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
- return FRAME_SKIPED; //divx bug
+ return FRAME_SKIPPED; //divx bug
}else
return -1; //end of stream
}
else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
- else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Textutre Object start");
- else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Spatial Layer start");
- else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Textutre SNR Layer start");
- else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Tile start");
- else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Shape Layer start");
+ else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
+ else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
+ else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
+ else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
+ else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
width = height = 0;
break;
}
- if ((width == 0) || (height == 0))
+ if(avcodec_check_dimensions(s->avctx, width, height))
return -1;
s->width = width;
s->height = height;
if(s->avctx->debug & FF_DEBUG_PICT_INFO){
av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
- av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
+ s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
}
s->y_dc_scale_table=