[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.42, Sat Feb 15 15:22:18 2003 UTC revision 1.48, Sun Aug 22 13:16:12 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    /* Initialized once during xvid_global call
42     * RO access is thread safe */
43  static REVERSE_EVENT DCT3D[2][4096];  static REVERSE_EVENT DCT3D[2][4096];
   
 #ifdef BIGLUT  
 static VLC coeff_VLC[2][2][4096][64];  
 VLC *intra_table;  
 static VLC *inter_table;  
 #else  
44  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
 #endif  
45    
46  /* not really MB related, but VLCs are only available here */  /* not really MB related, but VLCs are only available here */
47  void bs_put_spritetrajectory(Bitstream * bs, const int val)  void bs_put_spritetrajectory(Bitstream * bs, const int val)
# Line 86  Line 51 
51          const int code2 = sprite_trajectory_len[len].code;          const int code2 = sprite_trajectory_len[len].code;
52          const int len2 = sprite_trajectory_len[len].len;          const int len2 = sprite_trajectory_len[len].len;
53    
54  //      printf("GMC=%d Code/Len  = %d / %d ",val, code,len);  #if 0
55  //      printf("Code2 / Len2 = %d / %d \n",code2,len2);          printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
56            printf("Code2 / Len2 = %d / %d \n",code2,len2);
57    #endif
58    
59          BitstreamPutBits(bs, code2, len2);          BitstreamPutBits(bs, code2, len2);
60          if (len) BitstreamPutBits(bs, code, len);          if (len) BitstreamPutBits(bs, code, len);
# Line 113  Line 80 
80          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
81          int32_t l;          int32_t l;
82    
 #ifdef BIGLUT  
         intra_table = coeff_VLC[1];  
         inter_table = coeff_VLC[0];  
 #endif  
   
   
83          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++)
84                  for (i = 0; i < 4096; i++)                  for (i = 0; i < 4096; i++)
85                          DCT3D[intra][i].event.level = 0;                          DCT3D[intra][i].event.level = 0;
86    
87          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
88                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++) {
89                  {                          for (run = 0; run < 63 + last; run++) {
90                          for (run = 0; run < 63 + last; run++)                                  for (level = 0; level < (uint32_t)(32 << intra); level++) {
                                 for (level = 0; level < (uint32_t)(32 << intra); level++)  
                                 {  
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
91                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
92                                          coeff_VLC[intra][last][level + offset][run].len = 128;                                          coeff_VLC[intra][last][level + offset][run].len = 128;
93                                  }                                  }
94                  }                  }
95                    }
96            }
97    
98          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
99                  for (i = 0; i < 102; i++)                  for (i = 0; i < 102; i++) {
                 {  
 #ifdef BIGLUT  
                         offset = LEVELOFFSET;  
 #else  
100                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
101  #endif  
102                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++)                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++) {
                         {  
103                                  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;
104                                  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;
105                          }                          }
# Line 156  Line 108 
108                                  = coeff_tab[intra][i].vlc.code << 1;                                  = coeff_tab[intra][i].vlc.code << 1;
109                          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
110                                  = coeff_tab[intra][i].vlc.len + 1;                                  = coeff_tab[intra][i].vlc.len + 1;
111  #ifndef BIGLUT  
112                          if (!intra)                          if (!intra) {
 #endif  
                         {  
113                                  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
114                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
115                                  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
116                                          = coeff_tab[intra][i].vlc.len + 1;                                          = coeff_tab[intra][i].vlc.len + 1;
117                          }                          }
118                  }                  }
119            }
120    
121            for (intra = 0; intra < 2; intra++) {
122                    for (last = 0; last < 2; last++) {
123                            for (run = 0; run < 63 + last; run++) {
124                                    for (level = 1; level < (uint32_t)(32 << intra); level++) {
125    
         for (intra = 0; intra < 2; intra++)  
                 for (last = 0; last < 2; last++)  
                         for (run = 0; run < 63 + last; run++)  
                         {  
                                 for (level = 1; level < (uint32_t)(32 << intra); level++)  
                                 {  
126                                          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])
127                                              continue;                                              continue;
128    
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
129                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
130                      level_esc = level - max_level[intra][last][run];                      level_esc = level - max_level[intra][last][run];
131                                          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))*/  
132    
133                                          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]) {
                                         {  
134                                                  escape     = ESCAPE1;                                                  escape     = ESCAPE1;
135                                                  escape_len = 7 + 1;                                                  escape_len = 7 + 1;
136                                                  run_esc    = run;                                                  run_esc    = run;
137                                          }                                          } else {
138                                          else                                                  if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {
                                         {  
                                                 if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc])  
                                                 {  
139                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
140                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
141                                                          level_esc  = level;                                                          level_esc  = level;
142                                                  }                                                  } else {
143                                                  else                                                          if (!intra) {
                                                 {  
 #ifndef BIGLUT  
                                                         if (!intra)  
 #endif  
                                                         {  
144                                                                  coeff_VLC[intra][last][level + offset][run].code                                                                  coeff_VLC[intra][last][level + offset][run].code
145                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
146                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
147                                                                          coeff_VLC[intra][last][offset - level][run].code                                                                          coeff_VLC[intra][last][offset - level][run].code
148                                                                          = (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;
149                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;
150                                                          }                                                          }
151                                                          continue;                                                          continue;
# Line 224  Line 157 
157                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
158                                          coeff_VLC[intra][last][level + offset][run].len                                          coeff_VLC[intra][last][level + offset][run].len
159                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
160  #ifndef BIGLUT  
161                                          if (!intra)                                          if (!intra) {
 #endif  
                                         {  
162                                                  coeff_VLC[intra][last][offset - level][run].code                                                  coeff_VLC[intra][last][offset - level][run].code
163                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
164                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
# Line 236  Line 167 
167                                          }                                          }
168                                  }                                  }
169    
170  #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)  
                                 {  
171                                          coeff_VLC[intra][last][0][run].code                                          coeff_VLC[intra][last][0][run].code
172                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
173                                          coeff_VLC[intra][last][0][run].len = 30;                                          coeff_VLC[intra][last][0][run].len = 30;
174                                  }                                  }
 #endif  
