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

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

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

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

Legend:
Removed from v.248  
changed lines
  Added in v.1382

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4