home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wvis0626.zip / warpvision_20020626.zip / libavcodec / h263.c < prev    next >
C/C++ Source or Header  |  2002-06-24  |  137KB  |  3,820 lines
  1. /*
  2.  * H263/MPEG4 backend for ffmpeg encoder and decoder
  3.  * Copyright (c) 2000,2001 Fabrice Bellard.
  4.  * H263+ support.
  5.  * Copyright (c) 2001 Juan J. Sierralta P.
  6.  *
  7.  * This library is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2 of the License, or (at your option) any later version.
  11.  *
  12.  * This library is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with this library; if not, write to the Free Software
  19.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20.  *
  21.  * ac prediction encoding & b-frame support by Michael Niedermayer <michaelni@gmx.at>
  22.  */
  23.  
  24. //#define DEBUG
  25. #include "common.h"
  26. #include "dsputil.h"
  27. #include "avcodec.h"
  28. #include "mpegvideo.h"
  29. #include "h263data.h"
  30. #include "mpeg4data.h"
  31.  
  32. //rounded divison & shift
  33. #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
  34.  
  35. #define PRINT_MB_TYPE(a) ;
  36. //#define PRINT_MB_TYPE(a) printf(a);
  37.  
  38. static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
  39.                   int n);
  40. static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
  41. static void h263p_encode_umotion(MpegEncContext * s, int val);
  42. static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
  43.                    int n, int dc, UINT8 *scan_table, 
  44.                                PutBitContext *dc_pb, PutBitContext *ac_pb);
  45. static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
  46. static int h263p_decode_umotion(MpegEncContext * s, int pred);
  47. static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
  48.                              int n, int coded);
  49. static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
  50. static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  51.                               int n, int coded);
  52. static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
  53. static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
  54.                               int dir);
  55. static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
  56.  
  57. extern UINT32 inverse[256];
  58.  
  59. static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  60. static UINT8 fcode_tab[MAX_MV*2+1];
  61. static UINT8 umv_fcode_tab[MAX_MV*2+1];
  62.  
  63. static UINT16 uni_DCtab_lum  [512][2];
  64. static UINT16 uni_DCtab_chrom[512][2];
  65.  
  66. int h263_get_picture_format(int width, int height)
  67. {
  68.     int format;
  69.  
  70.     if (width == 128 && height == 96)
  71.         format = 1;
  72.     else if (width == 176 && height == 144)
  73.         format = 2;
  74.     else if (width == 352 && height == 288)
  75.         format = 3;
  76.     else if (width == 704 && height == 576)
  77.         format = 4;
  78.     else if (width == 1408 && height == 1152)
  79.         format = 5;
  80.     else
  81.         format = 7;
  82.     return format;
  83. }
  84.  
  85. void h263_encode_picture_header(MpegEncContext * s, int picture_number)
  86. {
  87.     int format;
  88.  
  89.     align_put_bits(&s->pb);
  90.  
  91.     /* Update the pointer to last GOB */
  92.     s->ptr_lastgob = pbBufPtr(&s->pb);
  93.     s->gob_number = 0;
  94.  
  95.     put_bits(&s->pb, 22, 0x20); /* PSC */
  96.     put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
  97.                          s->frame_rate) & 0xff);
  98.  
  99.     put_bits(&s->pb, 1, 1);    /* marker */
  100.     put_bits(&s->pb, 1, 0);    /* h263 id */
  101.     put_bits(&s->pb, 1, 0);    /* split screen off */
  102.     put_bits(&s->pb, 1, 0);    /* camera  off */
  103.     put_bits(&s->pb, 1, 0);    /* freeze picture release off */
  104.     
  105.     format = h263_get_picture_format(s->width, s->height);
  106.     if (!s->h263_plus) {
  107.         /* H.263v1 */
  108.         put_bits(&s->pb, 3, format);
  109.         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
  110.         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
  111.         of H.263v1 UMV implies to check the predicted MV after
  112.         calculation of the current MB to see if we're on the limits */
  113.         put_bits(&s->pb, 1, 0);    /* unrestricted motion vector: off */
  114.         put_bits(&s->pb, 1, 0);    /* SAC: off */
  115.         put_bits(&s->pb, 1, 0);    /* advanced prediction mode: off */
  116.         put_bits(&s->pb, 1, 0);    /* not PB frame */
  117.         put_bits(&s->pb, 5, s->qscale);
  118.         put_bits(&s->pb, 1, 0);    /* Continuous Presence Multipoint mode: off */
  119.     } else {
  120.         /* H.263v2 */
  121.         /* H.263 Plus PTYPE */
  122.         put_bits(&s->pb, 3, 7);
  123.         put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
  124.         if (format == 7)
  125.             put_bits(&s->pb,3,6); /* Custom Source Format */
  126.         else
  127.             put_bits(&s->pb, 3, format);
  128.             
  129.         put_bits(&s->pb,1,0); /* Custom PCF: off */
  130.         s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
  131.         put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
  132.         put_bits(&s->pb,1,0); /* SAC: off */
  133.         put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
  134.         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
  135.         put_bits(&s->pb,1,0); /* Deblocking Filter: off */
  136.         put_bits(&s->pb,1,0); /* Slice Structured: off */
  137.         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
  138.         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
  139.         put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
  140.         put_bits(&s->pb,1,0); /* Modified Quantization: off */
  141.         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
  142.         put_bits(&s->pb,3,0); /* Reserved */
  143.         
  144.         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
  145.         
  146.         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
  147.         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
  148.         if (s->pict_type == I_TYPE)
  149.             s->no_rounding = 0;
  150.         else
  151.             s->no_rounding ^= 1;
  152.         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
  153.         put_bits(&s->pb,2,0); /* Reserved */
  154.         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
  155.         
  156.         /* This should be here if PLUSPTYPE */
  157.         put_bits(&s->pb, 1, 0);    /* Continuous Presence Multipoint mode: off */
  158.         
  159.         if (format == 7) {
  160.             /* Custom Picture Format (CPFMT) */
  161.         
  162.         if (s->aspect_ratio_info)
  163.             put_bits(&s->pb,4,s->aspect_ratio_info);
  164.         else
  165.             put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
  166.             put_bits(&s->pb,9,(s->width >> 2) - 1);
  167.             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
  168.             put_bits(&s->pb,9,(s->height >> 2));
  169.         }
  170.         
  171.         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
  172.         if (s->umvplus)
  173.             put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
  174.         put_bits(&s->pb, 5, s->qscale);
  175.     }
  176.  
  177.     put_bits(&s->pb, 1, 0);    /* no PEI */
  178.  
  179.     if(s->h263_aic){
  180.          s->y_dc_scale_table= 
  181.          s->c_dc_scale_table= h263_aic_dc_scale_table;
  182.     }else{
  183.         s->y_dc_scale_table=
  184.         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
  185.     }
  186. }
  187.  
  188. int h263_encode_gob_header(MpegEncContext * s, int mb_line)
  189. {
  190.     int pdif=0;
  191.     
  192.     /* Check to see if we need to put a new GBSC */
  193.     /* for RTP packetization                    */
  194.     if (s->rtp_mode) {
  195.         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
  196.         if (pdif >= s->rtp_payload_size) {
  197.             /* Bad luck, packet must be cut before */
  198.             align_put_bits(&s->pb);
  199.             flush_put_bits(&s->pb);
  200.             /* Call the RTP callback to send the last GOB */
  201.             if (s->rtp_callback) {
  202.                 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
  203.                 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
  204.             }
  205.             s->ptr_lastgob = pbBufPtr(&s->pb);
  206.             put_bits(&s->pb, 17, 1); /* GBSC */
  207.             s->gob_number = mb_line / s->gob_index;
  208.             put_bits(&s->pb, 5, s->gob_number); /* GN */
  209.             put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
  210.             put_bits(&s->pb, 5, s->qscale); /* GQUANT */
  211.             //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
  212.             return pdif;
  213.        } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
  214.            /* Cut the packet before we can't */
  215.            align_put_bits(&s->pb);
  216.            flush_put_bits(&s->pb);
  217.            /* Call the RTP callback to send the last GOB */
  218.            if (s->rtp_callback) {
  219.                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
  220.                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
  221.            }
  222.            s->ptr_lastgob = pbBufPtr(&s->pb);
  223.            put_bits(&s->pb, 17, 1); /* GBSC */
  224.            s->gob_number = mb_line / s->gob_index;
  225.            put_bits(&s->pb, 5, s->gob_number); /* GN */
  226.            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
  227.            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
  228.            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
  229.            return pdif;
  230.        }
  231.    }
  232.    return 0;
  233. }
  234.  
  235. static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
  236. {
  237.     int score0=0, score1=0;
  238.     int i, n;
  239.  
  240.     for(n=0; n<6; n++){
  241.         INT16 *ac_val, *ac_val1;
  242.  
  243.         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
  244.         ac_val1= ac_val;
  245.         if(dir[n]){
  246.             ac_val-= s->block_wrap[n]*16;
  247.             for(i=1; i<8; i++){
  248.                 const int level= block[n][block_permute_op(i   )];
  249.                 score0+= ABS(level);
  250.                 score1+= ABS(level - ac_val[i+8]);
  251.                 ac_val1[i  ]=    block[n][block_permute_op(i<<3)];
  252.                 ac_val1[i+8]= level;
  253.             }
  254.         }else{
  255.             ac_val-= 16;
  256.             for(i=1; i<8; i++){
  257.                 const int level= block[n][block_permute_op(i<<3)];
  258.                 score0+= ABS(level);
  259.                 score1+= ABS(level - ac_val[i]);
  260.                 ac_val1[i  ]= level;
  261.                 ac_val1[i+8]=    block[n][block_permute_op(i   )];
  262.             }
  263.         }
  264.     }
  265.  
  266.     return score0 > score1 ? 1 : 0;    
  267. }
  268.  
  269. void mpeg4_encode_mb(MpegEncContext * s,
  270.             DCTELEM block[6][64],
  271.             int motion_x, int motion_y)
  272. {
  273.     int cbpc, cbpy, i, pred_x, pred_y;
  274.     int bits;
  275.     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
  276.     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
  277.     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
  278.     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
  279.     
  280.     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
  281.     if (!s->mb_intra) {
  282.         /* compute cbp */
  283.         int cbp = 0;
  284.         for (i = 0; i < 6; i++) {
  285.             if (s->block_last_index[i] >= 0)
  286.                 cbp |= 1 << (5 - i);
  287.         }
  288.  
  289.         if(s->pict_type==B_TYPE){
  290.             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
  291.             int mb_type=  mb_type_table[s->mv_dir];
  292.             
  293.             if(s->mb_x==0){
  294.                 s->last_mv[0][0][0]= 
  295.                 s->last_mv[0][0][1]= 
  296.                 s->last_mv[1][0][0]= 
  297.                 s->last_mv[1][0][1]= 0;
  298.             }
  299.  
  300.             /* nothing to do if this MB was skiped in the next P Frame */
  301.             if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){
  302.                 s->skip_count++;
  303.                 s->mv[0][0][0]= 
  304.                 s->mv[0][0][1]= 
  305.                 s->mv[1][0][0]= 
  306.                 s->mv[1][0][1]= 0;
  307.                 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
  308.                 return;
  309.             }
  310.  
  311.             if ((cbp | motion_x | motion_y | mb_type) ==0) {
  312.                 /* direct MB with MV={0,0} */
  313.                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
  314.  
  315.                 if(interleaved_stats){
  316.                     s->misc_bits++;
  317.                     s->last_bits++;
  318.                 }
  319.                 s->skip_count++;
  320.                 return;
  321.             }
  322.             put_bits(&s->pb, 1, 0);    /* mb coded modb1=0 */
  323.             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
  324.             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
  325.             if(cbp) put_bits(&s->pb, 6, cbp);
  326.             
  327.             if(cbp && mb_type)
  328.                 put_bits(&s->pb, 1, 0); /* no q-scale change */
  329.  
  330.             if(interleaved_stats){
  331.                 bits= get_bit_count(&s->pb);
  332.                 s->misc_bits+= bits - s->last_bits;
  333.                 s->last_bits=bits;
  334.             }
  335.  
  336.             switch(mb_type)
  337.             {
  338.             case 0: /* direct */
  339.                 h263_encode_motion(s, motion_x, 1);
  340.                 h263_encode_motion(s, motion_y, 1);                
  341.                 break;
  342.             case 1: /* bidir */
  343.                 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
  344.                 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
  345.                 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
  346.                 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
  347.                 s->last_mv[0][0][0]= s->mv[0][0][0];
  348.                 s->last_mv[0][0][1]= s->mv[0][0][1];
  349.                 s->last_mv[1][0][0]= s->mv[1][0][0];
  350.                 s->last_mv[1][0][1]= s->mv[1][0][1];
  351.                 break;
  352.             case 2: /* backward */
  353.                 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
  354.                 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
  355.                 s->last_mv[1][0][0]= motion_x;
  356.                 s->last_mv[1][0][1]= motion_y;
  357.                 break;
  358.             case 3: /* forward */
  359.                 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
  360.                 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
  361.                 s->last_mv[0][0][0]= motion_x;
  362.                 s->last_mv[0][0][1]= motion_y;
  363.                 break;
  364.             default:
  365.                 printf("unknown mb type\n");
  366.                 return;
  367.             }
  368.  
  369.             if(interleaved_stats){
  370.                 bits= get_bit_count(&s->pb);
  371.                 s->mv_bits+= bits - s->last_bits;
  372.                 s->last_bits=bits;
  373.             }
  374.  
  375.             /* encode each block */
  376.             for (i = 0; i < 6; i++) {
  377.                 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s->pb);
  378.             }
  379.  
  380.             if(interleaved_stats){
  381.                 bits= get_bit_count(&s->pb);
  382.                 s->p_tex_bits+= bits - s->last_bits;
  383.                 s->last_bits=bits;
  384.             }
  385.         }else{ /* s->pict_type==B_TYPE */
  386.             if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
  387.                 /* check if the B frames can skip it too, as we must skip it if we skip here 
  388.                    why didnt they just compress the skip-mb bits instead of reusing them ?! */
  389.                 if(s->max_b_frames>0){
  390.                     int i;
  391.                     int x,y, offset;
  392.                     uint8_t *p_pic;
  393.  
  394.                     x= s->mb_x*16;
  395.                     y= s->mb_y*16;
  396.                     if(x+16 > s->width)  x= s->width-16;
  397.                     if(y+16 > s->height) y= s->height-16;
  398.  
  399.                     offset= x + y*s->linesize;
  400.                     p_pic= s->new_picture[0] + offset;
  401.                     
  402.                     s->mb_skiped=1;
  403.                     for(i=0; i<s->max_b_frames; i++){
  404.                         uint8_t *b_pic;
  405.                         int diff;
  406.  
  407.                         if(s->coded_order[i+1].pict_type!=B_TYPE) break;
  408.  
  409.                         b_pic= s->coded_order[i+1].picture[0] + offset;
  410.                         diff= pix_abs16x16(p_pic, b_pic, s->linesize);
  411.                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
  412.                             s->mb_skiped=0;
  413.                             break;
  414.                         }
  415.                     }
  416.                 }else
  417.                     s->mb_skiped=1; 
  418.  
  419.                 if(s->mb_skiped==1){
  420.                     /* skip macroblock */
  421.                     put_bits(&s->pb, 1, 1);
  422.  
  423.                     if(interleaved_stats){
  424.                         s->misc_bits++;
  425.                         s->last_bits++;
  426.                     }
  427.                     s->skip_count++;
  428.                     return;
  429.                 }
  430.             }
  431.  
  432.             put_bits(&s->pb, 1, 0);    /* mb coded */
  433.             if(s->mv_type==MV_TYPE_16X16){
  434.                 cbpc = cbp & 3;
  435.                 put_bits(&s->pb,
  436.                         inter_MCBPC_bits[cbpc],
  437.                         inter_MCBPC_code[cbpc]);
  438.                 cbpy = cbp >> 2;
  439.                 cbpy ^= 0xf;
  440.                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
  441.                     
  442.                 if(interleaved_stats){
  443.                     bits= get_bit_count(&s->pb);
  444.                     s->misc_bits+= bits - s->last_bits;
  445.                     s->last_bits=bits;
  446.                 }
  447.  
  448.                 /* motion vectors: 16x16 mode */
  449.                 h263_pred_motion(s, 0, &pred_x, &pred_y);
  450.             
  451.                 h263_encode_motion(s, motion_x - pred_x, s->f_code);
  452.                 h263_encode_motion(s, motion_y - pred_y, s->f_code);
  453.             }else{
  454.                 cbpc = (cbp & 3)+16;
  455.                 put_bits(&s->pb,
  456.                         inter_MCBPC_bits[cbpc],
  457.                         inter_MCBPC_code[cbpc]);
  458.                 cbpy = cbp >> 2;
  459.                 cbpy ^= 0xf;
  460.                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
  461.  
  462.                 if(interleaved_stats){
  463.                     bits= get_bit_count(&s->pb);
  464.                     s->misc_bits+= bits - s->last_bits;
  465.                     s->last_bits=bits;
  466.                 }
  467.  
  468.                 for(i=0; i<4; i++){
  469.                     /* motion vectors: 8x8 mode*/
  470.                     h263_pred_motion(s, i, &pred_x, &pred_y);
  471.  
  472.                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
  473.                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
  474.                 }
  475.             }
  476.  
  477.             if(interleaved_stats){ 
  478.                 bits= get_bit_count(&s->pb);
  479.                 s->mv_bits+= bits - s->last_bits;
  480.                 s->last_bits=bits;
  481.             }
  482.  
  483.             /* encode each block */
  484.             for (i = 0; i < 6; i++) {
  485.                 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb);
  486.             }
  487.  
  488.             if(interleaved_stats){
  489.                 bits= get_bit_count(&s->pb);
  490.                 s->p_tex_bits+= bits - s->last_bits;
  491.                 s->last_bits=bits;
  492.             }
  493.             s->p_count++;
  494.         }
  495.     } else {
  496.         int cbp;
  497.         int dc_diff[6];   //dc values with the dc prediction subtracted 
  498.         int dir[6];  //prediction direction
  499.         int zigzag_last_index[6];
  500.         UINT8 *scan_table[6];
  501.  
  502.         for(i=0; i<6; i++){
  503.             const int level= block[i][0];
  504.             UINT16 *dc_ptr;
  505.  
  506.             dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
  507.             if (i < 4) {
  508.                 *dc_ptr = level * s->y_dc_scale;
  509.             } else {
  510.                 *dc_ptr = level * s->c_dc_scale;
  511.             }
  512.         }
  513.  
  514.         s->ac_pred= decide_ac_pred(s, block, dir);
  515.  
  516.         if(s->ac_pred){
  517.             for(i=0; i<6; i++){
  518.                 UINT8 *st;
  519.                 int last_index;
  520.  
  521.                 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
  522.                 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
  523.                 else           st = ff_alternate_horizontal_scan; /* top */
  524.  
  525.                 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
  526.                     if(block[i][st[last_index]]) break;
  527.                 zigzag_last_index[i]= s->block_last_index[i];
  528.                 s->block_last_index[i]= last_index;
  529.                 scan_table[i]= st;
  530.             }
  531.         }else{
  532.             for(i=0; i<6; i++)
  533.                 scan_table[i]= zigzag_direct;
  534.         }
  535.  
  536.         /* compute cbp */
  537.         cbp = 0;
  538.         for (i = 0; i < 6; i++) {
  539.             if (s->block_last_index[i] >= 1)
  540.                 cbp |= 1 << (5 - i);
  541.         }
  542.  
  543.         cbpc = cbp & 3;
  544.         if (s->pict_type == I_TYPE) {
  545.             put_bits(&s->pb,
  546.                 intra_MCBPC_bits[cbpc],
  547.                 intra_MCBPC_code[cbpc]);
  548.         } else {
  549.             put_bits(&s->pb, 1, 0);    /* mb coded */
  550.             put_bits(&s->pb,
  551.                 inter_MCBPC_bits[cbpc + 4],
  552.                 inter_MCBPC_code[cbpc + 4]);
  553.         }
  554.         put_bits(pb2, 1, s->ac_pred);
  555.         cbpy = cbp >> 2;
  556.         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
  557.  
  558.         if(interleaved_stats){
  559.             bits= get_bit_count(&s->pb);
  560.             s->misc_bits+= bits - s->last_bits;
  561.             s->last_bits=bits;
  562.         }
  563.  
  564.         /* encode each block */
  565.         for (i = 0; i < 6; i++) {
  566.             mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
  567.         }
  568.  
  569.         if(interleaved_stats){
  570.             bits= get_bit_count(&s->pb);
  571.             s->i_tex_bits+= bits - s->last_bits;
  572.             s->last_bits=bits;
  573.         }
  574.         s->i_count++;
  575.  
  576.         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
  577.         if(s->ac_pred){
  578.             for(i=0; i<6; i++){
  579.                 int j;    
  580.                 INT16 *ac_val;
  581.  
  582.                 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
  583.  
  584.                 if(dir[i]){
  585.                     for(j=1; j<8; j++) 
  586.                         block[i][block_permute_op(j   )]= ac_val[j+8];
  587.                 }else{
  588.                     for(j=1; j<8; j++) 
  589.                         block[i][block_permute_op(j<<3)]= ac_val[j  ];
  590.                 }
  591.                 s->block_last_index[i]= zigzag_last_index[i];
  592.             }
  593.         }
  594.     }
  595. }
  596.  
  597. void h263_encode_mb(MpegEncContext * s,
  598.             DCTELEM block[6][64],
  599.             int motion_x, int motion_y)
  600. {
  601.     int cbpc, cbpy, i, cbp, pred_x, pred_y;
  602.     INT16 pred_dc;
  603.     INT16 rec_intradc[6];
  604.     UINT16 *dc_ptr[6];
  605.            
  606.     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
  607.     if (!s->mb_intra) {
  608.         /* compute cbp */
  609.         cbp = 0;
  610.         for (i = 0; i < 6; i++) {
  611.             if (s->block_last_index[i] >= 0)
  612.                 cbp |= 1 << (5 - i);
  613.         }
  614.         if ((cbp | motion_x | motion_y) == 0) {
  615.             /* skip macroblock */
  616.             put_bits(&s->pb, 1, 1);
  617.             return;
  618.         }
  619.         put_bits(&s->pb, 1, 0);    /* mb coded */
  620.         cbpc = cbp & 3;
  621.         put_bits(&s->pb,
  622.             inter_MCBPC_bits[cbpc],
  623.             inter_MCBPC_code[cbpc]);
  624.         cbpy = cbp >> 2;
  625.         cbpy ^= 0xf;
  626.         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
  627.  
  628.         /* motion vectors: 16x16 mode only now */
  629.         h263_pred_motion(s, 0, &pred_x, &pred_y);
  630.       
  631.         if (!s->umvplus) {  
  632.             h263_encode_motion(s, motion_x - pred_x, s->f_code);
  633.             h263_encode_motion(s, motion_y - pred_y, s->f_code);
  634.         }
  635.         else {
  636.             h263p_encode_umotion(s, motion_x - pred_x);
  637.             h263p_encode_umotion(s, motion_y - pred_y);
  638.             if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
  639.                 /* To prevent Start Code emulation */
  640.                 put_bits(&s->pb,1,1);
  641.         }
  642.     } else {
  643.         int li = s->h263_aic ? 0 : 1;
  644.         
  645.         cbp = 0;
  646.         for(i=0; i<6; i++) {
  647.             /* Predict DC */
  648.             if (s->h263_aic && s->mb_intra) {
  649.                 INT16 level = block[i][0];
  650.             
  651.                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
  652.                 level -= pred_dc;
  653.                 /* Quant */
  654.                 if (level < 0)
  655.                     level = (level + (s->qscale >> 1))/(s->y_dc_scale);
  656.                 else
  657.                     level = (level - (s->qscale >> 1))/(s->y_dc_scale);
  658.                     
  659.                 /* AIC can change CBP */
  660.                 if (level == 0 && s->block_last_index[i] == 0)
  661.                     s->block_last_index[i] = -1;
  662.                 else if (level < -127)
  663.                     level = -127;
  664.                 else if (level > 127)
  665.                     level = 127;
  666.                 
  667.                 block[i][0] = level;
  668.                 /* Reconstruction */ 
  669.                 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
  670.                 /* Oddify */
  671.                 rec_intradc[i] |= 1;
  672.                 //if ((rec_intradc[i] % 2) == 0)
  673.                 //    rec_intradc[i]++;
  674.                 /* Clipping */
  675.                 if (rec_intradc[i] < 0)
  676.                     rec_intradc[i] = 0;
  677.                 else if (rec_intradc[i] > 2047)
  678.                     rec_intradc[i] = 2047;
  679.                                 
  680.                 /* Update AC/DC tables */
  681.                 *dc_ptr[i] = rec_intradc[i];
  682.             }
  683.             /* compute cbp */
  684.             if (s->block_last_index[i] >= li)
  685.                 cbp |= 1 << (5 - i);
  686.         }
  687.  
  688.         cbpc = cbp & 3;
  689.         if (s->pict_type == I_TYPE) {
  690.             put_bits(&s->pb,
  691.                 intra_MCBPC_bits[cbpc],
  692.                 intra_MCBPC_code[cbpc]);
  693.         } else {
  694.             put_bits(&s->pb, 1, 0);    /* mb coded */
  695.             put_bits(&s->pb,
  696.                 inter_MCBPC_bits[cbpc + 4],
  697.                 inter_MCBPC_code[cbpc + 4]);
  698.         }
  699.         if (s->h263_aic) {
  700.             /* XXX: currently, we do not try to use ac prediction */
  701.             put_bits(&s->pb, 1, 0);    /* no AC prediction */
  702.         }
  703.         cbpy = cbp >> 2;
  704.         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
  705.     }
  706.  
  707.     for(i=0; i<6; i++) {
  708.         /* encode each block */
  709.         h263_encode_block(s, block[i], i);
  710.     
  711.         /* Update INTRADC for decoding */
  712.         if (s->h263_aic && s->mb_intra) {
  713.             block[i][0] = rec_intradc[i];
  714.             
  715.         }
  716.     }
  717. }
  718.  
  719. static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
  720. {
  721.     int x, y, wrap, a, c, pred_dc, scale;
  722.     INT16 *dc_val, *ac_val;
  723.  
  724.     /* find prediction */
  725.     if (n < 4) {
  726.         x = 2 * s->mb_x + 1 + (n & 1);
  727.         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
  728.         wrap = s->mb_width * 2 + 2;
  729.         dc_val = s->dc_val[0];
  730.         ac_val = s->ac_val[0][0];
  731.         scale = s->y_dc_scale;
  732.     } else {
  733.         x = s->mb_x + 1;
  734.         y = s->mb_y + 1;
  735.         wrap = s->mb_width + 2;
  736.         dc_val = s->dc_val[n - 4 + 1];
  737.         ac_val = s->ac_val[n - 4 + 1][0];
  738.         scale = s->c_dc_scale;
  739.     }
  740.     /* B C
  741.      * A X 
  742.      */
  743.     a = dc_val[(x - 1) + (y) * wrap];
  744.     c = dc_val[(x) + (y - 1) * wrap];
  745.     
  746.     /* No prediction outside GOB boundary */
  747.     if (s->first_slice_line && ((n < 2) || (n > 3)))
  748.         c = 1024;
  749.     pred_dc = 1024;
  750.     /* just DC prediction */
  751.     if (a != 1024 && c != 1024)
  752.         pred_dc = (a + c) >> 1;
  753.     else if (a != 1024)
  754.         pred_dc = a;
  755.     else
  756.         pred_dc = c;
  757.     
  758.     /* we assume pred is positive */
  759.     //pred_dc = (pred_dc + (scale >> 1)) / scale;
  760.     *dc_val_ptr = &dc_val[x + y * wrap];
  761.     return pred_dc;
  762. }
  763.  
  764.  
  765. void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
  766. {
  767.     int x, y, wrap, a, c, pred_dc, scale, i;
  768.     INT16 *dc_val, *ac_val, *ac_val1;
  769.  
  770.     /* find prediction */
  771.     if (n < 4) {
  772.         x = 2 * s->mb_x + 1 + (n & 1);
  773.         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
  774.         wrap = s->mb_width * 2 + 2;
  775.         dc_val = s->dc_val[0];
  776.         ac_val = s->ac_val[0][0];
  777.         scale = s->y_dc_scale;
  778.     } else {
  779.         x = s->mb_x + 1;
  780.         y = s->mb_y + 1;
  781.         wrap = s->mb_width + 2;
  782.         dc_val = s->dc_val[n - 4 + 1];
  783.         ac_val = s->ac_val[n - 4 + 1][0];
  784.         scale = s->c_dc_scale;
  785.     }
  786.     
  787.     ac_val += ((y) * wrap + (x)) * 16;
  788.     ac_val1 = ac_val;
  789.     
  790.     /* B C
  791.      * A X 
  792.      */
  793.     a = dc_val[(x - 1) + (y) * wrap];
  794.     c = dc_val[(x) + (y - 1) * wrap];
  795.     
  796.     /* No prediction outside GOB boundary */
  797.     if (s->first_slice_line && ((n < 2) || (n > 3)))
  798.         c = 1024;
  799.     pred_dc = 1024;
  800.     if (s->ac_pred) {
  801.         if (s->h263_aic_dir) {
  802.             /* left prediction */
  803.             if (a != 1024) {
  804.                 ac_val -= 16;
  805.                 for(i=1;i<8;i++) {
  806.                     block[block_permute_op(i*8)] += ac_val[i];
  807.                 }
  808.                 pred_dc = a;
  809.             }
  810.         } else {
  811.             /* top prediction */
  812.             if (c != 1024) {
  813.                 ac_val -= 16 * wrap;
  814.                 for(i=1;i<8;i++) {
  815.                     block[block_permute_op(i)] += ac_val[i + 8];
  816.                 }
  817.                 pred_dc = c;
  818.             }
  819.         }
  820.     } else {
  821.         /* just DC prediction */
  822.         if (a != 1024 && c != 1024)
  823.             pred_dc = (a + c) >> 1;
  824.         else if (a != 1024)
  825.             pred_dc = a;
  826.         else
  827.             pred_dc = c;
  828.     }
  829.     
  830.     /* we assume pred is positive */
  831.     block[0]=block[0]*scale + pred_dc;
  832.     
  833.     if (block[0] < 0)
  834.         block[0] = 0;
  835.     else if (!(block[0] & 1))
  836.         block[0]++;
  837.     
  838.     /* Update AC/DC tables */
  839.     dc_val[(x) + (y) * wrap] = block[0];
  840.     
  841.     /* left copy */
  842.     for(i=1;i<8;i++)
  843.         ac_val1[i] = block[block_permute_op(i * 8)];
  844.     /* top copy */
  845.     for(i=1;i<8;i++)
  846.         ac_val1[8 + i] = block[block_permute_op(i)];
  847. }
  848.  
  849. INT16 *h263_pred_motion(MpegEncContext * s, int block, 
  850.                         int *px, int *py)
  851. {
  852.     int xy, wrap;
  853.     INT16 *A, *B, *C, *mot_val;
  854.     static const int off[4]= {2, 1, 1, -1};
  855.  
  856.     wrap = s->block_wrap[0];
  857.     xy = s->block_index[block];
  858.  
  859.     mot_val = s->motion_val[xy];
  860.  
  861.     A = s->motion_val[xy - 1];
  862.     /* special case for first (slice) line */
  863.     if ((s->mb_y == 0 || s->first_slice_line) && block<3) {
  864.         // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
  865.         // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
  866.         if(block==0){ //most common case
  867.             if(s->mb_x  == s->resync_mb_x){ //rare
  868.                 *px= *py = 0;
  869.             }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
  870.                 C = s->motion_val[xy + off[block] - wrap];
  871.                 if(s->mb_x==0){
  872.                     *px = C[0];
  873.                     *py = C[1];
  874.                 }else{
  875.                     *px = mid_pred(A[0], 0, C[0]);
  876.                     *py = mid_pred(A[1], 0, C[1]);
  877.                 }
  878.             }else{
  879.                 *px = A[0];
  880.                 *py = A[1];
  881.             }
  882.         }else if(block==1){
  883.             if(s->mb_x + 1 == s->resync_mb_x){ //rare
  884.                 C = s->motion_val[xy + off[block] - wrap];
  885.                 *px = mid_pred(A[0], 0, C[0]);
  886.                 *py = mid_pred(A[1], 0, C[1]);
  887.             }else{
  888.                 *px = A[0];
  889.                 *py = A[1];
  890.             }
  891.         }else{ /* block==2*/
  892.             B = s->motion_val[xy - wrap];
  893.             C = s->motion_val[xy + off[block] - wrap];
  894.             if(s->mb_x == s->resync_mb_x) //rare
  895.                 A[0]=A[1]=0;
  896.     
  897.             *px = mid_pred(A[0], B[0], C[0]);
  898.             *py = mid_pred(A[1], B[1], C[1]);
  899.         }
  900.     } else {
  901.         B = s->motion_val[xy - wrap];
  902.         C = s->motion_val[xy + off[block] - wrap];
  903.         *px = mid_pred(A[0], B[0], C[0]);
  904.         *py = mid_pred(A[1], B[1], C[1]);
  905.     }
  906.     return mot_val;
  907. }
  908.  
  909. static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
  910. {
  911.     int range, l, m, bit_size, sign, code, bits;
  912.  
  913.     if (val == 0) {
  914.         /* zero vector */
  915.         code = 0;
  916.         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
  917.     } else {
  918.         bit_size = f_code - 1;
  919.         range = 1 << bit_size;
  920.         /* modulo encoding */
  921.         l = range * 32;
  922.         m = 2 * l;
  923.         if (val < -l) {
  924.             val += m;
  925.         } else if (val >= l) {
  926.             val -= m;
  927.         }
  928.  
  929.         if (val >= 0) {
  930.             sign = 0;
  931.         } else {
  932.             val = -val;
  933.             sign = 1;
  934.         }
  935.         val--;
  936.         code = (val >> bit_size) + 1;
  937.         bits = val & (range - 1);
  938.  
  939.         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
  940.         if (bit_size > 0) {
  941.             put_bits(&s->pb, bit_size, bits);
  942.         }
  943.     }
  944. }
  945.  
  946. /* Encode MV differences on H.263+ with Unrestricted MV mode */
  947. static void h263p_encode_umotion(MpegEncContext * s, int val)
  948. {
  949.     short sval = 0; 
  950.     short i = 0;
  951.     short n_bits = 0;
  952.     short temp_val;
  953.     int code = 0;
  954.     int tcode;
  955.     
  956.     if ( val == 0)
  957.         put_bits(&s->pb, 1, 1);
  958.     else if (val == 1)
  959.         put_bits(&s->pb, 3, 0);
  960.     else if (val == -1)
  961.         put_bits(&s->pb, 3, 2);
  962.     else {
  963.         
  964.         sval = ((val < 0) ? (short)(-val):(short)val);
  965.         temp_val = sval;
  966.         
  967.         while (temp_val != 0) {
  968.             temp_val = temp_val >> 1;
  969.             n_bits++;
  970.         }
  971.         
  972.         i = n_bits - 1;
  973.         while (i > 0) {
  974.             tcode = (sval & (1 << (i-1))) >> (i-1);
  975.             tcode = (tcode << 1) | 1;
  976.             code = (code << 2) | tcode;
  977.             i--;
  978.         }
  979.         code = ((code << 1) | (val < 0)) << 1;
  980.         put_bits(&s->pb, (2*n_bits)+1, code);
  981.         //printf("\nVal = %d\tCode = %d", sval, code);
  982.     }
  983. }
  984.  
  985. static void init_mv_penalty_and_fcode(MpegEncContext *s)
  986. {
  987.     int f_code;
  988.     int mv;
  989.     for(f_code=1; f_code<=MAX_FCODE; f_code++){
  990.         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
  991.             int len;
  992.  
  993.             if(mv==0) len= mvtab[0][1];
  994.             else{
  995.                 int val, bit_size, range, code;
  996.  
  997.                 bit_size = s->f_code - 1;
  998.                 range = 1 << bit_size;
  999.  
  1000.                 val=mv;
  1001.                 if (val < 0) 
  1002.                     val = -val;
  1003.                 val--;
  1004.                 code = (val >> bit_size) + 1;
  1005.                 if(code<33){
  1006.                     len= mvtab[code][1] + 1 + bit_size;
  1007.                 }else{
  1008.                     len= mvtab[32][1] + 2 + bit_size;
  1009.                 }
  1010.             }
  1011.  
  1012.             mv_penalty[f_code][mv+MAX_MV]= len;
  1013.         }
  1014.     }
  1015.  
  1016.     for(f_code=MAX_FCODE; f_code>0; f_code--){
  1017.         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
  1018.             fcode_tab[mv+MAX_MV]= f_code;
  1019.         }
  1020.     }
  1021.  
  1022.     for(mv=0; mv<MAX_MV*2+1; mv++){
  1023.         umv_fcode_tab[mv]= 1;
  1024.     }
  1025. }
  1026.  
  1027. static void init_uni_dc_tab(void)
  1028. {
  1029.     int level, uni_code, uni_len;
  1030.  
  1031.     for(level=-256; level<256; level++){
  1032.         int size, v, l;
  1033.         /* find number of bits */
  1034.         size = 0;
  1035.         v = abs(level);
  1036.         while (v) {
  1037.             v >>= 1;
  1038.         size++;
  1039.         }
  1040.  
  1041.         if (level < 0)
  1042.             l= (-level) ^ ((1 << size) - 1);
  1043.         else
  1044.             l= level;
  1045.  
  1046.         /* luminance */
  1047.         uni_code= DCtab_lum[size][0];
  1048.         uni_len = DCtab_lum[size][1];
  1049.  
  1050.         if (size > 0) {
  1051.             uni_code<<=size; uni_code|=l;
  1052.             uni_len+=size;
  1053.             if (size > 8){
  1054.                 uni_code<<=1; uni_code|=1;
  1055.                 uni_len++;
  1056.             }
  1057.         }
  1058.         uni_DCtab_lum[level+256][0]= uni_code;
  1059.         uni_DCtab_lum[level+256][1]= uni_len;
  1060.  
  1061.         /* chrominance */
  1062.         uni_code= DCtab_chrom[size][0];
  1063.         uni_len = DCtab_chrom[size][1];
  1064.         
  1065.         if (size > 0) {
  1066.             uni_code<<=size; uni_code|=l;
  1067.             uni_len+=size;
  1068.             if (size > 8){
  1069.                 uni_code<<=1; uni_code|=1;
  1070.                 uni_len++;
  1071.             }
  1072.         }
  1073.         uni_DCtab_chrom[level+256][0]= uni_code;
  1074.         uni_DCtab_chrom[level+256][1]= uni_len;
  1075.  
  1076.     }
  1077. }
  1078.  
  1079. void h263_encode_init(MpegEncContext *s)
  1080. {
  1081.     static int done = 0;
  1082.  
  1083.     if (!done) {
  1084.         done = 1;
  1085.  
  1086.         init_uni_dc_tab();
  1087.  
  1088.         init_rl(&rl_inter);
  1089.         init_rl(&rl_intra);
  1090.         init_rl(&rl_intra_aic);
  1091.  
  1092.         init_mv_penalty_and_fcode(s);
  1093.     }
  1094.     s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
  1095.     
  1096.     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
  1097.     switch(s->codec_id){
  1098.     case CODEC_ID_MPEG4:
  1099.         s->fcode_tab= fcode_tab;
  1100.         s->min_qcoeff= -2048;
  1101.         s->max_qcoeff=  2047;
  1102.         break;
  1103.     case CODEC_ID_H263P:
  1104.         s->fcode_tab= umv_fcode_tab;
  1105.         s->min_qcoeff= -128;
  1106.         s->max_qcoeff=  127;
  1107.         break;
  1108.         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
  1109.     default: //nothing needed default table allready set in mpegvideo.c
  1110.         s->min_qcoeff= -128;
  1111.         s->max_qcoeff=  127;
  1112.         s->y_dc_scale_table=
  1113.         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
  1114.     }
  1115.  
  1116.     /* h263 type bias */
  1117.     //FIXME mpeg4 mpeg quantizer    
  1118.     s->intra_quant_bias=0;
  1119.     s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
  1120. }
  1121.  
  1122. static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
  1123. {
  1124.     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
  1125.     RLTable *rl;
  1126.  
  1127.     rl = &rl_inter;
  1128.     if (s->mb_intra && !s->h263_aic) {
  1129.         /* DC coef */
  1130.         level = block[0];
  1131.         /* 255 cannot be represented, so we clamp */
  1132.         if (level > 254) {
  1133.             level = 254;
  1134.             block[0] = 254;
  1135.         }
  1136.         /* 0 cannot be represented also */
  1137.         else if (!level) {
  1138.             level = 1;
  1139.             block[0] = 1;
  1140.         }
  1141.         if (level == 128)
  1142.             put_bits(&s->pb, 8, 0xff);
  1143.         else
  1144.             put_bits(&s->pb, 8, level & 0xff);
  1145.         i = 1;
  1146.     } else {
  1147.         i = 0;
  1148.         if (s->h263_aic && s->mb_intra)
  1149.             rl = &rl_intra_aic;
  1150.     }
  1151.    
  1152.     /* AC coefs */
  1153.     last_index = s->block_last_index[n];
  1154.     last_non_zero = i - 1;
  1155.     for (; i <= last_index; i++) {
  1156.         j = zigzag_direct[i];
  1157.         level = block[j];
  1158.         if (level) {
  1159.             run = i - last_non_zero - 1;
  1160.             last = (i == last_index);
  1161.             sign = 0;
  1162.             slevel = level;
  1163.             if (level < 0) {
  1164.                 sign = 1;
  1165.                 level = -level;
  1166.             }
  1167.             code = get_rl_index(rl, last, run, level);
  1168.             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
  1169.             if (code == rl->n) {
  1170.                 put_bits(&s->pb, 1, last);
  1171.                 put_bits(&s->pb, 6, run);
  1172.                 put_bits(&s->pb, 8, slevel & 0xff);
  1173.             } else {
  1174.                 put_bits(&s->pb, 1, sign);
  1175.             }
  1176.             last_non_zero = i;
  1177.         }
  1178.     }
  1179. }
  1180.  
  1181. /***************************************************/
  1182.  
  1183. void ff_mpeg4_stuffing(PutBitContext * pbc)
  1184. {
  1185.     int length;
  1186.     put_bits(pbc, 1, 0);
  1187.     length= (-get_bit_count(pbc))&7;
  1188.     if(length) put_bits(pbc, length, (1<<length)-1);
  1189. }
  1190.  
  1191. /* must be called before writing the header */
  1192. void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
  1193.     int time_div, time_mod;
  1194.  
  1195.     if(s->pict_type==I_TYPE){ //we will encode a vol header
  1196.         s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
  1197.         if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
  1198.  
  1199.         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
  1200.     }
  1201.  
  1202.     s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
  1203.     time_div= s->time/s->time_increment_resolution;
  1204.     time_mod= s->time%s->time_increment_resolution;
  1205.  
  1206.     if(s->pict_type==B_TYPE){
  1207.         s->bp_time= s->last_non_b_time - s->time;
  1208.     }else{
  1209.         s->last_time_base= s->time_base;
  1210.         s->time_base= time_div;
  1211.         s->pp_time= s->time - s->last_non_b_time;
  1212.         s->last_non_b_time= s->time;
  1213.     }
  1214. }
  1215.  
  1216. static void mpeg4_encode_vol_header(MpegEncContext * s)
  1217. {
  1218.     int vo_ver_id=1; //must be 2 if we want GMC or q-pel
  1219.     char buf[255];
  1220.  
  1221.     s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
  1222.  
  1223.     put_bits(&s->pb, 16, 0);
  1224.     put_bits(&s->pb, 16, 0x100);        /* video obj */
  1225.     put_bits(&s->pb, 16, 0);
  1226.     put_bits(&s->pb, 16, 0x120);        /* video obj layer */
  1227.  
  1228.     put_bits(&s->pb, 1, 0);        /* random access vol */
  1229.     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
  1230.     put_bits(&s->pb, 1, 1);        /* is obj layer id= yes */
  1231.       put_bits(&s->pb, 4, vo_ver_id);    /* is obj layer ver id */
  1232.       put_bits(&s->pb, 3, 1);        /* is obj layer priority */
  1233.     if(s->aspect_ratio_info) 
  1234.         put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
  1235.     else
  1236.         put_bits(&s->pb, 4, 1);        /* aspect ratio info= sqare pixel */
  1237.  
  1238.     if(s->low_delay){
  1239.         put_bits(&s->pb, 1, 1);        /* vol control parameters= yes */
  1240.         put_bits(&s->pb, 2, 1);        /* chroma format YUV 420/YV12 */
  1241.         put_bits(&s->pb, 1, s->low_delay);
  1242.         put_bits(&s->pb, 1, 0);        /* vbv parameters= no */
  1243.     }else{
  1244.         put_bits(&s->pb, 1, 0);        /* vol control parameters= no */
  1245.     }
  1246.  
  1247.     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
  1248.     put_bits(&s->pb, 1, 1);        /* marker bit */
  1249.     
  1250.     put_bits(&s->pb, 16, s->time_increment_resolution);
  1251.     if (s->time_increment_bits < 1)
  1252.         s->time_increment_bits = 1;
  1253.     put_bits(&s->pb, 1, 1);        /* marker bit */
  1254.     put_bits(&s->pb, 1, 0);        /* fixed vop rate=no */
  1255.     put_bits(&s->pb, 1, 1);        /* marker bit */
  1256.     put_bits(&s->pb, 13, s->width);    /* vol width */
  1257.     put_bits(&s->pb, 1, 1);        /* marker bit */
  1258.     put_bits(&s->pb, 13, s->height);    /* vol height */
  1259.     put_bits(&s->pb, 1, 1);        /* marker bit */
  1260.     put_bits(&s->pb, 1, 0);        /* interlace */
  1261.     put_bits(&s->pb, 1, 1);        /* obmc disable */
  1262.     if (vo_ver_id == 1) {
  1263.         put_bits(&s->pb, 1, s->vol_sprite_usage=0);        /* sprite enable */
  1264.     }else{ /* vo_ver_id == 2 */
  1265.         put_bits(&s->pb, 2, s->vol_sprite_usage=0);        /* sprite enable */
  1266.     }
  1267.     put_bits(&s->pb, 1, 0);        /* not 8 bit */
  1268.     put_bits(&s->pb, 1, 0);        /* quant type= h263 style*/
  1269.     if (vo_ver_id != 1)
  1270.         put_bits(&s->pb, 1, s->quarter_sample=0);
  1271.     put_bits(&s->pb, 1, 1);        /* complexity estimation disable */
  1272.     s->resync_marker= s->rtp_mode;
  1273.     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
  1274.     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
  1275.     if(s->data_partitioning){
  1276.         put_bits(&s->pb, 1, 0);        /* no rvlc */
  1277.     }
  1278.  
  1279.     if (vo_ver_id != 1){
  1280.         put_bits(&s->pb, 1, 0);        /* newpred */
  1281.         put_bits(&s->pb, 1, 0);        /* reduced res vop */
  1282.     }
  1283.     put_bits(&s->pb, 1, 0);        /* scalability */
  1284.  
  1285.     ff_mpeg4_stuffing(&s->pb);
  1286.     put_bits(&s->pb, 16, 0);
  1287.     put_bits(&s->pb, 16, 0x1B2);    /* user_data */
  1288.     sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
  1289.     put_string(&s->pb, buf);
  1290.  
  1291.     ff_mpeg4_stuffing(&s->pb);
  1292. }
  1293.  
  1294. /* write mpeg4 VOP header */
  1295. void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
  1296. {
  1297.     int time_incr;
  1298.     int time_div, time_mod;
  1299.     
  1300.     if(s->pict_type==I_TYPE){
  1301.         s->no_rounding=0;
  1302.         if(picture_number==0 || !s->strict_std_compliance)
  1303.             mpeg4_encode_vol_header(s);
  1304.     }
  1305.     
  1306. //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
  1307.     
  1308.     put_bits(&s->pb, 16, 0);            /* vop header */
  1309.     put_bits(&s->pb, 16, 0x1B6);    /* vop header */
  1310.     put_bits(&s->pb, 2, s->pict_type - 1);    /* pict type: I = 0 , P = 1 */
  1311.  
  1312.     time_div= s->time/s->time_increment_resolution;
  1313.     time_mod= s->time%s->time_increment_resolution;
  1314.     time_incr= time_div - s->last_time_base;
  1315.     while(time_incr--)
  1316.         put_bits(&s->pb, 1, 1);
  1317.         
  1318.     put_bits(&s->pb, 1, 0);
  1319.  
  1320.     put_bits(&s->pb, 1, 1);    /* marker */
  1321.     put_bits(&s->pb, s->time_increment_bits, time_mod);    /* time increment */
  1322.     put_bits(&s->pb, 1, 1);    /* marker */
  1323.     put_bits(&s->pb, 1, 1);    /* vop coded */
  1324.     if (    s->pict_type == P_TYPE 
  1325.         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
  1326.         s->no_rounding ^= 1;
  1327.     put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
  1328.     }
  1329.     put_bits(&s->pb, 3, 0);    /* intra dc VLC threshold */
  1330.     //FIXME sprite stuff
  1331.  
  1332.     put_bits(&s->pb, 5, s->qscale);
  1333.  
  1334.     if (s->pict_type != I_TYPE)
  1335.     put_bits(&s->pb, 3, s->f_code);    /* fcode_for */
  1336.     if (s->pict_type == B_TYPE)
  1337.     put_bits(&s->pb, 3, s->b_code);    /* fcode_back */
  1338.     //    printf("****frame %d\n", picture_number);
  1339.  
  1340.      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
  1341.      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
  1342. }
  1343.  
  1344. static void h263_dc_scale(MpegEncContext * s)
  1345. {
  1346.     s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
  1347.     s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
  1348. }
  1349.  
  1350. inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
  1351. {
  1352.     int a, b, c, wrap, pred, scale;
  1353.     UINT16 *dc_val;
  1354.     int dummy;
  1355.  
  1356.     /* find prediction */
  1357.     if (n < 4) {
  1358.     scale = s->y_dc_scale;
  1359.     } else {
  1360.     scale = s->c_dc_scale;
  1361.     }
  1362.     wrap= s->block_wrap[n];
  1363.     dc_val = s->dc_val[0] + s->block_index[n];
  1364.  
  1365.     /* B C
  1366.      * A X 
  1367.      */
  1368.     a = dc_val[ - 1];
  1369.     b = dc_val[ - 1 - wrap];
  1370.     c = dc_val[ - wrap];
  1371.  
  1372.     if (abs(a - b) < abs(b - c)) {
  1373.     pred = c;
  1374.         *dir_ptr = 1; /* top */
  1375.     } else {
  1376.     pred = a;
  1377.         *dir_ptr = 0; /* left */
  1378.     }
  1379.     /* we assume pred is positive */
  1380. #if defined ARCH_X86 && !defined OS2
  1381.     asm volatile (
  1382.         "xorl %%edx, %%edx    \n\t"
  1383.         "mul %%ecx        \n\t"
  1384.         : "=d" (pred), "=a"(dummy)
  1385.         : "a" (pred + (scale >> 1)), "c" (inverse[scale])
  1386.     );
  1387. #else
  1388.     pred = (pred + (scale >> 1)) / scale;
  1389. #endif
  1390.  
  1391.     /* prepare address for prediction update */
  1392.     *dc_val_ptr = &dc_val[0];
  1393.  
  1394.     return pred;
  1395. }
  1396.  
  1397. void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
  1398.                    int dir)
  1399. {
  1400.     int i;
  1401.     INT16 *ac_val, *ac_val1;
  1402.  
  1403.     /* find prediction */
  1404.     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
  1405.     ac_val1 = ac_val;
  1406.     if (s->ac_pred) {
  1407.         if (dir == 0) {
  1408.             /* left prediction */
  1409.             ac_val -= 16;
  1410.             for(i=1;i<8;i++) {
  1411.                 block[block_permute_op(i*8)] += ac_val[i];
  1412.             }
  1413.         } else {
  1414.             /* top prediction */
  1415.             ac_val -= 16 * s->block_wrap[n];
  1416.             for(i=1;i<8;i++) {
  1417.                 block[block_permute_op(i)] += ac_val[i + 8];
  1418.             }
  1419.         }
  1420.     }
  1421.     /* left copy */
  1422.     for(i=1;i<8;i++)
  1423.         ac_val1[i] = block[block_permute_op(i * 8)];
  1424.     /* top copy */
  1425.     for(i=1;i<8;i++)
  1426.         ac_val1[8 + i] = block[block_permute_op(i)];
  1427. }
  1428.  
  1429. static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
  1430.                               int dir)
  1431. {
  1432.     int i;
  1433.     INT16 *ac_val;
  1434.  
  1435.     /* find prediction */
  1436.     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
  1437.  
  1438.     if (dir == 0) {
  1439.         /* left prediction */
  1440.         ac_val -= 16;
  1441.         for(i=1;i<8;i++) {
  1442.             block[block_permute_op(i*8)] -= ac_val[i];
  1443.         }
  1444.     } else {
  1445.         /* top prediction */
  1446.         ac_val -= 16 * s->block_wrap[n];
  1447.         for(i=1;i<8;i++) {
  1448.             block[block_permute_op(i)] -= ac_val[i + 8];
  1449.         }
  1450.     }
  1451. }
  1452.  
  1453. static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
  1454. {
  1455. #if 1
  1456. //    if(level<-255 || level>255) printf("dc overflow\n");
  1457.     level+=256;
  1458.     if (n < 4) {
  1459.     /* luminance */
  1460.     put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
  1461.     } else {
  1462.     /* chrominance */
  1463.     put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
  1464.     }
  1465. #else
  1466.     int size, v;
  1467.     /* find number of bits */
  1468.     size = 0;
  1469.     v = abs(level);
  1470.     while (v) {
  1471.     v >>= 1;
  1472.     size++;
  1473.     }
  1474.  
  1475.     if (n < 4) {
  1476.     /* luminance */
  1477.     put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
  1478.     } else {
  1479.     /* chrominance */
  1480.     put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
  1481.     }
  1482.  
  1483.     /* encode remaining bits */
  1484.     if (size > 0) {
  1485.     if (level < 0)
  1486.         level = (-level) ^ ((1 << size) - 1);
  1487.     put_bits(&s->pb, size, level);
  1488.     if (size > 8)
  1489.         put_bits(&s->pb, 1, 1);
  1490.     }
  1491. #endif
  1492. }
  1493.  
  1494. static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
  1495.                                UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
  1496. {
  1497.     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
  1498.     int code;
  1499.     const RLTable *rl;
  1500.  
  1501.     if (s->mb_intra) {
  1502.     /* mpeg4 based DC predictor */
  1503.     mpeg4_encode_dc(dc_pb, intra_dc, n);
  1504.     i = 1;
  1505.         rl = &rl_intra;
  1506.     } else {
  1507.     i = 0;
  1508.         rl = &rl_inter;
  1509.     }
  1510.  
  1511.     /* AC coefs */
  1512.     last_index = s->block_last_index[n];
  1513.     last_non_zero = i - 1;
  1514.     for (; i <= last_index; i++) {
  1515.     j = scan_table[i];
  1516.     level = block[j];
  1517.     if (level) {
  1518.         run = i - last_non_zero - 1;
  1519.         last = (i == last_index);
  1520.         sign = 0;
  1521.         slevel = level;
  1522.         if (level < 0) {
  1523.         sign = 1;
  1524.         level = -level;
  1525.         }
  1526.             code = get_rl_index(rl, last, run, level);
  1527.             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
  1528.             if (code == rl->n) {
  1529.                 int level1, run1;
  1530.                 level1 = level - rl->max_level[last][run];
  1531.                 if (level1 < 1) 
  1532.                     goto esc2;
  1533.                 code = get_rl_index(rl, last, run, level1);
  1534.                 if (code == rl->n) {
  1535.                 esc2:
  1536.                     put_bits(ac_pb, 1, 1);
  1537.                     if (level > MAX_LEVEL)
  1538.                         goto esc3;
  1539.                     run1 = run - rl->max_run[last][level] - 1;
  1540.                     if (run1 < 0)
  1541.                         goto esc3;
  1542.                     code = get_rl_index(rl, last, run1, level);
  1543.                     if (code == rl->n) {
  1544.                     esc3:
  1545.                         /* third escape */
  1546.                         put_bits(ac_pb, 1, 1);
  1547.                         put_bits(ac_pb, 1, last);
  1548.                         put_bits(ac_pb, 6, run);
  1549.                         put_bits(ac_pb, 1, 1);
  1550.                         put_bits(ac_pb, 12, slevel & 0xfff);
  1551.                         put_bits(ac_pb, 1, 1);
  1552.                     } else {
  1553.                         /* second escape */
  1554.                         put_bits(ac_pb, 1, 0);
  1555.                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
  1556.                         put_bits(ac_pb, 1, sign);
  1557.                     }
  1558.                 } else {
  1559.                     /* first escape */
  1560.                     put_bits(ac_pb, 1, 0);
  1561.                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
  1562.                     put_bits(ac_pb, 1, sign);
  1563.                 }
  1564.             } else {
  1565.                 put_bits(ac_pb, 1, sign);
  1566.             }
  1567.         last_non_zero = i;
  1568.     }
  1569.     }
  1570. }
  1571.  
  1572.  
  1573.  
  1574. /***********************************************/
  1575. /* decoding */
  1576.  
  1577. static VLC intra_MCBPC_vlc;
  1578. static VLC inter_MCBPC_vlc;
  1579. static VLC cbpy_vlc;
  1580. static VLC mv_vlc;
  1581. static VLC dc_lum, dc_chrom;
  1582. static VLC sprite_trajectory;
  1583. static VLC mb_type_b_vlc;
  1584.  
  1585. void init_rl(RLTable *rl)
  1586. {
  1587.     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
  1588.     UINT8 index_run[MAX_RUN+1];
  1589.     int last, run, level, start, end, i;
  1590.  
  1591.     /* compute max_level[], max_run[] and index_run[] */
  1592.     for(last=0;last<2;last++) {
  1593.         if (last == 0) {
  1594.             start = 0;
  1595.             end = rl->last;
  1596.         } else {
  1597.             start = rl->last;
  1598.             end = rl->n;
  1599.         }
  1600.  
  1601.         memset(max_level, 0, MAX_RUN + 1);
  1602.         memset(max_run, 0, MAX_LEVEL + 1);
  1603.         memset(index_run, rl->n, MAX_RUN + 1);
  1604.         for(i=start;i<end;i++) {
  1605.             run = rl->table_run[i];
  1606.             level = rl->table_level[i];
  1607.             if (index_run[run] == rl->n)
  1608.                 index_run[run] = i;
  1609.             if (level > max_level[run])
  1610.                 max_level[run] = level;
  1611.             if (run > max_run[level])
  1612.                 max_run[level] = run;
  1613.         }
  1614.         rl->max_level[last] = av_malloc(MAX_RUN + 1);
  1615.         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
  1616.         rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
  1617.         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
  1618.         rl->index_run[last] = av_malloc(MAX_RUN + 1);
  1619.         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
  1620.     }
  1621. }
  1622.  
  1623. void init_vlc_rl(RLTable *rl)
  1624. {
  1625.     init_vlc(&rl->vlc, 9, rl->n + 1, 
  1626.              &rl->table_vlc[0][1], 4, 2,
  1627.              &rl->table_vlc[0][0], 4, 2);
  1628. }
  1629.  
  1630. /* init vlcs */
  1631.  
  1632. /* XXX: find a better solution to handle static init */
  1633. void h263_decode_init_vlc(MpegEncContext *s)
  1634. {
  1635.     static int done = 0;
  1636.  
  1637.     if (!done) {
  1638.         done = 1;
  1639.  
  1640.         init_vlc(&intra_MCBPC_vlc, 6, 8, 
  1641.                  intra_MCBPC_bits, 1, 1,
  1642.                  intra_MCBPC_code, 1, 1);
  1643.         init_vlc(&inter_MCBPC_vlc, 9, 25, 
  1644.                  inter_MCBPC_bits, 1, 1,
  1645.                  inter_MCBPC_code, 1, 1);
  1646.         init_vlc(&cbpy_vlc, 6, 16,
  1647.                  &cbpy_tab[0][1], 2, 1,
  1648.                  &cbpy_tab[0][0], 2, 1);
  1649.         init_vlc(&mv_vlc, 9, 33,
  1650.                  &mvtab[0][1], 2, 1,
  1651.                  &mvtab[0][0], 2, 1);
  1652.         init_rl(&rl_inter);
  1653.         init_rl(&rl_intra);
  1654.         init_rl(&rl_intra_aic);
  1655.         init_vlc_rl(&rl_inter);
  1656.         init_vlc_rl(&rl_intra);
  1657.         init_vlc_rl(&rl_intra_aic);
  1658.         init_vlc(&dc_lum, 9, 13,
  1659.                  &DCtab_lum[0][1], 2, 1,
  1660.                  &DCtab_lum[0][0], 2, 1);
  1661.         init_vlc(&dc_chrom, 9, 13,
  1662.                  &DCtab_chrom[0][1], 2, 1,
  1663.                  &DCtab_chrom[0][0], 2, 1);
  1664.         init_vlc(&sprite_trajectory, 9, 15,
  1665.                  &sprite_trajectory_tab[0][1], 4, 2,
  1666.                  &sprite_trajectory_tab[0][0], 4, 2);
  1667.         init_vlc(&mb_type_b_vlc, 4, 4,
  1668.                  &mb_type_b_tab[0][1], 2, 1,
  1669.                  &mb_type_b_tab[0][0], 2, 1);
  1670.     }
  1671. }
  1672.  
  1673. int h263_decode_gob_header(MpegEncContext *s)
  1674. {
  1675.     unsigned int val, gfid;
  1676.     
  1677.     /* Check for GOB Start Code */
  1678.     val = show_bits(&s->gb, 16);
  1679.     if (val == 0) {
  1680.         /* We have a GBSC probably with GSTUFF */
  1681.         skip_bits(&s->gb, 16); /* Drop the zeros */
  1682.         while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
  1683. #ifdef DEBUG
  1684.         fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
  1685. #endif
  1686.         s->gob_number = get_bits(&s->gb, 5); /* GN */
  1687.         gfid = get_bits(&s->gb, 2); /* GFID */
  1688.         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
  1689. #ifdef DEBUG
  1690.         fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
  1691. #endif
  1692.         return 1;
  1693.     }
  1694.     return 0;
  1695.             
  1696. }
  1697.  
  1698. static inline void memsetw(short *tab, int val, int n)
  1699. {
  1700.     int i;
  1701.     for(i=0;i<n;i++)
  1702.         tab[i] = val;
  1703. }
  1704.  
  1705. void ff_mpeg4_init_partitions(MpegEncContext *s)
  1706. {
  1707.     init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
  1708.     init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
  1709. }
  1710.  
  1711. void ff_mpeg4_merge_partitions(MpegEncContext *s)
  1712. {
  1713.     const int pb2_len   = get_bit_count(&s->pb2   );
  1714.     const int tex_pb_len= get_bit_count(&s->tex_pb);
  1715.     const int bits= get_bit_count(&s->pb);
  1716.  
  1717.     if(s->pict_type==I_TYPE){
  1718.         put_bits(&s->pb, 19, DC_MARKER);
  1719.         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
  1720.         s->i_tex_bits+= tex_pb_len;
  1721.     }else{
  1722.         put_bits(&s->pb, 17, MOTION_MARKER);
  1723.         s->misc_bits+=17 + pb2_len;;
  1724.         s->mv_bits+= bits - s->last_bits;
  1725.         s->p_tex_bits+= tex_pb_len;
  1726.     }
  1727.  
  1728.     flush_put_bits(&s->pb2);
  1729.     flush_put_bits(&s->tex_pb);
  1730.  
  1731.     ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
  1732.     ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
  1733.     s->last_bits= get_bit_count(&s->pb);
  1734. }
  1735.  
  1736. void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
  1737. {
  1738.     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
  1739.  
  1740.     ff_mpeg4_stuffing(&s->pb);
  1741.     if(s->pict_type==I_TYPE)
  1742.         put_bits(&s->pb, 16, 0);
  1743.     else if(s->pict_type==B_TYPE)
  1744.         put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0);
  1745.     else /* S/P_TYPE */
  1746.         put_bits(&s->pb, s->f_code+15, 0);
  1747.     put_bits(&s->pb, 1, 1);
  1748.     
  1749.     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
  1750.     put_bits(&s->pb, 5, s->qscale);
  1751.     put_bits(&s->pb, 1, 0); /* no HEC */
  1752. }
  1753.  
  1754. /**
  1755.  * decodes the next video packet and sets s->next_qscale 
  1756.  * returns mb_num of the next packet or <0 if something went wrong
  1757.  */
  1758. static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb)
  1759. {
  1760.     int bits;
  1761.     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
  1762.     int header_extension=0, mb_num;
  1763. //printf("%X\n", show_bits(&gb, 24));
  1764. //printf("parse_video_packet_header\n");
  1765. //    if(show_aligned_bits(gb, 1, 16) != 0) return -1;
  1766.     
  1767.     /* is there enough space left for a video packet + header */
  1768.     if( get_bits_count(gb) > gb->size*8-20) return -1;
  1769.  
  1770. //printf("resync at %d %d\n", s->mb_x, s->mb_y);
  1771. //    skip_bits(gb, 1);
  1772. //    align_get_bits(gb);
  1773.     if(get_bits(gb, 16)!=0){
  1774.         printf("internal error while decoding video packet header\n");
  1775.     }
  1776.  
  1777. //printf("%X\n", show_bits(gb, 24));
  1778.     bits=0;
  1779.     while(!get_bits1(gb) && bits<30) bits++;
  1780.     if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){
  1781.         printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n", 
  1782.                bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y);
  1783.         return -1;
  1784.     }else if(s->pict_type == I_TYPE && bits != 0){
  1785.         printf("marker too long\n");
  1786.         return -1;
  1787.     }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){
  1788.         printf("marker does not match f/b_code\n");
  1789.         return -1;
  1790.     }
  1791. //printf("%X\n", show_bits(gb, 24));
  1792.  
  1793.     if(s->shape != RECT_SHAPE){
  1794.         header_extension= get_bits1(gb);
  1795.         //FIXME more stuff here
  1796.     }
  1797.  
  1798.     mb_num= get_bits(gb, mb_num_bits);
  1799.     if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){
  1800.         fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width);
  1801.         return -1;
  1802.     }
  1803.  
  1804.     if(s->shape != BIN_ONLY_SHAPE){
  1805.         s->next_resync_qscale= get_bits(gb, 5);
  1806.         if(s->next_resync_qscale==0)
  1807.             s->next_resync_qscale= s->qscale;
  1808.         if(s->next_resync_qscale==0){
  1809.             fprintf(stderr, "qscale==0\n");
  1810.             return -1;
  1811.         }
  1812.     }
  1813.  
  1814.     if(s->shape == RECT_SHAPE){
  1815.         header_extension= get_bits1(gb);
  1816.     }
  1817.     if(header_extension){
  1818.         int time_increment;
  1819.         int time_incr=0;
  1820.         printf("header extension not supported\n");
  1821.         return -1;
  1822.  
  1823.         while (get_bits1(gb) != 0) 
  1824.             time_incr++;
  1825.  
  1826.         check_marker(gb, "before time_increment in video packed header");
  1827.         time_increment= get_bits(gb, s->time_increment_bits);
  1828.         if(s->pict_type!=B_TYPE){
  1829.             s->last_time_base= s->time_base;
  1830.             s->time_base+= time_incr;
  1831.             s->time= s->time_base*s->time_increment_resolution + time_increment;
  1832.             s->pp_time= s->time - s->last_non_b_time;
  1833.             s->last_non_b_time= s->time;
  1834.         }else{
  1835.             s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
  1836.             s->bp_time= s->last_non_b_time - s->time;
  1837.         }
  1838.         check_marker(gb, "before vop_coding_type in video packed header");
  1839.         
  1840.         skip_bits(gb, 2); /* vop coding type */
  1841.         //FIXME not rect stuff here
  1842.  
  1843.         if(s->shape != BIN_ONLY_SHAPE){
  1844.             skip_bits(gb, 3); /* intra dc vlc threshold */
  1845.  
  1846.             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
  1847.                 mpeg4_decode_sprite_trajectory(s);
  1848.             }
  1849.  
  1850.             //FIXME reduced res stuff here
  1851.             
  1852.             if (s->pict_type != I_TYPE) {
  1853.                 s->f_code = get_bits(gb, 3);    /* fcode_for */
  1854.                 if(s->f_code==0){
  1855.                     printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
  1856.                     return -1; // makes no sense to continue, as the MV decoding will break very quickly
  1857.                 }
  1858.             }
  1859.             if (s->pict_type == B_TYPE) {
  1860.                 s->b_code = get_bits(gb, 3);
  1861.             }       
  1862.         }
  1863.     }
  1864.     //FIXME new-pred stuff
  1865.     
  1866. //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
  1867.  
  1868.     return mb_num;
  1869. }
  1870.  
  1871. void ff_mpeg4_clean_buffers(MpegEncContext *s)
  1872. {
  1873.     int c_wrap, c_xy, l_wrap, l_xy;
  1874.  
  1875.     l_wrap= s->block_wrap[0];
  1876.     l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
  1877.     c_wrap= s->block_wrap[4];
  1878.     c_xy= s->mb_y*c_wrap + s->mb_x;
  1879.  
  1880.     /* clean DC */
  1881.     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
  1882.     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
  1883.     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
  1884.  
  1885.     /* clean AC */
  1886.     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
  1887.     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
  1888.     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
  1889.  
  1890.     /* clean MV */
  1891.     // we cant clear the MVs as they might be needed by a b frame
  1892. //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
  1893. //    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
  1894.     s->last_mv[0][0][0]=
  1895.     s->last_mv[0][0][1]=
  1896.     s->last_mv[1][0][0]=
  1897.     s->last_mv[1][0][1]= 0;
  1898. }
  1899.  
  1900. /* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */
  1901. int ff_mpeg4_resync(MpegEncContext *s)
  1902. {
  1903.     GetBitContext gb;
  1904.     
  1905.     /* search & parse next resync marker */
  1906.     
  1907.     gb= s->next_resync_gb;
  1908.     align_get_bits(&gb);
  1909. //printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb));
  1910.     for(;;) {
  1911.         int v= show_bits(&gb, 24);
  1912.         if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){
  1913.             s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width;
  1914. //printf("mpeg4_resync end\n");
  1915.             s->gb= s->next_resync_gb; //continue at the next resync marker
  1916.             return -1;
  1917.         }else if(v>>8 == 0){
  1918.             int next;
  1919.             s->next_resync_pos= get_bits_count(&gb);
  1920.             
  1921.             next= decode_video_packet_header(s, &gb);
  1922.             if(next >= 0){
  1923.                 s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width;
  1924.                 break;
  1925.             }
  1926.  
  1927.             align_get_bits(&gb);
  1928.         }
  1929.         skip_bits(&gb, 8);
  1930.     }
  1931.     s->next_resync_gb=gb;
  1932.     
  1933.     return 0;
  1934. }
  1935.  
  1936. static inline void init_block_index(MpegEncContext *s)
  1937. {
  1938.     s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
  1939.     s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
  1940.     s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
  1941.     s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
  1942.     s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
  1943.     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) + s->mb_x;
  1944. }
  1945.  
  1946. static inline void update_block_index(MpegEncContext *s)
  1947. {
  1948.     s->block_index[0]+=2;
  1949.     s->block_index[1]+=2;
  1950.     s->block_index[2]+=2;
  1951.     s->block_index[3]+=2;
  1952.     s->block_index[4]++;
  1953.     s->block_index[5]++;
  1954. }
  1955.  
  1956. /**
  1957.  * decodes the first & second partition
  1958.  * returns error type or 0 if no error
  1959.  */
  1960. int ff_mpeg4_decode_partitions(MpegEncContext *s)
  1961. {
  1962.     static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
  1963.     int mb_num;
  1964.     
  1965.     /* decode first partition */
  1966.     mb_num=0;
  1967.     s->first_slice_line=1;
  1968.     s->mb_x= s->resync_mb_x;
  1969.     for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
  1970.         init_block_index(s);
  1971.         for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
  1972.             const int xy= s->mb_x + s->mb_y*s->mb_width;
  1973.             int cbpc;
  1974.             int dir=0;
  1975.             
  1976.             mb_num++;
  1977.             update_block_index(s);
  1978.             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
  1979.                 s->first_slice_line=0;
  1980.             
  1981.             if(s->mb_x==0) PRINT_MB_TYPE("\n");
  1982.  
  1983.             if(s->pict_type==I_TYPE){
  1984.                 int i;
  1985.  
  1986.                 PRINT_MB_TYPE("I");
  1987.                 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
  1988.                 if (cbpc < 0){
  1989.                     fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
  1990.                     return DECODING_DESYNC;
  1991.                 }
  1992.                 s->cbp_table[xy]= cbpc & 3;
  1993.                 s->mb_type[xy]= MB_TYPE_INTRA;
  1994.                 s->mb_intra = 1;
  1995.  
  1996.                 if(cbpc & 4) {
  1997.                     s->qscale += quant_tab[get_bits(&s->gb, 2)];
  1998.                     if (s->qscale < 1)
  1999.                         s->qscale = 1;
  2000.                     else if (s->qscale > 31)
  2001.                         s->qscale = 31;
  2002.                     h263_dc_scale(s);
  2003.                 }
  2004.                 s->qscale_table[xy]= s->qscale;
  2005.  
  2006.                 s->mbintra_table[xy]= 1;
  2007.                 for(i=0; i<6; i++){
  2008.                     int dc_pred_dir;
  2009.                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
  2010.                     if(dc < 0){
  2011.                         fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
  2012.                         return DECODING_DESYNC;
  2013.                     }
  2014.                     dir<<=1;
  2015.                     if(dc_pred_dir) dir|=1;
  2016.                 }
  2017.                 s->pred_dir_table[xy]= dir;
  2018.             }else{ /* P/S_TYPE */
  2019.                 int mx, my, pred_x, pred_y;
  2020.                 INT16 * const mot_val= s->motion_val[s->block_index[0]];
  2021.                 const int stride= s->block_wrap[0]*2;
  2022.  
  2023.                 if(get_bits1(&s->gb)){
  2024.                     /* skip mb */
  2025.                     s->mb_type[xy]= MB_TYPE_SKIPED;
  2026.                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
  2027.                         const int a= s->sprite_warping_accuracy;
  2028.                         PRINT_MB_TYPE("G");
  2029.                         if(s->divx_version==500 && s->divx_build==413){
  2030.                             mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
  2031.                             my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
  2032.                         }else{
  2033.                             mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
  2034.                             my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
  2035.                             s->mb_type[xy]= MB_TYPE_GMC | MB_TYPE_SKIPED;
  2036.                         }
  2037.                     }else{
  2038.                         PRINT_MB_TYPE("S");
  2039.                         mx = 0;
  2040.                         my = 0;
  2041.                     }
  2042.                     mot_val[0       ]= mot_val[2       ]=
  2043.                     mot_val[0+stride]= mot_val[2+stride]= mx;
  2044.                     mot_val[1       ]= mot_val[3       ]=
  2045.                     mot_val[1+stride]= mot_val[3+stride]= my;
  2046.  
  2047.                     if(s->mbintra_table[xy])
  2048.                         ff_clean_intra_table_entries(s);
  2049.  
  2050.                     continue;
  2051.                 }
  2052.                 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
  2053.                 if (cbpc < 0){
  2054.                     fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
  2055.                     return DECODING_DESYNC;
  2056.                 }
  2057.                 if (cbpc > 20)
  2058.                     cbpc+=3;
  2059.                 else if (cbpc == 20)
  2060.                     fprintf(stderr, "Stuffing !");
  2061.                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
  2062.     
  2063.                 s->mb_intra = ((cbpc & 4) != 0);
  2064.         
  2065.                 if(s->mb_intra){
  2066.                     PRINT_MB_TYPE("I");
  2067.                     s->mbintra_table[xy]= 1;
  2068.                     s->mb_type[xy]= MB_TYPE_INTRA;
  2069.                     mot_val[0       ]= mot_val[2       ]= 
  2070.                     mot_val[0+stride]= mot_val[2+stride]= 0;
  2071.                     mot_val[1       ]= mot_val[3       ]=
  2072.                     mot_val[1+stride]= mot_val[3+stride]= 0;
  2073.                 }else{
  2074.                     if(s->mbintra_table[xy])
  2075.                         ff_clean_intra_table_entries(s);
  2076.  
  2077.                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
  2078.                         s->mcsel= get_bits1(&s->gb);
  2079.                     else s->mcsel= 0;
  2080.         
  2081.                     if ((cbpc & 16) == 0) {
  2082.                         PRINT_MB_TYPE("P");
  2083.                         /* 16x16 motion prediction */
  2084.                         s->mb_type[xy]= MB_TYPE_INTER;
  2085.  
  2086.                         h263_pred_motion(s, 0, &pred_x, &pred_y);
  2087.                         if(!s->mcsel)
  2088.                            mx = h263_decode_motion(s, pred_x, s->f_code);
  2089.                         else {
  2090.                             const int a= s->sprite_warping_accuracy;
  2091.                             if(s->divx_version==500 && s->divx_build==413){
  2092.                                 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
  2093.                             }else{
  2094.                                 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
  2095.                             }
  2096.                         }
  2097.                         if (mx >= 0xffff)
  2098.                             return DECODING_DESYNC;
  2099.             
  2100.                         if(!s->mcsel)
  2101.                            my = h263_decode_motion(s, pred_y, s->f_code);
  2102.                         else{
  2103.                            const int a= s->sprite_warping_accuracy;
  2104.                             if(s->divx_version==500 && s->divx_build==413){
  2105.                                 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
  2106.                             }else{
  2107.                                 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
  2108.                             }
  2109.                         }
  2110.                         if (my >= 0xffff)
  2111.                             return DECODING_DESYNC;
  2112.                         mot_val[0       ]= mot_val[2       ] =
  2113.                         mot_val[0+stride]= mot_val[2+stride]= mx;
  2114.                         mot_val[1       ]= mot_val[3       ]=
  2115.                         mot_val[1+stride]= mot_val[3+stride]= my;
  2116.                     } else {
  2117.                         int i;
  2118.                         PRINT_MB_TYPE("4");
  2119.                         s->mb_type[xy]= MB_TYPE_INTER4V;
  2120.                         for(i=0;i<4;i++) {
  2121.                             INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
  2122.                             mx = h263_decode_motion(s, pred_x, s->f_code);
  2123.                             if (mx >= 0xffff)
  2124.                                 return DECODING_DESYNC;
  2125.                 
  2126.                             my = h263_decode_motion(s, pred_y, s->f_code);
  2127.                             if (my >= 0xffff)
  2128.                                 return DECODING_DESYNC;
  2129.                             mot_val[0] = mx;
  2130.                             mot_val[1] = my;
  2131.                         }
  2132.                     }
  2133.                 }
  2134.             }
  2135.         }
  2136.         s->mb_x= 0;
  2137.     }
  2138.  
  2139.     if     (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER    ) s->decoding_error= DECODING_DESYNC;
  2140.     else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC;
  2141.     if(s->decoding_error== DECODING_DESYNC){
  2142.         fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y);
  2143.         return DECODING_DESYNC;
  2144.     }
  2145.  
  2146.     /* decode second partition */
  2147.     mb_num=0;
  2148.     s->mb_x= s->resync_mb_x;
  2149.     for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
  2150.         init_block_index(s);
  2151.         for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
  2152.             const int xy= s->mb_x + s->mb_y*s->mb_width;
  2153.  
  2154.             mb_num++;
  2155.             update_block_index(s);
  2156.             
  2157.             if(s->pict_type==I_TYPE){
  2158.                 int ac_pred= get_bits1(&s->gb);
  2159.                 int cbpy = get_vlc(&s->gb, &cbpy_vlc);
  2160.                 if(cbpy<0){
  2161.                     fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
  2162.                     return DECODING_AC_LOST;
  2163.                 }
  2164.                 
  2165.                 s->cbp_table[xy]|= cbpy<<2;
  2166.                 s->pred_dir_table[xy]|= ac_pred<<7;
  2167.             }else{ /* P || S_TYPE */
  2168.                 if(s->mb_type[xy]&MB_TYPE_INTRA){          
  2169.                     int dir=0,i;
  2170.                     int ac_pred = get_bits1(&s->gb);
  2171.                     int cbpy = get_vlc(&s->gb, &cbpy_vlc);
  2172.  
  2173.                     if(cbpy<0){
  2174.                         fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
  2175.                         return DECODING_ACDC_LOST;
  2176.                     }
  2177.                     
  2178.                     if(s->cbp_table[xy] & 8) {
  2179.                         s->qscale += quant_tab[get_bits(&s->gb, 2)];
  2180.                         if (s->qscale < 1)
  2181.                             s->qscale = 1;
  2182.                         else if (s->qscale > 31)
  2183.                             s->qscale = 31;
  2184.                         h263_dc_scale(s);
  2185.                     }
  2186.                     s->qscale_table[xy]= s->qscale;
  2187.  
  2188.                     for(i=0; i<6; i++){
  2189.                         int dc_pred_dir;
  2190.                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
  2191.                         if(dc < 0){
  2192.                             fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
  2193.                             return DECODING_ACDC_LOST;
  2194.                         }
  2195.                         dir<<=1;
  2196.                         if(dc_pred_dir) dir|=1;
  2197.                     }
  2198.                     s->cbp_table[xy]&= 3; //remove dquant
  2199.                     s->cbp_table[xy]|= cbpy<<2;
  2200.                     s->pred_dir_table[xy]= dir | (ac_pred<<7);
  2201.                 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
  2202.                     s->qscale_table[xy]= s->qscale;
  2203.                     s->cbp_table[xy]= 0;
  2204.                 }else{
  2205.                     int cbpy = get_vlc(&s->gb, &cbpy_vlc);
  2206.  
  2207.                     if(cbpy<0){
  2208.                         fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
  2209.                         return DECODING_ACDC_LOST;
  2210.                     }
  2211.                     
  2212.                     if(s->cbp_table[xy] & 8) {
  2213. //fprintf(stderr, "dquant\n");
  2214.                         s->qscale += quant_tab[get_bits(&s->gb, 2)];
  2215.                         if (s->qscale < 1)
  2216.                             s->qscale = 1;
  2217.                         else if (s->qscale > 31)
  2218.                             s->qscale = 31;
  2219.                         h263_dc_scale(s);
  2220.                     }
  2221.                     s->qscale_table[xy]= s->qscale;
  2222.  
  2223.                     s->cbp_table[xy]&= 3; //remove dquant
  2224.                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
  2225.                 }
  2226.             }
  2227.         }
  2228.         s->mb_x= 0;
  2229.     }
  2230.     
  2231.  
  2232.     return 0;        
  2233. }
  2234.  
  2235. static int mpeg4_decode_partitioned_mb(MpegEncContext *s,
  2236.                    DCTELEM block[6][64])
  2237. {
  2238.     int cbp, mb_type;
  2239.     const int xy= s->mb_x + s->mb_y*s->mb_width;
  2240.  
  2241.     if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start
  2242.         int i;
  2243.         int block_index_backup[6];
  2244.         int qscale= s->qscale;
  2245.         
  2246.         for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i];
  2247.         
  2248.         s->decoding_error= ff_mpeg4_decode_partitions(s);
  2249.         
  2250.         for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i];
  2251.         s->first_slice_line=1;
  2252.         s->mb_x= s->resync_mb_x;
  2253.         s->mb_y= s->resync_mb_y;
  2254.         s->qscale= qscale;
  2255.         h263_dc_scale(s);
  2256.  
  2257.         if(s->decoding_error==DECODING_DESYNC) return -1;
  2258.     }
  2259.     
  2260.     mb_type= s->mb_type[xy];
  2261.     if(s->decoding_error)
  2262.         cbp=0;
  2263.     else 
  2264.         cbp = s->cbp_table[xy];
  2265.  
  2266.     if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){
  2267.         s->qscale= s->qscale_table[xy];
  2268.         h263_dc_scale(s);
  2269.     }
  2270.  
  2271.     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
  2272.         int i;
  2273.         for(i=0; i<4; i++){
  2274.             s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
  2275.             s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
  2276.         }
  2277.         s->mb_intra = mb_type&MB_TYPE_INTRA;
  2278.  
  2279.         if (mb_type&MB_TYPE_SKIPED) {
  2280.             /* skip mb */
  2281.             for(i=0;i<6;i++)
  2282.                 s->block_last_index[i] = -1;
  2283.             s->mv_dir = MV_DIR_FORWARD;
  2284.             s->mv_type = MV_TYPE_16X16;
  2285.             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
  2286.                 s->mcsel=1;
  2287.                 s->mb_skiped = 0;
  2288.             }else{
  2289.                 s->mcsel=0;
  2290.                 s->mb_skiped = 1;
  2291.             }
  2292.             return 0;
  2293.         }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){
  2294.             s->ac_pred = s->pred_dir_table[xy]>>7;
  2295.  
  2296.             /* decode each block */
  2297.             for (i = 0; i < 6; i++) {
  2298.                 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
  2299.                 if(ret==DECODING_AC_LOST){
  2300.                     fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
  2301.                     s->decoding_error=DECODING_AC_LOST;
  2302.                     cbp=0;
  2303.                 }else if(ret==DECODING_ACDC_LOST){
  2304.                     fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y);
  2305.                     s->decoding_error=DECODING_ACDC_LOST;
  2306.                     break;
  2307.                 }
  2308.             }
  2309.         }else if(!s->mb_intra){
  2310. //            s->mcsel= 0; //FIXME do we need to init that
  2311.             
  2312.             s->mv_dir = MV_DIR_FORWARD;
  2313.             if (mb_type&MB_TYPE_INTER4V) {
  2314.                 s->mv_type = MV_TYPE_8X8;
  2315.             } else {
  2316.                 s->mv_type = MV_TYPE_16X16;
  2317.             }
  2318.             if(s->decoding_error==0 && cbp){
  2319.                 /* decode each block */
  2320.                 for (i = 0; i < 6; i++) {
  2321.                     int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
  2322.                     if(ret==DECODING_AC_LOST){
  2323.                         fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
  2324.                         s->decoding_error=DECODING_AC_LOST;
  2325.                         break;
  2326.                     }
  2327.                 }
  2328.             }
  2329.         }
  2330.     } else { /* I-Frame */
  2331.         int i;
  2332.         s->mb_intra = 1;
  2333.         s->ac_pred = s->pred_dir_table[xy]>>7;
  2334.         
  2335.         /* decode each block */
  2336.         for (i = 0; i < 6; i++) {
  2337.             int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
  2338.             if(ret==DECODING_AC_LOST){
  2339.                 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
  2340.                 s->decoding_error=DECODING_AC_LOST;
  2341.                 cbp=0;
  2342.             }else if(ret==DECODING_ACDC_LOST){
  2343.                 fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y);
  2344.                 return -1;
  2345.             }
  2346.         }
  2347.     }
  2348.  
  2349.     return 0;
  2350. }
  2351.  
  2352.  
  2353. int h263_decode_mb(MpegEncContext *s,
  2354.                    DCTELEM block[6][64])
  2355. {
  2356.     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
  2357.     INT16 *mot_val;
  2358.     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
  2359.  
  2360.     if(s->mb_x==0) PRINT_MB_TYPE("\n")
  2361.  
  2362.     if(s->resync_marker){
  2363.         if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
  2364.             s->first_slice_line=0; 
  2365.         }
  2366.     }
  2367.  
  2368.     if(s->data_partitioning && s->pict_type!=B_TYPE)
  2369.         return mpeg4_decode_partitioned_mb(s, block);
  2370.  
  2371.     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
  2372.         if (get_bits1(&s->gb)) {
  2373.             /* skip mb */
  2374.             s->mb_intra = 0;
  2375.             for(i=0;i<6;i++)
  2376.                 s->block_last_index[i] = -1;
  2377.             s->mv_dir = MV_DIR_FORWARD;
  2378.             s->mv_type = MV_TYPE_16X16;
  2379.             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
  2380.                 const int a= s->sprite_warping_accuracy;
  2381. //                int l = (1 << (s->f_code - 1)) * 32;
  2382.                 PRINT_MB_TYPE("G");
  2383.                 s->mcsel=1;
  2384.                 if(s->divx_version==500 && s->divx_build==413){
  2385.                     s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
  2386.                     s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
  2387.                 }else{
  2388.                     s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
  2389.                     s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
  2390.                 }
  2391. /*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
  2392.                 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
  2393.                 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
  2394.                 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
  2395.  
  2396.                 s->mb_skiped = 0;
  2397.             }else{
  2398.                 PRINT_MB_TYPE("S");
  2399.                 s->mcsel=0;
  2400.                 s->mv[0][0][0] = 0;
  2401.                 s->mv[0][0][1] = 0;
  2402.                 s->mb_skiped = 1;
  2403.             }
  2404.             return 0;
  2405.         }
  2406.         cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
  2407.         //fprintf(stderr, "\tCBPC: %d", cbpc);
  2408.         if (cbpc < 0)
  2409.             return -1;
  2410.         if (cbpc > 20)
  2411.             cbpc+=3;
  2412.         else if (cbpc == 20)
  2413.             fprintf(stderr, "Stuffing !");
  2414.         
  2415.         dquant = cbpc & 8;
  2416.         s->mb_intra = ((cbpc & 4) != 0);
  2417.         if (s->mb_intra) goto intra;
  2418.         
  2419.         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
  2420.             s->mcsel= get_bits1(&s->gb);
  2421.         else s->mcsel= 0;
  2422.         cbpy = get_vlc(&s->gb, &cbpy_vlc);
  2423.         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
  2424.         if (dquant) {
  2425.             s->qscale += quant_tab[get_bits(&s->gb, 2)];
  2426.             if (s->qscale < 1)
  2427.                 s->qscale = 1;
  2428.             else if (s->qscale > 31)
  2429.                 s->qscale = 31;
  2430.             h263_dc_scale(s);
  2431.         }
  2432.         s->mv_dir = MV_DIR_FORWARD;
  2433.         if ((cbpc & 16) == 0) {
  2434.             PRINT_MB_TYPE("P");
  2435.             /* 16x16 motion prediction */
  2436.             s->mv_type = MV_TYPE_16X16;
  2437.             h263_pred_motion(s, 0, &pred_x, &pred_y);
  2438.             if (s->umvplus_dec)
  2439.                mx = h263p_decode_umotion(s, pred_x);
  2440.             else if(!s->mcsel)
  2441.                mx = h263_decode_motion(s, pred_x, s->f_code);
  2442.             else {
  2443.                const int a= s->sprite_warping_accuracy;
  2444. //        int l = (1 << (s->f_code - 1)) * 32;
  2445.                 if(s->divx_version==500 && s->divx_build==413){
  2446.                     mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
  2447.                 }else{
  2448.                     mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
  2449.                 }
  2450. //        if (mx < -l) mx= -l, printf("C");
  2451. //        else if (mx >= l) mx= l-1, printf("C");
  2452.             }
  2453.             if (mx >= 0xffff)
  2454.                 return -1;
  2455.             
  2456.             if (s->umvplus_dec)
  2457.                my = h263p_decode_umotion(s, pred_y);
  2458.             else if(!s->mcsel)
  2459.                my = h263_decode_motion(s, pred_y, s->f_code);
  2460.             else{
  2461.                const int a= s->sprite_warping_accuracy;
  2462. //       int l = (1 << (s->f_code - 1)) * 32;
  2463.                 if(s->divx_version==500 && s->divx_build==413){
  2464.                     my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
  2465.                 }else{
  2466.                     my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
  2467.                 }
  2468. //       if (my < -l) my= -l, printf("C");
  2469. //       else if (my >= l) my= l-1, printf("C");
  2470.             }
  2471.             if (my >= 0xffff)
  2472.                 return -1;
  2473.             s->mv[0][0][0] = mx;
  2474.             s->mv[0][0][1] = my;
  2475.             /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
  2476.             fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
  2477.             fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
  2478.             if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
  2479.                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
  2480.                            
  2481.         } else {
  2482.             PRINT_MB_TYPE("4");
  2483.             s->mv_type = MV_TYPE_8X8;
  2484.             for(i=0;i<4;i++) {
  2485.                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
  2486.                 if (s->umvplus_dec)
  2487.                   mx = h263p_decode_umotion(s, pred_x);
  2488.                 else
  2489.                   mx = h263_decode_motion(s, pred_x, s->f_code);
  2490.                 if (mx >= 0xffff)
  2491.                     return -1;
  2492.                 
  2493.                 if (s->umvplus_dec)
  2494.                   my = h263p_decode_umotion(s, pred_y);
  2495.                 else    
  2496.                   my = h263_decode_motion(s, pred_y, s->f_code);
  2497.                 if (my >= 0xffff)
  2498.                     return -1;
  2499.                 s->mv[0][i][0] = mx;
  2500.                 s->mv[0][i][1] = my;
  2501.                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
  2502.                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
  2503.                 mot_val[0] = mx;
  2504.                 mot_val[1] = my;
  2505.             }
  2506.         }
  2507.     } else if(s->pict_type==B_TYPE) {
  2508.         int modb1; // first bit of modb
  2509.         int modb2; // second bit of modb
  2510.         int mb_type;
  2511.         uint16_t time_pp;
  2512.         uint16_t time_pb;
  2513.         int xy;
  2514.  
  2515.         s->mb_intra = 0; //B-frames never contain intra blocks
  2516.         s->mcsel=0;      //     ...               true gmc blocks
  2517.  
  2518.         if(s->mb_x==0){
  2519.             s->last_mv[0][0][0]= 
  2520.             s->last_mv[0][0][1]= 
  2521.             s->last_mv[1][0][0]= 
  2522.             s->last_mv[1][0][1]= 0;
  2523.         }
  2524.  
  2525.         /* if we skipped it in the future P Frame than skip it now too */
  2526.         s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
  2527.  
  2528.         if(s->mb_skiped){
  2529.                 /* skip mb */
  2530.             for(i=0;i<6;i++)
  2531.                 s->block_last_index[i] = -1;
  2532.  
  2533.             s->mv_dir = MV_DIR_FORWARD;
  2534.             s->mv_type = MV_TYPE_16X16;
  2535.             s->mv[0][0][0] = 0;
  2536.             s->mv[0][0][1] = 0;
  2537.             s->mv[1][0][0] = 0;
  2538.             s->mv[1][0][1] = 0;
  2539. //FIXME is this correct?
  2540. /*            s->last_mv[0][0][0]=
  2541.             s->last_mv[0][0][1]=0;*/
  2542.             PRINT_MB_TYPE("s")
  2543.             return 0;
  2544.         }
  2545.  
  2546.         modb1= get_bits1(&s->gb);
  2547.         if(modb1==0){
  2548.             modb2= get_bits1(&s->gb);
  2549.             mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
  2550.             if(modb2==0) cbp= get_bits(&s->gb, 6);
  2551.             else cbp=0;
  2552.             if (mb_type && cbp) {
  2553.                 if(get_bits1(&s->gb)){
  2554.                     s->qscale +=get_bits1(&s->gb)*4 - 2;
  2555.                     if (s->qscale < 1)
  2556.                         s->qscale = 1;
  2557.                     else if (s->qscale > 31)
  2558.                         s->qscale = 31;
  2559.                     h263_dc_scale(s);
  2560.                 }
  2561.             }
  2562.         }else{
  2563.             mb_type=4; //like 0 but no vectors coded
  2564.             cbp=0;
  2565.         }
  2566.         s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
  2567.         mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
  2568.         switch(mb_type)
  2569.         {
  2570.         case 0: /* direct */
  2571.             mx = h263_decode_motion(s, 0, 1);
  2572.             my = h263_decode_motion(s, 0, 1);
  2573.         case 4: /* direct with mx=my=0 */
  2574.             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
  2575.             xy= s->block_index[0];
  2576.             time_pp= s->pp_time;
  2577.             time_pb= time_pp - s->bp_time;
  2578. //if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
  2579.             //FIXME 4MV
  2580.             //FIXME avoid divides
  2581.             s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
  2582.             s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
  2583.             s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
  2584.                                 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
  2585.             s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
  2586.                                 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
  2587. /*            s->mv[0][0][0] = 
  2588.             s->mv[0][0][1] = 
  2589.             s->mv[1][0][0] = 
  2590.             s->mv[1][0][1] = 1000;*/
  2591.             PRINT_MB_TYPE("D");
  2592.             break;
  2593.         case 1: 
  2594.             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
  2595.             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
  2596.             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
  2597.             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
  2598.             s->last_mv[0][0][1]= s->mv[0][0][1] = my;
  2599.  
  2600.             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
  2601.             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
  2602.             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
  2603.             s->last_mv[1][0][1]= s->mv[1][0][1] = my;
  2604.             PRINT_MB_TYPE("i");
  2605.             break;
  2606.         case 2: 
  2607.             s->mv_dir = MV_DIR_BACKWARD;
  2608.             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
  2609.             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
  2610.             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
  2611.             s->last_mv[1][0][1]= s->mv[1][0][1] = my;
  2612.             PRINT_MB_TYPE("B");
  2613.             break;
  2614.         case 3:
  2615.             s->mv_dir = MV_DIR_FORWARD;
  2616.             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
  2617.             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
  2618.             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
  2619.             s->last_mv[0][0][1]= s->mv[0][0][1] = my;
  2620.             PRINT_MB_TYPE("F");
  2621.             break;
  2622.         default: 
  2623.             printf("illegal MB_type\n");
  2624.             return -1;
  2625.         }
  2626.     } else { /* I-Frame */
  2627.         cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
  2628.         if (cbpc < 0)
  2629.             return -1;
  2630.         dquant = cbpc & 4;
  2631.         s->mb_intra = 1;
  2632. intra:
  2633.         PRINT_MB_TYPE("I");
  2634.         s->ac_pred = 0;
  2635.         if (s->h263_pred || s->h263_aic) {
  2636.             s->ac_pred = get_bits1(&s->gb);
  2637.             if (s->ac_pred && s->h263_aic)
  2638.                 s->h263_aic_dir = get_bits1(&s->gb);
  2639.         }
  2640.         cbpy = get_vlc(&s->gb, &cbpy_vlc);
  2641.         if(cbpy<0) return -1;
  2642.         cbp = (cbpc & 3) | (cbpy << 2);
  2643.         if (dquant) {
  2644.             s->qscale += quant_tab[get_bits(&s->gb, 2)];
  2645.             if (s->qscale < 1)
  2646.                 s->qscale = 1;
  2647.             else if (s->qscale > 31)
  2648.                 s->qscale = 31;
  2649.             h263_dc_scale(s);
  2650.         }
  2651.     }
  2652.  
  2653.     /* decode each block */
  2654.     if (s->h263_pred) {
  2655.     for (i = 0; i < 6; i++) {
  2656.         if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
  2657.                 return -1;
  2658.     }
  2659.     } else {
  2660.     for (i = 0; i < 6; i++) {
  2661.         if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
  2662.                 return -1;
  2663.     }
  2664.     }
  2665.     return 0;
  2666. }
  2667.  
  2668. static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
  2669. {
  2670.     int code, val, sign, shift, l, m;
  2671.  
  2672.     code = get_vlc(&s->gb, &mv_vlc);
  2673.     if (code < 0)
  2674.         return 0xffff;
  2675.  
  2676.     if (code == 0)
  2677.         return pred;
  2678.     sign = get_bits1(&s->gb);
  2679.     shift = f_code - 1;
  2680.     val = (code - 1) << shift;
  2681.     if (shift > 0)
  2682.         val |= get_bits(&s->gb, shift);
  2683.     val++;
  2684.     if (sign)
  2685.         val = -val;
  2686.     val += pred;
  2687.  
  2688.     /* modulo decoding */
  2689.     if (!s->h263_long_vectors) {
  2690.         l = (1 << (f_code - 1)) * 32;
  2691.         m = 2 * l;
  2692.         if (val < -l) {
  2693.             val += m;
  2694.         } else if (val >= l) {
  2695.             val -= m;
  2696.         }
  2697.     } else {
  2698.         /* horrible h263 long vector mode */
  2699.         if (pred < -31 && val < -63)
  2700.             val += 64;
  2701.         if (pred > 32 && val > 63)
  2702.             val -= 64;
  2703.         
  2704.     }
  2705.     return val;
  2706. }
  2707.  
  2708. /* Decodes RVLC of H.263+ UMV */
  2709. static int h263p_decode_umotion(MpegEncContext * s, int pred)
  2710. {
  2711.    int code = 0, sign;
  2712.    
  2713.    if (get_bits1(&s->gb)) /* Motion difference = 0 */
  2714.       return pred;
  2715.    
  2716.    code = 2 + get_bits1(&s->gb);
  2717.    
  2718.    while (get_bits1(&s->gb))
  2719.    {
  2720.       code <<= 1;
  2721.       code += get_bits1(&s->gb);
  2722.    }
  2723.    sign = code & 1;
  2724.    code >>= 1;
  2725.    
  2726.    code = (sign) ? (pred - code) : (pred + code);
  2727. #ifdef DEBUG
  2728.    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
  2729. #endif
  2730.    return code;   
  2731.  
  2732. }
  2733.  
  2734. static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
  2735.                              int n, int coded)
  2736. {
  2737.     int code, level, i, j, last, run;
  2738.     RLTable *rl = &rl_inter;
  2739.     const UINT8 *scan_table;
  2740.  
  2741.     scan_table = zigzag_direct;
  2742.     if (s->h263_aic && s->mb_intra) {
  2743.         rl = &rl_intra_aic;
  2744.         i = 0;
  2745.         if (s->ac_pred) {
  2746.             if (s->h263_aic_dir) 
  2747.                 scan_table = ff_alternate_vertical_scan; /* left */
  2748.             else
  2749.                 scan_table = ff_alternate_horizontal_scan; /* top */
  2750.         }
  2751.     } else if (s->mb_intra) {
  2752.         /* DC coef */
  2753.         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
  2754.             int component, diff;
  2755.             component = (n <= 3 ? 0 : n - 4 + 1);
  2756.             level = s->last_dc[component];
  2757.             if (s->rv10_first_dc_coded[component]) {
  2758.                 diff = rv_decode_dc(s, n);
  2759.                 if (diff == 0xffff)
  2760.                     return -1;
  2761.                 level += diff;
  2762.                 level = level & 0xff; /* handle wrap round */
  2763.                 s->last_dc[component] = level;
  2764.             } else {
  2765.                 s->rv10_first_dc_coded[component] = 1;
  2766.             }
  2767.         } else {
  2768.             level = get_bits(&s->gb, 8);
  2769.             if (level == 255)
  2770.                 level = 128;
  2771.         }
  2772.         block[0] = level;
  2773.         i = 1;
  2774.     } else {
  2775.         i = 0;
  2776.     }
  2777.     if (!coded) {
  2778.         if (s->mb_intra && s->h263_aic)
  2779.             goto not_coded;
  2780.         s->block_last_index[n] = i - 1;
  2781.         return 0;
  2782.     }
  2783.  
  2784.     for(;;) {
  2785.         code = get_vlc(&s->gb, &rl->vlc);
  2786.         if (code < 0)
  2787.             return -1;
  2788.         if (code == rl->n) {
  2789.             /* escape */
  2790.             last = get_bits1(&s->gb);
  2791.             run = get_bits(&s->gb, 6);
  2792.             level = (INT8)get_bits(&s->gb, 8);
  2793.             if (s->h263_rv10 && level == -128) {
  2794.                 /* XXX: should patch encoder too */
  2795.                 level = get_bits(&s->gb, 12);
  2796.                 level = (level << 20) >> 20;
  2797.             }
  2798.         } else {
  2799.             run = rl->table_run[code];
  2800.             level = rl->table_level[code];
  2801.             last = code >= rl->last;
  2802.             if (get_bits1(&s->gb))
  2803.                 level = -level;
  2804.         }
  2805.         i += run;
  2806.         if (i >= 64)
  2807.             return -1;
  2808.         j = scan_table[i];
  2809.         block[j] = level;
  2810.         if (last)
  2811.             break;
  2812.         i++;
  2813.     }
  2814. not_coded:    
  2815.     if (s->mb_intra && s->h263_aic) {
  2816.         h263_pred_acdc(s, block, n);
  2817.         i = 63;
  2818.     }
  2819.     s->block_last_index[n] = i;
  2820.     return 0;
  2821. }
  2822.  
  2823. static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
  2824. {
  2825.     int level, pred, code;
  2826.     UINT16 *dc_val;
  2827.  
  2828.     if (n < 4) 
  2829.         code = get_vlc(&s->gb, &dc_lum);
  2830.     else 
  2831.         code = get_vlc(&s->gb, &dc_chrom);
  2832.     if (code < 0 || code > 9 /* && s->nbit<9 */){
  2833.         fprintf(stderr, "illegal dc vlc\n");
  2834.         return -1;
  2835.     }
  2836.     if (code == 0) {
  2837.         level = 0;
  2838.     } else {
  2839.         level = get_bits(&s->gb, code);
  2840.         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
  2841.             level = - (level ^ ((1 << code) - 1));
  2842.         if (code > 8){
  2843.             if(get_bits1(&s->gb)==0){ /* marker */
  2844.                 fprintf(stderr, "dc marker bit missing\n");
  2845.                 return -1;
  2846.             }
  2847.         }
  2848.     }
  2849.  
  2850.     pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
  2851.     level += pred;
  2852.     if (level < 0)
  2853.         level = 0;
  2854.     if (n < 4) {
  2855.         *dc_val = level * s->y_dc_scale;
  2856.     } else {
  2857.         *dc_val = level * s->c_dc_scale;
  2858.     }
  2859.     return level;
  2860. }
  2861.  
  2862. /**
  2863.  * decode a block
  2864.  * returns 0 if everything went ok
  2865.  * returns DECODING_AC_LOST   if an error was detected during AC decoding
  2866.  * returns DECODING_ACDC_LOST if an error was detected during DC decoding
  2867.  */
  2868. static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  2869.                               int n, int coded)
  2870. {
  2871.     int code, level, i, j, last, run;
  2872.     int dc_pred_dir;
  2873.     RLTable *rl;
  2874.     const UINT8 *scan_table;
  2875.  
  2876.     if (s->mb_intra) {
  2877.     /* DC coef */
  2878.         if(s->data_partitioning && s->pict_type!=B_TYPE){
  2879.             level = s->dc_val[0][ s->block_index[n] ];
  2880.             if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
  2881.             else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
  2882.             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
  2883.         }else{
  2884.             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
  2885.             if (level < 0)
  2886.                 return DECODING_ACDC_LOST;
  2887.         }
  2888.         block[0] = level;
  2889.         i = 1;
  2890.         if (!coded) 
  2891.             goto not_coded;
  2892.         rl = &rl_intra;
  2893.         if (s->ac_pred) {
  2894.             if (dc_pred_dir == 0) 
  2895.                 scan_table = ff_alternate_vertical_scan; /* left */
  2896.             else
  2897.                 scan_table = ff_alternate_horizontal_scan; /* top */
  2898.         } else {
  2899.             scan_table = zigzag_direct;
  2900.         }
  2901.     } else {
  2902.     i = 0;
  2903.         if (!coded) {
  2904.             s->block_last_index[n] = i - 1;
  2905.             return 0;
  2906.         }
  2907.         rl = &rl_inter;
  2908.         scan_table = zigzag_direct;
  2909.     }
  2910.  
  2911.     for(;;) {
  2912.         code = get_vlc(&s->gb, &rl->vlc);
  2913.         if (code < 0)
  2914.             return DECODING_AC_LOST;
  2915.         if (code == rl->n) {
  2916.             /* escape */
  2917.             if (get_bits1(&s->gb) != 0) {
  2918.                 if (get_bits1(&s->gb) != 0) {
  2919.                     /* third escape */
  2920.                     last = get_bits1(&s->gb);
  2921.                     run = get_bits(&s->gb, 6);
  2922.                     if(get_bits1(&s->gb)==0){
  2923.                         fprintf(stderr, "1. marker bit missing in 3. esc\n");
  2924.                         return DECODING_AC_LOST;
  2925.                     }
  2926.                     level = get_bits(&s->gb, 12);
  2927.                     level = (level << 20) >> 20; /* sign extend */
  2928.                     if(get_bits1(&s->gb)==0){
  2929.                         fprintf(stderr, "2. marker bit missing in 3. esc\n");
  2930.                         return DECODING_AC_LOST;
  2931.                     }
  2932.                     if(level>512 || level<-512){ //FIXME check that QP=1 is ok with this too
  2933.                         fprintf(stderr, "|level| overflow in 3. esc\n");
  2934.                         return DECODING_AC_LOST;
  2935.                     }
  2936. #if 1 
  2937.                     {
  2938.                         const int abs_level= ABS(level);
  2939.                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){
  2940.                             const int run1= run - rl->max_run[last][abs_level] - 1;
  2941.                             if(abs_level <= rl->max_level[last][run]){
  2942.                                 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
  2943.                                 return DECODING_AC_LOST;
  2944.                             }
  2945.                             if(abs_level <= rl->max_level[last][run]*2){
  2946.                                 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
  2947.                                 return DECODING_AC_LOST;
  2948.                             }
  2949.                             if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
  2950.                                 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
  2951.                                 return DECODING_AC_LOST;
  2952.                             }
  2953.                         }
  2954.                     }
  2955. #endif
  2956.                 } else {
  2957.                     /* second escape */
  2958.                     code = get_vlc(&s->gb, &rl->vlc);
  2959.                     if (code < 0 || code >= rl->n)
  2960.                         return DECODING_AC_LOST;
  2961.                     run = rl->table_run[code];
  2962.                     level = rl->table_level[code];
  2963.                     last = code >= rl->last;
  2964.                     run += rl->max_run[last][level] + 1;
  2965.                     if (get_bits1(&s->gb))
  2966.                         level = -level;
  2967.                 }
  2968.             } else {
  2969.                 /* first escape */
  2970.                 code = get_vlc(&s->gb, &rl->vlc);
  2971.                 if (code < 0 || code >= rl->n)
  2972.                     return DECODING_AC_LOST;
  2973.                 run = rl->table_run[code];
  2974.                 level = rl->table_level[code];
  2975.                 last = code >= rl->last;
  2976.                 level += rl->max_level[last][run];
  2977.                 if (get_bits1(&s->gb))
  2978.                     level = -level;
  2979.             }
  2980.         } else {
  2981.             run = rl->table_run[code];
  2982.             level = rl->table_level[code];
  2983.             last = code >= rl->last;
  2984.             if (get_bits1(&s->gb))
  2985.                 level = -level;
  2986.         }
  2987.         i += run;
  2988.         if (i >= 64)
  2989.             return DECODING_AC_LOST;
  2990.     j = scan_table[i];
  2991.         block[j] = level;
  2992.         i++;
  2993.         if (last)
  2994.             break;
  2995.     }
  2996.  not_coded:
  2997.     if (s->mb_intra) {
  2998.         mpeg4_pred_ac(s, block, n, dc_pred_dir);
  2999.         if (s->ac_pred) {
  3000.             i = 64; /* XXX: not optimal */
  3001.         }
  3002.     }
  3003.     s->block_last_index[n] = i - 1;
  3004.     return 0;
  3005. }
  3006.  
  3007. /* most is hardcoded. should extend to handle all h263 streams */
  3008. int h263_decode_picture_header(MpegEncContext *s)
  3009. {
  3010.     int format, width, height;
  3011.  
  3012.     /* picture start code */
  3013.     if (get_bits(&s->gb, 22) != 0x20) {
  3014.         fprintf(stderr, "Bad picture start code\n");
  3015.         return -1;
  3016.     }
  3017.     /* temporal reference */
  3018.     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
  3019.  
  3020.     /* PTYPE starts here */    
  3021.     if (get_bits1(&s->gb) != 1) {
  3022.         /* marker */
  3023.         fprintf(stderr, "Bad marker\n");
  3024.         return -1;
  3025.     }
  3026.     if (get_bits1(&s->gb) != 0) {
  3027.         fprintf(stderr, "Bad H263 id\n");
  3028.         return -1;    /* h263 id */
  3029.     }
  3030.     skip_bits1(&s->gb);    /* split screen off */
  3031.     skip_bits1(&s->gb);    /* camera  off */
  3032.     skip_bits1(&s->gb);    /* freeze picture release off */
  3033.  
  3034.     /* Reset GOB number */
  3035.     s->gob_number = 0;
  3036.         
  3037.     format = get_bits(&s->gb, 3);
  3038.     /*
  3039.         0    forbidden
  3040.         1    sub-QCIF
  3041.         10   QCIF
  3042.         7    extended PTYPE (PLUSPTYPE)
  3043.     */
  3044.  
  3045.     if (format != 7 && format != 6) {
  3046.         s->h263_plus = 0;
  3047.         /* H.263v1 */
  3048.         width = h263_format[format][0];
  3049.         height = h263_format[format][1];
  3050.         if (!width)
  3051.             return -1;
  3052.         
  3053.         s->width = width;
  3054.         s->height = height;
  3055.         s->pict_type = I_TYPE + get_bits1(&s->gb);
  3056.  
  3057.         s->unrestricted_mv = get_bits1(&s->gb); 
  3058.         s->h263_long_vectors = s->unrestricted_mv;
  3059.  
  3060.         if (get_bits1(&s->gb) != 0) {
  3061.             fprintf(stderr, "H263 SAC not supported\n");
  3062.             return -1;    /* SAC: off */
  3063.         }
  3064.         if (get_bits1(&s->gb) != 0) {
  3065.             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
  3066.         }   
  3067.         
  3068.         if (get_bits1(&s->gb) != 0) {
  3069.             fprintf(stderr, "H263 PB frame not supported\n");
  3070.             return -1;    /* not PB frame */
  3071.         }
  3072.         s->qscale = get_bits(&s->gb, 5);
  3073.         skip_bits1(&s->gb);    /* Continuous Presence Multipoint mode: off */
  3074.     } else {
  3075.         int ufep;
  3076.         
  3077.         /* H.263v2 */
  3078.         s->h263_plus = 1;
  3079.         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
  3080.  
  3081.         /* ufep other than 0 and 1 are reserved */        
  3082.         if (ufep == 1) {
  3083.             /* OPPTYPE */       
  3084.             format = get_bits(&s->gb, 3);
  3085.             dprintf("ufep=1, format: %d\n", format);
  3086.             skip_bits(&s->gb,1); /* Custom PCF */
  3087.             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
  3088.             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
  3089.             if (get_bits1(&s->gb) != 0) {
  3090.                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
  3091.             }
  3092.             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
  3093.                 s->h263_aic = 1;
  3094.             }
  3095.         
  3096.             skip_bits(&s->gb, 7);
  3097.             /* these are the 7 bits: (in order of appearence  */
  3098.             /* Deblocking Filter */
  3099.             /* Slice Structured */
  3100.             /* Reference Picture Selection */
  3101.             /* Independent Segment Decoding */
  3102.             /* Alternative Inter VLC */
  3103.             /* Modified Quantization */
  3104.             /* Prevent start code emulation */
  3105.  
  3106.             skip_bits(&s->gb, 3); /* Reserved */
  3107.         } else if (ufep != 0) {
  3108.             fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
  3109.             return -1;
  3110.         }
  3111.             
  3112.         /* MPPTYPE */
  3113.         s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
  3114.         dprintf("pict_type: %d\n", s->pict_type);
  3115.         if (s->pict_type != I_TYPE &&
  3116.             s->pict_type != P_TYPE)
  3117.             return -1;
  3118.         skip_bits(&s->gb, 2);
  3119.         s->no_rounding = get_bits1(&s->gb);
  3120.         dprintf("RTYPE: %d\n", s->no_rounding);
  3121.         skip_bits(&s->gb, 4);
  3122.         
  3123.         /* Get the picture dimensions */
  3124.         if (ufep) {
  3125.             if (format == 6) {
  3126.                 /* Custom Picture Format (CPFMT) */
  3127.                 s->aspect_ratio_info = get_bits(&s->gb, 4);
  3128.                 dprintf("aspect: %d\n", s->aspect_ratio_info);
  3129.                 /* aspect ratios:
  3130.                 0 - forbidden
  3131.                 1 - 1:1
  3132.                 2 - 12:11 (CIF 4:3)
  3133.                 3 - 10:11 (525-type 4:3)
  3134.                 4 - 16:11 (CIF 16:9)
  3135.                 5 - 40:33 (525-type 16:9)
  3136.                 6-14 - reserved
  3137.                 */
  3138.                 width = (get_bits(&s->gb, 9) + 1) * 4;
  3139.                 skip_bits1(&s->gb);
  3140.                 height = get_bits(&s->gb, 9) * 4;
  3141.                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
  3142.                 if (s->aspect_ratio_info == EXTENDED_PAR) {
  3143.                     /* aspected dimensions */
  3144.                     skip_bits(&s->gb, 8); /* width */
  3145.                     skip_bits(&s->gb, 8); /* height */
  3146.                 }
  3147.             } else {
  3148.                 width = h263_format[format][0];
  3149.                 height = h263_format[format][1];
  3150.             }
  3151.             if ((width == 0) || (height == 0))
  3152.                 return -1;
  3153.             s->width = width;
  3154.             s->height = height;
  3155.             if (s->umvplus_dec) {
  3156.                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
  3157.             }
  3158.         }
  3159.             
  3160.         s->qscale = get_bits(&s->gb, 5);
  3161.     }
  3162.     /* PEI */
  3163.     while (get_bits1(&s->gb) != 0) {
  3164.         skip_bits(&s->gb, 8);
  3165.     }
  3166.     s->f_code = 1;
  3167.     
  3168.     if(s->h263_aic){
  3169.          s->y_dc_scale_table= 
  3170.          s->c_dc_scale_table= h263_aic_dc_scale_table;
  3171.     }else{
  3172.         s->y_dc_scale_table=
  3173.         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
  3174.     }
  3175.  
  3176.     return 0;
  3177. }
  3178.  
  3179. static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
  3180. {
  3181.     int i;
  3182.     int a= 2<<s->sprite_warping_accuracy;
  3183.     int rho= 3-s->sprite_warping_accuracy;
  3184.     int r=16/a;
  3185.     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
  3186.     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
  3187.     int sprite_ref[4][2];
  3188.     int virtual_ref[2][2];
  3189.     int w2, h2;
  3190.     int alpha=0, beta=0;
  3191.     int w= s->width;
  3192.     int h= s->height;
  3193. //printf("SP %d\n", s->sprite_warping_accuracy);
  3194.     for(i=0; i<s->num_sprite_warping_points; i++){
  3195.         int length;
  3196.         int x=0, y=0;
  3197.  
  3198.         length= get_vlc(&s->gb, &sprite_trajectory);
  3199.         if(length){
  3200.             x= get_bits(&s->gb, length);
  3201. //printf("lx %d %d\n", length, x);
  3202.             if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
  3203.                 x = - (x ^ ((1 << length) - 1));
  3204.         }
  3205.         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
  3206.         
  3207.         length= get_vlc(&s->gb, &sprite_trajectory);
  3208.         if(length){
  3209.             y=get_bits(&s->gb, length);
  3210. //printf("ly %d %d\n", length, y);
  3211.             if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
  3212.                 y = - (y ^ ((1 << length) - 1));
  3213.         }
  3214.         skip_bits1(&s->gb); /* marker bit */
  3215. //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
  3216. //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
  3217. //x=y=0;
  3218.         d[i][0]= x;
  3219.         d[i][1]= y;
  3220.     }
  3221.  
  3222.     while((1<<alpha)<w) alpha++;
  3223.     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
  3224.     w2= 1<<alpha;
  3225.     h2= 1<<beta;
  3226.  
  3227. // Note, the 4th point isnt used for GMC
  3228.     if(s->divx_version==500 && s->divx_build==413){
  3229.         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
  3230.         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
  3231.         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
  3232.         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
  3233.         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
  3234.         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
  3235.     } else {
  3236.         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
  3237.         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
  3238.         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
  3239.         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
  3240.         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
  3241.         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
  3242.     }
  3243. /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
  3244.     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
  3245.     
  3246. // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
  3247. // perhaps it should be reordered to be more readable ...
  3248. // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
  3249. // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
  3250.     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
  3251.         + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
  3252.     virtual_ref[0][1]= 16*vop_ref[0][1] 
  3253.         + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
  3254.     virtual_ref[1][0]= 16*vop_ref[0][0] 
  3255.         + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
  3256.     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
  3257.         + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
  3258.  
  3259.     switch(s->num_sprite_warping_points)
  3260.     {
  3261.         case 0:
  3262.             s->sprite_offset[0][0]= 0;
  3263.             s->sprite_offset[0][1]= 0;
  3264.             s->sprite_offset[1][0]= 0;
  3265.             s->sprite_offset[1][1]= 0;
  3266.             s->sprite_delta[0][0][0]= a;
  3267.             s->sprite_delta[0][0][1]= 0;
  3268.             s->sprite_delta[0][1][0]= 0;
  3269.             s->sprite_delta[0][1][1]= a;
  3270.             s->sprite_delta[1][0][0]= a;
  3271.             s->sprite_delta[1][0][1]= 0;
  3272.             s->sprite_delta[1][1][0]= 0;
  3273.             s->sprite_delta[1][1][1]= a;
  3274.             s->sprite_shift[0][0]= 0;
  3275.             s->sprite_shift[0][1]= 0;
  3276.             s->sprite_shift[1][0]= 0;
  3277.             s->sprite_shift[1][1]= 0;
  3278.             break;
  3279.         case 1: //GMC only
  3280.             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
  3281.             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
  3282.             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
  3283.             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
  3284.             s->sprite_delta[0][0][0]= a;
  3285.             s->sprite_delta[0][0][1]= 0;
  3286.             s->sprite_delta[0][1][0]= 0;
  3287.             s->sprite_delta[0][1][1]= a;
  3288.             s->sprite_delta[1][0][0]= a;
  3289.             s->sprite_delta[1][0][1]= 0;
  3290.             s->sprite_delta[1][1][0]= 0;
  3291.             s->sprite_delta[1][1][1]= a;
  3292.             s->sprite_shift[0][0]= 0;
  3293.             s->sprite_shift[0][1]= 0;
  3294.             s->sprite_shift[1][0]= 0;
  3295.             s->sprite_shift[1][1]= 0;
  3296.             break;
  3297.         case 2:
  3298.         case 3: //FIXME
  3299.             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
  3300.                                                   + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
  3301.                                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
  3302.             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
  3303.                                                   + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
  3304.                                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
  3305.             s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
  3306.                                  +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
  3307.                                  +2*w2*r*sprite_ref[0][0] - 16*w2);
  3308.             s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
  3309.                                  +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
  3310.                                  +2*w2*r*sprite_ref[0][1] - 16*w2);
  3311.             s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
  3312.             s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
  3313.             s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
  3314.             s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
  3315.             s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
  3316.             s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
  3317.             s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
  3318.             s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
  3319.             s->sprite_shift[0][0]= alpha+rho;
  3320.             s->sprite_shift[0][1]= alpha+rho;
  3321.             s->sprite_shift[1][0]= alpha+rho+2;
  3322.             s->sprite_shift[1][1]= alpha+rho+2;
  3323.             break;
  3324. //        case 3:
  3325.             break;
  3326.     }
  3327. /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
  3328. printf("%d %d\n", s->sprite_delta[0][0][1], 0);
  3329. printf("%d %d\n", s->sprite_delta[0][1][0], 0);
  3330. printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
  3331. printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
  3332. printf("%d %d\n", s->sprite_delta[1][0][1], 0);
  3333. printf("%d %d\n", s->sprite_delta[1][1][0], 0);
  3334. printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
  3335.     /* try to simplify the situation */ 
  3336.     if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
  3337.        && s->sprite_delta[0][0][1] == 0
  3338.        && s->sprite_delta[0][1][0] == 0
  3339.        && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
  3340.        && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
  3341.        && s->sprite_delta[1][0][1] == 0
  3342.        && s->sprite_delta[1][1][0] == 0
  3343.        && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
  3344.     {
  3345.         s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
  3346.         s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
  3347.         s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
  3348.         s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
  3349.         s->sprite_delta[0][0][0]= a;
  3350.         s->sprite_delta[0][0][1]= 0;
  3351.         s->sprite_delta[0][1][0]= 0;
  3352.         s->sprite_delta[0][1][1]= a;
  3353.         s->sprite_delta[1][0][0]= a;
  3354.         s->sprite_delta[1][0][1]= 0;
  3355.         s->sprite_delta[1][1][0]= 0;
  3356.         s->sprite_delta[1][1][1]= a;
  3357.         s->sprite_shift[0][0]= 0;
  3358.         s->sprite_shift[0][1]= 0;
  3359.         s->sprite_shift[1][0]= 0;
  3360.         s->sprite_shift[1][1]= 0;
  3361.         s->real_sprite_warping_points=1;
  3362.     }
  3363.     else
  3364.         s->real_sprite_warping_points= s->num_sprite_warping_points;
  3365.  
  3366. //printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
  3367. }
  3368.  
  3369. /* decode mpeg4 VOP header */
  3370. int mpeg4_decode_picture_header(MpegEncContext * s)
  3371. {
  3372.     int time_incr, startcode, state, v;
  3373.     int time_increment;
  3374.  
  3375.  redo:
  3376.     /* search next start code */
  3377.     align_get_bits(&s->gb);
  3378.     state = 0xff;
  3379.     for(;;) {
  3380.         v = get_bits(&s->gb, 8);
  3381.         if (state == 0x000001) {
  3382.             state = ((state << 8) | v) & 0xffffff;
  3383.             startcode = state;
  3384.             break;
  3385.         }
  3386.         state = ((state << 8) | v) & 0xffffff;
  3387.         if( get_bits_count(&s->gb) > s->gb.size*8-32){
  3388.             if(s->gb.size>50){
  3389.                 printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
  3390.                 return -1;
  3391.             }else{
  3392.                 printf("frame skip\n");
  3393.                 return FRAME_SKIPED;
  3394.             }
  3395.         }
  3396.     }
  3397. //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
  3398.     if (startcode == 0x120) { // Video Object Layer
  3399.         int width, height, vo_ver_id;
  3400.  
  3401.         /* vol header */
  3402.         skip_bits(&s->gb, 1); /* random access */
  3403.         s->vo_type= get_bits(&s->gb, 8);
  3404.         if (get_bits1(&s->gb) != 0) { /* is_ol_id */
  3405.             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
  3406.             skip_bits(&s->gb, 3); /* vo_priority */
  3407.         } else {
  3408.             vo_ver_id = 1;
  3409.         }
  3410. //printf("vo type:%d\n",s->vo_type);
  3411.         s->aspect_ratio_info= get_bits(&s->gb, 4);
  3412.     if(s->aspect_ratio_info == EXTENDED_PAR){
  3413.             skip_bits(&s->gb, 8); //par_width
  3414.             skip_bits(&s->gb, 8); // par_height
  3415.         }
  3416.  
  3417.         if ((s->vol_control_parameters=get_bits1(&s->gb))) { /* vol control parameter */
  3418.             int chroma_format= get_bits(&s->gb, 2);
  3419.             if(chroma_format!=1){
  3420.                 printf("illegal chroma format\n");
  3421.             }
  3422.             s->low_delay= get_bits1(&s->gb);
  3423.             if(get_bits1(&s->gb)){ /* vbv parameters */
  3424.                 printf("vbv parameters not supported\n");
  3425.                 return -1;
  3426.             }
  3427.         }else{
  3428.             s->low_delay=0;
  3429.         }
  3430.  
  3431.         s->shape = get_bits(&s->gb, 2); /* vol shape */
  3432.         if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
  3433.         if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
  3434.             printf("Gray shape not supported\n");
  3435.             skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
  3436.         }
  3437.  
  3438.         skip_bits1(&s->gb);   /* marker */
  3439.         
  3440.         s->time_increment_resolution = get_bits(&s->gb, 16);
  3441.         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
  3442.         if (s->time_increment_bits < 1)
  3443.             s->time_increment_bits = 1;
  3444.         skip_bits1(&s->gb);   /* marker */
  3445.  
  3446.         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
  3447.             skip_bits(&s->gb, s->time_increment_bits);
  3448.         }
  3449.  
  3450.         if (s->shape != BIN_ONLY_SHAPE) {
  3451.             if (s->shape == RECT_SHAPE) {
  3452.                 skip_bits1(&s->gb);   /* marker */
  3453.                 width = get_bits(&s->gb, 13);
  3454.                 skip_bits1(&s->gb);   /* marker */
  3455.                 height = get_bits(&s->gb, 13);
  3456.                 skip_bits1(&s->gb);   /* marker */
  3457.                 if(width && height){ /* they should be non zero but who knows ... */
  3458.                     s->width = width;
  3459.                     s->height = height;
  3460. //                    printf("width/height: %d %d\n", width, height);
  3461.                 }
  3462.             }
  3463.             
  3464.             if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
  3465.             if(!get_bits1(&s->gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
  3466.             if (vo_ver_id == 1) {
  3467.                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
  3468.             } else {
  3469.                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
  3470.             }
  3471.             if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
  3472.             if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
  3473.                 if(s->vol_sprite_usage==STATIC_SPRITE){
  3474.                     s->sprite_width = get_bits(&s->gb, 13);
  3475.                     skip_bits1(&s->gb); /* marker */
  3476.                     s->sprite_height= get_bits(&s->gb, 13);
  3477.                     skip_bits1(&s->gb); /* marker */
  3478.                     s->sprite_left  = get_bits(&s->gb, 13);
  3479.                     skip_bits1(&s->gb); /* marker */
  3480.                     s->sprite_top   = get_bits(&s->gb, 13);
  3481.                     skip_bits1(&s->gb); /* marker */
  3482.                 }
  3483.                 s->num_sprite_warping_points= get_bits(&s->gb, 6);
  3484.                 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
  3485.                 s->sprite_brightness_change= get_bits1(&s->gb);
  3486.                 if(s->vol_sprite_usage==STATIC_SPRITE)
  3487.                     s->low_latency_sprite= get_bits1(&s->gb);            
  3488.             }
  3489.             // FIXME sadct disable bit if verid!=1 && shape not rect
  3490.             
  3491.             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
  3492.                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
  3493.                 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
  3494.                 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
  3495.             } else {
  3496.                 s->quant_precision = 5;
  3497.             }
  3498.             
  3499.             // FIXME a bunch of grayscale shape things
  3500.  
  3501.             if(get_bits1(&s->gb)){ /* vol_quant_type */
  3502.                 int i, j, v;
  3503.                 /* load default matrixes */
  3504.                 for(i=0; i<64; i++){
  3505.                     v= ff_mpeg4_default_intra_matrix[i];
  3506.                     s->intra_matrix[i]= v;
  3507.                     s->chroma_intra_matrix[i]= v;
  3508.                     
  3509.                     v= ff_mpeg4_default_non_intra_matrix[i];
  3510.                     s->inter_matrix[i]= v;
  3511.                     s->chroma_inter_matrix[i]= v;
  3512.                 }
  3513.  
  3514.                 /* load custom intra matrix */
  3515.                 if(get_bits1(&s->gb)){
  3516.                     for(i=0; i<64; i++){
  3517.                         v= get_bits(&s->gb, 8);
  3518.                         if(v==0) break;
  3519.  
  3520.                         j= zigzag_direct[i];
  3521.                         s->intra_matrix[j]= v;
  3522.                         s->chroma_intra_matrix[j]= v;
  3523.                     }
  3524.                 }
  3525.  
  3526.                 /* load custom non intra matrix */
  3527.                 if(get_bits1(&s->gb)){
  3528.                     for(i=0; i<64; i++){
  3529.                         v= get_bits(&s->gb, 8);
  3530.                         if(v==0) break;
  3531.  
  3532.                         j= zigzag_direct[i];
  3533.                         s->inter_matrix[j]= v;
  3534.                         s->chroma_inter_matrix[j]= v;
  3535.                     }
  3536.  
  3537.                     /* replicate last value */
  3538.                     for(; i<64; i++){
  3539.                         j= zigzag_direct[i];
  3540.                         s->inter_matrix[j]= v;
  3541.                         s->chroma_inter_matrix[j]= v;
  3542.                     }
  3543.                 }
  3544.  
  3545.                 s->dct_unquantize= s->dct_unquantize_mpeg2;
  3546.  
  3547.                 // FIXME a bunch of grayscale shape things
  3548.             }else
  3549.                 s->dct_unquantize= s->dct_unquantize_h263;
  3550.  
  3551.             if(vo_ver_id != 1)
  3552.                  s->quarter_sample= get_bits1(&s->gb);
  3553.             else s->quarter_sample=0;
  3554.  
  3555.             if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
  3556.  
  3557.             s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
  3558.  
  3559.             s->data_partitioning= get_bits1(&s->gb);
  3560.             if(s->data_partitioning){
  3561.                 s->rvlc= get_bits1(&s->gb);
  3562.                 if(s->rvlc){
  3563.                     printf("reversible vlc not supported\n");
  3564.                 }
  3565.             }
  3566.             
  3567.             if(vo_ver_id != 1) {
  3568.                 s->new_pred= get_bits1(&s->gb);
  3569.                 if(s->new_pred){
  3570.                     printf("new pred not supported\n");
  3571.                     skip_bits(&s->gb, 2); /* requested upstream message type */
  3572.                     skip_bits1(&s->gb); /* newpred segment type */
  3573.                 }
  3574.                 s->reduced_res_vop= get_bits1(&s->gb);
  3575.                 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
  3576.             }
  3577.             else{
  3578.                 s->new_pred=0;
  3579.                 s->reduced_res_vop= 0;
  3580.             }
  3581.  
  3582.             s->scalability= get_bits1(&s->gb);
  3583.             if (s->scalability) {
  3584.                 printf("scalability not supported\n");
  3585.             }
  3586.         }
  3587. //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
  3588.         goto redo;
  3589.     } else if (startcode == 0x1b2) { //userdata
  3590.         char buf[256];
  3591.         int i;
  3592.         int e;
  3593.         int ver, build;
  3594.  
  3595. //printf("user Data %X\n", show_bits(&s->gb, 32));
  3596.         buf[0]= show_bits(&s->gb, 8);
  3597.         for(i=1; i<256; i++){
  3598.             buf[i]= show_bits(&s->gb, 16)&0xFF;
  3599.             if(buf[i]==0) break;
  3600.             skip_bits(&s->gb, 8);
  3601.         }
  3602.         buf[255]=0;
  3603.         e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
  3604.         if(e!=2)
  3605.             e=sscanf(buf, "DivX%db%d", &ver, &build);
  3606.         if(e==2){
  3607.             s->divx_version= ver;
  3608.             s->divx_build= build;
  3609.             if(s->picture_number==0){
  3610.                 printf("This file was encoded with DivX%d Build%d\n", ver, build);
  3611.                 if(ver==500 && build==413){
  3612.                     printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
  3613. #if 0
  3614.                 }else{
  3615.                     printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
  3616.                            "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
  3617. #endif
  3618.                 }
  3619.             }
  3620.         }
  3621. //printf("User Data: %s\n", buf);
  3622.         goto redo;
  3623.     } else if (startcode != 0x1b6) { //VOP
  3624.         goto redo;
  3625.     }
  3626.  
  3627.     s->pict_type = get_bits(&s->gb, 2) + I_TYPE;    /* pict type: I = 0 , P = 1 */
  3628. //if(s->pict_type!=I_TYPE) return FRAME_SKIPED;
  3629.     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
  3630.         printf("low_delay flag set, but shouldnt, clearing it\n");
  3631.         s->low_delay=0;
  3632.     }
  3633. // printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); 
  3634. //printf("%d", s->pict_type);
  3635.     time_incr=0;
  3636.     while (get_bits1(&s->gb) != 0) 
  3637.         time_incr++;
  3638.  
  3639.     check_marker(&s->gb, "before time_increment");
  3640.     time_increment= get_bits(&s->gb, s->time_increment_bits);
  3641. //printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
  3642.     if(s->pict_type!=B_TYPE){
  3643.         s->last_time_base= s->time_base;
  3644.         s->time_base+= time_incr;
  3645.         s->time= s->time_base*s->time_increment_resolution + time_increment;
  3646.         s->pp_time= s->time - s->last_non_b_time;
  3647.         s->last_non_b_time= s->time;
  3648.     }else{
  3649.         s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
  3650.         s->bp_time= s->last_non_b_time - s->time;
  3651.         if(s->pp_time <=s->bp_time){
  3652. //            printf("messed up order, seeking?, skiping current b frame\n");
  3653.             return FRAME_SKIPED;
  3654.         }
  3655.     }
  3656.  
  3657.     if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
  3658.         printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
  3659.         for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
  3660.             if(get_bits1(&s->gb)) break;
  3661.         }
  3662.         printf("my guess is %d bits ;)\n",s->time_increment_bits);
  3663.     }
  3664.     /* vop coded */
  3665.     if (get_bits1(&s->gb) != 1)
  3666.         goto redo;
  3667. //printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
  3668. //s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
  3669.     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
  3670.                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
  3671.         /* rounding type for motion estimation */
  3672.     s->no_rounding = get_bits1(&s->gb);
  3673.     } else {
  3674.     s->no_rounding = 0;
  3675.     }
  3676. //FIXME reduced res stuff
  3677.  
  3678.      if (s->shape != RECT_SHAPE) {
  3679.          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
  3680.              int width, height, hor_spat_ref, ver_spat_ref;
  3681.  
  3682.              width = get_bits(&s->gb, 13);
  3683.              skip_bits1(&s->gb);   /* marker */
  3684.              height = get_bits(&s->gb, 13);
  3685.              skip_bits1(&s->gb);   /* marker */
  3686.              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
  3687.              skip_bits1(&s->gb);   /* marker */
  3688.              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
  3689.          }
  3690.          skip_bits1(&s->gb); /* change_CR_disable */
  3691.  
  3692.          if (get_bits1(&s->gb) != 0) {
  3693.              skip_bits(&s->gb, 8); /* constant_alpha_value */
  3694.          }
  3695.      }
  3696. //FIXME complexity estimation stuff
  3697.      
  3698.      if (s->shape != BIN_ONLY_SHAPE) {
  3699.          int t;
  3700.          t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
  3701. //printf("threshold %d\n", t);
  3702.          //FIXME interlaced specific bits
  3703.      }
  3704.  
  3705.      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
  3706.          if(s->num_sprite_warping_points){
  3707.              mpeg4_decode_sprite_trajectory(s);
  3708.          }
  3709.          if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
  3710.          if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
  3711.      }
  3712.  
  3713.      if (s->shape != BIN_ONLY_SHAPE) {
  3714.          /* note: we do not use quant_precision to avoid problem if no
  3715.             MPEG4 vol header as it is found on some old opendivx
  3716.             movies */
  3717.          s->qscale = get_bits(&s->gb, 5);
  3718.          if(s->qscale==0){
  3719.              printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
  3720.              return -1; // makes no sense to continue, as there is nothing left from the image then
  3721.          }
  3722.   
  3723.          if (s->pict_type != I_TYPE) {
  3724.              s->f_code = get_bits(&s->gb, 3);    /* fcode_for */
  3725.              if(s->f_code==0){
  3726.                  printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
  3727.                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
  3728.              }
  3729.          }
  3730.          if (s->pict_type == B_TYPE) {
  3731.              s->b_code = get_bits(&s->gb, 3);
  3732. //printf("b-code %d\n", s->b_code);
  3733.          }
  3734. //printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
  3735.          if(!s->scalability){
  3736.              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
  3737.                  skip_bits1(&s->gb); // vop shape coding type
  3738.              }
  3739.          }
  3740.      }
  3741.      /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
  3742.      // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
  3743.      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
  3744.          dprintf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
  3745.          s->low_delay=1;
  3746.      }
  3747.  
  3748.      s->picture_number++; // better than pic number==0 allways ;)
  3749. //printf("done\n");
  3750.  
  3751.      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
  3752.      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
  3753.  
  3754.      return 0;
  3755. }
  3756.  
  3757. /* don't understand why they choose a different header ! */
  3758. int intel_h263_decode_picture_header(MpegEncContext *s)
  3759. {
  3760.     int format;
  3761.  
  3762.     /* picture header */
  3763.     if (get_bits(&s->gb, 22) != 0x20) {
  3764.         fprintf(stderr, "Bad picture start code\n");
  3765.         return -1;
  3766.     }
  3767.     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
  3768.  
  3769.     if (get_bits1(&s->gb) != 1) {
  3770.         fprintf(stderr, "Bad marker\n");
  3771.         return -1;    /* marker */
  3772.     }
  3773.     if (get_bits1(&s->gb) != 0) {
  3774.         fprintf(stderr, "Bad H263 id\n");
  3775.         return -1;    /* h263 id */
  3776.     }
  3777.     skip_bits1(&s->gb);    /* split screen off */
  3778.     skip_bits1(&s->gb);    /* camera  off */
  3779.     skip_bits1(&s->gb);    /* freeze picture release off */
  3780.  
  3781.     format = get_bits(&s->gb, 3);
  3782.     if (format != 7) {
  3783.         fprintf(stderr, "Intel H263 free format not supported\n");
  3784.         return -1;
  3785.     }
  3786.     s->h263_plus = 0;
  3787.  
  3788.     s->pict_type = I_TYPE + get_bits1(&s->gb);
  3789.     
  3790.     s->unrestricted_mv = get_bits1(&s->gb); 
  3791.     s->h263_long_vectors = s->unrestricted_mv;
  3792.  
  3793.     if (get_bits1(&s->gb) != 0) {
  3794.         fprintf(stderr, "SAC not supported\n");
  3795.         return -1;    /* SAC: off */
  3796.     }
  3797.     if (get_bits1(&s->gb) != 0) {
  3798.         fprintf(stderr, "Advanced Prediction Mode not supported\n");
  3799.         return -1;    /* advanced prediction mode: off */
  3800.     }
  3801.     if (get_bits1(&s->gb) != 0) {
  3802.         fprintf(stderr, "PB frame mode no supported\n");
  3803.         return -1;    /* PB frame mode */
  3804.     }
  3805.  
  3806.     /* skip unknown header garbage */
  3807.     skip_bits(&s->gb, 41);
  3808.  
  3809.     s->qscale = get_bits(&s->gb, 5);
  3810.     skip_bits1(&s->gb);    /* Continuous Presence Multipoint mode: off */
  3811.  
  3812.     /* PEI */
  3813.     while (get_bits1(&s->gb) != 0) {
  3814.         skip_bits(&s->gb, 8);
  3815.     }
  3816.     s->f_code = 1;
  3817.     return 0;
  3818. }
  3819.  
  3820.