175                          }                          }
176  /* init sprite_trajectory tables */                  }
177  /* even if GMC is not specified (it might be used later...) */          }
178    
179            /* init sprite_trajectory tables
180             * even if GMC is not specified (it might be used later...) */
181    
182          sprite_trajectory_code[0+16384].code = 0;          sprite_trajectory_code[0+16384].code = 0;
183          sprite_trajectory_code[0+16384].len = 0;          sprite_trajectory_code[0+16384].len = 0;
184          for (k=0;k<14;k++)          for (k=0;k<14;k++) {
         {  
185                  int limit = (1<<k);                  int limit = (1<<k);
186    
187                  for (l=-(2*limit-1); l <= -limit; l++)                  for (l=-(2*limit-1); l <= -limit; l++) {
                 {  
188                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
189                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
190                  }                  }
191    
192                  for (l=limit; l<= 2*limit-1; l++)                  for (l=limit; l<= 2*limit-1; l++) {
                 {  
193                          sprite_trajectory_code[l+16384].code = l;                          sprite_trajectory_code[l+16384].code = l;
194                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
195                  }                  }
# Line 334  Line 251 
251    
252  }  }
253    
 #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);  
   
 }  
   
   
   
 /* returns the number of bits required to encode qcoeff */  
 int  
 CodeCoeff_CalcBits(const int16_t qcoeff[64],  
                   VLC * table,  
                   const uint16_t * zigzag,  
                   uint16_t intra)  
 {  
         int bits = 0;  
         uint32_t j, last;  
         short v;  
         VLC *vlc;  
   
         j = intra;  
         last = intra;  
   
         while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                 j++;  
   
         if (j >= 64) return 0;  /* empty block */  
   
         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) {  
                         bits += vlc->len;  
                 } else {  
                         vlc += 64 * 4096;  
                         bits += vlc->len;  
                         break;  
                 }  
         } while (1);  
   
         return bits;  
 }  
   
   
 #else  
   
254  static __inline void  static __inline void
255  CodeCoeffInter(Bitstream * bs,  CodeCoeffInter(Bitstream * bs,
256                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 498  Line 329 
329          {          {
330                  if ((level = qcoeff[zigzag[i++]]) != 0)                  if ((level = qcoeff[zigzag[i++]]) != 0)
331                  {                  {
332                          abs_level = ABS(prev_level);                          abs_level = abs(prev_level);
333                          abs_level = abs_level < 64 ? abs_level : 0;                          abs_level = abs_level < 64 ? abs_level : 0;
334                          code      = coeff_VLC[1][0][abs_level][prev_run].code;                          code      = coeff_VLC[1][0][abs_level][prev_run].code;
335                          len               = coeff_VLC[1][0][abs_level][prev_run].len;                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
# Line 518  Line 349 
349                          run++;                          run++;
350          }          }
351    
352          abs_level = ABS(prev_level);          abs_level = abs(prev_level);
353          abs_level = abs_level < 64 ? abs_level : 0;          abs_level = abs_level < 64 ? abs_level : 0;
354          code      = coeff_VLC[1][1][abs_level][prev_run].code;          code      = coeff_VLC[1][1][abs_level][prev_run].code;
355          len               = coeff_VLC[1][1][abs_level][prev_run].len;          len               = coeff_VLC[1][1][abs_level][prev_run].len;
# Line 559  Line 390 
390          {          {
391                  if ((level = qcoeff[zigzag[i++]]) != 0)                  if ((level = qcoeff[zigzag[i++]]) != 0)
392                  {                  {
393                          abs_level = ABS(prev_level);                          abs_level = abs(prev_level);
394                          abs_level = abs_level < 64 ? abs_level : 0;                          abs_level = abs_level < 64 ? abs_level : 0;
395                          len               = coeff_VLC[1][0][abs_level][prev_run].len;                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
396                          bits      += len!=128 ? len : 30;                          bits      += len!=128 ? len : 30;
# Line 572  Line 403 
403                          run++;                          run++;
404          }          }
405    
406          abs_level = ABS(prev_level);          abs_level = abs(prev_level);
407          abs_level = abs_level < 64 ? abs_level : 0;          abs_level = abs_level < 64 ? abs_level : 0;
408          len               = coeff_VLC[1][1][abs_level][prev_run].len;          len               = coeff_VLC[1][1][abs_level][prev_run].len;
409          bits      += len!=128 ? len : 30;          bits      += len!=128 ? len : 30;
# Line 624  Line 455 
455          return bits;          return bits;
456  }  }
457    
458    static const int iDQtab[5] = {
459            1, 0, -1 /* no change */, 2, 3
460    };
461    #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
462    
 #endif  
463    
464  static __inline void  static __inline void
465  CodeBlockIntra(const FRAMEINFO * const frame,  CodeBlockIntra(const FRAMEINFO * const frame,
# Line 639  Line 473 
473    
474          cbpy = pMB->cbp >> 2;          cbpy = pMB->cbp >> 2;
475    
476          // write mcbpc          /* write mcbpc */
477          if (frame->coding_type == I_VOP) {          if (frame->coding_type == I_VOP) {
478                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
479                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
# Line 650  Line 484 
484                                                   mcbpc_inter_tab[mcbpc].len);                                                   mcbpc_inter_tab[mcbpc].len);
485          }          }
486    
487          // ac prediction flag          /* ac prediction flag */
488          if (pMB->acpred_directions[0])          if (pMB->acpred_directions[0])
489                  BitstreamPutBits(bs, 1, 1);                  BitstreamPutBits(bs, 1, 1);
490          else          else
491                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
492    
493          // write cbpy          /* write cbpy */
494          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
495    
496          // write dquant          /* write dquant */
497          if (pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA_Q)
498                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
499    
500          // write interlacing          /* write interlacing */
501          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
502                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
503          }          }
504          // code block coeffs          /* code block coeffs */
505          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
506                  if (i < 4)                  if (i < 4)
507                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
# Line 678  Line 512 
512    
513                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i))) {
514                          const uint16_t *scan_table =                          const uint16_t *scan_table =
515                                  frame->global_flags & XVID_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
516                                  scan_tables[2] : scan_tables[pMB->acpred_directions[i]];                                  scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
517    
518                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
519    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);  
 #else  
520                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
 #endif  
