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

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

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

revision 1.25.2.11, Thu Jan 16 21:16:04 2003 UTC revision 1.46, Mon Mar 22 22:36:23 2004 UTC
# Line 1  Line 1 
1   /******************************************************************************  /*****************************************************************************
2    *                                                                            *   *
3    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *   *  XVID MPEG-4 VIDEO CODEC
4    *                                                                            *   *  - MB coding -
5    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *   *
6    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *   *  Copyright (C) 2002 Michael Militzer <isibaar@xvid.org>
7    *  software module in hardware or software products are advised that its     *   *
8    *  use may infringe existing patents or copyrights, and any such use         *   *  This program is free software ; you can redistribute it and/or modify
9    *  would be at such party's own risk.  The original developer of this        *   *  it under the terms of the GNU General Public License as published by
10    *  software module and his/her company, and subsequent editors and their     *   *  the Free Software Foundation ; either version 2 of the License, or
11    *  companies, will have no liability for use of this software or             *   *  (at your option) any later version.
12    *  modifications or derivatives thereof.                                     *   *
13    *                                                                            *   *  This program is distributed in the hope that it will be useful,
14    *  XviD is free software; you can redistribute it and/or modify it           *   *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
15    *  under the terms of the GNU General Public License as published by         *   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    *  the Free Software Foundation; either version 2 of the License, or         *   *  GNU General Public License for more details.
17    *  (at your option) any later version.                                       *   *
18    *                                                                            *   *  You should have received a copy of the GNU General Public License
19    *  XviD is distributed in the hope that it will be useful, but               *   *  along with this program ; if not, write to the Free Software
20    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *   *
22    *  GNU General Public License for more details.                              *   * $Id$
23    *                                                                            *   *
24    *  You should have received a copy of the GNU General Public License         *   ****************************************************************************/
   *  along with this program; if not, write to the Free Software               *  
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *  
   *                                                                            *  
   ******************************************************************************/  
   
  /******************************************************************************  
   *                                                                            *  
   *  mbcoding.c                                                                *  
   *                                                                            *  
   *  Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org>                  *  
   *                                                                            *  
   *  For more information visit the XviD homepage: http://www.xvid.org         *  
   *                                                                            *  
   ******************************************************************************/  
   
  /******************************************************************************  
   *                                                                                                                                                        *  
   *  Revision history:                                                         *  
   *                                                                            *  
   *  28.10.2002 GMC support - gruel                                                                                        *  
   *  28.06.2002 added check_resync_marker()                                    *  
   *  14.04.2002 bframe encoding                                                                                            *  
   *  08.03.2002 initial version; isibaar                                                           *  
   *                                                                                                                                                        *  
   ******************************************************************************/  
   
25    
26  #include <stdio.h>  #include <stdio.h>
27  #include <stdlib.h>  #include <stdlib.h>
28    #include <string.h>
29    
30  #include "../portab.h"  #include "../portab.h"
31  #include "../global.h"  #include "../global.h"
32  #include "bitstream.h"  #include "bitstream.h"
# Line 60  Line 36 
36    
37  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
38    
 /* #define BIGLUT */  
   
 #ifdef BIGLUT  
 #define LEVELOFFSET 2048  
 #else  
39  #define LEVELOFFSET 32  #define LEVELOFFSET 32
 #endif  
40    
41  static REVERSE_EVENT DCT3D[2][4096];  static REVERSE_EVENT DCT3D[2][4096];
   
 #ifdef BIGLUT  
 static VLC coeff_VLC[2][2][4096][64];  
 static VLC *intra_table, *inter_table;  
 #else  
42  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
 #endif  
