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

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

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

revision 1.25.2.1, Mon Sep 23 20:36:01 2002 UTC revision 1.56, Thu Jun 28 14:55:11 2007 UTC
# Line 1  Line 1 
1   /******************************************************************************  /*****************************************************************************
2    *                                                                            *   *
3    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *   *  XVID MPEG-4 VIDEO CODEC
4    *                                                                            *   *  - MB coding -
5    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *   *
6    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *   *  Copyright (C) 2002 Michael Militzer <isibaar@xvid.org>
7    *  software module in hardware or software products are advised that its     *   *
8    *  use may infringe existing patents or copyrights, and any such use         *   *  This program is free software ; you can redistribute it and/or modify
9    *  would be at such party's own risk.  The original developer of this        *   *  it under the terms of the GNU General Public License as published by
10    *  software module and his/her company, and subsequent editors and their     *   *  the Free Software Foundation ; either version 2 of the License, or
11    *  companies, will have no liability for use of this software or             *   *  (at your option) any later version.
12    *  modifications or derivatives thereof.                                     *   *
13    *                                                                            *   *  This program is distributed in the hope that it will be useful,
14    *  XviD is free software; you can redistribute it and/or modify it           *   *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
15    *  under the terms of the GNU General Public License as published by         *   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    *  the Free Software Foundation; either version 2 of the License, or         *   *  GNU General Public License for more details.
17    *  (at your option) any later version.                                       *   *
18    *                                                                            *   *  You should have received a copy of the GNU General Public License
19    *  XviD is distributed in the hope that it will be useful, but               *   *  along with this program ; if not, write to the Free Software
20    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *   *
22    *  GNU General Public License for more details.                              *   * $Id$
23    *                                                                            *   *
24    *  You should have received a copy of the GNU General Public License         *   ****************************************************************************/
   *  along with this program; if not, write to the Free Software               *  
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *  
   *                                                                            *  
   ******************************************************************************/  
   
  /******************************************************************************  
   *                                                                            *  
   *  mbcoding.c                                                                *  
   *                                                                            *  
   *  Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org>                  *  
   *                                                                            *  
   *  For more information visit the XviD homepage: http://www.xvid.org         *  
   *                                                                            *  
   ******************************************************************************/  
   
  /******************************************************************************  
   *                                                                                                                                                        *  
   *  Revision history:                                                         *  
   *                                                                            *  
   *  28.06.2002 added check_resync_marker()                                    *  
   *  14.04.2002 bframe encoding                                                                                            *  
   *  08.03.2002 initial version; isibaar                                                           *  
   *                                                                                                                                                        *  
   ******************************************************************************/  
   
   
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 58  Line 36 
36    
37  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
38    
39  #define ABS(X) (((X)>0)?(X):-(X))  #ifdef _DEBUG
40  #define CLIP(X,A) (X > A) ? (A) : (X)  # include "../motion/estimation.h"
41    # include "../motion/motion_inlines.h"
42    # include <assert.h>
43    #endif
44    
45    
46    #define LEVELOFFSET 32
47    
48    /* Initialized once during xvid_global call
49     * RO access is thread safe */
50    static REVERSE_EVENT DCT3D[2][4096];
51    static VLC coeff_VLC[2][2][64][64];
52    
53    /* not really MB related, but VLCs are only available here */
54    void bs_put_spritetrajectory(Bitstream * bs, const int val)
55    {
56            const int code = sprite_trajectory_code[val+16384].code;
57            const int len = sprite_trajectory_code[val+16384].len;
58            const int code2 = sprite_trajectory_len[len].code;
59            const int len2 = sprite_trajectory_len[len].len;
60    
61  VLC intra_table[524032];  #if 0
62  VLC inter_table[524032];          printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
63            printf("Code2 / Len2 = %d / %d \n",code2,len2);
64    #endif
65    
66  VLC DCT3Dintra[4096];          BitstreamPutBits(bs, code2, len2);
67  VLC DCT3Dinter[4096];          if (len) BitstreamPutBits(bs, code, len);
68    }
69    
70    int bs_get_spritetrajectory(Bitstream * bs)
71    {
72            int i;
73            for (i = 0; i < 12; i++)
74            {
75                    if (BitstreamShowBits(bs, sprite_trajectory_len[i].len) == sprite_trajectory_len[i].code)
76                    {
77                            BitstreamSkip(bs, sprite_trajectory_len[i].len);
78                            return i;
79                    }
80            }
81            return -1;
82    }
83    
84  void  void
85  init_vlc_tables(void)  init_vlc_tables(void)
86  {  {
87            uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
88            int32_t l;
89    
90          int32_t k, l, i, intra, last;          for (intra = 0; intra < 2; intra++)
91          VLC *vlc[2];                  for (i = 0; i < 4096; i++)
92          VLC **coeff_ptr;                          DCT3D[intra][i].event.level = 0;
         VLC *vlc1, *vlc2;  
   
         vlc1 = DCT3Dintra;  
         vlc2 = DCT3Dinter;  
   
         vlc[0] = intra_table;  
         vlc[1] = inter_table;  
   
         // generate encoding vlc lookup tables  
         // the lookup table idea is taken from the excellent fame project by Vivien Chapellier  
         for (i = 0; i < 4; i++) {  
                 intra = i % 2;  
                 last = i / 2;  
   
                 coeff_ptr = coeff_vlc[last + 2 * intra];  
   
                 for (k = -2047; k < 2048; k++) {        // level  
                         int8_t *max_level_ptr = max_level[last + 2 * intra];  
                         int8_t *max_run_ptr = max_run[last + 2 * intra];  
   
                         for (l = 0; l < 64; l++) {      // run  
                                 int32_t level = k;  
                                 ptr_t run = l;  
   
                                 if ((abs(level) <= max_level_ptr[run]) && (run <= (uint32_t) max_run_ptr[abs(level)])) {        // level < max_level and run < max_run  
   
                                         vlc[intra]->code = 0;  
                                         vlc[intra]->len = 0;  
                                         goto loop_end;  
                                 } else {  
                                         if (level > 0)  // correct level  
                                                 level -= max_level_ptr[run];  
                                         else  
                                                 level += max_level_ptr[run];  
   
                                         if ((abs(level) <= max_level_ptr[run]) &&  
                                                 (run <= (uint32_t) max_run_ptr[abs(level)])) {  
93    
94                                                  vlc[intra]->code = 0x06;          for (intra = 0; intra < 2; intra++) {
95                                                  vlc[intra]->len = 8;                  for (last = 0; last < 2; last++) {
96                                                  goto loop_end;                          for (run = 0; run < 63 + last; run++) {
97                                    for (level = 0; level < (uint32_t)(32 << intra); level++) {
98                                            offset = !intra * LEVELOFFSET;
99                                            coeff_VLC[intra][last][level + offset][run].len = 128;
100                                    }
101                            }
102                    }
103                                          }                                          }
104    
105                                          if (level > 0)  // still here?          for (intra = 0; intra < 2; intra++) {
106                                                  level += max_level_ptr[run];    // restore level                  for (i = 0; i < 102; i++) {
107                                          else                          offset = !intra * LEVELOFFSET;
                                                 level -= max_level_ptr[run];  
108    
109                                          run -= max_run_ptr[abs(level)] + 1;     // and change run                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++) {
110                                    DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;
111                                    DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
112                            }
113    
114                                          if ((abs(level) <= max_level_ptr[run]) &&                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].code
115                                                  (run <= (uint32_t) max_run_ptr[abs(level)])) {                                  = coeff_tab[intra][i].vlc.code << 1;
116                            coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len
117                                    = coeff_tab[intra][i].vlc.len + 1;
118    
119                                                  vlc[intra]->code = 0x0e;                          if (!intra) {
120                                                  vlc[intra]->len = 9;                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code
121                                                  goto loop_end;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
122                                    coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len
123                                            = coeff_tab[intra][i].vlc.len + 1;
124                            }
125                                          }                                          }
                                         run += max_run_ptr[abs(level)] + 1;  
126                                  }                                  }
127    
128                                  vlc[intra]->code =          for (intra = 0; intra < 2; intra++) {
129                                          (uint32_t) ((l << 14) | (0x1e + last) << 20) | (1 << 13) |                  for (last = 0; last < 2; last++) {
130                                          ((k & 0xfff) << 1) | 1;                          for (run = 0; run < 63 + last; run++) {
131                                    for (level = 1; level < (uint32_t)(32 << intra); level++) {
132    
133                                  vlc[intra]->len = 30;                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
                                 vlc[intra]++;  
134                                  continue;                                  continue;
135    
136                            loop_end:                                          offset = !intra * LEVELOFFSET;
137                                  if (level != 0) {                      level_esc = level - max_level[intra][last][run];
138                                          vlc[intra]->code =                                          run_esc = run - 1 - max_run[intra][last][level];
139                                                  (vlc[intra]->  
140                                                   code << (coeff_ptr[run][abs(level) - 1].len +                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]) {
141                                                                    1)) | (coeff_ptr[run][abs(level) -                                                  escape     = ESCAPE1;
142                                                                                                                  1].code << 1);                                                  escape_len = 7 + 1;
143                                          vlc[intra]->len =                                                  run_esc    = run;
144                                                  (coeff_ptr[run][abs(level) - 1].len + 1) +                                          } else {
145                                                  vlc[intra]->len;                                                  if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {
146                                                            escape     = ESCAPE2;
147                                          if (level < 0)                                                          escape_len = 7 + 2;
148                                                  vlc[intra]->code += 1;                                                          level_esc  = level;
149                                  }                                                  } else {
150                                                            if (!intra) {
151                                  vlc[intra]++;                                                                  coeff_VLC[intra][last][level + offset][run].code
152                                                                            = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
153                                                                    coeff_VLC[intra][last][level + offset][run].len = 30;
154                                                                            coeff_VLC[intra][last][offset - level][run].code
155                                                                            = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-(int32_t)level & 0xfff) << 1) | 1;
156                                                                    coeff_VLC[intra][last][offset - level][run].len = 30;
157                          }                          }
158                                                            continue;
159                  }                  }
160          }          }
161    
162          for (i = 0; i < 4096; i++) {                                          coeff_VLC[intra][last][level + offset][run].code
163                  if (i >= 512) {                                                  = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
164                          *vlc1 = DCT3Dtab3[(i >> 5) - 16];                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
165                          *vlc2 = DCT3Dtab0[(i >> 5) - 16];                                          coeff_VLC[intra][last][level + offset][run].len
166                  } else if (i >= 128) {                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
167                          *vlc1 = DCT3Dtab4[(i >> 2) - 32];  
168                          *vlc2 = DCT3Dtab1[(i >> 2) - 32];                                          if (!intra) {
169                  } else if (i >= 8) {                                                  coeff_VLC[intra][last][offset - level][run].code
170                          *vlc1 = DCT3Dtab5[i - 8];                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
171                          *vlc2 = DCT3Dtab2[i - 8];                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
172                  } else {                                                  coeff_VLC[intra][last][offset - level][run].len
173                          *vlc1 = ERRtab[i];                                                          = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
174                          *vlc2 = ERRtab[i];                                          }
175                                    }
176    
177                                    if (!intra) {
178                                            coeff_VLC[intra][last][0][run].code
179                                                    = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
180                                            coeff_VLC[intra][last][0][run].len = 30;
181                  }                  }
182                            }
183                    }
184            }
185    
186            /* init sprite_trajectory tables
187             * even if GMC is not specified (it might be used later...) */
188    
189                  vlc1++;          sprite_trajectory_code[0+16384].code = 0;
190                  vlc2++;          sprite_trajectory_code[0+16384].len = 0;
191            for (k=0;k<14;k++) {
192                    int limit = (1<<k);
193    
194                    for (l=-(2*limit-1); l <= -limit; l++) {
195                            sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
196                            sprite_trajectory_code[l+16384].len = k+1;
197          }          }
         DCT3D[0] = DCT3Dinter;  
         DCT3D[1] = DCT3Dintra;  
