falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
561 Commits
32 Branches
574MB
Tree: ee6f786146
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ee6f786146'
${ noResults }
FFmpeg/libavcodec/h263.c

2943 lines
97KB
Raw Blame History 

  1. /*

  2.  * H263/MPEG4 backend for ffmpeg encoder and decoder

  3.  * Copyright (c) 2000,2001 Gerard Lantau.

  4.  * H263+ support.

  5.  * Copyright (c) 2001 Juan J. Sierralta P.

  6.  *

  7.  * This program is free software; you can redistribute it and/or modify

  8.  * it under the terms of the GNU General Public License as published by

  9.  * the Free Software Foundation; either version 2 of the License, or

  10.  * (at your option) any later version.

  11.  *

  12.  * This program 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

  15.  * GNU General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU General Public License

  18.  * along with this program; if not, write to the Free Software

  19.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  20.  *

  21.  * ac prediction encoding & b-frame support by Michael Niedermayer <michaelni@gmx.at>

  22.  */

  23. #include "common.h"

  24. #include "dsputil.h"

  25. #include "avcodec.h"

  26. #include "mpegvideo.h"

  27. #include "h263data.h"

  28. #include "mpeg4data.h"

  29. 

  30. //rounded divison & shift

  31. #define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))

  32. #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))

  33. #define ABS(a) (((a)>=0)?(a):(-(a)))

  34. #define MAX(a,b) ((a) > (b) ? (a) : (b))

  35. #define MIN(a,b) ((a) < (b) ? (a) : (b))

  36. 

  37. static void h263_encode_block(MpegEncContext * s, DCTELEM * block,

  38. 			      int n);

  39. static void h263_encode_motion(MpegEncContext * s, int val, int fcode);

  40. static void h263p_encode_umotion(MpegEncContext * s, int val);

  41. static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,

  42. 			       int n, int dc, UINT8 *scan_table);

  43. static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);

  44. static int h263p_decode_umotion(MpegEncContext * s, int pred);

  45. static int h263_decode_block(MpegEncContext * s, DCTELEM * block,

  46.                              int n, int coded);

  47. static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,

  48.                               int n, int coded);

  49. static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);

  50. static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,

  51.                               int dir);

  52. static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);

  53. 

  54. extern UINT32 inverse[256];

  55. 

  56. static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];

  57. static UINT8 fcode_tab[MAX_MV*2+1];

  58. static UINT8 umv_fcode_tab[MAX_MV*2+1];

  59. 

  60. static UINT16 uni_DCtab_lum  [512][2];

  61. static UINT16 uni_DCtab_chrom[512][2];

  62. 

  63. int h263_get_picture_format(int width, int height)

  64. {

  65.     int format;

  66. 

  67.     if (width == 128 && height == 96)

  68. 	format = 1;

  69.     else if (width == 176 && height == 144)

  70. 	format = 2;

  71.     else if (width == 352 && height == 288)

  72. 	format = 3;

  73.     else if (width == 704 && height == 576)

  74. 	format = 4;

  75.     else if (width == 1408 && height == 1152)

  76. 	format = 5;

  77.     else

  78.         format = 7;

  79.     return format;

  80. }

  81. 

  82. void h263_encode_picture_header(MpegEncContext * s, int picture_number)

  83. {

  84.     int format;

  85. 

  86.     align_put_bits(&s->pb);

  87. 

  88.     /* Update the pointer to last GOB */

  89.     s->ptr_lastgob = pbBufPtr(&s->pb);

  90.     s->gob_number = 0;

  91. 

  92.     put_bits(&s->pb, 22, 0x20); /* PSC */

  93.     put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 

  94.                          s->frame_rate) & 0xff);

  95. 

  96.     put_bits(&s->pb, 1, 1);	/* marker */

  97.     put_bits(&s->pb, 1, 0);	/* h263 id */

  98.     put_bits(&s->pb, 1, 0);	/* split screen off */

  99.     put_bits(&s->pb, 1, 0);	/* camera  off */

  100.     put_bits(&s->pb, 1, 0);	/* freeze picture release off */

  101.     

  102.     format = h263_get_picture_format(s->width, s->height);

  103.     if (!s->h263_plus) {

  104.         /* H.263v1 */

  105.         put_bits(&s->pb, 3, format);

  106.         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));

  107.         /* By now UMV IS DISABLED ON H.263v1, since the restrictions

  108.         of H.263v1 UMV implies to check the predicted MV after

  109.         calculation of the current MB to see if we're on the limits */

  110.         put_bits(&s->pb, 1, 0);	/* unrestricted motion vector: off */

  111.         put_bits(&s->pb, 1, 0);	/* SAC: off */

  112.         put_bits(&s->pb, 1, 0);	/* advanced prediction mode: off */

  113.         put_bits(&s->pb, 1, 0);	/* not PB frame */

  114.         put_bits(&s->pb, 5, s->qscale);

  115.         put_bits(&s->pb, 1, 0);	/* Continuous Presence Multipoint mode: off */

  116.     } else {

  117.         /* H.263v2 */

  118.         /* H.263 Plus PTYPE */

  119.         put_bits(&s->pb, 3, 7);

  120.         put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */

  121.         if (format == 7)

  122.             put_bits(&s->pb,3,6); /* Custom Source Format */

  123.         else

  124.             put_bits(&s->pb, 3, format);

  125.             

  126.         put_bits(&s->pb,1,0); /* Custom PCF: off */

  127.         s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;

  128.         put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */

  129.         put_bits(&s->pb,1,0); /* SAC: off */

  130.         put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */

  131.         put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */

  132.         put_bits(&s->pb,1,0); /* Deblocking Filter: off */

  133.         put_bits(&s->pb,1,0); /* Slice Structured: off */

  134.         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */

  135.         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */

  136.         put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */

  137.         put_bits(&s->pb,1,0); /* Modified Quantization: off */

  138.         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */

  139.         put_bits(&s->pb,3,0); /* Reserved */

  140. 		

  141.         put_bits(&s->pb, 3, s->pict_type == P_TYPE);

  142. 		

  143.         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */

  144.         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */

  145.         put_bits(&s->pb,1,0); /* Rounding Type */

  146.         put_bits(&s->pb,2,0); /* Reserved */

  147.         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */

  148. 		

  149.         /* This should be here if PLUSPTYPE */

  150.         put_bits(&s->pb, 1, 0);	/* Continuous Presence Multipoint mode: off */

  151. 		

  152. 		if (format == 7) {

  153.             /* Custom Picture Format (CPFMT) */

  154. 		

  155.             put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */

  156.             put_bits(&s->pb,9,(s->width >> 2) - 1);

  157.             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */

  158.             put_bits(&s->pb,9,(s->height >> 2));

  159.         }

  160.         

  161.         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

  162.         if (s->umvplus)

  163.             put_bits(&s->pb,1,1); /* Limited according tables of Annex D */

  164.         put_bits(&s->pb, 5, s->qscale);

  165.     }

  166. 

  167.     put_bits(&s->pb, 1, 0);	/* no PEI */

  168. }

  169. 

  170. int h263_encode_gob_header(MpegEncContext * s, int mb_line)

  171. {

  172.     int pdif=0;

  173.     

  174.     /* Check to see if we need to put a new GBSC */

  175.     /* for RTP packetization                    */

  176.     if (s->rtp_mode) {

  177.         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;

  178.         if (pdif >= s->rtp_payload_size) {

  179.             /* Bad luck, packet must be cut before */

  180.             align_put_bits(&s->pb);

  181.             flush_put_bits(&s->pb);

  182.             /* Call the RTP callback to send the last GOB */

  183.             if (s->rtp_callback) {

  184.                 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;

  185.                 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);

  186.             }

  187.             s->ptr_lastgob = pbBufPtr(&s->pb);

  188.             put_bits(&s->pb, 17, 1); /* GBSC */

  189.             s->gob_number = mb_line / s->gob_index;

  190.             put_bits(&s->pb, 5, s->gob_number); /* GN */

  191.             put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */

  192.             put_bits(&s->pb, 5, s->qscale); /* GQUANT */

  193.             //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);

  194.             return pdif;

  195.        } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {

  196.            /* Cut the packet before we can't */

  197.            align_put_bits(&s->pb);

  198.            flush_put_bits(&s->pb);

  199.            /* Call the RTP callback to send the last GOB */

  200.            if (s->rtp_callback) {

  201.                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;

  202.                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);

  203.            }

  204.            s->ptr_lastgob = pbBufPtr(&s->pb);

  205.            put_bits(&s->pb, 17, 1); /* GBSC */

  206.            s->gob_number = mb_line / s->gob_index;

  207.            put_bits(&s->pb, 5, s->gob_number); /* GN */

  208.            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */

  209.            put_bits(&s->pb, 5, s->qscale); /* GQUANT */

  210.            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);

  211.            return pdif;

  212.        }

  213.    }

  214.    return 0;

  215. }

  216. 

  217. static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])

  218. {

  219.     int score0=0, score1=0;

  220.     int i, n;

  221. 

  222.     for(n=0; n<6; n++){

  223.         INT16 *ac_val, *ac_val1;

  224. 

  225.         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;

  226.         ac_val1= ac_val;

  227.         if(dir[n]){

  228.             ac_val-= s->block_wrap[n]*16;

  229.             for(i=1; i<8; i++){

  230.                 const int level= block[n][block_permute_op(i   )];

  231.                 score0+= ABS(level);

  232.                 score1+= ABS(level - ac_val[i+8]);

  233.                 ac_val1[i  ]=    block[n][block_permute_op(i<<3)];

  234.                 ac_val1[i+8]= level;

  235.             }

  236.         }else{

  237.             ac_val-= 16;

  238.             for(i=1; i<8; i++){

  239.                 const int level= block[n][block_permute_op(i<<3)];

  240.                 score0+= ABS(level);

  241.                 score1+= ABS(level - ac_val[i]);

  242.                 ac_val1[i  ]= level;

  243.                 ac_val1[i+8]=    block[n][block_permute_op(i   )];

  244.             }

  245.         }

  246.     }

  247. 

  248.     return score0 > score1 ? 1 : 0;    

  249. }

  250. 

  251. void mpeg4_encode_mb(MpegEncContext * s,

  252. 		    DCTELEM block[6][64],

  253. 		    int motion_x, int motion_y)

  254. {

  255.     int cbpc, cbpy, i, pred_x, pred_y;

  256.     int bits;

  257.     

  258.     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);

  259.     if (!s->mb_intra) {

  260.         /* compute cbp */

  261.         int cbp = 0;

  262.         for (i = 0; i < 6; i++) {

  263.             if (s->block_last_index[i] >= 0)

  264.                 cbp |= 1 << (5 - i);

  265.         }

  266. 

  267.         if(s->pict_type==B_TYPE){

  268.             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */

  269.             int mb_type=  mb_type_table[s->mv_dir];

  270.             

  271.             if(s->mb_x==0){

  272.                 s->last_mv[0][0][0]= 

  273.                 s->last_mv[0][0][1]= 

  274.                 s->last_mv[1][0][0]= 

  275.                 s->last_mv[1][0][1]= 0;

  276.             }

  277. 

  278.             /* nothing to do if this MB was skiped in the next P Frame */

  279.             if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){

  280.                 s->skip_count++;

  281.                 s->mv[0][0][0]= 

  282.                 s->mv[0][0][1]= 

  283.                 s->mv[1][0][0]= 

  284.                 s->mv[1][0][1]= 0;

  285.                 s->mv_dir= MV_DIR_FORWARD; //doesnt matter

  286.                 return;

  287.             }

  288. 

  289.             if ((cbp | motion_x | motion_y | mb_type) ==0) {

  290.                 /* direct MB with MV={0,0} */

  291.                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */

  292.                 s->misc_bits++;

  293.                 s->last_bits++;

  294.                 s->skip_count++;

  295.                 return;

  296.             }

  297.             put_bits(&s->pb, 1, 0);	/* mb coded modb1=0 */

  298.             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge

  299.             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)

  300.             if(cbp) put_bits(&s->pb, 6, cbp);

  301.             

  302.             if(cbp && mb_type)

  303.                 put_bits(&s->pb, 1, 0); /* no q-scale change */

  304. 

  305.             bits= get_bit_count(&s->pb);

  306.             s->misc_bits+= bits - s->last_bits;

  307.             s->last_bits=bits;

  308. 

  309.             switch(mb_type)

  310.             {

  311.             case 0: /* direct */

  312.                 h263_encode_motion(s, motion_x, 1);

  313.                 h263_encode_motion(s, motion_y, 1);                

  314.                 break;

  315.             case 1: /* bidir */

  316.                 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);

  317.                 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);

  318.                 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);

  319.                 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);

  320.                 s->last_mv[0][0][0]= s->mv[0][0][0];

  321.                 s->last_mv[0][0][1]= s->mv[0][0][1];

  322.                 s->last_mv[1][0][0]= s->mv[1][0][0];

  323.                 s->last_mv[1][0][1]= s->mv[1][0][1];

  324.                 break;

  325.             case 2: /* backward */

  326.                 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);

  327.                 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);

  328.                 s->last_mv[1][0][0]= motion_x;

  329.                 s->last_mv[1][0][1]= motion_y;

  330.                 break;

  331.             case 3: /* forward */

  332.                 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);

  333.                 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);

  334.                 s->last_mv[0][0][0]= motion_x;

  335.                 s->last_mv[0][0][1]= motion_y;

  336.                 break;

  337.             default:

  338.                 printf("unknown mb type\n");

  339.                 return;

  340.             }

  341.             bits= get_bit_count(&s->pb);

  342.             s->mv_bits+= bits - s->last_bits;

  343.             s->last_bits=bits;

  344. 

  345.             /* encode each block */

  346.             for (i = 0; i < 6; i++) {

  347.                 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);

  348.             }

  349.             bits= get_bit_count(&s->pb);

  350.             s->p_tex_bits+= bits - s->last_bits;

  351.             s->last_bits=bits;

  352.         }else{ /* s->pict_type==B_TYPE */

  353.             if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {

  354.                 /* check if the B frames can skip it too, as we must skip it if we skip here 

  355.                    why didnt they just compress the skip-mb bits instead of reusing them ?! */

  356.                 if(s->max_b_frames>0){

  357.                     int i;

  358.                     const int offset= (s->mb_x + s->mb_y*s->linesize)*16;

  359.                     uint8_t *p_pic= s->new_picture[0] + offset;

  360.                     s->mb_skiped=1;

  361.                     for(i=0; i<s->max_b_frames; i++){

  362.                         uint8_t *b_pic= s->coded_order[i+1].picture[0] + offset;

  363.                         int diff= pix_abs16x16(p_pic, b_pic, s->linesize);

  364.                         if(diff>s->qscale*70){

  365.                             s->mb_skiped=0;

  366.                             break;

  367.                         }

  368.                     }

  369.                 }else

  370.                     s->mb_skiped=1; 

  371. 

  372.                 if(s->mb_skiped==1){

  373.                     /* skip macroblock */

  374.                     put_bits(&s->pb, 1, 1);

  375.                     s->misc_bits++;

  376.                     s->last_bits++;

  377.                     s->skip_count++;

  378.                     return;

  379.                 }

  380.             }

  381.             put_bits(&s->pb, 1, 0);	/* mb coded */

  382.             if(s->mv_type==MV_TYPE_16X16){

  383.                 cbpc = cbp & 3;

  384.                 put_bits(&s->pb,

  385.                         inter_MCBPC_bits[cbpc],

  386.                         inter_MCBPC_code[cbpc]);

  387.                 cbpy = cbp >> 2;

  388.                 cbpy ^= 0xf;

  389.                 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);

  390.                     

  391.                 bits= get_bit_count(&s->pb);

  392.                 s->misc_bits+= bits - s->last_bits;

  393.                 s->last_bits=bits;

  394. 

  395.                 /* motion vectors: 16x16 mode */

  396.                 h263_pred_motion(s, 0, &pred_x, &pred_y);

  397.             

  398.                 h263_encode_motion(s, motion_x - pred_x, s->f_code);

  399.                 h263_encode_motion(s, motion_y - pred_y, s->f_code);

  400.             }else{

  401.                 cbpc = (cbp & 3)+16;

  402.                 put_bits(&s->pb,

  403.                         inter_MCBPC_bits[cbpc],

  404.                         inter_MCBPC_code[cbpc]);

  405.                 cbpy = cbp >> 2;

  406.                 cbpy ^= 0xf;

  407.                 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);

  408. 

  409.                 bits= get_bit_count(&s->pb);

  410.                 s->misc_bits+= bits - s->last_bits;

  411.                 s->last_bits=bits;

  412. 

  413.                 for(i=0; i<4; i++){

  414.                     /* motion vectors: 8x8 mode*/

  415.                     h263_pred_motion(s, i, &pred_x, &pred_y);

  416. 

  417.                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);

  418.                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);

  419.                 }

  420.             }

  421.             bits= get_bit_count(&s->pb);

  422.             s->mv_bits+= bits - s->last_bits;

  423.             s->last_bits=bits;

  424. 

  425.             /* encode each block */

  426.             for (i = 0; i < 6; i++) {

  427.                 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);

  428.             }

  429.             bits= get_bit_count(&s->pb);

  430.             s->p_tex_bits+= bits - s->last_bits;

  431.             s->last_bits=bits;

  432.             s->p_count++;

  433.         }

  434.     } else {

  435.         int cbp;

  436.         int dc_diff[6];   //dc values with the dc prediction subtracted 

  437.         int dir[6];  //prediction direction

  438.         int zigzag_last_index[6];

  439.         UINT8 *scan_table[6];

  440. 

  441.         for(i=0; i<6; i++){

  442.             const int level= block[i][0];

  443.             UINT16 *dc_ptr;

  444. 

  445.             dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);

  446.             if (i < 4) {

  447.                 *dc_ptr = level * s->y_dc_scale;

  448.             } else {

  449.                 *dc_ptr = level * s->c_dc_scale;

  450.             }

  451.         }

  452. 

  453.         s->ac_pred= decide_ac_pred(s, block, dir);

  454. 

  455.         if(s->ac_pred){

  456.             for(i=0; i<6; i++){

  457.                 UINT8 *st;

  458.                 int last_index;

  459. 

  460.                 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);

  461.                 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */

  462.                 else           st = ff_alternate_horizontal_scan; /* top */

  463. 

  464.                 for(last_index=63; last_index>=0; last_index--) //FIXME optimize

  465.                     if(block[i][st[last_index]]) break;

  466.                 zigzag_last_index[i]= s->block_last_index[i];

  467.                 s->block_last_index[i]= last_index;

  468.                 scan_table[i]= st;

  469.             }

  470.         }else{

  471.             for(i=0; i<6; i++)

  472.                 scan_table[i]= zigzag_direct;

  473.         }

  474. 

  475.         /* compute cbp */

  476.         cbp = 0;

  477.         for (i = 0; i < 6; i++) {

  478.             if (s->block_last_index[i] >= 1)

  479.                 cbp |= 1 << (5 - i);

  480.         }

  481. 

  482.         cbpc = cbp & 3;

  483.         if (s->pict_type == I_TYPE) {

  484.             put_bits(&s->pb,

  485.                 intra_MCBPC_bits[cbpc],

  486.                 intra_MCBPC_code[cbpc]);

  487.         } else {

  488.             put_bits(&s->pb, 1, 0);	/* mb coded */

  489.             put_bits(&s->pb,

  490.                 inter_MCBPC_bits[cbpc + 4],

  491.                 inter_MCBPC_code[cbpc + 4]);

  492.         }

  493.         put_bits(&s->pb, 1, s->ac_pred);

  494.         cbpy = cbp >> 2;

  495.         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);

  496. 

  497.         bits= get_bit_count(&s->pb);

  498.         s->misc_bits+= bits - s->last_bits;

  499.         s->last_bits=bits;

  500. 

  501.         /* encode each block */

  502.         for (i = 0; i < 6; i++) {

  503.             mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);

  504.         }

  505. 

  506.         bits= get_bit_count(&s->pb);

  507.         s->i_tex_bits+= bits - s->last_bits;

  508.         s->last_bits=bits;

  509.         s->i_count++;

  510. 

  511.         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */

  512.         if(s->ac_pred){

  513.             for(i=0; i<6; i++){

  514.                 int j;    

  515.                 INT16 *ac_val;

  516. 

  517.                 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;

  518. 

  519.                 if(dir[i]){

  520.                     for(j=1; j<8; j++) 

  521.                         block[i][block_permute_op(j   )]= ac_val[j+8];

  522.                 }else{

  523.                     for(j=1; j<8; j++) 

  524.                         block[i][block_permute_op(j<<3)]= ac_val[j  ];

  525.                 }

  526.                 s->block_last_index[i]= zigzag_last_index[i];

  527.             }

  528.         }

  529.     }

  530. }

  531. 

  532. void h263_encode_mb(MpegEncContext * s,

  533. 		    DCTELEM block[6][64],

  534. 		    int motion_x, int motion_y)

  535. {

  536.     int cbpc, cbpy, i, cbp, pred_x, pred_y;

  537.    

  538.     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);

  539.     if (!s->mb_intra) {

  540. 	   /* compute cbp */

  541.         cbp = 0;

  542.         for (i = 0; i < 6; i++) {

  543.             if (s->block_last_index[i] >= 0)

  544.                 cbp |= 1 << (5 - i);

  545.         }

  546.         if ((cbp | motion_x | motion_y) == 0) {

  547.             /* skip macroblock */

  548.             put_bits(&s->pb, 1, 1);

  549.             return;

  550.         }

  551.         put_bits(&s->pb, 1, 0);    /* mb coded */

  552.         cbpc = cbp & 3;

  553.         put_bits(&s->pb,

  554.                  inter_MCBPC_bits[cbpc],

  555.                  inter_MCBPC_code[cbpc]);

  556.         cbpy = cbp >> 2;

  557.         cbpy ^= 0xf;

  558.         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);

  559. 

  560.        /* motion vectors: 16x16 mode only now */

  561.         h263_pred_motion(s, 0, &pred_x, &pred_y);

  562.       

  563.         if (!s->umvplus) {  

  564.             h263_encode_motion(s, motion_x - pred_x, s->f_code);

  565.             h263_encode_motion(s, motion_y - pred_y, s->f_code);

  566.         }

  567.         else {

  568.             h263p_encode_umotion(s, motion_x - pred_x);

  569.             h263p_encode_umotion(s, motion_y - pred_y);

  570.             if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))

  571.             /* To prevent Start Code emulation */

  572.                 put_bits(&s->pb,1,1);

  573.         }

  574.    } else {

  575. 	/* compute cbp */

  576. 	cbp = 0;

  577. 	for (i = 0; i < 6; i++) {

  578. 	    if (s->block_last_index[i] >= 1)

  579. 		cbp |= 1 << (5 - i);

  580. 	}

  581. 

  582. 	cbpc = cbp & 3;

  583. 	if (s->pict_type == I_TYPE) {

  584. 	    put_bits(&s->pb,

  585. 		     intra_MCBPC_bits[cbpc],

  586. 		     intra_MCBPC_code[cbpc]);

  587. 	} else {

  588. 	    put_bits(&s->pb, 1, 0);	/* mb coded */

  589. 	    put_bits(&s->pb,

  590. 		     inter_MCBPC_bits[cbpc + 4],

  591. 		     inter_MCBPC_code[cbpc + 4]);

  592. 	}

  593. 	if (s->h263_pred) {

  594. 	    /* XXX: currently, we do not try to use ac prediction */

  595. 	    put_bits(&s->pb, 1, 0);	/* no ac prediction */

  596. 	}

  597. 	cbpy = cbp >> 2;

  598. 	put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);

  599.     }

  600. 

  601.     /* encode each block */

  602.     for (i = 0; i < 6; i++) {

  603.         h263_encode_block(s, block[i], i);

  604.     }

  605. }

  606. 

  607. void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)

  608. {

  609.     int x, y, wrap, a, c, pred_dc, scale, i;

  610.     INT16 *dc_val, *ac_val, *ac_val1;

  611. 

  612.     /* find prediction */

  613.     if (n < 4) {

  614.         x = 2 * s->mb_x + 1 + (n & 1);

  615.         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);

  616.         wrap = s->mb_width * 2 + 2;

  617.         dc_val = s->dc_val[0];

  618.         ac_val = s->ac_val[0][0];

  619.         scale = s->y_dc_scale;

  620.     } else {

  621.         x = s->mb_x + 1;

  622.         y = s->mb_y + 1;

  623.         wrap = s->mb_width + 2;

  624.         dc_val = s->dc_val[n - 4 + 1];

  625.         ac_val = s->ac_val[n - 4 + 1][0];

  626.         scale = s->c_dc_scale;

  627.     }

  628.     

  629.     ac_val += ((y) * wrap + (x)) * 16;

  630.     ac_val1 = ac_val;

  631.     

  632.     /* B C

  633.      * A X 

  634.      */

  635.     a = dc_val[(x - 1) + (y) * wrap];

  636.     c = dc_val[(x) + (y - 1) * wrap];

  637.     

  638.     pred_dc = 1024;

  639.     if (s->ac_pred) {

  640.         if (s->h263_aic_dir) {

  641.             /* left prediction */

  642.             if (a != 1024) {

  643.                 ac_val -= 16;

  644.                 for(i=1;i<8;i++) {

  645.                     block[block_permute_op(i*8)] += ac_val[i];

  646.                 }

  647.                 pred_dc = a;

  648.             }

  649.         } else {

  650.             /* top prediction */

  651.             if (c != 1024) {

  652.                 ac_val -= 16 * wrap;

  653.                 for(i=1;i<8;i++) {

  654.                     block[block_permute_op(i)] += ac_val[i + 8];

  655.                 }

  656.                 pred_dc = c;

  657.             }

  658.         }

  659.     } else {

  660.         /* just DC prediction */

  661.         if (a != 1024 && c != 1024)

  662.             pred_dc = (a + c) >> 1;

  663.         else if (a != 1024)

  664.             pred_dc = a;

  665.         else

  666.             pred_dc = c;

  667.     }

  668.     

  669.     /* we assume pred is positive */

  670.     block[0]=block[0]*scale + pred_dc;

  671.     

  672.     if (block[0] < 0)

  673.         block[0] = 0;

  674.     else if (!(block[0] & 1))

  675.         block[0]++;

  676.     

  677.     /* Update AC/DC tables */

  678.     dc_val[(x) + (y) * wrap] = block[0];

  679.     

  680.     /* left copy */

  681.     for(i=1;i<8;i++)

  682.         ac_val1[i] = block[block_permute_op(i * 8)];

  683.     /* top copy */

  684.     for(i=1;i<8;i++)

  685.         ac_val1[8 + i] = block[block_permute_op(i)];

  686. }

  687. 

  688. INT16 *h263_pred_motion(MpegEncContext * s, int block, 

  689.                         int *px, int *py)

  690. {

  691.     int xy, wrap;

  692.     INT16 *A, *B, *C, *mot_val;

  693.     static const int off[4]= {2, 1, 1, -1};

  694. 

  695.     wrap = s->block_wrap[0];

  696.     xy = s->block_index[block];

  697. 

  698.     mot_val = s->motion_val[xy];

  699. 

  700.     /* special case for first line */

  701.     if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) {

  702.         A = s->motion_val[xy - 1];

  703.         *px = A[0];

  704.         *py = A[1];

  705.     } else {

  706.         A = s->motion_val[xy - 1];

  707.         B = s->motion_val[xy - wrap];

  708.         C = s->motion_val[xy + off[block] - wrap];

  709.         *px = mid_pred(A[0], B[0], C[0]);

  710.         *py = mid_pred(A[1], B[1], C[1]);

  711.     }

  712.     return mot_val;

  713. }

  714. 

  715. static void h263_encode_motion(MpegEncContext * s, int val, int f_code)

  716. {

  717.     int range, l, m, bit_size, sign, code, bits;

  718. 

  719.     if (val == 0) {

  720.         /* zero vector */

  721.         code = 0;

  722.         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);

  723.     } else {

  724.         bit_size = f_code - 1;

  725.         range = 1 << bit_size;

  726.         /* modulo encoding */

  727.         l = range * 32;

  728.         m = 2 * l;

  729.         if (val < -l) {

  730.             val += m;

  731.         } else if (val >= l) {

  732.             val -= m;

  733.         }

  734. 

  735.         if (val >= 0) {

  736.             sign = 0;

  737.         } else {

  738.             val = -val;

  739.             sign = 1;

  740.         }

  741.         val--;

  742.         code = (val >> bit_size) + 1;

  743.         bits = val & (range - 1);

  744. 

  745.         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 

  746.         if (bit_size > 0) {

  747.             put_bits(&s->pb, bit_size, bits);

  748.         }

  749.     }

  750. }

  751. 

  752. /* Encode MV differences on H.263+ with Unrestricted MV mode */

  753. static void h263p_encode_umotion(MpegEncContext * s, int val)

  754. {

  755.     short sval = 0; 

  756.     short i = 0;

  757.     short n_bits = 0;

  758.     short temp_val;

  759.     int code = 0;

  760.     int tcode;

  761.     

  762.     if ( val == 0)

  763.         put_bits(&s->pb, 1, 1);

  764.     else if (val == 1)

  765.         put_bits(&s->pb, 3, 0);

  766.     else if (val == -1)

  767.         put_bits(&s->pb, 3, 2);

  768.     else {

  769.         

  770.         sval = ((val < 0) ? (short)(-val):(short)val);

  771.         temp_val = sval;

  772.         

  773.         while (temp_val != 0) {

  774.             temp_val = temp_val >> 1;

  775.             n_bits++;

  776.         }

  777.         

  778.         i = n_bits - 1;

  779.         while (i > 0) {

  780.             tcode = (sval & (1 << (i-1))) >> (i-1);

  781.             tcode = (tcode << 1) | 1;

  782.             code = (code << 2) | tcode;

  783.             i--;

  784.         }

  785.         code = ((code << 1) | (val < 0)) << 1;

  786.         put_bits(&s->pb, (2*n_bits)+1, code);

  787.         //printf("\nVal = %d\tCode = %d", sval, code);

  788.     }

  789. }

  790. 

  791. static void init_mv_penalty_and_fcode(MpegEncContext *s)

  792. {

  793.     int f_code;

  794.     int mv;

  795.     for(f_code=1; f_code<=MAX_FCODE; f_code++){

  796.         for(mv=-MAX_MV; mv<=MAX_MV; mv++){

  797.             int len;

  798. 

  799.             if(mv==0) len= mvtab[0][1];

  800.             else{

  801.                 int val, bit_size, range, code;

  802. 

  803.                 bit_size = s->f_code - 1;

  804.                 range = 1 << bit_size;

  805. 

  806.                 val=mv;

  807.                 if (val < 0) 

  808.                     val = -val;

  809.                 val--;

  810.                 code = (val >> bit_size) + 1;

  811.                 if(code<33){

  812.                     len= mvtab[code][1] + 1 + bit_size;

  813.                 }else{

  814.                     len= mvtab[32][1] + 2 + bit_size;

  815.                 }

  816.             }

  817. 

  818.             mv_penalty[f_code][mv+MAX_MV]= len;

  819.         }

  820.     }

  821. 

  822.     for(f_code=MAX_FCODE; f_code>0; f_code--){

  823.         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){

  824.             fcode_tab[mv+MAX_MV]= f_code;

  825.         }

  826.     }

  827. 

  828.     for(mv=0; mv<MAX_MV*2+1; mv++){

  829.         umv_fcode_tab[mv]= 1;

  830.     }

  831. }

  832. 

  833. static void init_uni_dc_tab()

  834. {

  835.     int level, uni_code, uni_len;

  836. 

  837.     for(level=-256; level<256; level++){

  838.         int size, v, l;

  839.         /* find number of bits */

  840.         size = 0;

  841.         v = abs(level);

  842.         while (v) {

  843.             v >>= 1;

  844. 	    size++;

  845.         }

  846. 

  847.         if (level < 0)

  848.             l= (-level) ^ ((1 << size) - 1);

  849.         else

  850.             l= level;

  851. 

  852.         /* luminance */

  853.         uni_code= DCtab_lum[size][0];

  854.         uni_len = DCtab_lum[size][1];

  855. 

  856.         if (size > 0) {

  857.             uni_code<<=size; uni_code|=l;

  858.             uni_len+=size;

  859.             if (size > 8){

  860.                 uni_code<<=1; uni_code|=1;

  861.                 uni_len++;

  862.             }

  863.         }

  864.         uni_DCtab_lum[level+256][0]= uni_code;

  865.         uni_DCtab_lum[level+256][1]= uni_len;

  866. 

  867.         /* chrominance */

  868.         uni_code= DCtab_chrom[size][0];

  869.         uni_len = DCtab_chrom[size][1];

  870.         

  871.         if (size > 0) {

  872.             uni_code<<=size; uni_code|=l;

  873.             uni_len+=size;

  874.             if (size > 8){

  875.                 uni_code<<=1; uni_code|=1;

  876.                 uni_len++;

  877.             }

  878.         }

  879.         uni_DCtab_chrom[level+256][0]= uni_code;

  880.         uni_DCtab_chrom[level+256][1]= uni_len;

  881. 

  882.     }

  883. }

  884. 

  885. void h263_encode_init(MpegEncContext *s)

  886. {

  887.     static int done = 0;

  888. 

  889.     if (!done) {

  890.         done = 1;

  891. 

  892.         init_uni_dc_tab();

  893. 

  894.         init_rl(&rl_inter);

  895.         init_rl(&rl_intra);

  896. 

  897.         init_mv_penalty_and_fcode(s);

  898.     }

  899.     s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p

  900.     

  901.     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME

  902.     if(s->h263_plus) s->fcode_tab= umv_fcode_tab;

  903.     else if(s->h263_pred && !s->h263_msmpeg4) s->fcode_tab= fcode_tab;

  904. }

  905. 

  906. static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)

  907. {

  908.     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;

  909.     int code;

  910.     RLTable *rl = &rl_inter;

  911. 

  912.     if (s->mb_intra) {

  913.         /* DC coef */

  914. 	    level = block[0];

  915.         /* 255 cannot be represented, so we clamp */

  916.         if (level > 254) {

  917.             level = 254;

  918.             block[0] = 254;

  919.         }

  920.         /* 0 cannot be represented also */

  921.         else if (!level) {

  922.             level = 1;

  923.             block[0] = 1;

  924.         }

  925. 	    if (level == 128)

  926. 	        put_bits(&s->pb, 8, 0xff);

  927. 	    else

  928. 	        put_bits(&s->pb, 8, level & 0xff);

  929. 	    i = 1;

  930.     } else {

  931. 	    i = 0;

  932.     }

  933. 

  934.     /* AC coefs */

  935.     last_index = s->block_last_index[n];

  936.     last_non_zero = i - 1;

  937.     for (; i <= last_index; i++) {

  938. 	j = zigzag_direct[i];

  939. 	level = block[j];

  940. 	if (level) {

  941. 	    run = i - last_non_zero - 1;

  942. 	    last = (i == last_index);

  943. 	    sign = 0;

  944. 	    slevel = level;

  945. 	    if (level < 0) {

  946. 		sign = 1;

  947. 		level = -level;

  948. 	    }

  949.             code = get_rl_index(rl, last, run, level);

  950.             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);

  951.             if (code == rl->n) {

  952.                 put_bits(&s->pb, 1, last);

  953.                 put_bits(&s->pb, 6, run);

  954.                 put_bits(&s->pb, 8, slevel & 0xff);

  955.             } else {

  956.                 put_bits(&s->pb, 1, sign);

  957.             }

  958. 	    last_non_zero = i;

  959. 	}

  960.     }

  961. }

  962. 

  963. /***************************************************/

  964. 

  965. static void mpeg4_stuffing(PutBitContext * pbc)

  966. {

  967.     int length;

  968.     put_bits(pbc, 1, 0);

  969.     length= (-get_bit_count(pbc))&7;

  970.     put_bits(pbc, length, (1<<length)-1);

  971. }

  972. 

  973. static void put_string(PutBitContext * pbc, char *s)

  974. {

  975.     while(*s){

  976.         put_bits(pbc, 8, *s);

  977.         s++;

  978.     }

  979.     put_bits(pbc, 8, 0);

  980. }

  981. 

  982. /* must be called before writing the header */

  983. void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){

  984.     int time_div, time_mod;

  985. 

  986.     if(s->pict_type==I_TYPE){ //we will encode a vol header

  987.         s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);

  988.         if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;

  989. 

  990.         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;

  991.     }

  992. 

  993.     s->time= picture_number*(int64_t)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;

  994.     time_div= s->time/s->time_increment_resolution;

  995.     time_mod= s->time%s->time_increment_resolution;

  996. 

  997.     if(s->pict_type==B_TYPE){

  998.         s->bp_time= s->last_non_b_time - s->time;

  999.     }else{

  1000.         s->last_time_base= s->time_base;

  1001.         s->time_base= time_div;

  1002.         s->pp_time= s->time - s->last_non_b_time;

  1003.         s->last_non_b_time= s->time;

  1004.     }

  1005. }

  1006. 

  1007. static void mpeg4_encode_vol_header(MpegEncContext * s)

  1008. {

  1009.     int vo_ver_id=1; //must be 2 if we want GMC or q-pel

  1010.     char buf[255];

  1011.     

  1012.     if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);

  1013.     put_bits(&s->pb, 16, 0);

  1014.     put_bits(&s->pb, 16, 0x100);        /* video obj */

  1015.     put_bits(&s->pb, 16, 0);

  1016.     put_bits(&s->pb, 16, 0x120);        /* video obj layer */

  1017. 

  1018.     put_bits(&s->pb, 1, 0);		/* random access vol */

  1019.     put_bits(&s->pb, 8, 1);		/* video obj type indication= simple obj */

  1020.     put_bits(&s->pb, 1, 1);		/* is obj layer id= yes */

  1021.       put_bits(&s->pb, 4, vo_ver_id);	/* is obj layer ver id */

  1022.       put_bits(&s->pb, 3, 1);		/* is obj layer priority */

  1023.     if(s->aspect_ratio_info) 

  1024.         put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */

  1025.     else

  1026.         put_bits(&s->pb, 4, 1);		/* aspect ratio info= sqare pixel */

  1027.     put_bits(&s->pb, 1, 0);		/* vol control parameters= no */

  1028.     put_bits(&s->pb, 2, RECT_SHAPE);	/* vol shape= rectangle */

  1029.     put_bits(&s->pb, 1, 1);		/* marker bit */

  1030.     

  1031.     put_bits(&s->pb, 16, s->time_increment_resolution);

  1032.     if (s->time_increment_bits < 1)

  1033.         s->time_increment_bits = 1;

  1034.     put_bits(&s->pb, 1, 1);		/* marker bit */

  1035.     put_bits(&s->pb, 1, 0);		/* fixed vop rate=no */

  1036.     put_bits(&s->pb, 1, 1);		/* marker bit */

  1037.     put_bits(&s->pb, 13, s->width);	/* vol width */

  1038.     put_bits(&s->pb, 1, 1);		/* marker bit */

  1039.     put_bits(&s->pb, 13, s->height);	/* vol height */

  1040.     put_bits(&s->pb, 1, 1);		/* marker bit */

  1041.     put_bits(&s->pb, 1, 0);		/* interlace */

  1042.     put_bits(&s->pb, 1, 1);		/* obmc disable */

  1043.     if (vo_ver_id == 1) {

  1044.         put_bits(&s->pb, 1, s->vol_sprite_usage=0);		/* sprite enable */

  1045.     }else{ /* vo_ver_id == 2 */

  1046.         put_bits(&s->pb, 2, s->vol_sprite_usage=0);		/* sprite enable */

  1047.     }

  1048.     put_bits(&s->pb, 1, 0);		/* not 8 bit */

  1049.     put_bits(&s->pb, 1, 0);		/* quant type= h263 style*/

  1050.     if (vo_ver_id != 1)

  1051.         put_bits(&s->pb, 1, s->quarter_sample=0);

  1052.     put_bits(&s->pb, 1, 1);		/* complexity estimation disable */

  1053.     put_bits(&s->pb, 1, 1);		/* resync marker disable */

  1054.     put_bits(&s->pb, 1, 0);		/* data partitioned */

  1055.     if (vo_ver_id != 1){

  1056.         put_bits(&s->pb, 1, 0);		/* newpred */

  1057.         put_bits(&s->pb, 1, 0);		/* reduced res vop */

  1058.     }

  1059.     put_bits(&s->pb, 1, 0);		/* scalability */

  1060. 

  1061.     mpeg4_stuffing(&s->pb);

  1062.     put_bits(&s->pb, 16, 0);

  1063.     put_bits(&s->pb, 16, 0x1B2);	/* user_data */

  1064.     sprintf(buf, "FFmpeg v%s / libavcodec build: %s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);

  1065.     put_string(&s->pb, buf);

  1066. 

  1067.     s->no_rounding = 0;

  1068. }

  1069. 

  1070. /* write mpeg4 VOP header */

  1071. void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)

  1072. {

  1073.     int time_incr;

  1074.     int time_div, time_mod;

  1075.     

  1076.     if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);

  1077.     

  1078. //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);

  1079.     

  1080.     if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);

  1081.     put_bits(&s->pb, 16, 0);	        /* vop header */

  1082.     put_bits(&s->pb, 16, 0x1B6);	/* vop header */

  1083.     put_bits(&s->pb, 2, s->pict_type - 1);	/* pict type: I = 0 , P = 1 */

  1084. 

  1085.     time_div= s->time/s->time_increment_resolution;

  1086.     time_mod= s->time%s->time_increment_resolution;

  1087.     time_incr= time_div - s->last_time_base;

  1088.     while(time_incr--)

  1089.         put_bits(&s->pb, 1, 1);

  1090.         

  1091.     put_bits(&s->pb, 1, 0);

  1092. 

  1093.     put_bits(&s->pb, 1, 1);	/* marker */

  1094.     put_bits(&s->pb, s->time_increment_bits, time_mod);	/* time increment */

  1095.     put_bits(&s->pb, 1, 1);	/* marker */

  1096.     put_bits(&s->pb, 1, 1);	/* vop coded */

  1097.     if (    s->pict_type == P_TYPE 

  1098.         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {

  1099.         s->no_rounding ^= 1;

  1100. 	put_bits(&s->pb, 1, s->no_rounding);	/* rounding type */

  1101.     }

  1102.     put_bits(&s->pb, 3, 0);	/* intra dc VLC threshold */

  1103.     //FIXME sprite stuff

  1104. 

  1105.     put_bits(&s->pb, 5, s->qscale);

  1106. 

  1107.     if (s->pict_type != I_TYPE)

  1108. 	put_bits(&s->pb, 3, s->f_code);	/* fcode_for */

  1109.     if (s->pict_type == B_TYPE)

  1110. 	put_bits(&s->pb, 3, s->b_code);	/* fcode_back */

  1111.     //    printf("****frame %d\n", picture_number);

  1112. }

  1113. 

  1114. void h263_dc_scale(MpegEncContext * s)

  1115. {

  1116. #if 1

  1117.     const static UINT8 y_tab[32]={

  1118.     //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

  1119.         0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46

  1120.     };

  1121.     const static UINT8 c_tab[32]={

  1122.     //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

  1123.         0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25

  1124.     };

  1125.     s->y_dc_scale = y_tab[s->qscale];

  1126.     s->c_dc_scale = c_tab[s->qscale];

  1127. #else

  1128.     int quant;

  1129.     quant = s->qscale;

  1130.     /* luminance */

  1131.     if (quant < 5)

  1132. 	s->y_dc_scale = 8;

  1133.     else if (quant > 4 && quant < 9)

  1134. 	s->y_dc_scale = (2 * quant);

  1135.     else if (quant > 8 && quant < 25)

  1136. 	s->y_dc_scale = (quant + 8);

  1137.     else

  1138. 	s->y_dc_scale = (2 * quant - 16);

  1139.     /* chrominance */

  1140.     if (quant < 5)

  1141. 	s->c_dc_scale = 8;

  1142.     else if (quant > 4 && quant < 25)

  1143. 	s->c_dc_scale = ((quant + 13) / 2);

  1144.     else

  1145. 	s->c_dc_scale = (quant - 6);

  1146. #endif

  1147. }

  1148. 

  1149. static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)

  1150. {

  1151.     int a, b, c, wrap, pred, scale;

  1152.     UINT16 *dc_val;

  1153.     int dummy;

  1154. 

  1155.     /* find prediction */

  1156.     if (n < 4) {

  1157. 	scale = s->y_dc_scale;

  1158.     } else {

  1159. 	scale = s->c_dc_scale;

  1160.     }

  1161.     wrap= s->block_wrap[n];

  1162.     dc_val = s->dc_val[0] + s->block_index[n];

  1163. 

  1164.     /* B C

  1165.      * A X 

  1166.      */

  1167.     a = dc_val[ - 1];

  1168.     b = dc_val[ - 1 - wrap];

  1169.     c = dc_val[ - wrap];

  1170. 

  1171.     if (abs(a - b) < abs(b - c)) {

  1172. 	pred = c;

  1173.         *dir_ptr = 1; /* top */

  1174.     } else {

  1175. 	pred = a;

  1176.         *dir_ptr = 0; /* left */

  1177.     }

  1178.     /* we assume pred is positive */

  1179. #ifdef ARCH_X86

  1180. 	asm volatile (

  1181. 		"xorl %%edx, %%edx	\n\t"

  1182. 		"mul %%ecx		\n\t"

  1183. 		: "=d" (pred), "=a"(dummy)

  1184. 		: "a" (pred + (scale >> 1)), "c" (inverse[scale])

  1185. 	);

  1186. #else

  1187.     pred = (pred + (scale >> 1)) / scale;

  1188. #endif

  1189. 

  1190.     /* prepare address for prediction update */

  1191.     *dc_val_ptr = &dc_val[0];

  1192. 

  1193.     return pred;

  1194. }

  1195. 

  1196. void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,

  1197.                    int dir)

  1198. {

  1199.     int i;

  1200.     INT16 *ac_val, *ac_val1;

  1201. 

  1202.     /* find prediction */

  1203.     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;

  1204.     ac_val1 = ac_val;

  1205.     if (s->ac_pred) {

  1206.         if (dir == 0) {

  1207.             /* left prediction */

  1208.             ac_val -= 16;

  1209.             for(i=1;i<8;i++) {

  1210.                 block[block_permute_op(i*8)] += ac_val[i];

  1211.             }

  1212.         } else {

  1213.             /* top prediction */

  1214.             ac_val -= 16 * s->block_wrap[n];

  1215.             for(i=1;i<8;i++) {

  1216.                 block[block_permute_op(i)] += ac_val[i + 8];

  1217.             }

  1218.         }

  1219.     }

  1220.     /* left copy */

  1221.     for(i=1;i<8;i++)

  1222.         ac_val1[i] = block[block_permute_op(i * 8)];

  1223.     /* top copy */

  1224.     for(i=1;i<8;i++)

  1225.         ac_val1[8 + i] = block[block_permute_op(i)];

  1226. }

  1227. 

  1228. static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,

  1229.                               int dir)

  1230. {

  1231.     int i;

  1232.     INT16 *ac_val;

  1233. 

  1234.     /* find prediction */

  1235.     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;

  1236.  

  1237.     if (dir == 0) {

  1238.         /* left prediction */

  1239.         ac_val -= 16;

  1240.         for(i=1;i<8;i++) {

  1241.             block[block_permute_op(i*8)] -= ac_val[i];

  1242.         }

  1243.     } else {

  1244.         /* top prediction */

  1245.         ac_val -= 16 * s->block_wrap[n];

  1246.         for(i=1;i<8;i++) {

  1247.             block[block_permute_op(i)] -= ac_val[i + 8];

  1248.         }

  1249.     }

  1250. }

  1251. 

  1252. static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)

  1253. {

  1254. #if 1

  1255.     level+=256;

  1256.     if (n < 4) {

  1257. 	/* luminance */

  1258. 	put_bits(&s->pb, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);

  1259.     } else {

  1260. 	/* chrominance */

  1261. 	put_bits(&s->pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);

  1262.     }

  1263. #else

  1264.     int size, v;

  1265.     /* find number of bits */

  1266.     size = 0;

  1267.     v = abs(level);

  1268.     while (v) {

  1269. 	v >>= 1;

  1270. 	size++;

  1271.     }

  1272. 

  1273.     if (n < 4) {

  1274. 	/* luminance */

  1275. 	put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);

  1276.     } else {

  1277. 	/* chrominance */

  1278. 	put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);

  1279.     }

  1280. 

  1281.     /* encode remaining bits */

  1282.     if (size > 0) {

  1283. 	if (level < 0)

  1284. 	    level = (-level) ^ ((1 << size) - 1);

  1285. 	put_bits(&s->pb, size, level);

  1286. 	if (size > 8)

  1287. 	    put_bits(&s->pb, 1, 1);

  1288.     }

  1289. #endif

  1290. }

  1291. 

  1292. static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)

  1293. {

  1294.     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;

  1295.     int code;

  1296.     const RLTable *rl;

  1297. 

  1298.     if (s->mb_intra) {

  1299. 	/* mpeg4 based DC predictor */

  1300. 	mpeg4_encode_dc(s, intra_dc, n);

  1301. 	i = 1;

  1302.         rl = &rl_intra;

  1303.     } else {

  1304. 	i = 0;

  1305.         rl = &rl_inter;

  1306.     }

  1307. 

  1308.     /* AC coefs */

  1309.     last_index = s->block_last_index[n];

  1310.     last_non_zero = i - 1;

  1311.     for (; i <= last_index; i++) {

  1312. 	j = scan_table[i];

  1313. 	level = block[j];

  1314. 	if (level) {

  1315. 	    run = i - last_non_zero - 1;

  1316. 	    last = (i == last_index);

  1317. 	    sign = 0;

  1318. 	    slevel = level;

  1319. 	    if (level < 0) {

  1320. 		sign = 1;

  1321. 		level = -level;

  1322. 	    }

  1323.             code = get_rl_index(rl, last, run, level);

  1324.             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);

  1325.             if (code == rl->n) {

  1326.                 int level1, run1;

  1327.                 level1 = level - rl->max_level[last][run];

  1328.                 if (level1 < 1) 

  1329.                     goto esc2;

  1330.                 code = get_rl_index(rl, last, run, level1);

  1331.                 if (code == rl->n) {

  1332.                 esc2:

  1333.                     put_bits(&s->pb, 1, 1);

  1334.                     if (level > MAX_LEVEL)

  1335.                         goto esc3;

  1336.                     run1 = run - rl->max_run[last][level] - 1;

  1337.                     if (run1 < 0)

  1338.                         goto esc3;

  1339.                     code = get_rl_index(rl, last, run1, level);

  1340.                     if (code == rl->n) {

  1341.                     esc3:

  1342.                         /* third escape */

  1343.                         put_bits(&s->pb, 1, 1);

  1344.                         put_bits(&s->pb, 1, last);

  1345.                         put_bits(&s->pb, 6, run);

  1346.                         put_bits(&s->pb, 1, 1);

  1347.                         put_bits(&s->pb, 12, slevel & 0xfff);

  1348.                         put_bits(&s->pb, 1, 1);

  1349.                     } else {

  1350.                         /* second escape */

  1351.                         put_bits(&s->pb, 1, 0);

  1352.                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);

  1353.                         put_bits(&s->pb, 1, sign);

  1354.                     }

  1355.                 } else {

  1356.                     /* first escape */

  1357.                     put_bits(&s->pb, 1, 0);

  1358.                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);

  1359.                     put_bits(&s->pb, 1, sign);

  1360.                 }

  1361.             } else {

  1362.                 put_bits(&s->pb, 1, sign);

  1363.             }

  1364. 	    last_non_zero = i;

  1365. 	}

  1366.     }

  1367. }

  1368. 

  1369. 

  1370. 

  1371. /***********************************************/

  1372. /* decoding */

  1373. 

  1374. static VLC intra_MCBPC_vlc;

  1375. static VLC inter_MCBPC_vlc;

  1376. static VLC cbpy_vlc;

  1377. static VLC mv_vlc;

  1378. static VLC dc_lum, dc_chrom;

  1379. static VLC sprite_trajectory;

  1380. static VLC mb_type_b_vlc;

  1381. 

  1382. void init_rl(RLTable *rl)

  1383. {

  1384.     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];

  1385.     UINT8 index_run[MAX_RUN+1];

  1386.     int last, run, level, start, end, i;

  1387. 

  1388.     /* compute max_level[], max_run[] and index_run[] */

  1389.     for(last=0;last<2;last++) {

  1390.         if (last == 0) {

  1391.             start = 0;

  1392.             end = rl->last;

  1393.         } else {

  1394.             start = rl->last;

  1395.             end = rl->n;

  1396.         }

  1397. 

  1398.         memset(max_level, 0, MAX_RUN + 1);

  1399.         memset(max_run, 0, MAX_LEVEL + 1);

  1400.         memset(index_run, rl->n, MAX_RUN + 1);

  1401.         for(i=start;i<end;i++) {

  1402.             run = rl->table_run[i];

  1403.             level = rl->table_level[i];

  1404.             if (index_run[run] == rl->n)

  1405.                 index_run[run] = i;

  1406.             if (level > max_level[run])

  1407.                 max_level[run] = level;

  1408.             if (run > max_run[level])

  1409.                 max_run[level] = run;

  1410.         }

  1411.         rl->max_level[last] = malloc(MAX_RUN + 1);

  1412.         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);

  1413.         rl->max_run[last] = malloc(MAX_LEVEL + 1);

  1414.         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);

  1415.         rl->index_run[last] = malloc(MAX_RUN + 1);

  1416.         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);

  1417.     }

  1418. }

  1419. 

  1420. void init_vlc_rl(RLTable *rl)

  1421. {

  1422.     init_vlc(&rl->vlc, 9, rl->n + 1, 

  1423.              &rl->table_vlc[0][1], 4, 2,

  1424.              &rl->table_vlc[0][0], 4, 2);

  1425. }

  1426. 

  1427. /* init vlcs */

  1428. 

  1429. /* XXX: find a better solution to handle static init */

  1430. void h263_decode_init_vlc(MpegEncContext *s)

  1431. {

  1432.     static int done = 0;

  1433. 

  1434.     if (!done) {

  1435.         done = 1;

  1436. 

  1437.         init_vlc(&intra_MCBPC_vlc, 6, 8, 

  1438.                  intra_MCBPC_bits, 1, 1,

  1439.                  intra_MCBPC_code, 1, 1);

  1440.         init_vlc(&inter_MCBPC_vlc, 9, 25, 

  1441.                  inter_MCBPC_bits, 1, 1,

  1442.                  inter_MCBPC_code, 1, 1);

  1443.         init_vlc(&cbpy_vlc, 6, 16,

  1444.                  &cbpy_tab[0][1], 2, 1,

  1445.                  &cbpy_tab[0][0], 2, 1);

  1446.         init_vlc(&mv_vlc, 9, 33,

  1447.                  &mvtab[0][1], 2, 1,

  1448.                  &mvtab[0][0], 2, 1);

  1449.         init_rl(&rl_inter);

  1450.         init_rl(&rl_intra);

  1451.         init_rl(&rl_intra_aic);

  1452.         init_vlc_rl(&rl_inter);

  1453.         init_vlc_rl(&rl_intra);

  1454.         init_vlc_rl(&rl_intra_aic);

  1455.         init_vlc(&dc_lum, 9, 13,

  1456.                  &DCtab_lum[0][1], 2, 1,

  1457.                  &DCtab_lum[0][0], 2, 1);

  1458.         init_vlc(&dc_chrom, 9, 13,

  1459.                  &DCtab_chrom[0][1], 2, 1,

  1460.                  &DCtab_chrom[0][0], 2, 1);

  1461.         init_vlc(&sprite_trajectory, 9, 15,

  1462.                  &sprite_trajectory_tab[0][1], 4, 2,

  1463.                  &sprite_trajectory_tab[0][0], 4, 2);

  1464.         init_vlc(&mb_type_b_vlc, 4, 4,

  1465.                  &mb_type_b_tab[0][1], 2, 1,

  1466.                  &mb_type_b_tab[0][0], 2, 1);

  1467.     }

  1468. }

  1469. 

  1470. int h263_decode_gob_header(MpegEncContext *s)

  1471. {

  1472.     unsigned int val, gfid;

  1473.     

  1474.     /* Check for GOB Start Code */

  1475.     val = show_bits(&s->gb, 16);

  1476.     if (val == 0) {

  1477.         /* We have a GBSC probably with GSTUFF */

  1478.         skip_bits(&s->gb, 16); /* Drop the zeros */

  1479.         while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */

  1480. #ifdef DEBUG

  1481.         fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);

  1482. #endif

  1483.         s->gob_number = get_bits(&s->gb, 5); /* GN */

  1484.         gfid = get_bits(&s->gb, 2); /* GFID */

  1485.         s->qscale = get_bits(&s->gb, 5); /* GQUANT */

  1486. #ifdef DEBUG

  1487.         fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);

  1488. #endif

  1489.         return 1;

  1490.     }

  1491.     return 0;

  1492.             

  1493. }

  1494. 

  1495. static inline void memsetw(short *tab, int val, int n)

  1496. {

  1497.     int i;

  1498.     for(i=0;i<n;i++)

  1499.         tab[i] = val;

  1500. }

  1501. 

  1502. static int mpeg4_resync(MpegEncContext *s)

  1503. {

  1504.     int state, v, bits;

  1505.     int mb_num_bits= av_log2(s->mb_num - 1) + 1;

  1506.     int header_extension=0, mb_num;

  1507.     int c_wrap, c_xy, l_wrap, l_xy;

  1508.     int time_increment;

  1509. //printf("resync at %d %d\n", s->mb_x, s->mb_y);

  1510. //printf("%X\n", show_bits(&s->gb, 24));

  1511. 

  1512.     if( get_bits_count(&s->gb) > s->gb.size*8-32)

  1513.         return 0;

  1514. 

  1515.     align_get_bits(&s->gb);

  1516.     state = 0xff;

  1517.     for(;;) {

  1518.         v = get_bits(&s->gb, 8);

  1519. //printf("%X ", v);

  1520.         state = ((state << 8) | v) & 0xffff;

  1521.         if (state == 0) break;

  1522.         if( get_bits_count(&s->gb) > s->gb.size*8-32){

  1523.             printf("resync failed\n");

  1524.             return -1;

  1525.         }

  1526.     }

  1527. //printf("%X\n", show_bits(&s->gb, 24));

  1528.     bits=0;

  1529.     while(!get_bits1(&s->gb) && bits<30) bits++;

  1530.     if(s->pict_type == P_TYPE && bits != s->f_code-1)

  1531.         printf("marker does not match f_code\n");

  1532.     //FIXME check bits for B-framess

  1533. //printf("%X\n", show_bits(&s->gb, 24));

  1534. 

  1535.     if(s->shape != RECT_SHAPE){

  1536.         header_extension= get_bits1(&s->gb);

  1537.         //FIXME more stuff here

  1538.     }

  1539. 

  1540.     mb_num= get_bits(&s->gb, mb_num_bits);

  1541.     if(mb_num != s->mb_x + s->mb_y*s->mb_width){

  1542.         printf("MB-num change not supported %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width);

  1543. //        s->mb_x= mb_num % s->mb_width;

  1544. //        s->mb_y= mb_num / s->mb_width;

  1545.         //FIXME many vars are wrong now

  1546.     } 

  1547. 

  1548.     if(s->shape != BIN_ONLY_SHAPE){

  1549.         s->qscale= get_bits(&s->gb, 5);

  1550.         h263_dc_scale(s);

  1551.     }

  1552. 

  1553.     if(s->shape == RECT_SHAPE){

  1554.         header_extension= get_bits1(&s->gb);

  1555.     }

  1556.     if(header_extension){

  1557.         int time_incr=0;

  1558.         printf("header extension not really supported\n");

  1559.         while (get_bits1(&s->gb) != 0) 

  1560.             time_incr++;

  1561. 

  1562.         check_marker(&s->gb, "before time_increment in video packed header");

  1563.         time_increment= get_bits(&s->gb, s->time_increment_bits);

  1564.         if(s->pict_type!=B_TYPE){

  1565.             s->last_time_base= s->time_base;

  1566.             s->time_base+= time_incr;

  1567.             s->time= s->time_base*s->time_increment_resolution + time_increment;

  1568.             s->pp_time= s->time - s->last_non_b_time;

  1569.             s->last_non_b_time= s->time;

  1570.         }else{

  1571.             s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;

  1572.             s->bp_time= s->last_non_b_time - s->time;

  1573.         }

  1574.         check_marker(&s->gb, "before vop_coding_type in video packed header");

  1575.         

  1576.         skip_bits(&s->gb, 2); /* vop coding type */

  1577.         //FIXME not rect stuff here

  1578. 

  1579.         if(s->shape != BIN_ONLY_SHAPE){

  1580.             skip_bits(&s->gb, 3); /* intra dc vlc threshold */

  1581. 

  1582.             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){

  1583.                 mpeg4_decode_sprite_trajectory(s);

  1584.             }

  1585. 

  1586.             //FIXME reduced res stuff here

  1587.             

  1588.             if (s->pict_type != I_TYPE) {

  1589.                 s->f_code = get_bits(&s->gb, 3);	/* fcode_for */

  1590.                 if(s->f_code==0){

  1591.                     printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");

  1592.                     return -1; // makes no sense to continue, as the MV decoding will break very quickly

  1593.                 }

  1594.             }

  1595.             if (s->pict_type == B_TYPE) {

  1596.                 s->b_code = get_bits(&s->gb, 3);

  1597.             }       

  1598.         }

  1599. 

  1600.     }

  1601.     //FIXME new-pred stuff

  1602. 

  1603.     l_wrap= s->block_wrap[0];

  1604.     l_xy= s->mb_y*l_wrap*2;

  1605.     c_wrap= s->block_wrap[4];

  1606.     c_xy= s->mb_y*c_wrap;

  1607. 

  1608.     /* clean DC */

  1609.     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*3);

  1610.     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap*2);

  1611.     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap*2);

  1612. 

  1613.     /* clean AC */

  1614.     memset(s->ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16));

  1615.     memset(s->ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16));

  1616.     memset(s->ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16));

  1617. 

  1618.     /* clean MV */

  1619.     memset(s->motion_val + l_xy, 0, l_wrap*3*2*sizeof(INT16));

  1620. //    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));

  1621.     s->resync_x_pos= s->mb_x;

  1622.     s->first_slice_line=1;

  1623. 

  1624.     return 0;

  1625. }

  1626. 

  1627. int h263_decode_mb(MpegEncContext *s,

  1628.                    DCTELEM block[6][64])

  1629. {

  1630.     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

  1631.     INT16 *mot_val;

  1632.     static INT8 quant_tab[4] = { -1, -2, 1, 2 };

  1633. 

  1634.     if(s->resync_marker){

  1635.         if(   s->resync_x_pos == s->mb_x+1

  1636.            || s->resync_x_pos == s->mb_x){

  1637.             /* f*ck mpeg4

  1638.                this is here so we dont need to slowdown h263_pred_motion with it */

  1639.             if(s->resync_x_pos == s->mb_x+1 && s->mb_x==0){

  1640.                 int xy= s->block_index[0] - s->block_wrap[0];

  1641.                 s->motion_val[xy][0]= s->motion_val[xy+2][0];

  1642.                 s->motion_val[xy][1]= s->motion_val[xy+2][1];

  1643.             }

  1644. 

  1645.             s->first_slice_line=0; 

  1646.             s->resync_x_pos=0; // isnt needed but for cleanness sake ;)

  1647.         }

  1648. 

  1649.         if(show_aligned_bits(&s->gb, 1, 16) == 0){

  1650.             if( mpeg4_resync(s) < 0 ) return -1;

  1651.             

  1652.         }

  1653.     }

  1654. 

  1655.     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {

  1656.         if (get_bits1(&s->gb)) {

  1657.             /* skip mb */

  1658.             s->mb_intra = 0;

  1659.             for(i=0;i<6;i++)

  1660.                 s->block_last_index[i] = -1;

  1661.             s->mv_dir = MV_DIR_FORWARD;

  1662.             s->mv_type = MV_TYPE_16X16;

  1663.             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){

  1664.                 const int a= s->sprite_warping_accuracy;

  1665. //                int l = (1 << (s->f_code - 1)) * 32;

  1666. 

  1667.                 s->mcsel=1;

  1668.                 if(s->divx_version==500 && s->divx_build==413){

  1669.                     s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));

  1670.                     s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));

  1671.                 }else{

  1672.                     s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);

  1673.                     s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);

  1674.                 }

  1675. /*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;

  1676.                 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;

  1677.                 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;

  1678.                 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/

  1679. 

  1680.                 s->mb_skiped = 0;

  1681.             }else{

  1682.                 s->mcsel=0;

  1683.                 s->mv[0][0][0] = 0;

  1684.                 s->mv[0][0][1] = 0;

  1685.                 s->mb_skiped = 1;

  1686.             }

  1687.             return 0;

  1688.         }

  1689.         cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);

  1690.         //fprintf(stderr, "\tCBPC: %d", cbpc);

  1691.         if (cbpc < 0)

  1692.             return -1;

  1693.         if (cbpc > 20)

  1694.             cbpc+=3;

  1695.         else if (cbpc == 20)

  1696.             fprintf(stderr, "Stuffing !");

  1697.         

  1698.         dquant = cbpc & 8;

  1699.         s->mb_intra = ((cbpc & 4) != 0);

  1700.         if (s->mb_intra) goto intra;

  1701.         

  1702.         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)

  1703.             s->mcsel= get_bits1(&s->gb);

  1704.         else s->mcsel= 0;

  1705.         cbpy = get_vlc(&s->gb, &cbpy_vlc);

  1706.         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);

  1707.         if (dquant) {

  1708.             s->qscale += quant_tab[get_bits(&s->gb, 2)];

  1709.             if (s->qscale < 1)

  1710.                 s->qscale = 1;

  1711.             else if (s->qscale > 31)

  1712.                 s->qscale = 31;

  1713.             h263_dc_scale(s);

  1714.         }

  1715.         s->mv_dir = MV_DIR_FORWARD;

  1716.         if ((cbpc & 16) == 0) {

  1717.             /* 16x16 motion prediction */

  1718.             s->mv_type = MV_TYPE_16X16;

  1719.             h263_pred_motion(s, 0, &pred_x, &pred_y);

  1720.             if (s->umvplus_dec)

  1721.                mx = h263p_decode_umotion(s, pred_x);

  1722.             else if(!s->mcsel)

  1723.                mx = h263_decode_motion(s, pred_x, s->f_code);

  1724.             else {

  1725.                const int a= s->sprite_warping_accuracy;

  1726. //        int l = (1 << (s->f_code - 1)) * 32;

  1727.                 if(s->divx_version==500 && s->divx_build==413){

  1728.                     mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));

  1729.                 }else{

  1730.                     mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);

  1731.                 }

  1732. //        if (mx < -l) mx= -l, printf("C");

  1733. //        else if (mx >= l) mx= l-1, printf("C");

  1734.             }

  1735.             if (mx >= 0xffff)

  1736.                 return -1;

  1737.             

  1738.             if (s->umvplus_dec)

  1739.                my = h263p_decode_umotion(s, pred_y);

  1740.             else if(!s->mcsel)

  1741.                my = h263_decode_motion(s, pred_y, s->f_code);

  1742.             else{

  1743.                const int a= s->sprite_warping_accuracy;

  1744. //       int l = (1 << (s->f_code - 1)) * 32;

  1745.                 if(s->divx_version==500 && s->divx_build==413){

  1746.                     my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));

  1747.                 }else{

  1748.                     my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);

  1749.                 }

  1750. //       if (my < -l) my= -l, printf("C");

  1751. //       else if (my >= l) my= l-1, printf("C");

  1752.             }

  1753.             if (my >= 0xffff)

  1754.                 return -1;

  1755.             s->mv[0][0][0] = mx;

  1756.             s->mv[0][0][1] = my;

  1757.             /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);

  1758.             fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);

  1759.             fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/

  1760.             if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)

  1761.                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

  1762.                            

  1763.         } else {

  1764.             s->mv_type = MV_TYPE_8X8;

  1765.             for(i=0;i<4;i++) {

  1766.                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);

  1767.                 if (s->umvplus_dec)

  1768.                   mx = h263p_decode_umotion(s, pred_x);

  1769.                 else

  1770.                   mx = h263_decode_motion(s, pred_x, s->f_code);

  1771.                 if (mx >= 0xffff)

  1772.                     return -1;

  1773.                 

  1774.                 if (s->umvplus_dec)

  1775.                   my = h263p_decode_umotion(s, pred_y);

  1776.                 else    

  1777.                   my = h263_decode_motion(s, pred_y, s->f_code);

  1778.                 if (my >= 0xffff)

  1779.                     return -1;

  1780.                 s->mv[0][i][0] = mx;

  1781.                 s->mv[0][i][1] = my;

  1782.                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)

  1783.                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

  1784.                 mot_val[0] = mx;

  1785.                 mot_val[1] = my;

  1786.             }

  1787.         }

  1788.     } else if(s->pict_type==B_TYPE) {

  1789.         int modb1; // first bit of modb

  1790.         int modb2; // second bit of modb

  1791.         int mb_type;

  1792.         uint16_t time_pp;

  1793.         uint16_t time_pb;

  1794.         int xy;

  1795. 

  1796.         s->mb_intra = 0; //B-frames never contain intra blocks

  1797.         s->mcsel=0;      //     ...               true gmc blocks

  1798. 

  1799.         if(s->mb_x==0){

  1800.             s->last_mv[0][0][0]= 

  1801.             s->last_mv[0][0][1]= 

  1802.             s->last_mv[1][0][0]= 

  1803.             s->last_mv[1][0][1]= 0;

  1804. //            printf("\n");

  1805.         }

  1806. 

  1807.         /* if we skipped it in the future P Frame than skip it now too */

  1808.         s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC

  1809. 

  1810.         if(s->mb_skiped){

  1811.                 /* skip mb */

  1812.             for(i=0;i<6;i++)

  1813.                 s->block_last_index[i] = -1;

  1814. 

  1815.             s->mv_dir = MV_DIR_FORWARD;

  1816.             s->mv_type = MV_TYPE_16X16;

  1817.             s->mv[0][0][0] = 0;

  1818.             s->mv[0][0][1] = 0;

  1819.             s->mv[1][0][0] = 0;

  1820.             s->mv[1][0][1] = 0;

  1821. //FIXME is this correct?

  1822. /*            s->last_mv[0][0][0]=

  1823.             s->last_mv[0][0][1]=0;*/

  1824. //            printf("S");

  1825.             return 0;

  1826.         }

  1827. 

  1828.         modb1= get_bits1(&s->gb);

  1829.         if(modb1==0){

  1830.             modb2= get_bits1(&s->gb);

  1831.             mb_type= get_vlc(&s->gb, &mb_type_b_vlc);

  1832.             if(modb2==0) cbp= get_bits(&s->gb, 6);

  1833.             else cbp=0;

  1834.             if (mb_type && cbp) {

  1835.                 if(get_bits1(&s->gb)){

  1836.                     s->qscale +=get_bits1(&s->gb)*4 - 2;

  1837.                     if (s->qscale < 1)

  1838.                         s->qscale = 1;

  1839.                     else if (s->qscale > 31)

  1840.                         s->qscale = 31;

  1841.                     h263_dc_scale(s);

  1842.                 }

  1843.             }

  1844.         }else{

  1845.             mb_type=4; //like 0 but no vectors coded

  1846.             cbp=0;

  1847.         }

  1848.         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

  1849.         mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my

  1850.         switch(mb_type)

  1851.         {

  1852.         case 0: /* direct */

  1853.             mx = h263_decode_motion(s, 0, 1);

  1854.             my = h263_decode_motion(s, 0, 1);

  1855.         case 4: /* direct with mx=my=0 */

  1856.             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;

  1857.             xy= s->block_index[0];

  1858.             time_pp= s->pp_time;

  1859.             time_pb= time_pp - s->bp_time;

  1860. //if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);

  1861.             //FIXME 4MV

  1862.             //FIXME avoid divides

  1863.             s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;

  1864.             s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;

  1865.             s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]

  1866.                                 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;

  1867.             s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 

  1868.                                 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;

  1869. /*            s->mv[0][0][0] = 

  1870.             s->mv[0][0][1] = 

  1871.             s->mv[1][0][0] = 

  1872.             s->mv[1][0][1] = 1000;*/

  1873. //            printf("D");

  1874.             break;

  1875.         case 1: 

  1876.             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;

  1877.             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);

  1878.             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);

  1879.             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;

  1880.             s->last_mv[0][0][1]= s->mv[0][0][1] = my;

  1881. 

  1882.             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);

  1883.             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);

  1884.             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;

  1885.             s->last_mv[1][0][1]= s->mv[1][0][1] = my;

  1886. //            printf("I");

  1887.             break;

  1888.         case 2: 

  1889.             s->mv_dir = MV_DIR_BACKWARD;

  1890.             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);

  1891.             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);

  1892.             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;

  1893.             s->last_mv[1][0][1]= s->mv[1][0][1] = my;

  1894. //            printf("B");

  1895.             break;

  1896.         case 3:

  1897.             s->mv_dir = MV_DIR_FORWARD;

  1898.             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);

  1899.             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);

  1900.             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;

  1901.             s->last_mv[0][0][1]= s->mv[0][0][1] = my;

  1902. //            printf("F");

  1903.             break;

  1904.         default: return -1;

  1905.         }

  1906.     } else { /* I-Frame */

  1907.         cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);

  1908.         if (cbpc < 0)

  1909.             return -1;

  1910.         dquant = cbpc & 4;

  1911.         s->mb_intra = 1;

  1912. intra:

  1913.         s->ac_pred = 0;

  1914.         if (s->h263_pred || s->h263_aic) {

  1915.             s->ac_pred = get_bits1(&s->gb);

  1916.             if (s->ac_pred && s->h263_aic)

  1917.                 s->h263_aic_dir = get_bits1(&s->gb);

  1918.         }

  1919.         if (s->h263_aic) {

  1920.             s->y_dc_scale = 2 * s->qscale;

  1921.             s->c_dc_scale = 2 * s->qscale;

  1922.         }

  1923.         cbpy = get_vlc(&s->gb, &cbpy_vlc);

  1924.         cbp = (cbpc & 3) | (cbpy << 2);

  1925.         if (dquant) {

  1926.             s->qscale += quant_tab[get_bits(&s->gb, 2)];

  1927.             if (s->qscale < 1)

  1928.                 s->qscale = 1;

  1929.             else if (s->qscale > 31)

  1930.                 s->qscale = 31;

  1931.             h263_dc_scale(s);

  1932.         }

  1933.     }

  1934. 

  1935.     /* decode each block */

  1936.     if (s->h263_pred) {

  1937. 	for (i = 0; i < 6; i++) {

  1938. 	    if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)

  1939.                 return -1;

  1940. 	}

  1941.     } else {

  1942. 	for (i = 0; i < 6; i++) {

  1943. 	    if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)

  1944.                 return -1;

  1945. 	}

  1946.     }

  1947.     return 0;

  1948. }

  1949. 

  1950. static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)

  1951. {

  1952.     int code, val, sign, shift, l, m;

  1953. 

  1954.     code = get_vlc(&s->gb, &mv_vlc);

  1955.     if (code < 0)

  1956.         return 0xffff;

  1957. 

  1958.     if (code == 0)

  1959.         return pred;

  1960.     sign = get_bits1(&s->gb);

  1961.     shift = f_code - 1;

  1962.     val = (code - 1) << shift;

  1963.     if (shift > 0)

  1964.         val |= get_bits(&s->gb, shift);

  1965.     val++;

  1966.     if (sign)

  1967.         val = -val;

  1968.     val += pred;

  1969.     

  1970.     /* modulo decoding */

  1971.     if (!s->h263_long_vectors) {

  1972.         l = (1 << (f_code - 1)) * 32;

  1973.         m = 2 * l;

  1974.         if (val < -l) {

  1975.             val += m;

  1976.         } else if (val >= l) {

  1977.             val -= m;

  1978.         }

  1979.     } else {

  1980.         /* horrible h263 long vector mode */

  1981.         if (pred < -31 && val < -63)

  1982.             val += 64;

  1983.         if (pred > 32 && val > 63)

  1984.             val -= 64;

  1985.         

  1986.     }

  1987.     return val;

  1988. }

  1989. 

  1990. /* Decodes RVLC of H.263+ UMV */

  1991. static int h263p_decode_umotion(MpegEncContext * s, int pred)

  1992. {

  1993.    int code = 0, sign;

  1994.    

  1995.    if (get_bits1(&s->gb)) /* Motion difference = 0 */

  1996.       return pred;

  1997.    

  1998.    code = 2 + get_bits1(&s->gb);

  1999.    

  2000.    while (get_bits1(&s->gb))

  2001.    {

  2002.       code <<= 1;

  2003.       code += get_bits1(&s->gb);

  2004.    }

  2005.    sign = code & 1;

  2006.    code >>= 1;

  2007.    

  2008.    code = (sign) ? (pred - code) : (pred + code);

  2009. #ifdef DEBUG

  2010.    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);

  2011. #endif

  2012.    return code;   

  2013. 

  2014. }

  2015. 

  2016. static int h263_decode_block(MpegEncContext * s, DCTELEM * block,

  2017.                              int n, int coded)

  2018. {

  2019.     int code, level, i, j, last, run;

  2020.     RLTable *rl = &rl_inter;

  2021.     const UINT8 *scan_table;

  2022. 

  2023.     scan_table = zigzag_direct;

  2024.     if (s->h263_aic && s->mb_intra) {

  2025.         rl = &rl_intra_aic;

  2026.         i = 0;

  2027.         if (s->ac_pred) {

  2028.             if (s->h263_aic_dir) 

  2029.                 scan_table = ff_alternate_vertical_scan; /* left */

  2030.             else

  2031.                 scan_table = ff_alternate_horizontal_scan; /* top */

  2032.         }

  2033.     } else if (s->mb_intra) {

  2034.         /* DC coef */

  2035.         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {

  2036.             int component, diff;

  2037.             component = (n <= 3 ? 0 : n - 4 + 1);

  2038.             level = s->last_dc[component];

  2039.             if (s->rv10_first_dc_coded[component]) {

  2040.                 diff = rv_decode_dc(s, n);

  2041.                 if (diff == 0xffff)

  2042.                     return -1;

  2043.                 level += diff;

  2044.                 level = level & 0xff; /* handle wrap round */

  2045.                 s->last_dc[component] = level;

  2046.             } else {

  2047.                 s->rv10_first_dc_coded[component] = 1;

  2048.             }

  2049.         } else {

  2050.             level = get_bits(&s->gb, 8);

  2051.             if (level == 255)

  2052.                 level = 128;

  2053.         }

  2054.         block[0] = level;

  2055.         i = 1;

  2056.     } else {

  2057.         i = 0;

  2058.     }

  2059.     if (!coded) {

  2060.         if (s->mb_intra && s->h263_aic)

  2061.             goto not_coded;

  2062.         s->block_last_index[n] = i - 1;

  2063.         return 0;

  2064.     }

  2065. 

  2066.     for(;;) {

  2067.         code = get_vlc(&s->gb, &rl->vlc);

  2068.         if (code < 0)

  2069.             return -1;

  2070.         if (code == rl->n) {

  2071.             /* escape */

  2072.             last = get_bits1(&s->gb);

  2073.             run = get_bits(&s->gb, 6);

  2074.             level = (INT8)get_bits(&s->gb, 8);

  2075.             if (s->h263_rv10 && level == -128) {

  2076.                 /* XXX: should patch encoder too */

  2077.                 level = get_bits(&s->gb, 12);

  2078.                 level = (level << 20) >> 20;

  2079.             }

  2080.         } else {

  2081.             run = rl->table_run[code];

  2082.             level = rl->table_level[code];

  2083.             last = code >= rl->last;

  2084.             if (get_bits1(&s->gb))

  2085.                 level = -level;

  2086.         }

  2087.         i += run;

  2088.         if (i >= 64)

  2089.             return -1;

  2090.         j = scan_table[i];

  2091.         block[j] = level;

  2092.         if (last)

  2093.             break;

  2094.         i++;

  2095.     }

  2096. not_coded:    

  2097.     if (s->mb_intra && s->h263_aic) {

  2098.         h263_pred_acdc(s, block, n);

  2099.         i = 63;

  2100.     }

  2101.     s->block_last_index[n] = i;

  2102.     return 0;

  2103. }

  2104. 

  2105. static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)

  2106. {

  2107.     int level, pred, code;

  2108.     UINT16 *dc_val;

  2109. 

  2110.     if (n < 4) 

  2111.         code = get_vlc(&s->gb, &dc_lum);

  2112.     else 

  2113.         code = get_vlc(&s->gb, &dc_chrom);

  2114.     if (code < 0)

  2115.         return -1;

  2116.     if (code == 0) {

  2117.         level = 0;

  2118.     } else {

  2119.         level = get_bits(&s->gb, code);

  2120.         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/

  2121.             level = - (level ^ ((1 << code) - 1));

  2122.         if (code > 8)

  2123.             skip_bits1(&s->gb); /* marker */

  2124.     }

  2125. 

  2126.     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);

  2127.     level += pred;

  2128.     if (level < 0)

  2129.         level = 0;

  2130.     if (n < 4) {

  2131.         *dc_val = level * s->y_dc_scale;

  2132.     } else {

  2133.         *dc_val = level * s->c_dc_scale;

  2134.     }

  2135.     return level;

  2136. }

  2137. 

  2138. static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,

  2139.                               int n, int coded)

  2140. {

  2141.     int code, level, i, j, last, run;

  2142.     int dc_pred_dir;

  2143.     RLTable *rl;

  2144.     const UINT8 *scan_table;

  2145. 

  2146.     if (s->mb_intra) {

  2147. 	/* DC coef */

  2148.         level = mpeg4_decode_dc(s, n, &dc_pred_dir);

  2149.         if (level < 0)

  2150.             return -1;

  2151.         block[0] = level;

  2152. 	i = 1;

  2153.         if (!coded) 

  2154.             goto not_coded;

  2155.         rl = &rl_intra;

  2156.         if (s->ac_pred) {

  2157.             if (dc_pred_dir == 0) 

  2158.                 scan_table = ff_alternate_vertical_scan; /* left */

  2159.             else

  2160.                 scan_table = ff_alternate_horizontal_scan; /* top */

  2161.         } else {

  2162.             scan_table = zigzag_direct;

  2163.         }

  2164.     } else {

  2165. 	i = 0;

  2166.         if (!coded) {

  2167.             s->block_last_index[n] = i - 1;

  2168.             return 0;

  2169.         }

  2170.         rl = &rl_inter;

  2171.         scan_table = zigzag_direct;

  2172.     }

  2173. 

  2174.     for(;;) {

  2175.         code = get_vlc(&s->gb, &rl->vlc);

  2176.         if (code < 0)

  2177.             return -1;

  2178.         if (code == rl->n) {

  2179.             /* escape */

  2180.             if (get_bits1(&s->gb) != 0) {

  2181.                 if (get_bits1(&s->gb) != 0) {

  2182.                     /* third escape */

  2183.                     last = get_bits1(&s->gb);

  2184.                     run = get_bits(&s->gb, 6);

  2185.                     get_bits1(&s->gb); /* marker */

  2186.                     level = get_bits(&s->gb, 12);

  2187.                     level = (level << 20) >> 20; /* sign extend */

  2188.                     skip_bits1(&s->gb); /* marker */

  2189.                 } else {

  2190.                     /* second escape */

  2191.                     code = get_vlc(&s->gb, &rl->vlc);

  2192.                     if (code < 0 || code >= rl->n)

  2193.                         return -1;

  2194.                     run = rl->table_run[code];

  2195.                     level = rl->table_level[code];

  2196.                     last = code >= rl->last;

  2197.                     run += rl->max_run[last][level] + 1;

  2198.                     if (get_bits1(&s->gb))

  2199.                         level = -level;

  2200.                 }

  2201.             } else {

  2202.                 /* first escape */

  2203.                 code = get_vlc(&s->gb, &rl->vlc);

  2204.                 if (code < 0 || code >= rl->n)

  2205.                     return -1;

  2206.                 run = rl->table_run[code];

  2207.                 level = rl->table_level[code];

  2208.                 last = code >= rl->last;

  2209.                 level += rl->max_level[last][run];

  2210.                 if (get_bits1(&s->gb))

  2211.                     level = -level;

  2212.             }

  2213.         } else {

  2214.             run = rl->table_run[code];

  2215.             level = rl->table_level[code];

  2216.             last = code >= rl->last;

  2217.             if (get_bits1(&s->gb))

  2218.                 level = -level;

  2219.         }

  2220.         i += run;

  2221.         if (i >= 64)

  2222.             return -1;

  2223. 	j = scan_table[i];

  2224.         block[j] = level;

  2225.         i++;

  2226.         if (last)

  2227.             break;

  2228.     }

  2229.  not_coded:

  2230.     if (s->mb_intra) {

  2231.         mpeg4_pred_ac(s, block, n, dc_pred_dir);

  2232.         if (s->ac_pred) {

  2233.             i = 64; /* XXX: not optimal */

  2234.         }

  2235.     }

  2236.     s->block_last_index[n] = i - 1;

  2237.     return 0;

  2238. }

  2239. 

  2240. /* most is hardcoded. should extend to handle all h263 streams */

  2241. int h263_decode_picture_header(MpegEncContext *s)

  2242. {

  2243.     int format, width, height;

  2244. 

  2245.     /* picture header */

  2246.     if (get_bits(&s->gb, 22) != 0x20)

  2247.         return -1;

  2248.     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */

  2249.     

  2250.     if (get_bits1(&s->gb) != 1)

  2251.         return -1;	/* marker */

  2252.     if (get_bits1(&s->gb) != 0)

  2253.         return -1;	/* h263 id */

  2254.     skip_bits1(&s->gb);	/* split screen off */

  2255.     skip_bits1(&s->gb);	/* camera  off */

  2256.     skip_bits1(&s->gb);	/* freeze picture release off */

  2257. 

  2258.     /* Reset GOB number */

  2259.     s->gob_number = 0;

  2260.         

  2261.     format = get_bits(&s->gb, 3);

  2262. 

  2263.     if (format != 7 && format != 6) {

  2264.         s->h263_plus = 0;

  2265.         /* H.263v1 */

  2266.         width = h263_format[format][0];

  2267.         height = h263_format[format][1];

  2268.         if (!width)

  2269.             return -1;

  2270.         

  2271.         s->width = width;

  2272.         s->height = height;

  2273.         s->pict_type = I_TYPE + get_bits1(&s->gb);

  2274. 

  2275.         s->unrestricted_mv = get_bits1(&s->gb); 

  2276.         s->h263_long_vectors = s->unrestricted_mv;

  2277. 

  2278.         if (get_bits1(&s->gb) != 0)

  2279.             return -1;	/* SAC: off */

  2280.         if (get_bits1(&s->gb) != 0) {

  2281.             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */

  2282.         }   

  2283.         

  2284.         if (get_bits1(&s->gb) != 0)

  2285.             return -1;	/* not PB frame */

  2286. 

  2287.         s->qscale = get_bits(&s->gb, 5);

  2288.         skip_bits1(&s->gb);	/* Continuous Presence Multipoint mode: off */

  2289.     } else {

  2290.         int ufep;

  2291.         

  2292.         /* H.263v2 */

  2293.         s->h263_plus = 1;

  2294.         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */

  2295.         

  2296.         if (ufep == 1) {

  2297.             /* OPPTYPE */       

  2298.             format = get_bits(&s->gb, 3);

  2299.             skip_bits(&s->gb,1); /* Custom PCF */

  2300.             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */

  2301.             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */

  2302.             if (get_bits1(&s->gb) != 0) {

  2303.                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */

  2304.             }

  2305.             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */

  2306.                 s->h263_aic = 1;

  2307.             }

  2308.             skip_bits(&s->gb, 7);

  2309.             skip_bits(&s->gb, 3); /* Reserved */

  2310.         } else if (ufep != 0)

  2311.             return -1;

  2312.             

  2313.         /* MPPTYPE */

  2314.         s->pict_type = get_bits(&s->gb, 3) + 1;

  2315.         if (s->pict_type != I_TYPE &&

  2316.             s->pict_type != P_TYPE)

  2317.             return -1;

  2318.         skip_bits(&s->gb, 2);

  2319.         s->no_rounding = get_bits1(&s->gb);

  2320.         //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);

  2321.         skip_bits(&s->gb, 4);

  2322.         

  2323.         /* Get the picture dimensions */

  2324.         if (ufep) {

  2325.             if (format == 6) {

  2326.                 /* Custom Picture Format (CPFMT) */

  2327.                 skip_bits(&s->gb, 4); /* aspect ratio */

  2328.                 width = (get_bits(&s->gb, 9) + 1) * 4;

  2329.                 skip_bits1(&s->gb);

  2330.                 height = get_bits(&s->gb, 9) * 4;

  2331. #ifdef DEBUG 

  2332.                 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);

  2333. #endif            

  2334.             }

  2335.             else {

  2336.                 width = h263_format[format][0];

  2337.                 height = h263_format[format][1];

  2338.             }

  2339.             if ((width == 0) || (height == 0))

  2340.                 return -1;

  2341.             s->width = width;

  2342.             s->height = height;

  2343.             if (s->umvplus_dec) {

  2344.                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

  2345.             }

  2346.         }

  2347.             

  2348.         s->qscale = get_bits(&s->gb, 5);

  2349.     }

  2350.     /* PEI */

  2351.     while (get_bits1(&s->gb) != 0) {

  2352.         skip_bits(&s->gb, 8);

  2353.     }

  2354.     s->f_code = 1;

  2355.     return 0;

  2356. }

  2357. 

  2358. static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)

  2359. {

  2360.     int i;

  2361.     int a= 2<<s->sprite_warping_accuracy;

  2362.     int rho= 3-s->sprite_warping_accuracy;

  2363.     int r=16/a;

  2364.     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes

  2365.     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};

  2366.     int sprite_ref[4][2];

  2367.     int virtual_ref[2][2];

  2368.     int w2, h2;

  2369.     int alpha=0, beta=0;

  2370.     int w= s->width;

  2371.     int h= s->height;

  2372. //printf("SP %d\n", s->sprite_warping_accuracy);

  2373.     for(i=0; i<s->num_sprite_warping_points; i++){

  2374.         int length;

  2375.         int x=0, y=0;

  2376. 

  2377.         length= get_vlc(&s->gb, &sprite_trajectory);

  2378.         if(length){

  2379.             x= get_bits(&s->gb, length);

  2380. //printf("lx %d %d\n", length, x);

  2381.             if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/

  2382.                 x = - (x ^ ((1 << length) - 1));

  2383.         }

  2384.         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */

  2385.         

  2386.         length= get_vlc(&s->gb, &sprite_trajectory);

  2387.         if(length){

  2388.             y=get_bits(&s->gb, length);

  2389. //printf("ly %d %d\n", length, y);

  2390.             if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/

  2391.                 y = - (y ^ ((1 << length) - 1));

  2392.         }

  2393.         skip_bits1(&s->gb); /* marker bit */

  2394. //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);

  2395. //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");

  2396. //x=y=0;

  2397.         d[i][0]= x;

  2398.         d[i][1]= y;

  2399.     }

  2400. 

  2401.     while((1<<alpha)<w) alpha++;

  2402.     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'

  2403.     w2= 1<<alpha;

  2404.     h2= 1<<beta;

  2405. 

  2406. // Note, the 4th point isnt used for GMC

  2407.     if(s->divx_version==500 && s->divx_build==413){

  2408.         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];

  2409.         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];

  2410.         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];

  2411.         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];

  2412.         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];

  2413.         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];

  2414.     } else {

  2415.         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);

  2416.         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);

  2417.         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);

  2418.         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);

  2419.         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);

  2420.         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);

  2421.     }

  2422. /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);

  2423.     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */

  2424.     

  2425. // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)

  2426. // perhaps it should be reordered to be more readable ...

  2427. // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides

  2428. // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form

  2429.     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 

  2430.         + RDIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);

  2431.     virtual_ref[0][1]= 16*vop_ref[0][1] 

  2432.         + RDIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);

  2433.     virtual_ref[1][0]= 16*vop_ref[0][0] 

  2434.         + RDIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);

  2435.     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 

  2436.         + RDIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);

  2437. 

  2438.     switch(s->num_sprite_warping_points)

  2439.     {

  2440.         case 0:

  2441.             s->sprite_offset[0][0]= 0;

  2442.             s->sprite_offset[0][1]= 0;

  2443.             s->sprite_offset[1][0]= 0;

  2444.             s->sprite_offset[1][1]= 0;

  2445.             s->sprite_delta[0][0][0]= a;

  2446.             s->sprite_delta[0][0][1]= 0;

  2447.             s->sprite_delta[0][1][0]= 0;

  2448.             s->sprite_delta[0][1][1]= a;

  2449.             s->sprite_delta[1][0][0]= a;

  2450.             s->sprite_delta[1][0][1]= 0;

  2451.             s->sprite_delta[1][1][0]= 0;

  2452.             s->sprite_delta[1][1][1]= a;

  2453.             s->sprite_shift[0][0]= 0;

  2454.             s->sprite_shift[0][1]= 0;

  2455.             s->sprite_shift[1][0]= 0;

  2456.             s->sprite_shift[1][1]= 0;

  2457.             break;

  2458.         case 1: //GMC only

  2459.             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];

  2460.             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];

  2461.             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);

  2462.             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);

  2463.             s->sprite_delta[0][0][0]= a;

  2464.             s->sprite_delta[0][0][1]= 0;

  2465.             s->sprite_delta[0][1][0]= 0;

  2466.             s->sprite_delta[0][1][1]= a;

  2467.             s->sprite_delta[1][0][0]= a;

  2468.             s->sprite_delta[1][0][1]= 0;

  2469.             s->sprite_delta[1][1][0]= 0;

  2470.             s->sprite_delta[1][1][1]= a;

  2471.             s->sprite_shift[0][0]= 0;

  2472.             s->sprite_shift[0][1]= 0;

  2473.             s->sprite_shift[1][0]= 0;

  2474.             s->sprite_shift[1][1]= 0;

  2475.             break;

  2476.         case 2:

  2477.         case 3: //FIXME

  2478.             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))

  2479.                                                   + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])

  2480.                                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));

  2481.             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))

  2482.                                                   + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])

  2483.                                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));

  2484.             s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)

  2485.                                  +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)

  2486.                                  +2*w2*r*sprite_ref[0][0] - 16*w2);

  2487.             s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 

  2488.                                  +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)

  2489.                                  +2*w2*r*sprite_ref[0][1] - 16*w2);

  2490.             s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);

  2491.             s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);

  2492.             s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);

  2493.             s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);

  2494.             s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);

  2495.             s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);

  2496.             s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);

  2497.             s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);

  2498.             s->sprite_shift[0][0]= alpha+rho;

  2499.             s->sprite_shift[0][1]= alpha+rho;

  2500.             s->sprite_shift[1][0]= alpha+rho+2;

  2501.             s->sprite_shift[1][1]= alpha+rho+2;

  2502.             break;

  2503. //        case 3:

  2504.             break;

  2505.     }

  2506. /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);

  2507. printf("%d %d\n", s->sprite_delta[0][0][1], 0);

  2508. printf("%d %d\n", s->sprite_delta[0][1][0], 0);

  2509. printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);

  2510. printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);

  2511. printf("%d %d\n", s->sprite_delta[1][0][1], 0);

  2512. printf("%d %d\n", s->sprite_delta[1][1][0], 0);

  2513. printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/

  2514.     /* try to simplify the situation */ 

  2515.     if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]

  2516.        && s->sprite_delta[0][0][1] == 0

  2517.        && s->sprite_delta[0][1][0] == 0

  2518.        && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]

  2519.        && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]

  2520.        && s->sprite_delta[1][0][1] == 0

  2521.        && s->sprite_delta[1][1][0] == 0

  2522.        && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])

  2523.     {

  2524.         s->sprite_offset[0][0]>>=s->sprite_shift[0][0];

  2525.         s->sprite_offset[0][1]>>=s->sprite_shift[0][1];

  2526.         s->sprite_offset[1][0]>>=s->sprite_shift[1][0];

  2527.         s->sprite_offset[1][1]>>=s->sprite_shift[1][1];

  2528.         s->sprite_delta[0][0][0]= a;

  2529.         s->sprite_delta[0][0][1]= 0;

  2530.         s->sprite_delta[0][1][0]= 0;

  2531.         s->sprite_delta[0][1][1]= a;

  2532.         s->sprite_delta[1][0][0]= a;

  2533.         s->sprite_delta[1][0][1]= 0;

  2534.         s->sprite_delta[1][1][0]= 0;

  2535.         s->sprite_delta[1][1][1]= a;

  2536.         s->sprite_shift[0][0]= 0;

  2537.         s->sprite_shift[0][1]= 0;

  2538.         s->sprite_shift[1][0]= 0;

  2539.         s->sprite_shift[1][1]= 0;

  2540.         s->real_sprite_warping_points=1;

  2541.     }

  2542.     else

  2543.         s->real_sprite_warping_points= s->num_sprite_warping_points;

  2544. 

  2545. //printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);

  2546. }

  2547. 

  2548. /* decode mpeg4 VOP header */

  2549. int mpeg4_decode_picture_header(MpegEncContext * s)

  2550. {

  2551.     int time_incr, startcode, state, v;

  2552.     int time_increment;

  2553. 

  2554.  redo:

  2555.     /* search next start code */

  2556.     align_get_bits(&s->gb);

  2557.     state = 0xff;

  2558.     for(;;) {

  2559.         v = get_bits(&s->gb, 8);

  2560.         if (state == 0x000001) {

  2561.             state = ((state << 8) | v) & 0xffffff;

  2562.             startcode = state;

  2563.             break;

  2564.         }

  2565.         state = ((state << 8) | v) & 0xffffff;

  2566.         if( get_bits_count(&s->gb) > s->gb.size*8-32){

  2567.             printf("no VOP startcode found\n");

  2568.             return -1;

  2569.         }

  2570.     }

  2571. //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));

  2572.     if (startcode == 0x120) { // Video Object Layer

  2573.         int width, height, vo_ver_id;

  2574. 

  2575.         /* vol header */

  2576.         skip_bits(&s->gb, 1); /* random access */

  2577.         skip_bits(&s->gb, 8); /* vo_type */

  2578.         if (get_bits1(&s->gb) != 0) { /* is_ol_id */

  2579.             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */

  2580.             skip_bits(&s->gb, 3); /* vo_priority */

  2581.         } else {

  2582.             vo_ver_id = 1;

  2583.         }

  2584.         

  2585.         s->aspect_ratio_info= get_bits(&s->gb, 4);

  2586. 	if(s->aspect_ratio_info == EXTENDET_PAR){

  2587.             skip_bits(&s->gb, 8); //par_width

  2588.             skip_bits(&s->gb, 8); // par_height

  2589.         }

  2590. 

  2591.         if(get_bits1(&s->gb)){ /* vol control parameter */

  2592.             printf("vol control parameter not supported\n");

  2593.             return -1;   

  2594.         }

  2595.         s->shape = get_bits(&s->gb, 2); /* vol shape */

  2596.         if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");

  2597.         if(s->shape == GRAY_SHAPE && vo_ver_id != 1){

  2598.             printf("Gray shape not supported\n");

  2599.             skip_bits(&s->gb, 4);  //video_object_layer_shape_extension

  2600.         }

  2601. 

  2602.         skip_bits1(&s->gb);   /* marker */

  2603.         

  2604.         s->time_increment_resolution = get_bits(&s->gb, 16);

  2605.         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;

  2606.         if (s->time_increment_bits < 1)

  2607.             s->time_increment_bits = 1;

  2608.         skip_bits1(&s->gb);   /* marker */

  2609. 

  2610.         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */

  2611.             skip_bits(&s->gb, s->time_increment_bits);

  2612.         }

  2613. 

  2614.         if (s->shape != BIN_ONLY_SHAPE) {

  2615.             if (s->shape == RECT_SHAPE) {

  2616.                 skip_bits1(&s->gb);   /* marker */

  2617.                 width = get_bits(&s->gb, 13);

  2618.                 skip_bits1(&s->gb);   /* marker */

  2619.                 height = get_bits(&s->gb, 13);

  2620.                 skip_bits1(&s->gb);   /* marker */

  2621.                 if(width && height){ /* they should be non zero but who knows ... */

  2622.                     s->width = width;

  2623.                     s->height = height;

  2624. //                    printf("width/height: %d %d\n", width, height);

  2625.                 }

  2626.             }

  2627.             

  2628.             if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */

  2629.             if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */

  2630.             if (vo_ver_id == 1) {

  2631.                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */

  2632.             } else {

  2633.                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */

  2634.             }

  2635.             if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");

  2636.             if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){

  2637.                 if(s->vol_sprite_usage==STATIC_SPRITE){

  2638.                     s->sprite_width = get_bits(&s->gb, 13);

  2639.                     skip_bits1(&s->gb); /* marker */

  2640.                     s->sprite_height= get_bits(&s->gb, 13);

  2641.                     skip_bits1(&s->gb); /* marker */

  2642.                     s->sprite_left  = get_bits(&s->gb, 13);

  2643.                     skip_bits1(&s->gb); /* marker */

  2644.                     s->sprite_top   = get_bits(&s->gb, 13);

  2645.                     skip_bits1(&s->gb); /* marker */

  2646.                 }

  2647.                 s->num_sprite_warping_points= get_bits(&s->gb, 6);

  2648.                 s->sprite_warping_accuracy = get_bits(&s->gb, 2);

  2649.                 s->sprite_brightness_change= get_bits1(&s->gb);

  2650.                 if(s->vol_sprite_usage==STATIC_SPRITE)

  2651.                     s->low_latency_sprite= get_bits1(&s->gb);            

  2652.             }

  2653.             // FIXME sadct disable bit if verid!=1 && shape not rect

  2654.             

  2655.             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */

  2656.                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */

  2657.                 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */

  2658.                 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);

  2659.             } else {

  2660.                 s->quant_precision = 5;

  2661.             }

  2662.             

  2663.             // FIXME a bunch of grayscale shape things

  2664. 

  2665.             if(get_bits1(&s->gb)){ /* vol_quant_type */

  2666.                 int i, j, v;

  2667.                 /* load default matrixes */

  2668.                 for(i=0; i<64; i++){

  2669.                     v= ff_mpeg4_default_intra_matrix[i];

  2670.                     s->intra_matrix[i]= v;

  2671.                     s->chroma_intra_matrix[i]= v;

  2672.                     

  2673.                     v= ff_mpeg4_default_non_intra_matrix[i];

  2674.                     s->non_intra_matrix[i]= v;

  2675.                     s->chroma_non_intra_matrix[i]= v;

  2676.                 }

  2677. 

  2678.                 /* load custom intra matrix */

  2679.                 if(get_bits1(&s->gb)){

  2680.                     for(i=0; i<64; i++){

  2681.                         v= get_bits(&s->gb, 8);

  2682.                         if(v==0) break;

  2683. 

  2684.                         j= zigzag_direct[i];

  2685.                         s->intra_matrix[j]= v;

  2686.                         s->chroma_intra_matrix[j]= v;

  2687.                     }

  2688.                 }

  2689. 

  2690.                 /* load custom non intra matrix */

  2691.                 if(get_bits1(&s->gb)){

  2692.                     for(i=0; i<64; i++){

  2693.                         v= get_bits(&s->gb, 8);

  2694.                         if(v==0) break;

  2695. 

  2696.                         j= zigzag_direct[i];

  2697.                         s->non_intra_matrix[j]= v;

  2698.                         s->chroma_non_intra_matrix[j]= v;

  2699.                     }

  2700. 

  2701.                     /* replicate last value */

  2702.                     for(; i<64; i++){

  2703.                         j= zigzag_direct[i];

  2704.                         s->non_intra_matrix[j]= v;

  2705.                         s->chroma_non_intra_matrix[j]= v;

  2706.                     }

  2707.                 }

  2708. 

  2709.                 s->dct_unquantize= s->dct_unquantize_mpeg2;

  2710. 

  2711.                 // FIXME a bunch of grayscale shape things

  2712.             }else

  2713.                 s->dct_unquantize= s->dct_unquantize_h263;

  2714. 

  2715.             if(vo_ver_id != 1)

  2716.                  s->quarter_sample= get_bits1(&s->gb);

  2717.             else s->quarter_sample=0;

  2718. 

  2719.             if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");

  2720. 

  2721.             s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */

  2722. 

  2723.             s->data_partioning= get_bits1(&s->gb);

  2724.             if(s->data_partioning){

  2725.                 printf("data partitioning not supported\n");

  2726.                 skip_bits1(&s->gb); // reversible vlc

  2727.             }

  2728.             

  2729.             if(vo_ver_id != 1) {

  2730.                 s->new_pred= get_bits1(&s->gb);

  2731.                 if(s->new_pred){

  2732.                     printf("new pred not supported\n");

  2733.                     skip_bits(&s->gb, 2); /* requested upstream message type */

  2734.                     skip_bits1(&s->gb); /* newpred segment type */

  2735.                 }

  2736.                 s->reduced_res_vop= get_bits1(&s->gb);

  2737.                 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");

  2738.             }

  2739.             else{

  2740.                 s->new_pred=0;

  2741.                 s->reduced_res_vop= 0;

  2742.             }

  2743. 

  2744.             s->scalability= get_bits1(&s->gb);

  2745.             if (s->scalability) {

  2746.                 printf("scalability not supported\n");

  2747.             }

  2748.         }

  2749. //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);

  2750.         goto redo;

  2751.     } else if (startcode == 0x1b2) { //userdata

  2752.         char buf[256];

  2753.         int i;

  2754.         int e;

  2755.         int ver, build;

  2756. 

  2757. //printf("user Data %X\n", show_bits(&s->gb, 32));

  2758.         buf[0]= show_bits(&s->gb, 8);

  2759.         for(i=1; i<256; i++){

  2760.             buf[i]= show_bits(&s->gb, 16)&0xFF;

  2761.             if(buf[i]==0) break;

  2762.             skip_bits(&s->gb, 8);

  2763.         }

  2764.         buf[255]=0;

  2765.         e=sscanf(buf, "DivX%dBuild%d", &ver, &build);

  2766.         if(e==2){

  2767.             s->divx_version= ver;

  2768.             s->divx_build= build;

  2769.             if(s->picture_number==0){

  2770.                 printf("This file was encoded with DivX%d Build%d\n", ver, build);

  2771.                 if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...

  2772.                     printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");

  2773.                 }else{

  2774.                     printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"

  2775.                            "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");

  2776.                 }

  2777.             }

  2778.         }

  2779. //printf("User Data: %s\n", buf);

  2780.         goto redo;

  2781.     } else if (startcode != 0x1b6) { //VOP

  2782.         goto redo;

  2783.     }

  2784. 

  2785.     s->pict_type = get_bits(&s->gb, 2) + 1;	/* pict type: I = 0 , P = 1 */

  2786. // printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample); 

  2787.     time_incr=0;

  2788.     while (get_bits1(&s->gb) != 0) 

  2789.         time_incr++;

  2790. 

  2791.     check_marker(&s->gb, "before time_increment");

  2792.     time_increment= get_bits(&s->gb, s->time_increment_bits);

  2793. //printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);

  2794.     if(s->pict_type!=B_TYPE){

  2795.         s->last_time_base= s->time_base;

  2796.         s->time_base+= time_incr;

  2797.         s->time= s->time_base*s->time_increment_resolution + time_increment;

  2798.         s->pp_time= s->time - s->last_non_b_time;

  2799.         s->last_non_b_time= s->time;

  2800.     }else{

  2801.         s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;

  2802.         s->bp_time= s->last_non_b_time - s->time;

  2803.     }

  2804. 

  2805.     if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){

  2806.         printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");

  2807.         for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){

  2808.             if(get_bits1(&s->gb)) break;

  2809.         }

  2810.         printf("my guess is %d bits ;)\n",s->time_increment_bits);

  2811.     }

  2812.     /* vop coded */

  2813.     if (get_bits1(&s->gb) != 1)

  2814.         goto redo;

  2815. //printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,

  2816. //s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  

  2817.     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE

  2818.                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {

  2819.         /* rounding type for motion estimation */

  2820. 	s->no_rounding = get_bits1(&s->gb);

  2821.     } else {

  2822. 	s->no_rounding = 0;

  2823.     }

  2824. //FIXME reduced res stuff

  2825. 

  2826.      if (s->shape != RECT_SHAPE) {

  2827.          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {

  2828.              int width, height, hor_spat_ref, ver_spat_ref;

  2829.  

  2830.              width = get_bits(&s->gb, 13);

  2831.              skip_bits1(&s->gb);   /* marker */

  2832.              height = get_bits(&s->gb, 13);

  2833.              skip_bits1(&s->gb);   /* marker */

  2834.              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */

  2835.              skip_bits1(&s->gb);   /* marker */

  2836.              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */

  2837.          }

  2838.          skip_bits1(&s->gb); /* change_CR_disable */

  2839.  

  2840.          if (get_bits1(&s->gb) != 0) {

  2841.              skip_bits(&s->gb, 8); /* constant_alpha_value */

  2842.          }

  2843.      }

  2844. //FIXME complexity estimation stuff

  2845.      

  2846.      if (s->shape != BIN_ONLY_SHAPE) {

  2847.          int t;

  2848.          t=get_bits(&s->gb, 3); /* intra dc VLC threshold */

  2849. //printf("threshold %d\n", t);

  2850.          //FIXME interlaced specific bits

  2851.      }

  2852. 

  2853.      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){

  2854.          if(s->num_sprite_warping_points){

  2855.              mpeg4_decode_sprite_trajectory(s);

  2856.          }

  2857.          if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");

  2858.          if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");

  2859.      }

  2860. 

  2861.      if (s->shape != BIN_ONLY_SHAPE) {

  2862.          /* note: we do not use quant_precision to avoid problem if no

  2863.             MPEG4 vol header as it is found on some old opendivx

  2864.             movies */

  2865.          s->qscale = get_bits(&s->gb, 5);

  2866.          if(s->qscale==0){

  2867.              printf("Error, header damaged or not MPEG4 header (qscale=0)\n");

  2868.              return -1; // makes no sense to continue, as there is nothing left from the image then

  2869.          }

  2870.   

  2871.          if (s->pict_type != I_TYPE) {

  2872.              s->f_code = get_bits(&s->gb, 3);	/* fcode_for */

  2873.              if(s->f_code==0){

  2874.                  printf("Error, header damaged or not MPEG4 header (f_code=0)\n");

  2875.                  return -1; // makes no sense to continue, as the MV decoding will break very quickly

  2876.              }

  2877.          }

  2878.          if (s->pict_type == B_TYPE) {

  2879.              s->b_code = get_bits(&s->gb, 3);

  2880. //printf("b-code %d\n", s->b_code);

  2881.          }

  2882. //printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);

  2883.          if(!s->scalability){

  2884.              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {

  2885.                  skip_bits1(&s->gb); // vop shape coding type

  2886.              }

  2887.          }

  2888.      }

  2889.      s->picture_number++; // better than pic number==0 allways ;)

  2890.      return 0;

  2891. }

  2892. 

  2893. /* don't understand why they choose a different header ! */

  2894. int intel_h263_decode_picture_header(MpegEncContext *s)

  2895. {

  2896.     int format;

  2897. 

  2898.     /* picture header */

  2899.     if (get_bits(&s->gb, 22) != 0x20)

  2900.         return -1;

  2901.     skip_bits(&s->gb, 8); /* picture timestamp */

  2902. 

  2903.     if (get_bits1(&s->gb) != 1)

  2904.         return -1;	/* marker */

  2905.     if (get_bits1(&s->gb) != 0)

  2906.         return -1;	/* h263 id */

  2907.     skip_bits1(&s->gb);	/* split screen off */

  2908.     skip_bits1(&s->gb);	/* camera  off */

  2909.     skip_bits1(&s->gb);	/* freeze picture release off */

  2910. 

  2911.     format = get_bits(&s->gb, 3);

  2912.     if (format != 7)

  2913.         return -1;

  2914. 

  2915.     s->h263_plus = 0;

  2916. 

  2917.     s->pict_type = I_TYPE + get_bits1(&s->gb);

  2918.     

  2919.     s->unrestricted_mv = get_bits1(&s->gb); 

  2920.     s->h263_long_vectors = s->unrestricted_mv;

  2921. 

  2922.     if (get_bits1(&s->gb) != 0)

  2923.         return -1;	/* SAC: off */

  2924.     if (get_bits1(&s->gb) != 0)

  2925.         return -1;	/* advanced prediction mode: off */

  2926.     if (get_bits1(&s->gb) != 0)

  2927.         return -1;	/* not PB frame */

  2928. 

  2929.     /* skip unknown header garbage */

  2930.     skip_bits(&s->gb, 41);

  2931. 

  2932.     s->qscale = get_bits(&s->gb, 5);

  2933.     skip_bits1(&s->gb);	/* Continuous Presence Multipoint mode: off */

  2934. 

  2935.     /* PEI */

  2936.     while (get_bits1(&s->gb) != 0) {

  2937.         skip_bits(&s->gb, 8);

  2938.     }

  2939.     s->f_code = 1;

  2940.     return 0;

  2941. }