[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 514, Sun Sep 22 17:01:36 2002 UTC revision 883, Fri Feb 21 08:32:34 2003 UTC
# Line 1  Line 1 
1  /*****************************************************************************   /******************************************************************************
2   *    *                                                                            *
3   *  XVID MPEG-4 VIDEO CODEC    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *
4   *  - Macro Block coding functions -    *                                                                            *
5   *    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *
6   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
7   *    *  software module in hardware or software products are advised that its     *
8   *    *  use may infringe existing patents or copyrights, and any such use         *
9   *  This program is an implementation of a part of one or more MPEG-4    *  would be at such party's own risk.  The original developer of this        *
10   *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending    *  software module and his/her company, and subsequent editors and their     *
11   *  to use this software module in hardware or software products are    *  companies, will have no liability for use of this software or             *
12   *  advised that its use may infringe existing patents or copyrights, and    *  modifications or derivatives thereof.                                     *
13   *  any such use would be at such party's own risk.  The original    *                                                                            *
14   *  developer of this software module and his/her company, and subsequent    *  XviD is free software; you can redistribute it and/or modify it           *
15   *  editors and their companies, will have no liability for use of this    *  under the terms of the GNU General Public License as published by         *
16   *  software or modifications or derivatives thereof.    *  the Free Software Foundation; either version 2 of the License, or         *
17   *    *  (at your option) any later version.                                       *
18   *  This program is free software; you can redistribute it and/or modify    *                                                                            *
19   *  it under the terms of the GNU General Public License as published by    *  XviD is distributed in the hope that it will be useful, but               *
20   *  the Free Software Foundation; either version 2 of the License, or    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *
21   *  (at your option) any later version.    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
22   *    *  GNU General Public License for more details.                              *
23   *  This program is distributed in the hope that it will be useful,    *                                                                            *
24   *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *  You should have received a copy of the GNU General Public License         *
25   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *  along with this program; if not, write to the Free Software               *
26   *  GNU General Public License for more details.    *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *
27   *    *                                                                            *
28   *  You should have received a copy of the GNU General Public License    ******************************************************************************/
29   *  along with this program; if not, write to the Free Software  
30   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   /******************************************************************************
31   *    *                                                                            *
32   * $Id: mbcoding.c,v 1.32 2002-09-22 17:01:36 edgomez Exp $    *  mbcoding.c                                                                *
33   *    *                                                                            *
34   ****************************************************************************/    *  Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org>                  *
35      *                                                                            *
36      *  For more information visit the XviD homepage: http://www.xvid.org         *
37      *                                                                            *
38      ******************************************************************************/
39    
40     /******************************************************************************
41      *                                                                                                                                                        *
42      *  Revision history:                                                         *
43      *                                                                            *
44      *  28.10.2002 GMC support - gruel                                                                                        *
45      *  28.06.2002 added check_resync_marker()                                    *
46      *  14.04.2002 bframe encoding                                                                                            *
47      *  08.03.2002 initial version; isibaar                                                           *
48      *                                                                                                                                                        *
49      ******************************************************************************/
50    
51    
52    #include <stdio.h>
53  #include <stdlib.h>  #include <stdlib.h>
54  #include "../portab.h"  #include "../portab.h"
55    #include "../global.h"
56  #include "bitstream.h"  #include "bitstream.h"
57  #include "zigzag.h"  #include "zigzag.h"
58  #include "vlc_codes.h"  #include "vlc_codes.h"
# Line 42  Line 60 
60    
61  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
62    
63  #define ABS(X) (((X)>0)?(X):-(X))  /* #define BIGLUT */
 #define CLIP(X,A) (X > A) ? (A) : (X)  
64    
65  /*****************************************************************************  #ifdef BIGLUT
66   * Local data  #define LEVELOFFSET 2048
67   ****************************************************************************/  #else
68    #define LEVELOFFSET 32
69    #endif
70    
71    static REVERSE_EVENT DCT3D[2][4096];
72    
73    #ifdef BIGLUT
74    static VLC coeff_VLC[2][2][4096][64];
75    VLC *intra_table;
76    static VLC *inter_table;
77    #else
78    static VLC coeff_VLC[2][2][64][64];
79    #endif
80    
81  /* msvc sp5+pp gets confused if they globals are made static */  /* not really MB related, but VLCs are only available here */
82  VLC intra_table[524032];  void bs_put_spritetrajectory(Bitstream * bs, const int val)
83  VLC inter_table[524032];  {
84            const int code = sprite_trajectory_code[val+16384].code;
85            const int len = sprite_trajectory_code[val+16384].len;
86            const int code2 = sprite_trajectory_len[len].code;
87            const int len2 = sprite_trajectory_len[len].len;
88    
89  static VLC DCT3Dintra[4096];  //      printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
90  static VLC DCT3Dinter[4096];  //      printf("Code2 / Len2 = %d / %d \n",code2,len2);
91    
92  /*****************************************************************************          BitstreamPutBits(bs, code2, len2);
93   * Vector Length Coding Initialization          if (len) BitstreamPutBits(bs, code, len);
94   ****************************************************************************/  }
95    
96    int bs_get_spritetrajectory(Bitstream * bs)
97    {
98            int i;
99            for (i = 0; i < 12; i++)
100            {
101                    if (BitstreamShowBits(bs, sprite_trajectory_len[i].len) == sprite_trajectory_len[i].code)
102                    {
103                            BitstreamSkip(bs, sprite_trajectory_len[i].len);
104                            return i;
105                    }
106            }
107            return -1;
108    }
109    
110  void  void
111  init_vlc_tables(void)  init_vlc_tables(void)
112  {  {
113            uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
114            int32_t l;
115    
116          int32_t k, l, i, intra, last;  #ifdef BIGLUT
117          VLC *vlc[2];          intra_table = coeff_VLC[1];
118          VLC const **coeff_ptr;          inter_table = coeff_VLC[0];
119          VLC *vlc1, *vlc2;  #endif
   
         vlc1 = DCT3Dintra;  
         vlc2 = DCT3Dinter;  
   
         vlc[0] = intra_table;  
         vlc[1] = inter_table;  
120    
         /*  
          * Generate encoding vlc lookup tables  
          * the lookup table idea is taken from the excellent fame project  
          * by Vivien Chapellier  
          */  
         for (i = 0; i < 4; i++) {  
                 intra = i % 2;  
                 last = i / 2;  
121    
122                  coeff_ptr = coeff_vlc[last + 2 * intra];          for (intra = 0; intra < 2; intra++)
123                    for (i = 0; i < 4096; i++)
124                            DCT3D[intra][i].event.level = 0;
125    
126                  for (k = -2047; k < 2048; k++) {        // level          for (intra = 0; intra < 2; intra++)
127                          int8_t const *max_level_ptr = max_level[last + 2 * intra];                  for (last = 0; last < 2; last++)
128                          int8_t const *max_run_ptr = max_run[last + 2 * intra];                  {
129                            for (run = 0; run < 63 + last; run++)
130                                    for (level = 0; level < (uint32_t)(32 << intra); level++)
131                                    {
132    #ifdef BIGLUT
133                                            offset = LEVELOFFSET;
134    #else
135                                            offset = !intra * LEVELOFFSET;
136    #endif
137                                            coeff_VLC[intra][last][level + offset][run].len = 128;
138                                    }
139                    }
140    
141                          for (l = 0; l < 64; l++) {      // run          for (intra = 0; intra < 2; intra++)
142                                  int32_t level = k;                  for (i = 0; i < 102; i++)
143                                  ptr_t run = l;                  {
144    #ifdef BIGLUT
145                            offset = LEVELOFFSET;
146    #else
147                            offset = !intra * LEVELOFFSET;
148    #endif
149                            for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++)
150                            {
151                                    DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;
152                                    DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
153                            }
154    
155                                  if ((abs(level) <= max_level_ptr[run]) && (run <= (uint32_t) max_run_ptr[abs(level)])) {        // level < max_level and run < max_run                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].code
156                                    = coeff_tab[intra][i].vlc.code << 1;
157                            coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len
158                                    = coeff_tab[intra][i].vlc.len + 1;
159    #ifndef BIGLUT
160                            if (!intra)
161    #endif
162                            {
163                                    coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code
164                                            = (coeff_tab[intra][i].vlc.code << 1) | 1;
165                                    coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len
166                                            = coeff_tab[intra][i].vlc.len + 1;
167                            }
168                    }
169    
170                                          vlc[intra]->code = 0;          for (intra = 0; intra < 2; intra++)
171                                          vlc[intra]->len = 0;                  for (last = 0; last < 2; last++)
172                                          goto loop_end;                          for (run = 0; run < 63 + last; run++)
173                                  } else {                          {
174                                          if (level > 0)  // correct level                                  for (level = 1; level < (uint32_t)(32 << intra); level++)
175                                                  level -= max_level_ptr[run];                                  {
176                                          else                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
177                                                  level += max_level_ptr[run];                                              continue;
178    
179                                          if ((abs(level) <= max_level_ptr[run]) &&  #ifdef BIGLUT
180                                                  (run <= (uint32_t) max_run_ptr[abs(level)])) {                                          offset = LEVELOFFSET;
181    #else
182                                            offset = !intra * LEVELOFFSET;
183    #endif
184                        level_esc = level - max_level[intra][last][run];
185                                            run_esc = run - 1 - max_run[intra][last][level];
186                                            /*use this test to use shorter esc2 codes when possible
187                                            if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]
188                                                    && !(coeff_VLC[intra][last][level_esc + offset][run].len + 7 + 1
189                                                             > coeff_VLC[intra][last][level + offset][run_esc].code + 7 + 2))*/
190    
191                                                  vlc[intra]->code = 0x06;                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc])
192                                                  vlc[intra]->len = 8;                                          {
193                                                  goto loop_end;                                                  escape     = ESCAPE1;
194                                                    escape_len = 7 + 1;
195                                                    run_esc    = run;
196                                          }                                          }
   
                                         if (level > 0)  // still here?  
                                                 level += max_level_ptr[run];    // restore level  
197                                          else                                          else
198                                                  level -= max_level_ptr[run];                                          {
199                                                    if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc])
200                                          run -= max_run_ptr[abs(level)] + 1;     // and change run                                                  {
201                                                            escape     = ESCAPE2;
202                                          if ((abs(level) <= max_level_ptr[run]) &&                                                          escape_len = 7 + 2;
203                                                  (run <= (uint32_t) max_run_ptr[abs(level)])) {                                                          level_esc  = level;
   
                                                 vlc[intra]->code = 0x0e;  
                                                 vlc[intra]->len = 9;  
                                                 goto loop_end;  
204                                          }                                          }
205                                          run += max_run_ptr[abs(level)] + 1;                                                  else
206                                                    {
207    #ifndef BIGLUT
208                                                            if (!intra)
209    #endif
210                                                            {
211                                                                    coeff_VLC[intra][last][level + offset][run].code
212                                                                            = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
213                                                                    coeff_VLC[intra][last][level + offset][run].len = 30;
214                                                                            coeff_VLC[intra][last][offset - level][run].code
215                                                                            = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-(int32_t)level & 0xfff) << 1) | 1;
216                                                                    coeff_VLC[intra][last][offset - level][run].len = 30;
217                                  }                                  }
   
                                 vlc[intra]->code =  
                                         (uint32_t) ((l << 14) | (0x1e + last) << 20) | (1 << 13) |  
                                         ((k & 0xfff) << 1) | 1;  
   
                                 vlc[intra]->len = 30;  
                                 vlc[intra]++;  
218                                  continue;                                  continue;
   
                           loop_end:  
                                 if (level != 0) {  
                                         vlc[intra]->code =  
                                                 (vlc[intra]->  
                                                  code << (coeff_ptr[run][abs(level) - 1].len +  
                                                                   1)) | (coeff_ptr[run][abs(level) -  
                                                                                                                 1].code << 1);  
                                         vlc[intra]->len =  
                                                 (coeff_ptr[run][abs(level) - 1].len + 1) +  
                                                 vlc[intra]->len;  
   
                                         if (level < 0)  
                                                 vlc[intra]->code += 1;  
                                 }  
   
                                 vlc[intra]++;  
                         }  
219                  }                  }
220          }          }
221    
222          for (i = 0; i < 4096; i++) {                                          coeff_VLC[intra][last][level + offset][run].code
223                  if (i >= 512) {                                                  = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
224                          *vlc1 = DCT3Dtab3[(i >> 5) - 16];                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
225                          *vlc2 = DCT3Dtab0[(i >> 5) - 16];                                          coeff_VLC[intra][last][level + offset][run].len
226                  } else if (i >= 128) {                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
227                          *vlc1 = DCT3Dtab4[(i >> 2) - 32];  #ifndef BIGLUT
228                          *vlc2 = DCT3Dtab1[(i >> 2) - 32];                                          if (!intra)
229                  } else if (i >= 8) {  #endif
230                          *vlc1 = DCT3Dtab5[i - 8];                                          {
231                          *vlc2 = DCT3Dtab2[i - 8];                                                  coeff_VLC[intra][last][offset - level][run].code
232                  } else {                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
233                          *vlc1 = ERRtab[i];                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
234                          *vlc2 = ERRtab[i];                                                  coeff_VLC[intra][last][offset - level][run].len
235                                                            = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
236                                            }
237                  }                  }
238    
239                  vlc1++;  #ifdef BIGLUT
240                  vlc2++;                                  for (level = 32 << intra; level < 2048; level++)
241                                    {
242                                            coeff_VLC[intra][last][level + offset][run].code
243                                                    = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
244                                            coeff_VLC[intra][last][level + offset][run].len = 30;
245    
246                                            coeff_VLC[intra][last][offset - level][run].code
247                                                    = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;
248                                            coeff_VLC[intra][last][offset - level][run].len = 30;
249          }          }
250          DCT3D[0] = DCT3Dinter;  #else
251          DCT3D[1] = DCT3Dintra;                                  if (!intra)
252                                    {
253                                            coeff_VLC[intra][last][0][run].code
254                                                    = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
255                                            coeff_VLC[intra][last][0][run].len = 30;
256                                    }
257    #endif
258                            }
259    /* init sprite_trajectory tables */
260    /* even if GMC is not specified (it might be used later...) */
261    
262            sprite_trajectory_code[0+16384].code = 0;
263            sprite_trajectory_code[0+16384].len = 0;
264            for (k=0;k<14;k++)
265            {
266                    int limit = (1<<k);
267    
268                    for (l=-(2*limit-1); l <= -limit; l++)
269                    {
270                            sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
271                            sprite_trajectory_code[l+16384].len = k+1;
272  }  }
273    
274  /*****************************************************************************                  for (l=limit; l<= 2*limit-1; l++)
275   * Local inlined functions for MB coding                  {
276   ****************************************************************************/                          sprite_trajectory_code[l+16384].code = l;
277                            sprite_trajectory_code[l+16384].len = k+1;
278                    }
279            }
280    }
281    
282  static __inline void  static __inline void
283  CodeVector(Bitstream * bs,  CodeVector(Bitstream * bs,
# Line 240  Line 334 
334    
335  }  }
336    
337    #ifdef BIGLUT
338    
339  static __inline void  static __inline void
340  CodeCoeff(Bitstream * bs,  CodeCoeff(Bitstream * bs,
341                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 259  Line 355 
355                  j++;                  j++;
356    
357          do {          do {
358                  vlc = table + 64 * 2047 + (v << 6) + j - last;                  vlc = table + 64 * 2048 + (v << 6) + j - last;
359                  last = ++j;                  last = ++j;
360    
361                  // count zeroes                  /* count zeroes */
362                  while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)                  while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
363                          j++;                          j++;
364    
365                  // write code                  /* write code */
366                  if (j != 64) {                  if (j != 64) {
367                          BitstreamPutBits(bs, vlc->code, vlc->len);                          BitstreamPutBits(bs, vlc->code, vlc->len);
368                  } else {                  } else {
369                          vlc += 64 * 4095;                          vlc += 64 * 4096;
370                          BitstreamPutBits(bs, vlc->code, vlc->len);                          BitstreamPutBits(bs, vlc->code, vlc->len);
371                          break;                          break;
372                  }                  }
# Line 278  Line 374 
374    
375  }  }
376    
 /*****************************************************************************  
  * Local functions  
  ****************************************************************************/  
377    
378  static void  
379  CodeBlockIntra(const FRAMEINFO * frame,  /* returns the number of bits required to encode qcoeff */
380    int
381    CodeCoeff_CalcBits(const int16_t qcoeff[64],
382                      VLC * table,
383                      const uint16_t * zigzag,
384                      uint16_t intra)
385    {
386            int bits = 0;
387            uint32_t j, last;
388            short v;
389            VLC *vlc;
390    
391            j = intra;
392            last = intra;
393    
394            while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
395                    j++;
396    
397            if (j >= 64) return 0;  /* empty block */
398    
399            do {
400                    vlc = table + 64 * 2048 + (v << 6) + j - last;
401                    last = ++j;
402    
403                    /* count zeroes */
404                    while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
405                            j++;
406    
407                    /* write code */
408                    if (j != 64) {
409                            bits += vlc->len;
410                    } else {
411                            vlc += 64 * 4096;
412                            bits += vlc->len;
413                            break;
414                    }
415            } while (1);
416    
417            return bits;
418    }
419    
420    
421    #else
422    
423    static __inline void
424    CodeCoeffInter(Bitstream * bs,
425                      const int16_t qcoeff[64],
426                      const uint16_t * zigzag)
427    {
428            uint32_t i, run, prev_run, code, len;
429            int32_t level, prev_level, level_shifted;
430    
431            i       = 0;
432            run = 0;
433    
434            while (!(level = qcoeff[zigzag[i++]]))
435                    run++;
436    
437            prev_level = level;
438            prev_run   = run;
439            run = 0;
440    
441            while (i < 64)
442            {
443                    if ((level = qcoeff[zigzag[i++]]) != 0)
444                    {
445                            level_shifted = prev_level + 32;
446                            if (!(level_shifted & -64))
447                            {
448                                    code = coeff_VLC[0][0][level_shifted][prev_run].code;
449                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
450                            }
451                            else
452                            {
453                                    code = (ESCAPE3 << 21) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
454                                    len  = 30;
455                            }
456                            BitstreamPutBits(bs, code, len);
457                            prev_level = level;
458                            prev_run   = run;
459                            run = 0;
460                    }
461                    else
462                            run++;
463            }
464    
465            level_shifted = prev_level + 32;
466            if (!(level_shifted & -64))
467            {
468                    code = coeff_VLC[0][1][level_shifted][prev_run].code;
469                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
470            }
471            else
472            {
473                    code = (ESCAPE3 << 21) | (1 << 20) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
474                    len  = 30;
475            }
476            BitstreamPutBits(bs, code, len);
477    }
478    
479    static __inline void
480    CodeCoeffIntra(Bitstream * bs,
481                      const int16_t qcoeff[64],
482                      const uint16_t * zigzag)
483    {
484            uint32_t i, abs_level, run, prev_run, code, len;
485            int32_t level, prev_level;
486    
487            i       = 1;
488            run = 0;
489    
490            while (i<64 && !(level = qcoeff[zigzag[i++]]))
491                    run++;
492    
493            prev_level = level;
494            prev_run   = run;
495            run = 0;
496    
497            while (i < 64)
498            {
499                    if ((level = qcoeff[zigzag[i++]]) != 0)
500                    {
501                            abs_level = ABS(prev_level);
502                            abs_level = abs_level < 64 ? abs_level : 0;
503                            code      = coeff_VLC[1][0][abs_level][prev_run].code;
504                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
505                            if (len != 128)
506                                    code |= (prev_level < 0);
507                            else
508                            {
509                            code = (ESCAPE3 << 21) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
510                                    len  = 30;
511                            }
512                            BitstreamPutBits(bs, code, len);
513                            prev_level = level;
514                            prev_run   = run;
515                            run = 0;
516                    }
517                    else
518                            run++;
519            }
520    
521            abs_level = ABS(prev_level);
522            abs_level = abs_level < 64 ? abs_level : 0;
523            code      = coeff_VLC[1][1][abs_level][prev_run].code;
524            len               = coeff_VLC[1][1][abs_level][prev_run].len;
525            if (len != 128)
526                    code |= (prev_level < 0);
527            else
528            {
529                    code = (ESCAPE3 << 21) | (1 << 20) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
530                    len  = 30;
531            }
532            BitstreamPutBits(bs, code, len);
533    }
534    
535    
536    
537    /* returns the number of bits required to encode qcoeff */
538    
539    int
540    CodeCoeffIntra_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
541    {
542            int bits = 0;
543            uint32_t i, abs_level, run, prev_run, len;
544            int32_t level, prev_level;
545    
546            i       = 1;
547            run = 0;
548    
549            while (i<64 && !(level = qcoeff[zigzag[i++]]))
550                    run++;
551    
552            if (i >= 64) return 0;  /* empty block */
553    
554            prev_level = level;
555            prev_run   = run;
556            run = 0;
557    
558            while (i < 64)
559            {
560                    if ((level = qcoeff[zigzag[i++]]) != 0)
561                    {
562                            abs_level = ABS(prev_level);
563                            abs_level = abs_level < 64 ? abs_level : 0;
564                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
565                            bits      += len!=128 ? len : 30;
566    
567                            prev_level = level;
568                            prev_run   = run;
569                            run = 0;
570                    }
571                    else
572                            run++;
573            }
574    
575            abs_level = ABS(prev_level);
576            abs_level = abs_level < 64 ? abs_level : 0;
577            len               = coeff_VLC[1][1][abs_level][prev_run].len;
578            bits      += len!=128 ? len : 30;
579    
580            return bits;
581    }
582    
583    int
584    CodeCoeffInter_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
585    {
586            uint32_t i, run, prev_run, len;
587            int32_t level, prev_level, level_shifted;
588            int bits = 0;
589    
590            i       = 0;
591            run = 0;
592    
593            while (!(level = qcoeff[zigzag[i++]]))
594                    run++;
595    
596            prev_level = level;
597            prev_run   = run;
598            run = 0;
599    
600            while (i < 64) {
601                    if ((level = qcoeff[zigzag[i++]]) != 0) {
602                            level_shifted = prev_level + 32;
603                            if (!(level_shifted & -64))
604                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
605                            else
606                                    len  = 30;
607    
608                            bits += len;
609                            prev_level = level;
610                            prev_run   = run;
611                            run = 0;
612                    }
613                    else
614                            run++;
615            }
616    
617            level_shifted = prev_level + 32;
618            if (!(level_shifted & -64))
619                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
620            else
621                    len  = 30;
622            bits += len;
623    
624            return bits;
625    }
626    
627    
628    #endif
629    
630    static __inline void
631    CodeBlockIntra(const FRAMEINFO * const frame,
632                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
633                             int16_t qcoeff[6 * 64],                             int16_t qcoeff[6 * 64],
634                             Bitstream * bs,                             Bitstream * bs,
# Line 332  Line 677 
677                                                           dcc_tab[qcoeff[i * 64 + 0] + 255].len);                                                           dcc_tab[qcoeff[i * 64 + 0] + 255].len);
678    
679                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i))) {
680                            const uint16_t *scan_table =
681                                    frame->global_flags & XVID_ALTERNATESCAN ?
682                                    scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
683    
684                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
685    
686                          CodeCoeff(bs, &qcoeff[i * 64], intra_table,  #ifdef BIGLUT
687                                            scan_tables[pMB->acpred_directions[i]], 1);                          CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);
688    #else
689                            CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
690    #endif
691    
692                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
693                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 346  Line 698 
698    
699    
700  static void  static void
701  CodeBlockInter(const FRAMEINFO * frame,  CodeBlockInter(const FRAMEINFO * const frame,
702                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
703                             int16_t qcoeff[6 * 64],                             int16_t qcoeff[6 * 64],
704                             Bitstream * bs,                             Bitstream * bs,
# Line 363  Line 715 
715          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
716                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
717    
718            if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
719                    BitstreamPutBit(bs, pMB->mcsel);                // mcsel: '0'=local motion, '1'=GMC
720    
721          // write cbpy          // write cbpy
722          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
723    
# Line 374  Line 729 
729          if (frame->global_flags & XVID_INTERLACING) {          if (frame->global_flags & XVID_INTERLACING) {
730                  if (pMB->cbp) {                  if (pMB->cbp) {
731                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
732                          DPRINTF(DPRINTF_DEBUG, "codep: field_dct: %d", pMB->field_dct);                          DPRINTF(DPRINTF_MB,"codep: field_dct: %i", pMB->field_dct);
733                  }                  }
734    
735                  // if inter block, write field ME flag                  // if inter block, write field ME flag
736                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
737                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, pMB->field_pred);
738                          DPRINTF(DPRINTF_DEBUG, "codep: field_pred: %d", pMB->field_pred);                          DPRINTF(DPRINTF_MB,"codep: field_pred: %i", pMB->field_pred);
739    
740                          // write field prediction references                          // write field prediction references
741                          if (pMB->field_pred) {                          if (pMB->field_pred) {
# Line 389  Line 744 
744                          }                          }
745                  }                  }
746          }          }
747          // code motion vector(s)          // code motion vector(s) if motion is local
748            if (!pMB->mcsel)
749          for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {          for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
750                  CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                  CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
751                  CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);                  CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);
# Line 400  Line 756 
756          // code block coeffs          // code block coeffs
757          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
758                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i)))
759                          CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);                  {
760                            const uint16_t *scan_table =
761                                    frame->global_flags & XVID_ALTERNATESCAN ?
762                                    scan_tables[2] : scan_tables[0];
763    
764    #ifdef BIGLUT
765                            CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);
766    #else
767                            CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
768    #endif
769                    }
770    
771          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
772          pStat->iTextBits += bits;          pStat->iTextBits += bits;
   
