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

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

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

revision 809, Sun Jan 26 01:44:44 2003 UTC revision 1486, Sat Jul 10 17:49:31 2004 UTC
# Line 1  Line 1 
1  /*****************************************************************************  /*****************************************************************************
2   *   *
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  - Macro Block coding functions -   *  - MB coding -
5   *   *
6   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
7   *   *
8   *  This file is part of XviD, a free MPEG-4 video encoder/decoder   *  This program is free software ; you can redistribute it and/or modify
9   *   *  it under the terms of the GNU General Public License as published by
  *  XviD is free software; you can redistribute it and/or modify it  
  *  under the terms of the GNU General Public License as published by  
10   *  the Free Software Foundation; either version 2 of the License, or   *  the Free Software Foundation; either version 2 of the License, or
11   *  (at your option) any later version.   *  (at your option) any later version.
12   *   *
# Line 21  Line 19 
19   *  along with this program; if not, write to the Free Software   *  along with this program; if not, write to the Free Software
20   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21   *   *
22   *  Under section 8 of the GNU General Public License, the copyright   * $Id: mbcoding.c,v 1.47 2004-07-10 17:49:31 edgomez Exp $
  *  holders of XVID explicitly forbid distribution in the following  
  *  countries:  
  *  
  *    - Japan  
  *    - United States of America  
  *  
  *  Linking XviD statically or dynamically with other modules is making a  
  *  combined work based on XviD.  Thus, the terms and conditions of the  
  *  GNU General Public License cover the whole combination.  
  *  
  *  As a special exception, the copyright holders of XviD give you  
  *  permission to link XviD with independent modules that communicate with  
  *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the  
  *  license terms of these independent modules, and to copy and distribute  
  *  the resulting combined work under terms of your choice, provided that  
  *  every copy of the combined work is accompanied by a complete copy of  
  *  the source code of XviD (the version of XviD used to produce the  
  *  combined work), being distributed under the terms of the GNU General  
  *  Public License plus this exception.  An independent module is a module  
  *  which is not derived from or based on XviD.  
  *  
  *  Note that people who make modified versions of XviD are not obligated  
  *  to grant this special exception for their modified versions; it is  
  *  their choice whether to do so.  The GNU General Public License gives  
  *  permission to release a modified version without this exception; this  
  *  exception also makes it possible to release a modified version which  
  *  carries forward this exception.  
  *  
  * $Id: mbcoding.c,v 1.39 2003-01-26 01:44:07 suxen_drol Exp $  
23   *   *
24   ****************************************************************************/   ****************************************************************************/
25    
26    #include <stdio.h>
27  #include <stdlib.h>  #include <stdlib.h>
28    #include <string.h>
29    
30  #include "../portab.h"  #include "../portab.h"
31    #include "../global.h"
32  #include "bitstream.h"  #include "bitstream.h"
33  #include "zigzag.h"  #include "zigzag.h"
34  #include "vlc_codes.h"  #include "vlc_codes.h"
# Line 63  Line 36 
36    
37  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
38    
 #define ABS(X) (((X)>0)?(X):-(X))  
 #define CLIP(X,A) (X > A) ? (A) : (X)  
   
 /* #define BIGLUT */  
   
 #ifdef BIGLUT  
 #define LEVELOFFSET 2048  
 #else  
39  #define LEVELOFFSET 32  #define LEVELOFFSET 32
 #endif  
   
 /*****************************************************************************  
  * Local data  
  ****************************************************************************/  
40    
41  static REVERSE_EVENT DCT3D[2][4096];  static REVERSE_EVENT DCT3D[2][4096];
   
 #ifdef BIGLUT  
 static VLC coeff_VLC[2][2][4096][64];  
 static VLC *intra_table, *inter_table;  
 #else  