198    
199                    for (l=limit; l<= 2*limit-1; l++) {
200                            sprite_trajectory_code[l+16384].code = l;
201                            sprite_trajectory_code[l+16384].len = k+1;
202                    }
203            }
204  }  }
205    
206  static __inline void  static __inline void
207  CodeVector(Bitstream * bs,  CodeVector(Bitstream * bs,
208                     int32_t value,                     int32_t value,
209                     int32_t f_code,                     int32_t f_code)
                    Statistics * pStat)  
210  {  {
211    
212          const int scale_factor = 1 << (f_code - 1);          const int scale_factor = 1 << (f_code - 1);
# Line 201  Line 218 
218          if (value > (cmp - 1))          if (value > (cmp - 1))
219                  value -= 64 * scale_factor;                  value -= 64 * scale_factor;
220    
         pStat->iMvSum += value * value;  
         pStat->iMvCount++;  
   
221          if (value == 0) {          if (value == 0) {
222                  BitstreamPutBits(bs, mb_motion_table[32].code,                  BitstreamPutBits(bs, mb_motion_table[32].code,
223                                                   mb_motion_table[32].len);                                                   mb_motion_table[32].len);
# Line 240  Line 254 
254    
255  }  }
256    
257    static __inline void
258    CodeCoeffInter(Bitstream * bs,
259                      const int16_t qcoeff[64],
260                      const uint16_t * zigzag)
261    {
262            uint32_t i, run, prev_run, code, len;
263            int32_t level, prev_level, level_shifted;
264    
265            i       = 0;
266            run = 0;
267    
268            while (!(level = qcoeff[zigzag[i++]]))
269                    run++;
270    
271            prev_level = level;
272            prev_run   = run;
273            run = 0;
274    
275            while (i < 64)
276            {
277                    if ((level = qcoeff[zigzag[i++]]) != 0)
278                    {
279                            level_shifted = prev_level + 32;
280                            if (!(level_shifted & -64))
281                            {
282                                    code = coeff_VLC[0][0][level_shifted][prev_run].code;
283                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
284                            }
285                            else
286                            {
287                                    code = (ESCAPE3 << 21) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
288                                    len  = 30;
289                            }
290                            BitstreamPutBits(bs, code, len);
291                            prev_level = level;
292                            prev_run   = run;
293                            run = 0;
294                    }
295                    else
296                            run++;
297            }
298    
299            level_shifted = prev_level + 32;
300            if (!(level_shifted & -64))
301            {
302                    code = coeff_VLC[0][1][level_shifted][prev_run].code;
303                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
304            }
305            else
306            {
307                    code = (ESCAPE3 << 21) | (1 << 20) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
308                    len  = 30;
309            }
310            BitstreamPutBits(bs, code, len);
311    }
312    
313  static __inline void  static __inline void
314  CodeCoeff(Bitstream * bs,  CodeCoeffIntra(Bitstream * bs,
315                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
316                    VLC * table,                    const uint16_t * zigzag)
                   const uint16_t * zigzag,  
                   uint16_t intra)  
317  {  {
318            uint32_t i, abs_level, run, prev_run, code, len;
319            int32_t level, prev_level;
320    
321          uint32_t j, last;          i       = 1;
322          short v;          run = 0;
         VLC *vlc;  
323    
324          j = intra;          while (i<64 && !(level = qcoeff[zigzag[i++]]))
325          last = intra;                  run++;
326    
327          while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)          prev_level = level;
328                  j++;          prev_run   = run;
329            run = 0;
330    
331          do {          while (i < 64)
332                  vlc = table + 64 * 2047 + (v << 6) + j - last;          {
333                  last = ++j;                  if ((level = qcoeff[zigzag[i++]]) != 0)
334                    {
335                            abs_level = abs(prev_level);
336                            abs_level = abs_level < 64 ? abs_level : 0;
337                            code      = coeff_VLC[1][0][abs_level][prev_run].code;
338                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
339                            if (len != 128)
340                                    code |= (prev_level < 0);
341                            else
342                            {
343                            code = (ESCAPE3 << 21) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
344                                    len  = 30;
345                            }
346                            BitstreamPutBits(bs, code, len);
347                            prev_level = level;
348                            prev_run   = run;
349                            run = 0;
350                    }
351                    else
352                            run++;
353            }
354    
355                  // count zeroes          abs_level = abs(prev_level);
356                  while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)          abs_level = abs_level < 64 ? abs_level : 0;
357                          j++;          code      = coeff_VLC[1][1][abs_level][prev_run].code;
358            len               = coeff_VLC[1][1][abs_level][prev_run].len;
359                  // write code          if (len != 128)
360                  if (j != 64) {                  code |= (prev_level < 0);
361                          BitstreamPutBits(bs, vlc->code, vlc->len);          else
362                  } else {          {
363                          vlc += 64 * 4095;                  code = (ESCAPE3 << 21) | (1 << 20) | (prev_run << 14) | (1 << 13) | ((prev_level & 0xfff) << 1) | 1;
364                          BitstreamPutBits(bs, vlc->code, vlc->len);                  len  = 30;
365                          break;          }
366            BitstreamPutBits(bs, code, len);
367                  }                  }
         } while (1);  
368    
369    
370    
371    /* returns the number of bits required to encode qcoeff */
372    
373    int
374    CodeCoeffIntra_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
375    {
376            int bits = 0;
377            uint32_t i, abs_level, run, prev_run, len;
378            int32_t level, prev_level;
379    
380            i       = 1;
381            run = 0;
382    
383            while (i<64 && !(level = qcoeff[zigzag[i++]]))
384                    run++;
385    
386            if (i >= 64) return 0;  /* empty block */
387    
388            prev_level = level;
389            prev_run   = run;
390            run = 0;
391    
392            while (i < 64)
393            {
394                    if ((level = qcoeff[zigzag[i++]]) != 0)
395                    {
396                            abs_level = abs(prev_level);
397                            abs_level = abs_level < 64 ? abs_level : 0;
398                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
399                            bits      += len!=128 ? len : 30;
400    
401                            prev_level = level;
402                            prev_run   = run;
403                            run = 0;
404                    }
405                    else
406                            run++;
407            }
408    
409            abs_level = abs(prev_level);
410            abs_level = abs_level < 64 ? abs_level : 0;
411            len               = coeff_VLC[1][1][abs_level][prev_run].len;
412            bits      += len!=128 ? len : 30;
413    
414            return bits;
415  }  }
416    
417    int
418    CodeCoeffInter_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
419    {
420            uint32_t i, run, prev_run, len;
421            int32_t level, prev_level, level_shifted;
422            int bits = 0;
423    
424            i       = 0;
425            run = 0;
426    
427            while (!(level = qcoeff[zigzag[i++]]))
428                    run++;
429    
430            prev_level = level;
431            prev_run   = run;
432            run = 0;
433    
434            while (i < 64) {
435                    if ((level = qcoeff[zigzag[i++]]) != 0) {
436                            level_shifted = prev_level + 32;
437                            if (!(level_shifted & -64))
438                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
439                            else
440                                    len  = 30;
441    
442                            bits += len;
443                            prev_level = level;
444                            prev_run   = run;
445                            run = 0;
446                    }
447                    else
448                            run++;
449            }
450    
451            level_shifted = prev_level + 32;
452            if (!(level_shifted & -64))
453                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
454            else
455                    len  = 30;
456            bits += len;
457    
458            return bits;
459    }
460    
461    static const int iDQtab[5] = {
462            1, 0, -1 /* no change */, 2, 3
463    };
464    #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
465    
466    
467  static __inline void  static __inline void
468  CodeBlockIntra(const FRAMEINFO * frame,  CodeBlockIntra(const FRAMEINFO * const frame,
469                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
470                             int16_t qcoeff[6 * 64],                             int16_t qcoeff[6 * 64],
471                             Bitstream * bs,                             Bitstream * bs,
# Line 292  Line 476 
476    
477          cbpy = pMB->cbp >> 2;          cbpy = pMB->cbp >> 2;
478    
479          // write mcbpc          /* write mcbpc */
480          if (frame->coding_type == I_VOP) {          if (frame->coding_type == I_VOP) {
481                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
482                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
# Line 303  Line 487 
487                                                   mcbpc_inter_tab[mcbpc].len);                                                   mcbpc_inter_tab[mcbpc].len);
488          }          }
489    
490          // ac prediction flag          /* ac prediction flag */
491          if (pMB->acpred_directions[0])          if (pMB->acpred_directions[0])
492                  BitstreamPutBits(bs, 1, 1);                  BitstreamPutBits(bs, 1, 1);
493          else          else
494                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
495    
496          // write cbpy          /* write cbpy */
497          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
498    
499          // write dquant          /* write dquant */
500          if (pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA_Q)
501                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
502    
503          // write interlacing          /* write interlacing */
504          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
505                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
506          }          }
507          // code block coeffs          /* code block coeffs */
508          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
509                  if (i < 4)                  if (i < 4)
510                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
# Line 330  Line 514 
514                                                           dcc_tab[qcoeff[i * 64 + 0] + 255].len);                                                           dcc_tab[qcoeff[i * 64 + 0] + 255].len);
515    
516                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i))) {
517                            const uint16_t *scan_table =
518                                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
519                                    scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
520    
521                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
522    
523                          CodeCoeff(bs, &qcoeff[i * 64], intra_table,                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
                                           scan_tables[pMB->acpred_directions[i]], 1);  
524    
525                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
526                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 344  Line 531 
531    
532    
533  static void  static void
534  CodeBlockInter(const FRAMEINFO * frame,  CodeBlockInter(const FRAMEINFO * const frame,
535                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
536                             int16_t qcoeff[6 * 64],                             int16_t qcoeff[6 * 64],
537                             Bitstream * bs,                             Bitstream * bs,
# Line 357  Line 544 
544          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
545          cbpy = 15 - (pMB->cbp >> 2);          cbpy = 15 - (pMB->cbp >> 2);
546    
547          // write mcbpc          /* write mcbpc */
548          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
549                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
550    
551          // write cbpy          if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
552          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);                  BitstreamPutBit(bs, pMB->mcsel);                /* mcsel: '0'=local motion, '1'=GMC */
553    
554            /* write cbpy */
555            BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
556    
557          // write dquant          /* write dquant */
558          if (pMB->mode == MODE_INTER_Q)          if (pMB->mode == MODE_INTER_Q)
559                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
560    
561          // interlacing          /* interlacing */
562          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
563                  if (pMB->cbp) {                  if (pMB->cbp) {
564                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
565                          DEBUG1("codep: field_dct: ", pMB->field_dct);                          DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);
566                  }                  }
567    
568                  // if inter block, write field ME flag                  /* if inter block, write field ME flag */
569                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
570                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
571                          DEBUG1("codep: field_pred: ", pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
572    
573                          // write field prediction references                          /* write field prediction references */
574    #if 0 /* Remove the #if once field_pred is supported */
575                          if (pMB->field_pred) {                          if (pMB->field_pred) {
576                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
577                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
578                          }                          }
579    #endif
580                  }                  }
581          }          }
582          // code motion vector(s)  
583            bits = BitstreamPos(bs);
584    
585            /* code motion vector(s) if motion is local  */
586            if (!pMB->mcsel)
587          for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {          for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
588                  CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode);
589                  CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode);
590    
591    #ifdef _DEBUG
592                            if (i == 0) /* for simplicity */ {
593                                    int coded_length = BitstreamPos(bs) - bits;
594                                    int estimated_length = d_mv_bits(pMB->pmvs[i].x, pMB->pmvs[i].y, zeroMV, frame->fcode, 0);
595                                    assert(estimated_length == coded_length);
596                                    d_mv_bits(pMB->pmvs[i].x, pMB->pmvs[i].y, zeroMV, frame->fcode, 0);
597                            }
598    #endif
599          }          }
600    
601            bits = BitstreamPos(bs) - bits;
602            pStat->iMVBits += bits;
603    
604          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
605    
606          // code block coeffs          /* code block coeffs */
607          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
608                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
609                          CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);                          const uint16_t *scan_table =
610                                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
611                                    scan_tables[2] : scan_tables[0];
612    
613                            CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
614                    }
615    
616          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
617          pStat->iTextBits += bits;          pStat->iTextBits += bits;
   