43    
44  /* not really MB related, but VLCs are only available here */  /* not really MB related, but VLCs are only available here */
45  void bs_put_spritetrajectory(Bitstream * bs, const int val)  void bs_put_spritetrajectory(Bitstream * bs, const int val)
# Line 85  Line 49 
49          const int code2 = sprite_trajectory_len[len].code;          const int code2 = sprite_trajectory_len[len].code;
50          const int len2 = sprite_trajectory_len[len].len;          const int len2 = sprite_trajectory_len[len].len;
51    
52  //      printf("GMC=%d Code/Len  = %d / %d ",val, code,len);  #if 0
53  //      printf("Code2 / Len2 = %d / %d \n",code2,len2);          printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
54            printf("Code2 / Len2 = %d / %d \n",code2,len2);
55    #endif
56    
57          BitstreamPutBits(bs, code2, len2);          BitstreamPutBits(bs, code2, len2);
58          if (len) BitstreamPutBits(bs, code, len);          if (len) BitstreamPutBits(bs, code, len);
# Line 109  Line 75 
75  void  void
76  init_vlc_tables(void)  init_vlc_tables(void)
77  {  {
78          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset, limit;          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
79          int32_t l;          int32_t l;
80    
 #ifdef BIGLUT  
         intra_table = coeff_VLC[1];  
         inter_table = coeff_VLC[0];  
 #endif  
   
   
81          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++)
82                  for (i = 0; i < 4096; i++)                  for (i = 0; i < 4096; i++)
83                          DCT3D[intra][i].event.level = 0;                          DCT3D[intra][i].event.level = 0;
84    
85          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
86                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++) {
87                  {                          for (run = 0; run < 63 + last; run++) {
88                          for (run = 0; run < 63 + last; run++)                                  for (level = 0; level < (uint32_t)(32 << intra); level++) {
                                 for (level = 0; level < 32 << intra; level++)  
                                 {  
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
89                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
90                                          coeff_VLC[intra][last][level + offset][run].len = 128;                                          coeff_VLC[intra][last][level + offset][run].len = 128;
91                                  }                                  }
92                  }                  }
93                    }
94            }
95    
96          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
97                  for (i = 0; i < 102; i++)                  for (i = 0; i < 102; i++) {
                 {  
 #ifdef BIGLUT  
                         offset = LEVELOFFSET;  
 #else  
98                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
99  #endif  
100                          for (j = 0; j < 1 << (12 - coeff_tab[intra][i].vlc.len); j++)                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++) {
                         {  
101                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;
102                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
103                          }                          }
# Line 155  Line 106 
106                                  = coeff_tab[intra][i].vlc.code << 1;                                  = coeff_tab[intra][i].vlc.code << 1;
107                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len
108                                  = coeff_tab[intra][i].vlc.len + 1;                                  = coeff_tab[intra][i].vlc.len + 1;
109  #ifndef BIGLUT  
110                          if (!intra)                          if (!intra) {
 #endif  
                         {  
111                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code
112                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
113                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len
114                                          = coeff_tab[intra][i].vlc.len + 1;                                          = coeff_tab[intra][i].vlc.len + 1;
115                          }                          }
116                  }                  }
117            }
118    
119            for (intra = 0; intra < 2; intra++) {
120                    for (last = 0; last < 2; last++) {
121                            for (run = 0; run < 63 + last; run++) {
122                                    for (level = 1; level < (uint32_t)(32 << intra); level++) {
123    
         for (intra = 0; intra < 2; intra++)  
                 for (last = 0; last < 2; last++)  
                         for (run = 0; run < 63 + last; run++)  
                         {  
                                 for (level = 1; level < 32 << intra; level++)  
                                 {  
124                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
125                                              continue;                                              continue;
126    
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
127                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
128                      level_esc = level - max_level[intra][last][run];                      level_esc = level - max_level[intra][last][run];
129                                          run_esc = run - 1 - max_run[intra][last][level];                                          run_esc = run - 1 - max_run[intra][last][level];
                                         /*use this test to use shorter esc2 codes when possible  
                                         if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]  
                                                 && !(coeff_VLC[intra][last][level_esc + offset][run].len + 7 + 1  
                                                          > coeff_VLC[intra][last][level + offset][run_esc].code + 7 + 2))*/  
130    
131                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc])                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]) {
                                         {  
132                                                  escape     = ESCAPE1;                                                  escape     = ESCAPE1;
133                                                  escape_len = 7 + 1;                                                  escape_len = 7 + 1;
134                                                  run_esc    = run;                                                  run_esc    = run;
135                                          }                                          } else {
136                                          else                                                  if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {
                                         {  
                                                 if (level <= max_level[intra][last][run_esc] && run_esc <= max_run[intra][last][level])  
                                                 {  
137                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
138                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
139                                                          level_esc  = level;                                                          level_esc  = level;
140                                                  }                                                  } else {
141                                                  else                                                          if (!intra) {
                                                 {  
 #ifndef BIGLUT  
                                                         if (!intra)  
 #endif  
                                                         {  
142                                                                  coeff_VLC[intra][last][level + offset][run].code                                                                  coeff_VLC[intra][last][level + offset][run].code
143                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
144                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
145                                                                          coeff_VLC[intra][last][offset - level][run].code                                                                          coeff_VLC[intra][last][offset - level][run].code
146                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-(int32_t)level & 0xfff) << 1) | 1;
147                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;
148                                                          }                                                          }
149                                                          continue;                                                          continue;
# Line 223  Line 155 
155                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
156                                          coeff_VLC[intra][last][level + offset][run].len                                          coeff_VLC[intra][last][level + offset][run].len
157                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
158  #ifndef BIGLUT  
159                                          if (!intra)                                          if (!intra) {
 #endif  
                                         {  
160                                                  coeff_VLC[intra][last][offset - level][run].code                                                  coeff_VLC[intra][last][offset - level][run].code
161                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
162                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
# Line 235  Line 165 
165                                          }                                          }
166                                  }                                  }
167    
168  #ifdef BIGLUT                                  if (!intra) {
                                 for (level = 32 << intra; level < 2048; level++)  
                                 {  
                                         coeff_VLC[intra][last][level + offset][run].code  
                                                 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;  
                                         coeff_VLC[intra][last][level + offset][run].len = 30;  
   
                                         coeff_VLC[intra][last][offset - level][run].code  
                                                 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;  
                                         coeff_VLC[intra][last][offset - level][run].len = 30;  
                                 }  
 #else  
                                 if (!intra)  
                                 {  
169                                          coeff_VLC[intra][last][0][run].code                                          coeff_VLC[intra][last][0][run].code
170                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
171                                          coeff_VLC[intra][last][0][run].len = 30;                                          coeff_VLC[intra][last][0][run].len = 30;
172                                  }                                  }
 #endif  
173                          }                          }
174  /* init sprite_trajectory tables */                  }
175  /* even if GMC is not specified (it might be used later...) */          }
176    
177            /* init sprite_trajectory tables
178             * even if GMC is not specified (it might be used later...) */
179    
180          sprite_trajectory_code[0+16384].code = 0;          sprite_trajectory_code[0+16384].code = 0;
181          sprite_trajectory_code[0+16384].len = 0;          sprite_trajectory_code[0+16384].len = 0;
182          for (k=0;k<14;k++)          for (k=0;k<14;k++) {
         {  
183                  int limit = (1<<k);                  int limit = (1<<k);
184    
185                  for (l=-(2*limit-1); l <= -limit; l++)                  for (l=-(2*limit-1); l <= -limit; l++) {
186                  {                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
187                          sprite_trajectory_code[i+16384].code = (2*limit-1)+l;                          sprite_trajectory_code[l+16384].len = k+1;
                         sprite_trajectory_code[i+16384].len = k+1;  
188                  }                  }
189    
190                  for (l=limit; l<= 2*limit-1; l++)                  for (l=limit; l<= 2*limit-1; l++) {
191                  {                          sprite_trajectory_code[l+16384].code = l;
192                          sprite_trajectory_code[i+16384].code = l;                          sprite_trajectory_code[l+16384].len = k+1;
                         sprite_trajectory_code[i+16384].len = k+1;  
193                  }                  }
194          }          }
195  }  }
# Line 333  Line 249 
249    
250  }  }
251    
 #ifdef BIGLUT  
   
 static __inline void  
 CodeCoeff(Bitstream * bs,  
                   const int16_t qcoeff[64],  
                   VLC * table,  
                   const uint16_t * zigzag,  
                   uint16_t intra)  
 {  
   
         uint32_t j, last;  
         short v;  
         VLC *vlc;  
   
         j = intra;  
         last = intra;  
   
         while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                 j++;  
   
         do {  
                 vlc = table + 64 * 2048 + (v << 6) + j - last;  
                 last = ++j;  
   
                 /* count zeroes */  
                 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                         j++;  
   
                 /* write code */  
                 if (j != 64) {  
                         BitstreamPutBits(bs, vlc->code, vlc->len);  
                 } else {  
                         vlc += 64 * 4096;  
                         BitstreamPutBits(bs, vlc->code, vlc->len);  
                         break;  
                 }  
         } while (1);  
   
 }  
   
 #else  
   
