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.
464 Commits
32 Branches
325MB
Tree: 44eb495128
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '44eb495128'
${ noResults }
FFmpeg/libavcodec/h263.c

2036 lines
64KB
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. #include "common.h"

  22. #include "dsputil.h"

  23. #include "avcodec.h"

  24. #include "mpegvideo.h"

  25. #include "h263data.h"

  26. #include "mpeg4data.h"

  27. 

  28. //rounded divison & shift

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

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

  31. 

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

  33. 			      int n);

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

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

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

  37. 			       int n);

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

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

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

  41.                              int n, int coded);

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

  43.                               int n, int coded);

  44. 

  45. int h263_get_picture_format(int width, int height)

  46. {

  47.     int format;

  48. 

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

  50. 	format = 1;

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

  52. 	format = 2;

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

  54. 	format = 3;

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

  56. 	format = 4;

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

  58. 	format = 5;

  59.     else

  60.         format = 7;

  61.     return format;

  62. }

  63. 

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

  65. {

  66.     int format;

  67. 

  68.     align_put_bits(&s->pb);

  69. 

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

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

  72.     s->gob_number = 0;

  73. 

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

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

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

  77. 

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

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

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

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

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

  83.     

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

  85.     if (!s->h263_plus) {

  86.         /* H.263v1 */

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

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

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

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

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

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

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

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

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

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

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

  98.     } else {

  99.         /* H.263v2 */

  100.         /* H.263 Plus PTYPE */

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

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

  103.         if (format == 7)

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

  105.         else

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

  107.             

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

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

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

  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); /* Advanced Intra Coding: off */

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

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

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

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

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

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

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

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

  122. 		

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

  124. 		

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

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

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

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

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

  130. 		

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

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

  133. 		

  134. 		if (format == 7) {

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

  136. 		

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

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

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

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

  141.         }

  142.         

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

  144.         if (s->umvplus)

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

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

  147.     }

  148. 

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

  150. }

  151. 

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

  153. {

  154.     int pdif=0;

  155.     

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

  157.     /* for RTP packetization                    */

  158.     if (s->rtp_mode) {

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

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

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

  162.             align_put_bits(&s->pb);

  163.             flush_put_bits(&s->pb);

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

  165.             if (s->rtp_callback) {

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

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

  168.             }

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

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

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

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

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

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

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

  176.             return pdif;

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

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

  179.            align_put_bits(&s->pb);

  180.            flush_put_bits(&s->pb);

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

  182.            if (s->rtp_callback) {

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

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

  185.            }

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

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

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

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

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

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

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

  193.            return pdif;

  194.        }

  195.    }

  196.    return 0;

  197. }

  198.     

  199. void h263_encode_mb(MpegEncContext * s,

  200. 		    DCTELEM block[6][64],

  201. 		    int motion_x, int motion_y)

  202. {

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

  204.    

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

  206.    if (!s->mb_intra) {

  207. 	   /* compute cbp */

  208. 	   cbp = 0;

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

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

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

  212. 	   }

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

  214. 	      /* skip macroblock */

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

  216. 	      return;

  217. 	   }

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

  219. 	   cbpc = cbp & 3;

  220. 	   put_bits(&s->pb,

  221. 		inter_MCBPC_bits[cbpc],

  222. 		inter_MCBPC_code[cbpc]);

  223. 	   cbpy = cbp >> 2;

  224. 	   cbpy ^= 0xf;

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

  226. 

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

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

  229.       

  230.       if (!s->umvplus) {  

  231.          h263_encode_motion(s, motion_x - pred_x);

  232.          h263_encode_motion(s, motion_y - pred_y);

  233.       }

  234.       else {

  235.          h263p_encode_umotion(s, motion_x - pred_x);

  236.          h263p_encode_umotion(s, motion_y - pred_y);

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

  238.             /* To prevent Start Code emulation */

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

  240.       }

  241.    } else {

  242. 	/* compute cbp */

  243. 	cbp = 0;

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

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

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

  247. 	}

  248. 

  249. 	cbpc = cbp & 3;

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

  251. 	    put_bits(&s->pb,

  252. 		     intra_MCBPC_bits[cbpc],

  253. 		     intra_MCBPC_code[cbpc]);

  254. 	} else {

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

  256. 	    put_bits(&s->pb,

  257. 		     inter_MCBPC_bits[cbpc + 4],

  258. 		     inter_MCBPC_code[cbpc + 4]);

  259. 	}

  260. 	if (s->h263_pred) {

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

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

  263. 	}

  264. 	cbpy = cbp >> 2;

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

  266.     }

  267. 

  268.     /* encode each block */

  269.     if (s->h263_pred) {

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

  271. 	    mpeg4_encode_block(s, block[i], i);

  272. 	}

  273.     } else {

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

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

  276. 	}

  277.     }

  278. }

  279. 

  280. 

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

  282. {

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

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

  285. 

  286.     /* find prediction */

  287.     if (n < 4) {

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

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

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

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

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

  293.         scale = s->y_dc_scale;

  294.     } else {

  295.         x = s->mb_x + 1;

  296.         y = s->mb_y + 1;

  297.         wrap = s->mb_width + 2;

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

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

  300.         scale = s->c_dc_scale;

  301.     }

  302.     

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

  304.     ac_val1 = ac_val;

  305.     

  306.     /* B C

  307.      * A X 

  308.      */

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

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

  311.     

  312.     pred_dc = 1024;

  313.     if (s->ac_pred) {

  314.         if (s->h263_aic_dir) {

  315.             /* left prediction */

  316.             if (a != 1024) {

  317.                 ac_val -= 16;

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

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

  320.                 }

  321.                 pred_dc = a;

  322.             }

  323.         } else {

  324.             /* top prediction */

  325.             if (c != 1024) {

  326.                 ac_val -= 16 * wrap;

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

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

  329.                 }

  330.                 pred_dc = c;

  331.             }

  332.         }

  333.     } else {

  334.         /* just DC prediction */

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

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

  337.         else if (a != 1024)

  338.             pred_dc = a;

  339.         else

  340.             pred_dc = c;

  341.     }

  342.     

  343.     /* we assume pred is positive */

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

  345.     

  346.     if (block[0] < 0)

  347.         block[0] = 0;

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

  349.         block[0]++;

  350.     

  351.     /* Update AC/DC tables */

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

  353.     

  354.     /* left copy */

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

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

  357.     /* top copy */

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

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

  360. }

  361. 

  362. 

  363. static inline int mid_pred(int a, int b, int c)

  364. {

  365.     int vmin, vmax;

  366.     vmax = vmin = a;

  367.     if (b < vmin)

  368.         vmin = b;

  369.     else

  370. 	vmax = b;

  371. 

  372.     if (c < vmin)

  373.         vmin = c;

  374.     else if (c > vmax)

  375.         vmax = c;

  376. 

  377.     return a + b + c - vmin - vmax;

  378. }

  379. 

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

  381.                         int *px, int *py)

  382. {

  383.     int xy, y, wrap;

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

  385. 

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

  387.     y = xy = 2 * s->mb_y + 1 + ((block >> 1) & 1); // y

  388.     xy *= wrap; // y * wrap

  389.     xy += 2 * s->mb_x + 1 + (block & 1); // x + y * wrap

  390. 

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

  392. 

  393.     /* special case for first line */

  394.     if (y == 1 || s->first_slice_line || s->first_gob_line) {

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

  396.         *px = A[0];

  397.         *py = A[1];

  398.     } else {

  399.         switch(block) {

  400.         default:

  401.         case 0:

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

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

  404.             C = s->motion_val[xy + 2 - wrap];

  405.             break;

  406.         case 1:

  407.         case 2:

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

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

  410.             C = s->motion_val[xy + 1 - wrap];

  411.             break;

  412.         case 3:

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

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

  415.             C = s->motion_val[xy - wrap];

  416.             break;

  417.         }

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

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

  420.     }

  421.     return mot_val;

  422. }

  423. 

  424. 

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

  426. {

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

  428. 

  429.     if (val == 0) {

  430.         /* zero vector */

  431.         code = 0;

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

  433.     } else {

  434.         bit_size = s->f_code - 1;

  435.         range = 1 << bit_size;

  436.         /* modulo encoding */

  437.         l = range * 32;

  438.         m = 2 * l;

  439.         if (val < -l) {

  440.             val += m;

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

  442.             val -= m;

  443.         }

  444. 

  445.         if (val >= 0) {

  446.             val--;

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

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

  449.             sign = 0;

  450.         } else {

  451.             val = -val;

  452.             val--;

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

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

  455.             sign = 1;

  456.         }

  457. 

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

  459.         if (bit_size > 0) {

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

  461.         }

  462.     }

  463. }

  464. 

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

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

  467. {

  468.     short sval = 0; 

  469.     short i = 0;

  470.     short n_bits = 0;

  471.     short temp_val;

  472.     int code = 0;

  473.     int tcode;

  474.     

  475.     if ( val == 0)

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

  477.     else if (val == 1)

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

  479.     else if (val == -1)

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

  481.     else {

  482.         

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

  484.         temp_val = sval;

  485.         

  486.         while (temp_val != 0) {

  487.             temp_val = temp_val >> 1;

  488.             n_bits++;

  489.         }

  490.         

  491.         i = n_bits - 1;

  492.         while (i > 0) {

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

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

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

  496.             i--;

  497.         }

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

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

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

  501.     }

  502. }

  503. 

  504. void h263_encode_init_vlc(MpegEncContext *s)

  505. {

  506.     static int done = 0;

  507. 

  508.     if (!done) {

  509.         done = 1;

  510.         init_rl(&rl_inter);

  511.         init_rl(&rl_intra);

  512.     }

  513. }

  514. 

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

  516. {

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

  518.     int code;

  519.     RLTable *rl = &rl_inter;

  520. 

  521.     if (s->mb_intra) {

  522.         /* DC coef */

  523. 	    level = block[0];

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

  525.         if (level > 254) {

  526.             level = 254;

  527.             block[0] = 254;

  528.         }

  529.         /* 0 cannot be represented also */

  530.         else if (!level) {

  531.             level = 1;

  532.             block[0] = 1;

  533.         }

  534. 	    if (level == 128)

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

  536. 	    else

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

  538. 	    i = 1;

  539.     } else {

  540. 	    i = 0;

  541.     }

  542. 

  543.     /* AC coefs */

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

  545.     last_non_zero = i - 1;

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

  547. 	j = zigzag_direct[i];

  548. 	level = block[j];

  549. 	if (level) {

  550. 	    run = i - last_non_zero - 1;

  551. 	    last = (i == last_index);

  552. 	    sign = 0;

  553. 	    slevel = level;

  554. 	    if (level < 0) {

  555. 		sign = 1;

  556. 		level = -level;

  557. 	    }

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

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

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

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

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

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

  564.             } else {

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

  566.             }

  567. 	    last_non_zero = i;

  568. 	}

  569.     }

  570. }

  571. 

  572. /***************************************************/

  573. 

  574. /* write mpeg4 VOP header */

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

  576. {

  577.     align_put_bits(&s->pb);

  578. 

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

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

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

  582.     /* XXX: time base + 1 not always correct */

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

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

  585. 

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

  587.     put_bits(&s->pb, 4, 1);	/* XXX: correct time increment */

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

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

  590.     if (s->pict_type == P_TYPE) {

  591.         s->no_rounding = 0;

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

  593.     }

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

  595. 

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

  597. 

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

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

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

  601. }

  602. 

  603. void h263_dc_scale(MpegEncContext * s)

  604. {

  605.     int quant;

  606. 

  607.     quant = s->qscale;

  608.     /* luminance */

  609.     if (quant < 5)

  610. 	s->y_dc_scale = 8;

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

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

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

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

  615.     else

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

  617.     /* chrominance */

  618.     if (quant < 5)

  619. 	s->c_dc_scale = 8;

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

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

  622.     else

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

  624. }

  625. 

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

  627. {

  628.     int a, b, c, xy, wrap, pred, scale;

  629.     UINT16 *dc_val;

  630. 

  631.     /* find prediction */

  632.     if (n < 4) {

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

  634. 	xy = 2 * s->mb_y + 1 + ((n & 2) >> 1);

  635.         xy *= wrap;

  636. 	xy += 2 * s->mb_x + 1 + (n & 1);

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

  638. 	scale = s->y_dc_scale;

  639.     } else {

  640. 	wrap = s->mb_width + 2;

  641. 	xy = s->mb_y + 1;

  642. 	xy *= wrap;

  643. 	xy += s->mb_x + 1;

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

  645. 	scale = s->c_dc_scale;

  646.     }

  647. 

  648.     /* B C

  649.      * A X 

  650.      */

  651.     a = dc_val[xy - 1];

  652.     b = dc_val[xy - 1 - wrap];

  653.     c = dc_val[xy - wrap];

  654. 

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

  656. 	pred = c;

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

  658.     } else {

  659. 	pred = a;

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

  661.     }

  662.     /* we assume pred is positive */

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

  664. 

  665.     /* prepare address for prediction update */

  666.     *dc_val_ptr = &dc_val[xy];

  667. 

  668.     return pred;

  669. }

  670. 

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

  672.                    int dir)

  673. {

  674.     int x, y, wrap, i;

  675.     INT16 *ac_val, *ac_val1;

  676. 

  677.     /* find prediction */

  678.     if (n < 4) {

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

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

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

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

  683.     } else {

  684. 	x = s->mb_x + 1;

  685. 	y = s->mb_y + 1;

  686. 	wrap = s->mb_width + 2;

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

  688.     }

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

  690.     ac_val1 = ac_val;

  691.     if (s->ac_pred) {

  692.         if (dir == 0) {

  693.             /* left prediction */

  694.             ac_val -= 16;

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

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

  697.             }

  698.         } else {

  699.             /* top prediction */

  700.             ac_val -= 16 * wrap;

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

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

  703.             }

  704.         }

  705.     }

  706.     /* left copy */

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

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

  709.     /* top copy */

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

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

  712. }

  713. 

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

  715. {

  716.     int size, v, pred;

  717.     UINT16 *dc_val;

  718. 

  719.     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);

  720.     if (n < 4) {

  721.         *dc_val = level * s->y_dc_scale;

  722.     } else {

  723.         *dc_val = level * s->c_dc_scale;

  724.     }

  725. 

  726.     /* do the prediction */

  727.     level -= pred;

  728.     /* find number of bits */

  729.     size = 0;

  730.     v = abs(level);

  731.     while (v) {

  732. 	v >>= 1;

  733. 	size++;

  734.     }

  735. 

  736.     if (n < 4) {

  737. 	/* luminance */

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

  739.     } else {

  740. 	/* chrominance */

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

  742.     }

  743. 

  744.     /* encode remaining bits */

  745.     if (size > 0) {

  746. 	if (level < 0)

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

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

  749. 	if (size > 8)

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

  751.     }

  752. }

  753. 

  754. static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)

  755. {

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

  757.     int code, dc_pred_dir;

  758.     const RLTable *rl;

  759. 

  760.     if (s->mb_intra) {

  761. 	/* mpeg4 based DC predictor */

  762. 	mpeg4_encode_dc(s, block[0], n, &dc_pred_dir);

  763. 	i = 1;

  764.         rl = &rl_intra;

  765.     } else {

  766. 	i = 0;

  767.         rl = &rl_inter;

  768.     }

  769. 

  770.     /* AC coefs */

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

  772.     last_non_zero = i - 1;

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

  774. 	j = zigzag_direct[i];

  775. 	level = block[j];

  776. 	if (level) {

  777. 	    run = i - last_non_zero - 1;

  778. 	    last = (i == last_index);

  779. 	    sign = 0;

  780. 	    slevel = level;

  781. 	    if (level < 0) {

  782. 		sign = 1;

  783. 		level = -level;

  784. 	    }

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

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

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

  788.                 int level1, run1;

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

  790.                 if (level1 < 1) 

  791.                     goto esc2;

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

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

  794.                 esc2:

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

  796.                     if (level > MAX_LEVEL)

  797.                         goto esc3;

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

  799.                     if (run1 < 0)

  800.                         goto esc3;

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

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

  803.                     esc3:

  804.                         /* third escape */

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

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

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

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

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

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

  811.                     } else {

  812.                         /* second escape */

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

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

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

  816.                     }

  817.                 } else {

  818.                     /* first escape */

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

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

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

  822.                 }

  823.             } else {

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

  825.             }

  826. 	    last_non_zero = i;

  827. 	}

  828.     }

  829. }

  830. 

  831. 

  832. 

  833. /***********************************************/

  834. /* decoding */

  835. 

  836. static VLC intra_MCBPC_vlc;

  837. static VLC inter_MCBPC_vlc;

  838. static VLC cbpy_vlc;

  839. static VLC mv_vlc;

  840. static VLC dc_lum, dc_chrom;

  841. static VLC sprite_trajectory;

  842. 

  843. void init_rl(RLTable *rl)

  844. {

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

  846.     UINT8 index_run[MAX_RUN+1];

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

  848. 

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

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

  851.         if (last == 0) {

  852.             start = 0;

  853.             end = rl->last;

  854.         } else {

  855.             start = rl->last;

  856.             end = rl->n;

  857.         }

  858. 

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

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

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

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

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

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

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

  866.                 index_run[run] = i;

  867.             if (level > max_level[run])

  868.                 max_level[run] = level;

  869.             if (run > max_run[level])

  870.                 max_run[level] = run;

  871.         }

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

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

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

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

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

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

  878.     }

  879. }

  880. 

  881. void init_vlc_rl(RLTable *rl)

  882. {

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

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

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

  886. }

  887. 

  888. /* init vlcs */

  889. 

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

  891. void h263_decode_init_vlc(MpegEncContext *s)

  892. {

  893.     static int done = 0;

  894. 

  895.     if (!done) {

  896.         done = 1;

  897. 

  898.         init_vlc(&intra_MCBPC_vlc, 6, 8, 

  899.                  intra_MCBPC_bits, 1, 1,

  900.                  intra_MCBPC_code, 1, 1);

  901.         init_vlc(&inter_MCBPC_vlc, 9, 25, 

  902.                  inter_MCBPC_bits, 1, 1,

  903.                  inter_MCBPC_code, 1, 1);

  904.         init_vlc(&cbpy_vlc, 6, 16,

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

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

  907.         init_vlc(&mv_vlc, 9, 33,

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

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

  910.         init_rl(&rl_inter);

  911.         init_rl(&rl_intra);

  912.         init_rl(&rl_intra_aic);

  913.         init_vlc_rl(&rl_inter);

  914.         init_vlc_rl(&rl_intra);

  915.         init_vlc_rl(&rl_intra_aic);

  916.         init_vlc(&dc_lum, 9, 13,

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

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

  919.         init_vlc(&dc_chrom, 9, 13,

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

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

  922.         init_vlc(&sprite_trajectory, 9, 15,

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

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

  925.     }

  926. }

  927. 

  928. int h263_decode_gob_header(MpegEncContext *s)

  929. {

  930.     unsigned int val, gfid;

  931.     

  932.     /* Check for GOB Start Code */

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

  934.     if (val == 0) {

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

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

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

  938. #ifdef DEBUG

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

  940. #endif

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

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

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

  944. #ifdef DEBUG

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

  946. #endif

  947.         return 1;

  948.     }

  949.     return 0;

  950.             

  951. }

  952. 

  953. int h263_decode_mb(MpegEncContext *s,

  954.                    DCTELEM block[6][64])

  955. {

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

  957.     INT16 *mot_val;

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

  959.     

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

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

  962.             /* skip mb */

  963.             s->mb_intra = 0;

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

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

  966.             s->mv_dir = MV_DIR_FORWARD;

  967.             s->mv_type = MV_TYPE_16X16;

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

  969.                 const int a= s->sprite_warping_accuracy;

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

  971. 

  972.                 s->mcsel=1;

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

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

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

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

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

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

  979. 

  980.                 s->mb_skiped = 0;

  981.             }else{

  982.                 s->mcsel=0;

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

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

  985.                 s->mb_skiped = 1;

  986.             }

  987.             return 0;

  988.         }

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

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

  991.         if (cbpc < 0)

  992.             return -1;

  993.         if (cbpc > 20)

  994.             cbpc+=3;

  995.         else if (cbpc == 20)

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

  997.         

  998.         dquant = cbpc & 8;

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

  1000.     } else {

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

  1002.         if (cbpc < 0)

  1003.             return -1;

  1004.         dquant = cbpc & 4;

  1005.         s->mb_intra = 1;

  1006.     }

  1007. 

  1008.     if (!s->mb_intra) {

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

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

  1011.         else s->mcsel= 0;

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

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

  1014.         if (dquant) {

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

  1016.             if (s->qscale < 1)

  1017.                 s->qscale = 1;

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

  1019.                 s->qscale = 31;

  1020.         }

  1021.         s->mv_dir = MV_DIR_FORWARD;

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

  1023.             /* 16x16 motion prediction */

  1024.             s->mv_type = MV_TYPE_16X16;

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

  1026.             if (s->umvplus_dec)

  1027.                mx = h263p_decode_umotion(s, pred_x);

  1028.             else if(!s->mcsel)

  1029.                mx = h263_decode_motion(s, pred_x);

  1030.             else {

  1031.                const int a= s->sprite_warping_accuracy;

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

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

  1034. //        if (mx < -l) mx= -l;

  1035. //        else if (mx >= l) mx= l-1;

  1036.             }

  1037.             if (mx >= 0xffff)

  1038.                 return -1;

  1039.             

  1040.             if (s->umvplus_dec)

  1041.                my = h263p_decode_umotion(s, pred_y);

  1042.             else if(!s->mcsel)

  1043.                my = h263_decode_motion(s, pred_y);

  1044.             else{

  1045.                const int a= s->sprite_warping_accuracy;

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

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

  1048. //       if (my < -l) my= -l;

  1049. //       else if (my >= l) my= l-1;

  1050.             }

  1051.             if (my >= 0xffff)

  1052.                 return -1;

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

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

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

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

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

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

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

  1060.                            

  1061.         } else {

  1062.             s->mv_type = MV_TYPE_8X8;

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

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

  1065.                 if (s->umvplus_dec)

  1066.                   mx = h263p_decode_umotion(s, pred_x);

  1067.                 else

  1068.                   mx = h263_decode_motion(s, pred_x);

  1069.                 if (mx >= 0xffff)

  1070.                     return -1;

  1071.                 

  1072.                 if (s->umvplus_dec)

  1073.                   my = h263p_decode_umotion(s, pred_y);

  1074.                 else    

  1075.                   my = h263_decode_motion(s, pred_y);

  1076.                 if (my >= 0xffff)

  1077.                     return -1;

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

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

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

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

  1082.                 mot_val[0] = mx;

  1083.                 mot_val[1] = my;

  1084.             }

  1085.         }

  1086.     } else {

  1087.         s->ac_pred = 0;

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

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

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

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

  1092.         }

  1093.         if (s->h263_aic) {

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

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

  1096.         }

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

  1098.         cbp = (cbpc & 3) | (cbpy << 2);

  1099.         if (dquant) {

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

  1101.             if (s->qscale < 1)

  1102.                 s->qscale = 1;

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

  1104.                 s->qscale = 31;

  1105.         }

  1106.     }

  1107. 

  1108.     /* decode each block */

  1109.     if (s->h263_pred) {

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

  1111. 	    if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)

  1112.                 return -1;

  1113. 	}

  1114.     } else {

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

  1116. 	    if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)

  1117.                 return -1;

  1118. 	}

  1119.     }

  1120.     return 0;

  1121. }

  1122. 

  1123. static int h263_decode_motion(MpegEncContext * s, int pred)

  1124. {

  1125.     int code, val, sign, shift, l, m;

  1126. 

  1127.     code = get_vlc(&s->gb, &mv_vlc);

  1128.     if (code < 0)

  1129.         return 0xffff;

  1130. 

  1131.     if (code == 0)

  1132.         return pred;

  1133.     sign = get_bits1(&s->gb);

  1134.     shift = s->f_code - 1;

  1135.     val = (code - 1) << shift;

  1136.     if (shift > 0)

  1137.         val |= get_bits(&s->gb, shift);

  1138.     val++;

  1139.     if (sign)

  1140.         val = -val;

  1141.     val += pred;

  1142.     

  1143.     /* modulo decoding */

  1144.     if (!s->h263_long_vectors) {

  1145.         l = (1 << (s->f_code - 1)) * 32;

  1146.         m = 2 * l;

  1147.         if (val < -l) {

  1148.             val += m;

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

  1150.             val -= m;

  1151.         }

  1152.     } else {

  1153.         /* horrible h263 long vector mode */

  1154.         if (pred < -31 && val < -63)

  1155.             val += 64;

  1156.         if (pred > 32 && val > 63)

  1157.             val -= 64;

  1158.         

  1159.     }

  1160.     return val;

  1161. }

  1162. 

  1163. /* Decodes RVLC of H.263+ UMV */

  1164. static int h263p_decode_umotion(MpegEncContext * s, int pred)

  1165. {

  1166.    int code = 0, sign;

  1167.    

  1168.    if (get_bits1(&s->gb)) /* Motion difference = 0 */

  1169.       return pred;

  1170.    

  1171.    code = 2 + get_bits1(&s->gb);

  1172.    

  1173.    while (get_bits1(&s->gb))

  1174.    {

  1175.       code <<= 1;

  1176.       code += get_bits1(&s->gb);

  1177.    }

  1178.    sign = code & 1;

  1179.    code >>= 1;

  1180.    

  1181.    code = (sign) ? (pred - code) : (pred + code);

  1182. #ifdef DEBUG

  1183.    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);

  1184. #endif

  1185.    return code;   

  1186. 

  1187. }

  1188. 

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

  1190.                              int n, int coded)

  1191. {

  1192.     int code, level, i, j, last, run;

  1193.     RLTable *rl = &rl_inter;

  1194.     const UINT8 *scan_table;

  1195. 

  1196.     scan_table = zigzag_direct;

  1197.     if (s->h263_aic && s->mb_intra) {

  1198.         rl = &rl_intra_aic;

  1199.         i = 0;

  1200.         if (s->ac_pred) {

  1201.             if (s->h263_aic_dir) 

  1202.                 scan_table = ff_alternate_vertical_scan; /* left */

  1203.             else

  1204.                 scan_table = ff_alternate_horizontal_scan; /* top */

  1205.         }

  1206.     } else if (s->mb_intra) {

  1207.         /* DC coef */

  1208.         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {

  1209.             int component, diff;

  1210.             component = (n <= 3 ? 0 : n - 4 + 1);

  1211.             level = s->last_dc[component];

  1212.             if (s->rv10_first_dc_coded[component]) {

  1213.                 diff = rv_decode_dc(s, n);

  1214.                 if (diff == 0xffff)

  1215.                     return -1;

  1216.                 level += diff;

  1217.                 level = level & 0xff; /* handle wrap round */

  1218.                 s->last_dc[component] = level;

  1219.             } else {

  1220.                 s->rv10_first_dc_coded[component] = 1;

  1221.             }

  1222.         } else {

  1223.             level = get_bits(&s->gb, 8);

  1224.             if (level == 255)

  1225.                 level = 128;

  1226.         }

  1227.         block[0] = level;

  1228.         i = 1;

  1229.     } else {

  1230.         i = 0;

  1231.     }

  1232.     if (!coded) {

  1233.         if (s->mb_intra && s->h263_aic)

  1234.             goto not_coded;

  1235.         s->block_last_index[n] = i - 1;

  1236.         return 0;

  1237.     }

  1238. 

  1239.     for(;;) {

  1240.         code = get_vlc(&s->gb, &rl->vlc);

  1241.         if (code < 0)

  1242.             return -1;

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

  1244.             /* escape */

  1245.             last = get_bits1(&s->gb);

  1246.             run = get_bits(&s->gb, 6);

  1247.             level = (INT8)get_bits(&s->gb, 8);

  1248.             if (s->h263_rv10 && level == -128) {

  1249.                 /* XXX: should patch encoder too */

  1250.                 level = get_bits(&s->gb, 12);

  1251.                 level = (level << 20) >> 20;

  1252.             }

  1253.         } else {

  1254.             run = rl->table_run[code];

  1255.             level = rl->table_level[code];

  1256.             last = code >= rl->last;

  1257.             if (get_bits1(&s->gb))

  1258.                 level = -level;

  1259.         }

  1260.         i += run;

  1261.         if (i >= 64)

  1262.             return -1;

  1263.         j = scan_table[i];

  1264.         block[j] = level;

  1265.         if (last)

  1266.             break;

  1267.         i++;

  1268.     }

  1269. not_coded:    

  1270.     if (s->mb_intra && s->h263_aic) {

  1271.         h263_pred_acdc(s, block, n);

  1272.         i = 64;

  1273.     }

  1274.     s->block_last_index[n] = i;

  1275.     return 0;

  1276. }

  1277. 

  1278. static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)

  1279. {

  1280.     int level, pred, code;

  1281.     UINT16 *dc_val;

  1282. 

  1283.     if (n < 4) 

  1284.         code = get_vlc(&s->gb, &dc_lum);

  1285.     else 

  1286.         code = get_vlc(&s->gb, &dc_chrom);

  1287.     if (code < 0)

  1288.         return -1;

  1289.     if (code == 0) {

  1290.         level = 0;

  1291.     } else {

  1292.         level = get_bits(&s->gb, code);

  1293.         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/

  1294.             level = - (level ^ ((1 << code) - 1));

  1295.         if (code > 8)

  1296.             skip_bits1(&s->gb); /* marker */

  1297.     }

  1298. 

  1299.     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);

  1300.     level += pred;

  1301.     if (level < 0)

  1302.         level = 0;

  1303.     if (n < 4) {

  1304.         *dc_val = level * s->y_dc_scale;

  1305.     } else {

  1306.         *dc_val = level * s->c_dc_scale;

  1307.     }

  1308.     return level;

  1309. }

  1310. 

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

  1312.                               int n, int coded)

  1313. {

  1314.     int code, level, i, j, last, run;

  1315.     int dc_pred_dir;

  1316.     RLTable *rl;

  1317.     const UINT8 *scan_table;

  1318. 

  1319.     if (s->mb_intra) {

  1320. 	/* DC coef */

  1321.         level = mpeg4_decode_dc(s, n, &dc_pred_dir);

  1322.         if (level < 0)

  1323.             return -1;

  1324.         block[0] = level;

  1325. 	i = 1;

  1326.         if (!coded) 

  1327.             goto not_coded;

  1328.         rl = &rl_intra;

  1329.         if (s->ac_pred) {

  1330.             if (dc_pred_dir == 0) 

  1331.                 scan_table = ff_alternate_vertical_scan; /* left */

  1332.             else

  1333.                 scan_table = ff_alternate_horizontal_scan; /* top */

  1334.         } else {

  1335.             scan_table = zigzag_direct;

  1336.         }

  1337.     } else {

  1338. 	i = 0;

  1339.         if (!coded) {

  1340.             s->block_last_index[n] = i - 1;

  1341.             return 0;

  1342.         }

  1343.         rl = &rl_inter;

  1344.         scan_table = zigzag_direct;

  1345.     }

  1346. 

  1347.     for(;;) {

  1348.         code = get_vlc(&s->gb, &rl->vlc);

  1349.         if (code < 0)

  1350.             return -1;

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

  1352.             /* escape */

  1353.             if (get_bits1(&s->gb) != 0) {

  1354.                 if (get_bits1(&s->gb) != 0) {

  1355.                     /* third escape */

  1356.                     last = get_bits1(&s->gb);

  1357.                     run = get_bits(&s->gb, 6);

  1358.                     get_bits1(&s->gb); /* marker */

  1359.                     level = get_bits(&s->gb, 12);

  1360.                     level = (level << 20) >> 20; /* sign extend */

  1361.                     skip_bits1(&s->gb); /* marker */

  1362.                 } else {

  1363.                     /* second escape */

  1364.                     code = get_vlc(&s->gb, &rl->vlc);

  1365.                     if (code < 0 || code >= rl->n)

  1366.                         return -1;

  1367.                     run = rl->table_run[code];

  1368.                     level = rl->table_level[code];

  1369.                     last = code >= rl->last;

  1370.                     run += rl->max_run[last][level] + 1;

  1371.                     if (get_bits1(&s->gb))

  1372.                         level = -level;

  1373.                 }

  1374.             } else {

  1375.                 /* first escape */

  1376.                 code = get_vlc(&s->gb, &rl->vlc);

  1377.                 if (code < 0 || code >= rl->n)

  1378.                     return -1;

  1379.                 run = rl->table_run[code];

  1380.                 level = rl->table_level[code];

  1381.                 last = code >= rl->last;

  1382.                 level += rl->max_level[last][run];

  1383.                 if (get_bits1(&s->gb))

  1384.                     level = -level;

  1385.             }

  1386.         } else {

  1387.             run = rl->table_run[code];

  1388.             level = rl->table_level[code];

  1389.             last = code >= rl->last;

  1390.             if (get_bits1(&s->gb))

  1391.                 level = -level;

  1392.         }

  1393.         i += run;

  1394.         if (i >= 64)

  1395.             return -1;

  1396. 	j = scan_table[i];

  1397.         block[j] = level;

  1398.         i++;

  1399.         if (last)

  1400.             break;

  1401.     }

  1402.  not_coded:

  1403.     if (s->mb_intra) {

  1404.         mpeg4_pred_ac(s, block, n, dc_pred_dir);

  1405.         if (s->ac_pred) {

  1406.             i = 64; /* XXX: not optimal */

  1407.         }

  1408.     }

  1409.     s->block_last_index[n] = i - 1;

  1410.     return 0;

  1411. }

  1412. 

  1413. /* most is hardcoded. should extend to handle all h263 streams */

  1414. int h263_decode_picture_header(MpegEncContext *s)

  1415. {

  1416.     int format, width, height;

  1417. 

  1418.     /* picture header */

  1419.     if (get_bits(&s->gb, 22) != 0x20)

  1420.         return -1;

  1421.     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */

  1422.     

  1423.     if (get_bits1(&s->gb) != 1)

  1424.         return -1;	/* marker */

  1425.     if (get_bits1(&s->gb) != 0)

  1426.         return -1;	/* h263 id */

  1427.     skip_bits1(&s->gb);	/* split screen off */

  1428.     skip_bits1(&s->gb);	/* camera  off */

  1429.     skip_bits1(&s->gb);	/* freeze picture release off */

  1430. 

  1431.     /* Reset GOB number */

  1432.     s->gob_number = 0;

  1433.         

  1434.     format = get_bits(&s->gb, 3);

  1435. 

  1436.     if (format != 7 && format != 6) {

  1437.         s->h263_plus = 0;

  1438.         /* H.263v1 */

  1439.         width = h263_format[format][0];

  1440.         height = h263_format[format][1];

  1441.         if (!width)

  1442.             return -1;

  1443.         

  1444.         s->width = width;

  1445.         s->height = height;

  1446.         s->pict_type = I_TYPE + get_bits1(&s->gb);

  1447. 

  1448.         s->unrestricted_mv = get_bits1(&s->gb); 

  1449.         s->h263_long_vectors = s->unrestricted_mv;

  1450. 

  1451.         if (get_bits1(&s->gb) != 0)

  1452.             return -1;	/* SAC: off */

  1453.         if (get_bits1(&s->gb) != 0) {

  1454.             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */

  1455.         }   

  1456.         

  1457.         if (get_bits1(&s->gb) != 0)

  1458.             return -1;	/* not PB frame */

  1459. 

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

  1461.         skip_bits1(&s->gb);	/* Continuous Presence Multipoint mode: off */

  1462.     } else {

  1463.         int ufep;

  1464.         

  1465.         /* H.263v2 */

  1466.         s->h263_plus = 1;

  1467.         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */

  1468.         

  1469.         if (ufep == 1) {

  1470.             /* OPPTYPE */       

  1471.             format = get_bits(&s->gb, 3);

  1472.             skip_bits(&s->gb,1); /* Custom PCF */

  1473.             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */

  1474.             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */

  1475.             if (get_bits1(&s->gb) != 0) {

  1476.                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */

  1477.             }

  1478.             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */

  1479.                 s->h263_aic = 1;

  1480.             }

  1481.             skip_bits(&s->gb, 7);

  1482.             skip_bits(&s->gb, 3); /* Reserved */

  1483.         } else if (ufep != 0)

  1484.             return -1;

  1485.             

  1486.         /* MPPTYPE */

  1487.         s->pict_type = get_bits(&s->gb, 3) + 1;

  1488.         if (s->pict_type != I_TYPE &&

  1489.             s->pict_type != P_TYPE)

  1490.             return -1;

  1491.         skip_bits(&s->gb, 2);

  1492.         s->no_rounding = get_bits1(&s->gb);

  1493.         //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);

  1494.         skip_bits(&s->gb, 4);

  1495.         

  1496.         /* Get the picture dimensions */

  1497.         if (ufep) {

  1498.             if (format == 6) {

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

  1500.                 skip_bits(&s->gb, 4); /* aspect ratio */

  1501.                 width = (get_bits(&s->gb, 9) + 1) * 4;

  1502.                 skip_bits1(&s->gb);

  1503.                 height = get_bits(&s->gb, 9) * 4;

  1504. #ifdef DEBUG 

  1505.                 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);

  1506. #endif            

  1507.             }

  1508.             else {

  1509.                 width = h263_format[format][0];

  1510.                 height = h263_format[format][1];

  1511.             }

  1512.             if ((width == 0) || (height == 0))

  1513.                 return -1;

  1514.             s->width = width;

  1515.             s->height = height;

  1516.             if (s->umvplus_dec) {

  1517.                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

  1518.             }

  1519.         }

  1520.             

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

  1522.     }

  1523.     /* PEI */

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

  1525.         skip_bits(&s->gb, 8);

  1526.     }

  1527.     s->f_code = 1;

  1528.     return 0;

  1529. }

  1530. 

  1531. static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)

  1532. {

  1533.     int i;

  1534.     int a= 2<<s->sprite_warping_accuracy;

  1535.     int rho= 3-s->sprite_warping_accuracy;

  1536.     int r=16/a;

  1537.     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes

  1538.     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};

  1539.     int sprite_ref[4][2];

  1540.     int virtual_ref[2][2];

  1541.     int w2, h2;

  1542.     int alpha=0, beta=0;

  1543.     int w= s->width;

  1544.     int h= s->height;

  1545. //printf("SP %d\n", s->sprite_warping_accuracy);

  1546.     for(i=0; i<s->num_sprite_warping_points; i++){

  1547.         int length;

  1548.         int x=0, y=0;

  1549. 

  1550.         length= get_vlc(&s->gb, &sprite_trajectory);

  1551.         if(length){

  1552.             x= get_bits(&s->gb, length);

  1553. //printf("lx %d %d\n", length, x);

  1554.             if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/

  1555.                 x = - (x ^ ((1 << length) - 1));

  1556.         }

  1557.         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */

  1558.         

  1559.         length= get_vlc(&s->gb, &sprite_trajectory);

  1560.         if(length){

  1561.             y=get_bits(&s->gb, length);

  1562. //printf("ly %d %d\n", length, y);

  1563.             if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/

  1564.                 y = - (y ^ ((1 << length) - 1));

  1565.         }

  1566.         skip_bits1(&s->gb); /* marker bit */

  1567. //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);

  1568. //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");

  1569. //x=y=0;

  1570.         d[i][0]= x;

  1571.         d[i][1]= y;

  1572.     }

  1573. 

  1574.     while((1<<alpha)<w) alpha++;

  1575.     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'

  1576.     w2= 1<<alpha;

  1577.     h2= 1<<beta;

  1578. 

  1579. // Note, the 4th point isnt used for GMC

  1580. /*

  1581.     sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);

  1582.     sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);

  1583.     sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);

  1584.     sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);

  1585.     sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);

  1586.     sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);

  1587. */

  1588. //FIXME DIVX5 vs. mpeg4 ?

  1589.     sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];

  1590.     sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];

  1591.     sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];

  1592.     sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];

  1593.     sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];

  1594.     sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];

  1595. /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);

  1596.     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */

  1597.     

  1598. // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)

  1599. // perhaps it should be reordered to be more readable ...

  1600. // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides

  1601. // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form

  1602.     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 

  1603.         + 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);

  1604.     virtual_ref[0][1]= 16*vop_ref[0][1] 

  1605.         + 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);

  1606.     virtual_ref[1][0]= 16*vop_ref[0][0] 

  1607.         + 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);

  1608.     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 

  1609.         + 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);

  1610. 

  1611.     switch(s->num_sprite_warping_points)

  1612.     {

  1613.         case 0:

  1614.             s->sprite_offset[0][0]= 0;

  1615.             s->sprite_offset[0][1]= 0;

  1616.             s->sprite_offset[1][0]= 0;

  1617.             s->sprite_offset[1][1]= 0;

  1618.             s->sprite_delta[0][0][0]= a;

  1619.             s->sprite_delta[0][0][1]= 0;

  1620.             s->sprite_delta[0][1][0]= 0;

  1621.             s->sprite_delta[0][1][1]= a;

  1622.             s->sprite_delta[1][0][0]= a;

  1623.             s->sprite_delta[1][0][1]= 0;

  1624.             s->sprite_delta[1][1][0]= 0;

  1625.             s->sprite_delta[1][1][1]= a;

  1626.             s->sprite_shift[0][0]= 0;

  1627.             s->sprite_shift[0][1]= 0;

  1628.             s->sprite_shift[1][0]= 0;

  1629.             s->sprite_shift[1][1]= 0;

  1630.             break;

  1631.         case 1: //GMC only

  1632.             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];

  1633.             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];

  1634.             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);

  1635.             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);

  1636.             s->sprite_delta[0][0][0]= a;

  1637.             s->sprite_delta[0][0][1]= 0;

  1638.             s->sprite_delta[0][1][0]= 0;

  1639.             s->sprite_delta[0][1][1]= a;

  1640.             s->sprite_delta[1][0][0]= a;

  1641.             s->sprite_delta[1][0][1]= 0;

  1642.             s->sprite_delta[1][1][0]= 0;

  1643.             s->sprite_delta[1][1][1]= a;

  1644.             s->sprite_shift[0][0]= 0;

  1645.             s->sprite_shift[0][1]= 0;

  1646.             s->sprite_shift[1][0]= 0;

  1647.             s->sprite_shift[1][1]= 0;

  1648.             break;

  1649.         case 2:

  1650.         case 3: //FIXME

  1651.             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))

  1652.                                                   + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])

  1653.                                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));

  1654.             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))

  1655.                                                   + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])

  1656.                                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));

  1657.             s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)

  1658.                                  +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)

  1659.                                  +2*w2*r*sprite_ref[0][0] - 16*w2);

  1660.             s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 

  1661.                                  +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)

  1662.                                  +2*w2*r*sprite_ref[0][1] - 16*w2);

  1663.             s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);

  1664.             s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);

  1665.             s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);

  1666.             s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);

  1667.             s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);

  1668.             s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);

  1669.             s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);

  1670.             s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);

  1671.             s->sprite_shift[0][0]= alpha+rho;

  1672.             s->sprite_shift[0][1]= alpha+rho;

  1673.             s->sprite_shift[1][0]= alpha+rho+2;

  1674.             s->sprite_shift[1][1]= alpha+rho+2;

  1675.             break;

  1676. //        case 3:

  1677.             break;

  1678.     }

  1679. /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);

  1680. printf("%d %d\n", s->sprite_delta[0][0][1], 0);

  1681. printf("%d %d\n", s->sprite_delta[0][1][0], 0);

  1682. printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);

  1683. printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);

  1684. printf("%d %d\n", s->sprite_delta[1][0][1], 0);

  1685. printf("%d %d\n", s->sprite_delta[1][1][0], 0);

  1686. printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/

  1687.     /* try to simplify the situation */ 

  1688.     if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]

  1689.        && s->sprite_delta[0][0][1] == 0

  1690.        && s->sprite_delta[0][1][0] == 0

  1691.        && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]

  1692.        && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]

  1693.        && s->sprite_delta[1][0][1] == 0

  1694.        && s->sprite_delta[1][1][0] == 0

  1695.        && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])

  1696.     {

  1697.         s->sprite_offset[0][0]>>=s->sprite_shift[0][0];

  1698.         s->sprite_offset[0][1]>>=s->sprite_shift[0][1];

  1699.         s->sprite_offset[1][0]>>=s->sprite_shift[1][0];

  1700.         s->sprite_offset[1][1]>>=s->sprite_shift[1][1];

  1701.         s->sprite_delta[0][0][0]= a;

  1702.         s->sprite_delta[0][0][1]= 0;

  1703.         s->sprite_delta[0][1][0]= 0;

  1704.         s->sprite_delta[0][1][1]= a;

  1705.         s->sprite_delta[1][0][0]= a;

  1706.         s->sprite_delta[1][0][1]= 0;

  1707.         s->sprite_delta[1][1][0]= 0;

  1708.         s->sprite_delta[1][1][1]= a;

  1709.         s->sprite_shift[0][0]= 0;

  1710.         s->sprite_shift[0][1]= 0;

  1711.         s->sprite_shift[1][0]= 0;

  1712.         s->sprite_shift[1][1]= 0;

  1713.         s->real_sprite_warping_points=1;

  1714.     }

  1715.     else

  1716.         s->real_sprite_warping_points= s->num_sprite_warping_points;

  1717. 

  1718. //FIXME convert stuff if accurace != 3

  1719. }

  1720. 

  1721. /* decode mpeg4 VOP header */

  1722. int mpeg4_decode_picture_header(MpegEncContext * s)

  1723. {

  1724.     int time_incr, startcode, state, v;

  1725. 

  1726.  redo:

  1727.     /* search next start code */

  1728.     align_get_bits(&s->gb);

  1729.     state = 0xff;

  1730.     for(;;) {

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

  1732.         if (state == 0x000001) {

  1733.             state = ((state << 8) | v) & 0xffffff;

  1734.             startcode = state;

  1735.             break;

  1736.         }

  1737.         state = ((state << 8) | v) & 0xffffff;

  1738.         /* XXX: really detect end of frame */

  1739.         if (state == 0)

  1740.             return -1;

  1741.     }

  1742. //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));

  1743.     if (startcode == 0x120) { // Video Object Layer

  1744.         int time_increment_resolution, width, height, vo_ver_id;

  1745. 

  1746.         /* vol header */

  1747.         skip_bits(&s->gb, 1); /* random access */

  1748.         skip_bits(&s->gb, 8); /* vo_type */

  1749.         if (get_bits1(&s->gb) != 0) { /* is_ol_id */

  1750.             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */

  1751.             skip_bits(&s->gb, 3); /* vo_priority */

  1752.         } else {

  1753.             vo_ver_id = 1;

  1754.         }

  1755.         

  1756.         s->aspect_ratio_info= get_bits(&s->gb, 4);

  1757. 	if(s->aspect_ratio_info == EXTENDET_PAR){

  1758.             skip_bits(&s->gb, 8); //par_width

  1759.             skip_bits(&s->gb, 8); // par_height

  1760.         }

  1761.         if(get_bits1(&s->gb)){ /* vol control parameter */

  1762.             printf("vol control parameter not supported\n");

  1763.             return -1;   

  1764.         }

  1765.         s->shape = get_bits(&s->gb, 2); /* vol shape */

  1766.         if(s->shape == GRAY_SHAPE && vo_ver_id != 1){

  1767.             printf("Gray shape not supported\n");

  1768.             skip_bits(&s->gb, 4);  //video_object_layer_shape_extension

  1769.         }

  1770. 

  1771.         skip_bits1(&s->gb);   /* marker */

  1772.         

  1773.         time_increment_resolution = get_bits(&s->gb, 16);

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

  1775.         if (s->time_increment_bits < 1)

  1776.             s->time_increment_bits = 1;

  1777.         skip_bits1(&s->gb);   /* marker */

  1778. 

  1779.         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */

  1780.             skip_bits(&s->gb, s->time_increment_bits);

  1781.         }

  1782. 

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

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

  1785.                 skip_bits1(&s->gb);   /* marker */

  1786.                 width = get_bits(&s->gb, 13);

  1787.                 skip_bits1(&s->gb);   /* marker */

  1788.                 height = get_bits(&s->gb, 13);

  1789.                 skip_bits1(&s->gb);   /* marker */

  1790.             }

  1791.             

  1792.             skip_bits1(&s->gb);   /* interlaced */

  1793.             if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */

  1794.             if (vo_ver_id == 1) {

  1795.                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */

  1796.             } else {

  1797.                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */

  1798.             }

  1799.             if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");

  1800.             if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){

  1801.                 if(s->vol_sprite_usage==STATIC_SPRITE){

  1802.                     s->sprite_width = get_bits(&s->gb, 13);

  1803.                     skip_bits1(&s->gb); /* marker */

  1804.                     s->sprite_height= get_bits(&s->gb, 13);

  1805.                     skip_bits1(&s->gb); /* marker */

  1806.                     s->sprite_left  = get_bits(&s->gb, 13);

  1807.                     skip_bits1(&s->gb); /* marker */

  1808.                     s->sprite_top   = get_bits(&s->gb, 13);

  1809.                     skip_bits1(&s->gb); /* marker */

  1810.                 }

  1811.                 s->num_sprite_warping_points= get_bits(&s->gb, 6);

  1812.                 s->sprite_warping_accuracy = get_bits(&s->gb, 2);

  1813.                 s->sprite_brightness_change= get_bits1(&s->gb);

  1814.                 if(s->vol_sprite_usage==STATIC_SPRITE)

  1815.                     s->low_latency_sprite= get_bits1(&s->gb);            

  1816.             }

  1817.             // FIXME sadct disable bit if verid!=1 && shape not rect

  1818.             

  1819.             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */

  1820.                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */

  1821.                 skip_bits(&s->gb, 4); /* bits_per_pixel */

  1822.             } else {

  1823.                 s->quant_precision = 5;

  1824.             }

  1825.             

  1826.             // FIXME a bunch of grayscale shape things

  1827.             if(get_bits1(&s->gb)) printf("Quant-Type not supported\n");  /* vol_quant_type */ //FIXME

  1828.             if(vo_ver_id != 1)

  1829.                  s->quarter_sample= get_bits1(&s->gb);

  1830.             else s->quarter_sample=0;

  1831. #if 0

  1832.             if(get_bits1(&s->gb)) printf("Complexity est disabled\n");

  1833.             if(get_bits1(&s->gb)) printf("resync disable\n");

  1834. #else

  1835.             skip_bits1(&s->gb);   /* complexity_estimation_disabled */

  1836.             skip_bits1(&s->gb);   /* resync_marker_disabled */

  1837. #endif

  1838.             s->data_partioning= get_bits1(&s->gb);

  1839.             if(s->data_partioning){

  1840.                 printf("data partitioning not supported\n");

  1841.                 skip_bits1(&s->gb); // reversible vlc

  1842.             }

  1843.             

  1844.             if(vo_ver_id != 1) {

  1845.                 s->new_pred= get_bits1(&s->gb);

  1846.                 if(s->new_pred){

  1847.                     printf("new pred not supported\n");

  1848.                     skip_bits(&s->gb, 2); /* requested upstream message type */

  1849.                     skip_bits1(&s->gb); /* newpred segment type */

  1850.                 }

  1851.                 s->reduced_res_vop= get_bits1(&s->gb);

  1852.                 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");

  1853.             }

  1854.             else{

  1855.                 s->new_pred=0;

  1856.                 s->reduced_res_vop= 0;

  1857.             }

  1858. 

  1859.             s->scalability= get_bits1(&s->gb);

  1860.             if (s->scalability) {

  1861.                 printf("bad scalability!!!\n");

  1862.                 return -1;

  1863.             }

  1864.         }

  1865. //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);

  1866.         goto redo;

  1867.     } else if (startcode == 0x1b2) { //userdata

  1868.         char buf[256];

  1869.         int i;

  1870.         int e;

  1871.         int ver, build;

  1872. 

  1873. //printf("user Data %X\n", show_bits(&s->gb, 32));

  1874.         buf[0]= show_bits(&s->gb, 8);

  1875.         for(i=1; i<256; i++){

  1876.             buf[i]= show_bits(&s->gb, 16)&0xFF;

  1877.             if(buf[i]==0) break;

  1878.             skip_bits(&s->gb, 8);

  1879.         }

  1880.         buf[255]=0;

  1881.         e=sscanf(buf, "DivX%dBuild%d", &ver, &build);

  1882.         if(e==2){

  1883.             s->divx_version= ver;

  1884.             s->divx_build= build;

  1885.             if(s->picture_number==0){

  1886.                 printf("This file was encoded with DivX%d Build%d\n", ver, build);

  1887.                 if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...

  1888.                     printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");

  1889.                 }else{

  1890.                     printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"

  1891.                            "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");

  1892.                 }

  1893.             }

  1894.         }

  1895. //printf("User Data: %s\n", buf);

  1896.         goto redo;

  1897.     } else if (startcode != 0x1b6) { //VOP

  1898.         goto redo;

  1899.     }

  1900. 

  1901.     s->pict_type = get_bits(&s->gb, 2) + 1;	/* pict type: I = 0 , P = 1 */

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

  1903.     {

  1904.         printf("B-VOP\n");

  1905. 	return -1;

  1906.     }

  1907.  

  1908.     /* XXX: parse time base */

  1909.     time_incr = 0;

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

  1911.         time_incr++;

  1912. 

  1913.     skip_bits1(&s->gb);   	/* marker */

  1914.     skip_bits(&s->gb, s->time_increment_bits);

  1915.     skip_bits1(&s->gb);   	/* marker */

  1916.     /* vop coded */

  1917.     if (get_bits1(&s->gb) != 1)

  1918.         goto redo;

  1919.     

  1920.     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE

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

  1922.         /* rounding type for motion estimation */

  1923. 	s->no_rounding = get_bits1(&s->gb);

  1924.     } else {

  1925. 	s->no_rounding = 0;

  1926.     }

  1927. //FIXME reduced res stuff

  1928. 

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

  1930.          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {

  1931.              int width, height, hor_spat_ref, ver_spat_ref;

  1932.  

  1933.              width = get_bits(&s->gb, 13);

  1934.              skip_bits1(&s->gb);   /* marker */

  1935.              height = get_bits(&s->gb, 13);

  1936.              skip_bits1(&s->gb);   /* marker */

  1937.              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */

  1938.              skip_bits1(&s->gb);   /* marker */

  1939.              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */

  1940.          }

  1941.          skip_bits1(&s->gb); /* change_CR_disable */

  1942.  

  1943.          if (get_bits1(&s->gb) != 0) {

  1944.              skip_bits(&s->gb, 8); /* constant_alpha_value */

  1945.          }

  1946.      }

  1947. //FIXME complexity estimation stuff

  1948.      

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

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

  1951.          //FIXME interlaced specific bits

  1952.      }

  1953. 

  1954.      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){

  1955.          if(s->num_sprite_warping_points){

  1956.              mpeg4_decode_sprite_trajectory(s);

  1957.          }

  1958.          if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");

  1959.          if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");

  1960.      }

  1961. 

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

  1963.          /* note: we do not use quant_precision to avoid problem if no

  1964.             MPEG4 vol header as it is found on some old opendivx

  1965.             movies */

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

  1967.   

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

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

  1970.          }

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

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

  1973.          }

  1974. //printf("quant:%d fcode:%d\n", s->qscale, s->f_code);

  1975.          if(!s->scalability){

  1976.              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {

  1977.                  skip_bits1(&s->gb); // vop shape coding type

  1978.              }

  1979.          }

  1980.      }

  1981. //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);

  1982.      s->picture_number++; // better than pic number==0 allways ;)

  1983.      return 0;

  1984. }

  1985. 

  1986. /* don't understand why they choose a different header ! */

  1987. int intel_h263_decode_picture_header(MpegEncContext *s)

  1988. {

  1989.     int format;

  1990. 

  1991.     /* picture header */

  1992.     if (get_bits(&s->gb, 22) != 0x20)

  1993.         return -1;

  1994.     skip_bits(&s->gb, 8); /* picture timestamp */

  1995. 

  1996.     if (get_bits1(&s->gb) != 1)

  1997.         return -1;	/* marker */

  1998.     if (get_bits1(&s->gb) != 0)

  1999.         return -1;	/* h263 id */

  2000.     skip_bits1(&s->gb);	/* split screen off */

  2001.     skip_bits1(&s->gb);	/* camera  off */

  2002.     skip_bits1(&s->gb);	/* freeze picture release off */

  2003. 

  2004.     format = get_bits(&s->gb, 3);

  2005.     if (format != 7)

  2006.         return -1;

  2007. 

  2008.     s->h263_plus = 0;

  2009. 

  2010.     s->pict_type = I_TYPE + get_bits1(&s->gb);

  2011.     

  2012.     s->unrestricted_mv = get_bits1(&s->gb); 

  2013.     s->h263_long_vectors = s->unrestricted_mv;

  2014. 

  2015.     if (get_bits1(&s->gb) != 0)

  2016.         return -1;	/* SAC: off */

  2017.     if (get_bits1(&s->gb) != 0)

  2018.         return -1;	/* advanced prediction mode: off */

  2019.     if (get_bits1(&s->gb) != 0)

  2020.         return -1;	/* not PB frame */

  2021. 

  2022.     /* skip unknown header garbage */

  2023.     skip_bits(&s->gb, 41);

  2024. 

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

  2026.     skip_bits1(&s->gb);	/* Continuous Presence Multipoint mode: off */

  2027. 

  2028.     /* PEI */

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

  2030.         skip_bits(&s->gb, 8);

  2031.     }

  2032.     s->f_code = 1;

  2033.     return 0;

  2034. }