773  }  }
774    
 /*****************************************************************************  
  * Macro Block bitstream encoding functions  
  ****************************************************************************/  
775    
776  void  void
777  MBCoding(const FRAMEINFO * frame,  MBCoding(const FRAMEINFO * const frame,
778                   MACROBLOCK * pMB,                   MACROBLOCK * pMB,
779                   int16_t qcoeff[6 * 64],                   int16_t qcoeff[6 * 64],
780                   Bitstream * bs,                   Bitstream * bs,
781                   Statistics * pStat)                   Statistics * pStat)
782  {  {
783            if (frame->coding_type != I_VOP)
784          if (frame->coding_type == P_VOP) {                          BitstreamPutBit(bs, 0); // not_coded
                         BitstreamPutBit(bs, 0); // coded  
         }  
785    
786          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
787                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
# Line 430  Line 790 
790    
791  }  }
792    
793    /*
794    // moved to mbcoding.h so that in can be 'static __inline'
795  void  void
796  MBSkip(Bitstream * bs)  MBSkip(Bitstream * bs)
797  {  {
798          BitstreamPutBit(bs, 1); // not coded          BitstreamPutBit(bs, 1); // not coded
         return;  
799  }  }
800    */
801    
802  /*****************************************************************************  /***************************************************************
803   * decoding stuff starts here   * bframe encoding start
804   ****************************************************************************/   ***************************************************************/
805    
806  /*  /*
807   * For IVOP addbits == 0          mbtype
808   * For PVOP addbits == fcode - 1          0       1b              direct(h263)            mvdb
809   * For BVOP addbits == max(fcode,bcode) - 1          1       01b             interpolate mc+q        dbquant, mvdf, mvdb
810   * returns true or false          2       001b    backward mc+q           dbquant, mvdb
811            3       0001b   forward mc+q            dbquant, mvdf
812   */   */
813    
814    static __inline void
815    put_bvop_mbtype(Bitstream * bs,
816                                    int value)
817    {
818            switch (value) {
819                    case MODE_FORWARD:
820                            BitstreamPutBit(bs, 0);
821                    case MODE_BACKWARD:
822                            BitstreamPutBit(bs, 0);
823                    case MODE_INTERPOLATE:
824                            BitstreamPutBit(bs, 0);
825                    case MODE_DIRECT:
826                            BitstreamPutBit(bs, 1);
827                    default:
828                            break;
829            }
830    }
831    
832    /*
833            dbquant
834            -2      10b
835            0       0b
836            +2      11b
837    */
838    
839    static __inline void
840    put_bvop_dbquant(Bitstream * bs,
841                                     int value)
842    {
843            switch (value) {
844            case 0:
845                    BitstreamPutBit(bs, 0);
846                    return;
847    
848            case -2:
849                    BitstreamPutBit(bs, 1);
850                    BitstreamPutBit(bs, 0);
851                    return;
852    
853            case 2:
854                    BitstreamPutBit(bs, 1);
855                    BitstreamPutBit(bs, 1);
856                    return;
857    
858            default:;                                       // invalid
859            }
860    }
861    
862    
863    
864    void
865    MBCodingBVOP(const MACROBLOCK * mb,
866                             const int16_t qcoeff[6 * 64],
867                             const int32_t fcode,
868                             const int32_t bcode,
869                             Bitstream * bs,
870                             Statistics * pStat,
871                             int direction)
872    {
873            int vcode = fcode;
874            unsigned int i;
875    
876    /*      ------------------------------------------------------------------
877                    when a block is skipped it is decoded DIRECT(0,0)
878                    hence is interpolated from forward & backward frames
879            ------------------------------------------------------------------ */
880    
881            if (mb->mode == MODE_DIRECT_NONE_MV) {
882                    BitstreamPutBit(bs, 1); // skipped
883                    return;
884            }
885    
886            BitstreamPutBit(bs, 0);         // not skipped
887    
888            if (mb->cbp == 0) {
889                    BitstreamPutBit(bs, 1); // cbp == 0
890            } else {
891                    BitstreamPutBit(bs, 0); // cbp == xxx
892            }
893    
894            put_bvop_mbtype(bs, mb->mode);
895    
896            if (mb->cbp) {
897                    BitstreamPutBits(bs, mb->cbp, 6);
898            }
899    
900            if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
901                    put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0
902            }
903    
904            switch (mb->mode) {
905                    case MODE_INTERPOLATE:
906                            CodeVector(bs, mb->pmvs[1].x, vcode, pStat); //forward vector of interpolate mode
907                            CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
908                    case MODE_BACKWARD:
909                            vcode = bcode;
910                    case MODE_FORWARD:
911                            CodeVector(bs, mb->pmvs[0].x, vcode, pStat);
912                            CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
913                            break;
914                    case MODE_DIRECT:
915                            CodeVector(bs, mb->pmvs[3].x, 1, pStat);        // fcode is always 1 for delta vector
916                            CodeVector(bs, mb->pmvs[3].y, 1, pStat);        // prediction is always (0,0)
917                    default: break;
918            }
919    
920            for (i = 0; i < 6; i++) {
921                    if (mb->cbp & (1 << (5 - i))) {
922    #ifdef BIGLUT
923                            CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);
924    #else
925                            CodeCoeffInter(bs, &qcoeff[i * 64], scan_tables[0]);
926    #endif
927                    }
928            }
929    }
930    
931    
932    
933    /***************************************************************
934     * decoding stuff starts here                                  *
935     ***************************************************************/
936    
937    
938    // for IVOP addbits == 0
939    // for PVOP addbits == fcode - 1
940    // for BVOP addbits == max(fcode,bcode) - 1
941    // returns true or false
942  int  int
943  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
944  {  {
# Line 490  Line 980 
980    
981          uint32_t index;          uint32_t index;
982    
983          index = CLIP(BitstreamShowBits(bs, 9), 256);          index = MIN(BitstreamShowBits(bs, 9), 256);
984    
985          BitstreamSkip(bs, mcbpc_inter_table[index].len);          BitstreamSkip(bs, mcbpc_inter_table[index].len);
986    
# Line 516  Line 1006 
1006    
1007  }  }
1008    
1009  int  static __inline int
1010  get_mv_data(Bitstream * bs)  get_mv_data(Bitstream * bs)
1011  {  {
1012    
# Line 625  Line 1115 
1115    
1116  }  }
1117    
 /*****************************************************************************  
  * Local inlined function to "decode" written vlc codes  
  ****************************************************************************/  
   
