git.sesse.net Git - ffmpeg/blob - libavcodec/h263dec.c

   1 /*
   2  * H263 decoder
   3  * Copyright (c) 2001 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include "avcodec.h"
  20 #include "dsputil.h"
  21 #include "mpegvideo.h"
  22
  23 #if 1
  24 #define PRINT_QP(a, b) {}
  25 #else
  26 #define PRINT_QP(a, b) printf(a, b)
  27 #endif
  28
  29 //#define DEBUG
  30 //#define PRINT_FRAME_TIME
  31 #ifdef PRINT_FRAME_TIME
  32 static inline long long rdtsc()
  33 {
  34         long long l;
  35         asm volatile(   "rdtsc\n\t"
  36                 : "=A" (l)
  37         );
  38 //      printf("%d\n", int(l/1000));
  39         return l;
  40 }
  41 #endif
  42
  43 const UINT16 ff_mpeg4_resync_prefix[8];
  44
  45 static int h263_decode_init(AVCodecContext *avctx)
  46 {
  47     MpegEncContext *s = avctx->priv_data;
  48
  49     s->avctx = avctx;
  50     s->out_format = FMT_H263;
  51
  52     s->width = avctx->width;
  53     s->height = avctx->height;
  54     s->workaround_bugs= avctx->workaround_bugs;
  55
  56     // set defaults
  57     s->quant_precision=5;
  58     s->progressive_sequence=1;
  59     s->decode_mb= ff_h263_decode_mb;
  60
  61     /* select sub codec */
  62     switch(avctx->codec->id) {
  63     case CODEC_ID_H263:
  64         s->gob_number = 0;
  65         s->first_slice_line = 0;
  66         break;
  67     case CODEC_ID_MPEG4:
  68         s->time_increment_bits = 4; /* default value for broken headers */
  69         s->h263_pred = 1;
  70         s->has_b_frames = 1; //default, might be overriden in the vol header during header parsing
  71         break;
  72     case CODEC_ID_MSMPEG4V1:
  73         s->h263_msmpeg4 = 1;
  74         s->h263_pred = 1;
  75         s->msmpeg4_version=1;
  76         break;
  77     case CODEC_ID_MSMPEG4V2:
  78         s->h263_msmpeg4 = 1;
  79         s->h263_pred = 1;
  80         s->msmpeg4_version=2;
  81         break;
  82     case CODEC_ID_MSMPEG4V3:
  83         s->h263_msmpeg4 = 1;
  84         s->h263_pred = 1;
  85         s->msmpeg4_version=3;
  86         break;
  87     case CODEC_ID_WMV1:
  88         s->h263_msmpeg4 = 1;
  89         s->h263_pred = 1;
  90         s->msmpeg4_version=4;
  91         break;
  92     case CODEC_ID_WMV2:
  93         s->h263_msmpeg4 = 1;
  94         s->h263_pred = 1;
  95         s->msmpeg4_version=5;
  96         break;
  97     case CODEC_ID_H263I:
  98         s->h263_intel = 1;
  99         break;
 100     default:
 101         return -1;
 102     }
 103     s->codec_id= avctx->codec->id;
 104
 105     /* for h263, we allocate the images after having read the header */
 106     if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4)
 107         if (MPV_common_init(s) < 0)
 108             return -1;
 109
 110     if (s->h263_msmpeg4)
 111         ff_msmpeg4_decode_init(s);
 112     else
 113         h263_decode_init_vlc(s);
 114
 115     return 0;
 116 }
 117
 118 static int h263_decode_end(AVCodecContext *avctx)
 119 {
 120     MpegEncContext *s = avctx->priv_data;
 121
 122     MPV_common_end(s);
 123     return 0;
 124 }
 125
 126 /**
 127  * retunrs the number of bytes consumed for building the current frame
 128  */
 129 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
 130     int pos= (get_bits_count(&s->gb)+7)>>3;
 131     if(s->divx_version>=500){
 132         //we would have to scan through the whole buf to handle the weird reordering ...
 133         return buf_size;
 134     }else{
 135         if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
 136         if(pos+10>buf_size) pos=buf_size; // oops ;)
 137
 138         return pos;
 139     }
 140 }
 141
 142 static int decode_slice(MpegEncContext *s){
 143     s->last_resync_gb= s->gb;
 144     s->first_slice_line= 1;
 145
 146     s->resync_mb_x= s->mb_x;
 147     s->resync_mb_y= s->mb_y;
 148
 149     s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
 150     s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
 151
 152     if(s->partitioned_frame){
 153         const int qscale= s->qscale;
 154
 155         if(s->codec_id==CODEC_ID_MPEG4){
 156             if(ff_mpeg4_decode_partitions(s) < 0)
 157                 return -1;
 158         }
 159
 160         /* restore variables which where modified */
 161         s->first_slice_line=1;
 162         s->mb_x= s->resync_mb_x;
 163         s->mb_y= s->resync_mb_y;
 164         s->qscale= qscale;
 165         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
 166         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
 167     }
 168
 169     for(; s->mb_y < s->mb_height; s->mb_y++) {
 170         /* per-row end of slice checks */
 171         if(s->msmpeg4_version){
 172             if(s->resync_mb_y + s->slice_height == s->mb_y){
 173                 const int xy= s->mb_x + s->mb_y*s->mb_width;
 174                 s->error_status_table[xy-1]|= AC_END|DC_END|MV_END;
 175                 return 0;
 176             }
 177         }
 178
 179         if(s->msmpeg4_version==1){
 180             s->last_dc[0]=
 181             s->last_dc[1]=
 182             s->last_dc[2]= 128;
 183         }
 184
 185         ff_init_block_index(s);
 186         for(; s->mb_x < s->mb_width; s->mb_x++) {
 187             int ret;
 188
 189             ff_update_block_index(s);
 190
 191             if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
 192                 s->first_slice_line=0;
 193             }
 194
 195             /* DCT & quantize */
 196             clear_blocks(s->block[0]);
 197
 198             s->mv_dir = MV_DIR_FORWARD;
 199             s->mv_type = MV_TYPE_16X16;
 200 //printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
 201             ret= s->decode_mb(s, s->block);
 202
 203             PRINT_QP("%2d", s->qscale);
 204             MPV_decode_mb(s, s->block);
 205
 206             if(ret<0){
 207                 const int xy= s->mb_x + s->mb_y*s->mb_width;
 208                 if(ret==SLICE_END){
 209 //printf("%d %d %06X\n", s->mb_x, s->gb.size*8 - get_bits_count(&s->gb), show_bits(&s->gb, 24));
 210                     s->error_status_table[xy]|= AC_END;
 211                     if(!s->partitioned_frame)
 212                         s->error_status_table[xy]|= MV_END|DC_END;
 213
 214                     if(++s->mb_x >= s->mb_width){
 215                         s->mb_x=0;
 216                         ff_draw_horiz_band(s);
 217                         s->mb_y++;
 218                     }
 219                     return 0;
 220                 }else if(ret==SLICE_NOEND){
 221                     fprintf(stderr,"Slice mismatch at MB: %d\n", xy);
 222                     return -1;
 223                 }
 224                 fprintf(stderr,"Error at MB: %d\n", xy);
 225                 s->error_status_table[xy]|= AC_ERROR;
 226                 if(!s->partitioned_frame)
 227                     s->error_status_table[xy]|= DC_ERROR|MV_ERROR;
 228
 229                 return -1;
 230             }
 231         }
 232
 233         ff_draw_horiz_band(s);
 234
 235         PRINT_QP("%s", "\n");
 236
 237         s->mb_x= 0;
 238     }
 239
 240     assert(s->mb_x==0 && s->mb_y==s->mb_height);
 241
 242     // handle formats which dont have unique end markers
 243     if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly
 244         int left= s->gb.size*8 - get_bits_count(&s->gb);
 245         int max_extra=7;
 246
 247         /* no markers in M$ crap */
 248         if(s->msmpeg4_version && s->pict_type==I_TYPE)
 249             max_extra+= 17;
 250
 251         /* buggy padding but the frame should still end approximately at the bitstream end */
 252         if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_resilience>=3)
 253             max_extra+= 48;
 254         else if((s->workaround_bugs&FF_BUG_NO_PADDING))
 255             max_extra+= 256*256*256*64;
 256
 257         if(left>max_extra){
 258             fprintf(stderr, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24));
 259         }
 260         else if(left<0){
 261             fprintf(stderr, "overreading %d bits\n", -left);
 262         }else
 263             s->error_status_table[s->mb_num-1]|= AC_END|MV_END|DC_END;
 264
 265         return 0;
 266     }
 267
 268     fprintf(stderr, "slice end not reached but screenspace end (%d left %06X)\n",
 269             s->gb.size*8 - get_bits_count(&s->gb),
 270             show_bits(&s->gb, 24));
 271     return -1;
 272 }
 273
 274 static int h263_decode_frame(AVCodecContext *avctx,
 275                              void *data, int *data_size,
 276                              UINT8 *buf, int buf_size)
 277 {
 278     MpegEncContext *s = avctx->priv_data;
 279     int ret,i;
 280     AVPicture *pict = data;
 281 #ifdef PRINT_FRAME_TIME
 282 uint64_t time= rdtsc();
 283 #endif
 284 #ifdef DEBUG
 285     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 286     printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
 287 #endif
 288
 289     s->hurry_up= avctx->hurry_up;
 290     s->error_resilience= avctx->error_resilience;
 291
 292     s->flags= avctx->flags;
 293
 294     *data_size = 0;
 295
 296    /* no supplementary picture */
 297     if (buf_size == 0) {
 298         return 0;
 299     }
 300
 301     if(s->bitstream_buffer_size && buf_size<20){ //divx 5.01+ frame reorder
 302         init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size);
 303     }else
 304         init_get_bits(&s->gb, buf, buf_size);
 305     s->bitstream_buffer_size=0;
 306
 307     if (!s->context_initialized) {
 308         if (DCT_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
 309             return -1;
 310     }
 311
 312     /* let's go :-) */
 313     if (s->h263_msmpeg4) {
 314         ret = msmpeg4_decode_picture_header(s);
 315     } else if (s->h263_pred) {
 316         ret = mpeg4_decode_picture_header(s);
 317         s->has_b_frames= !s->low_delay;
 318     } else if (s->h263_intel) {
 319         ret = intel_h263_decode_picture_header(s);
 320     } else {
 321         ret = h263_decode_picture_header(s);
 322     }
 323     avctx->has_b_frames= s->has_b_frames;
 324
 325     if(s->workaround_bugs&FF_BUG_AUTODETECT){
 326         if(s->avctx->fourcc == ff_get_fourcc("XVIX"))
 327             s->workaround_bugs|= FF_BUG_XVID_ILACE;
 328
 329         if(s->avctx->fourcc == ff_get_fourcc("MP4S"))
 330             s->workaround_bugs|= FF_BUG_AC_VLC;
 331
 332         if(s->avctx->fourcc == ff_get_fourcc("M4S2"))
 333             s->workaround_bugs|= FF_BUG_AC_VLC;
 334
 335         if(s->avctx->fourcc == ff_get_fourcc("UMP4")){
 336             s->workaround_bugs|= FF_BUG_UMP4;
 337             s->workaround_bugs|= FF_BUG_AC_VLC;
 338         }
 339
 340         if(s->divx_version==500)
 341             s->workaround_bugs|= FF_BUG_NO_PADDING;
 342
 343         /* very ugly XVID padding bug detection FIXME/XXX solve this differently
 344          * lets hope this at least works
 345          */
 346         if(   s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0
 347            && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
 348             s->workaround_bugs|= FF_BUG_NO_PADDING;
 349
 350         if(s->lavc_build && s->lavc_build<4609) //FIXME not sure about the version num but a 4609 file seems ok
 351             s->workaround_bugs|= FF_BUG_NO_PADDING;
 352     }
 353
 354
 355 #if 0 // dump bits per frame / qp / complexity
 356 {
 357     static FILE *f=NULL;
 358     if(!f) f=fopen("rate_qp_cplx.txt", "w");
 359     fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
 360 }
 361 #endif
 362
 363         /* After H263 & mpeg4 header decode we have the height, width,*/
 364         /* and other parameters. So then we could init the picture   */
 365         /* FIXME: By the way H263 decoder is evolving it should have */
 366         /* an H263EncContext                                         */
 367     if (   s->width != avctx->width || s->height != avctx->height
 368         || avctx->aspect_ratio_info != s->aspect_ratio_info
 369         || avctx->aspected_width != s->aspected_width
 370         || avctx->aspected_height != s->aspected_height) {
 371         /* H.263 could change picture size any time */
 372         MPV_common_end(s);
 373         s->context_initialized=0;
 374     }
 375     if (!s->context_initialized) {
 376         avctx->width = s->width;
 377         avctx->height = s->height;
 378         avctx->aspect_ratio_info= s->aspect_ratio_info;
 379         if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
 380         {
 381             avctx->aspected_width = s->aspected_width;
 382             avctx->aspected_height = s->aspected_height;
 383         }
 384
 385         if (s->codec_id==CODEC_ID_H263 && s->codec_id==CODEC_ID_H263)
 386             s->gob_index = ff_h263_get_gob_height(s);
 387
 388         if (MPV_common_init(s) < 0)
 389             return -1;
 390     }
 391
 392     if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_size);
 393     /* skip if the header was thrashed */
 394     if (ret < 0){
 395         fprintf(stderr, "header damaged\n");
 396         return -1;
 397     }
 398     /* skip b frames if we dont have reference frames */
 399     if(s->num_available_buffers<2 && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
 400     /* skip b frames if we are in a hurry */
 401     if(s->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
 402
 403     if(s->next_p_frame_damaged){
 404         if(s->pict_type==B_TYPE)
 405             return get_consumed_bytes(s, buf_size);
 406         else
 407             s->next_p_frame_damaged=0;
 408     }
 409
 410     MPV_frame_start(s, avctx);
 411
 412 #ifdef DEBUG
 413     printf("qscale=%d\n", s->qscale);
 414 #endif
 415
 416     if(s->error_resilience)
 417         memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_num*sizeof(UINT8));
 418
 419     /* decode each macroblock */
 420     s->block_wrap[0]=
 421     s->block_wrap[1]=
 422     s->block_wrap[2]=
 423     s->block_wrap[3]= s->mb_width*2 + 2;
 424     s->block_wrap[4]=
 425     s->block_wrap[5]= s->mb_width + 2;
 426     s->mb_x=0;
 427     s->mb_y=0;
 428
 429     decode_slice(s);
 430     s->error_status_table[0]|= VP_START;
 431     while(s->mb_y<s->mb_height && s->gb.size*8 - get_bits_count(&s->gb)>32){
 432         if(s->msmpeg4_version){
 433             if(s->mb_x!=0 || (s->mb_y%s->slice_height)!=0)
 434                 break;
 435         }else{
 436             if(ff_h263_resync(s)<0)
 437                 break;
 438         }
 439
 440         if(s->msmpeg4_version!=4)
 441             ff_mpeg4_clean_buffers(s);
 442
 443         decode_slice(s);
 444         s->error_status_table[s->resync_mb_x + s->resync_mb_y*s->mb_width]|= VP_START;
 445     }
 446
 447     if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)
 448         if(msmpeg4_decode_ext_header(s, buf_size) < 0) return -1;
 449
 450     /* divx 5.01+ bistream reorder stuff */
 451     if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_version>=500){
 452         int current_pos= get_bits_count(&s->gb)>>3;
 453
 454         if(   buf_size - current_pos > 5
 455            && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){
 456             int i;
 457             int startcode_found=0;
 458             for(i=current_pos; i<buf_size-3; i++){
 459                 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
 460                     startcode_found=1;
 461                     break;
 462                 }
 463             }
 464             if(startcode_found){
 465                 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
 466                 s->bitstream_buffer_size= buf_size - current_pos;
 467             }
 468         }
 469     }
 470
 471     if(s->error_resilience){
 472         int error=0, num_end_markers=0;
 473         for(i=0; i<s->mb_num; i++){
 474             int status= s->error_status_table[i];
 475 #if 0
 476             if(i%s->mb_width == 0) printf("\n");
 477             printf("%2X ", status);
 478 #endif
 479             if(status==0) continue;
 480
 481             if(status&(DC_ERROR|AC_ERROR|MV_ERROR))
 482                 error=1;
 483             if(status&VP_START){
 484                 if(num_end_markers)
 485                     error=1;
 486                 num_end_markers=3;
 487             }
 488             if(status&AC_END)
 489                 num_end_markers--;
 490             if(status&DC_END)
 491                 num_end_markers--;
 492             if(status&MV_END)
 493                 num_end_markers--;
 494         }
 495         if(num_end_markers || error){
 496             fprintf(stderr, "concealing errors\n");
 497 //printf("type:%d\n", s->pict_type);
 498             ff_error_resilience(s);
 499         }
 500     }
 501
 502     MPV_frame_end(s);
 503 #if 0 //dirty show MVs, we should export the MV tables and write a filter to show them
 504 {
 505   int mb_y;
 506   s->has_b_frames=1;
 507   for(mb_y=0; mb_y<s->mb_height; mb_y++){
 508     int mb_x;
 509     int y= mb_y*16 + 8;
 510     for(mb_x=0; mb_x<s->mb_width; mb_x++){
 511       int x= mb_x*16 + 8;
 512       uint8_t *ptr= s->last_picture[0];
 513       int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
 514       int mx= (s->motion_val[xy][0]>>1) + x;
 515       int my= (s->motion_val[xy][1]>>1) + y;
 516       int i;
 517       int max;
 518
 519       if(mx<0) mx=0;
 520       if(my<0) my=0;
 521       if(mx>=s->width)  mx= s->width -1;
 522       if(my>=s->height) my= s->height-1;
 523       max= ABS(mx-x);
 524       if(ABS(my-y) > max) max= ABS(my-y);
 525       /* the ugliest linedrawing routine ... */
 526       for(i=0; i<max; i++){
 527         int x1= x + (mx-x)*i/max;
 528         int y1= y + (my-y)*i/max;
 529         ptr[y1*s->linesize + x1]+=100;
 530       }
 531       ptr[y*s->linesize + x]+=100;
 532       s->mbskip_table[mb_x + mb_y*s->mb_width]=0;
 533     }
 534   }
 535
 536 }
 537 #endif
 538     if(s->pict_type==B_TYPE || (!s->has_b_frames)){
 539         pict->data[0] = s->current_picture[0];
 540         pict->data[1] = s->current_picture[1];
 541         pict->data[2] = s->current_picture[2];
 542     } else {
 543         pict->data[0] = s->last_picture[0];
 544         pict->data[1] = s->last_picture[1];
 545         pict->data[2] = s->last_picture[2];
 546     }
 547     pict->linesize[0] = s->linesize;
 548     pict->linesize[1] = s->uvlinesize;
 549     pict->linesize[2] = s->uvlinesize;
 550
 551     avctx->quality = s->qscale;
 552
 553     /* Return the Picture timestamp as the frame number */
 554     /* we substract 1 because it is added on utils.c    */
 555     avctx->frame_number = s->picture_number - 1;
 556
 557     /* dont output the last pic after seeking
 558        note we allready added +1 for the current pix in MPV_frame_end(s) */
 559     if(s->num_available_buffers>=2 || (!s->has_b_frames))
 560         *data_size = sizeof(AVPicture);
 561 #ifdef PRINT_FRAME_TIME
 562 printf("%Ld\n", rdtsc()-time);
 563 #endif
 564     return get_consumed_bytes(s, buf_size);
 565 }
 566
 567 AVCodec mpeg4_decoder = {
 568     "mpeg4",
 569     CODEC_TYPE_VIDEO,
 570     CODEC_ID_MPEG4,
 571     sizeof(MpegEncContext),
 572     h263_decode_init,
 573     NULL,
 574     h263_decode_end,
 575     h263_decode_frame,
 576     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 577 };
 578
 579 AVCodec h263_decoder = {
 580     "h263",
 581     CODEC_TYPE_VIDEO,
 582     CODEC_ID_H263,
 583     sizeof(MpegEncContext),
 584     h263_decode_init,
 585     NULL,
 586     h263_decode_end,
 587     h263_decode_frame,
 588     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 589 };
 590
 591 AVCodec msmpeg4v1_decoder = {
 592     "msmpeg4v1",
 593     CODEC_TYPE_VIDEO,
 594     CODEC_ID_MSMPEG4V1,
 595     sizeof(MpegEncContext),
 596     h263_decode_init,
 597     NULL,
 598     h263_decode_end,
 599     h263_decode_frame,
 600     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 601 };
 602
 603 AVCodec msmpeg4v2_decoder = {
 604     "msmpeg4v2",
 605     CODEC_TYPE_VIDEO,
 606     CODEC_ID_MSMPEG4V2,
 607     sizeof(MpegEncContext),
 608     h263_decode_init,
 609     NULL,
 610     h263_decode_end,
 611     h263_decode_frame,
 612     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 613 };
 614
 615 AVCodec msmpeg4v3_decoder = {
 616     "msmpeg4",
 617     CODEC_TYPE_VIDEO,
 618     CODEC_ID_MSMPEG4V3,
 619     sizeof(MpegEncContext),
 620     h263_decode_init,
 621     NULL,
 622     h263_decode_end,
 623     h263_decode_frame,
 624     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 625 };
 626
 627 AVCodec wmv1_decoder = {
 628     "wmv1",
 629     CODEC_TYPE_VIDEO,
 630     CODEC_ID_WMV1,
 631     sizeof(MpegEncContext),
 632     h263_decode_init,
 633     NULL,
 634     h263_decode_end,
 635     h263_decode_frame,
 636     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 637 };
 638
 639 AVCodec wmv2_decoder = {
 640     "wmv2",
 641     CODEC_TYPE_VIDEO,
 642     CODEC_ID_WMV2,
 643     sizeof(MpegEncContext),
 644     h263_decode_init,
 645     NULL,
 646     h263_decode_end,
 647     h263_decode_frame,
 648     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 649 };
 650
 651 AVCodec h263i_decoder = {
 652     "h263i",
 653     CODEC_TYPE_VIDEO,
 654     CODEC_ID_H263I,
 655     sizeof(MpegEncContext),
 656     h263_decode_init,
 657     NULL,
 658     h263_decode_end,
 659     h263_decode_frame,
 660     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 661 };
 662