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