618  }  }
619    
620    
621  void  void
622  MBCoding(const FRAMEINFO * frame,  MBCoding(const FRAMEINFO * const frame,
623                   MACROBLOCK * pMB,                   MACROBLOCK * pMB,
624                   int16_t qcoeff[6 * 64],                   int16_t qcoeff[6 * 64],
625                   Bitstream * bs,                   Bitstream * bs,
626                   Statistics * pStat)                   Statistics * pStat)
627  {  {
628            if (frame->coding_type != I_VOP)
629                            BitstreamPutBit(bs, 0); /* not_coded */
630    
631          if (frame->coding_type == P_VOP) {          if (frame->vop_flags & XVID_VOP_GREYSCALE) {
632                          BitstreamPutBit(bs, 0); // coded                  pMB->cbp &= 0x3C;               /* keep only bits 5-2 */
633                    qcoeff[4*64+0]=0;               /* for INTRA DC value is saved */
634                    qcoeff[5*64+0]=0;
635          }          }
636    
637          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
# Line 425  Line 641 
641    
642  }  }
643    
 /*  
 // moved to mbcoding.h so that in can be 'static __inline'  
 void  
 MBSkip(Bitstream * bs)  
 {  
         BitstreamPutBit(bs, 1); // not coded  
 }  
 */  
   