42  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
43    
44    /* not really MB related, but VLCs are only available here */
45    void bs_put_spritetrajectory(Bitstream * bs, const int val)
46    {
47            const int code = sprite_trajectory_code[val+16384].code;
48            const int len = sprite_trajectory_code[val+16384].len;
49            const int code2 = sprite_trajectory_len[len].code;
50            const int len2 = sprite_trajectory_len[len].len;
51    
52    #if 0
53            printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
54            printf("Code2 / Len2 = %d / %d \n",code2,len2);
55  #endif  #endif
56    
57  /*****************************************************************************          BitstreamPutBits(bs, code2, len2);
58   * Vector Length Coding Initialization          if (len) BitstreamPutBits(bs, code, len);
59   ****************************************************************************/  }
60    
61    int bs_get_spritetrajectory(Bitstream * bs)
62    {
63            int i;
64            for (i = 0; i < 12; i++)
65            {
66                    if (BitstreamShowBits(bs, sprite_trajectory_len[i].len) == sprite_trajectory_len[i].code)
67                    {
68                            BitstreamSkip(bs, sprite_trajectory_len[i].len);
69                            return i;
70                    }
71            }
72            return -1;
73    }
74    
75  void  void
76  init_vlc_tables(void)  init_vlc_tables(void)
77  {  {
78          ptr_t i, j, 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;
79            int32_t l;
 #ifdef BIGLUT  
         intra_table = (VLC*)coeff_VLC[1];  
         inter_table = (VLC*)coeff_VLC[0];  
 #endif  
   
80    
81          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++)
82                  for (i = 0; i < 4096; i++)                  for (i = 0; i < 4096; i++)
83                          DCT3D[intra][i].event.level = 0;                          DCT3D[intra][i].event.level = 0;
84    
85          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
86                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++) {
87                  {                          for (run = 0; run < 63 + last; run++) {
88                          for (run = 0; run < 63 + last; run++)                                  for (level = 0; level < (uint32_t)(32 << intra); level++) {
                                 for (level = 0; level < 32 << intra; level++)  
                                 {  
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
89                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
90                                          coeff_VLC[intra][last][level + offset][run].len = 128;                                          coeff_VLC[intra][last][level + offset][run].len = 128;
91                                  }                                  }
92                  }                  }
93                    }
94            }
95    
96          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
97                  for (i = 0; i < 102; i++)                  for (i = 0; i < 102; i++) {
                 {  
 #ifdef BIGLUT  
                         offset = LEVELOFFSET;  
 #else  
98                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
99  #endif  
100                          for (j = 0; j < 1 << (12 - coeff_tab[intra][i].vlc.len); j++)                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++) {
                         {  
101                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;
102                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
103                          }                          }
# Line 139  Line 106 
106                                  = coeff_tab[intra][i].vlc.code << 1;                                  = coeff_tab[intra][i].vlc.code << 1;
107                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len
108                                  = coeff_tab[intra][i].vlc.len + 1;                                  = coeff_tab[intra][i].vlc.len + 1;
109  #ifndef BIGLUT  
110                          if (!intra)                          if (!intra) {
 #endif  
                         {  
111                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code
112                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
113                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len
114                                          = coeff_tab[intra][i].vlc.len + 1;                                          = coeff_tab[intra][i].vlc.len + 1;
115                          }                          }
116                  }                  }
117            }
118    
119            for (intra = 0; intra < 2; intra++) {
120                    for (last = 0; last < 2; last++) {
121                            for (run = 0; run < 63 + last; run++) {
122                                    for (level = 1; level < (uint32_t)(32 << intra); level++) {
123    
         for (intra = 0; intra < 2; intra++)  
                 for (last = 0; last < 2; last++)  
                         for (run = 0; run < 63 + last; run++)  
                         {  
                                 for (level = 1; level < 32 << intra; level++)  
                                 {  
124                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
125                                              continue;                                              continue;
126    
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
127                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
128                      level_esc = level - max_level[intra][last][run];                      level_esc = level - max_level[intra][last][run];
129                                          run_esc = run - 1 - max_run[intra][last][level];                                          run_esc = run - 1 - max_run[intra][last][level];
                                         /*use this test to use shorter esc2 codes when possible  
                                         if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]  
                                                 && !(coeff_VLC[intra][last][level_esc + offset][run].len + 7 + 1  
                                                          > coeff_VLC[intra][last][level + offset][run_esc].code + 7 + 2))*/  
130    
131                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc])                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]) {
                                         {  
132                                                  escape     = ESCAPE1;                                                  escape     = ESCAPE1;
133                                                  escape_len = 7 + 1;                                                  escape_len = 7 + 1;
134                                                  run_esc    = run;                                                  run_esc    = run;
135                                          }                                          } else {
136                                          else                                                  if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {
                                         {  
                                                 if (level <= max_level[intra][last][run_esc] && run_esc <= max_run[intra][last][level])  
                                                 {  
137                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
138                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
139                                                          level_esc  = level;                                                          level_esc  = level;
140                                                  }                                                  } else {
141                                                  else                                                          if (!intra) {
                                                 {  
 #ifndef BIGLUT  
                                                         if (!intra)  
 #endif  
                                                         {  
142                                                                  coeff_VLC[intra][last][level + offset][run].code                                                                  coeff_VLC[intra][last][level + offset][run].code
143                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
144                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
145                                                                          coeff_VLC[intra][last][offset - level][run].code                                                                          coeff_VLC[intra][last][offset - level][run].code
146                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-(int32_t)level & 0xfff) << 1) | 1;
147                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;
148                                                          }                                                          }
149                                                          continue;                                                          continue;
# Line 207  Line 155 
155                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
156                                          coeff_VLC[intra][last][level + offset][run].len                                          coeff_VLC[intra][last][level + offset][run].len
157                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
158  #ifndef BIGLUT  
159                                          if (!intra)                                          if (!intra) {
 #endif  
                                         {  
160                                                  coeff_VLC[intra][last][offset - level][run].code                                                  coeff_VLC[intra][last][offset - level][run].code
161                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
162                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
# Line 219  Line 165 
165                                          }                                          }
166                                  }                                  }
167    
168  #ifdef BIGLUT                                  if (!intra) {
                                 for (level = 32 << intra; level < 2048; level++)  
                                 {  
                                         coeff_VLC[intra][last][level + offset][run].code  
                                                 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;  
                                         coeff_VLC[intra][last][level + offset][run].len = 30;  
   
                                         coeff_VLC[intra][last][offset - level][run].code  
                                                 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;  
                                         coeff_VLC[intra][last][offset - level][run].len = 30;  
                                 }  
 #else  
                                 if (!intra)  
                                 {  
169                                          coeff_VLC[intra][last][0][run].code                                          coeff_VLC[intra][last][0][run].code
170                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
171                                          coeff_VLC[intra][last][0][run].len = 30;                                          coeff_VLC[intra][last][0][run].len = 30;
172                                  }                                  }
173  #endif                          }
174                          }                          }
175  }  }
176    
177  /*****************************************************************************          /* init sprite_trajectory tables
178   * Local inlined functions for MB coding           * even if GMC is not specified (it might be used later...) */
179   ****************************************************************************/  
180            sprite_trajectory_code[0+16384].code = 0;
181            sprite_trajectory_code[0+16384].len = 0;
182            for (k=0;k<14;k++) {
183                    int limit = (1<<k);
184    
185                    for (l=-(2*limit-1); l <= -limit; l++) {
186                            sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
187                            sprite_trajectory_code[l+16384].len = k+1;
188                    }
189    
190                    for (l=limit; l<= 2*limit-1; l++) {
191                            sprite_trajectory_code[l+16384].code = l;
192                            sprite_trajectory_code[l+16384].len = k+1;
193                    }
194            }
195    }
196    
197  static __inline void  static __inline void
198  CodeVector(Bitstream * bs,  CodeVector(Bitstream * bs,
# Line 300  Line 249 
249    
250  }  }
251    
 #ifdef BIGLUT  
   
 static __inline void  
 CodeCoeff(Bitstream * bs,  
                   const int16_t qcoeff[64],  
                   VLC * table,  
                   const uint16_t * zigzag,  
                   uint16_t intra)  
 {  
   
         uint32_t j, last;  
         short v;  
         VLC *vlc;  
   
         j = intra;  
         last = intra;  
   
         while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                 j++;  
   
         do {  
                 vlc = table + 64 * 2048 + (v << 6) + j - last;  
                 last = ++j;  
   
                 /* count zeroes */  
                 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                         j++;  
   
                 /* write code */  
                 if (j != 64) {  
                         BitstreamPutBits(bs, vlc->code, vlc->len);  
                 } else {  
                         vlc += 64 * 4096;  
                         BitstreamPutBits(bs, vlc->code, vlc->len);  
                         break;  
                 }  
         } while (1);  
   
 }  
   
 #else  
   
