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

Legend:
Removed from v.454  
changed lines
  Added in v.1486

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