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