252  static __inline void  static __inline void
253  CodeCoeffInter(Bitstream * bs,  CodeCoeffInter(Bitstream * bs,
254                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 409  Line 316 
316          i       = 1;          i       = 1;
317          run = 0;          run = 0;
318    
319          while (!(level = qcoeff[zigzag[i++]]))          while (i<64 && !(level = qcoeff[zigzag[i++]]))
320                  run++;                  run++;
321    
322          prev_level = level;          prev_level = level;
# Line 420  Line 327 
327          {          {
328                  if ((level = qcoeff[zigzag[i++]]) != 0)                  if ((level = qcoeff[zigzag[i++]]) != 0)
329                  {                  {
330                          abs_level = ABS(prev_level);                          abs_level = abs(prev_level);
331                          abs_level = abs_level < 64 ? abs_level : 0;                          abs_level = abs_level < 64 ? abs_level : 0;
332                          code      = coeff_VLC[1][0][abs_level][prev_run].code;                          code      = coeff_VLC[1][0][abs_level][prev_run].code;
333                          len               = coeff_VLC[1][0][abs_level][prev_run].len;                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
# Line 440  Line 347 
347                          run++;                          run++;
348          }          }
349    
350          abs_level = ABS(prev_level);          abs_level = abs(prev_level);
351          abs_level = abs_level < 64 ? abs_level : 0;          abs_level = abs_level < 64 ? abs_level : 0;
352          code      = coeff_VLC[1][1][abs_level][prev_run].code;          code      = coeff_VLC[1][1][abs_level][prev_run].code;
353          len               = coeff_VLC[1][1][abs_level][prev_run].len;          len               = coeff_VLC[1][1][abs_level][prev_run].len;
# Line 454  Line 361 
361          BitstreamPutBits(bs, code, len);          BitstreamPutBits(bs, code, len);
362  }  }
363    
 #endif  
364    
 /*****************************************************************************  
  * Local functions  
  ****************************************************************************/  
365    
366  static void  /* returns the number of bits required to encode qcoeff */
367  CodeBlockIntra(const FRAMEINFO * frame,  
368    int
369    CodeCoeffIntra_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
370    {
371            int bits = 0;
372            uint32_t i, abs_level, run, prev_run, len;
373            int32_t level, prev_level;
374    
375            i       = 1;
376            run = 0;
377    
378            while (i<64 && !(level = qcoeff[zigzag[i++]]))
379                    run++;
380    
381            if (i >= 64) return 0;  /* empty block */
382    
383            prev_level = level;
384            prev_run   = run;
385            run = 0;
386    
387            while (i < 64)
388            {
389                    if ((level = qcoeff[zigzag[i++]]) != 0)
390                    {
391                            abs_level = abs(prev_level);
392                            abs_level = abs_level < 64 ? abs_level : 0;
393                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
394                            bits      += len!=128 ? len : 30;
395    
396                            prev_level = level;
397                            prev_run   = run;
398                            run = 0;
399                    }
400                    else
401                            run++;
402            }
403    
404            abs_level = abs(prev_level);
405            abs_level = abs_level < 64 ? abs_level : 0;
406            len               = coeff_VLC[1][1][abs_level][prev_run].len;
407            bits      += len!=128 ? len : 30;
408    
409            return bits;
410    }
411    
412    int
413    CodeCoeffInter_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
414    {
415            uint32_t i, run, prev_run, len;
416            int32_t level, prev_level, level_shifted;
417            int bits = 0;
418    
419            i       = 0;
420            run = 0;
421    
422            while (!(level = qcoeff[zigzag[i++]]))
423                    run++;
424    
425            prev_level = level;
426            prev_run   = run;
427            run = 0;
428    
429            while (i < 64) {
430                    if ((level = qcoeff[zigzag[i++]]) != 0) {
431                            level_shifted = prev_level + 32;
432                            if (!(level_shifted & -64))
433                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
434                            else
435                                    len  = 30;
436    
437                            bits += len;
438                            prev_level = level;
439                            prev_run   = run;
440                            run = 0;
441                    }
442                    else
443                            run++;
444            }
445    
446            level_shifted = prev_level + 32;
447            if (!(level_shifted & -64))
448                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
449            else
450                    len  = 30;
451            bits += len;
452    
453            return bits;
454    }
455    
456    static int iDQtab[5] = {
457            1, 0, -1 /* no change */, 2, 3
458    };
459    #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
460    
461    
462    static __inline void
463    CodeBlockIntra(const FRAMEINFO * const frame,
464                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
465                             int16_t qcoeff[6 * 64],                             int16_t qcoeff[6 * 64],
466                             Bitstream * bs,                             Bitstream * bs,
# Line 490  Line 489 
489                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
490    
491          /* write cbpy */          /* write cbpy */
492          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
493    
494          /* write dquant */          /* write dquant */
495          if (pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA_Q)
496                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
497    
498          /* write interlacing */          /* write interlacing */
499          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
500                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
501          }          }
502          /* code block coeffs */          /* code block coeffs */
# Line 510  Line 509 
509                                                           dcc_tab[qcoeff[i * 64 + 0] + 255].len);                                                           dcc_tab[qcoeff[i * 64 + 0] + 255].len);
510    
511                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i))) {
512                            const uint16_t *scan_table =
513                                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
514                                    scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
515    
516                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
517    
518  #ifdef BIGLUT                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
519                          CodeCoeff(bs, &qcoeff[i * 64], intra_table,  
                                           scan_tables[pMB->acpred_directions[i]], 1);  
 #else  
                         CodeCoeffIntra(bs, &qcoeff[i * 64], scan_tables[pMB->acpred_directions[i]]);  
 #endif  
520                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
521                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
522                  }                  }
# Line 527  Line 526 
526    
527    
528  static void  static void
529  CodeBlockInter(const FRAMEINFO * frame,  CodeBlockInter(const FRAMEINFO * const frame,
530                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
531                             int16_t qcoeff[6 * 64],                             int16_t qcoeff[6 * 64],
532                             Bitstream * bs,                             Bitstream * bs,
# Line 544  Line 543 
543          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
544                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
545    
546            if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
547                    BitstreamPutBit(bs, pMB->mcsel);                /* mcsel: '0'=local motion, '1'=GMC */
548    
549          /* write cbpy */          /* write cbpy */
550          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
551    
552          /* write dquant */          /* write dquant */
553          if (pMB->mode == MODE_INTER_Q)          if (pMB->mode == MODE_INTER_Q)
554                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
555    
556          /* interlacing */          /* interlacing */
557          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
558                  if (pMB->cbp) {                  if (pMB->cbp) {
559                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
560                          DPRINTF(DPRINTF_DEBUG, "codep: field_dct: %d", pMB->field_dct);                          DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);
561                  }                  }
562    
563                  /* if inter block, write field ME flag */                  /* if inter block, write field ME flag */
564                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
565                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
566                          DPRINTF(DPRINTF_DEBUG, "codep: field_pred: %d", pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
567    
568                          /* write field prediction references */                          /* write field prediction references */
569    #if 0 /* Remove the #if once field_pred is supported */
570                          if (pMB->field_pred) {                          if (pMB->field_pred) {
571                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
572                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
573                          }                          }
574    #endif
575                  }                  }
576          }          }
577          /* code motion vector(s) */          /* code motion vector(s) if motion is local  */
578            if (!pMB->mcsel)
579          for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {          for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
580                  CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                  CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
581                  CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);                  CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);
# Line 580  Line 585 
585    
586          /* code block coeffs */          /* code block coeffs */
587          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
588                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
589  #ifdef BIGLUT                          const uint16_t *scan_table =
590                          CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
591  #else                                  scan_tables[2] : scan_tables[0];
592                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_tables[0]);  
593  #endif                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
594                    }
595    
596          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
597          pStat->iTextBits += bits;          pStat->iTextBits += bits;
   
598  }  }
599    
 /*****************************************************************************  
  * Macro Block bitstream encoding functions  
  ****************************************************************************/  