1118  static __inline int  static __inline int
1119  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
1120                    int *run,                    int *run,
# Line 638  Line 1124 
1124  {  {
1125    
1126          uint32_t mode;          uint32_t mode;
         const VLC *tab;  
1127          int32_t level;          int32_t level;
1128            REVERSE_EVENT *reverse_event;
1129    
1130          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 */
1131                  intra = 0;                  intra = 0;
1132    
1133          tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];          if (BitstreamShowBits(bs, 7) != ESCAPE) {
1134                    reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];
1135    
1136          if (tab->code == -1)                  if ((level = reverse_event->event.level) == 0)
1137                  goto error;                  goto error;
1138    
1139          BitstreamSkip(bs, tab->len);                  *last = reverse_event->event.last;
1140                    *run  = reverse_event->event.run;
1141    
1142          if (tab->code != ESCAPE) {                  BitstreamSkip(bs, reverse_event->len);
1143                  if (!intra) {  
1144                          *run = (tab->code >> 4) & 255;                  return BitstreamGetBits(bs, 1) ? -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;  
1145          }          }
1146    
1147            BitstreamSkip(bs, 7);
1148    
1149          if (short_video_header) {          if (short_video_header) {
1150                  // escape mode 4 - H.263 type, only used if short_video_header = 1                  /* escape mode 4 - H.263 type, only used if short_video_header = 1  */
1151                  *last = BitstreamGetBit(bs);                  *last = BitstreamGetBit(bs);
1152                  *run = BitstreamGetBits(bs, 6);                  *run = BitstreamGetBits(bs, 6);
1153                  level = BitstreamGetBits(bs, 8);                  level = BitstreamGetBits(bs, 8);
# Line 673  Line 1155 
1155                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1156                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);
1157    
1158                  return (level >= 128 ? -(256 - level) : level);                  return (level << 24) >> 24;
1159          }          }
1160    
1161          mode = BitstreamShowBits(bs, 2);          mode = BitstreamShowBits(bs, 2);
# Line 681  Line 1163 
1163          if (mode < 3) {          if (mode < 3) {
1164                  BitstreamSkip(bs, (mode == 2) ? 2 : 1);                  BitstreamSkip(bs, (mode == 2) ? 2 : 1);
1165    
1166                  tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];
1167                  if (tab->code == -1)  
1168                    if ((level = reverse_event->event.level) == 0)
1169                          goto error;                          goto error;
1170    
1171                  BitstreamSkip(bs, tab->len);                  *last = reverse_event->event.last;
1172                    *run  = reverse_event->event.run;
1173    
1174                  if (!intra) {                  BitstreamSkip(bs, reverse_event->len);
                         *run = (tab->code >> 4) & 255;  
                         level = tab->code & 15;  
                         *last = (tab->code >> 12) & 1;  
                 } else {  
                         *run = (tab->code >> 8) & 255;  
                         level = tab->code & 255;  
                         *last = (tab->code >> 16) & 1;  
                 }  
1175    
1176                  if (mode < 2)                   // first escape mode, level is offset                  if (mode < 2)                   /* first escape mode, level is offset */
1177                          level += max_level[*last + (!intra << 1)][*run];        // need to add back the max level                          level += max_level[intra][*last][*run];
1178                  else if (mode == 2)             // second escape mode, run is offset                  else                                    /* second escape mode, run is offset */
1179                          *run += max_run[*last + (!intra << 1)][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1180    
1181                  return BitstreamGetBit(bs) ? -level : level;                  return BitstreamGetBits(bs, 1) ? -level : level;
1182          }          }
1183          // third escape mode - fixed length codes  
1184            /* third escape mode - fixed length codes */
1185          BitstreamSkip(bs, 2);          BitstreamSkip(bs, 2);
1186          *last = BitstreamGetBits(bs, 1);          *last = BitstreamGetBits(bs, 1);
1187          *run = BitstreamGetBits(bs, 6);          *run = BitstreamGetBits(bs, 6);
1188          BitstreamSkip(bs, 1);           // marker          BitstreamSkip(bs, 1);           /* marker */
1189          level = BitstreamGetBits(bs, 12);          level = BitstreamGetBits(bs, 12);
1190          BitstreamSkip(bs, 1);           // marker          BitstreamSkip(bs, 1);           /* marker */
1191    
1192          return (level & 0x800) ? (level | (-1 ^ 0xfff)) : level;          return (level << 20) >> 20;
1193    
1194    error:    error:
1195          *run = VLC_ERROR;          *run = VLC_ERROR;
1196          return 0;          return 0;
   
