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

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

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

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