[svn] / trunk / xvidcore / src / bitstream / mbcoding.c Repository:
ViewVC logotype

Diff of /trunk/xvidcore/src/bitstream/mbcoding.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 100, Thu Apr 4 13:58:18 2002 UTC revision 1773, Sat Apr 28 16:30:26 2007 UTC
# Line 1  Line 1 
1    /*****************************************************************************
2     *
3     *  XVID MPEG-4 VIDEO CODEC
4     *  - MB coding -
5     *
6     *  Copyright (C) 2002 Michael Militzer <isibaar@xvid.org>
7     *
8     *  This program is free software ; you can redistribute it and/or modify
9     *  it under the terms of the GNU General Public License as published by
10     *  the Free Software Foundation ; either version 2 of the License, or
11     *  (at your option) any later version.
12     *
13     *  This program is distributed in the hope that it will be useful,
14     *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
15     *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     *  GNU General Public License for more details.
17     *
18     *  You should have received a copy of the GNU General Public License
19     *  along with this program ; if not, write to the Free Software
20     *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21     *
22     * $Id: mbcoding.c,v 1.54 2007-04-28 16:30:20 syskin Exp $
23     *
24     ****************************************************************************/
25    
26    #include <stdio.h>
27  #include <stdlib.h>  #include <stdlib.h>
28    #include <string.h>
29    
30  #include "../portab.h"  #include "../portab.h"
31    #include "../global.h"
32  #include "bitstream.h"  #include "bitstream.h"
33  #include "zigzag.h"  #include "zigzag.h"
34  #include "vlc_codes.h"  #include "vlc_codes.h"
# Line 7  Line 36 
36    
37  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
38    
39  #define ESCAPE 7167  #ifdef _DEBUG
40  #define ABS(X) (((X)>0)?(X):-(X))  # include "../motion/estimation.h"
41  #define CLIP(X,A) (X > A) ? (A) : (X)  # include "../motion/motion_inlines.h"
42    # include <assert.h>
43    #endif
44    
 VLC DCT3Dintra[4096];  
 VLC DCT3Dinter[4096];  
 static VLC *DCT3D[2];  
45    
46  VLC intra_table[65536];  #define LEVELOFFSET 32
 VLC inter_table[65536];  
47    
48  static short clip_table[4096];  /* Initialized once during xvid_global call
49     * RO access is thread safe */
50    static REVERSE_EVENT DCT3D[2][4096];
51    static VLC coeff_VLC[2][2][64][64];
52    
53  void init_vlc_tables(void)  /* not really MB related, but VLCs are only available here */
54    void bs_put_spritetrajectory(Bitstream * bs, const int val)
55  {  {
56            const int code = sprite_trajectory_code[val+16384].code;
57            const int len = sprite_trajectory_code[val+16384].len;
58            const int code2 = sprite_trajectory_len[len].code;
59            const int len2 = sprite_trajectory_len[len].len;
60    
61          int32_t k, l, i, intra, last;  #if 0
62          VLC *vlc[2];          printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
63          VLC **coeff_ptr;          printf("Code2 / Len2 = %d / %d \n",code2,len2);
64          VLC *vlc1, *vlc2;  #endif
   
         vlc1 = DCT3Dintra;  
         vlc2 = DCT3Dinter;  
65    
66          vlc[0] = intra_table;          BitstreamPutBits(bs, code2, len2);
67          vlc[1] = inter_table;          if (len) BitstreamPutBits(bs, code, len);
   
         // initialize the clipping table  
         for(i = -2048; i < 2048; i++) {  
                 clip_table[i + 2048] = i;  
                 if(i < -255)  
                         clip_table[i + 2048] = -255;  
                 if(i > 255)  
                         clip_table[i + 2048] = 255;  
68          }          }
69    
70          // generate encoding vlc lookup tables  int bs_get_spritetrajectory(Bitstream * bs)
71          for(i = 0; i < 4; i++) {  {
72                  intra = i % 2;          int i;
73                  last = i / 2;          for (i = 0; i < 12; i++)
74            {
75                  coeff_ptr = coeff_vlc[last + 2 * intra];                  if (BitstreamShowBits(bs, sprite_trajectory_len[i].len) == sprite_trajectory_len[i].code)
76                    {
77                  for(k = -255; k < 256; k++) { // level                          BitstreamSkip(bs, sprite_trajectory_len[i].len);
78                          int8_t *max_level_ptr = max_level[last + 2 * intra];                          return i;
79                          int8_t *max_run_ptr = max_run[last + 2 * intra];                  }
80            }
81            return -1;
82    }
83    
84                          for(l = 0; l < 64; l++) { // run  void
85                                  int32_t level = k;  init_vlc_tables(void)
86                                  uint32_t run = l;  {
87            uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
88            int32_t l;
89    
90                                  if((abs(level) <= max_level_ptr[run]) &&          for (intra = 0; intra < 2; intra++)
91                                     (run <= max_run_ptr[abs(level)])) { // level < max_level and run < max_run                  for (i = 0; i < 4096; i++)
92                            DCT3D[intra][i].event.level = 0;
93    
94                                                  vlc[intra]->code = 0;          for (intra = 0; intra < 2; intra++) {
95                                                  vlc[intra]->len = 0;                  for (last = 0; last < 2; last++) {
96                                                  goto loop_end;                          for (run = 0; run < 63 + last; run++) {
97                                    for (level = 0; level < (uint32_t)(32 << intra); level++) {
98                                            offset = !intra * LEVELOFFSET;
99                                            coeff_VLC[intra][last][level + offset][run].len = 128;
100                                    }
101                            }
102                                  }                                  }
                                 else {  
                                         if(level > 0)                                        // correct level  
                                                 level -= max_level_ptr[run];  
                                         else  
                                                 level += max_level_ptr[run];  
   
                                         if((abs(level) <= max_level_ptr[run]) &&  
                                            (run <= max_run_ptr[abs(level)])) {  
   
                                                 vlc[intra]->code = 0x06;  
                                                 vlc[intra]->len = 8;  
                                                 goto loop_end;  
103                                          }                                          }
104    
105                                          if(level > 0)                                       // still here?          for (intra = 0; intra < 2; intra++) {
106                                                  level += max_level_ptr[run];    // restore level                  for (i = 0; i < 102; i++) {
107                                          else                          offset = !intra * LEVELOFFSET;
                                                 level -= max_level_ptr[run];  
108    
109                                          run -= max_run_ptr[abs(level)] + 1; // and change run                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++) {
110                                    DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;
111                                    DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
112                            }
113    
114                                          if((abs(level) <= max_level_ptr[run]) &&                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].code
115                                             (run <= max_run_ptr[abs(level)])) {                                  = coeff_tab[intra][i].vlc.code << 1;
116                            coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len
117                                    = coeff_tab[intra][i].vlc.len + 1;
118    
119                                                  vlc[intra]->code = 0x0e;                          if (!intra) {
120                                                  vlc[intra]->len = 9;                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code
121                                                  goto loop_end;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
122                                    coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len
123                                            = coeff_tab[intra][i].vlc.len + 1;
124                            }
125                                          }                                          }
                                         run += max_run_ptr[abs(level)] + 1;  
126                                  }                                  }
127    
128                                  vlc[intra]->code = (uint32_t) ((l << 14) | (0x1e + last) << 20) |          for (intra = 0; intra < 2; intra++) {
129                                                                                            (1 << 13) | ((k & 0xfff) << 1) | 1;                  for (last = 0; last < 2; last++) {
130                            for (run = 0; run < 63 + last; run++) {
131                                    for (level = 1; level < (uint32_t)(32 << intra); level++) {
132    
133                                  vlc[intra]->len = 30;                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
                                 vlc[intra]++;  
134                                  continue;                                  continue;
135    
136  loop_end:                                          offset = !intra * LEVELOFFSET;
137                                  if(level != 0) {                      level_esc = level - max_level[intra][last][run];
138                                          vlc[intra]->code = (vlc[intra]->code << (coeff_ptr[run][abs(level) - 1].len + 1)) |                                          run_esc = run - 1 - max_run[intra][last][level];
139                                                                             (coeff_ptr[run][abs(level) - 1].code << 1);  
140                                          vlc[intra]->len = (coeff_ptr[run][abs(level) - 1].len + 1) + vlc[intra]->len;                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]) {
141                                                    escape     = ESCAPE1;
142                                          if(level < 0)                                                  escape_len = 7 + 1;
143                                                  vlc[intra]->code += 1;                                                  run_esc    = run;
144                                            } else {
145                                                    if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {
146                                                            escape     = ESCAPE2;
147                                                            escape_len = 7 + 2;
148                                                            level_esc  = level;
149                                                    } else {
150                                                            if (!intra) {
151                                                                    coeff_VLC[intra][last][level + offset][run].code
152                                                                            = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
153                                                                    coeff_VLC[intra][last][level + offset][run].len = 30;
154                                                                            coeff_VLC[intra][last][offset - level][run].code
155                                                                            = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-(int32_t)level & 0xfff) << 1) | 1;
156                                                                    coeff_VLC[intra][last][offset - level][run].len = 30;
157                                                            }
158                                                            continue;
159                                  }                                  }
   
                                 vlc[intra]++;  
160                          }                          }
161    
162                                            coeff_VLC[intra][last][level + offset][run].code
163                                                    = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
164                                                    |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
165                                            coeff_VLC[intra][last][level + offset][run].len
166                                                    = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
167    
168                                            if (!intra) {
169                                                    coeff_VLC[intra][last][offset - level][run].code
170                                                            = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
171                                                            |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
172                                                    coeff_VLC[intra][last][offset - level][run].len
173                                                            = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
174                  }                  }
175          }          }
176    
177          for(i = 0; i < 4096; i++) {                                  if (!intra) {
178                  if(i >= 512) {                                          coeff_VLC[intra][last][0][run].code
179                          *vlc1 = DCT3Dtab3[(i >> 5) - 16];                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
180                          *vlc2 = DCT3Dtab0[(i >> 5) - 16];                                          coeff_VLC[intra][last][0][run].len = 30;
181                  }                  }
                 else if(i >= 128) {  
                         *vlc1 = DCT3Dtab4[(i >> 2) - 32];  
                         *vlc2 = DCT3Dtab1[(i >> 2) - 32];  
182                  }                  }
                 else if(i >= 8) {  
                         *vlc1 = DCT3Dtab5[i - 8];  
                         *vlc2 = DCT3Dtab2[i - 8];  
183                  }                  }
                 else {  
                         *vlc1 = ERRtab[i];  
                         *vlc2 = ERRtab[i];  
184                  }                  }
185    
186                  vlc1++;          /* init sprite_trajectory tables
187                  vlc2++;           * even if GMC is not specified (it might be used later...) */
188    
189            sprite_trajectory_code[0+16384].code = 0;
190            sprite_trajectory_code[0+16384].len = 0;
191            for (k=0;k<14;k++) {
192                    int limit = (1<<k);
193    
194                    for (l=-(2*limit-1); l <= -limit; l++) {
195                            sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
196                            sprite_trajectory_code[l+16384].len = k+1;
197          }          }
         DCT3D[0] = DCT3Dinter;  
         DCT3D[1] = DCT3Dintra;  
