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

Legend:
Removed from v.497  
changed lines
  Added in v.1573

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