00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "internal.h"
00029 #include "avcodec.h"
00030 #include "dsputil.h"
00031 #include "mpegvideo.h"
00032 #include "h263.h"
00033 #include "h263_parser.h"
00034 #include "mpeg4video_parser.h"
00035 #include "msmpeg4.h"
00036 #include "vdpau_internal.h"
00037 #include "flv.h"
00038 #include "mpeg4video.h"
00039
00040
00041
00042
00043 av_cold int ff_h263_decode_init(AVCodecContext *avctx)
00044 {
00045 MpegEncContext *s = avctx->priv_data;
00046
00047 s->avctx = avctx;
00048 s->out_format = FMT_H263;
00049
00050 s->width = avctx->coded_width;
00051 s->height = avctx->coded_height;
00052 s->workaround_bugs= avctx->workaround_bugs;
00053
00054
00055 MPV_decode_defaults(s);
00056 s->quant_precision=5;
00057 s->decode_mb= ff_h263_decode_mb;
00058 s->low_delay= 1;
00059 avctx->pix_fmt= avctx->get_format(avctx, avctx->codec->pix_fmts);
00060 s->unrestricted_mv= 1;
00061
00062
00063 switch(avctx->codec->id) {
00064 case CODEC_ID_H263:
00065 s->unrestricted_mv= 0;
00066 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
00067 break;
00068 case CODEC_ID_MPEG4:
00069 break;
00070 case CODEC_ID_MSMPEG4V1:
00071 s->h263_msmpeg4 = 1;
00072 s->h263_pred = 1;
00073 s->msmpeg4_version=1;
00074 break;
00075 case CODEC_ID_MSMPEG4V2:
00076 s->h263_msmpeg4 = 1;
00077 s->h263_pred = 1;
00078 s->msmpeg4_version=2;
00079 break;
00080 case CODEC_ID_MSMPEG4V3:
00081 s->h263_msmpeg4 = 1;
00082 s->h263_pred = 1;
00083 s->msmpeg4_version=3;
00084 break;
00085 case CODEC_ID_WMV1:
00086 s->h263_msmpeg4 = 1;
00087 s->h263_pred = 1;
00088 s->msmpeg4_version=4;
00089 break;
00090 case CODEC_ID_WMV2:
00091 s->h263_msmpeg4 = 1;
00092 s->h263_pred = 1;
00093 s->msmpeg4_version=5;
00094 break;
00095 case CODEC_ID_VC1:
00096 case CODEC_ID_WMV3:
00097 s->h263_msmpeg4 = 1;
00098 s->h263_pred = 1;
00099 s->msmpeg4_version=6;
00100 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
00101 break;
00102 case CODEC_ID_H263I:
00103 break;
00104 case CODEC_ID_FLV1:
00105 s->h263_flv = 1;
00106 break;
00107 default:
00108 return -1;
00109 }
00110 s->codec_id= avctx->codec->id;
00111 avctx->hwaccel= ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
00112
00113
00114 if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4)
00115 if (MPV_common_init(s) < 0)
00116 return -1;
00117
00118 h263_decode_init_vlc(s);
00119
00120 return 0;
00121 }
00122
00123 av_cold int ff_h263_decode_end(AVCodecContext *avctx)
00124 {
00125 MpegEncContext *s = avctx->priv_data;
00126
00127 MPV_common_end(s);
00128 return 0;
00129 }
00130
00134 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
00135 int pos= (get_bits_count(&s->gb)+7)>>3;
00136
00137 if(s->divx_packed || s->avctx->hwaccel){
00138
00139 return buf_size;
00140 }else if(s->flags&CODEC_FLAG_TRUNCATED){
00141 pos -= s->parse_context.last_index;
00142 if(pos<0) pos=0;
00143 return pos;
00144 }else{
00145 if(pos==0) pos=1;
00146 if(pos+10>buf_size) pos=buf_size;
00147
00148 return pos;
00149 }
00150 }
00151
00152 static int decode_slice(MpegEncContext *s){
00153 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
00154 const int mb_size= 16>>s->avctx->lowres;
00155 s->last_resync_gb= s->gb;
00156 s->first_slice_line= 1;
00157
00158 s->resync_mb_x= s->mb_x;
00159 s->resync_mb_y= s->mb_y;
00160
00161 ff_set_qscale(s, s->qscale);
00162
00163 if (s->avctx->hwaccel) {
00164 const uint8_t *start= s->gb.buffer + get_bits_count(&s->gb)/8;
00165 const uint8_t *end = ff_h263_find_resync_marker(start + 1, s->gb.buffer_end);
00166 skip_bits_long(&s->gb, 8*(end - start));
00167 return s->avctx->hwaccel->decode_slice(s->avctx, start, end - start);
00168 }
00169
00170 if(s->partitioned_frame){
00171 const int qscale= s->qscale;
00172
00173 if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
00174 if(ff_mpeg4_decode_partitions(s) < 0)
00175 return -1;
00176 }
00177
00178
00179 s->first_slice_line=1;
00180 s->mb_x= s->resync_mb_x;
00181 s->mb_y= s->resync_mb_y;
00182 ff_set_qscale(s, qscale);
00183 }
00184
00185 for(; s->mb_y < s->mb_height; s->mb_y++) {
00186
00187 if(s->msmpeg4_version){
00188 if(s->resync_mb_y + s->slice_height == s->mb_y){
00189 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);
00190
00191 return 0;
00192 }
00193 }
00194
00195 if(s->msmpeg4_version==1){
00196 s->last_dc[0]=
00197 s->last_dc[1]=
00198 s->last_dc[2]= 128;
00199 }
00200
00201 ff_init_block_index(s);
00202 for(; s->mb_x < s->mb_width; s->mb_x++) {
00203 int ret;
00204
00205 ff_update_block_index(s);
00206
00207 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
00208 s->first_slice_line=0;
00209 }
00210
00211
00212
00213 s->mv_dir = MV_DIR_FORWARD;
00214 s->mv_type = MV_TYPE_16X16;
00215
00216
00217 ret= s->decode_mb(s, s->block);
00218
00219 if (s->pict_type!=FF_B_TYPE)
00220 ff_h263_update_motion_val(s);
00221
00222 if(ret<0){
00223 const int xy= s->mb_x + s->mb_y*s->mb_stride;
00224 if(ret==SLICE_END){
00225 MPV_decode_mb(s, s->block);
00226 if(s->loop_filter)
00227 ff_h263_loop_filter(s);
00228
00229
00230 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);
00231
00232 s->padding_bug_score--;
00233
00234 if(++s->mb_x >= s->mb_width){
00235 s->mb_x=0;
00236 ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
00237 s->mb_y++;
00238 }
00239 return 0;
00240 }else if(ret==SLICE_NOEND){
00241 av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy);
00242 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);
00243 return -1;
00244 }
00245 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
00246 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);
00247
00248 return -1;
00249 }
00250
00251 MPV_decode_mb(s, s->block);
00252 if(s->loop_filter)
00253 ff_h263_loop_filter(s);
00254 }
00255
00256 ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
00257
00258 s->mb_x= 0;
00259 }
00260
00261 assert(s->mb_x==0 && s->mb_y==s->mb_height);
00262
00263
00264 if( s->codec_id==CODEC_ID_MPEG4
00265 && (s->workaround_bugs&FF_BUG_AUTODETECT)
00266 && get_bits_left(&s->gb) >=0
00267 && get_bits_left(&s->gb) < 48
00268
00269 && !s->data_partitioning){
00270
00271 const int bits_count= get_bits_count(&s->gb);
00272 const int bits_left = s->gb.size_in_bits - bits_count;
00273
00274 if(bits_left==0){
00275 s->padding_bug_score+=16;
00276 } else if(bits_left != 1){
00277 int v= show_bits(&s->gb, 8);
00278 v|= 0x7F >> (7-(bits_count&7));
00279
00280 if(v==0x7F && bits_left<=8)
00281 s->padding_bug_score--;
00282 else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16)
00283 s->padding_bug_score+= 4;
00284 else
00285 s->padding_bug_score++;
00286 }
00287 }
00288
00289 if(s->workaround_bugs&FF_BUG_AUTODETECT){
00290 if(s->padding_bug_score > -2 && !s->data_partitioning )
00291 s->workaround_bugs |= FF_BUG_NO_PADDING;
00292 else
00293 s->workaround_bugs &= ~FF_BUG_NO_PADDING;
00294 }
00295
00296
00297 if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){
00298 int left= get_bits_left(&s->gb);
00299 int max_extra=7;
00300
00301
00302 if(s->msmpeg4_version && s->pict_type==FF_I_TYPE)
00303 max_extra+= 17;
00304
00305
00306 if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_recognition>=3)
00307 max_extra+= 48;
00308 else if((s->workaround_bugs&FF_BUG_NO_PADDING))
00309 max_extra+= 256*256*256*64;
00310
00311 if(left>max_extra){
00312 av_log(s->avctx, AV_LOG_ERROR, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24));
00313 }
00314 else if(left<0){
00315 av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
00316 }else
00317 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);
00318
00319 return 0;
00320 }
00321
00322 av_log(s->avctx, AV_LOG_ERROR, "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
00323 get_bits_left(&s->gb),
00324 show_bits(&s->gb, 24), s->padding_bug_score);
00325
00326 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);
00327
00328 return -1;
00329 }
00330
00331 int ff_h263_decode_frame(AVCodecContext *avctx,
00332 void *data, int *data_size,
00333 AVPacket *avpkt)
00334 {
00335 const uint8_t *buf = avpkt->data;
00336 int buf_size = avpkt->size;
00337 MpegEncContext *s = avctx->priv_data;
00338 int ret;
00339 AVFrame *pict = data;
00340
00341 #ifdef PRINT_FRAME_TIME
00342 uint64_t time= rdtsc();
00343 #endif
00344 s->flags= avctx->flags;
00345 s->flags2= avctx->flags2;
00346
00347
00348 if (buf_size == 0) {
00349
00350 if (s->low_delay==0 && s->next_picture_ptr) {
00351 *pict= *(AVFrame*)s->next_picture_ptr;
00352 s->next_picture_ptr= NULL;
00353
00354 *data_size = sizeof(AVFrame);
00355 }
00356
00357 return 0;
00358 }
00359
00360 if(s->flags&CODEC_FLAG_TRUNCATED){
00361 int next;
00362
00363 if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
00364 next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);
00365 }else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){
00366 next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
00367 }else{
00368 av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");
00369 return -1;
00370 }
00371
00372 if( ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
00373 return buf_size;
00374 }
00375
00376
00377 retry:
00378
00379 if(s->bitstream_buffer_size && (s->divx_packed || buf_size<20)){
00380 init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
00381 }else
00382 init_get_bits(&s->gb, buf, buf_size*8);
00383 s->bitstream_buffer_size=0;
00384
00385 if (!s->context_initialized) {
00386 if (MPV_common_init(s) < 0)
00387 return -1;
00388 }
00389
00390
00391
00392 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
00393 int i= ff_find_unused_picture(s, 0);
00394 s->current_picture_ptr= &s->picture[i];
00395 }
00396
00397
00398 if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) {
00399 ret= ff_wmv2_decode_picture_header(s);
00400 } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {
00401 ret = msmpeg4_decode_picture_header(s);
00402 } else if (CONFIG_MPEG4_DECODER && s->h263_pred) {
00403 if(s->avctx->extradata_size && s->picture_number==0){
00404 GetBitContext gb;
00405
00406 init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
00407 ret = ff_mpeg4_decode_picture_header(s, &gb);
00408 }
00409 ret = ff_mpeg4_decode_picture_header(s, &s->gb);
00410 } else if (CONFIG_H263I_DECODER && s->codec_id == CODEC_ID_H263I) {
00411 ret = ff_intel_h263_decode_picture_header(s);
00412 } else if (CONFIG_FLV_DECODER && s->h263_flv) {
00413 ret = ff_flv_decode_picture_header(s);
00414 } else {
00415 ret = h263_decode_picture_header(s);
00416 }
00417
00418 if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size);
00419
00420
00421 if (ret < 0){
00422 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
00423 return -1;
00424 }
00425
00426 avctx->has_b_frames= !s->low_delay;
00427
00428 if(s->xvid_build==-1 && s->divx_version==-1 && s->lavc_build==-1){
00429 if(s->stream_codec_tag == AV_RL32("XVID") ||
00430 s->codec_tag == AV_RL32("XVID") || s->codec_tag == AV_RL32("XVIX") ||
00431 s->codec_tag == AV_RL32("RMP4"))
00432 s->xvid_build= 0;
00433 #if 0
00434 if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==1
00435 && s->padding_bug_score > 0 && s->low_delay)
00436 s->xvid_build= 0;
00437 #endif
00438 }
00439
00440 if(s->xvid_build==-1 && s->divx_version==-1 && s->lavc_build==-1){
00441 if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
00442 s->divx_version= 400;
00443 }
00444
00445 if(s->xvid_build>=0 && s->divx_version>=0){
00446 s->divx_version=
00447 s->divx_build= -1;
00448 }
00449
00450 if(s->workaround_bugs&FF_BUG_AUTODETECT){
00451 if(s->codec_tag == AV_RL32("XVIX"))
00452 s->workaround_bugs|= FF_BUG_XVID_ILACE;
00453
00454 if(s->codec_tag == AV_RL32("UMP4")){
00455 s->workaround_bugs|= FF_BUG_UMP4;
00456 }
00457
00458 if(s->divx_version>=500 && s->divx_build<1814){
00459 s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
00460 }
00461
00462 if(s->divx_version>502 && s->divx_build<1814){
00463 s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;
00464 }
00465
00466 if(s->xvid_build<=3U)
00467 s->padding_bug_score= 256*256*256*64;
00468
00469 if(s->xvid_build<=1U)
00470 s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
00471
00472 if(s->xvid_build<=12U)
00473 s->workaround_bugs|= FF_BUG_EDGE;
00474
00475 if(s->xvid_build<=32U)
00476 s->workaround_bugs|= FF_BUG_DC_CLIP;
00477
00478 #define SET_QPEL_FUNC(postfix1, postfix2) \
00479 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
00480 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
00481 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
00482
00483 if(s->lavc_build<4653U)
00484 s->workaround_bugs|= FF_BUG_STD_QPEL;
00485
00486 if(s->lavc_build<4655U)
00487 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
00488
00489 if(s->lavc_build<4670U){
00490 s->workaround_bugs|= FF_BUG_EDGE;
00491 }
00492
00493 if(s->lavc_build<=4712U)
00494 s->workaround_bugs|= FF_BUG_DC_CLIP;
00495
00496 if(s->divx_version>=0)
00497 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
00498
00499 if(s->divx_version==501 && s->divx_build==20020416)
00500 s->padding_bug_score= 256*256*256*64;
00501
00502 if(s->divx_version<500U){
00503 s->workaround_bugs|= FF_BUG_EDGE;
00504 }
00505
00506 if(s->divx_version>=0)
00507 s->workaround_bugs|= FF_BUG_HPEL_CHROMA;
00508 #if 0
00509 if(s->divx_version==500)
00510 s->padding_bug_score= 256*256*256*64;
00511
00512
00513
00514
00515 if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==-1
00516 && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
00517 s->workaround_bugs|= FF_BUG_NO_PADDING;
00518
00519 if(s->lavc_build<4609U)
00520 s->workaround_bugs|= FF_BUG_NO_PADDING;
00521 #endif
00522 }
00523
00524 if(s->workaround_bugs& FF_BUG_STD_QPEL){
00525 SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
00526 SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
00527 SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
00528 SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
00529 SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
00530 SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
00531
00532 SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
00533 SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
00534 SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
00535 SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
00536 SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
00537 SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
00538 }
00539
00540 if(avctx->debug & FF_DEBUG_BUGS)
00541 av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
00542 s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build,
00543 s->divx_packed ? "p" : "");
00544
00545 #if 0 // dump bits per frame / qp / complexity
00546 {
00547 static FILE *f=NULL;
00548 if(!f) f=fopen("rate_qp_cplx.txt", "w");
00549 fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
00550 }
00551 #endif
00552
00553 #if HAVE_MMX
00554 if(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build>=0 && avctx->idct_algo == FF_IDCT_AUTO && (mm_flags & FF_MM_MMX)){
00555 avctx->idct_algo= FF_IDCT_XVIDMMX;
00556 avctx->coded_width= 0;
00557
00558 s->picture_number=0;
00559 }
00560 #endif
00561
00562
00563
00564
00565
00566
00567 if ( s->width != avctx->coded_width
00568 || s->height != avctx->coded_height) {
00569
00570 ParseContext pc= s->parse_context;
00571 s->parse_context.buffer=0;
00572 MPV_common_end(s);
00573 s->parse_context= pc;
00574 }
00575 if (!s->context_initialized) {
00576 avcodec_set_dimensions(avctx, s->width, s->height);
00577
00578 goto retry;
00579 }
00580
00581 if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P || s->codec_id == CODEC_ID_H263I))
00582 s->gob_index = ff_h263_get_gob_height(s);
00583
00584
00585 s->current_picture.pict_type= s->pict_type;
00586 s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
00587
00588
00589 if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size);
00590
00591 if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, buf_size);
00592 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
00593 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
00594 || avctx->skip_frame >= AVDISCARD_ALL)
00595 return get_consumed_bytes(s, buf_size);
00596
00597 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
00598
00599 if(s->next_p_frame_damaged){
00600 if(s->pict_type==FF_B_TYPE)
00601 return get_consumed_bytes(s, buf_size);
00602 else
00603 s->next_p_frame_damaged=0;
00604 }
00605
00606 if((s->avctx->flags2 & CODEC_FLAG2_FAST) && s->pict_type==FF_B_TYPE){
00607 s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
00608 s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
00609 }else if((!s->no_rounding) || s->pict_type==FF_B_TYPE){
00610 s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
00611 s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
00612 }else{
00613 s->me.qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab;
00614 s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
00615 }
00616
00617 if(MPV_frame_start(s, avctx) < 0)
00618 return -1;
00619
00620 if (CONFIG_MPEG4_VDPAU_DECODER && (s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) {
00621 ff_vdpau_mpeg4_decode_picture(s, s->gb.buffer, s->gb.buffer_end - s->gb.buffer);
00622 goto frame_end;
00623 }
00624
00625 if (avctx->hwaccel) {
00626 if (avctx->hwaccel->start_frame(avctx, s->gb.buffer, s->gb.buffer_end - s->gb.buffer) < 0)
00627 return -1;
00628 }
00629
00630 ff_er_frame_start(s);
00631
00632
00633
00634 if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5){
00635 ret = ff_wmv2_decode_secondary_picture_header(s);
00636 if(ret<0) return ret;
00637 if(ret==1) goto intrax8_decoded;
00638 }
00639
00640
00641 s->mb_x=0;
00642 s->mb_y=0;
00643
00644 decode_slice(s);
00645 while(s->mb_y<s->mb_height){
00646 if(s->msmpeg4_version){
00647 if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
00648 break;
00649 }else{
00650 if(ff_h263_resync(s)<0)
00651 break;
00652 }
00653
00654 if(s->msmpeg4_version<4 && s->h263_pred)
00655 ff_mpeg4_clean_buffers(s);
00656
00657 decode_slice(s);
00658 }
00659
00660 if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==FF_I_TYPE)
00661 if(!CONFIG_MSMPEG4_DECODER || msmpeg4_decode_ext_header(s, buf_size) < 0){
00662 s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;
00663 }
00664
00665 assert(s->bitstream_buffer_size==0);
00666 frame_end:
00667
00668 if(s->codec_id==CODEC_ID_MPEG4 && s->divx_packed){
00669 int current_pos= get_bits_count(&s->gb)>>3;
00670 int startcode_found=0;
00671
00672 if(buf_size - current_pos > 5){
00673 int i;
00674 for(i=current_pos; i<buf_size-3; i++){
00675 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
00676 startcode_found=1;
00677 break;
00678 }
00679 }
00680 }
00681 if(s->gb.buffer == s->bitstream_buffer && buf_size>7 && s->xvid_build>=0){
00682 startcode_found=1;
00683 current_pos=0;
00684 }
00685
00686 if(startcode_found){
00687 av_fast_malloc(
00688 &s->bitstream_buffer,
00689 &s->allocated_bitstream_buffer_size,
00690 buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE);
00691 if (!s->bitstream_buffer)
00692 return AVERROR(ENOMEM);
00693 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
00694 s->bitstream_buffer_size= buf_size - current_pos;
00695 }
00696 }
00697
00698 intrax8_decoded:
00699 ff_er_frame_end(s);
00700
00701 if (avctx->hwaccel) {
00702 if (avctx->hwaccel->end_frame(avctx) < 0)
00703 return -1;
00704 }
00705
00706 MPV_frame_end(s);
00707
00708 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
00709 assert(s->current_picture.pict_type == s->pict_type);
00710 if (s->pict_type == FF_B_TYPE || s->low_delay) {
00711 *pict= *(AVFrame*)s->current_picture_ptr;
00712 } else if (s->last_picture_ptr != NULL) {
00713 *pict= *(AVFrame*)s->last_picture_ptr;
00714 }
00715
00716 if(s->last_picture_ptr || s->low_delay){
00717 *data_size = sizeof(AVFrame);
00718 ff_print_debug_info(s, pict);
00719 }
00720
00721 #ifdef PRINT_FRAME_TIME
00722 av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time);
00723 #endif
00724
00725 return get_consumed_bytes(s, buf_size);
00726 }
00727
00728 AVCodec h263_decoder = {
00729 "h263",
00730 AVMEDIA_TYPE_VIDEO,
00731 CODEC_ID_H263,
00732 sizeof(MpegEncContext),
00733 ff_h263_decode_init,
00734 NULL,
00735 ff_h263_decode_end,
00736 ff_h263_decode_frame,
00737 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
00738 .flush= ff_mpeg_flush,
00739 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
00740 .pix_fmts= ff_hwaccel_pixfmt_list_420,
00741 };