600    
601  void  void
602  MBCoding(const FRAMEINFO * frame,  MBCoding(const FRAMEINFO * const frame,
603                   MACROBLOCK * pMB,                   MACROBLOCK * pMB,
604                   int16_t qcoeff[6 * 64],                   int16_t qcoeff[6 * 64],
605                   Bitstream * bs,                   Bitstream * bs,
606                   Statistics * pStat)                   Statistics * pStat)
607  {  {
608            if (frame->coding_type != I_VOP)
609          if (frame->coding_type == P_VOP) {                          BitstreamPutBit(bs, 0); /* not_coded */
                         BitstreamPutBit(bs, 0); /* coded */  
         }  
610    
611          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
612                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
# Line 615  Line 615 
615    
616  }  }
617    
618    /***************************************************************
619     * bframe encoding start
620     ***************************************************************/
621    
622    /*
623            mbtype
624            0       1b              direct(h263)            mvdb
625            1       01b             interpolate mc+q        dbquant, mvdf, mvdb
626            2       001b    backward mc+q           dbquant, mvdb
627            3       0001b   forward mc+q            dbquant, mvdf
628    */
629    
630    static __inline void
631    put_bvop_mbtype(Bitstream * bs,
632                                    int value)
633    {
634            switch (value) {
635                    case MODE_FORWARD:
636                            BitstreamPutBit(bs, 0);
637                    case MODE_BACKWARD:
638                            BitstreamPutBit(bs, 0);
639                    case MODE_INTERPOLATE:
640                            BitstreamPutBit(bs, 0);
641                    case MODE_DIRECT:
642                            BitstreamPutBit(bs, 1);
643                    default:
644                            break;
645            }
646    }
647    
648    /*
649            dbquant
650            -2      10b
651            0       0b
652            +2      11b
653    */
654    
655    static __inline void
656    put_bvop_dbquant(Bitstream * bs,
657                                     int value)
658    {
659            switch (value) {
660            case 0:
661                    BitstreamPutBit(bs, 0);
662                    return;
663    
664            case -2:
665                    BitstreamPutBit(bs, 1);
666                    BitstreamPutBit(bs, 0);
667                    return;
668    
669            case 2:
670                    BitstreamPutBit(bs, 1);
671                    BitstreamPutBit(bs, 1);
672                    return;
673    
674            default:;                                       /* invalid */
675            }
676    }
677    
678    
679    
680  void  void
681  MBSkip(Bitstream * bs)  MBCodingBVOP(const FRAMEINFO * const frame,
682                             const MACROBLOCK * mb,
683                             const int16_t qcoeff[6 * 64],
684                             const int32_t fcode,
685                             const int32_t bcode,
686                             Bitstream * bs,
687                             Statistics * pStat)
688  {  {
689          BitstreamPutBit(bs, 1); /* not coded */          int vcode = fcode;
690            unsigned int i;
691    
692            const uint16_t *scan_table =
693                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
694                    scan_tables[2] : scan_tables[0];
695            int bits;
696    
697    
698    /*      ------------------------------------------------------------------
699                    when a block is skipped it is decoded DIRECT(0,0)
700                    hence is interpolated from forward & backward frames
701            ------------------------------------------------------------------ */
702    
703            if (mb->mode == MODE_DIRECT_NONE_MV) {
704                    BitstreamPutBit(bs, 1); /* skipped */
705          return;          return;
706  }  }
707    
708  /*****************************************************************************          BitstreamPutBit(bs, 0);         /* not skipped */
709   * decoding stuff starts here  
710   ****************************************************************************/          if (mb->cbp == 0) {
711                    BitstreamPutBit(bs, 1); /* cbp == 0 */
712            } else {
713                    BitstreamPutBit(bs, 0); /* cbp == xxx */
714            }
715    
716            put_bvop_mbtype(bs, mb->mode);
717    
718            if (mb->cbp) {
719                    BitstreamPutBits(bs, mb->cbp, 6);
720            }
721    
722            if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
723                    put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */
724            }
725    
726            if (frame->vol_flags & XVID_VOL_INTERLACING) {
727                    if (mb->cbp) {
728                            BitstreamPutBit(bs, mb->field_dct);
729                            DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);
730                    }
731    
732                    /* if not direct block, write field ME flag */
733                    if (mb->mode != MODE_DIRECT) {
734                            BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
735    
736                            /* write field prediction references */
737    #if 0 /* Remove the #if once field_pred is supported */
738                            if (mb->field_pred) {
739                                    BitstreamPutBit(bs, mb->field_for_top);
740                                    BitstreamPutBit(bs, mb->field_for_bot);
741                            }
742    #endif
743                    }
744            }
745    
746    
747            switch (mb->mode) {
748                    case MODE_INTERPOLATE:
749                            CodeVector(bs, mb->pmvs[1].x, vcode, pStat); /* forward vector of interpolate mode */
750                            CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
751                    case MODE_BACKWARD:
752                            vcode = bcode;
753                    case MODE_FORWARD:
754                            CodeVector(bs, mb->pmvs[0].x, vcode, pStat);
755                            CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
756                            break;
757                    case MODE_DIRECT:
758                            CodeVector(bs, mb->pmvs[3].x, 1, pStat);        /* fcode is always 1 for delta vector */
759                            CodeVector(bs, mb->pmvs[3].y, 1, pStat);        /* prediction is always (0,0) */
760                    default: break;
761            }
762    
763            bits = BitstreamPos(bs);
764            for (i = 0; i < 6; i++) {
765                    if (mb->cbp & (1 << (5 - i))) {
766                            CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
767                    }
768            }
769            pStat->iTextBits += BitstreamPos(bs) - bits;
770    }
771    
772    
773    
774    /***************************************************************
775     * decoding stuff starts here                                  *
776     ***************************************************************/
777    
778    
779  /*  /*
780   * For IVOP addbits == 0   * for IVOP addbits == 0
781   * For PVOP addbits == fcode - 1   * for PVOP addbits == fcode - 1
782   * For BVOP addbits == max(fcode,bcode) - 1   * for BVOP addbits == max(fcode,bcode) - 1
783   * returns true or false   * returns true or false
784   */   */
   
785  int  int
786  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
787  {  {
# Line 675  Line 823 
823    
824          uint32_t index;          uint32_t index;
825    
826          index = CLIP(BitstreamShowBits(bs, 9), 256);          index = MIN(BitstreamShowBits(bs, 9), 256);
827    
828          BitstreamSkip(bs, mcbpc_inter_table[index].len);          BitstreamSkip(bs, mcbpc_inter_table[index].len);
829    
# Line 701  Line 849 
849    
850  }  }
851    
852  int  static __inline int
853  get_mv_data(Bitstream * bs)  get_mv_data(Bitstream * bs)
854  {  {
855    
# Line 747  Line 895 
895                  return data;                  return data;
896    
897          res = BitstreamGetBits(bs, fcode - 1);          res = BitstreamGetBits(bs, fcode - 1);
898          mv = ((ABS(data) - 1) * scale_fac) + res + 1;          mv = ((abs(data) - 1) * scale_fac) + res + 1;
899    
900          return data < 0 ? -mv : mv;          return data < 0 ? -mv : mv;
901    
# Line 810  Line 958 
958    
959  }  }
960    
961  /*****************************************************************************  #define GET_BITS(cache, n) ((cache)>>(32-(n)))
  * Local inlined function to "decode" written vlc codes  
  ****************************************************************************/  
