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