198    
199                    for (l=limit; l<= 2*limit-1; l++) {
200                            sprite_trajectory_code[l+16384].code = l;
201                            sprite_trajectory_code[l+16384].len = k+1;
202                    }
203            }
204  }  }
205    
206  static __inline void CodeVector(Bitstream *bs,  static __inline void
207                                  int16_t value,  CodeVector(Bitstream * bs,
208                                  int16_t f_code,                     int32_t value,
209                                  Statistics *pStat)                     int32_t f_code)
210  {  {
211    
212          const int scale_factor = 1 << (f_code - 1);          const int scale_factor = 1 << (f_code - 1);
# Line 159  Line 218 
218          if(value > (cmp - 1))          if(value > (cmp - 1))
219                  value -= 64 * scale_factor;                  value -= 64 * scale_factor;
220    
         pStat->iMvSum += value * value;  
         pStat->iMvCount++;  
   
221          if (value == 0) {          if (value == 0) {
222                  BitstreamPutBits(bs, mb_motion_table[32].code, mb_motion_table[32].len);                  BitstreamPutBits(bs, mb_motion_table[32].code,
223                                                     mb_motion_table[32].len);
224          } else {          } else {
225                  uint16_t length, code, mv_res, sign;                  uint16_t length, code, mv_res, sign;
226    
# Line 188  Line 245 
245                          code = -code;                          code = -code;
246    
247                  code += 32;                  code += 32;
248                  BitstreamPutBits(bs, mb_motion_table[code].code, mb_motion_table[code].len);                  BitstreamPutBits(bs, mb_motion_table[code].code,
249                                                     mb_motion_table[code].len);
250    
251                  if(f_code)                  if(f_code)
252                          BitstreamPutBits(bs, mv_res, f_code);                          BitstreamPutBits(bs, mv_res, f_code);
# Line 196  Line 254 
254    
255  }  }
256    
257    static __inline void
258    CodeCoeffInter(Bitstream * bs,
259                      const int16_t qcoeff[64],
260                      const uint16_t * zigzag)
261    {
262            uint32_t i, run, prev_run, code, len;
263            int32_t level, prev_level, level_shifted;
264    
265            i       = 0;
266            run = 0;
267    
268            while (!(level = qcoeff[zigzag[i++]]))
269                    run++;
270    
271            prev_level = level;
272            prev_run   = run;
273            run = 0;
274    
275            while (i < 64)
276            {
277                    if ((level = qcoeff[zigzag[i++]]) != 0)
278                    {
279                            level_shifted = prev_level + 32;
280                            if (!(level_shifted & -64))
281                            {
282                                    code = coeff_VLC[0][0][level_shifted][prev_run].code;
283                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
284                            }
285                            else
286                            {
287                                    code = (ESCAPE3 << 21) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
288                                    len  = 30;
289                            }
290                            BitstreamPutBits(bs, code, len);
291                            prev_level = level;
292                            prev_run   = run;
293                            run = 0;
294                    }
295                    else
296                            run++;
297            }
298    
299            level_shifted = prev_level + 32;
300            if (!(level_shifted & -64))
301            {
302                    code = coeff_VLC[0][1][level_shifted][prev_run].code;
303                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
304            }
305            else
306            {
307                    code = (ESCAPE3 << 21) | (1 << 20) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
308                    len  = 30;
309            }
310            BitstreamPutBits(bs, code, len);
311    }
312    
313  static __inline void CodeCoeff(Bitstream *bs,  static __inline void
314                                 int16_t qcoeff[64],  CodeCoeffIntra(Bitstream * bs,
315                                 VLC *table,                    const int16_t qcoeff[64],
316                                 const uint16_t *zigzag,                    const uint16_t * zigzag)
                                uint16_t intra)  
317  {  {
318            uint32_t i, abs_level, run, prev_run, code, len;
319            int32_t level, prev_level;
320    
321          uint32_t j, last;          i       = 1;
322          short v;          run = 0;
         VLC *vlc;  
323    
324          j = intra;          while (i<64 && !(level = qcoeff[zigzag[i++]]))
325          last = 1 + intra;                  run++;
326    
327          while((v = qcoeff[zigzag[j++]]) == 0);          prev_level = level;
328            prev_run   = run;
329            run = 0;
330    
331          do {          while (i < 64)
332                  // count zeroes          {
333                  vlc = table + 64*255 + (clip_table[2048+v] << 6) + j - last;                  if ((level = qcoeff[zigzag[i++]]) != 0)
334                  last = j + 1;                  {
335                  while(j < 64 && (v = qcoeff[zigzag[j++]]) == 0);                          abs_level = abs(prev_level);
336                            abs_level = abs_level < 64 ? abs_level : 0;
337                  // write code                          code      = coeff_VLC[1][0][abs_level][prev_run].code;
338                  if(j != 64) {                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
339                          BitstreamPutBits(bs, vlc->code, vlc->len);                          if (len != 128)
340                  } else {                                  code |= (prev_level < 0);
341                          vlc += 64*511;                          else
342                          BitstreamPutBits(bs, vlc->code, vlc->len);                          {
343                          break;                          code = (ESCAPE3 << 21) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
344                                    len  = 30;
345                            }
346                            BitstreamPutBits(bs, code, len);
347                            prev_level = level;
348                            prev_run   = run;
349                            run = 0;
350                    }
351                    else
352                            run++;
353            }
354    
355            abs_level = abs(prev_level);
356            abs_level = abs_level < 64 ? abs_level : 0;
357            code      = coeff_VLC[1][1][abs_level][prev_run].code;
358            len               = coeff_VLC[1][1][abs_level][prev_run].len;
359            if (len != 128)
360                    code |= (prev_level < 0);
361            else
362            {
363                    code = (ESCAPE3 << 21) | (1 << 20) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
364                    len  = 30;
365            }
366            BitstreamPutBits(bs, code, len);
367    }
368    
369    
370    
371    /* returns the number of bits required to encode qcoeff */
372    
373    int
374    CodeCoeffIntra_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
375    {
376            int bits = 0;
377            uint32_t i, abs_level, run, prev_run, len;
378            int32_t level, prev_level;
379    
380            i       = 1;
381            run = 0;
382    
383            while (i<64 && !(level = qcoeff[zigzag[i++]]))
384                    run++;
385    
386            if (i >= 64) return 0;  /* empty block */
387    
388            prev_level = level;
389            prev_run   = run;
390            run = 0;
391    
392            while (i < 64)
393            {
394                    if ((level = qcoeff[zigzag[i++]]) != 0)
395                    {
396                            abs_level = abs(prev_level);
397                            abs_level = abs_level < 64 ? abs_level : 0;
398                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
399                            bits      += len!=128 ? len : 30;
400    
401                            prev_level = level;
402                            prev_run   = run;
403                            run = 0;
404                    }
405                    else
406                            run++;
407                  }                  }
         } while(1);  
408    
409            abs_level = abs(prev_level);
410            abs_level = abs_level < 64 ? abs_level : 0;
411            len               = coeff_VLC[1][1][abs_level][prev_run].len;
412            bits      += len!=128 ? len : 30;
413    
414            return bits;
415  }  }
416    
417    int
418    CodeCoeffInter_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
419    {
420            uint32_t i, run, prev_run, len;
421            int32_t level, prev_level, level_shifted;
422            int bits = 0;
423    
424            i       = 0;
425            run = 0;
426    
427            while (!(level = qcoeff[zigzag[i++]]))
428                    run++;
429    
430            prev_level = level;
431            prev_run   = run;
432            run = 0;
433    
434  static void CodeBlockIntra(const MBParam * pParam,          while (i < 64) {
435                    if ((level = qcoeff[zigzag[i++]]) != 0) {
436                            level_shifted = prev_level + 32;
437                            if (!(level_shifted & -64))
438                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
439                            else
440                                    len  = 30;
441    
442                            bits += len;
443                            prev_level = level;
444                            prev_run   = run;
445                            run = 0;
446                    }
447                    else
448                            run++;
449            }
450    
451            level_shifted = prev_level + 32;
452            if (!(level_shifted & -64))
453                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
454            else
455                    len  = 30;
456            bits += len;
457    
458            return bits;
459    }
460    
461    static const int iDQtab[5] = {
462            1, 0, -1 /* no change */, 2, 3
463    };
464    #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
465    
466    
467    static __inline void
468    CodeBlockIntra(const FRAMEINFO * const frame,
469                             const MACROBLOCK *pMB,                             const MACROBLOCK *pMB,
470                             int16_t qcoeff[6*64],                             int16_t qcoeff[6*64],
471                             Bitstream * bs,                             Bitstream * bs,
# Line 243  Line 476 
476    
477          cbpy = pMB->cbp >> 2;          cbpy = pMB->cbp >> 2;
478    
479          // write mcbpc          /* write mcbpc */
480          if(pParam->coding_type == I_VOP) {          if (frame->coding_type == I_VOP) {
481                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
482                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code, mcbpc_intra_tab[mcbpc].len);                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
483          }                                                   mcbpc_intra_tab[mcbpc].len);
484          else {          } else {
485                  mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);                  mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
486                  BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code, mcbpc_inter_tab[mcbpc].len);                  BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
487                                                     mcbpc_inter_tab[mcbpc].len);
488          }          }
489    
490          // ac prediction flag          /* ac prediction flag */
491          if(pMB->acpred_directions[0])          if(pMB->acpred_directions[0])
492                  BitstreamPutBits(bs, 1, 1);                  BitstreamPutBits(bs, 1, 1);
493          else          else
494                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
495    
496          // write cbpy          /* write cbpy */
497          BitstreamPutBits (bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
498    
499          // write dquant          /* write dquant */
500          if(pMB->mode == MODE_INTRA_Q)          if(pMB->mode == MODE_INTRA_Q)
501                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
502    
503          // write interlacing          /* write interlacing */
504          if (pParam->global_flags & XVID_INTERLACING)          if (frame->vol_flags & XVID_VOL_INTERLACING) {
         {  
505                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
506          }          }
507            /* code block coeffs */
508          // code block coeffs          for (i = 0; i < 6; i++) {
         for(i = 0; i < 6; i++)  
         {  
509                  if(i < 4)                  if(i < 4)
510                          BitstreamPutBits(bs,                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
                                          dcy_tab[qcoeff[i*64 + 0] + 255].code,  
511                                           dcy_tab[qcoeff[i*64 + 0] + 255].len);                                           dcy_tab[qcoeff[i*64 + 0] + 255].len);
512                  else                  else
513                          BitstreamPutBits(bs,                          BitstreamPutBits(bs, dcc_tab[qcoeff[i * 64 + 0] + 255].code,
                                          dcc_tab[qcoeff[i*64 + 0] + 255].code,  
514                                           dcc_tab[qcoeff[i*64 + 0] + 255].len);                                           dcc_tab[qcoeff[i*64 + 0] + 255].len);
515    
516                  if(pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
517                  {                          const uint16_t *scan_table =
518                                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
519                                    scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
520    
521                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
522    
523                          CodeCoeff(bs,                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
                                   &qcoeff[i*64],  
                                   intra_table,  
                                   scan_tables[pMB->acpred_directions[i]],  
                                   1);  
524    
525                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
526                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 302  Line 530 
530  }  }
531    
532    
533  static void CodeBlockInter(const MBParam * pParam,  static void
534    CodeBlockInter(const FRAMEINFO * const frame,
535                             const MACROBLOCK *pMB,                             const MACROBLOCK *pMB,
536                             int16_t qcoeff[6*64],                             int16_t qcoeff[6*64],
537                             Bitstream * bs,                             Bitstream * bs,
# Line 315  Line 544 
544          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
545          cbpy = 15 - (pMB->cbp >> 2);          cbpy = 15 - (pMB->cbp >> 2);
546    
547          // write mcbpc          /* write mcbpc */
548          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code, mcbpc_inter_tab[mcbpc].len);          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
549                                             mcbpc_inter_tab[mcbpc].len);
550    
551            if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
552                    BitstreamPutBit(bs, pMB->mcsel);                /* mcsel: '0'=local motion, '1'=GMC */
553    
554          // write cbpy          /* write cbpy */
555          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
556    
557          // write dquant          /* write dquant */
558          if(pMB->mode == MODE_INTER_Q)          if(pMB->mode == MODE_INTER_Q)
559                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
560    
561          // interlacing          /* interlacing */
562          if (pParam->global_flags & XVID_INTERLACING)          if (frame->vol_flags & XVID_VOL_INTERLACING) {
563          {                  if (pMB->cbp) {
564                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
565                  DEBUG1("codep: field_dct: ", pMB->field_dct);                          DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);
566                    }
567    
568                  // if inter block, write field ME flag                  /* if inter block, write field ME flag */
569                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
570                  {                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
571                          BitstreamPutBit(bs, pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
                         DEBUG1("codep: field_pred: ", pMB->field_pred);  
572    
573                          // write field prediction references                          /* write field prediction references */
574                          if (pMB->field_pred)  #if 0 /* Remove the #if once field_pred is supported */
575                          {                          if (pMB->field_pred) {
576                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
577                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
578                          }                          }
579    #endif
580                  }                  }
581          }          }
582    
583          // code motion vector(s)          bits = BitstreamPos(bs);
584          for(i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++)  
585          {          /* code motion vector(s) if motion is local  */
586                  CodeVector(bs, pMB->pmvs[i].x, pParam->fixed_code, pStat);          if (!pMB->mcsel)
587                  CodeVector(bs, pMB->pmvs[i].y, pParam->fixed_code, pStat);                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
588                            CodeVector(bs, pMB->pmvs[i].x, frame->fcode);
589                            CodeVector(bs, pMB->pmvs[i].y, frame->fcode);
590    
591    #ifdef _DEBUG
592                            if (i == 0) /* for simplicity */ {
593                                    int coded_length = BitstreamPos(bs) - bits;
594                                    int estimated_length = d_mv_bits(pMB->pmvs[i].x, pMB->pmvs[i].y, zeroMV, frame->fcode, 0);
595                                    assert(estimated_length == coded_length);
596                                    d_mv_bits(pMB->pmvs[i].x, pMB->pmvs[i].y, zeroMV, frame->fcode, 0);
597                            }
598    #endif
599          }          }
600    
601            bits = BitstreamPos(bs) - bits;
602            pStat->iMVBits += bits;
603    
604          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
605    
606          // code block coeffs          /* code block coeffs */
607          for(i = 0; i < 6; i++)          for(i = 0; i < 6; i++)
608                  if(pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
609                          CodeCoeff(bs, &qcoeff[i*64], inter_table, scan_tables[0], 0);                          const uint16_t *scan_table =
610                                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
611                                    scan_tables[2] : scan_tables[0];
612    
613                            CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
614                    }
615    
616          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
617          pStat->iTextBits += bits;          pStat->iTextBits += bits;
   