252  static __inline void  static __inline void
253  CodeCoeffInter(Bitstream * bs,  CodeCoeffInter(Bitstream * bs,
254                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 442  Line 316 
316          i       = 1;          i       = 1;
317          run = 0;          run = 0;
318    
319          while (!(level = qcoeff[zigzag[i++]]))          while (i<64 && !(level = qcoeff[zigzag[i++]]))
320                  run++;                  run++;
321    
322          prev_level = level;          prev_level = level;
# Line 453  Line 327 
327          {          {
328                  if ((level = qcoeff[zigzag[i++]]) != 0)                  if ((level = qcoeff[zigzag[i++]]) != 0)
329                  {                  {
330                          abs_level = ABS(prev_level);                          abs_level = abs(prev_level);
331                          abs_level = abs_level < 64 ? abs_level : 0;                          abs_level = abs_level < 64 ? abs_level : 0;
332                          code      = coeff_VLC[1][0][abs_level][prev_run].code;                          code      = coeff_VLC[1][0][abs_level][prev_run].code;
333                          len               = coeff_VLC[1][0][abs_level][prev_run].len;                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
# Line 473  Line 347 
347                          run++;                          run++;
348          }          }
349    
350          abs_level = ABS(prev_level);          abs_level = abs(prev_level);
351          abs_level = abs_level < 64 ? abs_level : 0;          abs_level = abs_level < 64 ? abs_level : 0;
352          code      = coeff_VLC[1][1][abs_level][prev_run].code;          code      = coeff_VLC[1][1][abs_level][prev_run].code;
353          len               = coeff_VLC[1][1][abs_level][prev_run].len;          len               = coeff_VLC[1][1][abs_level][prev_run].len;
# Line 487  Line 361 
361          BitstreamPutBits(bs, code, len);          BitstreamPutBits(bs, code, len);
362  }  }
363    
364  #endif  
365    
366    /* returns the number of bits required to encode qcoeff */
367    
368    int
369    CodeCoeffIntra_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
370    {
371            int bits = 0;
372            uint32_t i, abs_level, run, prev_run, len;
373            int32_t level, prev_level;
374    
375            i       = 1;
376            run = 0;
377    
378            while (i<64 && !(level = qcoeff[zigzag[i++]]))
379                    run++;
380    
381            if (i >= 64) return 0;  /* empty block */
382    
383            prev_level = level;
384            prev_run   = run;
385            run = 0;
386    
387            while (i < 64)
388            {
389                    if ((level = qcoeff[zigzag[i++]]) != 0)
390                    {
391                            abs_level = abs(prev_level);
392                            abs_level = abs_level < 64 ? abs_level : 0;
393                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
394                            bits      += len!=128 ? len : 30;
395    
396                            prev_level = level;
397                            prev_run   = run;
398                            run = 0;
399                    }
400                    else
401                            run++;
402            }
403    
404            abs_level = abs(prev_level);
405            abs_level = abs_level < 64 ? abs_level : 0;
406            len               = coeff_VLC[1][1][abs_level][prev_run].len;
407            bits      += len!=128 ? len : 30;
408    
409            return bits;
410    }
411    
412    int
413    CodeCoeffInter_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
414    {
415            uint32_t i, run, prev_run, len;
416            int32_t level, prev_level, level_shifted;
417            int bits = 0;
418    
419            i       = 0;
420            run = 0;
421    
422            while (!(level = qcoeff[zigzag[i++]]))
423                    run++;
424    
425            prev_level = level;
426            prev_run   = run;
427            run = 0;
428    
429            while (i < 64) {
430                    if ((level = qcoeff[zigzag[i++]]) != 0) {
431                            level_shifted = prev_level + 32;
432                            if (!(level_shifted & -64))
433                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
434                            else
435                                    len  = 30;
436    
437                            bits += len;
438                            prev_level = level;
439                            prev_run   = run;
440                            run = 0;
441                    }
442                    else
443                            run++;
444            }
445    
446            level_shifted = prev_level + 32;
447            if (!(level_shifted & -64))
448                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
449            else
450                    len  = 30;
451            bits += len;
452    
453            return bits;
454    }
455    
456    static int iDQtab[5] = {
457            1, 0, -1 /* no change */, 2, 3
458    };
459    #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
460    
461    
462  static __inline void  static __inline void
463  CodeBlockIntra(const FRAMEINFO * const frame,  CodeBlockIntra(const FRAMEINFO * const frame,
# Line 501  Line 471 
471    
472          cbpy = pMB->cbp >> 2;          cbpy = pMB->cbp >> 2;
473    
474          // write mcbpc          /* write mcbpc */
475          if (frame->coding_type == I_VOP) {          if (frame->coding_type == I_VOP) {
476                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
477                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
# Line 512  Line 482 
482                                                   mcbpc_inter_tab[mcbpc].len);                                                   mcbpc_inter_tab[mcbpc].len);
483          }          }
484    
485          // ac prediction flag          /* ac prediction flag */
486          if (pMB->acpred_directions[0])          if (pMB->acpred_directions[0])
487                  BitstreamPutBits(bs, 1, 1);                  BitstreamPutBits(bs, 1, 1);
488          else          else
489                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
490    
491          // write cbpy          /* write cbpy */
492          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
493    
494          // write dquant          /* write dquant */
495          if (pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA_Q)
496                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
497    
498          // write interlacing          /* write interlacing */
499          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
500                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
501          }          }
502          // code block coeffs          /* code block coeffs */
503          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
504                  if (i < 4)                  if (i < 4)
505                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
# Line 540  Line 510 
510    
511                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i))) {
512                          const uint16_t *scan_table =                          const uint16_t *scan_table =
513                                  frame->global_flags & XVID_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
514                                  scan_tables[2] : scan_tables[pMB->acpred_directions[i]];                                  scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
515    
516                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
517    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);  
 #else  
518                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
 #endif  
519    
520                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
521                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 573  Line 539 
539          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
540          cbpy = 15 - (pMB->cbp >> 2);          cbpy = 15 - (pMB->cbp >> 2);
541    
542          // write mcbpc          /* write mcbpc */
543          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
544                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
545    
546          if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )          if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
547                  BitstreamPutBit(bs, pMB->mcsel);                // mcsel: '0'=local motion, '1'=GMC                  BitstreamPutBit(bs, pMB->mcsel);                /* mcsel: '0'=local motion, '1'=GMC */
548    
549          // write cbpy          /* write cbpy */
550          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
551    
552          // write dquant          /* write dquant */
553          if (pMB->mode == MODE_INTER_Q)          if (pMB->mode == MODE_INTER_Q)
554                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
555    
556          // interlacing          /* interlacing */
557          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
558                  if (pMB->cbp) {                  if (pMB->cbp) {
559                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
560                          DPRINTF(DPRINTF_MB,"codep: field_dct: %i", pMB->field_dct);                          DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);
561                  }                  }
562    
563                  // if inter block, write field ME flag                  /* if inter block, write field ME flag */
564                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
565                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
566                          DPRINTF(DPRINTF_MB,"codep: field_pred: %i", pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
567    
568                          // write field prediction references                          /* write field prediction references */
569    #if 0 /* Remove the #if once field_pred is supported */
570                          if (pMB->field_pred) {                          if (pMB->field_pred) {
571                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
572                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
573                          }                          }
574    #endif
575                  }                  }
576          }          }
577          // code motion vector(s) if motion is local          /* code motion vector(s) if motion is local  */
578          if (!pMB->mcsel)          if (!pMB->mcsel)
579                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
580                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
# Line 615  Line 583 
583    
584          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
585    
586          // code block coeffs          /* code block coeffs */
587          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
588                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
                 {  
589                          const uint16_t *scan_table =                          const uint16_t *scan_table =
590                                  frame->global_flags & XVID_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
591                                  scan_tables[2] : scan_tables[0];                                  scan_tables[2] : scan_tables[0];
592    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);  
 #else  