1197  }  }
1198    
 /*****************************************************************************  
  * MB reading functions  
  ****************************************************************************/  
   
1199  void  void
1200  get_intra_block(Bitstream * bs,  get_intra_block(Bitstream * bs,
1201                                  int16_t * block,                                  int16_t * block,
# Line 732  Line 1204 
1204  {  {
1205    
1206          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1207          int level;          int level, run, last;
         int run;  
         int last;  
1208    
1209          do {          do {
1210                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1211                  if (run == -1) {                  if (run == -1) {
1212                          DPRINTF(DPRINTF_DEBUG, "fatal: invalid run");                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");
1213                          break;                          break;
1214                  }                  }
1215                  coeff += run;                  coeff += run;
# Line 748  Line 1218 
1218                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);
1219                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));
1220    
1221                  if (level < -127 || level > 127) {                  if (level < -2047 || level > 2047) {
1222                          DPRINTF(DPRINTF_DEBUG, "warning: intra_overflow: %d", level);                          DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);
1223                  }                  }
1224                  coeff++;                  coeff++;
1225          } while (!last);          } while (!last);
# Line 758  Line 1228 
1228    
1229  void  void
1230  get_inter_block(Bitstream * bs,  get_inter_block(Bitstream * bs,
1231                                  int16_t * block)                                  int16_t * block,
1232                                    int direction)
1233  {  {
1234    
1235          const uint16_t *scan = scan_tables[0];          const uint16_t *scan = scan_tables[direction];
1236          int p;          int p;
1237          int level;          int level;
1238          int run;          int run;
# Line 779  Line 1250 
1250                  block[scan[p]] = level;                  block[scan[p]] = level;
1251    
1252                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);
1253                    // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));
1254    
1255                  if (level < -127 || level > 127) {                  if (level < -2047 || level > 2047) {
1256                          DPRINTF(DPRINTF_DEBUG, "warning: inter_overflow: %d", level);                          DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);
1257                  }                  }
1258                  p++;                  p++;
1259          } while (!last);          } while (!last);
1260    
1261  }  }
1262    
1263    /*****************************************************************************
1264     * VLC tables and other constant arrays
1265     ****************************************************************************/
1266    
1267    VLC_TABLE const coeff_tab[2][102] =
1268    {
1269            /* intra = 0 */
1270            {
1271                    {{ 2,  2}, {0, 0, 1}},
1272                    {{15,  4}, {0, 0, 2}},
1273                    {{21,  6}, {0, 0, 3}},
1274                    {{23,  7}, {0, 0, 4}},
1275                    {{31,  8}, {0, 0, 5}},
1276                    {{37,  9}, {0, 0, 6}},
1277                    {{36,  9}, {0, 0, 7}},
1278                    {{33, 10}, {0, 0, 8}},
1279                    {{32, 10}, {0, 0, 9}},
1280                    {{ 7, 11}, {0, 0, 10}},
1281                    {{ 6, 11}, {0, 0, 11}},
1282                    {{32, 11}, {0, 0, 12}},
1283                    {{ 6,  3}, {0, 1, 1}},
1284                    {{20,  6}, {0, 1, 2}},
1285                    {{30,  8}, {0, 1, 3}},
1286                    {{15, 10}, {0, 1, 4}},
1287                    {{33, 11}, {0, 1, 5}},
1288                    {{80, 12}, {0, 1, 6}},
1289                    {{14,  4}, {0, 2, 1}},
1290                    {{29,  8}, {0, 2, 2}},
1291                    {{14, 10}, {0, 2, 3}},
1292                    {{81, 12}, {0, 2, 4}},
1293                    {{13,  5}, {0, 3, 1}},
1294                    {{35,  9}, {0, 3, 2}},
1295                    {{13, 10}, {0, 3, 3}},
1296                    {{12,  5}, {0, 4, 1}},
1297                    {{34,  9}, {0, 4, 2}},
1298                    {{82, 12}, {0, 4, 3}},
1299                    {{11,  5}, {0, 5, 1}},
1300                    {{12, 10}, {0, 5, 2}},
1301                    {{83, 12}, {0, 5, 3}},
1302                    {{19,  6}, {0, 6, 1}},
1303                    {{11, 10}, {0, 6, 2}},
1304                    {{84, 12}, {0, 6, 3}},
1305                    {{18,  6}, {0, 7, 1}},
1306                    {{10, 10}, {0, 7, 2}},
1307                    {{17,  6}, {0, 8, 1}},
1308                    {{ 9, 10}, {0, 8, 2}},
1309                    {{16,  6}, {0, 9, 1}},
1310                    {{ 8, 10}, {0, 9, 2}},
1311                    {{22,  7}, {0, 10, 1}},
1312                    {{85, 12}, {0, 10, 2}},
1313                    {{21,  7}, {0, 11, 1}},
1314                    {{20,  7}, {0, 12, 1}},
1315                    {{28,  8}, {0, 13, 1}},
1316                    {{27,  8}, {0, 14, 1}},
1317                    {{33,  9}, {0, 15, 1}},
1318                    {{32,  9}, {0, 16, 1}},
1319                    {{31,  9}, {0, 17, 1}},
1320                    {{30,  9}, {0, 18, 1}},
1321                    {{29,  9}, {0, 19, 1}},
1322                    {{28,  9}, {0, 20, 1}},
1323                    {{27,  9}, {0, 21, 1}},
1324                    {{26,  9}, {0, 22, 1}},
1325                    {{34, 11}, {0, 23, 1}},
1326                    {{35, 11}, {0, 24, 1}},
1327                    {{86, 12}, {0, 25, 1}},
1328                    {{87, 12}, {0, 26, 1}},
1329                    {{ 7,  4}, {1, 0, 1}},
1330                    {{25,  9}, {1, 0, 2}},
1331                    {{ 5, 11}, {1, 0, 3}},
1332                    {{15,  6}, {1, 1, 1}},
1333                    {{ 4, 11}, {1, 1, 2}},
1334                    {{14,  6}, {1, 2, 1}},
1335                    {{13,  6}, {1, 3, 1}},
1336                    {{12,  6}, {1, 4, 1}},
1337                    {{19,  7}, {1, 5, 1}},
1338                    {{18,  7}, {1, 6, 1}},
1339                    {{17,  7}, {1, 7, 1}},
1340                    {{16,  7}, {1, 8, 1}},
1341                    {{26,  8}, {1, 9, 1}},
1342                    {{25,  8}, {1, 10, 1}},
1343                    {{24,  8}, {1, 11, 1}},
1344                    {{23,  8}, {1, 12, 1}},
1345                    {{22,  8}, {1, 13, 1}},
1346                    {{21,  8}, {1, 14, 1}},
1347                    {{20,  8}, {1, 15, 1}},
1348                    {{19,  8}, {1, 16, 1}},
1349                    {{24,  9}, {1, 17, 1}},
1350                    {{23,  9}, {1, 18, 1}},
1351                    {{22,  9}, {1, 19, 1}},
1352                    {{21,  9}, {1, 20, 1}},
1353                    {{20,  9}, {1, 21, 1}},
1354                    {{19,  9}, {1, 22, 1}},
1355                    {{18,  9}, {1, 23, 1}},
1356                    {{17,  9}, {1, 24, 1}},
1357                    {{ 7, 10}, {1, 25, 1}},
1358                    {{ 6, 10}, {1, 26, 1}},
1359                    {{ 5, 10}, {1, 27, 1}},
1360                    {{ 4, 10}, {1, 28, 1}},
1361                    {{36, 11}, {1, 29, 1}},
1362                    {{37, 11}, {1, 30, 1}},
1363                    {{38, 11}, {1, 31, 1}},
1364                    {{39, 11}, {1, 32, 1}},
1365                    {{88, 12}, {1, 33, 1}},
1366                    {{89, 12}, {1, 34, 1}},
1367                    {{90, 12}, {1, 35, 1}},
1368                    {{91, 12}, {1, 36, 1}},
1369                    {{92, 12}, {1, 37, 1}},
1370                    {{93, 12}, {1, 38, 1}},
1371                    {{94, 12}, {1, 39, 1}},
1372                    {{95, 12}, {1, 40, 1}}
1373            },
1374            /* intra = 1 */
1375            {
1376                    {{ 2,  2}, {0, 0, 1}},
1377                    {{15,  4}, {0, 0, 3}},
1378                    {{21,  6}, {0, 0, 6}},
1379                    {{23,  7}, {0, 0, 9}},
1380                    {{31,  8}, {0, 0, 10}},
1381                    {{37,  9}, {0, 0, 13}},
1382                    {{36,  9}, {0, 0, 14}},
1383                    {{33, 10}, {0, 0, 17}},
1384                    {{32, 10}, {0, 0, 18}},
1385                    {{ 7, 11}, {0, 0, 21}},
1386                    {{ 6, 11}, {0, 0, 22}},
1387                    {{32, 11}, {0, 0, 23}},
1388                    {{ 6,  3}, {0, 0, 2}},
1389                    {{20,  6}, {0, 1, 2}},
1390                    {{30,  8}, {0, 0, 11}},
1391                    {{15, 10}, {0, 0, 19}},
1392                    {{33, 11}, {0, 0, 24}},
1393                    {{80, 12}, {0, 0, 25}},
1394                    {{14,  4}, {0, 1, 1}},
1395                    {{29,  8}, {0, 0, 12}},
1396                    {{14, 10}, {0, 0, 20}},
1397                    {{81, 12}, {0, 0, 26}},
1398                    {{13,  5}, {0, 0, 4}},
1399                    {{35,  9}, {0, 0, 15}},
1400                    {{13, 10}, {0, 1, 7}},
1401                    {{12,  5}, {0, 0, 5}},
1402                    {{34,  9}, {0, 4, 2}},
1403                    {{82, 12}, {0, 0, 27}},
1404                    {{11,  5}, {0, 2, 1}},
1405                    {{12, 10}, {0, 2, 4}},
1406                    {{83, 12}, {0, 1, 9}},
1407                    {{19,  6}, {0, 0, 7}},
1408                    {{11, 10}, {0, 3, 4}},
1409                    {{84, 12}, {0, 6, 3}},
1410                    {{18,  6}, {0, 0, 8}},
1411                    {{10, 10}, {0, 4, 3}},
1412                    {{17,  6}, {0, 3, 1}},
1413                    {{ 9, 10}, {0, 8, 2}},
1414                    {{16,  6}, {0, 4, 1}},
1415                    {{ 8, 10}, {0, 5, 3}},
1416                    {{22,  7}, {0, 1, 3}},
1417                    {{85, 12}, {0, 1, 10}},
1418                    {{21,  7}, {0, 2, 2}},
1419                    {{20,  7}, {0, 7, 1}},
1420                    {{28,  8}, {0, 1, 4}},
1421                    {{27,  8}, {0, 3, 2}},
1422                    {{33,  9}, {0, 0, 16}},
1423                    {{32,  9}, {0, 1, 5}},
1424                    {{31,  9}, {0, 1, 6}},
1425                    {{30,  9}, {0, 2, 3}},
1426                    {{29,  9}, {0, 3, 3}},
1427                    {{28,  9}, {0, 5, 2}},
1428                    {{27,  9}, {0, 6, 2}},
1429                    {{26,  9}, {0, 7, 2}},
1430                    {{34, 11}, {0, 1, 8}},
1431                    {{35, 11}, {0, 9, 2}},
1432                    {{86, 12}, {0, 2, 5}},
1433                    {{87, 12}, {0, 7, 3}},
1434                    {{ 7,  4}, {1, 0, 1}},
1435                    {{25,  9}, {0, 11, 1}},
1436                    {{ 5, 11}, {1, 0, 6}},
1437                    {{15,  6}, {1, 1, 1}},
1438                    {{ 4, 11}, {1, 0, 7}},
1439                    {{14,  6}, {1, 2, 1}},
1440                    {{13,  6}, {0, 5, 1}},
1441                    {{12,  6}, {1, 0, 2}},
1442                    {{19,  7}, {1, 5, 1}},
1443                    {{18,  7}, {0, 6, 1}},
1444                    {{17,  7}, {1, 3, 1}},
1445                    {{16,  7}, {1, 4, 1}},
1446                    {{26,  8}, {1, 9, 1}},
1447                    {{25,  8}, {0, 8, 1}},
1448                    {{24,  8}, {0, 9, 1}},
1449                    {{23,  8}, {0, 10, 1}},
1450                    {{22,  8}, {1, 0, 3}},
1451                    {{21,  8}, {1, 6, 1}},
1452                    {{20,  8}, {1, 7, 1}},
1453                    {{19,  8}, {1, 8, 1}},
1454                    {{24,  9}, {0, 12, 1}},
1455                    {{23,  9}, {1, 0, 4}},
1456                    {{22,  9}, {1, 1, 2}},
1457                    {{21,  9}, {1, 10, 1}},
1458                    {{20,  9}, {1, 11, 1}},
1459                    {{19,  9}, {1, 12, 1}},
1460                    {{18,  9}, {1, 13, 1}},
1461                    {{17,  9}, {1, 14, 1}},
1462                    {{ 7, 10}, {0, 13, 1}},
1463                    {{ 6, 10}, {1, 0, 5}},
1464                    {{ 5, 10}, {1, 1, 3}},
1465                    {{ 4, 10}, {1, 2, 2}},
1466                    {{36, 11}, {1, 3, 2}},
1467                    {{37, 11}, {1, 4, 2}},
1468                    {{38, 11}, {1, 15, 1}},
1469                    {{39, 11}, {1, 16, 1}},
1470                    {{88, 12}, {0, 14, 1}},
1471                    {{89, 12}, {1, 0, 8}},
1472                    {{90, 12}, {1, 5, 2}},
1473                    {{91, 12}, {1, 6, 2}},
1474                    {{92, 12}, {1, 17, 1}},
1475                    {{93, 12}, {1, 18, 1}},
1476                    {{94, 12}, {1, 19, 1}},
1477                    {{95, 12}, {1, 20, 1}}
1478            }
1479    };
1480    
1481    /* constants taken from momusys/vm_common/inlcude/max_level.h */
1482    uint8_t const max_level[2][2][64] = {
1483            {
1484                    /* intra = 0, last = 0 */
1485                    {
1486                            12, 6, 4, 3, 3, 3, 3, 2,
1487                            2, 2, 2, 1, 1, 1, 1, 1,
1488                            1, 1, 1, 1, 1, 1, 1, 1,
1489                            1, 1, 1, 0, 0, 0, 0, 0,
1490                            0, 0, 0, 0, 0, 0, 0, 0,
1491                            0, 0, 0, 0, 0, 0, 0, 0,
1492                            0, 0, 0, 0, 0, 0, 0, 0,
1493                            0, 0, 0, 0, 0, 0, 0, 0
1494                    },
1495                    /* intra = 0, last = 1 */
1496                    {
1497                            3, 2, 1, 1, 1, 1, 1, 1,
1498                            1, 1, 1, 1, 1, 1, 1, 1,
1499                            1, 1, 1, 1, 1, 1, 1, 1,
1500                            1, 1, 1, 1, 1, 1, 1, 1,
1501                            1, 1, 1, 1, 1, 1, 1, 1,
1502                            1, 0, 0, 0, 0, 0, 0, 0,
1503                            0, 0, 0, 0, 0, 0, 0, 0,
1504                            0, 0, 0, 0, 0, 0, 0, 0
1505                    }
1506            },
1507            {
1508                    /* intra = 1, last = 0 */
1509                    {
1510                            27, 10, 5, 4, 3, 3, 3, 3,
1511                            2, 2, 1, 1, 1, 1, 1, 0,
1512                            0, 0, 0, 0, 0, 0, 0, 0,
1513                            0, 0, 0, 0, 0, 0, 0, 0,
1514                            0, 0, 0, 0, 0, 0, 0, 0,
1515                            0, 0, 0, 0, 0, 0, 0, 0,
1516                            0, 0, 0, 0, 0, 0, 0, 0,
1517                            0, 0, 0, 0, 0, 0, 0, 0
1518                    },
1519                    /* intra = 1, last = 1 */
1520                    {
1521                            8, 3, 2, 2, 2, 2, 2, 1,
1522                            1, 1, 1, 1, 1, 1, 1, 1,
1523                            1, 1, 1, 1, 1, 0, 0, 0,
1524                            0, 0, 0, 0, 0, 0, 0, 0,
1525                            0, 0, 0, 0, 0, 0, 0, 0,
1526                            0, 0, 0, 0, 0, 0, 0, 0,
1527                            0, 0, 0, 0, 0, 0, 0, 0,
1528                            0, 0, 0, 0, 0, 0, 0, 0
1529                    }
1530            }
1531    };
1532    
1533    uint8_t const max_run[2][2][64] = {
1534            {
1535                    /* intra = 0, last = 0 */
1536                    {
1537                            0, 26, 10, 6, 2, 1, 1, 0,
1538                            0, 0, 0, 0, 0, 0, 0, 0,
1539                            0, 0, 0, 0, 0, 0, 0, 0,
1540                            0, 0, 0, 0, 0, 0, 0, 0,
1541                            0, 0, 0, 0, 0, 0, 0, 0,
1542                            0, 0, 0, 0, 0, 0, 0, 0,
1543                            0, 0, 0, 0, 0, 0, 0, 0,
1544                            0, 0, 0, 0, 0, 0, 0, 0,
1545                    },
1546                    /* intra = 0, last = 1 */
1547                    {
1548                            0, 40, 1, 0, 0, 0, 0, 0,
1549                            0, 0, 0, 0, 0, 0, 0, 0,
1550                            0, 0, 0, 0, 0, 0, 0, 0,
1551                            0, 0, 0, 0, 0, 0, 0, 0,
1552                            0, 0, 0, 0, 0, 0, 0, 0,
1553                            0, 0, 0, 0, 0, 0, 0, 0,
1554                            0, 0, 0, 0, 0, 0, 0, 0,
1555                            0, 0, 0, 0, 0, 0, 0, 0,
1556                    }
1557            },
1558            {
1559                    /* intra = 1, last = 0 */
1560                    {
1561                            0, 14, 9, 7, 3, 2, 1, 1,
1562                            1, 1, 1, 0, 0, 0, 0, 0,
1563                            0, 0, 0, 0, 0, 0, 0, 0,
1564                            0, 0, 0, 0, 0, 0, 0, 0,
1565                            0, 0, 0, 0, 0, 0, 0, 0,
1566                            0, 0, 0, 0, 0, 0, 0, 0,
1567                            0, 0, 0, 0, 0, 0, 0, 0,
1568                            0, 0, 0, 0, 0, 0, 0, 0,
1569                    },
1570                    /* intra = 1, last = 1 */
1571                    {
1572                            0, 20, 6, 1, 0, 0, 0, 0,
1573                            0, 0, 0, 0, 0, 0, 0, 0,
1574                            0, 0, 0, 0, 0, 0, 0, 0,
1575                            0, 0, 0, 0, 0, 0, 0, 0,
1576                            0, 0, 0, 0, 0, 0, 0, 0,
1577                            0, 0, 0, 0, 0, 0, 0, 0,
1578                            0, 0, 0, 0, 0, 0, 0, 0,
1579                            0, 0, 0, 0, 0, 0, 0, 0,
1580                    }
1581            }
1582    };
1583    
1584    /******************************************************************
1585     * encoder tables                                                 *
1586     ******************************************************************/
1587    
1588    VLC sprite_trajectory_code[32768];
1589    
1590    VLC sprite_trajectory_len[15] = {
1591            { 0x00 , 2},
1592            { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1593            { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7F, 7}, { 0xFE, 8},
1594            { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1595    
1596    
1597    /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1598       the sign bit must be added afterwards. */
1599    
1600    /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1601     CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1602     Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1603    
1604    VLC mcbpc_intra_tab[15] = {
1605            {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1606            {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1607            {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1608            {0x00, 0}, {0x03, 3}, {0x03, 6}
1609    };
1610    
1611    /* MCBPC inter.
1612       Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1613    
1614    VLC mcbpc_inter_tab[29] = {
1615            {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1616            {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1617            {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1618            {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1619    };
1620    
1621    const VLC cbpy_tab[16] = {
1622            {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1623            {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1624    };
1625    
1626    const VLC dcy_tab[511] = {
1627            {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1628            {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1629            {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1630            {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1631            {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1632            {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1633            {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1634            {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1635            {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1636            {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1637            {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1638            {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1639            {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1640            {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1641            {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1642            {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1643            {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1644            {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1645            {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1646            {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1647            {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1648            {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1649            {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1650            {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1651            {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1652            {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1653            {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1654            {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1655            {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1656            {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1657            {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1658            {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1659            {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1660            {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1661            {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1662            {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1663            {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1664            {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1665            {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1666            {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1667            {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1668            {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1669            {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1670            {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1671            {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1672            {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1673            {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1674            {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1675            {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1676            {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1677            {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1678            {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1679            {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1680            {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1681            {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1682            {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1683            {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1684            {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1685            {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1686            {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1687            {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1688            {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1689            {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1690            {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1691            {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1692            {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1693            {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1694            {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1695            {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1696            {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1697            {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1698            {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1699            {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1700            {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1701            {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1702            {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1703            {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1704            {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1705            {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1706            {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1707            {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1708            {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1709            {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1710            {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1711            {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1712            {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1713            {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1714            {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1715            {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1716            {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1717            {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1718            {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1719            {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1720            {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1721            {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1722            {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1723            {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1724            {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1725            {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1726            {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1727            {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1728            {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1729            {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1730            {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1731            {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1732            {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1733            {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1734            {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1735            {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1736            {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1737            {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1738            {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1739            {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1740            {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1741            {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1742            {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1743            {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1744            {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1745            {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1746            {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1747            {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1748            {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1749            {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1750            {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1751            {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1752            {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1753            {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1754            {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1755    };
1756    
1757    const VLC dcc_tab[511] = {
1758            {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1759            {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1760            {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1761            {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1762            {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1763            {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1764            {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1765            {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1766            {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1767            {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1768            {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1769            {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1770            {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1771            {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1772            {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1773            {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1774            {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1775            {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1776            {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1777            {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1778            {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1779            {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1780            {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1781            {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1782            {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1783            {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1784            {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1785            {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1786            {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1787            {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1788            {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1789            {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1790            {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1791            {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1792            {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1793            {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1794            {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1795            {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1796            {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1797            {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1798            {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1799            {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1800            {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1801            {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1802            {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1803            {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1804            {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1805            {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1806            {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1807            {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1808            {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1809            {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1810            {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1811            {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1812            {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1813            {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1814            {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1815            {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1816            {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1817            {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1818            {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1819            {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1820            {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1821            {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1822            {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1823            {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1824            {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1825            {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1826            {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1827            {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1828            {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1829            {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1830            {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1831            {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1832            {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1833            {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1834            {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1835            {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1836            {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1837            {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1838            {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1839            {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1840            {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1841            {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1842            {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1843            {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1844            {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1845            {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1846            {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1847            {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1848            {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1849            {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1850            {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1851            {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1852            {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1853            {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1854            {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1855            {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1856            {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1857            {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1858            {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1859            {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1860            {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1861            {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1862            {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1863            {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1864            {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1865            {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1866            {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1867            {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1868            {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1869            {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1870            {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1871            {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1872            {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1873            {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1874            {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1875            {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1876            {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1877            {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1878            {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1879            {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1880            {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1881            {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1882            {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1883            {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1884            {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1885            {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1886    };
1887    
1888    
1889    const VLC mb_motion_table[65] = {
1890            {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1891            {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1892            {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1893            {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1894            {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1895            {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1896            {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1897            {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1898            {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1899            {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1900            {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1901            {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1902            {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1903            {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1904            {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1905            {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1906            {0x04, 13}
1907    };
1908    
1909    
1910    /******************************************************************
1911     * decoder tables                                                 *
1912     ******************************************************************/
1913    
1914    VLC const mcbpc_intra_table[64] = {
1915            {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4},  {4, 4},  {4, 4},  {4, 4},
1916            {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1917            {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1918            {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
1919            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1920            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1921            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1922            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1}
1923    };
1924    
1925    VLC const mcbpc_inter_table[257] = {
1926            {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1927            {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1928            {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1929            {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1930            {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1931            {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1932            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1933            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1934            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1935            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1936            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1937            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1938            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1939            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1940            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1941            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1942            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1943            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1944            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1945            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1946            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1947            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1948            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1949            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1950            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1951            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1952            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1953            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1954            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1955            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1956            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1957            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1958            {0, 1}
1959    };
1960    
1961    VLC const cbpy_table[64] = {
1962            {-1, 0}, {-1, 0}, {6, 6},  {9, 6},  {8, 5},  {8, 5},  {4, 5},  {4, 5},
1963            {2, 5},  {2, 5},  {1, 5},  {1, 5},  {0, 4},  {0, 4},  {0, 4},  {0, 4},
1964            {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1965            {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4},  {5, 4},  {5, 4},  {5, 4},
1966            {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4},  {3, 4},  {3, 4},  {3, 4},
1967            {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4},  {7, 4},  {7, 4},  {7, 4},
1968            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1969            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1970    };
1971    
1972    VLC const TMNMVtab0[] = {
1973            {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1974            {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1975    };
1976    
1977    VLC const TMNMVtab1[] = {
1978            {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1979            {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1980            {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1981            {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1982            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1983            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1984            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1985            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1986            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1987            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1988            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1989            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1990            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1991            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1992            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1993            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1994            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1995            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1996            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1997            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1998            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1999            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
2000            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
2001            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
2002    };
2003    
2004    VLC const TMNMVtab2[] = {
2005            {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
2006            {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
2007            {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
2008            {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
2009            {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
2010            {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
2011            {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
2012            {24, 10}, {24, 10}, {24, 10}, {24, 10},
2013            {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
2014            {23, 10}, {23, 10}, {23, 10}, {23, 10},
2015            {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
2016            {22, 10}, {22, 10}, {22, 10}, {22, 10},
2017            {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
2018            {21, 10}, {21, 10}, {21, 10}, {21, 10},
2019            {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
2020            {20, 10}, {20, 10}, {20, 10}, {20, 10},
2021            {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
2022            {19, 10}, {19, 10}, {19, 10}, {19, 10},
2023            {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
2024            {18, 10}, {18, 10}, {18, 10}, {18, 10},
2025            {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
2026            {17, 10}, {17, 10}, {17, 10}, {17, 10},
2027            {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
2028            {16, 10}, {16, 10}, {16, 10}, {16, 10},
2029            {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
2030            {15, 10}, {15, 10}, {15, 10}, {15, 10},
2031            {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
2032            {14, 10}, {14, 10}, {14, 10}, {14, 10},
2033            {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
2034            {13, 10}, {13, 10}, {13, 10}, {13, 10},
2035            {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10}
2036    };
2037    
2038    short const dc_threshold[] = {
2039            21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,
2040             8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,
2041            25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,
2042            28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,
2043            30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,
2044            29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,
2045            26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,
2046            29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606
2047    };
2048    
2049    VLC const dc_lum_tab[] = {
2050            {0, 0}, {4, 3}, {3, 3}, {0, 3},
2051            {2, 2}, {2, 2}, {1, 2}, {1, 2},
2052    };

Legend:
Removed from v.514  
changed lines
  Added in v.883

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4