618  }  }
619    
620    
621  void MBCoding(const MBParam * pParam,  void
622    MBCoding(const FRAMEINFO * const frame,
623                MACROBLOCK *pMB,                MACROBLOCK *pMB,
624                int16_t qcoeff[6*64],                int16_t qcoeff[6*64],
625                Bitstream * bs,                Bitstream * bs,
626                Statistics * pStat)                Statistics * pStat)
627  {  {
628            if (frame->coding_type != I_VOP)
629                            BitstreamPutBit(bs, 0); /* not_coded */
630    
631            if (frame->vop_flags & XVID_VOP_GREYSCALE) {
632                    pMB->cbp &= 0x3C;               /* keep only bits 5-2 */
633                    qcoeff[4*64+0]=0;               /* for INTRA DC value is saved */
634                    qcoeff[5*64+0]=0;
635            }
636    
637          int intra = (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q);          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
638                    CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
639            else
640                    CodeBlockInter(frame, pMB, qcoeff, bs, pStat);
641    
642          if(pParam->coding_type == P_VOP) {  }
643                  if(pMB->cbp == 0 && pMB->mode == MODE_INTER &&  
644                     pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0)  /***************************************************************
645     * bframe encoding start
646     ***************************************************************/
647    
648    /*
649            mbtype
650            0       1b              direct(h263)            mvdb
651            1       01b             interpolate mc+q        dbquant, mvdf, mvdb
652            2       001b    backward mc+q           dbquant, mvdb
653            3       0001b   forward mc+q            dbquant, mvdf
654    */
655    
656    static __inline void
657    put_bvop_mbtype(Bitstream * bs,
658                                    int value)
659    {
660            switch (value) {
661                    case MODE_FORWARD:
662                            BitstreamPutBit(bs, 0);
663                    case MODE_BACKWARD:
664                            BitstreamPutBit(bs, 0);
665                    case MODE_INTERPOLATE:
666                            BitstreamPutBit(bs, 0);
667                    case MODE_DIRECT:
668                            BitstreamPutBit(bs, 1);
669                    default:
670                            break;
671            }
672    }
673    
674    /*
675            dbquant
676            -2      10b
677            0       0b
678            +2      11b
679    */
680    
681    static __inline void
682    put_bvop_dbquant(Bitstream * bs,
683                                     int value)
684    {
685            switch (value) {
686            case 0:
687                    BitstreamPutBit(bs, 0);
688                    return;
689    
690            case -2:
691                    BitstreamPutBit(bs, 1);
692                    BitstreamPutBit(bs, 0);
693                    return;
694    
695            case 2:
696                    BitstreamPutBit(bs, 1);
697                    BitstreamPutBit(bs, 1);
698                    return;
699    
700            default:;                                       /* invalid */
701            }
702    }
703    
704    
705    
706    void
707    MBCodingBVOP(const FRAMEINFO * const frame,
708                             const MACROBLOCK * mb,
709                             const int16_t qcoeff[6 * 64],
710                             const int32_t fcode,
711                             const int32_t bcode,
712                             Bitstream * bs,
713                             Statistics * pStat)
714                  {                  {
715                          BitstreamPutBit(bs, 1);         // not_coded          int vcode = fcode;
716            unsigned int i;
717    
718            const uint16_t *scan_table =
719                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
720                    scan_tables[2] : scan_tables[0];
721            int bits;
722    
723    /*      ------------------------------------------------------------------
724                    when a block is skipped it is decoded DIRECT(0,0)
725                    hence is interpolated from forward & backward frames
726            ------------------------------------------------------------------ */
727    
728            if (mb->mode == MODE_DIRECT_NONE_MV) {
729                    BitstreamPutBit(bs, 1); /* skipped */
730                          return;                          return;
731                  }                  }
732                  else  
733                          BitstreamPutBit(bs, 0);         // coded          BitstreamPutBit(bs, 0);         /* not skipped */
734    
735            if (mb->cbp == 0) {
736                    BitstreamPutBit(bs, 1); /* cbp == 0 */
737            } else {
738                    BitstreamPutBit(bs, 0); /* cbp == xxx */
739          }          }
740    
741          if(intra)          put_bvop_mbtype(bs, mb->mode);
742                  CodeBlockIntra(pParam, pMB, qcoeff, bs, pStat);  
743          else          if (mb->cbp) {
744                  CodeBlockInter(pParam, pMB, qcoeff, bs, pStat);                  BitstreamPutBits(bs, mb->cbp, 6);
745            }
746    
747            if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
748                    put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */
749            }
750    
751            if (frame->vol_flags & XVID_VOL_INTERLACING) {
752                    if (mb->cbp) {
753                            BitstreamPutBit(bs, mb->field_dct);
754                            DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);
755  }  }
756    
757                    /* if not direct block, write field ME flag */
758                    if (mb->mode != MODE_DIRECT) {
759                            BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
760    
761                            /* write field prediction references */
762    #if 0 /* Remove the #if once field_pred is supported */
763                            if (mb->field_pred) {
764                                    BitstreamPutBit(bs, mb->field_for_top);
765                                    BitstreamPutBit(bs, mb->field_for_bot);
766                            }
767    #endif
768                    }
769            }
770    
771            bits = BitstreamPos(bs);
772    
773            switch (mb->mode) {
774                    case MODE_INTERPOLATE:
775                            CodeVector(bs, mb->pmvs[1].x, vcode); /* forward vector of interpolate mode */
776                            CodeVector(bs, mb->pmvs[1].y, vcode);
777                    case MODE_BACKWARD:
778                            vcode = bcode;
779                    case MODE_FORWARD:
780                            CodeVector(bs, mb->pmvs[0].x, vcode);
781                            CodeVector(bs, mb->pmvs[0].y, vcode);
782                            break;
783                    case MODE_DIRECT:
784                            CodeVector(bs, mb->pmvs[3].x, 1);       /* fcode is always 1 for delta vector */
785                            CodeVector(bs, mb->pmvs[3].y, 1);       /* prediction is always (0,0) */
786                    default: break;
787            }
788            pStat->iMVBits += BitstreamPos(bs) - bits;
789    
790            bits = BitstreamPos(bs);
791            for (i = 0; i < 6; i++) {
792                    if (mb->cbp & (1 << (5 - i))) {
793                            CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
794                    }
795            }
796            pStat->iTextBits += BitstreamPos(bs) - bits;
797    }
798    
799    
800    
801  /***************************************************************  /***************************************************************
802   * decoding stuff starts here                                  *   * decoding stuff starts here                                  *
803   ***************************************************************/   ***************************************************************/
804    
805  int get_mcbpc_intra(Bitstream * bs)  
806    /*
807     * for IVOP addbits == 0
808     * for PVOP addbits == fcode - 1
809     * for BVOP addbits == max(fcode,bcode) - 1
810     * returns true or false
811     */
812    int
813    check_resync_marker(Bitstream * bs, int addbits)
814    {
815            uint32_t nbits;
816            uint32_t code;
817            uint32_t nbitsresyncmarker = NUMBITS_VP_RESYNC_MARKER + addbits;
818    
819            nbits = BitstreamNumBitsToByteAlign(bs);
820            code = BitstreamShowBits(bs, nbits);
821    
822            if (code == (((uint32_t)1 << (nbits - 1)) - 1))
823  {  {
824                    return BitstreamShowBitsFromByteAlign(bs, nbitsresyncmarker) == RESYNC_MARKER;
825            }
826    
827          uint32_t index;          return 0;
828    }
829    
830    
831    
832    int
833    get_mcbpc_intra(Bitstream * bs)
834    {
835    
836          while((index = BitstreamShowBits(bs, 9)) == 1)          uint32_t index;
                 BitstreamSkip(bs, 9);  
837    
838            index = BitstreamShowBits(bs, 9);
839          index >>= 3;          index >>= 3;
840    
841          BitstreamSkip(bs, mcbpc_intra_table[index].len);          BitstreamSkip(bs, mcbpc_intra_table[index].len);
# Line 414  Line 844 
844    
845  }  }
846    
847  int get_mcbpc_inter(Bitstream * bs)  int
848    get_mcbpc_inter(Bitstream * bs)
849  {  {
850    
851          uint32_t index;          uint32_t index;
852    
853          while((index = CLIP(BitstreamShowBits(bs, 9), 256)) == 1)          index = MIN(BitstreamShowBits(bs, 9), 256);
                 BitstreamSkip(bs, 9);  
854    
855          BitstreamSkip(bs,  mcbpc_inter_table[index].len);          BitstreamSkip(bs,  mcbpc_inter_table[index].len);
856    
# Line 428  Line 858 
858    
859  }  }
860    
861  int get_cbpy(Bitstream * bs, int intra)  int
862    get_cbpy(Bitstream * bs,
863                     int intra)
864  {  {
865    
866          int cbpy;          int cbpy;
# Line 444  Line 876 
876    
877  }  }
878    
879  int get_mv_data(Bitstream * bs)  static __inline int
880    get_mv_data(Bitstream * bs)
881  {  {
882    
883          uint32_t index;          uint32_t index;
# Line 454  Line 887 
887    
888          index = BitstreamShowBits(bs, 12);          index = BitstreamShowBits(bs, 12);
889    
890          if(index >= 512)          if (index >= 512) {
         {  
891                  index = (index >> 8) - 2;                  index = (index >> 8) - 2;
892                  BitstreamSkip(bs, TMNMVtab0[index].len);                  BitstreamSkip(bs, TMNMVtab0[index].len);
893                  return TMNMVtab0[index].code;                  return TMNMVtab0[index].code;
894          }          }
895    
896          if(index >= 128)          if (index >= 128) {
         {  
897                  index = (index >> 2) - 32;                  index = (index >> 2) - 32;
898                  BitstreamSkip(bs, TMNMVtab1[index].len);                  BitstreamSkip(bs, TMNMVtab1[index].len);
899                  return TMNMVtab1[index].code;                  return TMNMVtab1[index].code;
# Line 475  Line 906 
906    
907  }  }
908    
909  int get_mv(Bitstream * bs, int fcode)  int
910    get_mv(Bitstream * bs,
911               int fcode)
912  {  {
913    
914          int data;          int data;
# Line 489  Line 922 
922                  return data;                  return data;
923    
924          res = BitstreamGetBits(bs, fcode - 1);          res = BitstreamGetBits(bs, fcode - 1);
925          mv = ((ABS(data) - 1) * scale_fac) + res + 1;          mv = ((abs(data) - 1) * scale_fac) + res + 1;
926    
927          return data < 0 ? -mv : mv;          return data < 0 ? -mv : mv;
928    
929  }  }
930    
931  int get_dc_dif(Bitstream * bs, uint32_t dc_size)  int
932    get_dc_dif(Bitstream * bs,
933                       uint32_t dc_size)
934  {  {
935    
936          int code = BitstreamGetBits(bs, dc_size);          int code = BitstreamGetBits(bs, dc_size);
# Line 508  Line 943 
943    
944  }  }
945    
946  int get_dc_size_lum(Bitstream * bs)  int
947    get_dc_size_lum(Bitstream * bs)
948  {  {
949    
950          int code, i;          int code, i;
951    
952          code = BitstreamShowBits(bs, 11);          code = BitstreamShowBits(bs, 11);
953    
954          for(i = 11; i > 3; i--) {          for(i = 11; i > 3; i--) {
# Line 528  Line 965 
965  }  }
966    
967    
968  int get_dc_size_chrom(Bitstream * bs)  int
969    get_dc_size_chrom(Bitstream * bs)
970  {  {
971    
972          uint32_t code, i;          uint32_t code, i;
973    
974          code = BitstreamShowBits(bs, 12);          code = BitstreamShowBits(bs, 12);
975    
976          for(i = 12; i > 2; i--) {          for(i = 12; i > 2; i--) {
# Line 546  Line 985 
985    
986  }  }
987    
988  int get_coeff(Bitstream * bs, int *run, int *last, int intra, int short_video_header)  #define GET_BITS(cache, n) ((cache)>>(32-(n)))
989    
990    static __inline int
991    get_coeff(Bitstream * bs,
992                      int *run,
993                      int *last,
994                      int intra,
995                      int short_video_header)
996  {  {
997    
998          uint32_t mode;          uint32_t mode;
         const VLC *tab;  
999          int32_t level;          int32_t level;
1000            REVERSE_EVENT *reverse_event;
1001    
1002            uint32_t cache = BitstreamShowBits(bs, 32);
1003    
1004          if(short_video_header) // inter-VLCs will be used for both intra and inter blocks          if (short_video_header)         /* inter-VLCs will be used for both intra and inter blocks */
1005                  intra = 0;                  intra = 0;
1006    
1007          tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];          if (GET_BITS(cache, 7) != ESCAPE) {
1008                    reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1009    
1010          if(tab->code == -1)                  if ((level = reverse_event->event.level) == 0)
1011                  goto error;                  goto error;
1012    
1013          BitstreamSkip(bs, tab->len);                  *last = reverse_event->event.last;
1014                    *run  = reverse_event->event.run;
1015    
1016          if(tab->code != ESCAPE) {                  /* Don't forget to update the bitstream position */
1017                  if(!intra)                  BitstreamSkip(bs, reverse_event->len+1);
1018                  {  
1019                          *run = (tab->code >> 4) & 255;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
                         level = tab->code & 15;  
                         *last = (tab->code >> 12) & 1;  
                 }  
                 else  
                 {  
                         *run = (tab->code >> 8) & 255;  
                         level = tab->code & 255;  
                         *last = (tab->code >> 16) & 1;  
                 }  
                 return BitstreamGetBit(bs) ? -level : level;  
1020          }          }
1021    
1022          if(short_video_header)          /* flush 7bits of cache */
1023          {          cache <<= 7;
1024                  // escape mode 4 - H.263 type, only used if short_video_header = 1  
1025                  *last = BitstreamGetBit(bs);          if (short_video_header) {
1026                  *run = BitstreamGetBits(bs, 6);                  /* escape mode 4 - H.263 type, only used if short_video_header = 1  */
1027                  level = BitstreamGetBits(bs, 8);                  *last =  GET_BITS(cache, 1);
1028                    *run  = (GET_BITS(cache, 7) &0x3f);
1029                    level = (GET_BITS(cache, 15)&0xff);
1030    
1031                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1032                          DEBUG1("Illegal LEVEL for ESCAPE mode 4:", level);                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1033    
1034                  return (level >= 128 ? -(256 - level) : level);                  /* We've "eaten" 22 bits */
1035                    BitstreamSkip(bs, 22);
1036    
1037                    return (level << 24) >> 24;
1038          }          }
1039    
1040          mode = BitstreamShowBits(bs, 2);          if ((mode = GET_BITS(cache, 2)) < 3) {
1041                    const int skip[3] = {1, 1, 2};
1042                    cache <<= skip[mode];
1043    
1044          if(mode < 3) {                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
1045    
1046                  tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  if ((level = reverse_event->event.level) == 0)
                 if (tab->code == -1)  
1047                          goto error;                          goto error;
1048    
1049                  BitstreamSkip(bs, tab->len);                  *last = reverse_event->event.last;
1050                    *run  = reverse_event->event.run;
1051    
1052                  if (!intra) {                  if (mode < 2) {
1053                          *run = (tab->code >> 4) & 255;                          /* first escape mode, level is offset */
1054                          level = tab->code & 15;                          level += max_level[intra][*last][*run];
1055                          *last = (tab->code >> 12) & 1;                  } else {
1056                  }                          /* second escape mode, run is offset */
1057                  else                          *run += max_run[intra][*last][level] + 1;
                 {  
                         *run = (tab->code >> 8) & 255;  
                         level = tab->code & 255;  
                         *last = (tab->code >> 16) & 1;  
1058                  }                  }
1059    
1060                  if(mode < 2) // first escape mode, level is offset                  /* Update bitstream position */
1061                          level += max_level[*last + (!intra<<1)][*run]; // need to add back the max level                  BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
                 else if(mode == 2)  // second escape mode, run is offset  
                         *run += max_run[*last + (!intra<<1)][level] + 1;  
1062    
1063                  return BitstreamGetBit(bs) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1064          }          }
1065    
1066          // third escape mode - fixed length codes          /* third escape mode - fixed length codes */
1067          BitstreamSkip(bs, 2);          cache <<= 2;
1068          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1069          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1070          BitstreamSkip(bs, 1);                           // marker          level = (GET_BITS(cache, 20)&0xfff);
         level = BitstreamGetBits(bs, 12);  
         BitstreamSkip(bs, 1);                           // marker  
1071    
1072          return (level & 0x800) ? (level | (-1 ^ 0xfff)) : level;          /* Update bitstream position */
1073            BitstreamSkip(bs, 30);
1074    
1075            return (level << 20) >> 20;
1076    
1077   error:   error:
1078          *run = VLC_ERROR;          *run = VLC_ERROR;
1079          return 0;          return 0;
   
1080  }  }
1081    
1082    void
1083  void get_intra_block(Bitstream * bs, int16_t * block, int direction, int coeff)  get_intra_block(Bitstream * bs,
1084                                    int16_t * block,
1085                                    int direction,
1086                                    int coeff)
1087  {  {
1088    
1089          const uint16_t * scan = scan_tables[ direction ];          const uint16_t * scan = scan_tables[ direction ];
1090          int level;          int level, run, last;
         int run;  
         int last;  
1091    
1092          do          do {
         {  
1093                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1094                  if (run == -1)                  if (run == -1) {
1095                  {                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
                         DEBUG("fatal: invalid run");  
1096                          break;                          break;
1097                  }                  }
1098                  coeff += run;                  coeff += run;
1099    
1100    #ifdef _DEBUG
1101                    if(coeff>=64) {
1102                      DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1103                      return;
1104                    }
1105    #endif
1106    
1107                  block[ scan[coeff] ] = level;                  block[ scan[coeff] ] = level;
1108                  if (level < -127 || level > 127)  
1109                  {                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1110                          DEBUG1("warning: intra_overflow", level);  #if 0
1111                    DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1112    #endif
1113    
1114                    if (level < -2047 || level > 2047) {
1115                            DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1116                  }                  }
1117                  coeff++;                  coeff++;
1118          } while (!last);          } while (!last);
1119    
1120  }  }
1121    
1122  void get_inter_block(Bitstream * bs, int16_t * block)  void
1123    get_inter_block_h263(
1124                    Bitstream * bs,
1125                    int16_t * block,
1126                    int direction,
1127                    const int quant,
1128                    const uint16_t *matrix)
1129  {  {
1130    
1131          const uint16_t * scan = scan_tables[0];          const uint16_t *scan = scan_tables[direction];
1132            const uint16_t quant_m_2 = quant << 1;
1133            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1134          int p;          int p;
1135          int level;          int level;
1136          int run;          int run;
1137          int last;          int last;
1138    
1139          p = 0;          p = 0;
1140          do          do {
         {  
1141                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1142                  if (run == -1)                  if (run == -1) {
1143                  {                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
                         DEBUG("fatal: invalid run");  
1144                          break;                          break;
1145                  }                  }
1146                  p += run;                  p += run;
1147                  block[ scan[p] ] = level;  
1148                  if (level < -127 || level > 127)  #ifdef _DEBUG
1149                  {                  if(p>=64)       {
1150                          DEBUG1("warning: inter_overflow", level);                    DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1151                      return;
1152                    }
1153    #endif
1154    
1155                    if (level < 0) {
1156                            level = level*quant_m_2 - quant_add;
1157                            block[scan[p]] = (level >= -2048 ? level : -2048);
1158                    } else {
1159                            level = level * quant_m_2 + quant_add;
1160                            block[scan[p]] = (level <= 2047 ? level : 2047);
1161                  }                  }
1162                  p++;                  p++;
1163          } while (!last);          } while (!last);
1164    }
1165    
1166    void
1167    get_inter_block_mpeg(
1168                    Bitstream * bs,
1169                    int16_t * block,
1170                    int direction,
1171                    const int quant,
1172                    const uint16_t *matrix)
1173    {
1174            const uint16_t *scan = scan_tables[direction];
1175            uint32_t sum = 0;
1176            int p;
1177            int level;
1178            int run;
1179            int last;
1180    
1181            p = 0;
1182            do {
1183                    level = get_coeff(bs, &run, &last, 0, 0);
1184                    if (run == -1) {
1185                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1186                            break;
1187                    }
1188                    p += run;
1189    
1190    #ifdef _DEBUG
1191                    if(p>=64)       {
1192                      DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1193                      return;
1194  }  }
1195    #endif
1196    
1197                    if (level < 0) {
1198                            level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1199                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1200                    } else {
1201                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1202                            block[scan[p]] = (level <= 2047 ? level : 2047);
1203                    }
1204    
1205                    sum ^= block[scan[p]];
1206    
1207                    p++;
1208            } while (!last);
1209    
1210            /*      mismatch control */
1211            if ((sum & 1) == 0) {
1212                    block[63] ^= 1;
1213            }
1214    }
1215    
1216    
1217    /*****************************************************************************
1218     * VLC tables and other constant arrays
1219     ****************************************************************************/
1220    
1221    VLC_TABLE const coeff_tab[2][102] =
1222    {
1223            /* intra = 0 */
1224            {
1225                    {{ 2,  2}, {0, 0, 1}},
1226                    {{15,  4}, {0, 0, 2}},
1227                    {{21,  6}, {0, 0, 3}},
1228                    {{23,  7}, {0, 0, 4}},
1229                    {{31,  8}, {0, 0, 5}},
1230                    {{37,  9}, {0, 0, 6}},
1231                    {{36,  9}, {0, 0, 7}},
1232                    {{33, 10}, {0, 0, 8}},
1233                    {{32, 10}, {0, 0, 9}},
1234                    {{ 7, 11}, {0, 0, 10}},
1235                    {{ 6, 11}, {0, 0, 11}},
1236                    {{32, 11}, {0, 0, 12}},
1237                    {{ 6,  3}, {0, 1, 1}},
1238                    {{20,  6}, {0, 1, 2}},
1239                    {{30,  8}, {0, 1, 3}},
1240                    {{15, 10}, {0, 1, 4}},
1241                    {{33, 11}, {0, 1, 5}},
1242                    {{80, 12}, {0, 1, 6}},
1243                    {{14,  4}, {0, 2, 1}},
1244                    {{29,  8}, {0, 2, 2}},
1245                    {{14, 10}, {0, 2, 3}},
1246                    {{81, 12}, {0, 2, 4}},
1247                    {{13,  5}, {0, 3, 1}},
1248                    {{35,  9}, {0, 3, 2}},
1249                    {{13, 10}, {0, 3, 3}},
1250                    {{12,  5}, {0, 4, 1}},
1251                    {{34,  9}, {0, 4, 2}},
1252                    {{82, 12}, {0, 4, 3}},
1253                    {{11,  5}, {0, 5, 1}},
1254                    {{12, 10}, {0, 5, 2}},
1255                    {{83, 12}, {0, 5, 3}},
1256                    {{19,  6}, {0, 6, 1}},
1257                    {{11, 10}, {0, 6, 2}},
1258                    {{84, 12}, {0, 6, 3}},
1259                    {{18,  6}, {0, 7, 1}},
1260                    {{10, 10}, {0, 7, 2}},
1261                    {{17,  6}, {0, 8, 1}},
1262                    {{ 9, 10}, {0, 8, 2}},
1263                    {{16,  6}, {0, 9, 1}},
1264                    {{ 8, 10}, {0, 9, 2}},
1265                    {{22,  7}, {0, 10, 1}},
1266                    {{85, 12}, {0, 10, 2}},
1267                    {{21,  7}, {0, 11, 1}},
1268                    {{20,  7}, {0, 12, 1}},
1269                    {{28,  8}, {0, 13, 1}},
1270                    {{27,  8}, {0, 14, 1}},
1271                    {{33,  9}, {0, 15, 1}},
1272                    {{32,  9}, {0, 16, 1}},
1273                    {{31,  9}, {0, 17, 1}},
1274                    {{30,  9}, {0, 18, 1}},
1275                    {{29,  9}, {0, 19, 1}},
1276                    {{28,  9}, {0, 20, 1}},
1277                    {{27,  9}, {0, 21, 1}},
1278                    {{26,  9}, {0, 22, 1}},
1279                    {{34, 11}, {0, 23, 1}},
1280                    {{35, 11}, {0, 24, 1}},
1281                    {{86, 12}, {0, 25, 1}},
1282                    {{87, 12}, {0, 26, 1}},
1283                    {{ 7,  4}, {1, 0, 1}},
1284                    {{25,  9}, {1, 0, 2}},
1285                    {{ 5, 11}, {1, 0, 3}},
1286                    {{15,  6}, {1, 1, 1}},
1287                    {{ 4, 11}, {1, 1, 2}},
1288                    {{14,  6}, {1, 2, 1}},
1289                    {{13,  6}, {1, 3, 1}},
1290                    {{12,  6}, {1, 4, 1}},
1291                    {{19,  7}, {1, 5, 1}},
1292                    {{18,  7}, {1, 6, 1}},
1293                    {{17,  7}, {1, 7, 1}},
1294                    {{16,  7}, {1, 8, 1}},
1295                    {{26,  8}, {1, 9, 1}},
1296                    {{25,  8}, {1, 10, 1}},
1297                    {{24,  8}, {1, 11, 1}},
1298                    {{23,  8}, {1, 12, 1}},
1299                    {{22,  8}, {1, 13, 1}},
1300                    {{21,  8}, {1, 14, 1}},
1301                    {{20,  8}, {1, 15, 1}},
1302                    {{19,  8}, {1, 16, 1}},
1303                    {{24,  9}, {1, 17, 1}},
1304                    {{23,  9}, {1, 18, 1}},
1305                    {{22,  9}, {1, 19, 1}},
1306                    {{21,  9}, {1, 20, 1}},
1307                    {{20,  9}, {1, 21, 1}},
1308                    {{19,  9}, {1, 22, 1}},
1309                    {{18,  9}, {1, 23, 1}},
1310                    {{17,  9}, {1, 24, 1}},
1311                    {{ 7, 10}, {1, 25, 1}},
1312                    {{ 6, 10}, {1, 26, 1}},
1313                    {{ 5, 10}, {1, 27, 1}},
1314                    {{ 4, 10}, {1, 28, 1}},
1315                    {{36, 11}, {1, 29, 1}},
1316                    {{37, 11}, {1, 30, 1}},
1317                    {{38, 11}, {1, 31, 1}},
1318                    {{39, 11}, {1, 32, 1}},
1319                    {{88, 12}, {1, 33, 1}},
1320                    {{89, 12}, {1, 34, 1}},
1321                    {{90, 12}, {1, 35, 1}},
1322                    {{91, 12}, {1, 36, 1}},
1323                    {{92, 12}, {1, 37, 1}},
1324                    {{93, 12}, {1, 38, 1}},
1325                    {{94, 12}, {1, 39, 1}},
1326                    {{95, 12}, {1, 40, 1}}
1327            },
1328            /* intra = 1 */
1329            {
1330                    {{ 2,  2}, {0, 0, 1}},
1331                    {{15,  4}, {0, 0, 3}},
1332                    {{21,  6}, {0, 0, 6}},
1333                    {{23,  7}, {0, 0, 9}},
1334                    {{31,  8}, {0, 0, 10}},
1335                    {{37,  9}, {0, 0, 13}},
1336                    {{36,  9}, {0, 0, 14}},
1337                    {{33, 10}, {0, 0, 17}},
1338                    {{32, 10}, {0, 0, 18}},
1339                    {{ 7, 11}, {0, 0, 21}},
1340                    {{ 6, 11}, {0, 0, 22}},
1341                    {{32, 11}, {0, 0, 23}},
1342                    {{ 6,  3}, {0, 0, 2}},
1343                    {{20,  6}, {0, 1, 2}},
1344                    {{30,  8}, {0, 0, 11}},
1345                    {{15, 10}, {0, 0, 19}},
1346                    {{33, 11}, {0, 0, 24}},
1347                    {{80, 12}, {0, 0, 25}},
1348                    {{14,  4}, {0, 1, 1}},
1349                    {{29,  8}, {0, 0, 12}},
1350                    {{14, 10}, {0, 0, 20}},
1351                    {{81, 12}, {0, 0, 26}},
1352                    {{13,  5}, {0, 0, 4}},
1353                    {{35,  9}, {0, 0, 15}},
1354                    {{13, 10}, {0, 1, 7}},
1355                    {{12,  5}, {0, 0, 5}},
1356                    {{34,  9}, {0, 4, 2}},
1357                    {{82, 12}, {0, 0, 27}},
1358                    {{11,  5}, {0, 2, 1}},
1359                    {{12, 10}, {0, 2, 4}},
1360                    {{83, 12}, {0, 1, 9}},
1361                    {{19,  6}, {0, 0, 7}},
1362                    {{11, 10}, {0, 3, 4}},
1363                    {{84, 12}, {0, 6, 3}},
1364                    {{18,  6}, {0, 0, 8}},
1365                    {{10, 10}, {0, 4, 3}},
1366                    {{17,  6}, {0, 3, 1}},
1367                    {{ 9, 10}, {0, 8, 2}},
1368                    {{16,  6}, {0, 4, 1}},
1369                    {{ 8, 10}, {0, 5, 3}},
1370                    {{22,  7}, {0, 1, 3}},
1371                    {{85, 12}, {0, 1, 10}},
1372                    {{21,  7}, {0, 2, 2}},
1373                    {{20,  7}, {0, 7, 1}},
1374                    {{28,  8}, {0, 1, 4}},
1375                    {{27,  8}, {0, 3, 2}},
1376                    {{33,  9}, {0, 0, 16}},
1377                    {{32,  9}, {0, 1, 5}},
1378                    {{31,  9}, {0, 1, 6}},
1379                    {{30,  9}, {0, 2, 3}},
1380                    {{29,  9}, {0, 3, 3}},
1381                    {{28,  9}, {0, 5, 2}},
1382                    {{27,  9}, {0, 6, 2}},
1383                    {{26,  9}, {0, 7, 2}},
1384                    {{34, 11}, {0, 1, 8}},
1385                    {{35, 11}, {0, 9, 2}},
1386                    {{86, 12}, {0, 2, 5}},
1387                    {{87, 12}, {0, 7, 3}},
1388                    {{ 7,  4}, {1, 0, 1}},
1389                    {{25,  9}, {0, 11, 1}},
1390                    {{ 5, 11}, {1, 0, 6}},
1391                    {{15,  6}, {1, 1, 1}},
1392                    {{ 4, 11}, {1, 0, 7}},
1393                    {{14,  6}, {1, 2, 1}},
1394                    {{13,  6}, {0, 5, 1}},
1395                    {{12,  6}, {1, 0, 2}},
1396                    {{19,  7}, {1, 5, 1}},
1397                    {{18,  7}, {0, 6, 1}},
1398                    {{17,  7}, {1, 3, 1}},
1399                    {{16,  7}, {1, 4, 1}},
1400                    {{26,  8}, {1, 9, 1}},
1401                    {{25,  8}, {0, 8, 1}},
1402                    {{24,  8}, {0, 9, 1}},
1403                    {{23,  8}, {0, 10, 1}},
1404                    {{22,  8}, {1, 0, 3}},
1405                    {{21,  8}, {1, 6, 1}},
1406                    {{20,  8}, {1, 7, 1}},
1407                    {{19,  8}, {1, 8, 1}},
1408                    {{24,  9}, {0, 12, 1}},
1409                    {{23,  9}, {1, 0, 4}},
1410                    {{22,  9}, {1, 1, 2}},
1411                    {{21,  9}, {1, 10, 1}},
1412                    {{20,  9}, {1, 11, 1}},
1413                    {{19,  9}, {1, 12, 1}},
1414                    {{18,  9}, {1, 13, 1}},
1415                    {{17,  9}, {1, 14, 1}},
1416                    {{ 7, 10}, {0, 13, 1}},
1417                    {{ 6, 10}, {1, 0, 5}},
1418                    {{ 5, 10}, {1, 1, 3}},
1419                    {{ 4, 10}, {1, 2, 2}},
1420                    {{36, 11}, {1, 3, 2}},
1421                    {{37, 11}, {1, 4, 2}},
1422                    {{38, 11}, {1, 15, 1}},
1423                    {{39, 11}, {1, 16, 1}},
1424                    {{88, 12}, {0, 14, 1}},
1425                    {{89, 12}, {1, 0, 8}},
1426                    {{90, 12}, {1, 5, 2}},
1427                    {{91, 12}, {1, 6, 2}},
1428                    {{92, 12}, {1, 17, 1}},
1429                    {{93, 12}, {1, 18, 1}},
1430                    {{94, 12}, {1, 19, 1}},
1431                    {{95, 12}, {1, 20, 1}}
1432            }
1433    };
1434    
1435    /* constants taken from momusys/vm_common/inlcude/max_level.h */
1436    uint8_t const max_level[2][2][64] = {
1437            {
1438                    /* intra = 0, last = 0 */
1439                    {
1440                            12, 6, 4, 3, 3, 3, 3, 2,
1441                            2, 2, 2, 1, 1, 1, 1, 1,
1442                            1, 1, 1, 1, 1, 1, 1, 1,
1443                            1, 1, 1, 0, 0, 0, 0, 0,
1444                            0, 0, 0, 0, 0, 0, 0, 0,
1445                            0, 0, 0, 0, 0, 0, 0, 0,
1446                            0, 0, 0, 0, 0, 0, 0, 0,
1447                            0, 0, 0, 0, 0, 0, 0, 0
1448                    },
1449                    /* intra = 0, last = 1 */
1450                    {
1451                            3, 2, 1, 1, 1, 1, 1, 1,
1452                            1, 1, 1, 1, 1, 1, 1, 1,
1453                            1, 1, 1, 1, 1, 1, 1, 1,
1454                            1, 1, 1, 1, 1, 1, 1, 1,
1455                            1, 1, 1, 1, 1, 1, 1, 1,
1456                            1, 0, 0, 0, 0, 0, 0, 0,
1457                            0, 0, 0, 0, 0, 0, 0, 0,
1458                            0, 0, 0, 0, 0, 0, 0, 0
1459                    }
1460            },
1461            {
1462                    /* intra = 1, last = 0 */
1463                    {
1464                            27, 10, 5, 4, 3, 3, 3, 3,
1465                            2, 2, 1, 1, 1, 1, 1, 0,
1466                            0, 0, 0, 0, 0, 0, 0, 0,
1467                            0, 0, 0, 0, 0, 0, 0, 0,
1468                            0, 0, 0, 0, 0, 0, 0, 0,
1469                            0, 0, 0, 0, 0, 0, 0, 0,
1470                            0, 0, 0, 0, 0, 0, 0, 0,
1471                            0, 0, 0, 0, 0, 0, 0, 0
1472                    },
1473                    /* intra = 1, last = 1 */
1474                    {
1475                            8, 3, 2, 2, 2, 2, 2, 1,
1476                            1, 1, 1, 1, 1, 1, 1, 1,
1477                            1, 1, 1, 1, 1, 0, 0, 0,
1478                            0, 0, 0, 0, 0, 0, 0, 0,
1479                            0, 0, 0, 0, 0, 0, 0, 0,
1480                            0, 0, 0, 0, 0, 0, 0, 0,
1481                            0, 0, 0, 0, 0, 0, 0, 0,
1482                            0, 0, 0, 0, 0, 0, 0, 0
1483                    }
1484            }
1485    };
1486    
1487    uint8_t const max_run[2][2][64] = {
1488            {
1489                    /* intra = 0, last = 0 */
1490                    {
1491                            0, 26, 10, 6, 2, 1, 1, 0,
1492                            0, 0, 0, 0, 0, 0, 0, 0,
1493                            0, 0, 0, 0, 0, 0, 0, 0,
1494                            0, 0, 0, 0, 0, 0, 0, 0,
1495                            0, 0, 0, 0, 0, 0, 0, 0,
1496                            0, 0, 0, 0, 0, 0, 0, 0,
1497                            0, 0, 0, 0, 0, 0, 0, 0,
1498                            0, 0, 0, 0, 0, 0, 0, 0,
1499                    },
1500                    /* intra = 0, last = 1 */
1501                    {
1502                            0, 40, 1, 0, 0, 0, 0, 0,
1503                            0, 0, 0, 0, 0, 0, 0, 0,
1504                            0, 0, 0, 0, 0, 0, 0, 0,
1505                            0, 0, 0, 0, 0, 0, 0, 0,
1506                            0, 0, 0, 0, 0, 0, 0, 0,
1507                            0, 0, 0, 0, 0, 0, 0, 0,
1508                            0, 0, 0, 0, 0, 0, 0, 0,
1509                            0, 0, 0, 0, 0, 0, 0, 0,
1510                    }
1511            },
1512            {
1513                    /* intra = 1, last = 0 */
1514                    {
1515                            0, 14, 9, 7, 3, 2, 1, 1,
1516                            1, 1, 1, 0, 0, 0, 0, 0,
1517                            0, 0, 0, 0, 0, 0, 0, 0,
1518                            0, 0, 0, 0, 0, 0, 0, 0,
1519                            0, 0, 0, 0, 0, 0, 0, 0,
1520                            0, 0, 0, 0, 0, 0, 0, 0,
1521                            0, 0, 0, 0, 0, 0, 0, 0,
1522                            0, 0, 0, 0, 0, 0, 0, 0,
1523                    },
1524                    /* intra = 1, last = 1 */
1525                    {
1526                            0, 20, 6, 1, 0, 0, 0, 0,
1527                            0, 0, 0, 0, 0, 0, 0, 0,
1528                            0, 0, 0, 0, 0, 0, 0, 0,
1529                            0, 0, 0, 0, 0, 0, 0, 0,
1530                            0, 0, 0, 0, 0, 0, 0, 0,
1531                            0, 0, 0, 0, 0, 0, 0, 0,
1532                            0, 0, 0, 0, 0, 0, 0, 0,
1533                            0, 0, 0, 0, 0, 0, 0, 0,
1534                    }
1535            }
1536    };
1537    
1538    /******************************************************************
1539     * encoder tables                                                 *
1540     ******************************************************************/
1541    
1542    VLC sprite_trajectory_code[32768];
1543    
1544    VLC sprite_trajectory_len[15] = {
1545            { 0x00 , 2},
1546            { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1547            { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},
1548            { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1549    
1550    
1551    /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1552       the sign bit must be added afterwards. */
1553    
1554    /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1555     CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1556     Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1557    
1558    VLC mcbpc_intra_tab[15] = {
1559            {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1560            {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1561            {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1562            {0x00, 0}, {0x03, 3}, {0x03, 6}
1563    };
1564    
1565    /* MCBPC inter.
1566       Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1567    
1568    VLC mcbpc_inter_tab[29] = {
1569            {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1570            {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1571            {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1572            {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1573    };
1574    
1575    const VLC xvid_cbpy_tab[16] = {
1576            {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1577            {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1578    };
1579    
1580    const VLC dcy_tab[511] = {
1581            {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1582            {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1583            {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1584            {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1585            {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1586            {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1587            {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1588            {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1589            {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1590            {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1591            {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1592            {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1593            {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1594            {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1595            {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1596            {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1597            {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1598            {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1599            {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1600            {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1601            {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1602            {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1603            {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1604            {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1605            {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1606            {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1607            {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1608            {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1609            {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1610            {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1611            {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1612            {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1613            {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1614            {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1615            {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1616            {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1617            {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1618            {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1619            {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1620            {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1621            {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1622            {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1623            {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1624            {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1625            {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1626            {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1627            {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1628            {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1629            {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1630            {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1631            {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1632            {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1633            {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1634            {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1635            {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1636            {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1637            {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1638            {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1639            {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1640            {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1641            {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1642            {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1643            {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1644            {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1645            {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1646            {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1647            {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1648            {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1649            {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1650            {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1651            {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1652            {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1653            {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1654            {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1655            {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1656            {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1657            {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1658            {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1659            {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1660            {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1661            {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1662            {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1663            {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1664            {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1665            {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1666            {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1667            {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1668            {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1669            {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1670            {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1671            {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1672            {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1673            {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1674            {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1675            {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1676            {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1677            {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1678            {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1679            {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1680            {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1681            {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1682            {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1683            {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1684            {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1685            {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1686            {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1687            {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1688            {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1689            {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1690            {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1691            {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1692            {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1693            {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1694            {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1695            {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1696            {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1697            {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1698            {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1699            {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1700            {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1701            {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1702            {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1703            {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1704            {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1705            {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1706            {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1707            {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1708            {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1709    };
1710    
1711    const VLC dcc_tab[511] = {
1712            {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1713            {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1714            {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1715            {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1716            {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1717            {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1718            {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1719            {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1720            {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1721            {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1722            {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1723            {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1724            {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1725            {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1726            {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1727            {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1728            {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1729            {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1730            {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1731            {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1732            {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1733            {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1734            {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1735            {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1736            {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1737            {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1738            {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1739            {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1740            {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1741            {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1742            {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1743            {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1744            {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1745            {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1746            {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1747            {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1748            {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1749            {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1750            {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1751            {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1752            {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1753            {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1754            {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1755            {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1756            {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1757            {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1758            {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1759            {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1760            {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1761            {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1762            {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1763            {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1764            {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1765            {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1766            {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1767            {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1768            {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1769            {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1770            {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1771            {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1772            {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1773            {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1774            {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1775            {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1776            {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1777            {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1778            {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1779            {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1780            {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1781            {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1782            {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1783            {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1784            {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1785            {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1786            {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1787            {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1788            {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1789            {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1790            {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1791            {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1792            {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1793            {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1794            {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1795            {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1796            {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1797            {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1798            {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1799            {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1800            {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1801            {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1802            {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1803            {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1804            {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1805            {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1806            {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1807            {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1808            {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1809            {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1810            {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1811            {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1812            {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1813            {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1814            {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1815            {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1816            {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1817            {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1818            {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1819            {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1820            {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1821            {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1822            {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1823            {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1824            {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1825            {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1826            {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1827            {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1828            {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1829            {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1830            {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1831            {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1832            {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1833            {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1834            {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1835            {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1836            {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1837            {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1838            {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1839            {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1840    };
1841    
1842    
1843    const VLC mb_motion_table[65] = {
1844            {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1845            {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1846            {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1847            {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1848            {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1849            {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1850            {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1851            {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1852            {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1853            {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1854            {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1855            {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1856            {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1857            {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1858            {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1859            {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1860            {0x04, 13}
1861    };
1862    
1863    
1864    /******************************************************************
1865     * decoder tables                                                 *
1866     ******************************************************************/
1867    
1868    VLC const mcbpc_intra_table[64] = {
1869            {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4},  {4, 4},  {4, 4},  {4, 4},
1870            {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1871            {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1872            {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
1873            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1874            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1875            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1876            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1}
1877    };
1878    
1879    VLC const mcbpc_inter_table[257] = {
1880            {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1881            {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1882            {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1883            {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1884            {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1885            {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1886            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1887            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1888            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1889            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1890            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1891            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1892            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1893            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1894            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1895            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1896            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1897            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1898            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1899            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1900            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1901            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1902            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1903            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1904            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1905            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1906            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1907            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1908            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1909            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1910            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1911            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1912            {0, 1}
1913    };
1914    
1915    VLC const cbpy_table[64] = {
1916            {-1, 0}, {-1, 0}, {6, 6},  {9, 6},  {8, 5},  {8, 5},  {4, 5},  {4, 5},
1917            {2, 5},  {2, 5},  {1, 5},  {1, 5},  {0, 4},  {0, 4},  {0, 4},  {0, 4},
1918            {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1919            {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4},  {5, 4},  {5, 4},  {5, 4},
1920            {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4},  {3, 4},  {3, 4},  {3, 4},
1921            {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4},  {7, 4},  {7, 4},  {7, 4},
1922            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1923            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1924    };
1925    
1926    VLC const TMNMVtab0[] = {
1927            {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1928            {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1929    };
1930    
1931    VLC const TMNMVtab1[] = {
1932            {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1933            {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1934            {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1935            {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1936            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1937            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1938            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1939            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1940            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1941            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1942            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1943            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1944            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1945            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1946            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1947            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1948            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1949            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1950            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1951            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1952            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1953            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1954            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1955            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
1956    };
1957    
1958    VLC const TMNMVtab2[] = {
1959            {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
1960            {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
1961            {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
1962            {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
1963            {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
1964            {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
1965            {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
1966            {24, 10}, {24, 10}, {24, 10}, {24, 10},
1967            {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
1968            {23, 10}, {23, 10}, {23, 10}, {23, 10},
1969            {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
1970            {22, 10}, {22, 10}, {22, 10}, {22, 10},
1971            {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
1972            {21, 10}, {21, 10}, {21, 10}, {21, 10},
1973            {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
1974            {20, 10}, {20, 10}, {20, 10}, {20, 10},
1975            {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
1976            {19, 10}, {19, 10}, {19, 10}, {19, 10},
1977            {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
1978            {18, 10}, {18, 10}, {18, 10}, {18, 10},
1979            {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
1980            {17, 10}, {17, 10}, {17, 10}, {17, 10},
1981            {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
1982            {16, 10}, {16, 10}, {16, 10}, {16, 10},
1983            {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
1984            {15, 10}, {15, 10}, {15, 10}, {15, 10},
1985            {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
1986            {14, 10}, {14, 10}, {14, 10}, {14, 10},
1987            {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
1988            {13, 10}, {13, 10}, {13, 10}, {13, 10},
1989            {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10}
1990    };
1991    
1992    short const dc_threshold[] = {
1993            26708, 29545, 29472, 26223, 30580, 29281,  8293, 29545,
1994            25632, 29285, 30313, 25701, 26144, 28530,  8301, 26740,
1995             8293, 20039,  8277, 20551,  8268, 30296, 17513, 25376,
1996            25711, 25445, 10272, 11825, 11825, 10544,  2606, 28505,
1997            29301, 29472, 26223, 30580, 29281,  8293, 26980, 29811,
1998            26994, 30050, 28532,  8306, 24936,  8307, 28532, 26400,
1999            30313,  8293, 25441, 25955, 29555, 29728,  8303, 29801,
2000             8307, 28531, 29301, 25955, 25376, 25711, 11877,    10
2001    };
2002    
2003    VLC const dc_lum_tab[] = {
2004            {0, 0}, {4, 3}, {3, 3}, {0, 3},
2005            {2, 2}, {2, 2}, {1, 2}, {1, 2},
2006    };
Legend:
Removed from v.100  
changed lines
  Added in v.1773
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4