644  /***************************************************************  /***************************************************************
645   * bframe encoding start   * bframe encoding start
646   ***************************************************************/   ***************************************************************/
# Line 490  Line 697 
697                  BitstreamPutBit(bs, 1);                  BitstreamPutBit(bs, 1);
698                  return;                  return;
699    
700          default:;                                       // invalid          default:;                                       /* invalid */
701          }          }
702  }  }
703    
704    
705    
706  void  void
707  MBCodingBVOP(const MACROBLOCK * mb,  MBCodingBVOP(const FRAMEINFO * const frame,
708                             const MACROBLOCK * mb,
709                           const int16_t qcoeff[6 * 64],                           const int16_t qcoeff[6 * 64],
710                           const int32_t fcode,                           const int32_t fcode,
711                           const int32_t bcode,                           const int32_t bcode,
# Line 507  Line 715 
715          int vcode = fcode;          int vcode = fcode;
716          unsigned int i;          unsigned int i;
717    
718            const uint16_t *scan_table =
719                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
720                    scan_tables[2] : scan_tables[0];
721            int bits;
722    
723  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
724                  when a block is skipped it is decoded DIRECT(0,0)                  when a block is skipped it is decoded DIRECT(0,0)
725                  hence is interpolated from forward & backward frames                  hence is interpolated from forward & backward frames
726          ------------------------------------------------------------------ */          ------------------------------------------------------------------ */
727    
728          if (mb->mode == MODE_DIRECT_NONE_MV) {          if (mb->mode == MODE_DIRECT_NONE_MV) {
729                  BitstreamPutBit(bs, 1); // skipped                  BitstreamPutBit(bs, 1); /* skipped */
730                  return;                  return;
731          }          }
732    
733          BitstreamPutBit(bs, 0);         // not skipped          BitstreamPutBit(bs, 0);         /* not skipped */
734    
735          if (mb->cbp == 0) {          if (mb->cbp == 0) {
736                  BitstreamPutBit(bs, 1); // cbp == 0                  BitstreamPutBit(bs, 1); /* cbp == 0 */
737          } else {          } else {
738                  BitstreamPutBit(bs, 0); // cbp == xxx                  BitstreamPutBit(bs, 0); /* cbp == xxx */
739          }          }
740    
741          put_bvop_mbtype(bs, mb->mode);          put_bvop_mbtype(bs, mb->mode);
# Line 532  Line 745 
745          }          }
746    
747          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
748                  put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0                  put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */
749            }
750    
751            if (frame->vol_flags & XVID_VOL_INTERLACING) {
752                    if (mb->cbp) {
753                            BitstreamPutBit(bs, mb->field_dct);
754                            DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);
755          }          }
756    
757                    /* if not direct block, write field ME flag */
758                    if (mb->mode != MODE_DIRECT) {
759                            BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
760    
761                            /* write field prediction references */
762    #if 0 /* Remove the #if once field_pred is supported */
763                            if (mb->field_pred) {
764                                    BitstreamPutBit(bs, mb->field_for_top);
765                                    BitstreamPutBit(bs, mb->field_for_bot);
766                            }
767    #endif
768                    }
769            }
770    
771            bits = BitstreamPos(bs);
772    
773          switch (mb->mode) {          switch (mb->mode) {
774                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
775                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); //forward vector of interpolate mode                          CodeVector(bs, mb->pmvs[1].x, vcode); /* forward vector of interpolate mode */
776                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode);
777                  case MODE_BACKWARD:                  case MODE_BACKWARD:
778                          vcode = bcode;                          vcode = bcode;
779                  case MODE_FORWARD:                  case MODE_FORWARD:
780                          CodeVector(bs, mb->pmvs[0].x, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].x, vcode);
781                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode);
782                          break;                          break;
783                  case MODE_DIRECT:                  case MODE_DIRECT:
784                          CodeVector(bs, mb->pmvs[3].x, 1, pStat);        // fcode is always 1 for delta vector                          CodeVector(bs, mb->pmvs[3].x, 1);       /* fcode is always 1 for delta vector */
785                          CodeVector(bs, mb->pmvs[3].y, 1, pStat);        // prediction is always (0,0)                          CodeVector(bs, mb->pmvs[3].y, 1);       /* prediction is always (0,0) */
786                  default: break;                  default: break;
787          }          }
788            pStat->iMVBits += BitstreamPos(bs) - bits;
789    
790            bits = BitstreamPos(bs);
791          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
792                  if (mb->cbp & (1 << (5 - i))) {                  if (mb->cbp & (1 << (5 - i))) {
793                          CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
794                  }                  }
795          }          }
796            pStat->iTextBits += BitstreamPos(bs) - bits;
797  }  }
798    
799    
# Line 565  Line 803 
803   ***************************************************************/   ***************************************************************/
804    
805    
806  // for IVOP addbits == 0  /*
807  // for PVOP addbits == fcode - 1   * for IVOP addbits == 0
808  // for BVOP addbits == max(fcode,bcode) - 1   * for PVOP addbits == fcode - 1
809  // returns true or false   * for BVOP addbits == max(fcode,bcode) - 1
810     * returns true or false
811     */
812  int  int
813  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
814  {  {
# Line 610  Line 850 
850    
851          uint32_t index;          uint32_t index;
852    
853          index = CLIP(BitstreamShowBits(bs, 9), 256);          index = MIN(BitstreamShowBits(bs, 9), 256);
854    
855          BitstreamSkip(bs, mcbpc_inter_table[index].len);          BitstreamSkip(bs, mcbpc_inter_table[index].len);
856    
# Line 682  Line 922 
922                  return data;                  return data;
923    
924          res = BitstreamGetBits(bs, fcode - 1);          res = BitstreamGetBits(bs, fcode - 1);
925          mv = ((ABS(data) - 1) * scale_fac) + res + 1;          mv = ((abs(data) - 1) * scale_fac) + res + 1;
926    
927          return data < 0 ? -mv : mv;          return data < 0 ? -mv : mv;
928    
# Line 745  Line 985 
985    
986  }  }
987    
988    #define GET_BITS(cache, n) ((cache)>>(32-(n)))
989    
990    static __inline int
991    get_coeff(Bitstream * bs,
992                      int *run,
993                      int *last,
994                      int intra,
995                      int short_video_header)
996    {
997    
998            uint32_t mode;
999            int32_t level;
1000            REVERSE_EVENT *reverse_event;
1001    
1002            uint32_t cache = BitstreamShowBits(bs, 32);
1003    
1004            if (short_video_header)         /* inter-VLCs will be used for both intra and inter blocks */
1005                    intra = 0;
1006    
1007            if (GET_BITS(cache, 7) != ESCAPE) {
1008                    reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1009    
1010                    if ((level = reverse_event->event.level) == 0)
1011                            goto error;
1012    
1013                    *last = reverse_event->event.last;
1014                    *run  = reverse_event->event.run;
1015    
1016                    /* Don't forget to update the bitstream position */
1017                    BitstreamSkip(bs, reverse_event->len+1);
1018    
1019                    return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1020            }
1021    
1022            /* flush 7bits of cache */
1023            cache <<= 7;
1024    
1025            if (short_video_header) {
1026                    /* escape mode 4 - H.263 type, only used if short_video_header = 1  */
1027                    *last =  GET_BITS(cache, 1);
1028                    *run  = (GET_BITS(cache, 7) &0x3f);
1029                    level = (GET_BITS(cache, 15)&0xff);
1030    
1031                    if (level == 0 || level == 128)
1032                            DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1033    
1034                    /* We've "eaten" 22 bits */
1035                    BitstreamSkip(bs, 22);
1036    
1037                    return (level << 24) >> 24;
1038            }
1039    
1040            if ((mode = GET_BITS(cache, 2)) < 3) {
1041                    const int skip[3] = {1, 1, 2};
1042                    cache <<= skip[mode];
1043    
1044                    reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1045    
1046                    if ((level = reverse_event->event.level) == 0)
1047                            goto error;
1048    
1049                    *last = reverse_event->event.last;
1050                    *run  = reverse_event->event.run;
1051    
1052                    if (mode < 2) {
1053                            /* first escape mode, level is offset */
1054                            level += max_level[intra][*last][*run];
1055                    } else {
1056                            /* second escape mode, run is offset */
1057                            *run += max_run[intra][*last][level] + 1;
1058                    }
1059    
1060                    /* Update bitstream position */
1061                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1062    
1063                    return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1064            }
1065    
1066            /* third escape mode - fixed length codes */
1067            cache <<= 2;
1068            *last =  GET_BITS(cache, 1);
1069            *run  = (GET_BITS(cache, 7)&0x3f);
1070            level = (GET_BITS(cache, 20)&0xfff);
1071    
1072            /* Update bitstream position */
1073            BitstreamSkip(bs, 30);
1074    
1075            return (level << 20) >> 20;
1076    
1077      error:
1078            *run = 64;
1079            return 0;
1080    }
1081    
1082  void  void
1083  get_intra_block(Bitstream * bs,  get_intra_block(Bitstream * bs,
1084                                  int16_t * block,                                  int16_t * block,
# Line 757  Line 1091 
1091    
1092          do {          do {
1093                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1094                  if (run == -1) {                  coeff += run;
1095                          DEBUG("fatal: invalid run");                  if (coeff & ~63) {
1096                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1097                          break;                          break;
1098                  }                  }
1099                  coeff += run;  
1100                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1101    
1102                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1103                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));  #if 0
1104                    DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1105    #endif
1106    
1107                  if (level < -127 || level > 127) {                  if (level < -2047 || level > 2047) {
1108                          DEBUG1("warning: intra_overflow", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1109                  }                  }
1110                  coeff++;                  coeff++;
1111          } while (!last);          } while (!last);
# Line 776  Line 1113 
1113  }  }
1114    
1115  void  void
1116  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1117                                  int16_t * block)                  Bitstream * bs,
1118                    int16_t * block,
1119                    int direction,
1120                    const int quant,
1121                    const uint16_t *matrix)
1122  {  {
1123    
1124          const uint16_t *scan = scan_tables[0];          const uint16_t *scan = scan_tables[direction];
1125            const uint16_t quant_m_2 = quant << 1;
1126            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1127          int p;          int p;
1128          int level;          int level;
1129          int run;          int run;
# Line 789  Line 1132 
1132          p = 0;          p = 0;
1133          do {          do {
1134                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1135                  if (run == -1) {                  p += run;
1136                          DEBUG("fatal: invalid run");                  if (p & ~63) {
1137                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1138                          break;                          break;
1139                  }                  }
                 p += run;  
1140    
1141                  block[scan[p]] = level;                  if (level < 0) {
1142                            level = level*quant_m_2 - quant_add;
1143                            block[scan[p]] = (level >= -2048 ? level : -2048);
1144                    } else {
1145                            level = level * quant_m_2 + quant_add;
1146                            block[scan[p]] = (level <= 2047 ? level : 2047);
1147                    }
1148                    p++;
1149            } while (!last);
1150    }
1151    
1152    void
1153    get_inter_block_mpeg(
1154                    Bitstream * bs,
1155                    int16_t * block,
1156                    int direction,
1157                    const int quant,
1158                    const uint16_t *matrix)
1159    {
1160            const uint16_t *scan = scan_tables[direction];
1161            uint32_t sum = 0;
1162            int p;
1163            int level;
1164            int run;
1165            int last;
1166    
1167                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);          p = 0;
1168                  // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));          do {
1169                    level = get_coeff(bs, &run, &last, 0, 0);
1170                    p += run;
1171                    if (p & ~63) {
1172                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1173                            break;
1174                    }
1175    
1176                  if (level < -127 || level > 127) {                  if (level < 0) {
1177                          DEBUG1("warning: inter_overflow", level);                          level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1178                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1179                    } else {
1180                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1181                            block[scan[p]] = (level <= 2047 ? level : 2047);
1182                  }                  }
1183    
1184                    sum ^= block[scan[p]];
1185    
1186                  p++;                  p++;
1187          } while (!last);          } while (!last);
1188    
1189  }          /*      mismatch control */
1190            if ((sum & 1) == 0) {
1191                    block[63] ^= 1;
1192            }
1193    }
1194    
1195    
1196    /*****************************************************************************
1197     * VLC tables and other constant arrays
1198     ****************************************************************************/
1199    
1200    VLC_TABLE const coeff_tab[2][102] =
1201    {
1202            /* intra = 0 */
1203            {
1204                    {{ 2,  2}, {0, 0, 1}},
1205                    {{15,  4}, {0, 0, 2}},
1206                    {{21,  6}, {0, 0, 3}},
1207                    {{23,  7}, {0, 0, 4}},
1208                    {{31,  8}, {0, 0, 5}},
1209                    {{37,  9}, {0, 0, 6}},
1210                    {{36,  9}, {0, 0, 7}},
1211                    {{33, 10}, {0, 0, 8}},
1212                    {{32, 10}, {0, 0, 9}},
1213                    {{ 7, 11}, {0, 0, 10}},
1214                    {{ 6, 11}, {0, 0, 11}},
1215                    {{32, 11}, {0, 0, 12}},
1216                    {{ 6,  3}, {0, 1, 1}},
1217                    {{20,  6}, {0, 1, 2}},
1218                    {{30,  8}, {0, 1, 3}},
1219                    {{15, 10}, {0, 1, 4}},
1220                    {{33, 11}, {0, 1, 5}},
1221                    {{80, 12}, {0, 1, 6}},
1222                    {{14,  4}, {0, 2, 1}},
1223                    {{29,  8}, {0, 2, 2}},
1224                    {{14, 10}, {0, 2, 3}},
1225                    {{81, 12}, {0, 2, 4}},
1226                    {{13,  5}, {0, 3, 1}},
1227                    {{35,  9}, {0, 3, 2}},
1228                    {{13, 10}, {0, 3, 3}},
1229                    {{12,  5}, {0, 4, 1}},
1230                    {{34,  9}, {0, 4, 2}},
1231                    {{82, 12}, {0, 4, 3}},
1232                    {{11,  5}, {0, 5, 1}},
1233                    {{12, 10}, {0, 5, 2}},
1234                    {{83, 12}, {0, 5, 3}},
1235                    {{19,  6}, {0, 6, 1}},
1236                    {{11, 10}, {0, 6, 2}},
1237                    {{84, 12}, {0, 6, 3}},
1238                    {{18,  6}, {0, 7, 1}},
1239                    {{10, 10}, {0, 7, 2}},
1240                    {{17,  6}, {0, 8, 1}},
1241                    {{ 9, 10}, {0, 8, 2}},
1242                    {{16,  6}, {0, 9, 1}},
1243                    {{ 8, 10}, {0, 9, 2}},
1244                    {{22,  7}, {0, 10, 1}},
1245                    {{85, 12}, {0, 10, 2}},
1246                    {{21,  7}, {0, 11, 1}},
1247                    {{20,  7}, {0, 12, 1}},
1248                    {{28,  8}, {0, 13, 1}},
1249                    {{27,  8}, {0, 14, 1}},
1250                    {{33,  9}, {0, 15, 1}},
1251                    {{32,  9}, {0, 16, 1}},
1252                    {{31,  9}, {0, 17, 1}},
1253                    {{30,  9}, {0, 18, 1}},
1254                    {{29,  9}, {0, 19, 1}},
1255                    {{28,  9}, {0, 20, 1}},
1256                    {{27,  9}, {0, 21, 1}},
1257                    {{26,  9}, {0, 22, 1}},
1258                    {{34, 11}, {0, 23, 1}},
1259                    {{35, 11}, {0, 24, 1}},
1260                    {{86, 12}, {0, 25, 1}},
1261                    {{87, 12}, {0, 26, 1}},
1262                    {{ 7,  4}, {1, 0, 1}},
1263                    {{25,  9}, {1, 0, 2}},
1264                    {{ 5, 11}, {1, 0, 3}},
1265                    {{15,  6}, {1, 1, 1}},
1266                    {{ 4, 11}, {1, 1, 2}},
1267                    {{14,  6}, {1, 2, 1}},
1268                    {{13,  6}, {1, 3, 1}},
1269                    {{12,  6}, {1, 4, 1}},
1270                    {{19,  7}, {1, 5, 1}},
1271                    {{18,  7}, {1, 6, 1}},
1272                    {{17,  7}, {1, 7, 1}},
1273                    {{16,  7}, {1, 8, 1}},
1274                    {{26,  8}, {1, 9, 1}},
1275                    {{25,  8}, {1, 10, 1}},
1276                    {{24,  8}, {1, 11, 1}},
1277                    {{23,  8}, {1, 12, 1}},
1278                    {{22,  8}, {1, 13, 1}},
1279                    {{21,  8}, {1, 14, 1}},
1280                    {{20,  8}, {1, 15, 1}},
1281                    {{19,  8}, {1, 16, 1}},
1282                    {{24,  9}, {1, 17, 1}},
1283                    {{23,  9}, {1, 18, 1}},
1284                    {{22,  9}, {1, 19, 1}},
1285                    {{21,  9}, {1, 20, 1}},
1286                    {{20,  9}, {1, 21, 1}},
1287                    {{19,  9}, {1, 22, 1}},
1288                    {{18,  9}, {1, 23, 1}},
1289                    {{17,  9}, {1, 24, 1}},
1290                    {{ 7, 10}, {1, 25, 1}},
1291                    {{ 6, 10}, {1, 26, 1}},
1292                    {{ 5, 10}, {1, 27, 1}},
1293                    {{ 4, 10}, {1, 28, 1}},
1294                    {{36, 11}, {1, 29, 1}},
1295                    {{37, 11}, {1, 30, 1}},
1296                    {{38, 11}, {1, 31, 1}},
1297                    {{39, 11}, {1, 32, 1}},
1298                    {{88, 12}, {1, 33, 1}},
1299                    {{89, 12}, {1, 34, 1}},
1300                    {{90, 12}, {1, 35, 1}},
1301                    {{91, 12}, {1, 36, 1}},
1302                    {{92, 12}, {1, 37, 1}},
1303                    {{93, 12}, {1, 38, 1}},
1304                    {{94, 12}, {1, 39, 1}},
1305                    {{95, 12}, {1, 40, 1}}
1306            },
1307            /* intra = 1 */
1308            {
1309                    {{ 2,  2}, {0, 0, 1}},
1310                    {{15,  4}, {0, 0, 3}},
1311                    {{21,  6}, {0, 0, 6}},
1312                    {{23,  7}, {0, 0, 9}},
1313                    {{31,  8}, {0, 0, 10}},
1314                    {{37,  9}, {0, 0, 13}},
1315                    {{36,  9}, {0, 0, 14}},
1316                    {{33, 10}, {0, 0, 17}},
1317                    {{32, 10}, {0, 0, 18}},
1318                    {{ 7, 11}, {0, 0, 21}},
1319                    {{ 6, 11}, {0, 0, 22}},
1320                    {{32, 11}, {0, 0, 23}},
1321                    {{ 6,  3}, {0, 0, 2}},
1322                    {{20,  6}, {0, 1, 2}},
1323                    {{30,  8}, {0, 0, 11}},
1324                    {{15, 10}, {0, 0, 19}},
1325                    {{33, 11}, {0, 0, 24}},
1326                    {{80, 12}, {0, 0, 25}},
1327                    {{14,  4}, {0, 1, 1}},
1328                    {{29,  8}, {0, 0, 12}},
1329                    {{14, 10}, {0, 0, 20}},
1330                    {{81, 12}, {0, 0, 26}},
1331                    {{13,  5}, {0, 0, 4}},
1332                    {{35,  9}, {0, 0, 15}},
1333                    {{13, 10}, {0, 1, 7}},
1334                    {{12,  5}, {0, 0, 5}},
1335                    {{34,  9}, {0, 4, 2}},
1336                    {{82, 12}, {0, 0, 27}},
1337                    {{11,  5}, {0, 2, 1}},
1338                    {{12, 10}, {0, 2, 4}},
1339                    {{83, 12}, {0, 1, 9}},
1340                    {{19,  6}, {0, 0, 7}},
1341                    {{11, 10}, {0, 3, 4}},
1342                    {{84, 12}, {0, 6, 3}},
1343                    {{18,  6}, {0, 0, 8}},
1344                    {{10, 10}, {0, 4, 3}},
1345                    {{17,  6}, {0, 3, 1}},
1346                    {{ 9, 10}, {0, 8, 2}},
1347                    {{16,  6}, {0, 4, 1}},
1348                    {{ 8, 10}, {0, 5, 3}},
1349                    {{22,  7}, {0, 1, 3}},
1350                    {{85, 12}, {0, 1, 10}},
1351                    {{21,  7}, {0, 2, 2}},
1352                    {{20,  7}, {0, 7, 1}},
1353                    {{28,  8}, {0, 1, 4}},
1354                    {{27,  8}, {0, 3, 2}},
1355                    {{33,  9}, {0, 0, 16}},
1356                    {{32,  9}, {0, 1, 5}},
1357                    {{31,  9}, {0, 1, 6}},
1358                    {{30,  9}, {0, 2, 3}},
1359                    {{29,  9}, {0, 3, 3}},
1360                    {{28,  9}, {0, 5, 2}},
1361                    {{27,  9}, {0, 6, 2}},
1362                    {{26,  9}, {0, 7, 2}},
1363                    {{34, 11}, {0, 1, 8}},
1364                    {{35, 11}, {0, 9, 2}},
1365                    {{86, 12}, {0, 2, 5}},
1366                    {{87, 12}, {0, 7, 3}},
1367                    {{ 7,  4}, {1, 0, 1}},
1368                    {{25,  9}, {0, 11, 1}},
1369                    {{ 5, 11}, {1, 0, 6}},
1370                    {{15,  6}, {1, 1, 1}},
1371                    {{ 4, 11}, {1, 0, 7}},
1372                    {{14,  6}, {1, 2, 1}},
1373                    {{13,  6}, {0, 5, 1}},
1374                    {{12,  6}, {1, 0, 2}},
1375                    {{19,  7}, {1, 5, 1}},
1376                    {{18,  7}, {0, 6, 1}},
1377                    {{17,  7}, {1, 3, 1}},
1378                    {{16,  7}, {1, 4, 1}},
1379                    {{26,  8}, {1, 9, 1}},
1380                    {{25,  8}, {0, 8, 1}},
1381                    {{24,  8}, {0, 9, 1}},
1382                    {{23,  8}, {0, 10, 1}},
1383                    {{22,  8}, {1, 0, 3}},
1384                    {{21,  8}, {1, 6, 1}},
1385                    {{20,  8}, {1, 7, 1}},
1386                    {{19,  8}, {1, 8, 1}},
1387                    {{24,  9}, {0, 12, 1}},
1388                    {{23,  9}, {1, 0, 4}},
1389                    {{22,  9}, {1, 1, 2}},
1390                    {{21,  9}, {1, 10, 1}},
1391                    {{20,  9}, {1, 11, 1}},
1392                    {{19,  9}, {1, 12, 1}},
1393                    {{18,  9}, {1, 13, 1}},
1394                    {{17,  9}, {1, 14, 1}},
1395                    {{ 7, 10}, {0, 13, 1}},
1396                    {{ 6, 10}, {1, 0, 5}},
1397                    {{ 5, 10}, {1, 1, 3}},
1398                    {{ 4, 10}, {1, 2, 2}},
1399                    {{36, 11}, {1, 3, 2}},
1400                    {{37, 11}, {1, 4, 2}},
1401                    {{38, 11}, {1, 15, 1}},
1402                    {{39, 11}, {1, 16, 1}},
1403                    {{88, 12}, {0, 14, 1}},
1404                    {{89, 12}, {1, 0, 8}},
1405                    {{90, 12}, {1, 5, 2}},
1406                    {{91, 12}, {1, 6, 2}},
1407                    {{92, 12}, {1, 17, 1}},
1408                    {{93, 12}, {1, 18, 1}},
1409                    {{94, 12}, {1, 19, 1}},
1410                    {{95, 12}, {1, 20, 1}}
1411            }
1412    };
1413    
1414    /* constants taken from momusys/vm_common/inlcude/max_level.h */
1415    uint8_t const max_level[2][2][64] = {
1416            {
1417                    /* intra = 0, last = 0 */
1418                    {
1419                            12, 6, 4, 3, 3, 3, 3, 2,
1420                            2, 2, 2, 1, 1, 1, 1, 1,
1421                            1, 1, 1, 1, 1, 1, 1, 1,
1422                            1, 1, 1, 0, 0, 0, 0, 0,
1423                            0, 0, 0, 0, 0, 0, 0, 0,
1424                            0, 0, 0, 0, 0, 0, 0, 0,
1425                            0, 0, 0, 0, 0, 0, 0, 0,
1426                            0, 0, 0, 0, 0, 0, 0, 0
1427                    },
1428                    /* intra = 0, last = 1 */
1429                    {
1430                            3, 2, 1, 1, 1, 1, 1, 1,
1431                            1, 1, 1, 1, 1, 1, 1, 1,
1432                            1, 1, 1, 1, 1, 1, 1, 1,
1433                            1, 1, 1, 1, 1, 1, 1, 1,
1434                            1, 1, 1, 1, 1, 1, 1, 1,
1435                            1, 0, 0, 0, 0, 0, 0, 0,
1436                            0, 0, 0, 0, 0, 0, 0, 0,
1437                            0, 0, 0, 0, 0, 0, 0, 0
1438                    }
1439            },
1440            {
1441                    /* intra = 1, last = 0 */
1442                    {
1443                            27, 10, 5, 4, 3, 3, 3, 3,
1444                            2, 2, 1, 1, 1, 1, 1, 0,
1445                            0, 0, 0, 0, 0, 0, 0, 0,
1446                            0, 0, 0, 0, 0, 0, 0, 0,
1447                            0, 0, 0, 0, 0, 0, 0, 0,
1448                            0, 0, 0, 0, 0, 0, 0, 0,
1449                            0, 0, 0, 0, 0, 0, 0, 0,
1450                            0, 0, 0, 0, 0, 0, 0, 0
1451                    },
1452                    /* intra = 1, last = 1 */
1453                    {
1454                            8, 3, 2, 2, 2, 2, 2, 1,
1455                            1, 1, 1, 1, 1, 1, 1, 1,
1456                            1, 1, 1, 1, 1, 0, 0, 0,
1457                            0, 0, 0, 0, 0, 0, 0, 0,
1458                            0, 0, 0, 0, 0, 0, 0, 0,
1459                            0, 0, 0, 0, 0, 0, 0, 0,
1460                            0, 0, 0, 0, 0, 0, 0, 0,
1461                            0, 0, 0, 0, 0, 0, 0, 0
1462                    }
1463            }
1464    };
1465    
1466    uint8_t const max_run[2][2][64] = {
1467            {
1468                    /* intra = 0, last = 0 */
1469                    {
1470                            0, 26, 10, 6, 2, 1, 1, 0,
1471                            0, 0, 0, 0, 0, 0, 0, 0,
1472                            0, 0, 0, 0, 0, 0, 0, 0,
1473                            0, 0, 0, 0, 0, 0, 0, 0,
1474                            0, 0, 0, 0, 0, 0, 0, 0,
1475                            0, 0, 0, 0, 0, 0, 0, 0,
1476                            0, 0, 0, 0, 0, 0, 0, 0,
1477                            0, 0, 0, 0, 0, 0, 0, 0,
1478                    },
1479                    /* intra = 0, last = 1 */
1480                    {
1481                            0, 40, 1, 0, 0, 0, 0, 0,
1482                            0, 0, 0, 0, 0, 0, 0, 0,
1483                            0, 0, 0, 0, 0, 0, 0, 0,
1484                            0, 0, 0, 0, 0, 0, 0, 0,
1485                            0, 0, 0, 0, 0, 0, 0, 0,
1486                            0, 0, 0, 0, 0, 0, 0, 0,
1487                            0, 0, 0, 0, 0, 0, 0, 0,
1488                            0, 0, 0, 0, 0, 0, 0, 0,
1489                    }
1490            },
1491            {
1492                    /* intra = 1, last = 0 */
1493                    {
1494                            0, 14, 9, 7, 3, 2, 1, 1,
1495                            1, 1, 1, 0, 0, 0, 0, 0,
1496                            0, 0, 0, 0, 0, 0, 0, 0,
1497                            0, 0, 0, 0, 0, 0, 0, 0,
1498                            0, 0, 0, 0, 0, 0, 0, 0,
1499                            0, 0, 0, 0, 0, 0, 0, 0,
1500                            0, 0, 0, 0, 0, 0, 0, 0,
1501                            0, 0, 0, 0, 0, 0, 0, 0,
1502                    },
1503                    /* intra = 1, last = 1 */
1504                    {
1505                            0, 20, 6, 1, 0, 0, 0, 0,
1506                            0, 0, 0, 0, 0, 0, 0, 0,
1507                            0, 0, 0, 0, 0, 0, 0, 0,
1508                            0, 0, 0, 0, 0, 0, 0, 0,
1509                            0, 0, 0, 0, 0, 0, 0, 0,
1510                            0, 0, 0, 0, 0, 0, 0, 0,
1511                            0, 0, 0, 0, 0, 0, 0, 0,
1512                            0, 0, 0, 0, 0, 0, 0, 0,
1513                    }
1514            }
1515    };
1516    
1517    /******************************************************************
1518     * encoder tables                                                 *
1519     ******************************************************************/
1520    
1521    VLC sprite_trajectory_code[32768];
1522    
1523    VLC sprite_trajectory_len[15] = {
1524            { 0x00 , 2},
1525            { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1526            { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},
1527            { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1528    
1529    
1530    /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1531       the sign bit must be added afterwards. */
1532    
1533    /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1534     CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1535     Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1536    
1537    VLC mcbpc_intra_tab[15] = {
1538            {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1539            {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1540            {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1541            {0x00, 0}, {0x03, 3}, {0x03, 6}
1542    };
1543    
1544    /* MCBPC inter.
1545       Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1546    
1547    VLC mcbpc_inter_tab[29] = {
1548            {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1549            {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1550            {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1551            {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1552    };
1553    
1554    const VLC xvid_cbpy_tab[16] = {
1555            {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1556            {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1557    };
1558    
1559    const VLC dcy_tab[511] = {
1560            {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1561            {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1562            {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1563            {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1564            {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1565            {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1566            {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1567            {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1568            {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1569            {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1570            {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1571            {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1572            {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1573            {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1574            {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1575            {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1576            {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1577            {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1578            {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1579            {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1580            {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1581            {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1582            {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1583            {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1584            {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1585            {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1586            {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1587            {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1588            {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1589            {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1590            {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1591            {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1592            {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1593            {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1594            {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1595            {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1596            {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1597            {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1598            {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1599            {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1600            {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1601            {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1602            {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1603            {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1604            {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1605            {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1606            {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1607            {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1608            {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1609            {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1610            {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1611            {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1612            {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1613            {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1614            {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1615            {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1616            {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1617            {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1618            {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1619            {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1620            {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1621            {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1622            {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1623            {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1624            {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1625            {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1626            {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1627            {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1628            {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1629            {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1630            {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1631            {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1632            {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1633            {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1634            {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1635            {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1636            {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1637            {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1638            {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1639            {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1640            {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1641            {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1642            {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1643            {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1644            {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1645            {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1646            {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1647            {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1648            {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1649            {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1650            {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1651            {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1652            {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1653            {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1654            {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1655            {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1656            {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1657            {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1658            {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1659            {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1660            {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1661            {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1662            {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1663            {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1664            {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1665            {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1666            {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1667            {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1668            {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1669            {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1670            {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1671            {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1672            {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1673            {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1674            {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1675            {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1676            {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1677            {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1678            {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1679            {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1680            {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1681            {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1682            {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1683            {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1684            {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1685            {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1686            {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1687            {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1688    };
1689    
1690    const VLC dcc_tab[511] = {
1691            {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1692            {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1693            {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1694            {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1695            {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1696            {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1697            {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1698            {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1699            {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1700            {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1701            {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1702            {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1703            {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1704            {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1705            {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1706            {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1707            {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1708            {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1709            {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1710            {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1711            {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1712            {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1713            {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1714            {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1715            {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1716            {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1717            {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1718            {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1719            {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1720            {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1721            {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1722            {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1723            {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1724            {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1725            {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1726            {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1727            {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1728            {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1729            {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1730            {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1731            {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1732            {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1733            {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1734            {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1735            {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1736            {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1737            {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1738            {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1739            {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1740            {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1741            {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1742            {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1743            {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1744            {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1745            {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1746            {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1747            {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1748            {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1749            {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1750            {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1751            {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1752            {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1753            {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1754            {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1755            {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1756            {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1757            {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1758            {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1759            {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1760            {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1761            {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1762            {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1763            {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1764            {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1765            {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1766            {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1767            {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1768            {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1769            {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1770            {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1771            {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1772            {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1773            {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1774            {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1775            {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1776            {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1777            {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1778            {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1779            {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1780            {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1781            {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1782            {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1783            {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1784            {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1785            {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1786            {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1787            {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1788            {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1789            {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1790            {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1791            {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1792            {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1793            {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1794            {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1795            {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1796            {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1797            {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1798            {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1799            {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1800            {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1801            {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1802            {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1803            {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1804            {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1805            {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1806            {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1807            {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1808            {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1809            {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1810            {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1811            {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1812            {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1813            {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1814            {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1815            {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1816            {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1817            {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1818            {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1819    };
1820    
1821    
1822    const VLC mb_motion_table[65] = {
1823            {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1824            {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1825            {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1826            {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1827            {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1828            {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1829            {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1830            {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1831            {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1832            {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1833            {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1834            {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1835            {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1836            {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1837            {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1838            {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1839            {0x04, 13}
1840    };
1841    
1842    
1843    /******************************************************************
1844     * decoder tables                                                 *
1845     ******************************************************************/
1846    
1847    VLC const mcbpc_intra_table[64] = {
1848            {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4},  {4, 4},  {4, 4},  {4, 4},
1849            {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1850            {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1851            {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
1852            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1853            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1854            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1855            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1}
1856    };
1857    
1858    VLC const mcbpc_inter_table[257] = {
1859            {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1860            {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1861            {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1862            {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1863            {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1864            {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1865            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1866            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1867            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1868            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1869            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1870            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1871            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1872            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1873            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1874            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1875            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1876            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1877            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1878            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1879            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1880            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1881            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1882            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1883            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1884            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1885            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1886            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1887            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1888            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1889            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1890            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1891            {0, 1}
1892    };
1893    
1894    VLC const cbpy_table[64] = {
1895            {-1, 0}, {-1, 0}, {6, 6},  {9, 6},  {8, 5},  {8, 5},  {4, 5},  {4, 5},
1896            {2, 5},  {2, 5},  {1, 5},  {1, 5},  {0, 4},  {0, 4},  {0, 4},  {0, 4},
1897            {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1898            {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4},  {5, 4},  {5, 4},  {5, 4},
1899            {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4},  {3, 4},  {3, 4},  {3, 4},
1900            {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4},  {7, 4},  {7, 4},  {7, 4},
1901            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1902            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1903    };
1904    
1905    VLC const TMNMVtab0[] = {
1906            {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1907            {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1908    };
1909    
1910    VLC const TMNMVtab1[] = {
1911            {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1912            {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1913            {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1914            {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1915            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1916            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1917            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1918            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1919            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1920            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1921            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1922            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1923            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1924            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1925            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1926            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1927            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1928            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1929            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1930            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1931            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1932            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1933            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1934            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
1935    };
1936    
1937    VLC const TMNMVtab2[] = {
1938            {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
1939            {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
1940            {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
1941            {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
1942            {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
1943            {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
1944            {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
1945            {24, 10}, {24, 10}, {24, 10}, {24, 10},
1946            {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
1947            {23, 10}, {23, 10}, {23, 10}, {23, 10},
1948            {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
1949            {22, 10}, {22, 10}, {22, 10}, {22, 10},
1950            {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
1951            {21, 10}, {21, 10}, {21, 10}, {21, 10},
1952            {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
1953            {20, 10}, {20, 10}, {20, 10}, {20, 10},
1954            {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
1955            {19, 10}, {19, 10}, {19, 10}, {19, 10},
1956            {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
1957            {18, 10}, {18, 10}, {18, 10}, {18, 10},
1958            {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
1959            {17, 10}, {17, 10}, {17, 10}, {17, 10},
1960            {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
1961            {16, 10}, {16, 10}, {16, 10}, {16, 10},
1962            {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
1963            {15, 10}, {15, 10}, {15, 10}, {15, 10},
1964            {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
1965            {14, 10}, {14, 10}, {14, 10}, {14, 10},
1966            {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
1967            {13, 10}, {13, 10}, {13, 10}, {13, 10},
1968            {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10}
1969    };
1970    
1971    short const dc_threshold[] = {
1972            26708, 29545, 29472, 26223, 30580, 29281,  8293, 29545,
1973            25632, 29285, 30313, 25701, 26144, 28530,  8301, 26740,
1974             8293, 20039,  8277, 20551,  8268, 30296, 17513, 25376,
1975            25711, 25445, 10272, 11825, 11825, 10544,  2606, 28505,
1976            29301, 29472, 26223, 30580, 29281,  8293, 26980, 29811,
1977            26994, 30050, 28532,  8306, 24936,  8307, 28532, 26400,
1978            30313,  8293, 25441, 25955, 29555, 29728,  8303, 29801,
1979             8307, 28531, 29301, 25955, 25376, 25711, 11877,    10
1980    };
1981    
1982    VLC const dc_lum_tab[] = {
1983            {0, 0}, {4, 3}, {3, 3}, {0, 3},
1984            {2, 2}, {2, 2}, {1, 2}, {1, 2},
1985    };
Legend:
Removed from v.1.25.2.1  
changed lines
  Added in v.1.56
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4