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

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

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

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