962    
963  static __inline int  static __inline int
964  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
# Line 826  Line 972 
972          int32_t level;          int32_t level;
973          REVERSE_EVENT *reverse_event;          REVERSE_EVENT *reverse_event;
974    
975            uint32_t cache = BitstreamShowBits(bs, 32);
976    
977          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 */
978                  intra = 0;                  intra = 0;
979    
980          if (BitstreamShowBits(bs, 7) != ESCAPE) {          if (GET_BITS(cache, 7) != ESCAPE) {
981                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
982    
983                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
984                          goto error;                          goto error;
# Line 838  Line 986 
986                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
987                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
988    
989                  BitstreamSkip(bs, reverse_event->len);                  /* Don't forget to update the bitstream position */
990                    BitstreamSkip(bs, reverse_event->len+1);
991    
992                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
993          }          }
994    
995          BitstreamSkip(bs, 7);          /* flush 7bits of cache */
996            cache <<= 7;
997    
998          if (short_video_header) {          if (short_video_header) {
999                  /* 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  */
1000                  *last = BitstreamGetBit(bs);                  *last =  GET_BITS(cache, 1);
1001                  *run = BitstreamGetBits(bs, 6);                  *run  = (GET_BITS(cache, 7) &0x3f);
1002                  level = BitstreamGetBits(bs, 8);                  level = (GET_BITS(cache, 15)&0xff);
1003    
1004                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1005                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1006    
1007                    /* We've "eaten" 22 bits */
1008                    BitstreamSkip(bs, 22);
1009    
1010                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1011          }          }
1012    
1013          mode = BitstreamShowBits(bs, 2);          if ((mode = GET_BITS(cache, 2)) < 3) {
1014                    const int skip[3] = {1, 1, 2};
1015          if (mode < 3) {                  cache <<= skip[mode];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
1016    
1017                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1018    
1019                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1020                          goto error;                          goto error;
# Line 870  Line 1022 
1022                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1023                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1024    
1025                  BitstreamSkip(bs, reverse_event->len);                  if (mode < 2) {
1026                            /* first escape mode, level is offset */
                 if (mode < 2)                   /* first escape mode, level is offset */  
1027                          level += max_level[intra][*last][*run];                          level += max_level[intra][*last][*run];
1028                  else                                    /* second escape mode, run is offset */                  } else {
1029                            /* second escape mode, run is offset */
1030                          *run += max_run[intra][*last][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1031                    }
1032    
1033                    /* Update bitstream position */
1034                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1035    
1036                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1037          }          }
1038    
1039          /* third escape mode - fixed length codes */          /* third escape mode - fixed length codes */
1040          BitstreamSkip(bs, 2);          cache <<= 2;
1041          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1042          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1043          BitstreamSkip(bs, 1);           /* marker */          level = (GET_BITS(cache, 20)&0xfff);
1044          level = BitstreamGetBits(bs, 12);  
1045          BitstreamSkip(bs, 1);           /* marker */          /* Update bitstream position */
1046            BitstreamSkip(bs, 30);
1047    
1048          return (level << 20) >> 20;          return (level << 20) >> 20;
1049    
# Line 895  Line 1052 
1052          return 0;          return 0;
1053  }  }
1054    
 /*****************************************************************************  
  * MB reading functions  
  ****************************************************************************/  
   