521    
522                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
523                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 711  Line 541 
541          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
542          cbpy = 15 - (pMB->cbp >> 2);          cbpy = 15 - (pMB->cbp >> 2);
543    
544          // write mcbpc          /* write mcbpc */
545          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
546                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
547    
548          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) )
549                  BitstreamPutBit(bs, pMB->mcsel);                // mcsel: '0'=local motion, '1'=GMC                  BitstreamPutBit(bs, pMB->mcsel);                /* mcsel: '0'=local motion, '1'=GMC */
550    
551          // write cbpy          /* write cbpy */
552          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
553    
554          // write dquant          /* write dquant */
555          if (pMB->mode == MODE_INTER_Q)          if (pMB->mode == MODE_INTER_Q)
556                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
557    
558          // interlacing          /* interlacing */
559          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
560                  if (pMB->cbp) {                  if (pMB->cbp) {
561                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
562                          DPRINTF(DPRINTF_MB,"codep: field_dct: %i", pMB->field_dct);                          DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);
563                  }                  }
564    
565                  // if inter block, write field ME flag                  /* if inter block, write field ME flag */
566                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
567                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
568                          DPRINTF(DPRINTF_MB,"codep: field_pred: %i", pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
569    
570                          // write field prediction references                          /* write field prediction references */
571    #if 0 /* Remove the #if once field_pred is supported */
572                          if (pMB->field_pred) {                          if (pMB->field_pred) {
573                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
574                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
575                          }                          }
576    #endif
577                  }                  }
578          }          }
579          // code motion vector(s) if motion is local          /* code motion vector(s) if motion is local  */
580          if (!pMB->mcsel)          if (!pMB->mcsel)
581                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
582                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
# Line 753  Line 585 
585    
586          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
587    
588          // code block coeffs          /* code block coeffs */
589          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
590                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
                 {  
591                          const uint16_t *scan_table =                          const uint16_t *scan_table =
592                                  frame->global_flags & XVID_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
593                                  scan_tables[2] : scan_tables[0];                                  scan_tables[2] : scan_tables[0];
594    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);  
 #else  
595                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
 #endif  
596                  }                  }
597    
598          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
# Line 781  Line 608 
608                   Statistics * pStat)                   Statistics * pStat)
609  {  {
610          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)
611                          BitstreamPutBit(bs, 0); // not_coded                          BitstreamPutBit(bs, 0); /* not_coded */
612    
613          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
614                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
# Line 790  Line 617 
617    
618  }  }
619    
 /*  
 // moved to mbcoding.h so that in can be 'static __inline'  
 void  
 MBSkip(Bitstream * bs)  
 {  
         BitstreamPutBit(bs, 1); // not coded  
 }  
 */  
   
620  /***************************************************************  /***************************************************************
621   * bframe encoding start   * bframe encoding start
622   ***************************************************************/   ***************************************************************/
# Line 855  Line 673 
673                  BitstreamPutBit(bs, 1);                  BitstreamPutBit(bs, 1);
674                  return;                  return;
675    
676          default:;                                       // invalid          default:;                                       /* invalid */
677          }          }
678  }  }
679    
680    
681    
682  void  void
683  MBCodingBVOP(const MACROBLOCK * mb,  MBCodingBVOP(const FRAMEINFO * const frame,
684                             const MACROBLOCK * mb,
685                           const int16_t qcoeff[6 * 64],                           const int16_t qcoeff[6 * 64],
686                           const int32_t fcode,                           const int32_t fcode,
687                           const int32_t bcode,                           const int32_t bcode,
688                           Bitstream * bs,                           Bitstream * bs,
689                           Statistics * pStat,                           Statistics * pStat)
                          int direction)  
