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

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

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