1055  void  void
1056  get_intra_block(Bitstream * bs,  get_intra_block(Bitstream * bs,
1057                                  int16_t * block,                                  int16_t * block,
# Line 907  Line 1060 
1060  {  {
1061    
1062          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1063          int level;          int level, run, last;
         int run;  
         int last;  
1064    
1065          do {          do {
1066                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1067                  if (run == -1) {                  if (run == -1) {
1068                          DPRINTF(DPRINTF_DEBUG, "fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1069                          break;                          break;
1070                  }                  }
1071                  coeff += run;                  coeff += run;
1072                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1073    
1074                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1075                  /*DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32)); */  #if 0
1076                    DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1077    #endif
1078    
1079                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1080                          DPRINTF(DPRINTF_DEBUG, "warning: intra_overflow: %d", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1081                  }                  }
1082                  coeff++;                  coeff++;
1083          } while (!last);          } while (!last);
# Line 932  Line 1085 
1085  }  }
1086    
1087  void  void
1088  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1089                                  int16_t * block)                  Bitstream * bs,
1090                    int16_t * block,
1091                    int direction,
1092                    const int quant,
1093                    const uint16_t *matrix)
1094  {  {
1095    
1096          const uint16_t *scan = scan_tables[0];          const uint16_t *scan = scan_tables[direction];
1097            const uint16_t quant_m_2 = quant << 1;
1098            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1099          int p;          int p;
1100          int level;          int level;
1101          int run;          int run;
# Line 946  Line 1105 
1105          do {          do {
1106                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1107                  if (run == -1) {                  if (run == -1) {
1108                          DPRINTF(DPRINTF_ERROR, "fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1109                          break;                          break;
1110                  }                  }
1111                  p += run;                  p += run;
1112    
1113                  block[scan[p]] = level;                  if (level < 0) {
1114                            level = level*quant_m_2 - quant_add;
1115                            block[scan[p]] = (level >= -2048 ? level : -2048);
1116                    } else {
1117                            level = level * quant_m_2 + quant_add;
1118                            block[scan[p]] = (level <= 2047 ? level : 2047);
1119                    }
1120                    p++;
1121            } while (!last);
1122    }
1123    
1124                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);  void
1125    get_inter_block_mpeg(
1126                    Bitstream * bs,
1127                    int16_t * block,
1128                    int direction,
1129                    const int quant,
1130                    const uint16_t *matrix)
1131    {
1132            const uint16_t *scan = scan_tables[direction];
1133            uint32_t sum = 0;
1134            int p;
1135            int level;
1136            int run;
1137            int last;
1138    
1139                  if (level < -2047 || level > 2047) {          p = 0;
1140                          DPRINTF(DPRINTF_DEBUG, "warning: inter_overflow: %d", level);          do {
1141                    level = get_coeff(bs, &run, &last, 0, 0);
1142                    if (run == -1) {
1143                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1144                            break;
1145                  }                  }
1146                    p += run;
1147    
1148                    if (level < 0) {
1149                            level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1150                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1151                    } else {
1152                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1153                            block[scan[p]] = (level <= 2047 ? level : 2047);
1154                    }
1155    
1156                    sum ^= block[scan[p]];
1157    
1158                  p++;                  p++;
1159          } while (!last);          } while (!last);
1160    
1161            /*      mismatch control */
1162            if ((sum & 1) == 0) {
1163                    block[63] ^= 1;
1164            }
1165  }  }
1166    
1167    
1168    /*****************************************************************************
1169     * VLC tables and other constant arrays
1170     ****************************************************************************/
1171    
1172    VLC_TABLE const coeff_tab[2][102] =
1173    {
1174            /* intra = 0 */
1175            {
1176                    {{ 2,  2}, {0, 0, 1}},
1177                    {{15,  4}, {0, 0, 2}},
1178                    {{21,  6}, {0, 0, 3}},
1179                    {{23,  7}, {0, 0, 4}},
1180                    {{31,  8}, {0, 0, 5}},
1181                    {{37,  9}, {0, 0, 6}},
1182                    {{36,  9}, {0, 0, 7}},
1183                    {{33, 10}, {0, 0, 8}},
1184                    {{32, 10}, {0, 0, 9}},
1185                    {{ 7, 11}, {0, 0, 10}},
1186                    {{ 6, 11}, {0, 0, 11}},
1187                    {{32, 11}, {0, 0, 12}},
1188                    {{ 6,  3}, {0, 1, 1}},
1189                    {{20,  6}, {0, 1, 2}},
1190                    {{30,  8}, {0, 1, 3}},
1191                    {{15, 10}, {0, 1, 4}},
1192                    {{33, 11}, {0, 1, 5}},
1193                    {{80, 12}, {0, 1, 6}},
1194                    {{14,  4}, {0, 2, 1}},
1195                    {{29,  8}, {0, 2, 2}},
1196                    {{14, 10}, {0, 2, 3}},
1197                    {{81, 12}, {0, 2, 4}},
1198                    {{13,  5}, {0, 3, 1}},
1199                    {{35,  9}, {0, 3, 2}},
1200                    {{13, 10}, {0, 3, 3}},
1201                    {{12,  5}, {0, 4, 1}},
1202                    {{34,  9}, {0, 4, 2}},
1203                    {{82, 12}, {0, 4, 3}},
1204                    {{11,  5}, {0, 5, 1}},
1205                    {{12, 10}, {0, 5, 2}},
1206                    {{83, 12}, {0, 5, 3}},
1207                    {{19,  6}, {0, 6, 1}},
1208                    {{11, 10}, {0, 6, 2}},
1209                    {{84, 12}, {0, 6, 3}},
1210                    {{18,  6}, {0, 7, 1}},
1211                    {{10, 10}, {0, 7, 2}},
1212                    {{17,  6}, {0, 8, 1}},
1213                    {{ 9, 10}, {0, 8, 2}},
1214                    {{16,  6}, {0, 9, 1}},
1215                    {{ 8, 10}, {0, 9, 2}},
1216                    {{22,  7}, {0, 10, 1}},
1217                    {{85, 12}, {0, 10, 2}},
1218                    {{21,  7}, {0, 11, 1}},
1219                    {{20,  7}, {0, 12, 1}},
1220                    {{28,  8}, {0, 13, 1}},
1221                    {{27,  8}, {0, 14, 1}},
1222                    {{33,  9}, {0, 15, 1}},
1223                    {{32,  9}, {0, 16, 1}},
1224                    {{31,  9}, {0, 17, 1}},
1225                    {{30,  9}, {0, 18, 1}},
1226                    {{29,  9}, {0, 19, 1}},
1227                    {{28,  9}, {0, 20, 1}},
1228                    {{27,  9}, {0, 21, 1}},
1229                    {{26,  9}, {0, 22, 1}},
1230                    {{34, 11}, {0, 23, 1}},
1231                    {{35, 11}, {0, 24, 1}},
1232                    {{86, 12}, {0, 25, 1}},
1233                    {{87, 12}, {0, 26, 1}},
1234                    {{ 7,  4}, {1, 0, 1}},
1235                    {{25,  9}, {1, 0, 2}},
1236                    {{ 5, 11}, {1, 0, 3}},
1237                    {{15,  6}, {1, 1, 1}},
1238                    {{ 4, 11}, {1, 1, 2}},
1239                    {{14,  6}, {1, 2, 1}},
1240                    {{13,  6}, {1, 3, 1}},
1241                    {{12,  6}, {1, 4, 1}},
1242                    {{19,  7}, {1, 5, 1}},
1243                    {{18,  7}, {1, 6, 1}},
1244                    {{17,  7}, {1, 7, 1}},
1245                    {{16,  7}, {1, 8, 1}},
1246                    {{26,  8}, {1, 9, 1}},
1247                    {{25,  8}, {1, 10, 1}},
1248                    {{24,  8}, {1, 11, 1}},
1249                    {{23,  8}, {1, 12, 1}},
1250                    {{22,  8}, {1, 13, 1}},
1251                    {{21,  8}, {1, 14, 1}},
1252                    {{20,  8}, {1, 15, 1}},
1253                    {{19,  8}, {1, 16, 1}},
1254                    {{24,  9}, {1, 17, 1}},
1255                    {{23,  9}, {1, 18, 1}},
1256                    {{22,  9}, {1, 19, 1}},
1257                    {{21,  9}, {1, 20, 1}},
1258                    {{20,  9}, {1, 21, 1}},
1259                    {{19,  9}, {1, 22, 1}},
1260                    {{18,  9}, {1, 23, 1}},
1261                    {{17,  9}, {1, 24, 1}},
1262                    {{ 7, 10}, {1, 25, 1}},
1263                    {{ 6, 10}, {1, 26, 1}},
1264                    {{ 5, 10}, {1, 27, 1}},
1265                    {{ 4, 10}, {1, 28, 1}},
1266                    {{36, 11}, {1, 29, 1}},
1267                    {{37, 11}, {1, 30, 1}},
1268                    {{38, 11}, {1, 31, 1}},
1269                    {{39, 11}, {1, 32, 1}},
1270                    {{88, 12}, {1, 33, 1}},
1271                    {{89, 12}, {1, 34, 1}},
1272                    {{90, 12}, {1, 35, 1}},
1273                    {{91, 12}, {1, 36, 1}},
1274                    {{92, 12}, {1, 37, 1}},
1275                    {{93, 12}, {1, 38, 1}},
1276                    {{94, 12}, {1, 39, 1}},
1277                    {{95, 12}, {1, 40, 1}}
1278            },
1279            /* intra = 1 */
1280            {
1281                    {{ 2,  2}, {0, 0, 1}},
1282                    {{15,  4}, {0, 0, 3}},
1283                    {{21,  6}, {0, 0, 6}},
1284                    {{23,  7}, {0, 0, 9}},
1285                    {{31,  8}, {0, 0, 10}},
1286                    {{37,  9}, {0, 0, 13}},
1287                    {{36,  9}, {0, 0, 14}},
1288                    {{33, 10}, {0, 0, 17}},
1289                    {{32, 10}, {0, 0, 18}},
1290                    {{ 7, 11}, {0, 0, 21}},
1291                    {{ 6, 11}, {0, 0, 22}},
1292                    {{32, 11}, {0, 0, 23}},
1293                    {{ 6,  3}, {0, 0, 2}},
1294                    {{20,  6}, {0, 1, 2}},
1295                    {{30,  8}, {0, 0, 11}},
1296                    {{15, 10}, {0, 0, 19}},
1297                    {{33, 11}, {0, 0, 24}},
1298                    {{80, 12}, {0, 0, 25}},
1299                    {{14,  4}, {0, 1, 1}},
1300                    {{29,  8}, {0, 0, 12}},
1301                    {{14, 10}, {0, 0, 20}},
1302                    {{81, 12}, {0, 0, 26}},
1303                    {{13,  5}, {0, 0, 4}},
1304                    {{35,  9}, {0, 0, 15}},
1305                    {{13, 10}, {0, 1, 7}},
1306                    {{12,  5}, {0, 0, 5}},
1307                    {{34,  9}, {0, 4, 2}},
1308                    {{82, 12}, {0, 0, 27}},
1309                    {{11,  5}, {0, 2, 1}},
1310                    {{12, 10}, {0, 2, 4}},
1311                    {{83, 12}, {0, 1, 9}},
1312                    {{19,  6}, {0, 0, 7}},
1313                    {{11, 10}, {0, 3, 4}},
1314                    {{84, 12}, {0, 6, 3}},
1315                    {{18,  6}, {0, 0, 8}},
1316                    {{10, 10}, {0, 4, 3}},
1317                    {{17,  6}, {0, 3, 1}},
1318                    {{ 9, 10}, {0, 8, 2}},
1319                    {{16,  6}, {0, 4, 1}},
1320                    {{ 8, 10}, {0, 5, 3}},
1321                    {{22,  7}, {0, 1, 3}},
1322                    {{85, 12}, {0, 1, 10}},
1323                    {{21,  7}, {0, 2, 2}},
1324                    {{20,  7}, {0, 7, 1}},
1325                    {{28,  8}, {0, 1, 4}},
1326                    {{27,  8}, {0, 3, 2}},
1327                    {{33,  9}, {0, 0, 16}},
1328                    {{32,  9}, {0, 1, 5}},
1329                    {{31,  9}, {0, 1, 6}},
1330                    {{30,  9}, {0, 2, 3}},
1331                    {{29,  9}, {0, 3, 3}},
1332                    {{28,  9}, {0, 5, 2}},
1333                    {{27,  9}, {0, 6, 2}},
1334                    {{26,  9}, {0, 7, 2}},
1335                    {{34, 11}, {0, 1, 8}},
1336                    {{35, 11}, {0, 9, 2}},
1337                    {{86, 12}, {0, 2, 5}},
1338                    {{87, 12}, {0, 7, 3}},
1339                    {{ 7,  4}, {1, 0, 1}},
1340                    {{25,  9}, {0, 11, 1}},
1341                    {{ 5, 11}, {1, 0, 6}},
1342                    {{15,  6}, {1, 1, 1}},
1343                    {{ 4, 11}, {1, 0, 7}},
1344                    {{14,  6}, {1, 2, 1}},
1345                    {{13,  6}, {0, 5, 1}},
1346                    {{12,  6}, {1, 0, 2}},
1347                    {{19,  7}, {1, 5, 1}},
1348                    {{18,  7}, {0, 6, 1}},
1349                    {{17,  7}, {1, 3, 1}},
1350                    {{16,  7}, {1, 4, 1}},
1351                    {{26,  8}, {1, 9, 1}},
1352                    {{25,  8}, {0, 8, 1}},
1353                    {{24,  8}, {0, 9, 1}},
1354                    {{23,  8}, {0, 10, 1}},
1355                    {{22,  8}, {1, 0, 3}},
1356                    {{21,  8}, {1, 6, 1}},
1357                    {{20,  8}, {1, 7, 1}},
1358                    {{19,  8}, {1, 8, 1}},
1359                    {{24,  9}, {0, 12, 1}},
1360                    {{23,  9}, {1, 0, 4}},
1361                    {{22,  9}, {1, 1, 2}},
1362                    {{21,  9}, {1, 10, 1}},
1363                    {{20,  9}, {1, 11, 1}},
1364                    {{19,  9}, {1, 12, 1}},
1365                    {{18,  9}, {1, 13, 1}},
1366                    {{17,  9}, {1, 14, 1}},
1367                    {{ 7, 10}, {0, 13, 1}},
1368                    {{ 6, 10}, {1, 0, 5}},
1369                    {{ 5, 10}, {1, 1, 3}},
1370                    {{ 4, 10}, {1, 2, 2}},
1371                    {{36, 11}, {1, 3, 2}},
1372                    {{37, 11}, {1, 4, 2}},
1373                    {{38, 11}, {1, 15, 1}},
1374                    {{39, 11}, {1, 16, 1}},
1375                    {{88, 12}, {0, 14, 1}},
1376                    {{89, 12}, {1, 0, 8}},
1377                    {{90, 12}, {1, 5, 2}},
1378                    {{91, 12}, {1, 6, 2}},
1379                    {{92, 12}, {1, 17, 1}},
1380                    {{93, 12}, {1, 18, 1}},
1381                    {{94, 12}, {1, 19, 1}},
1382                    {{95, 12}, {1, 20, 1}}
1383            }
1384    };
1385    
1386    /* constants taken from momusys/vm_common/inlcude/max_level.h */
1387    uint8_t const max_level[2][2][64] = {
1388            {
1389                    /* intra = 0, last = 0 */
1390                    {
1391                            12, 6, 4, 3, 3, 3, 3, 2,
1392                            2, 2, 2, 1, 1, 1, 1, 1,
1393                            1, 1, 1, 1, 1, 1, 1, 1,
1394                            1, 1, 1, 0, 0, 0, 0, 0,
1395                            0, 0, 0, 0, 0, 0, 0, 0,
1396                            0, 0, 0, 0, 0, 0, 0, 0,
1397                            0, 0, 0, 0, 0, 0, 0, 0,
1398                            0, 0, 0, 0, 0, 0, 0, 0
1399                    },
1400                    /* intra = 0, last = 1 */
1401                    {
1402                            3, 2, 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, 1, 1, 1, 1, 1, 1, 1,
1406                            1, 1, 1, 1, 1, 1, 1, 1,
1407                            1, 0, 0, 0, 0, 0, 0, 0,
1408                            0, 0, 0, 0, 0, 0, 0, 0,
1409                            0, 0, 0, 0, 0, 0, 0, 0
1410                    }
1411            },
1412            {
1413                    /* intra = 1, last = 0 */
1414                    {
1415                            27, 10, 5, 4, 3, 3, 3, 3,
1416                            2, 2, 1, 1, 1, 1, 1, 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                            0, 0, 0, 0, 0, 0, 0, 0,
1422                            0, 0, 0, 0, 0, 0, 0, 0
1423                    },
1424                    /* intra = 1, last = 1 */
1425                    {
1426                            8, 3, 2, 2, 2, 2, 2, 1,
1427                            1, 1, 1, 1, 1, 1, 1, 1,
1428                            1, 1, 1, 1, 1, 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                            0, 0, 0, 0, 0, 0, 0, 0,
1433                            0, 0, 0, 0, 0, 0, 0, 0
1434                    }
1435            }
1436    };
1437    
1438    uint8_t const max_run[2][2][64] = {
1439            {
1440                    /* intra = 0, last = 0 */
1441                    {
1442                            0, 26, 10, 6, 2, 1, 1, 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                            0, 0, 0, 0, 0, 0, 0, 0,
1449                            0, 0, 0, 0, 0, 0, 0, 0,
1450                    },
1451                    /* intra = 0, last = 1 */
1452                    {
1453                            0, 40, 1, 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                            0, 0, 0, 0, 0, 0, 0, 0,
1460                            0, 0, 0, 0, 0, 0, 0, 0,
1461                    }
1462            },
1463            {
1464                    /* intra = 1, last = 0 */
1465                    {
1466                            0, 14, 9, 7, 3, 2, 1, 1,
1467                            1, 1, 1, 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                            0, 0, 0, 0, 0, 0, 0, 0,
1473                            0, 0, 0, 0, 0, 0, 0, 0,
1474                    },
1475                    /* intra = 1, last = 1 */
1476                    {
1477                            0, 20, 6, 1, 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                            0, 0, 0, 0, 0, 0, 0, 0,
1484                            0, 0, 0, 0, 0, 0, 0, 0,
1485                    }
1486            }
1487    };
1488    
1489    /******************************************************************
1490     * encoder tables                                                 *
1491     ******************************************************************/
1492    
1493    VLC sprite_trajectory_code[32768];
1494    
1495    VLC sprite_trajectory_len[15] = {
1496            { 0x00 , 2},
1497            { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1498            { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},
1499            { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1500    
1501    
1502    /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1503       the sign bit must be added afterwards. */
1504    
1505    /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1506     CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1507     Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1508    
1509    VLC mcbpc_intra_tab[15] = {
1510            {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1511            {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1512            {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1513            {0x00, 0}, {0x03, 3}, {0x03, 6}
1514    };
1515    
1516    /* MCBPC inter.
1517       Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1518    
1519    VLC mcbpc_inter_tab[29] = {
1520            {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1521            {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1522            {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1523            {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1524    };
1525    
1526    const VLC xvid_cbpy_tab[16] = {
1527            {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1528            {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1529    };
1530    
1531    const VLC dcy_tab[511] = {
1532            {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1533            {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1534            {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1535            {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1536            {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1537            {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1538            {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1539            {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1540            {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1541            {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1542            {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1543            {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1544            {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1545            {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1546            {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1547            {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1548            {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1549            {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1550            {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1551            {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1552            {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1553            {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1554            {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1555            {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1556            {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1557            {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1558            {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1559            {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1560            {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1561            {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1562            {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1563            {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1564            {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1565            {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1566            {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1567            {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1568            {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1569            {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1570            {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1571            {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1572            {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1573            {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1574            {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1575            {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1576            {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1577            {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1578            {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1579            {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1580            {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1581            {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1582            {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1583            {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1584            {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1585            {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1586            {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1587            {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1588            {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1589            {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1590            {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1591            {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1592            {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1593            {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1594            {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1595            {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1596            {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1597            {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1598            {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1599            {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1600            {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1601            {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1602            {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1603            {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1604            {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1605            {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1606            {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1607            {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1608            {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1609            {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1610            {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1611            {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1612            {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1613            {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1614            {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1615            {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1616            {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1617            {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1618            {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1619            {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1620            {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1621            {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1622            {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1623            {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1624            {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1625            {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1626            {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1627            {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1628            {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1629            {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1630            {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1631            {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1632            {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1633            {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1634            {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1635            {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1636            {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1637            {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1638            {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1639            {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1640            {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1641            {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1642            {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1643            {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1644            {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1645            {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1646            {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1647            {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1648            {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1649            {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1650            {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1651            {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1652            {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1653            {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1654            {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1655            {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1656            {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1657            {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1658            {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1659            {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1660    };
1661    
1662    const VLC dcc_tab[511] = {
1663            {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1664            {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1665            {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1666            {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1667            {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1668            {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1669            {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1670            {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1671            {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1672            {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1673            {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1674            {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1675            {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1676            {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1677            {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1678            {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1679            {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1680            {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1681            {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1682            {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1683            {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1684            {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1685            {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1686            {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1687            {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1688            {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1689            {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1690            {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1691            {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1692            {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1693            {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1694            {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1695            {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1696            {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1697            {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1698            {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1699            {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1700            {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1701            {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1702            {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1703            {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1704            {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1705            {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1706            {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1707            {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1708            {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1709            {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1710            {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1711            {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1712            {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1713            {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1714            {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1715            {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1716            {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1717            {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1718            {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1719            {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1720            {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1721            {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1722            {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1723            {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1724            {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1725            {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1726            {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1727            {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1728            {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1729            {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1730            {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1731            {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1732            {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1733            {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1734            {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1735            {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1736            {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1737            {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1738            {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1739            {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1740            {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1741            {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1742            {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1743            {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1744            {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1745            {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1746            {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1747            {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1748            {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1749            {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1750            {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1751            {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1752            {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1753            {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1754            {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1755            {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1756            {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1757            {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1758            {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1759            {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1760            {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1761            {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1762            {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1763            {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1764            {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1765            {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1766            {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1767            {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1768            {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1769            {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1770            {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1771            {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1772            {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1773            {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1774            {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1775            {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1776            {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1777            {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1778            {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1779            {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1780            {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1781            {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1782            {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1783            {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1784            {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1785            {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1786            {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1787            {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1788            {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1789            {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1790            {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1791    };
1792    
1793    
1794    const VLC mb_motion_table[65] = {
1795            {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1796            {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1797            {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1798            {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1799            {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1800            {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1801            {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1802            {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1803            {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1804            {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1805            {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1806            {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1807            {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1808            {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1809            {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1810            {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1811            {0x04, 13}
1812    };
1813    
1814    
1815    /******************************************************************
1816     * decoder tables                                                 *
1817     ******************************************************************/
1818    
1819    VLC const mcbpc_intra_table[64] = {
1820            {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4},  {4, 4},  {4, 4},  {4, 4},
1821            {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1822            {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1823            {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
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            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1827            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1}
1828    };
1829    
1830    VLC const mcbpc_inter_table[257] = {
1831            {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1832            {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1833            {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1834            {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1835            {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1836            {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1837            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1838            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
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            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1842            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1843            {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            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1846            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1847            {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            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1854            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1855            {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            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1862            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1863            {0, 1}
1864    };
1865    
1866    VLC const cbpy_table[64] = {
1867            {-1, 0}, {-1, 0}, {6, 6},  {9, 6},  {8, 5},  {8, 5},  {4, 5},  {4, 5},
1868            {2, 5},  {2, 5},  {1, 5},  {1, 5},  {0, 4},  {0, 4},  {0, 4},  {0, 4},
1869            {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1870            {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4},  {5, 4},  {5, 4},  {5, 4},
1871            {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4},  {3, 4},  {3, 4},  {3, 4},
1872            {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4},  {7, 4},  {7, 4},  {7, 4},
1873            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1874            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1875    };
1876    
1877    VLC const TMNMVtab0[] = {
1878            {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1879            {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1880    };
1881    
1882    VLC const TMNMVtab1[] = {
1883            {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1884            {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1885            {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1886            {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1887            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1888            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1889            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1890            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1891            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1892            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1893            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1894            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1895            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1896            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1897            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1898            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
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            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1906            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
1907    };
1908    
1909    VLC const TMNMVtab2[] = {
1910            {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
1911            {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
1912            {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
1913            {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
1914            {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
1915            {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
1916            {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
1917            {24, 10}, {24, 10}, {24, 10}, {24, 10},
1918            {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
1919            {23, 10}, {23, 10}, {23, 10}, {23, 10},
1920            {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
1921            {22, 10}, {22, 10}, {22, 10}, {22, 10},
1922            {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
1923            {21, 10}, {21, 10}, {21, 10}, {21, 10},
1924            {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
1925            {20, 10}, {20, 10}, {20, 10}, {20, 10},
1926            {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
1927            {19, 10}, {19, 10}, {19, 10}, {19, 10},
1928            {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
1929            {18, 10}, {18, 10}, {18, 10}, {18, 10},
1930            {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
1931            {17, 10}, {17, 10}, {17, 10}, {17, 10},
1932            {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
1933            {16, 10}, {16, 10}, {16, 10}, {16, 10},
1934            {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
1935            {15, 10}, {15, 10}, {15, 10}, {15, 10},
1936            {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
1937            {14, 10}, {14, 10}, {14, 10}, {14, 10},
1938            {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
1939            {13, 10}, {13, 10}, {13, 10}, {13, 10},
1940            {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10}
1941    };
1942    
1943    short const dc_threshold[] = {
1944            21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,
1945             8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,
1946            25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,
1947            28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,
1948            30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,
1949            29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,
1950            26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,
1951            29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606
1952    };
1953    
1954    VLC const dc_lum_tab[] = {
1955            {0, 0}, {4, 3}, {3, 3}, {0, 3},
1956            {2, 2}, {2, 2}, {1, 2}, {1, 2},
1957    };
Legend:
Removed from v.809  
changed lines
  Added in v.1486
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4