690  {  {
691          int vcode = fcode;          int vcode = fcode;
692          unsigned int i;          unsigned int i;
693    
694            const uint16_t *scan_table =
695                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
696                    scan_tables[2] : scan_tables[0];
697            int bits;
698    
699    
700  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
701                  when a block is skipped it is decoded DIRECT(0,0)                  when a block is skipped it is decoded DIRECT(0,0)
702                  hence is interpolated from forward & backward frames                  hence is interpolated from forward & backward frames
703          ------------------------------------------------------------------ */          ------------------------------------------------------------------ */
704    
705          if (mb->mode == MODE_DIRECT_NONE_MV) {          if (mb->mode == MODE_DIRECT_NONE_MV) {
706                  BitstreamPutBit(bs, 1); // skipped                  BitstreamPutBit(bs, 1); /* skipped */
707                  return;                  return;
708          }          }
709    
710          BitstreamPutBit(bs, 0);         // not skipped          BitstreamPutBit(bs, 0);         /* not skipped */
711    
712          if (mb->cbp == 0) {          if (mb->cbp == 0) {
713                  BitstreamPutBit(bs, 1); // cbp == 0                  BitstreamPutBit(bs, 1); /* cbp == 0 */
714          } else {          } else {
715                  BitstreamPutBit(bs, 0); // cbp == xxx                  BitstreamPutBit(bs, 0); /* cbp == xxx */
716          }          }
717    
718          put_bvop_mbtype(bs, mb->mode);          put_bvop_mbtype(bs, mb->mode);
# Line 898  Line 722 
722          }          }
723    
724          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
725                  put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0                  put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */
726          }          }
727    
728            if (frame->vol_flags & XVID_VOL_INTERLACING) {
729                    if (mb->cbp) {
730                            BitstreamPutBit(bs, mb->field_dct);
731                            DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);
732                    }
733    
734                    /* if not direct block, write field ME flag */
735                    if (mb->mode != MODE_DIRECT) {
736                            BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
737    
738                            /* write field prediction references */
739    #if 0 /* Remove the #if once field_pred is supported */
740                            if (mb->field_pred) {
741                                    BitstreamPutBit(bs, mb->field_for_top);
742                                    BitstreamPutBit(bs, mb->field_for_bot);
743                            }
744    #endif
745                    }
746            }
747    
748    
749          switch (mb->mode) {          switch (mb->mode) {
750                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
751                          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 */
752                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
753                  case MODE_BACKWARD:                  case MODE_BACKWARD:
754                          vcode = bcode;                          vcode = bcode;
# Line 912  Line 757 
757                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
758                          break;                          break;
759                  case MODE_DIRECT:                  case MODE_DIRECT:
760                          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 */
761                          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) */
762                  default: break;                  default: break;
763          }          }
764    
765            bits = BitstreamPos(bs);
766          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
767                  if (mb->cbp & (1 << (5 - i))) {                  if (mb->cbp & (1 << (5 - i))) {
768  #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  
769                  }                  }
770          }          }
771            pStat->iTextBits += BitstreamPos(bs) - bits;
772  }  }
773    
774    
# Line 935  Line 778 
778   ***************************************************************/   ***************************************************************/
779    
780    
781  // for IVOP addbits == 0  /*
782  // for PVOP addbits == fcode - 1   * for IVOP addbits == 0
783  // for BVOP addbits == max(fcode,bcode) - 1   * for PVOP addbits == fcode - 1
784  // returns true or false   * for BVOP addbits == max(fcode,bcode) - 1
785     * returns true or false
786     */
787  int  int
788  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
789  {  {
# Line 1052  Line 897 
897                  return data;                  return data;
898    
899          res = BitstreamGetBits(bs, fcode - 1);          res = BitstreamGetBits(bs, fcode - 1);
900          mv = ((ABS(data) - 1) * scale_fac) + res + 1;          mv = ((abs(data) - 1) * scale_fac) + res + 1;
901    
902          return data < 0 ? -mv : mv;          return data < 0 ? -mv : mv;
903    
# Line 1115  Line 960 
960    
961  }  }
962    
963    #define GET_BITS(cache, n) ((cache)>>(32-(n)))
964    
965  static __inline int  static __inline int
966  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
967                    int *run,                    int *run,
# Line 1127  Line 974 
974          int32_t level;          int32_t level;
975          REVERSE_EVENT *reverse_event;          REVERSE_EVENT *reverse_event;
976    
977            uint32_t cache = BitstreamShowBits(bs, 32);
978    
979          if (short_video_header)         /* inter-VLCs will be used for both intra and inter blocks */          if (short_video_header)         /* inter-VLCs will be used for both intra and inter blocks */
980                  intra = 0;                  intra = 0;
981    
982          if (BitstreamShowBits(bs, 7) != ESCAPE) {          if (GET_BITS(cache, 7) != ESCAPE) {
983                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
984    
985                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
986                          goto error;                          goto error;
# Line 1139  Line 988 
988                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
989                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
990    
991                  BitstreamSkip(bs, reverse_event->len);                  /* Don't forget to update the bitstream position */
992                    BitstreamSkip(bs, reverse_event->len+1);
993    
994                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
995          }          }
996    
997          BitstreamSkip(bs, 7);          /* flush 7bits of cache */
998            cache <<= 7;
999    
1000          if (short_video_header) {          if (short_video_header) {
1001                  /* escape mode 4 - H.263 type, only used if short_video_header = 1  */                  /* escape mode 4 - H.263 type, only used if short_video_header = 1  */
1002                  *last = BitstreamGetBit(bs);                  *last =  GET_BITS(cache, 1);
1003                  *run = BitstreamGetBits(bs, 6);                  *run  = (GET_BITS(cache, 7) &0x3f);
1004                  level = BitstreamGetBits(bs, 8);                  level = (GET_BITS(cache, 15)&0xff);
1005    
1006                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1007                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1008    
1009                    /* We've "eaten" 22 bits */
1010                    BitstreamSkip(bs, 22);
1011    
1012                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1013          }          }
1014    
1015          mode = BitstreamShowBits(bs, 2);          if ((mode = GET_BITS(cache, 2)) < 3) {
1016                    const int skip[3] = {1, 1, 2};
1017                    cache <<= skip[mode];
1018    
1019          if (mode < 3) {                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
   
                 reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];  
1020    
1021                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1022                          goto error;                          goto error;
# Line 1171  Line 1024 
1024                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1025                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1026    
1027                  BitstreamSkip(bs, reverse_event->len);                  if (mode < 2) {
1028                            /* first escape mode, level is offset */
                 if (mode < 2)                   /* first escape mode, level is offset */  
1029                          level += max_level[intra][*last][*run];                          level += max_level[intra][*last][*run];
1030                  else                                    /* second escape mode, run is offset */                  } else {
1031                            /* second escape mode, run is offset */
1032                          *run += max_run[intra][*last][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1033                    }
1034    
1035                    /* Update bitstream position */
1036                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1037    
1038                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1039          }          }
1040    
1041          /* third escape mode - fixed length codes */          /* third escape mode - fixed length codes */
1042          BitstreamSkip(bs, 2);          cache <<= 2;
1043          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1044          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1045          BitstreamSkip(bs, 1);           /* marker */          level = (GET_BITS(cache, 20)&0xfff);
1046          level = BitstreamGetBits(bs, 12);  
1047          BitstreamSkip(bs, 1);           /* marker */          /* Update bitstream position */
1048            BitstreamSkip(bs, 30);
1049    
1050          return (level << 20) >> 20;          return (level << 20) >> 20;
1051    
# Line 1209  Line 1067 
1067          do {          do {
1068                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1069                  if (run == -1) {                  if (run == -1) {
1070                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1071                          break;                          break;
1072                  }                  }
1073                  coeff += run;                  coeff += run;
1074                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1075    
1076                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1077                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));  #if 0
1078                    DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1079    #endif
1080    
1081                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1082                          DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1083                  }                  }
1084                  coeff++;                  coeff++;
1085          } while (!last);          } while (!last);
# Line 1227  Line 1087 
1087  }  }
1088    
1089  void  void
1090  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1091                    Bitstream * bs,
1092                                  int16_t * block,                                  int16_t * block,
1093                                  int direction)                  int direction,
1094                    const int quant,
1095                    const uint16_t *matrix)
1096  {  {
1097    
1098          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1099            const uint16_t quant_m_2 = quant << 1;
1100            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1101          int p;          int p;
1102          int level;          int level;
1103          int run;          int run;
# Line 1242  Line 1107 
1107          do {          do {
1108                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1109                  if (run == -1) {                  if (run == -1) {
1110                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1111                          break;                          break;
1112                  }                  }
1113                  p += run;                  p += run;
1114    
1115                  block[scan[p]] = level;                  if (level < 0) {
1116                            level = level*quant_m_2 - quant_add;
1117                            block[scan[p]] = (level >= -2048 ? level : -2048);
1118                    } else {
1119                            level = level * quant_m_2 + quant_add;
1120                            block[scan[p]] = (level <= 2047 ? level : 2047);
1121                    }
1122                    p++;
1123            } while (!last);
1124    }
1125    
1126                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);  void
1127                  // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));  get_inter_block_mpeg(
1128                    Bitstream * bs,
1129                    int16_t * block,
1130                    int direction,
1131                    const int quant,
1132                    const uint16_t *matrix)
1133    {
1134            const uint16_t *scan = scan_tables[direction];
1135            uint32_t sum = 0;
1136            int p;
1137            int level;
1138            int run;
1139            int last;
1140    
1141                  if (level < -2047 || level > 2047) {          p = 0;
1142                          DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);          do {
1143                    level = get_coeff(bs, &run, &last, 0, 0);
1144                    if (run == -1) {
1145                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1146                            break;
1147                    }
1148                    p += run;
1149    
1150                    if (level < 0) {
1151                            level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1152                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1153                    } else {
1154                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1155                            block[scan[p]] = (level <= 2047 ? level : 2047);
1156                  }                  }
1157    
1158                    sum ^= block[scan[p]];
1159    
1160                  p++;                  p++;
1161          } while (!last);          } while (!last);
1162    
1163  }          /*      mismatch control */
1164            if ((sum & 1) == 0) {
1165                    block[63] ^= 1;
1166            }
1167    }
1168    
1169    
1170    /*****************************************************************************
1171     * VLC tables and other constant arrays
1172     ****************************************************************************/
1173    
1174    VLC_TABLE const coeff_tab[2][102] =
1175    {
1176            /* intra = 0 */
1177            {
1178                    {{ 2,  2}, {0, 0, 1}},
1179                    {{15,  4}, {0, 0, 2}},
1180                    {{21,  6}, {0, 0, 3}},
1181                    {{23,  7}, {0, 0, 4}},
1182                    {{31,  8}, {0, 0, 5}},
1183                    {{37,  9}, {0, 0, 6}},
1184                    {{36,  9}, {0, 0, 7}},
1185                    {{33, 10}, {0, 0, 8}},
1186                    {{32, 10}, {0, 0, 9}},
1187                    {{ 7, 11}, {0, 0, 10}},
1188                    {{ 6, 11}, {0, 0, 11}},
1189                    {{32, 11}, {0, 0, 12}},
1190                    {{ 6,  3}, {0, 1, 1}},
1191                    {{20,  6}, {0, 1, 2}},
1192                    {{30,  8}, {0, 1, 3}},
1193                    {{15, 10}, {0, 1, 4}},
1194                    {{33, 11}, {0, 1, 5}},
1195                    {{80, 12}, {0, 1, 6}},
1196                    {{14,  4}, {0, 2, 1}},
1197                    {{29,  8}, {0, 2, 2}},
1198                    {{14, 10}, {0, 2, 3}},
1199                    {{81, 12}, {0, 2, 4}},
1200                    {{13,  5}, {0, 3, 1}},
1201                    {{35,  9}, {0, 3, 2}},
1202                    {{13, 10}, {0, 3, 3}},
1203                    {{12,  5}, {0, 4, 1}},
1204                    {{34,  9}, {0, 4, 2}},
1205                    {{82, 12}, {0, 4, 3}},
1206                    {{11,  5}, {0, 5, 1}},
1207                    {{12, 10}, {0, 5, 2}},
1208                    {{83, 12}, {0, 5, 3}},
1209                    {{19,  6}, {0, 6, 1}},
1210                    {{11, 10}, {0, 6, 2}},
1211                    {{84, 12}, {0, 6, 3}},
1212                    {{18,  6}, {0, 7, 1}},
1213                    {{10, 10}, {0, 7, 2}},
1214                    {{17,  6}, {0, 8, 1}},
1215                    {{ 9, 10}, {0, 8, 2}},
1216                    {{16,  6}, {0, 9, 1}},
1217                    {{ 8, 10}, {0, 9, 2}},
1218                    {{22,  7}, {0, 10, 1}},
1219                    {{85, 12}, {0, 10, 2}},
1220                    {{21,  7}, {0, 11, 1}},
1221                    {{20,  7}, {0, 12, 1}},
1222                    {{28,  8}, {0, 13, 1}},
1223                    {{27,  8}, {0, 14, 1}},
1224                    {{33,  9}, {0, 15, 1}},
1225                    {{32,  9}, {0, 16, 1}},
1226                    {{31,  9}, {0, 17, 1}},
1227                    {{30,  9}, {0, 18, 1}},
1228                    {{29,  9}, {0, 19, 1}},
1229                    {{28,  9}, {0, 20, 1}},
1230                    {{27,  9}, {0, 21, 1}},
1231                    {{26,  9}, {0, 22, 1}},
1232                    {{34, 11}, {0, 23, 1}},
1233                    {{35, 11}, {0, 24, 1}},
1234                    {{86, 12}, {0, 25, 1}},
1235                    {{87, 12}, {0, 26, 1}},
1236                    {{ 7,  4}, {1, 0, 1}},
1237                    {{25,  9}, {1, 0, 2}},
1238                    {{ 5, 11}, {1, 0, 3}},
1239                    {{15,  6}, {1, 1, 1}},
1240                    {{ 4, 11}, {1, 1, 2}},
1241                    {{14,  6}, {1, 2, 1}},
1242                    {{13,  6}, {1, 3, 1}},
1243                    {{12,  6}, {1, 4, 1}},
1244                    {{19,  7}, {1, 5, 1}},
1245                    {{18,  7}, {1, 6, 1}},
1246                    {{17,  7}, {1, 7, 1}},
1247                    {{16,  7}, {1, 8, 1}},
1248                    {{26,  8}, {1, 9, 1}},
1249                    {{25,  8}, {1, 10, 1}},
1250                    {{24,  8}, {1, 11, 1}},
1251                    {{23,  8}, {1, 12, 1}},
1252                    {{22,  8}, {1, 13, 1}},
1253                    {{21,  8}, {1, 14, 1}},
1254                    {{20,  8}, {1, 15, 1}},
1255                    {{19,  8}, {1, 16, 1}},
1256                    {{24,  9}, {1, 17, 1}},
1257                    {{23,  9}, {1, 18, 1}},
1258                    {{22,  9}, {1, 19, 1}},
1259                    {{21,  9}, {1, 20, 1}},
1260                    {{20,  9}, {1, 21, 1}},
1261                    {{19,  9}, {1, 22, 1}},
1262                    {{18,  9}, {1, 23, 1}},
1263                    {{17,  9}, {1, 24, 1}},
1264                    {{ 7, 10}, {1, 25, 1}},
1265                    {{ 6, 10}, {1, 26, 1}},
1266                    {{ 5, 10}, {1, 27, 1}},
1267                    {{ 4, 10}, {1, 28, 1}},
1268                    {{36, 11}, {1, 29, 1}},
1269                    {{37, 11}, {1, 30, 1}},
1270                    {{38, 11}, {1, 31, 1}},
1271                    {{39, 11}, {1, 32, 1}},
1272                    {{88, 12}, {1, 33, 1}},
1273                    {{89, 12}, {1, 34, 1}},
1274                    {{90, 12}, {1, 35, 1}},
1275                    {{91, 12}, {1, 36, 1}},
1276                    {{92, 12}, {1, 37, 1}},
1277                    {{93, 12}, {1, 38, 1}},
1278                    {{94, 12}, {1, 39, 1}},
1279                    {{95, 12}, {1, 40, 1}}
1280            },
1281            /* intra = 1 */
1282            {
1283                    {{ 2,  2}, {0, 0, 1}},
1284                    {{15,  4}, {0, 0, 3}},
1285                    {{21,  6}, {0, 0, 6}},
1286                    {{23,  7}, {0, 0, 9}},
1287                    {{31,  8}, {0, 0, 10}},
1288                    {{37,  9}, {0, 0, 13}},
1289                    {{36,  9}, {0, 0, 14}},
1290                    {{33, 10}, {0, 0, 17}},
1291                    {{32, 10}, {0, 0, 18}},
1292                    {{ 7, 11}, {0, 0, 21}},
1293                    {{ 6, 11}, {0, 0, 22}},
1294                    {{32, 11}, {0, 0, 23}},
1295                    {{ 6,  3}, {0, 0, 2}},
1296                    {{20,  6}, {0, 1, 2}},
1297                    {{30,  8}, {0, 0, 11}},
1298                    {{15, 10}, {0, 0, 19}},
1299                    {{33, 11}, {0, 0, 24}},
1300                    {{80, 12}, {0, 0, 25}},
1301                    {{14,  4}, {0, 1, 1}},
1302                    {{29,  8}, {0, 0, 12}},
1303                    {{14, 10}, {0, 0, 20}},
1304                    {{81, 12}, {0, 0, 26}},
1305                    {{13,  5}, {0, 0, 4}},
1306                    {{35,  9}, {0, 0, 15}},
1307                    {{13, 10}, {0, 1, 7}},
1308                    {{12,  5}, {0, 0, 5}},
1309                    {{34,  9}, {0, 4, 2}},
1310                    {{82, 12}, {0, 0, 27}},
1311                    {{11,  5}, {0, 2, 1}},
1312                    {{12, 10}, {0, 2, 4}},
1313                    {{83, 12}, {0, 1, 9}},
1314                    {{19,  6}, {0, 0, 7}},
1315                    {{11, 10}, {0, 3, 4}},
1316                    {{84, 12}, {0, 6, 3}},
1317                    {{18,  6}, {0, 0, 8}},
1318                    {{10, 10}, {0, 4, 3}},
1319                    {{17,  6}, {0, 3, 1}},
1320                    {{ 9, 10}, {0, 8, 2}},
1321                    {{16,  6}, {0, 4, 1}},
1322                    {{ 8, 10}, {0, 5, 3}},
1323                    {{22,  7}, {0, 1, 3}},
1324                    {{85, 12}, {0, 1, 10}},
1325                    {{21,  7}, {0, 2, 2}},
1326                    {{20,  7}, {0, 7, 1}},
1327                    {{28,  8}, {0, 1, 4}},
1328                    {{27,  8}, {0, 3, 2}},
1329                    {{33,  9}, {0, 0, 16}},
1330                    {{32,  9}, {0, 1, 5}},
1331                    {{31,  9}, {0, 1, 6}},
1332                    {{30,  9}, {0, 2, 3}},
1333                    {{29,  9}, {0, 3, 3}},
1334                    {{28,  9}, {0, 5, 2}},
1335                    {{27,  9}, {0, 6, 2}},
1336                    {{26,  9}, {0, 7, 2}},
1337                    {{34, 11}, {0, 1, 8}},
1338                    {{35, 11}, {0, 9, 2}},
1339                    {{86, 12}, {0, 2, 5}},
1340                    {{87, 12}, {0, 7, 3}},
1341                    {{ 7,  4}, {1, 0, 1}},
1342                    {{25,  9}, {0, 11, 1}},
1343                    {{ 5, 11}, {1, 0, 6}},
1344                    {{15,  6}, {1, 1, 1}},
1345                    {{ 4, 11}, {1, 0, 7}},
1346                    {{14,  6}, {1, 2, 1}},
1347                    {{13,  6}, {0, 5, 1}},
1348                    {{12,  6}, {1, 0, 2}},
1349                    {{19,  7}, {1, 5, 1}},
1350                    {{18,  7}, {0, 6, 1}},
1351                    {{17,  7}, {1, 3, 1}},
1352                    {{16,  7}, {1, 4, 1}},
1353                    {{26,  8}, {1, 9, 1}},
1354                    {{25,  8}, {0, 8, 1}},
1355                    {{24,  8}, {0, 9, 1}},
1356                    {{23,  8}, {0, 10, 1}},
1357                    {{22,  8}, {1, 0, 3}},
1358                    {{21,  8}, {1, 6, 1}},
1359                    {{20,  8}, {1, 7, 1}},
1360                    {{19,  8}, {1, 8, 1}},
1361                    {{24,  9}, {0, 12, 1}},
1362                    {{23,  9}, {1, 0, 4}},
1363                    {{22,  9}, {1, 1, 2}},
1364                    {{21,  9}, {1, 10, 1}},
1365                    {{20,  9}, {1, 11, 1}},
1366                    {{19,  9}, {1, 12, 1}},
1367                    {{18,  9}, {1, 13, 1}},
1368                    {{17,  9}, {1, 14, 1}},
1369                    {{ 7, 10}, {0, 13, 1}},
1370                    {{ 6, 10}, {1, 0, 5}},
1371                    {{ 5, 10}, {1, 1, 3}},
1372                    {{ 4, 10}, {1, 2, 2}},
1373                    {{36, 11}, {1, 3, 2}},
1374                    {{37, 11}, {1, 4, 2}},
1375                    {{38, 11}, {1, 15, 1}},
1376                    {{39, 11}, {1, 16, 1}},
1377                    {{88, 12}, {0, 14, 1}},
1378                    {{89, 12}, {1, 0, 8}},
1379                    {{90, 12}, {1, 5, 2}},
1380                    {{91, 12}, {1, 6, 2}},
1381                    {{92, 12}, {1, 17, 1}},
1382                    {{93, 12}, {1, 18, 1}},
1383                    {{94, 12}, {1, 19, 1}},
1384                    {{95, 12}, {1, 20, 1}}
1385            }
1386    };
1387    
1388    /* constants taken from momusys/vm_common/inlcude/max_level.h */
1389    uint8_t const max_level[2][2][64] = {
1390            {
1391                    /* intra = 0, last = 0 */
1392                    {
1393                            12, 6, 4, 3, 3, 3, 3, 2,
1394                            2, 2, 2, 1, 1, 1, 1, 1,
1395                            1, 1, 1, 1, 1, 1, 1, 1,
1396                            1, 1, 1, 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                    },
1402                    /* intra = 0, last = 1 */
1403                    {
1404                            3, 2, 1, 1, 1, 1, 1, 1,
1405                            1, 1, 1, 1, 1, 1, 1, 1,
1406                            1, 1, 1, 1, 1, 1, 1, 1,
1407                            1, 1, 1, 1, 1, 1, 1, 1,
1408                            1, 1, 1, 1, 1, 1, 1, 1,
1409                            1, 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                    }
1413            },
1414            {
1415                    /* intra = 1, last = 0 */
1416                    {
1417                            27, 10, 5, 4, 3, 3, 3, 3,
1418                            2, 2, 1, 1, 1, 1, 1, 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                    },
1426                    /* intra = 1, last = 1 */
1427                    {
1428                            8, 3, 2, 2, 2, 2, 2, 1,
1429                            1, 1, 1, 1, 1, 1, 1, 1,
1430                            1, 1, 1, 1, 1, 0, 0, 0,
1431                            0, 0, 0, 0, 0, 0, 0, 0,
1432                            0, 0, 0, 0, 0, 0, 0, 0,
1433                            0, 0, 0, 0, 0, 0, 0, 0,
1434                            0, 0, 0, 0, 0, 0, 0, 0,
1435                            0, 0, 0, 0, 0, 0, 0, 0
1436                    }
1437            }
1438    };
1439    
1440    uint8_t const max_run[2][2][64] = {
1441            {
1442                    /* intra = 0, last = 0 */
1443                    {
1444                            0, 26, 10, 6, 2, 1, 1, 0,
1445                            0, 0, 0, 0, 0, 0, 0, 0,
1446                            0, 0, 0, 0, 0, 0, 0, 0,
1447                            0, 0, 0, 0, 0, 0, 0, 0,
1448                            0, 0, 0, 0, 0, 0, 0, 0,
1449                            0, 0, 0, 0, 0, 0, 0, 0,
1450                            0, 0, 0, 0, 0, 0, 0, 0,
1451                            0, 0, 0, 0, 0, 0, 0, 0,
1452                    },
1453                    /* intra = 0, last = 1 */
1454                    {
1455                            0, 40, 1, 0, 0, 0, 0, 0,
1456                            0, 0, 0, 0, 0, 0, 0, 0,
1457                            0, 0, 0, 0, 0, 0, 0, 0,
1458                            0, 0, 0, 0, 0, 0, 0, 0,
1459                            0, 0, 0, 0, 0, 0, 0, 0,
1460                            0, 0, 0, 0, 0, 0, 0, 0,
1461                            0, 0, 0, 0, 0, 0, 0, 0,
1462                            0, 0, 0, 0, 0, 0, 0, 0,
1463                    }
1464            },
1465            {
1466                    /* intra = 1, last = 0 */
1467                    {
1468                            0, 14, 9, 7, 3, 2, 1, 1,
1469                            1, 1, 1, 0, 0, 0, 0, 0,
1470                            0, 0, 0, 0, 0, 0, 0, 0,
1471                            0, 0, 0, 0, 0, 0, 0, 0,
1472                            0, 0, 0, 0, 0, 0, 0, 0,
1473                            0, 0, 0, 0, 0, 0, 0, 0,
1474                            0, 0, 0, 0, 0, 0, 0, 0,
1475                            0, 0, 0, 0, 0, 0, 0, 0,
1476                    },
1477                    /* intra = 1, last = 1 */
1478                    {
1479                            0, 20, 6, 1, 0, 0, 0, 0,
1480                            0, 0, 0, 0, 0, 0, 0, 0,
1481                            0, 0, 0, 0, 0, 0, 0, 0,
1482                            0, 0, 0, 0, 0, 0, 0, 0,
1483                            0, 0, 0, 0, 0, 0, 0, 0,
1484                            0, 0, 0, 0, 0, 0, 0, 0,
1485                            0, 0, 0, 0, 0, 0, 0, 0,
1486                            0, 0, 0, 0, 0, 0, 0, 0,
1487                    }
1488            }
1489    };
1490    
1491    /******************************************************************
1492     * encoder tables                                                 *
1493     ******************************************************************/
1494    
1495    VLC sprite_trajectory_code[32768];
1496    
1497    VLC sprite_trajectory_len[15] = {
1498            { 0x00 , 2},
1499            { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1500            { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},
1501            { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1502    
1503    
1504    /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1505       the sign bit must be added afterwards. */
1506    
1507    /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1508     CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1509     Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1510    
1511    VLC mcbpc_intra_tab[15] = {
1512            {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1513            {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1514            {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1515            {0x00, 0}, {0x03, 3}, {0x03, 6}
1516    };
1517    
1518    /* MCBPC inter.
1519       Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1520    
1521    VLC mcbpc_inter_tab[29] = {
1522            {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1523            {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1524            {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1525            {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1526    };
1527    
1528    const VLC xvid_cbpy_tab[16] = {
1529            {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1530            {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1531    };
1532    
1533    const VLC dcy_tab[511] = {
1534            {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1535            {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1536            {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1537            {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1538            {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1539            {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1540            {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1541            {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1542            {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1543            {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1544            {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1545            {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1546            {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1547            {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1548            {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1549            {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1550            {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1551            {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1552            {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1553            {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1554            {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1555            {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1556            {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1557            {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1558            {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1559            {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1560            {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1561            {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1562            {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1563            {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1564            {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1565            {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1566            {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1567            {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1568            {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1569            {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1570            {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1571            {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1572            {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1573            {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1574            {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1575            {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1576            {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1577            {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1578            {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1579            {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1580            {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1581            {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1582            {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1583            {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1584            {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1585            {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1586            {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1587            {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1588            {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1589            {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1590            {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1591            {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1592            {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1593            {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1594            {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1595            {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1596            {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1597            {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1598            {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1599            {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1600            {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1601            {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1602            {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1603            {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1604            {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1605            {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1606            {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1607            {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1608            {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1609            {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1610            {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1611            {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1612            {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1613            {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1614            {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1615            {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1616            {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1617            {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1618            {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1619            {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1620            {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1621            {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1622            {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1623            {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1624            {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1625            {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1626            {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1627            {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1628            {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1629            {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1630            {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1631            {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1632            {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1633            {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1634            {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1635            {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1636            {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1637            {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1638            {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1639            {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1640            {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1641            {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1642            {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1643            {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1644            {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1645            {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1646            {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1647            {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1648            {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1649            {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1650            {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1651            {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1652            {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1653            {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1654            {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1655            {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1656            {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1657            {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1658            {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1659            {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1660            {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1661            {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1662    };
1663    
1664    const VLC dcc_tab[511] = {
1665            {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1666            {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1667            {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1668            {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1669            {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1670            {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1671            {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1672            {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1673            {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1674            {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1675            {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1676            {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1677            {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1678            {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1679            {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1680            {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1681            {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1682            {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1683            {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1684            {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1685            {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1686            {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1687            {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1688            {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1689            {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1690            {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1691            {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1692            {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1693            {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1694            {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1695            {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1696            {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1697            {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1698            {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1699            {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1700            {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1701            {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1702            {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1703            {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1704            {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1705            {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1706            {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1707            {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1708            {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1709            {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1710            {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1711            {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1712            {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1713            {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1714            {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1715            {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1716            {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1717            {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1718            {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1719            {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1720            {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1721            {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1722            {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1723            {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1724            {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1725            {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1726            {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1727            {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1728            {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1729            {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1730            {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1731            {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1732            {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1733            {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1734            {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1735            {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1736            {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1737            {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1738            {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1739            {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1740            {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1741            {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1742            {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1743            {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1744            {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1745            {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1746            {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1747            {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1748            {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1749            {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1750            {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1751            {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1752            {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1753            {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1754            {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1755            {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1756            {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1757            {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1758            {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1759            {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1760            {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1761            {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1762            {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1763            {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1764            {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1765            {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1766            {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1767            {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1768            {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1769            {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1770            {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1771            {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1772            {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1773            {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1774            {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1775            {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1776            {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1777            {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1778            {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1779            {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1780            {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1781            {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1782            {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1783            {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1784            {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1785            {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1786            {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1787            {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1788            {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1789            {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1790            {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1791            {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1792            {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1793    };
1794    
1795    
1796    const VLC mb_motion_table[65] = {
1797            {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1798            {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1799            {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1800            {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1801            {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1802            {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1803            {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1804            {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1805            {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1806            {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1807            {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1808            {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1809            {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1810            {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1811            {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1812            {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1813            {0x04, 13}
1814    };
1815    
1816    
1817    /******************************************************************
1818     * decoder tables                                                 *
1819     ******************************************************************/
1820    
1821    VLC const mcbpc_intra_table[64] = {
1822            {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4},  {4, 4},  {4, 4},  {4, 4},
1823            {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1824            {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1825            {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
1826            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1827            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1828            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1829            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1}
1830    };
1831    
1832    VLC const mcbpc_inter_table[257] = {
1833            {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1834            {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1835            {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1836            {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1837            {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1838            {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1839            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1840            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1841            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1842            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1843            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1844            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1845            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1846            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1847            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1848            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1849            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1850            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1851            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1852            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1853            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1854            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1855            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1856            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1857            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1858            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1859            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1860            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1861            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1862            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1863            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1864            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1865            {0, 1}
1866    };
1867    
1868    VLC const cbpy_table[64] = {
1869            {-1, 0}, {-1, 0}, {6, 6},  {9, 6},  {8, 5},  {8, 5},  {4, 5},  {4, 5},
1870            {2, 5},  {2, 5},  {1, 5},  {1, 5},  {0, 4},  {0, 4},  {0, 4},  {0, 4},
1871            {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1872            {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4},  {5, 4},  {5, 4},  {5, 4},
1873            {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4},  {3, 4},  {3, 4},  {3, 4},
1874            {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4},  {7, 4},  {7, 4},  {7, 4},
1875            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1876            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1877    };
1878    
1879    VLC const TMNMVtab0[] = {
1880            {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1881            {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1882    };
1883    
1884    VLC const TMNMVtab1[] = {
1885            {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1886            {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1887            {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1888            {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1889            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1890            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1891            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1892            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1893            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1894            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1895            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1896            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1897            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1898            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1899            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1900            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1901            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1902            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1903            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1904            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1905            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1906            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1907            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1908            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
1909    };
1910    
1911    VLC const TMNMVtab2[] = {
1912            {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
1913            {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
1914            {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
1915            {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
1916            {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
1917            {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
1918            {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
1919            {24, 10}, {24, 10}, {24, 10}, {24, 10},
1920            {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
1921            {23, 10}, {23, 10}, {23, 10}, {23, 10},
1922            {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
1923            {22, 10}, {22, 10}, {22, 10}, {22, 10},
1924            {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
1925            {21, 10}, {21, 10}, {21, 10}, {21, 10},
1926            {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
1927            {20, 10}, {20, 10}, {20, 10}, {20, 10},
1928            {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
1929            {19, 10}, {19, 10}, {19, 10}, {19, 10},
1930            {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
1931            {18, 10}, {18, 10}, {18, 10}, {18, 10},
1932            {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
1933            {17, 10}, {17, 10}, {17, 10}, {17, 10},
1934            {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
1935            {16, 10}, {16, 10}, {16, 10}, {16, 10},
1936            {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
1937            {15, 10}, {15, 10}, {15, 10}, {15, 10},
1938            {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
1939            {14, 10}, {14, 10}, {14, 10}, {14, 10},
1940            {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
1941            {13, 10}, {13, 10}, {13, 10}, {13, 10},
1942            {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10}
1943    };
1944    
1945    short const dc_threshold[] = {
1946            21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,
1947             8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,
1948            25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,
1949            28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,
1950            30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,
1951            29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,
1952            26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,
1953            29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606
1954    };
1955    
1956    VLC const dc_lum_tab[] = {
1957            {0, 0}, {4, 3}, {3, 3}, {0, 3},
1958            {2, 2}, {2, 2}, {1, 2}, {1, 2},
1959    };
Legend:
Removed from v.1.42  
changed lines
  Added in v.1.48
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4