593                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
 #endif  
594                  }                  }
595    
596          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
# Line 643  Line 606 
606                   Statistics * pStat)                   Statistics * pStat)
607  {  {
608          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)
609                          BitstreamPutBit(bs, 0); // not_coded                          BitstreamPutBit(bs, 0); /* not_coded */
610    
611          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
612                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
# Line 652  Line 615 
615    
616  }  }
617    
 /*  
 // moved to mbcoding.h so that in can be 'static __inline'  
 void  
 MBSkip(Bitstream * bs)  
 {  
         BitstreamPutBit(bs, 1); // not coded  
 }  
 */  
   
618  /***************************************************************  /***************************************************************
619   * bframe encoding start   * bframe encoding start
620   ***************************************************************/   ***************************************************************/
# Line 717  Line 671 
671                  BitstreamPutBit(bs, 1);                  BitstreamPutBit(bs, 1);
672                  return;                  return;
673    
674          default:;                                       // invalid          default:;                                       /* invalid */
675          }          }
676  }  }
677    
678    
679    
680  void  void
681  MBCodingBVOP(const MACROBLOCK * mb,  MBCodingBVOP(const FRAMEINFO * const frame,
682                             const MACROBLOCK * mb,
683                           const int16_t qcoeff[6 * 64],                           const int16_t qcoeff[6 * 64],
684                           const int32_t fcode,                           const int32_t fcode,
685                           const int32_t bcode,                           const int32_t bcode,
686                           Bitstream * bs,                           Bitstream * bs,
687                           Statistics * pStat,                           Statistics * pStat)
                          int direction)  
