home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wvis0626.zip / warpvision_20020626.zip / libavcodec / h263dec.c < prev    next >
C/C++ Source or Header  |  2002-06-24  |  18KB  |  549 lines
  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. //#define DEBUG
  24. //#define PRINT_FRAME_TIME
  25. #ifdef PRINT_FRAME_TIME
  26. static inline long long rdtsc()
  27. {
  28.     long long l;
  29.     asm volatile(    "rdtsc\n\t"
  30.         : "=A" (l)
  31.     );
  32. //    printf("%d\n", int(l/1000));
  33.     return l;
  34. }
  35. #endif
  36.  
  37. static int h263_decode_init(AVCodecContext *avctx)
  38. {
  39.     MpegEncContext *s = avctx->priv_data;
  40.  
  41.     s->avctx = avctx;
  42.     s->out_format = FMT_H263;
  43.  
  44.     s->width = avctx->width;
  45.     s->height = avctx->height;
  46.     s->workaround_bugs= avctx->workaround_bugs;
  47.  
  48.     /* select sub codec */
  49.     switch(avctx->codec->id) {
  50.     case CODEC_ID_H263:
  51.         s->gob_number = 0;
  52.         s->first_slice_line = 0;
  53.         break;
  54.     case CODEC_ID_MPEG4:
  55.         s->time_increment_bits = 4; /* default value for broken headers */
  56.         s->h263_pred = 1;
  57.         s->has_b_frames = 1; //default, might be overriden in the vol header during header parsing
  58.         break;
  59.     case CODEC_ID_MSMPEG4V1:
  60.         s->h263_msmpeg4 = 1;
  61.         s->h263_pred = 1;
  62.         s->msmpeg4_version=1;
  63.         break;
  64.     case CODEC_ID_MSMPEG4V2:
  65.         s->h263_msmpeg4 = 1;
  66.         s->h263_pred = 1;
  67.         s->msmpeg4_version=2;
  68.         break;
  69.     case CODEC_ID_MSMPEG4V3:
  70.         s->h263_msmpeg4 = 1;
  71.         s->h263_pred = 1;
  72.         s->msmpeg4_version=3;
  73.         break;
  74.     case CODEC_ID_WMV1:
  75.         s->h263_msmpeg4 = 1;
  76.         s->h263_pred = 1;
  77.         s->msmpeg4_version=4;
  78.         break;
  79.     case CODEC_ID_WMV2:
  80.         s->h263_msmpeg4 = 1;
  81.         s->h263_pred = 1;
  82.         s->msmpeg4_version=5;
  83.         break;
  84.     case CODEC_ID_H263I:
  85.         s->h263_intel = 1;
  86.         break;
  87.     default:
  88.         return -1;
  89.     }
  90.     s->codec_id= avctx->codec->id;
  91.     avctx->mbskip_table= s->mbskip_table;
  92.     
  93.     /* for h263, we allocate the images after having read the header */
  94.     if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4)
  95.         if (MPV_common_init(s) < 0)
  96.             return -1;
  97.  
  98.     if (s->h263_msmpeg4)
  99.         ff_msmpeg4_decode_init(s);
  100.     else
  101.         h263_decode_init_vlc(s);
  102.     
  103.     return 0;
  104. }
  105.  
  106. static int h263_decode_end(AVCodecContext *avctx)
  107. {
  108.     MpegEncContext *s = avctx->priv_data;
  109.  
  110.     MPV_common_end(s);
  111.     return 0;
  112. }
  113.  
  114. static int h263_decode_frame(AVCodecContext *avctx, 
  115.                              void *data, int *data_size,
  116.                              UINT8 *buf, int buf_size)
  117. {
  118.     MpegEncContext *s = avctx->priv_data;
  119.     int ret;
  120.     AVPicture *pict = data; 
  121. #ifdef PRINT_FRAME_TIME
  122. uint64_t time= rdtsc();
  123. #endif
  124. #ifdef DEBUG
  125.     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
  126.     printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
  127. #endif
  128.  
  129.     s->hurry_up= avctx->hurry_up;
  130.     s->error_resilience= avctx->error_resilience;
  131.     s->workaround_bugs= avctx->workaround_bugs;
  132.     s->flags= avctx->flags;
  133.  
  134.     /* no supplementary picture */
  135.     if (buf_size == 0) {
  136.         *data_size = 0;
  137.         return 0;
  138.     }
  139.  
  140.     if(s->bitstream_buffer_size && buf_size<20){ //divx 5.01+ frame reorder
  141.         init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size);
  142.     }else
  143.         init_get_bits(&s->gb, buf, buf_size);
  144.     s->bitstream_buffer_size=0;
  145.  
  146.     /* let's go :-) */
  147.     if (s->h263_msmpeg4) {
  148.         ret = msmpeg4_decode_picture_header(s);
  149.     } else if (s->h263_pred) {
  150.         ret = mpeg4_decode_picture_header(s);
  151.         s->has_b_frames= !s->low_delay;
  152.     } else if (s->h263_intel) {
  153.         ret = intel_h263_decode_picture_header(s);
  154.     } else {
  155.         ret = h263_decode_picture_header(s);
  156.     }
  157.  
  158.         /* After H263 & mpeg4 header decode we have the height, width,*/
  159.         /* and other parameters. So then we could init the picture   */
  160.         /* FIXME: By the way H263 decoder is evolving it should have */
  161.         /* an H263EncContext                                         */
  162.     if (!s->context_initialized) {
  163.         avctx->width = s->width;
  164.         avctx->height = s->height;
  165.         avctx->aspect_ratio_info= s->aspect_ratio_info;
  166.         if (MPV_common_init(s) < 0)
  167.             return -1;
  168.     } else if (s->width != avctx->width || s->height != avctx->height) {
  169.         /* H.263 could change picture size any time */
  170.         MPV_common_end(s);
  171.         if (MPV_common_init(s) < 0)
  172.             return -1;
  173.     }
  174.  
  175.     if(ret==FRAME_SKIPED) return 0;
  176.     /* skip if the header was thrashed */
  177.     if (ret < 0){
  178.         fprintf(stderr, "header damaged\n");
  179.         return -1;
  180.     }
  181.     /* skip b frames if we dont have reference frames */
  182.     if(s->num_available_buffers<2 && s->pict_type==B_TYPE) return 0;
  183.     /* skip b frames if we are in a hurry */
  184.     if(s->hurry_up && s->pict_type==B_TYPE) return 0;
  185.     
  186.     if(s->next_p_frame_damaged){
  187.         if(s->pict_type==B_TYPE)
  188.             return 0;
  189.         else
  190.             s->next_p_frame_damaged=0;
  191.     }
  192.  
  193.     MPV_frame_start(s);
  194.  
  195. #ifdef DEBUG
  196.     printf("qscale=%d\n", s->qscale);
  197. #endif
  198.  
  199.     /* init resync/ error resilience specific variables */
  200.     s->next_resync_qscale= s->qscale;
  201.     s->next_resync_gb= s->gb;
  202.     if(s->resync_marker) s->mb_num_left= 0;
  203.     else                 s->mb_num_left= s->mb_num;
  204.  
  205.     /* decode each macroblock */
  206.     s->block_wrap[0]=
  207.     s->block_wrap[1]=
  208.     s->block_wrap[2]=
  209.     s->block_wrap[3]= s->mb_width*2 + 2;
  210.     s->block_wrap[4]=
  211.     s->block_wrap[5]= s->mb_width + 2;
  212.     for(s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
  213.         /* Check for GOB headers on H.263 */
  214.         /* FIXME: In the future H.263+ will have intra prediction */
  215.         /* and we are gonna need another way to detect MPEG4      */
  216.         if (s->mb_y && !s->h263_pred) {
  217.             s->first_slice_line = h263_decode_gob_header(s);
  218.         }
  219.         
  220.         if(s->msmpeg4_version==1){
  221.             s->last_dc[0]=
  222.             s->last_dc[1]=
  223.             s->last_dc[2]= 128;
  224.         }
  225.  
  226.         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
  227.         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
  228.  
  229.         s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1;
  230.         s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1);
  231.         s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1;
  232.         s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2);
  233.         s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
  234.         s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
  235.         for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
  236.             s->block_index[0]+=2;
  237.             s->block_index[1]+=2;
  238.             s->block_index[2]+=2;
  239.             s->block_index[3]+=2;
  240.             s->block_index[4]++;
  241.             s->block_index[5]++;
  242. #ifdef DEBUG
  243.             printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
  244. #endif
  245.  
  246.             if(s->resync_marker){
  247.                 if(s->mb_num_left<=0){
  248.                     /* except the first block */
  249.                     if(s->mb_x!=0 || s->mb_y!=0){
  250.                         /* did we miss the next resync marker without noticing an error yet */
  251.                         if(((get_bits_count(&s->gb)+8)&(~7)) != s->next_resync_pos && s->decoding_error==0){
  252.                             fprintf(stderr, "slice end missmatch x:%d y:%d %d %d\n", 
  253.                                     s->mb_x, s->mb_y, get_bits_count(&s->gb), s->next_resync_pos);
  254.                             ff_conceal_past_errors(s, 1);
  255.                         }
  256.                     }
  257.                     s->qscale= s->next_resync_qscale;
  258.                     s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
  259.                     s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
  260.  
  261.                     s->gb= s->next_resync_gb;
  262.                     s->resync_mb_x= s->mb_x; //we know that the marker is here cuz mb_num_left was the distance to it
  263.                     s->resync_mb_y= s->mb_y;
  264.                     s->first_slice_line=1;
  265.  
  266.                     if(s->codec_id==CODEC_ID_MPEG4){
  267.                         ff_mpeg4_clean_buffers(s);
  268.                         ff_mpeg4_resync(s);
  269.                     }
  270.                 }
  271.  
  272.                 if(   s->resync_mb_x==s->mb_x 
  273.                    && s->resync_mb_y==s->mb_y && s->decoding_error!=0){
  274.                     fprintf(stderr, "resynced at %d %d\n", s->mb_x, s->mb_y);
  275.                     s->decoding_error= 0;
  276.                 }
  277.             }
  278.  
  279.             //fprintf(stderr,"\nFrame: %d\tMB: %d",avctx->frame_number, (s->mb_y * s->mb_width) + s->mb_x);
  280.             /* DCT & quantize */
  281.             if(s->decoding_error!=DECODING_DESYNC){
  282.                 int last_error= s->decoding_error;
  283.                 clear_blocks(s->block[0]);
  284.             
  285.                 s->mv_dir = MV_DIR_FORWARD;
  286.                 s->mv_type = MV_TYPE_16X16;
  287.                 if (s->h263_msmpeg4) {
  288.                     if (msmpeg4_decode_mb(s, s->block) < 0) {
  289. //                        fprintf(stderr,"Error at MB: %d\n", (s->mb_y * s->mb_width) + s->mb_x);
  290.                         s->decoding_error=DECODING_DESYNC;
  291.                     }
  292.                 } else {
  293.                     if (h263_decode_mb(s, s->block) < 0) {
  294. //                        fprintf(stderr,"Error at MB: %d\n", (s->mb_y * s->mb_width) + s->mb_x);
  295.                         s->decoding_error=DECODING_DESYNC;
  296.                     }
  297.                 }
  298.  
  299.                 if(s->decoding_error!=last_error){
  300.                     ff_conceal_past_errors(s, 0);
  301.                 }
  302.             }
  303.  
  304.             /* conceal errors */
  305.             if(    s->decoding_error==DECODING_DESYNC
  306.                || (s->decoding_error==DECODING_ACDC_LOST && s->mb_intra)){
  307.                 s->mv_dir = MV_DIR_FORWARD;
  308.                 s->mv_type = MV_TYPE_16X16;
  309.                 s->mb_skiped=0;
  310.                 s->mb_intra=0;
  311.                 s->mv[0][0][0]=0; //FIXME this is not optimal 
  312.                 s->mv[0][0][1]=0;
  313.                 clear_blocks(s->block[0]);
  314.             }else if(s->decoding_error && !s->mb_intra){
  315.                 clear_blocks(s->block[0]);
  316.             }
  317.             //FIXME remove AC for intra
  318.                         
  319.             MPV_decode_mb(s, s->block);
  320.  
  321.             s->mb_num_left--;            
  322.         }
  323.         if (    avctx->draw_horiz_band 
  324.             && (s->num_available_buffers>=1 || (!s->has_b_frames)) ) {
  325.             UINT8 *src_ptr[3];
  326.             int y, h, offset;
  327.             y = s->mb_y * 16;
  328.             h = s->height - y;
  329.             if (h > 16)
  330.                 h = 16;
  331.             offset = y * s->linesize;
  332.             if(s->pict_type==B_TYPE || (!s->has_b_frames)){
  333.                 src_ptr[0] = s->current_picture[0] + offset;
  334.                 src_ptr[1] = s->current_picture[1] + (offset >> 2);
  335.                 src_ptr[2] = s->current_picture[2] + (offset >> 2);
  336.             } else {
  337.                 src_ptr[0] = s->last_picture[0] + offset;
  338.                 src_ptr[1] = s->last_picture[1] + (offset >> 2);
  339.                 src_ptr[2] = s->last_picture[2] + (offset >> 2);
  340.             }
  341.             avctx->draw_horiz_band(avctx, src_ptr, s->linesize,
  342.                                    y, s->width, h);
  343.         }
  344.     }
  345.     
  346.     if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)
  347.         if(msmpeg4_decode_ext_header(s, buf_size) < 0) return -1;
  348.     
  349.     /* divx 5.01+ bistream reorder stuff */
  350.     if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0){
  351.         int current_pos= get_bits_count(&s->gb)>>3;
  352.  
  353.         if(   buf_size - current_pos > 5 
  354.            && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){
  355.             int i;
  356.             int startcode_found=0;
  357.             for(i=current_pos; i<buf_size; i++){
  358.                 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
  359.                     startcode_found=1;
  360.                     break;
  361.                 }
  362.             }
  363.             if(startcode_found){
  364.                 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
  365.                 s->bitstream_buffer_size= buf_size - current_pos;
  366.             }
  367.         }
  368.     }
  369.  
  370.     if(s->bitstream_buffer_size==0 && s->error_resilience>0){
  371.         int left= s->gb.size*8 - get_bits_count(&s->gb);
  372.         int max_extra=8;
  373.         
  374.         if(s->codec_id==CODEC_ID_MPEG4) max_extra+=32;
  375.  
  376.         if(left>max_extra){
  377.             fprintf(stderr, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24));
  378.             if(s->decoding_error==0)
  379.                 ff_conceal_past_errors(s, 1);
  380.         }
  381.         if(left<0){
  382.             fprintf(stderr, "overreading %d bits\n", -left);
  383.             if(s->decoding_error==0)
  384.                 ff_conceal_past_errors(s, 1);
  385.         }
  386.     }
  387.   
  388.     MPV_frame_end(s);
  389. #if 0 //dirty show MVs, we should export the MV tables and write a filter to show them
  390. {
  391.   int mb_y;
  392.   s->has_b_frames=1;
  393.   for(mb_y=0; mb_y<s->mb_height; mb_y++){
  394.     int mb_x;
  395.     int y= mb_y*16 + 8;
  396.     for(mb_x=0; mb_x<s->mb_width; mb_x++){
  397.       int x= mb_x*16 + 8;
  398.       uint8_t *ptr= s->last_picture[0];
  399.       int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
  400.       int mx= (s->motion_val[xy][0]>>1) + x;
  401.       int my= (s->motion_val[xy][1]>>1) + y;
  402.       int i;
  403.       int max;
  404.  
  405.       if(mx<0) mx=0;
  406.       if(my<0) my=0;
  407.       if(mx>=s->width)  mx= s->width -1;
  408.       if(my>=s->height) my= s->height-1;
  409.       max= ABS(mx-x);
  410.       if(ABS(my-y) > max) max= ABS(my-y);
  411.       /* the ugliest linedrawing routine ... */
  412.       for(i=0; i<max; i++){
  413.         int x1= x + (mx-x)*i/max;
  414.         int y1= y + (my-y)*i/max;
  415.         ptr[y1*s->linesize + x1]+=100;
  416.       }
  417.       ptr[y*s->linesize + x]+=100;
  418.       s->mbskip_table[mb_x + mb_y*s->mb_width]=0;
  419.     }
  420.   }
  421.  
  422. }
  423. #endif    
  424.     if(s->pict_type==B_TYPE || (!s->has_b_frames)){
  425.         pict->data[0] = s->current_picture[0];
  426.         pict->data[1] = s->current_picture[1];
  427.         pict->data[2] = s->current_picture[2];
  428.     } else {
  429.         pict->data[0] = s->last_picture[0];
  430.         pict->data[1] = s->last_picture[1];
  431.         pict->data[2] = s->last_picture[2];
  432.     }
  433.     pict->linesize[0] = s->linesize;
  434.     pict->linesize[1] = s->linesize / 2;
  435.     pict->linesize[2] = s->linesize / 2;
  436.  
  437.     avctx->quality = s->qscale;
  438.  
  439.     /* Return the Picture timestamp as the frame number */
  440.     /* we substract 1 because it is added on utils.c    */
  441.     avctx->frame_number = s->picture_number - 1;
  442.  
  443.     /* dont output the last pic after seeking 
  444.        note we allready added +1 for the current pix in MPV_frame_end(s) */
  445.     if(s->num_available_buffers>=2 || (!s->has_b_frames))
  446.         *data_size = sizeof(AVPicture);
  447. #ifdef PRINT_FRAME_TIME
  448. printf("%Ld\n", rdtsc()-time);
  449. #endif
  450.     return buf_size;
  451. }
  452.  
  453. AVCodec mpeg4_decoder = {
  454.     "mpeg4",
  455.     CODEC_TYPE_VIDEO,
  456.     CODEC_ID_MPEG4,
  457.     sizeof(MpegEncContext),
  458.     h263_decode_init,
  459.     NULL,
  460.     h263_decode_end,
  461.     h263_decode_frame,
  462.     CODEC_CAP_DRAW_HORIZ_BAND,
  463. };
  464.  
  465. AVCodec h263_decoder = {
  466.     "h263",
  467.     CODEC_TYPE_VIDEO,
  468.     CODEC_ID_H263,
  469.     sizeof(MpegEncContext),
  470.     h263_decode_init,
  471.     NULL,
  472.     h263_decode_end,
  473.     h263_decode_frame,
  474.     CODEC_CAP_DRAW_HORIZ_BAND,
  475. };
  476.  
  477. AVCodec msmpeg4v1_decoder = {
  478.     "msmpeg4v1",
  479.     CODEC_TYPE_VIDEO,
  480.     CODEC_ID_MSMPEG4V1,
  481.     sizeof(MpegEncContext),
  482.     h263_decode_init,
  483.     NULL,
  484.     h263_decode_end,
  485.     h263_decode_frame,
  486.     CODEC_CAP_DRAW_HORIZ_BAND,
  487. };
  488.  
  489. AVCodec msmpeg4v2_decoder = {
  490.     "msmpeg4v2",
  491.     CODEC_TYPE_VIDEO,
  492.     CODEC_ID_MSMPEG4V2,
  493.     sizeof(MpegEncContext),
  494.     h263_decode_init,
  495.     NULL,
  496.     h263_decode_end,
  497.     h263_decode_frame,
  498.     CODEC_CAP_DRAW_HORIZ_BAND,
  499. };
  500.  
  501. AVCodec msmpeg4v3_decoder = {
  502.     "msmpeg4",
  503.     CODEC_TYPE_VIDEO,
  504.     CODEC_ID_MSMPEG4V3,
  505.     sizeof(MpegEncContext),
  506.     h263_decode_init,
  507.     NULL,
  508.     h263_decode_end,
  509.     h263_decode_frame,
  510.     CODEC_CAP_DRAW_HORIZ_BAND,
  511. };
  512.  
  513. AVCodec wmv1_decoder = {
  514.     "wmv1",
  515.     CODEC_TYPE_VIDEO,
  516.     CODEC_ID_WMV1,
  517.     sizeof(MpegEncContext),
  518.     h263_decode_init,
  519.     NULL,
  520.     h263_decode_end,
  521.     h263_decode_frame,
  522.     CODEC_CAP_DRAW_HORIZ_BAND,
  523. };
  524.  
  525. AVCodec wmv2_decoder = {
  526.     "wmv2",
  527.     CODEC_TYPE_VIDEO,
  528.     CODEC_ID_WMV2,
  529.     sizeof(MpegEncContext),
  530.     h263_decode_init,
  531.     NULL,
  532.     h263_decode_end,
  533.     h263_decode_frame,
  534.     CODEC_CAP_DRAW_HORIZ_BAND,
  535. };
  536.  
  537. AVCodec h263i_decoder = {
  538.     "h263i",
  539.     CODEC_TYPE_VIDEO,
  540.     CODEC_ID_H263I,
  541.     sizeof(MpegEncContext),
  542.     h263_decode_init,
  543.     NULL,
  544.     h263_decode_end,
  545.     h263_decode_frame,
  546.     CODEC_CAP_DRAW_HORIZ_BAND,
  547. };
  548.  
  549.