/**
* decodes skipped macroblocks
* @return 0
*/
static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
{
MpegEncContext * const s = &h->s;
int i;
s->mb_intra = 0;
for(i=mba1; i<mba2; i++){
int j, xy;
s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11;
s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11;
xy = s->mb_x + s->mb_y * s->mb_stride;
ff_init_block_index(s);
ff_update_block_index(s);
for(j=0;j<6;j++)
s->block_last_index[j] = -1;
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
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_skipped = 1;
h->mtype &= ~MB_TYPE_H261_FIL;
MPV_decode_mb(s, s->block);
}
return 0;
}
static int decode_slice(MpegEncContext *s){
const int part_mask= s->partitioned_frame ? (ER_AC_END|ER_AC_ERROR) : 0x7F;
const int mb_size= 16>>s->avctx->lowres;
s->last_resync_gb= s->gb;
s->first_slice_line= 1;
s->resync_mb_x= s->mb_x;
s->resync_mb_y= s->mb_y;
ff_set_qscale(s, s->qscale);
if (s->avctx->hwaccel) {
const uint8_t *start= s->gb.buffer + get_bits_count(&s->gb)/8;
const uint8_t *end = ff_h263_find_resync_marker(start + 1, s->gb.buffer_end);
skip_bits_long(&s->gb, 8*(end - start));
return s->avctx->hwaccel->decode_slice(s->avctx, start, end - start);
}
if(s->partitioned_frame){
const int qscale= s->qscale;
if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
if(ff_mpeg4_decode_partitions(s) < 0)
return -1;
}
/* restore variables which were modified */
s->first_slice_line=1;
s->mb_x= s->resync_mb_x;
s->mb_y= s->resync_mb_y;
ff_set_qscale(s, qscale);
}
for(; s->mb_y < s->mb_height; s->mb_y++) {
/* per-row end of slice checks */
if(s->msmpeg4_version){
if(s->resync_mb_y + s->slice_height == s->mb_y){
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
return 0;
}
}
if(s->msmpeg4_version==1){
s->last_dc[0]=
s->last_dc[1]=
s->last_dc[2]= 128;
}
ff_init_block_index(s);
for(; s->mb_x < s->mb_width; s->mb_x++) {
int ret;
ff_update_block_index(s);
if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
s->first_slice_line=0;
}
/* DCT & quantize */
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
// s->mb_skipped = 0;
//printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
ret= s->decode_mb(s, s->block);
if (s->pict_type!=AV_PICTURE_TYPE_B)
ff_h263_update_motion_val(s);
if(ret<0){
const int xy= s->mb_x + s->mb_y*s->mb_stride;
if(ret==SLICE_END){
MPV_decode_mb(s, s->block);
if(s->loop_filter)
ff_h263_loop_filter(s);
//printf("%d %d %d %06X\n", s->mb_x, s->mb_y, s->gb.size*8 - get_bits_count(&s->gb), show_bits(&s->gb, 24));
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_END&part_mask);
s->padding_bug_score--;
if(++s->mb_x >= s->mb_width){
s->mb_x=0;
ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
MPV_report_decode_progress(s);
s->mb_y++;
}
return 0;
}else if(ret==SLICE_NOEND){
av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy);
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x+1, s->mb_y, ER_MB_END&part_mask);
return -1;
}
av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR&part_mask);
return -1;
}
MPV_decode_mb(s, s->block);
if(s->loop_filter)
ff_h263_loop_filter(s);
}
ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
MPV_report_decode_progress(s);
s->mb_x= 0;
}
assert(s->mb_x==0 && s->mb_y==s->mb_height);
if(s->codec_id==CODEC_ID_MPEG4
&& (s->workaround_bugs&FF_BUG_AUTODETECT)
&& get_bits_left(&s->gb) >= 48
&& show_bits(&s->gb, 24)==0x4010
&& !s->data_partitioning)
s->padding_bug_score+=32;
/* try to detect the padding bug */
if( s->codec_id==CODEC_ID_MPEG4
&& (s->workaround_bugs&FF_BUG_AUTODETECT)
&& get_bits_left(&s->gb) >=0
&& get_bits_left(&s->gb) < 48
// && !s->resync_marker
&& !s->data_partitioning){
const int bits_count= get_bits_count(&s->gb);
const int bits_left = s->gb.size_in_bits - bits_count;
if(bits_left==0){
s->padding_bug_score+=16;
} else if(bits_left != 1){
int v= show_bits(&s->gb, 8);
v|= 0x7F >> (7-(bits_count&7));
if(v==0x7F && bits_left<=8)
s->padding_bug_score--;
else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16)
s->padding_bug_score+= 4;
else
s->padding_bug_score++;
}
}
static int h261_decode_mb(H261Context *h){
MpegEncContext * const s = &h->s;
int i, cbp, xy;
cbp = 63;
// Read mba
do{
h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
/* Check for slice end */
/* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
if (h->mba_diff == MBA_STARTCODE){ // start code
h->gob_start_code_skipped = 1;
return SLICE_END;
}
}
while( h->mba_diff == MBA_STUFFING ); // stuffing
if ( h->mba_diff < 0 ){
if ( get_bits_count(&s->gb) + 7 >= s->gb.size_in_bits )
return SLICE_END;
av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
return SLICE_ERROR;
}
h->mba_diff += 1;
h->current_mba += h->mba_diff;
if ( h->current_mba > MBA_STUFFING )
return SLICE_ERROR;
s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
xy = s->mb_x + s->mb_y * s->mb_stride;
ff_init_block_index(s);
ff_update_block_index(s);
// Read mtype
h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
h->mtype = h261_mtype_map[h->mtype];
// Read mquant
if ( IS_QUANT ( h->mtype ) ){
ff_set_qscale(s, get_bits(&s->gb, 5));
}
s->mb_intra = IS_INTRA4x4(h->mtype);
// Read mv
if ( IS_16X16 ( h->mtype ) ){
// Motion vector data is included for all MC macroblocks. MVD is obtained from the macroblock vector by subtracting the
// vector of the preceding macroblock. For this calculation the vector of the preceding macroblock is regarded as zero in the
// following three situations:
// 1) evaluating MVD for macroblocks 1, 12 and 23;
// 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
// 3) MTYPE of the previous macroblock was not MC.
if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
( h->mba_diff != 1))
{
h->current_mv_x = 0;
h->current_mv_y = 0;
}
h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x);
h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y);
}else{
h->current_mv_x = 0;
h->current_mv_y = 0;
}
// Read cbp
if ( HAS_CBP( h->mtype ) ){
cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1;
}
if(s->mb_intra){
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
goto intra;
}
//set motion vectors
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation
s->mv[0][0][1] = h->current_mv_y * 2;
intra:
/* decode each block */
if(s->mb_intra || HAS_CBP(h->mtype)){
s->dsp.clear_blocks(s->block[0]);
for (i = 0; i < 6; i++) {
if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
return SLICE_ERROR;
}
cbp+=cbp;
}
}else{
for (i = 0; i < 6; i++)
s->block_last_index[i]= -1;
}
MPV_decode_mb(s, s->block);
return SLICE_OK;
}
static int rv10_decode_packet(AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
MpegEncContext *s = avctx->priv_data;
int mb_count, mb_pos, left, start_mb_x;
init_get_bits(&s->gb, buf, buf_size*8);
if(s->codec_id ==CODEC_ID_RV10)
mb_count = rv10_decode_picture_header(s);
else
mb_count = rv20_decode_picture_header(s);
if (mb_count < 0) {
av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
return -1;
}
if (s->mb_x >= s->mb_width ||
s->mb_y >= s->mb_height) {
av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
return -1;
}
mb_pos = s->mb_y * s->mb_width + s->mb_x;
left = s->mb_width * s->mb_height - mb_pos;
if (mb_count > left) {
av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
return -1;
}
//if(s->pict_type == FF_P_TYPE) return 0;
if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
ff_er_frame_end(s);
MPV_frame_end(s);
s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
}
if(MPV_frame_start(s, avctx) < 0)
return -1;
ff_er_frame_start(s);
}
#ifdef DEBUG
av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
#endif
/* default quantization values */
if(s->codec_id== CODEC_ID_RV10){
if(s->mb_y==0) s->first_slice_line=1;
}else{
s->first_slice_line=1;
s->resync_mb_x= s->mb_x;
}
start_mb_x= s->mb_x;
s->resync_mb_y= s->mb_y;
if(s->h263_aic){
s->y_dc_scale_table=
s->c_dc_scale_table= ff_aic_dc_scale_table;
}else{
s->y_dc_scale_table=
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
}
if(s->modified_quant)
s->chroma_qscale_table= ff_h263_chroma_qscale_table;
ff_set_qscale(s, s->qscale);
s->rv10_first_dc_coded[0] = 0;
s->rv10_first_dc_coded[1] = 0;
s->rv10_first_dc_coded[2] = 0;
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
s->block_wrap[0]=
s->block_wrap[1]=
s->block_wrap[2]=
s->block_wrap[3]= s->b8_stride;
s->block_wrap[4]=
s->block_wrap[5]= s->mb_stride;
ff_init_block_index(s);
/* decode each macroblock */
for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
int ret;
ff_update_block_index(s);
#ifdef DEBUG
av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
#endif
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
ret=ff_h263_decode_mb(s, s->block);
if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
return -1;
}
if(s->pict_type != FF_B_TYPE)
ff_h263_update_motion_val(s);
MPV_decode_mb(s, s->block);
if(s->loop_filter)
ff_h263_loop_filter(s);
if (++s->mb_x == s->mb_width) {
s->mb_x = 0;
s->mb_y++;
ff_init_block_index(s);
}
if(s->mb_x == s->resync_mb_x)
s->first_slice_line=0;
if(ret == SLICE_END) break;
}
ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
return buf_size;
}
static int decode_slice(MpegEncContext *s){
const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
s->last_resync_gb= s->gb;
s->first_slice_line= 1;
s->resync_mb_x= s->mb_x;
s->resync_mb_y= s->mb_y;
ff_set_qscale(s, s->qscale);
if(s->partitioned_frame){
const int qscale= s->qscale;
if(s->codec_id==CODEC_ID_MPEG4){
if(ff_mpeg4_decode_partitions(s) < 0)
return -1;
}
/* restore variables which were modified */
s->first_slice_line=1;
s->mb_x= s->resync_mb_x;
s->mb_y= s->resync_mb_y;
ff_set_qscale(s, qscale);
}
for(; s->mb_y < s->mb_height; s->mb_y++) {
/* per-row end of slice checks */
if(s->msmpeg4_version){
if(s->resync_mb_y + s->slice_height == s->mb_y){
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
return 0;
}
}
if(s->msmpeg4_version==1){
s->last_dc[0]=
s->last_dc[1]=
s->last_dc[2]= 128;
}
ff_init_block_index(s);
for(; s->mb_x < s->mb_width; s->mb_x++) {
int ret;
ff_update_block_index(s);
if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
s->first_slice_line=0;
}
/* DCT & quantize */
s->dsp.clear_blocks(s->block[0]);
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
// s->mb_skiped = 0;
//printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
ret= s->decode_mb(s, s->block);
if (s->pict_type!=B_TYPE)
ff_h263_update_motion_val(s);
if(ret<0){
const int xy= s->mb_x + s->mb_y*s->mb_stride;
if(ret==SLICE_END){
MPV_decode_mb(s, s->block);
if(s->loop_filter)
ff_h263_loop_filter(s);
//printf("%d %d %d %06X\n", s->mb_x, s->mb_y, s->gb.size*8 - get_bits_count(&s->gb), show_bits(&s->gb, 24));
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
s->padding_bug_score--;
if(++s->mb_x >= s->mb_width){
s->mb_x=0;
ff_draw_horiz_band(s, s->mb_y*16, 16);
s->mb_y++;
}
return 0;
}else if(ret==SLICE_NOEND){
av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy);
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x+1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
return -1;
}
av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
return -1;
}
MPV_decode_mb(s, s->block);
if(s->loop_filter)
ff_h263_loop_filter(s);
}
ff_draw_horiz_band(s, s->mb_y*16, 16);
s->mb_x= 0;
}
assert(s->mb_x==0 && s->mb_y==s->mb_height);
/* try to detect the padding bug */
if( s->codec_id==CODEC_ID_MPEG4
&& (s->workaround_bugs&FF_BUG_AUTODETECT)
&& s->gb.size_in_bits - get_bits_count(&s->gb) >=0
&& s->gb.size_in_bits - get_bits_count(&s->gb) < 48
// && !s->resync_marker
&& !s->data_partitioning){
const int bits_count= get_bits_count(&s->gb);
const int bits_left = s->gb.size_in_bits - bits_count;
if(bits_left==0){
s->padding_bug_score+=16;
}else if(bits_left>8){
s->padding_bug_score++;
} else if(bits_left != 1){
int v= show_bits(&s->gb, 8);
v|= 0x7F >> (7-(bits_count&7));
if(v==0x7F)
s->padding_bug_score--;
else
s->padding_bug_score++;
}
}
static int rv10_decode_packet(AVCodecContext *avctx,
uint8_t *buf, int buf_size)
{
MpegEncContext *s = avctx->priv_data;
int i, mb_count, mb_pos, left;
init_get_bits(&s->gb, buf, buf_size*8);
mb_count = rv10_decode_picture_header(s);
if (mb_count < 0) {
fprintf(stderr, "HEADER ERROR\n");
return -1;
}
if (s->mb_x >= s->mb_width ||
s->mb_y >= s->mb_height) {
fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
return -1;
}
mb_pos = s->mb_y * s->mb_width + s->mb_x;
left = s->mb_width * s->mb_height - mb_pos;
if (mb_count > left) {
fprintf(stderr, "COUNT ERROR\n");
return -1;
}
if (s->mb_x == 0 && s->mb_y == 0) {
if(MPV_frame_start(s, avctx) < 0)
return -1;
}
#ifdef DEBUG
printf("qscale=%d\n", s->qscale);
#endif
/* default quantization values */
s->y_dc_scale = 8;
s->c_dc_scale = 8;
s->rv10_first_dc_coded[0] = 0;
s->rv10_first_dc_coded[1] = 0;
s->rv10_first_dc_coded[2] = 0;
if(s->mb_y==0) s->first_slice_line=1;
s->block_wrap[0]=
s->block_wrap[1]=
s->block_wrap[2]=
s->block_wrap[3]= s->mb_width*2 + 2;
s->block_wrap[4]=
s->block_wrap[5]= s->mb_width + 2;
ff_init_block_index(s);
/* decode each macroblock */
for(i=0;i<mb_count;i++) {
ff_update_block_index(s);
#ifdef DEBUG
printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
#endif
s->dsp.clear_blocks(s->block[0]);
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
if (ff_h263_decode_mb(s, s->block) == SLICE_ERROR) {
fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
return -1;
}
ff_h263_update_motion_val(s);
MPV_decode_mb(s, s->block);
if (++s->mb_x == s->mb_width) {
s->mb_x = 0;
s->mb_y++;
ff_init_block_index(s);
s->first_slice_line=0;
}
}
return buf_size;
}
static int rv10_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
UINT8 *buf, int buf_size)
{
MpegEncContext *s = avctx->priv_data;
int i, mb_count, mb_pos, left;
DCTELEM block[6][64];
AVPicture *pict = data;
#ifdef DEBUG
printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
#endif
/* no supplementary picture */
if (buf_size == 0) {
*data_size = 0;
return 0;
}
init_get_bits(&s->gb, buf, buf_size);
mb_count = rv10_decode_picture_header(s);
if (mb_count < 0) {
#ifdef DEBUG
printf("HEADER ERROR\n");
#endif
return -1;
}
if (s->mb_x >= s->mb_width ||
s->mb_y >= s->mb_height) {
#ifdef DEBUG
printf("POS ERROR %d %d\n", s->mb_x, s->mb_y);
#endif
return -1;
}
mb_pos = s->mb_y * s->mb_width + s->mb_x;
left = s->mb_width * s->mb_height - mb_pos;
if (mb_count > left) {
#ifdef DEBUG
printf("COUNT ERROR\n");
#endif
return -1;
}
if (s->mb_x == 0 && s->mb_y == 0) {
MPV_frame_start(s);
}
#ifdef DEBUG
printf("qscale=%d\n", s->qscale);
#endif
/* default quantization values */
s->y_dc_scale = 8;
s->c_dc_scale = 8;
s->rv10_first_dc_coded[0] = 0;
s->rv10_first_dc_coded[1] = 0;
s->rv10_first_dc_coded[2] = 0;
/* decode each macroblock */
for(i=0;i<mb_count;i++) {
#ifdef DEBUG
printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
#endif
memset(block, 0, sizeof(block));
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
if (h263_decode_mb(s, block) < 0) {
#ifdef DEBUG
printf("ERROR\n");
#endif
return -1;
}
MPV_decode_mb(s, block);
if (++s->mb_x == s->mb_width) {
s->mb_x = 0;
s->mb_y++;
}
}
if (s->mb_x == 0 &&
s->mb_y == s->mb_height) {
MPV_frame_end(s);
pict->data[0] = s->current_picture[0];
pict->data[1] = s->current_picture[1];
pict->data[2] = s->current_picture[2];
pict->linesize[0] = s->linesize;
pict->linesize[1] = s->linesize / 2;
pict->linesize[2] = s->linesize / 2;
avctx->quality = s->qscale;
*data_size = sizeof(AVPicture);
} else {
*data_size = 0;
}
return buf_size;
}
static int decode_slice(MpegEncContext *s){
const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
const int mb_size= 16>>s->avctx->lowres;
s->last_resync_gb= s->gb;
s->first_slice_line= 1;
s->resync_mb_x= s->mb_x;
s->resync_mb_y= s->mb_y;
ff_set_qscale(s, s->qscale);
if(s->partitioned_frame){
const int qscale= s->qscale;
/* restore variables which were modified */
s->first_slice_line=1;
s->mb_x= s->resync_mb_x;
s->mb_y= s->resync_mb_y;
ff_set_qscale(s, qscale);
}
for(; s->mb_y < s->mb_height; s->mb_y++) {
/* per-row end of slice checks */
ff_init_block_index(s);
for(; s->mb_x < s->mb_width; s->mb_x++) {
int ret;
ff_update_block_index(s);
if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
s->first_slice_line=0;
}
/* DCT & quantize */
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
// s->mb_skipped = 0;
//printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
ret= s->decode_mb(s, s->block);
if (s->pict_type!=FF_B_TYPE)
ff_h263_update_motion_val(s);
if(ret<0){
const int xy= s->mb_x + s->mb_y*s->mb_stride;
if(ret==SLICE_END){
MPV_decode_mb(s, s->block);
if(++s->mb_x >= s->mb_width){
s->mb_x=0;
ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
s->mb_y++;
}
return 0;
}else if(ret==SLICE_NOEND){
av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy);
return -1;
}
return -1;
}
MPV_decode_mb(s, s->block);
}
ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
s->mb_x= 0;
}
return -1;
}