688  {  {
689          int vcode = fcode;          int vcode = fcode;
690          unsigned int i;          unsigned int i;
691    
692            const uint16_t *scan_table =
693                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
694                    scan_tables[2] : scan_tables[0];
695            int bits;
696    
697    
698  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
699                  when a block is skipped it is decoded DIRECT(0,0)                  when a block is skipped it is decoded DIRECT(0,0)
700                  hence is interpolated from forward & backward frames                  hence is interpolated from forward & backward frames
701          ------------------------------------------------------------------ */          ------------------------------------------------------------------ */
702    
703          if (mb->mode == MODE_DIRECT_NONE_MV) {          if (mb->mode == MODE_DIRECT_NONE_MV) {
704                  BitstreamPutBit(bs, 1); // skipped                  BitstreamPutBit(bs, 1); /* skipped */
705                  return;                  return;
706          }          }
707    
708          BitstreamPutBit(bs, 0);         // not skipped          BitstreamPutBit(bs, 0);         /* not skipped */
709    
710          if (mb->cbp == 0) {          if (mb->cbp == 0) {
711                  BitstreamPutBit(bs, 1); // cbp == 0                  BitstreamPutBit(bs, 1); /* cbp == 0 */
712          } else {          } else {
713                  BitstreamPutBit(bs, 0); // cbp == xxx                  BitstreamPutBit(bs, 0); /* cbp == xxx */
714          }          }
715    
716          put_bvop_mbtype(bs, mb->mode);          put_bvop_mbtype(bs, mb->mode);
# Line 760  Line 720 
720          }          }
721    
722          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
723                  put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0                  put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */
724            }
725    
726            if (frame->vol_flags & XVID_VOL_INTERLACING) {
727                    if (mb->cbp) {
728                            BitstreamPutBit(bs, mb->field_dct);
729                            DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);
730                    }
731    
732                    /* if not direct block, write field ME flag */
733                    if (mb->mode != MODE_DIRECT) {
734                            BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
735    
736                            /* write field prediction references */
737    #if 0 /* Remove the #if once field_pred is supported */
738                            if (mb->field_pred) {
739                                    BitstreamPutBit(bs, mb->field_for_top);
740                                    BitstreamPutBit(bs, mb->field_for_bot);
741                            }
742    #endif
743                    }
744          }          }
745    
746    
747          switch (mb->mode) {          switch (mb->mode) {
748                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
749                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); //forward vector of interpolate mode                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); /* forward vector of interpolate mode */
750                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
751                  case MODE_BACKWARD:                  case MODE_BACKWARD:
752                          vcode = bcode;                          vcode = bcode;
# Line 774  Line 755 
755                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
756                          break;                          break;
757                  case MODE_DIRECT:                  case MODE_DIRECT:
758                          CodeVector(bs, mb->pmvs[3].x, 1, pStat);        // fcode is always 1 for delta vector                          CodeVector(bs, mb->pmvs[3].x, 1, pStat);        /* fcode is always 1 for delta vector */
759                          CodeVector(bs, mb->pmvs[3].y, 1, pStat);        // prediction is always (0,0)                          CodeVector(bs, mb->pmvs[3].y, 1, pStat);        /* prediction is always (0,0) */
760                  default: break;                  default: break;
761          }          }
762    
763            bits = BitstreamPos(bs);
764          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
765                  if (mb->cbp & (1 << (5 - i))) {                  if (mb->cbp & (1 << (5 - i))) {
766  #ifdef BIGLUT                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);  
 #else  
                         CodeCoeffInter(bs, &qcoeff[i * 64], scan_tables[0]);  
 #endif  
767                  }                  }
768          }          }
769            pStat->iTextBits += BitstreamPos(bs) - bits;
770  }  }
771    
772    
# Line 797  Line 776 
776   ***************************************************************/   ***************************************************************/
777    
778    
779  // for IVOP addbits == 0  /*
780  // for PVOP addbits == fcode - 1   * for IVOP addbits == 0
781  // for BVOP addbits == max(fcode,bcode) - 1   * for PVOP addbits == fcode - 1
782  // returns true or false   * for BVOP addbits == max(fcode,bcode) - 1
783     * returns true or false
784     */
785  int  int
786  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
787  {  {
# Line 914  Line 895 
895                  return data;                  return data;
896    
897          res = BitstreamGetBits(bs, fcode - 1);          res = BitstreamGetBits(bs, fcode - 1);
898          mv = ((ABS(data) - 1) * scale_fac) + res + 1;          mv = ((abs(data) - 1) * scale_fac) + res + 1;
899    
900          return data < 0 ? -mv : mv;          return data < 0 ? -mv : mv;
901    
# Line 1015  Line 996 
996                  level = BitstreamGetBits(bs, 8);                  level = BitstreamGetBits(bs, 8);
997    
998                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
999                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1000    
1001                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1002          }          }
# Line 1071  Line 1052 
1052          do {          do {
1053                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1054                  if (run == -1) {                  if (run == -1) {
1055                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1056                          break;                          break;
1057                  }                  }
1058                  coeff += run;                  coeff += run;
1059                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1060    
1061                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1062                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));  #if 0
1063                    DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1064    #endif
1065    
1066                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1067                          DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1068                  }                  }
1069                  coeff++;                  coeff++;
1070          } while (!last);          } while (!last);
# Line 1104  Line 1087 
1087          do {          do {
1088                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1089                  if (run == -1) {                  if (run == -1) {
1090                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1091                          break;                          break;
1092                  }                  }
1093                  p += run;                  p += run;
1094    
1095                  block[scan[p]] = level;                  block[scan[p]] = level;
1096    
1097                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);
1098                  // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */
1099    
1100                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1101                          DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);
1102                  }                  }
1103                  p++;                  p++;
1104          } while (!last);          } while (!last);
1105    
1106  }  }
1107    
1108    
1109    /*****************************************************************************
1110     * VLC tables and other constant arrays
1111     ****************************************************************************/
1112    
1113    VLC_TABLE const coeff_tab[2][102] =
1114    {
1115            /* intra = 0 */
1116            {
1117                    {{ 2,  2}, {0, 0, 1}},
1118                    {{15,  4}, {0, 0, 2}},
1119                    {{21,  6}, {0, 0, 3}},
1120                    {{23,  7}, {0, 0, 4}},
1121                    {{31,  8}, {0, 0, 5}},
1122                    {{37,  9}, {0, 0, 6}},
1123                    {{36,  9}, {0, 0, 7}},
1124                    {{33, 10}, {0, 0, 8}},
1125                    {{32, 10}, {0, 0, 9}},
1126                    {{ 7, 11}, {0, 0, 10}},
1127                    {{ 6, 11}, {0, 0, 11}},
1128                    {{32, 11}, {0, 0, 12}},
1129                    {{ 6,  3}, {0, 1, 1}},
1130                    {{20,  6}, {0, 1, 2}},
1131                    {{30,  8}, {0, 1, 3}},
1132                    {{15, 10}, {0, 1, 4}},
1133                    {{33, 11}, {0, 1, 5}},
1134                    {{80, 12}, {0, 1, 6}},
1135                    {{14,  4}, {0, 2, 1}},
1136                    {{29,  8}, {0, 2, 2}},
1137                    {{14, 10}, {0, 2, 3}},
1138                    {{81, 12}, {0, 2, 4}},
1139                    {{13,  5}, {0, 3, 1}},
1140                    {{35,  9}, {0, 3, 2}},
1141                    {{13, 10}, {0, 3, 3}},
1142                    {{12,  5}, {0, 4, 1}},
1143                    {{34,  9}, {0, 4, 2}},
1144                    {{82, 12}, {0, 4, 3}},
1145                    {{11,  5}, {0, 5, 1}},
1146                    {{12, 10}, {0, 5, 2}},
1147                    {{83, 12}, {0, 5, 3}},
1148                    {{19,  6}, {0, 6, 1}},
1149                    {{11, 10}, {0, 6, 2}},
1150                    {{84, 12}, {0, 6, 3}},
1151                    {{18,  6}, {0, 7, 1}},
1152                    {{10, 10}, {0, 7, 2}},
1153                    {{17,  6}, {0, 8, 1}},
1154                    {{ 9, 10}, {0, 8, 2}},
1155                    {{16,  6}, {0, 9, 1}},
1156                    {{ 8, 10}, {0, 9, 2}},
1157                    {{22,  7}, {0, 10, 1}},
1158                    {{85, 12}, {0, 10, 2}},
1159                    {{21,  7}, {0, 11, 1}},
1160                    {{20,  7}, {0, 12, 1}},
1161                    {{28,  8}, {0, 13, 1}},
1162                    {{27,  8}, {0, 14, 1}},
1163                    {{33,  9}, {0, 15, 1}},
1164                    {{32,  9}, {0, 16, 1}},
1165                    {{31,  9}, {0, 17, 1}},
1166                    {{30,  9}, {0, 18, 1}},
1167                    {{29,  9}, {0, 19, 1}},
1168                    {{28,  9}, {0, 20, 1}},
1169                    {{27,  9}, {0, 21, 1}},
1170                    {{26,  9}, {0, 22, 1}},
1171                    {{34, 11}, {0, 23, 1}},
1172                    {{35, 11}, {0, 24, 1}},
1173                    {{86, 12}, {0, 25, 1}},
1174                    {{87, 12}, {0, 26, 1}},
1175                    {{ 7,  4}, {1, 0, 1}},
1176                    {{25,  9}, {1, 0, 2}},
1177                    {{ 5, 11}, {1, 0, 3}},
1178                    {{15,  6}, {1, 1, 1}},
1179                    {{ 4, 11}, {1, 1, 2}},
1180                    {{14,  6}, {1, 2, 1}},
1181                    {{13,  6}, {1, 3, 1}},
1182                    {{12,  6}, {1, 4, 1}},
1183                    {{19,  7}, {1, 5, 1}},
1184                    {{18,  7}, {1, 6, 1}},
1185                    {{17,  7}, {1, 7, 1}},
1186                    {{16,  7}, {1, 8, 1}},
1187                    {{26,  8}, {1, 9, 1}},
1188                    {{25,  8}, {1, 10, 1}},
1189                    {{24,  8}, {1, 11, 1}},
1190                    {{23,  8}, {1, 12, 1}},
1191                    {{22,  8}, {1, 13, 1}},
1192                    {{21,  8}, {1, 14, 1}},
1193                    {{20,  8}, {1, 15, 1}},
1194                    {{19,  8}, {1, 16, 1}},
1195                    {{24,  9}, {1, 17, 1}},
1196                    {{23,  9}, {1, 18, 1}},
1197                    {{22,  9}, {1, 19, 1}},
1198                    {{21,  9}, {1, 20, 1}},
1199                    {{20,  9}, {1, 21, 1}},
1200                    {{19,  9}, {1, 22, 1}},
1201                    {{18,  9}, {1, 23, 1}},
1202                    {{17,  9}, {1, 24, 1}},
1203                    {{ 7, 10}, {1, 25, 1}},
1204                    {{ 6, 10}, {1, 26, 1}},
1205                    {{ 5, 10}, {1, 27, 1}},
1206                    {{ 4, 10}, {1, 28, 1}},
1207                    {{36, 11}, {1, 29, 1}},
1208                    {{37, 11}, {1, 30, 1}},
1209                    {{38, 11}, {1, 31, 1}},
1210                    {{39, 11}, {1, 32, 1}},
1211                    {{88, 12}, {1, 33, 1}},
1212                    {{89, 12}, {1, 34, 1}},
1213                    {{90, 12}, {1, 35, 1}},
1214                    {{91, 12}, {1, 36, 1}},
1215                    {{92, 12}, {1, 37, 1}},
1216                    {{93, 12}, {1, 38, 1}},
1217                    {{94, 12}, {1, 39, 1}},
1218                    {{95, 12}, {1, 40, 1}}
1219            },
1220            /* intra = 1 */
1221            {
1222                    {{ 2,  2}, {0, 0, 1}},
1223                    {{15,  4}, {0, 0, 3}},
1224                    {{21,  6}, {0, 0, 6}},
1225                    {{23,  7}, {0, 0, 9}},
1226                    {{31,  8}, {0, 0, 10}},
1227                    {{37,  9}, {0, 0, 13}},
1228                    {{36,  9}, {0, 0, 14}},
1229                    {{33, 10}, {0, 0, 17}},
1230                    {{32, 10}, {0, 0, 18}},
1231                    {{ 7, 11}, {0, 0, 21}},
1232                    {{ 6, 11}, {0, 0, 22}},
1233                    {{32, 11}, {0, 0, 23}},
1234                    {{ 6,  3}, {0, 0, 2}},
1235                    {{20,  6}, {0, 1, 2}},
1236                    {{30,  8}, {0, 0, 11}},
1237                    {{15, 10}, {0, 0, 19}},
1238                    {{33, 11}, {0, 0, 24}},
1239                    {{80, 12}, {0, 0, 25}},
1240                    {{14,  4}, {0, 1, 1}},
1241                    {{29,  8}, {0, 0, 12}},
1242                    {{14, 10}, {0, 0, 20}},
1243                    {{81, 12}, {0, 0, 26}},
1244                    {{13,  5}, {0, 0, 4}},
1245                    {{35,  9}, {0, 0, 15}},
1246                    {{13, 10}, {0, 1, 7}},
1247                    {{12,  5}, {0, 0, 5}},
1248                    {{34,  9}, {0, 4, 2}},
1249                    {{82, 12}, {0, 0, 27}},
1250                    {{11,  5}, {0, 2, 1}},
1251                    {{12, 10}, {0, 2, 4}},
1252                    {{83, 12}, {0, 1, 9}},
1253                    {{19,  6}, {0, 0, 7}},
1254                    {{11, 10}, {0, 3, 4}},
1255                    {{84, 12}, {0, 6, 3}},
1256                    {{18,  6}, {0, 0, 8}},
1257                    {{10, 10}, {0, 4, 3}},
1258                    {{17,  6}, {0, 3, 1}},
1259                    {{ 9, 10}, {0, 8, 2}},
1260                    {{16,  6}, {0, 4, 1}},
1261                    {{ 8, 10}, {0, 5, 3}},
1262                    {{22,  7}, {0, 1, 3}},
1263                    {{85, 12}, {0, 1, 10}},
1264                    {{21,  7}, {0, 2, 2}},
1265                    {{20,  7}, {0, 7, 1}},
1266                    {{28,  8}, {0, 1, 4}},
1267                    {{27,  8}, {0, 3, 2}},
1268                    {{33,  9}, {0, 0, 16}},
1269                    {{32,  9}, {0, 1, 5}},
1270                    {{31,  9}, {0, 1, 6}},
1271                    {{30,  9}, {0, 2, 3}},
1272                    {{29,  9}, {0, 3, 3}},
1273                    {{28,  9}, {0, 5, 2}},
1274                    {{27,  9}, {0, 6, 2}},
1275                    {{26,  9}, {0, 7, 2}},
1276                    {{34, 11}, {0, 1, 8}},
1277                    {{35, 11}, {0, 9, 2}},
1278                    {{86, 12}, {0, 2, 5}},
1279                    {{87, 12}, {0, 7, 3}},
1280                    {{ 7,  4}, {1, 0, 1}},
1281                    {{25,  9}, {0, 11, 1}},
1282                    {{ 5, 11}, {1, 0, 6}},
1283                    {{15,  6}, {1, 1, 1}},
1284                    {{ 4, 11}, {1, 0, 7}},
1285                    {{14,  6}, {1, 2, 1}},
1286                    {{13,  6}, {0, 5, 1}},
1287                    {{12,  6}, {1, 0, 2}},
1288                    {{19,  7}, {1, 5, 1}},
1289                    {{18,  7}, {0, 6, 1}},
1290                    {{17,  7}, {1, 3, 1}},
1291                    {{16,  7}, {1, 4, 1}},
1292                    {{26,  8}, {1, 9, 1}},
1293                    {{25,  8}, {0, 8, 1}},
1294                    {{24,  8}, {0, 9, 1}},
1295                    {{23,  8}, {0, 10, 1}},
1296                    {{22,  8}, {1, 0, 3}},
1297                    {{21,  8}, {1, 6, 1}},
1298                    {{20,  8}, {1, 7, 1}},
1299                    {{19,  8}, {1, 8, 1}},
1300                    {{24,  9}, {0, 12, 1}},
1301                    {{23,  9}, {1, 0, 4}},
1302                    {{22,  9}, {1, 1, 2}},
1303                    {{21,  9}, {1, 10, 1}},
1304                    {{20,  9}, {1, 11, 1}},
1305                    {{19,  9}, {1, 12, 1}},
1306                    {{18,  9}, {1, 13, 1}},
1307                    {{17,  9}, {1, 14, 1}},
1308                    {{ 7, 10}, {0, 13, 1}},
1309                    {{ 6, 10}, {1, 0, 5}},
1310                    {{ 5, 10}, {1, 1, 3}},
1311                    {{ 4, 10}, {1, 2, 2}},
1312                    {{36, 11}, {1, 3, 2}},
1313                    {{37, 11}, {1, 4, 2}},
1314                    {{38, 11}, {1, 15, 1}},
1315                    {{39, 11}, {1, 16, 1}},
1316                    {{88, 12}, {0, 14, 1}},
1317                    {{89, 12}, {1, 0, 8}},
1318                    {{90, 12}, {1, 5, 2}},
1319                    {{91, 12}, {1, 6, 2}},
1320                    {{92, 12}, {1, 17, 1}},
1321                    {{93, 12}, {1, 18, 1}},
1322                    {{94, 12}, {1, 19, 1}},
1323                    {{95, 12}, {1, 20, 1}}
1324            }
1325    };
1326    
1327    /* constants taken from momusys/vm_common/inlcude/max_level.h */
1328    uint8_t const max_level[2][2][64] = {
1329            {
1330                    /* intra = 0, last = 0 */
1331                    {
1332                            12, 6, 4, 3, 3, 3, 3, 2,
1333                            2, 2, 2, 1, 1, 1, 1, 1,
1334                            1, 1, 1, 1, 1, 1, 1, 1,
1335                            1, 1, 1, 0, 0, 0, 0, 0,
1336                            0, 0, 0, 0, 0, 0, 0, 0,
1337                            0, 0, 0, 0, 0, 0, 0, 0,
1338                            0, 0, 0, 0, 0, 0, 0, 0,
1339                            0, 0, 0, 0, 0, 0, 0, 0
1340                    },
1341                    /* intra = 0, last = 1 */
1342                    {
1343                            3, 2, 1, 1, 1, 1, 1, 1,
1344                            1, 1, 1, 1, 1, 1, 1, 1,
1345                            1, 1, 1, 1, 1, 1, 1, 1,
1346                            1, 1, 1, 1, 1, 1, 1, 1,
1347                            1, 1, 1, 1, 1, 1, 1, 1,
1348                            1, 0, 0, 0, 0, 0, 0, 0,
1349                            0, 0, 0, 0, 0, 0, 0, 0,
1350                            0, 0, 0, 0, 0, 0, 0, 0
1351                    }
1352            },
1353            {
1354                    /* intra = 1, last = 0 */
1355                    {
1356                            27, 10, 5, 4, 3, 3, 3, 3,
1357                            2, 2, 1, 1, 1, 1, 1, 0,
1358                            0, 0, 0, 0, 0, 0, 0, 0,
1359                            0, 0, 0, 0, 0, 0, 0, 0,
1360                            0, 0, 0, 0, 0, 0, 0, 0,
1361                            0, 0, 0, 0, 0, 0, 0, 0,
1362                            0, 0, 0, 0, 0, 0, 0, 0,
1363                            0, 0, 0, 0, 0, 0, 0, 0
1364                    },
1365                    /* intra = 1, last = 1 */
1366                    {
1367                            8, 3, 2, 2, 2, 2, 2, 1,
1368                            1, 1, 1, 1, 1, 1, 1, 1,
1369                            1, 1, 1, 1, 1, 0, 0, 0,
1370                            0, 0, 0, 0, 0, 0, 0, 0,
1371                            0, 0, 0, 0, 0, 0, 0, 0,
1372                            0, 0, 0, 0, 0, 0, 0, 0,
1373                            0, 0, 0, 0, 0, 0, 0, 0,
1374                            0, 0, 0, 0, 0, 0, 0, 0
1375                    }
1376            }
1377    };
1378    
1379    uint8_t const max_run[2][2][64] = {
1380            {
1381                    /* intra = 0, last = 0 */
1382                    {
1383                            0, 26, 10, 6, 2, 1, 1, 0,
1384                            0, 0, 0, 0, 0, 0, 0, 0,
1385                            0, 0, 0, 0, 0, 0, 0, 0,
1386                            0, 0, 0, 0, 0, 0, 0, 0,
1387                            0, 0, 0, 0, 0, 0, 0, 0,
1388                            0, 0, 0, 0, 0, 0, 0, 0,
1389                            0, 0, 0, 0, 0, 0, 0, 0,
1390                            0, 0, 0, 0, 0, 0, 0, 0,
1391                    },
1392                    /* intra = 0, last = 1 */
1393                    {
1394                            0, 40, 1, 0, 0, 0, 0, 0,
1395                            0, 0, 0, 0, 0, 0, 0, 0,
1396                            0, 0, 0, 0, 0, 0, 0, 0,
1397                            0, 0, 0, 0, 0, 0, 0, 0,
1398                            0, 0, 0, 0, 0, 0, 0, 0,
1399                            0, 0, 0, 0, 0, 0, 0, 0,
1400                            0, 0, 0, 0, 0, 0, 0, 0,
1401                            0, 0, 0, 0, 0, 0, 0, 0,
1402                    }
1403            },
1404            {
1405                    /* intra = 1, last = 0 */
1406                    {
1407                            0, 14, 9, 7, 3, 2, 1, 1,
1408                            1, 1, 1, 0, 0, 0, 0, 0,
1409                            0, 0, 0, 0, 0, 0, 0, 0,
1410                            0, 0, 0, 0, 0, 0, 0, 0,
1411                            0, 0, 0, 0, 0, 0, 0, 0,
1412                            0, 0, 0, 0, 0, 0, 0, 0,
1413                            0, 0, 0, 0, 0, 0, 0, 0,
1414                            0, 0, 0, 0, 0, 0, 0, 0,
1415                    },
1416                    /* intra = 1, last = 1 */
1417                    {
1418                            0, 20, 6, 1, 0, 0, 0, 0,
1419                            0, 0, 0, 0, 0, 0, 0, 0,
1420                            0, 0, 0, 0, 0, 0, 0, 0,
1421                            0, 0, 0, 0, 0, 0, 0, 0,
1422                            0, 0, 0, 0, 0, 0, 0, 0,
1423                            0, 0, 0, 0, 0, 0, 0, 0,
1424                            0, 0, 0, 0, 0, 0, 0, 0,
1425                            0, 0, 0, 0, 0, 0, 0, 0,
1426                    }
1427            }
1428    };
1429    
1430    /******************************************************************
1431     * encoder tables                                                 *
1432     ******************************************************************/
1433    
1434    VLC sprite_trajectory_code[32768];
1435    
1436    VLC sprite_trajectory_len[15] = {
1437            { 0x00 , 2},
1438            { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1439            { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},
1440            { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1441    
1442    
1443    /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1444       the sign bit must be added afterwards. */
1445    
1446    /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1447     CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1448     Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1449    
1450    VLC mcbpc_intra_tab[15] = {
1451            {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1452            {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1453            {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1454            {0x00, 0}, {0x03, 3}, {0x03, 6}
1455    };
1456    
1457    /* MCBPC inter.
1458       Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1459    
1460    VLC mcbpc_inter_tab[29] = {
1461            {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1462            {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1463            {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1464            {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1465    };
1466    
1467    const VLC xvid_cbpy_tab[16] = {
1468            {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1469            {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1470    };
1471    
1472    const VLC dcy_tab[511] = {
1473            {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1474            {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1475            {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1476            {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1477            {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1478            {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1479            {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1480            {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1481            {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1482            {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1483            {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1484            {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1485            {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1486            {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1487            {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1488            {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1489            {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1490            {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1491            {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1492            {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1493            {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1494            {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1495            {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1496            {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1497            {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1498            {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1499            {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1500            {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1501            {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1502            {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1503            {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1504            {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1505            {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1506            {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1507            {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1508            {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1509            {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1510            {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1511            {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1512            {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1513            {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1514            {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1515            {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1516            {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1517            {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1518            {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1519            {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1520            {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1521            {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1522            {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1523            {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1524            {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1525            {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1526            {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1527            {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1528            {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1529            {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1530            {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1531            {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1532            {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1533            {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1534            {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1535            {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1536            {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1537            {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1538            {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1539            {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1540            {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1541            {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1542            {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1543            {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1544            {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1545            {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1546            {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1547            {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1548            {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1549            {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1550            {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1551            {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1552            {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1553            {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1554            {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1555            {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1556            {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1557            {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1558            {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1559            {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1560            {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1561            {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1562            {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1563            {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1564            {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1565            {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1566            {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1567            {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1568            {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1569            {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1570            {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1571            {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1572            {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1573            {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1574            {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1575            {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1576            {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1577            {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1578            {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1579            {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1580            {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1581            {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1582            {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1583            {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1584            {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1585            {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1586            {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1587            {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1588            {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1589            {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1590            {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1591            {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1592            {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1593            {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1594            {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1595            {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1596            {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1597            {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1598            {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1599            {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1600            {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1601    };
1602    
1603    const VLC dcc_tab[511] = {
1604            {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1605            {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1606            {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1607            {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1608            {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1609            {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1610            {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1611            {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1612            {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1613            {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1614            {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1615            {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1616            {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1617            {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1618            {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1619            {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1620            {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1621            {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1622            {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1623            {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1624            {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1625            {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1626            {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1627            {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1628            {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1629            {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1630            {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1631            {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1632            {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1633            {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1634            {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1635            {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1636            {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1637            {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1638            {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1639            {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1640            {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1641            {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1642            {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1643            {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1644            {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1645            {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1646            {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1647            {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1648            {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1649            {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1650            {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1651            {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1652            {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1653            {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1654            {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1655            {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1656            {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1657            {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1658            {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1659            {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1660            {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1661            {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1662            {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1663            {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1664            {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1665            {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1666            {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1667            {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1668            {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1669            {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1670            {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1671            {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1672            {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1673            {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1674            {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1675            {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1676            {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1677            {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1678            {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1679            {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1680            {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1681            {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1682            {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1683            {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1684            {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1685            {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1686            {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1687            {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1688            {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1689            {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1690            {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1691            {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1692            {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1693            {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1694            {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1695            {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1696            {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1697            {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1698            {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1699            {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1700            {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1701            {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1702            {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1703            {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1704            {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1705            {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1706            {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1707            {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1708            {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1709            {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1710            {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1711            {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1712            {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1713            {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1714            {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1715            {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1716            {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1717            {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1718            {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1719            {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1720            {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1721            {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1722            {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1723            {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1724            {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1725            {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1726            {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1727            {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1728            {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1729            {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1730            {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1731            {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1732    };
1733    
1734    
1735    const VLC mb_motion_table[65] = {
1736            {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1737            {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1738            {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1739            {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1740            {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1741            {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1742            {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1743            {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1744            {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1745            {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1746            {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1747            {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1748            {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1749            {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1750            {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1751            {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1752            {0x04, 13}
1753    };
1754    
1755    
1756    /******************************************************************
1757     * decoder tables                                                 *
1758     ******************************************************************/
1759    
1760    VLC const mcbpc_intra_table[64] = {
1761            {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4},  {4, 4},  {4, 4},  {4, 4},
1762            {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1763            {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1764            {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
1765            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1766            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1767            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1768            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1}
1769    };
1770    
1771    VLC const mcbpc_inter_table[257] = {
1772            {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1773            {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1774            {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1775            {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1776            {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1777            {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1778            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1779            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1780            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1781            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1782            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1783            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1784            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1785            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1786            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1787            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1788            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1789            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1790            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1791            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1792            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1793            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1794            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1795            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1796            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1797            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1798            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1799            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1800            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1801            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1802            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1803            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1804            {0, 1}
1805    };
1806    
1807    VLC const cbpy_table[64] = {
1808            {-1, 0}, {-1, 0}, {6, 6},  {9, 6},  {8, 5},  {8, 5},  {4, 5},  {4, 5},
1809            {2, 5},  {2, 5},  {1, 5},  {1, 5},  {0, 4},  {0, 4},  {0, 4},  {0, 4},
1810            {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1811            {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4},  {5, 4},  {5, 4},  {5, 4},
1812            {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4},  {3, 4},  {3, 4},  {3, 4},
1813            {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4},  {7, 4},  {7, 4},  {7, 4},
1814            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1815            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1816    };
1817    
1818    VLC const TMNMVtab0[] = {
1819            {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1820            {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1821    };
1822    
1823    VLC const TMNMVtab1[] = {
1824            {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1825            {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1826            {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1827            {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1828            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1829            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1830            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1831            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1832            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1833            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1834            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1835            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1836            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1837            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1838            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1839            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1840            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1841            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1842            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1843            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1844            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1845            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1846            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1847            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
1848    };
1849    
1850    VLC const TMNMVtab2[] = {
1851            {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
1852            {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
1853            {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
1854            {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
1855            {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
1856            {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
1857            {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
1858            {24, 10}, {24, 10}, {24, 10}, {24, 10},
1859            {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
1860            {23, 10}, {23, 10}, {23, 10}, {23, 10},
1861            {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
1862            {22, 10}, {22, 10}, {22, 10}, {22, 10},
1863            {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
1864            {21, 10}, {21, 10}, {21, 10}, {21, 10},
1865            {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
1866            {20, 10}, {20, 10}, {20, 10}, {20, 10},
1867            {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
1868            {19, 10}, {19, 10}, {19, 10}, {19, 10},
1869            {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
1870            {18, 10}, {18, 10}, {18, 10}, {18, 10},
1871            {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
1872            {17, 10}, {17, 10}, {17, 10}, {17, 10},
1873            {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
1874            {16, 10}, {16, 10}, {16, 10}, {16, 10},
1875            {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
1876            {15, 10}, {15, 10}, {15, 10}, {15, 10},
1877            {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
1878            {14, 10}, {14, 10}, {14, 10}, {14, 10},
1879            {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
1880            {13, 10}, {13, 10}, {13, 10}, {13, 10},
1881            {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10}
1882    };
1883    
1884    short const dc_threshold[] = {
1885            21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,
1886             8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,
1887            25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,
1888            28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,
1889            30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,
1890            29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,
1891            26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,
1892            29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606
1893    };
1894    
1895    VLC const dc_lum_tab[] = {
1896            {0, 0}, {4, 3}, {3, 3}, {0, 3},
1897            {2, 2}, {2, 2}, {1, 2}, {1, 2},
1898    };
Legend:
Removed from v.1.25.2.11  
changed lines
  Added in v.1.46
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4