[svn] / branches / release-1_1-branch / xvidcore / src / bitstream / mbcoding.c Repository:
ViewVC logotype

Diff of /branches/release-1_1-branch/xvidcore/src/bitstream/mbcoding.c

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

revision 809, Sun Jan 26 01:44:44 2003 UTC revision 883, Fri Feb 21 08:32:34 2003 UTC
# Line 1  Line 1 
1  /*****************************************************************************   /******************************************************************************
2   *    *                                                                            *
3   *  XVID MPEG-4 VIDEO CODEC    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *
4   *  - Macro Block coding functions -    *                                                                            *
5   *    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *
6   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
7   *    *  software module in hardware or software products are advised that its     *
8   *  This file is part of XviD, a free MPEG-4 video encoder/decoder    *  use may infringe existing patents or copyrights, and any such use         *
9   *    *  would be at such party's own risk.  The original developer of this        *
10   *  XviD is free software; you can redistribute it and/or modify it    *  software module and his/her company, and subsequent editors and their     *
11   *  under the terms of the GNU General Public License as published by    *  companies, will have no liability for use of this software or             *
12   *  the Free Software Foundation; either version 2 of the License, or    *  modifications or derivatives thereof.                                     *
13   *  (at your option) any later version.    *                                                                            *
14   *    *  XviD is free software; you can redistribute it and/or modify it           *
15   *  This program is distributed in the hope that it will be useful,    *  under the terms of the GNU General Public License as published by         *
16   *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *  the Free Software Foundation; either version 2 of the License, or         *
17   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *  (at your option) any later version.                                       *
18   *  GNU General Public License for more details.    *                                                                            *
19   *    *  XviD is distributed in the hope that it will be useful, but               *
20   *  You should have received a copy of the GNU General Public License    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *
21   *  along with this program; if not, write to the Free Software    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
22   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA    *  GNU General Public License for more details.                              *
23   *    *                                                                            *
24   *  Under section 8 of the GNU General Public License, the copyright    *  You should have received a copy of the GNU General Public License         *
25   *  holders of XVID explicitly forbid distribution in the following    *  along with this program; if not, write to the Free Software               *
26   *  countries:    *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *
27   *    *                                                                            *
28   *    - Japan    ******************************************************************************/
29   *    - United States of America  
30   *   /******************************************************************************
31   *  Linking XviD statically or dynamically with other modules is making a    *                                                                            *
32   *  combined work based on XviD.  Thus, the terms and conditions of the    *  mbcoding.c                                                                *
33   *  GNU General Public License cover the whole combination.    *                                                                            *
34   *    *  Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org>                  *
35   *  As a special exception, the copyright holders of XviD give you    *                                                                            *
36   *  permission to link XviD with independent modules that communicate with    *  For more information visit the XviD homepage: http://www.xvid.org         *
37   *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the    *                                                                            *
38   *  license terms of these independent modules, and to copy and distribute    ******************************************************************************/
39   *  the resulting combined work under terms of your choice, provided that  
40   *  every copy of the combined work is accompanied by a complete copy of   /******************************************************************************
41   *  the source code of XviD (the version of XviD used to produce the    *                                                                                                                                                        *
42   *  combined work), being distributed under the terms of the GNU General    *  Revision history:                                                         *
43   *  Public License plus this exception.  An independent module is a module    *                                                                            *
44   *  which is not derived from or based on XviD.    *  28.10.2002 GMC support - gruel                                                                                        *
45   *    *  28.06.2002 added check_resync_marker()                                    *
46   *  Note that people who make modified versions of XviD are not obligated    *  14.04.2002 bframe encoding                                                                                            *
47   *  to grant this special exception for their modified versions; it is    *  08.03.2002 initial version; isibaar                                                           *
48   *  their choice whether to do so.  The GNU General Public License gives    *                                                                                                                                                        *
49   *  permission to release a modified version without this exception; this    ******************************************************************************/
  *  exception also makes it possible to release a modified version which  
  *  carries forward this exception.  
  *  
  * $Id: mbcoding.c,v 1.39 2003-01-26 01:44:07 suxen_drol Exp $  
  *  
  ****************************************************************************/  
50    
51    
52    #include <stdio.h>
53  #include <stdlib.h>  #include <stdlib.h>
54  #include "../portab.h"  #include "../portab.h"
55    #include "../global.h"
56  #include "bitstream.h"  #include "bitstream.h"
57  #include "zigzag.h"  #include "zigzag.h"
58  #include "vlc_codes.h"  #include "vlc_codes.h"
# Line 63  Line 60 
60    
61  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
62    
 #define ABS(X) (((X)>0)?(X):-(X))  
 #define CLIP(X,A) (X > A) ? (A) : (X)  
   
63  /* #define BIGLUT */  /* #define BIGLUT */
64    
65  #ifdef BIGLUT  #ifdef BIGLUT
# Line 74  Line 68 
68  #define LEVELOFFSET 32  #define LEVELOFFSET 32
69  #endif  #endif
70    
 /*****************************************************************************  
  * Local data  
  ****************************************************************************/  
   
71  static REVERSE_EVENT DCT3D[2][4096];  static REVERSE_EVENT DCT3D[2][4096];
72    
73  #ifdef BIGLUT  #ifdef BIGLUT
74  static VLC coeff_VLC[2][2][4096][64];  static VLC coeff_VLC[2][2][4096][64];
75  static VLC *intra_table, *inter_table;  VLC *intra_table;
76    static VLC *inter_table;
77  #else  #else
78  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
79  #endif  #endif
80    
81  /*****************************************************************************  /* not really MB related, but VLCs are only available here */
82   * Vector Length Coding Initialization  void bs_put_spritetrajectory(Bitstream * bs, const int val)
83   ****************************************************************************/  {
84            const int code = sprite_trajectory_code[val+16384].code;
85            const int len = sprite_trajectory_code[val+16384].len;
86            const int code2 = sprite_trajectory_len[len].code;
87            const int len2 = sprite_trajectory_len[len].len;
88    
89    //      printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
90    //      printf("Code2 / Len2 = %d / %d \n",code2,len2);
91    
92            BitstreamPutBits(bs, code2, len2);
93            if (len) BitstreamPutBits(bs, code, len);
94    }
95    
96    int bs_get_spritetrajectory(Bitstream * bs)
97    {
98            int i;
99            for (i = 0; i < 12; i++)
100            {
101                    if (BitstreamShowBits(bs, sprite_trajectory_len[i].len) == sprite_trajectory_len[i].code)
102                    {
103                            BitstreamSkip(bs, sprite_trajectory_len[i].len);
104                            return i;
105                    }
106            }
107            return -1;
108    }
109    
110  void  void
111  init_vlc_tables(void)  init_vlc_tables(void)
112  {  {
113          ptr_t i, j, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
114            int32_t l;
115    
116  #ifdef BIGLUT  #ifdef BIGLUT
117          intra_table = (VLC*)coeff_VLC[1];          intra_table = coeff_VLC[1];
118          inter_table = (VLC*)coeff_VLC[0];          inter_table = coeff_VLC[0];
119  #endif  #endif
120    
121    
# Line 110  Line 127 
127                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++)
128                  {                  {
129                          for (run = 0; run < 63 + last; run++)                          for (run = 0; run < 63 + last; run++)
130                                  for (level = 0; level < 32 << intra; level++)                                  for (level = 0; level < (uint32_t)(32 << intra); level++)
131                                  {                                  {
132  #ifdef BIGLUT  #ifdef BIGLUT
133                                          offset = LEVELOFFSET;                                          offset = LEVELOFFSET;
# Line 129  Line 146 
146  #else  #else
147                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
148  #endif  #endif
149                          for (j = 0; j < 1 << (12 - coeff_tab[intra][i].vlc.len); j++)                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++)
150                          {                          {
151                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;
152                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
# Line 154  Line 171 
171                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++)
172                          for (run = 0; run < 63 + last; run++)                          for (run = 0; run < 63 + last; run++)
173                          {                          {
174                                  for (level = 1; level < 32 << intra; level++)                                  for (level = 1; level < (uint32_t)(32 << intra); level++)
175                                  {                                  {
176                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
177                                              continue;                                              continue;
# Line 179  Line 196 
196                                          }                                          }
197                                          else                                          else
198                                          {                                          {
199                                                  if (level <= max_level[intra][last][run_esc] && run_esc <= max_run[intra][last][level])                                                  if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc])
200                                                  {                                                  {
201                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
202                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
# Line 195  Line 212 
212                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
213                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
214                                                                          coeff_VLC[intra][last][offset - level][run].code                                                                          coeff_VLC[intra][last][offset - level][run].code
215                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-(int32_t)level & 0xfff) << 1) | 1;
216                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;
217                                                          }                                                          }
218                                                          continue;                                                          continue;
# Line 239  Line 256 
256                                  }                                  }
257  #endif  #endif
258                          }                          }
259    /* init sprite_trajectory tables */
260    /* even if GMC is not specified (it might be used later...) */
261    
262            sprite_trajectory_code[0+16384].code = 0;
263            sprite_trajectory_code[0+16384].len = 0;
264            for (k=0;k<14;k++)
265            {
266                    int limit = (1<<k);
267    
268                    for (l=-(2*limit-1); l <= -limit; l++)
269                    {
270                            sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
271                            sprite_trajectory_code[l+16384].len = k+1;
272  }  }
273    
274  /*****************************************************************************                  for (l=limit; l<= 2*limit-1; l++)
275   * Local inlined functions for MB coding                  {
276   ****************************************************************************/                          sprite_trajectory_code[l+16384].code = l;
277                            sprite_trajectory_code[l+16384].len = k+1;
278                    }
279            }
280    }
281    
282  static __inline void  static __inline void
283  CodeVector(Bitstream * bs,  CodeVector(Bitstream * bs,
# Line 340  Line 374 
374    
375  }  }
376    
377    
378    
379    /* returns the number of bits required to encode qcoeff */
380    int
381    CodeCoeff_CalcBits(const int16_t qcoeff[64],
382                      VLC * table,
383                      const uint16_t * zigzag,
384                      uint16_t intra)
385    {
386            int bits = 0;
387            uint32_t j, last;
388            short v;
389            VLC *vlc;
390    
391            j = intra;
392            last = intra;
393    
394            while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
395                    j++;
396    
397            if (j >= 64) return 0;  /* empty block */
398    
399            do {
400                    vlc = table + 64 * 2048 + (v << 6) + j - last;
401                    last = ++j;
402    
403                    /* count zeroes */
404                    while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
405                            j++;
406    
407                    /* write code */
408                    if (j != 64) {
409                            bits += vlc->len;
410                    } else {
411                            vlc += 64 * 4096;
412                            bits += vlc->len;
413                            break;
414                    }
415            } while (1);
416    
417            return bits;
418    }
419    
420    
421  #else  #else
422    
423  static __inline void  static __inline void
# Line 409  Line 487 
487          i       = 1;          i       = 1;
488          run = 0;          run = 0;
489    
490          while (!(level = qcoeff[zigzag[i++]]))          while (i<64 && !(level = qcoeff[zigzag[i++]]))
491                  run++;                  run++;
492    
493          prev_level = level;          prev_level = level;
# Line 454  Line 532 
532          BitstreamPutBits(bs, code, len);          BitstreamPutBits(bs, code, len);
533  }  }
534    
 #endif  
535    
 /*****************************************************************************  
  * Local functions  
  ****************************************************************************/  
536    
537  static void  /* returns the number of bits required to encode qcoeff */
538  CodeBlockIntra(const FRAMEINFO * frame,  
539    int
540    CodeCoeffIntra_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
541    {
542            int bits = 0;
543            uint32_t i, abs_level, run, prev_run, len;
544            int32_t level, prev_level;
545    
546            i       = 1;
547            run = 0;
548    
549            while (i<64 && !(level = qcoeff[zigzag[i++]]))
550                    run++;
551    
552            if (i >= 64) return 0;  /* empty block */
553    
554            prev_level = level;
555            prev_run   = run;
556            run = 0;
557    
558            while (i < 64)
559            {
560                    if ((level = qcoeff[zigzag[i++]]) != 0)
561                    {
562                            abs_level = ABS(prev_level);
563                            abs_level = abs_level < 64 ? abs_level : 0;
564                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
565                            bits      += len!=128 ? len : 30;
566    
567                            prev_level = level;
568                            prev_run   = run;
569                            run = 0;
570                    }
571                    else
572                            run++;
573            }
574    
575            abs_level = ABS(prev_level);
576            abs_level = abs_level < 64 ? abs_level : 0;
577            len               = coeff_VLC[1][1][abs_level][prev_run].len;
578            bits      += len!=128 ? len : 30;
579    
580            return bits;
581    }
582    
583    int
584    CodeCoeffInter_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
585    {
586            uint32_t i, run, prev_run, len;
587            int32_t level, prev_level, level_shifted;
588            int bits = 0;
589    
590            i       = 0;
591            run = 0;
592    
593            while (!(level = qcoeff[zigzag[i++]]))
594                    run++;
595    
596            prev_level = level;
597            prev_run   = run;
598            run = 0;
599    
600            while (i < 64) {
601                    if ((level = qcoeff[zigzag[i++]]) != 0) {
602                            level_shifted = prev_level + 32;
603                            if (!(level_shifted & -64))
604                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
605                            else
606                                    len  = 30;
607    
608                            bits += len;
609                            prev_level = level;
610                            prev_run   = run;
611                            run = 0;
612                    }
613                    else
614                            run++;
615            }
616    
617            level_shifted = prev_level + 32;
618            if (!(level_shifted & -64))
619                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
620            else
621                    len  = 30;
622            bits += len;
623    
624            return bits;
625    }
626    
627    
628    #endif
629    
630    static __inline void
631    CodeBlockIntra(const FRAMEINFO * const frame,
632                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
633                             int16_t qcoeff[6 * 64],                             int16_t qcoeff[6 * 64],
634                             Bitstream * bs,                             Bitstream * bs,
# Line 472  Line 639 
639    
640          cbpy = pMB->cbp >> 2;          cbpy = pMB->cbp >> 2;
641    
642          /* write mcbpc */          // write mcbpc
643          if (frame->coding_type == I_VOP) {          if (frame->coding_type == I_VOP) {
644                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
645                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
# Line 483  Line 650 
650                                                   mcbpc_inter_tab[mcbpc].len);                                                   mcbpc_inter_tab[mcbpc].len);
651          }          }
652    
653          /* ac prediction flag */          // ac prediction flag
654          if (pMB->acpred_directions[0])          if (pMB->acpred_directions[0])
655                  BitstreamPutBits(bs, 1, 1);                  BitstreamPutBits(bs, 1, 1);
656          else          else
657                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
658    
659          /* write cbpy */          // write cbpy
660          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
661    
662          /* write dquant */          // write dquant
663          if (pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA_Q)
664                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, pMB->dquant, 2);
665    
666          /* write interlacing */          // write interlacing
667          if (frame->global_flags & XVID_INTERLACING) {          if (frame->global_flags & XVID_INTERLACING) {
668                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
669          }          }
670          /* code block coeffs */          // code block coeffs
671          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
672                  if (i < 4)                  if (i < 4)
673                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
# Line 510  Line 677 
677                                                           dcc_tab[qcoeff[i * 64 + 0] + 255].len);                                                           dcc_tab[qcoeff[i * 64 + 0] + 255].len);
678    
679                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i))) {
680                            const uint16_t *scan_table =
681                                    frame->global_flags & XVID_ALTERNATESCAN ?
682                                    scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
683    
684                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
685    
686  #ifdef BIGLUT  #ifdef BIGLUT
687                          CodeCoeff(bs, &qcoeff[i * 64], intra_table,                          CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);
                                           scan_tables[pMB->acpred_directions[i]], 1);  
688  #else  #else
689                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_tables[pMB->acpred_directions[i]]);                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
690  #endif  #endif
691    
692                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
693                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
694                  }                  }
# Line 527  Line 698 
698    
699    
700  static void  static void
701  CodeBlockInter(const FRAMEINFO * frame,  CodeBlockInter(const FRAMEINFO * const frame,
702                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
703                             int16_t qcoeff[6 * 64],                             int16_t qcoeff[6 * 64],
704                             Bitstream * bs,                             Bitstream * bs,
# Line 540  Line 711 
711          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
712          cbpy = 15 - (pMB->cbp >> 2);          cbpy = 15 - (pMB->cbp >> 2);
713    
714          /* write mcbpc */          // write mcbpc
715          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
716                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
717    
718          /* write cbpy */          if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
719                    BitstreamPutBit(bs, pMB->mcsel);                // mcsel: '0'=local motion, '1'=GMC
720    
721            // write cbpy
722          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
723    
724          /* write dquant */          // write dquant
725          if (pMB->mode == MODE_INTER_Q)          if (pMB->mode == MODE_INTER_Q)
726                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, pMB->dquant, 2);
727    
728          /* interlacing */          // interlacing
729          if (frame->global_flags & XVID_INTERLACING) {          if (frame->global_flags & XVID_INTERLACING) {
730                  if (pMB->cbp) {                  if (pMB->cbp) {
731                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
732                          DPRINTF(DPRINTF_DEBUG, "codep: field_dct: %d", pMB->field_dct);                          DPRINTF(DPRINTF_MB,"codep: field_dct: %i", pMB->field_dct);
733                  }                  }
734    
735                  /* if inter block, write field ME flag */                  // if inter block, write field ME flag
736                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
737                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, pMB->field_pred);
738                          DPRINTF(DPRINTF_DEBUG, "codep: field_pred: %d", pMB->field_pred);                          DPRINTF(DPRINTF_MB,"codep: field_pred: %i", pMB->field_pred);
739    
740                          /* write field prediction references */                          // write field prediction references
741                          if (pMB->field_pred) {                          if (pMB->field_pred) {
742                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
743                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
744                          }                          }
745                  }                  }
746          }          }
747          /* code motion vector(s) */          // code motion vector(s) if motion is local
748            if (!pMB->mcsel)
749          for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {          for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
750                  CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                  CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
751                  CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);                  CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);
# Line 578  Line 753 
753    
754          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
755    
756          /* code block coeffs */          // code block coeffs
757          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
758                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i)))
759                    {
760                            const uint16_t *scan_table =
761                                    frame->global_flags & XVID_ALTERNATESCAN ?
762                                    scan_tables[2] : scan_tables[0];
763    
764  #ifdef BIGLUT  #ifdef BIGLUT
765                          CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);                          CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);
766  #else  #else
767                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_tables[0]);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
768  #endif  #endif
769                    }
770    
771          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
772          pStat->iTextBits += bits;          pStat->iTextBits += bits;
   
773  }  }
774    
 /*****************************************************************************  
  * Macro Block bitstream encoding functions  
  ****************************************************************************/  
775    
776  void  void
777  MBCoding(const FRAMEINFO * frame,  MBCoding(const FRAMEINFO * const frame,
778                   MACROBLOCK * pMB,                   MACROBLOCK * pMB,
779                   int16_t qcoeff[6 * 64],                   int16_t qcoeff[6 * 64],
780                   Bitstream * bs,                   Bitstream * bs,
781                   Statistics * pStat)                   Statistics * pStat)
782  {  {
783            if (frame->coding_type != I_VOP)
784          if (frame->coding_type == P_VOP) {                          BitstreamPutBit(bs, 0); // not_coded
                         BitstreamPutBit(bs, 0); /* coded */  
         }  
785    
786          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
787                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
# Line 615  Line 790 
790    
791  }  }
792    
793    /*
794    // moved to mbcoding.h so that in can be 'static __inline'
795  void  void
796  MBSkip(Bitstream * bs)  MBSkip(Bitstream * bs)
797  {  {
798          BitstreamPutBit(bs, 1); /* not coded */          BitstreamPutBit(bs, 1); // not coded
         return;  
799  }  }
800    */
801    
802  /*****************************************************************************  /***************************************************************
803   * decoding stuff starts here   * bframe encoding start
804   ****************************************************************************/   ***************************************************************/
805    
806  /*  /*
807   * For IVOP addbits == 0          mbtype
808   * For PVOP addbits == fcode - 1          0       1b              direct(h263)            mvdb
809   * For BVOP addbits == max(fcode,bcode) - 1          1       01b             interpolate mc+q        dbquant, mvdf, mvdb
810   * returns true or false          2       001b    backward mc+q           dbquant, mvdb
811            3       0001b   forward mc+q            dbquant, mvdf
812   */   */
813    
814    static __inline void
815    put_bvop_mbtype(Bitstream * bs,
816                                    int value)
817    {
818            switch (value) {
819                    case MODE_FORWARD:
820                            BitstreamPutBit(bs, 0);
821                    case MODE_BACKWARD:
822                            BitstreamPutBit(bs, 0);
823                    case MODE_INTERPOLATE:
824                            BitstreamPutBit(bs, 0);
825                    case MODE_DIRECT:
826                            BitstreamPutBit(bs, 1);
827                    default:
828                            break;
829            }
830    }
831    
832    /*
833            dbquant
834            -2      10b
835            0       0b
836            +2      11b
837    */
838    
839    static __inline void
840    put_bvop_dbquant(Bitstream * bs,
841                                     int value)
842    {
843            switch (value) {
844            case 0:
845                    BitstreamPutBit(bs, 0);
846                    return;
847    
848            case -2:
849                    BitstreamPutBit(bs, 1);
850                    BitstreamPutBit(bs, 0);
851                    return;
852    
853            case 2:
854                    BitstreamPutBit(bs, 1);
855                    BitstreamPutBit(bs, 1);
856                    return;
857    
858            default:;                                       // invalid
859            }
860    }
861    
862    
863    
864    void
865    MBCodingBVOP(const MACROBLOCK * mb,
866                             const int16_t qcoeff[6 * 64],
867                             const int32_t fcode,
868                             const int32_t bcode,
869                             Bitstream * bs,
870                             Statistics * pStat,
871                             int direction)
872    {
873            int vcode = fcode;
874            unsigned int i;
875    
876    /*      ------------------------------------------------------------------
877                    when a block is skipped it is decoded DIRECT(0,0)
878                    hence is interpolated from forward & backward frames
879            ------------------------------------------------------------------ */
880    
881            if (mb->mode == MODE_DIRECT_NONE_MV) {
882                    BitstreamPutBit(bs, 1); // skipped
883                    return;
884            }
885    
886            BitstreamPutBit(bs, 0);         // not skipped
887    
888            if (mb->cbp == 0) {
889                    BitstreamPutBit(bs, 1); // cbp == 0
890            } else {
891                    BitstreamPutBit(bs, 0); // cbp == xxx
892            }
893    
894            put_bvop_mbtype(bs, mb->mode);
895    
896            if (mb->cbp) {
897                    BitstreamPutBits(bs, mb->cbp, 6);
898            }
899    
900            if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
901                    put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0
902            }
903    
904            switch (mb->mode) {
905                    case MODE_INTERPOLATE:
906                            CodeVector(bs, mb->pmvs[1].x, vcode, pStat); //forward vector of interpolate mode
907                            CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
908                    case MODE_BACKWARD:
909                            vcode = bcode;
910                    case MODE_FORWARD:
911                            CodeVector(bs, mb->pmvs[0].x, vcode, pStat);
912                            CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
913                            break;
914                    case MODE_DIRECT:
915                            CodeVector(bs, mb->pmvs[3].x, 1, pStat);        // fcode is always 1 for delta vector
916                            CodeVector(bs, mb->pmvs[3].y, 1, pStat);        // prediction is always (0,0)
917                    default: break;
918            }
919    
920            for (i = 0; i < 6; i++) {
921                    if (mb->cbp & (1 << (5 - i))) {
922    #ifdef BIGLUT
923                            CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);
924    #else
925                            CodeCoeffInter(bs, &qcoeff[i * 64], scan_tables[0]);
926    #endif
927                    }
928            }
929    }
930    
931    
932    
933    /***************************************************************
934     * decoding stuff starts here                                  *
935     ***************************************************************/
936    
937    
938    // for IVOP addbits == 0
939    // for PVOP addbits == fcode - 1
940    // for BVOP addbits == max(fcode,bcode) - 1
941    // returns true or false
942  int  int
943  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
944  {  {
# Line 675  Line 980 
980    
981          uint32_t index;          uint32_t index;
982    
983          index = CLIP(BitstreamShowBits(bs, 9), 256);          index = MIN(BitstreamShowBits(bs, 9), 256);
984    
985          BitstreamSkip(bs, mcbpc_inter_table[index].len);          BitstreamSkip(bs, mcbpc_inter_table[index].len);
986    
# Line 701  Line 1006 
1006    
1007  }  }
1008    
1009  int  static __inline int
1010  get_mv_data(Bitstream * bs)  get_mv_data(Bitstream * bs)
1011  {  {
1012    
# Line 810  Line 1115 
1115    
1116  }  }
1117    
 /*****************************************************************************  
  * Local inlined function to "decode" written vlc codes  
  ****************************************************************************/  
   
1118  static __inline int  static __inline int
1119  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
1120                    int *run,                    int *run,
# Line 895  Line 1196 
1196          return 0;          return 0;
1197  }  }
1198    
 /*****************************************************************************  
  * MB reading functions  
  ****************************************************************************/  
   
1199  void  void
1200  get_intra_block(Bitstream * bs,  get_intra_block(Bitstream * bs,
1201                                  int16_t * block,                                  int16_t * block,
# Line 907  Line 1204 
1204  {  {
1205    
1206          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1207          int level;          int level, run, last;
         int run;  
         int last;  
1208    
1209          do {          do {
1210                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1211                  if (run == -1) {                  if (run == -1) {
1212                          DPRINTF(DPRINTF_DEBUG, "fatal: invalid run");                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");
1213                          break;                          break;
1214                  }                  }
1215                  coeff += run;                  coeff += run;
1216                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1217    
1218                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);
1219                  /*DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32)); */                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));
1220    
1221                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1222                          DPRINTF(DPRINTF_DEBUG, "warning: intra_overflow: %d", level);                          DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);
1223                  }                  }
1224                  coeff++;                  coeff++;
1225          } while (!last);          } while (!last);
# Line 933  Line 1228 
1228    
1229  void  void
1230  get_inter_block(Bitstream * bs,  get_inter_block(Bitstream * bs,
1231                                  int16_t * block)                                  int16_t * block,
1232                                    int direction)
1233  {  {
1234    
1235          const uint16_t *scan = scan_tables[0];          const uint16_t *scan = scan_tables[direction];
1236          int p;          int p;
1237          int level;          int level;
1238          int run;          int run;
# Line 954  Line 1250 
1250                  block[scan[p]] = level;                  block[scan[p]] = level;
1251    
1252                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);
1253                    // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));
1254    
1255                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1256                          DPRINTF(DPRINTF_DEBUG, "warning: inter_overflow: %d", level);                          DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);
1257                  }                  }
1258                  p++;                  p++;
1259          } while (!last);          } while (!last);
1260    
1261  }  }
1262    
1263    /*****************************************************************************
1264     * VLC tables and other constant arrays
1265     ****************************************************************************/
1266    
1267    VLC_TABLE const coeff_tab[2][102] =
1268    {
1269            /* intra = 0 */
1270            {
1271                    {{ 2,  2}, {0, 0, 1}},
1272                    {{15,  4}, {0, 0, 2}},
1273                    {{21,  6}, {0, 0, 3}},
1274                    {{23,  7}, {0, 0, 4}},
1275                    {{31,  8}, {0, 0, 5}},
1276                    {{37,  9}, {0, 0, 6}},
1277                    {{36,  9}, {0, 0, 7}},
1278                    {{33, 10}, {0, 0, 8}},
1279                    {{32, 10}, {0, 0, 9}},
1280                    {{ 7, 11}, {0, 0, 10}},
1281                    {{ 6, 11}, {0, 0, 11}},
1282                    {{32, 11}, {0, 0, 12}},
1283                    {{ 6,  3}, {0, 1, 1}},
1284                    {{20,  6}, {0, 1, 2}},
1285                    {{30,  8}, {0, 1, 3}},
1286                    {{15, 10}, {0, 1, 4}},
1287                    {{33, 11}, {0, 1, 5}},
1288                    {{80, 12}, {0, 1, 6}},
1289                    {{14,  4}, {0, 2, 1}},
1290                    {{29,  8}, {0, 2, 2}},
1291                    {{14, 10}, {0, 2, 3}},
1292                    {{81, 12}, {0, 2, 4}},
1293                    {{13,  5}, {0, 3, 1}},
1294                    {{35,  9}, {0, 3, 2}},
1295                    {{13, 10}, {0, 3, 3}},
1296                    {{12,  5}, {0, 4, 1}},
1297                    {{34,  9}, {0, 4, 2}},
1298                    {{82, 12}, {0, 4, 3}},
1299                    {{11,  5}, {0, 5, 1}},
1300                    {{12, 10}, {0, 5, 2}},
1301                    {{83, 12}, {0, 5, 3}},
1302                    {{19,  6}, {0, 6, 1}},
1303                    {{11, 10}, {0, 6, 2}},
1304                    {{84, 12}, {0, 6, 3}},
1305                    {{18,  6}, {0, 7, 1}},
1306                    {{10, 10}, {0, 7, 2}},
1307                    {{17,  6}, {0, 8, 1}},
1308                    {{ 9, 10}, {0, 8, 2}},
1309                    {{16,  6}, {0, 9, 1}},
1310                    {{ 8, 10}, {0, 9, 2}},
1311                    {{22,  7}, {0, 10, 1}},
1312                    {{85, 12}, {0, 10, 2}},
1313                    {{21,  7}, {0, 11, 1}},
1314                    {{20,  7}, {0, 12, 1}},
1315                    {{28,  8}, {0, 13, 1}},
1316                    {{27,  8}, {0, 14, 1}},
1317                    {{33,  9}, {0, 15, 1}},
1318                    {{32,  9}, {0, 16, 1}},
1319                    {{31,  9}, {0, 17, 1}},
1320                    {{30,  9}, {0, 18, 1}},
1321                    {{29,  9}, {0, 19, 1}},
1322                    {{28,  9}, {0, 20, 1}},
1323                    {{27,  9}, {0, 21, 1}},
1324                    {{26,  9}, {0, 22, 1}},
1325                    {{34, 11}, {0, 23, 1}},
1326                    {{35, 11}, {0, 24, 1}},
1327                    {{86, 12}, {0, 25, 1}},
1328                    {{87, 12}, {0, 26, 1}},
1329                    {{ 7,  4}, {1, 0, 1}},
1330                    {{25,  9}, {1, 0, 2}},
1331                    {{ 5, 11}, {1, 0, 3}},
1332                    {{15,  6}, {1, 1, 1}},
1333                    {{ 4, 11}, {1, 1, 2}},
1334                    {{14,  6}, {1, 2, 1}},
1335                    {{13,  6}, {1, 3, 1}},
1336                    {{12,  6}, {1, 4, 1}},
1337                    {{19,  7}, {1, 5, 1}},
1338                    {{18,  7}, {1, 6, 1}},
1339                    {{17,  7}, {1, 7, 1}},
1340                    {{16,  7}, {1, 8, 1}},
1341                    {{26,  8}, {1, 9, 1}},
1342                    {{25,  8}, {1, 10, 1}},
1343                    {{24,  8}, {1, 11, 1}},
1344                    {{23,  8}, {1, 12, 1}},
1345                    {{22,  8}, {1, 13, 1}},
1346                    {{21,  8}, {1, 14, 1}},
1347                    {{20,  8}, {1, 15, 1}},
1348                    {{19,  8}, {1, 16, 1}},
1349                    {{24,  9}, {1, 17, 1}},
1350                    {{23,  9}, {1, 18, 1}},
1351                    {{22,  9}, {1, 19, 1}},
1352                    {{21,  9}, {1, 20, 1}},
1353                    {{20,  9}, {1, 21, 1}},
1354                    {{19,  9}, {1, 22, 1}},
1355                    {{18,  9}, {1, 23, 1}},
1356                    {{17,  9}, {1, 24, 1}},
1357                    {{ 7, 10}, {1, 25, 1}},
1358                    {{ 6, 10}, {1, 26, 1}},
1359                    {{ 5, 10}, {1, 27, 1}},
1360                    {{ 4, 10}, {1, 28, 1}},
1361                    {{36, 11}, {1, 29, 1}},
1362                    {{37, 11}, {1, 30, 1}},
1363                    {{38, 11}, {1, 31, 1}},
1364                    {{39, 11}, {1, 32, 1}},
1365                    {{88, 12}, {1, 33, 1}},
1366                    {{89, 12}, {1, 34, 1}},
1367                    {{90, 12}, {1, 35, 1}},
1368                    {{91, 12}, {1, 36, 1}},
1369                    {{92, 12}, {1, 37, 1}},
1370                    {{93, 12}, {1, 38, 1}},
1371                    {{94, 12}, {1, 39, 1}},
1372                    {{95, 12}, {1, 40, 1}}
1373            },
1374            /* intra = 1 */
1375            {
1376                    {{ 2,  2}, {0, 0, 1}},
1377                    {{15,  4}, {0, 0, 3}},
1378                    {{21,  6}, {0, 0, 6}},
1379                    {{23,  7}, {0, 0, 9}},
1380                    {{31,  8}, {0, 0, 10}},
1381                    {{37,  9}, {0, 0, 13}},
1382                    {{36,  9}, {0, 0, 14}},
1383                    {{33, 10}, {0, 0, 17}},
1384                    {{32, 10}, {0, 0, 18}},
1385                    {{ 7, 11}, {0, 0, 21}},
1386                    {{ 6, 11}, {0, 0, 22}},
1387                    {{32, 11}, {0, 0, 23}},
1388                    {{ 6,  3}, {0, 0, 2}},
1389                    {{20,  6}, {0, 1, 2}},
1390                    {{30,  8}, {0, 0, 11}},
1391                    {{15, 10}, {0, 0, 19}},
1392                    {{33, 11}, {0, 0, 24}},
1393                    {{80, 12}, {0, 0, 25}},
1394                    {{14,  4}, {0, 1, 1}},
1395                    {{29,  8}, {0, 0, 12}},
1396                    {{14, 10}, {0, 0, 20}},
1397                    {{81, 12}, {0, 0, 26}},
1398                    {{13,  5}, {0, 0, 4}},
1399                    {{35,  9}, {0, 0, 15}},
1400                    {{13, 10}, {0, 1, 7}},
1401                    {{12,  5}, {0, 0, 5}},
1402                    {{34,  9}, {0, 4, 2}},
1403                    {{82, 12}, {0, 0, 27}},
1404                    {{11,  5}, {0, 2, 1}},
1405                    {{12, 10}, {0, 2, 4}},
1406                    {{83, 12}, {0, 1, 9}},
1407                    {{19,  6}, {0, 0, 7}},
1408                    {{11, 10}, {0, 3, 4}},
1409                    {{84, 12}, {0, 6, 3}},
1410                    {{18,  6}, {0, 0, 8}},
1411                    {{10, 10}, {0, 4, 3}},
1412                    {{17,  6}, {0, 3, 1}},
1413                    {{ 9, 10}, {0, 8, 2}},
1414                    {{16,  6}, {0, 4, 1}},
1415                    {{ 8, 10}, {0, 5, 3}},
1416                    {{22,  7}, {0, 1, 3}},
1417                    {{85, 12}, {0, 1, 10}},
1418                    {{21,  7}, {0, 2, 2}},
1419                    {{20,  7}, {0, 7, 1}},
1420                    {{28,  8}, {0, 1, 4}},
1421                    {{27,  8}, {0, 3, 2}},
1422                    {{33,  9}, {0, 0, 16}},
1423                    {{32,  9}, {0, 1, 5}},
1424                    {{31,  9}, {0, 1, 6}},
1425                    {{30,  9}, {0, 2, 3}},
1426                    {{29,  9}, {0, 3, 3}},
1427                    {{28,  9}, {0, 5, 2}},
1428                    {{27,  9}, {0, 6, 2}},
1429                    {{26,  9}, {0, 7, 2}},
1430                    {{34, 11}, {0, 1, 8}},
1431                    {{35, 11}, {0, 9, 2}},
1432                    {{86, 12}, {0, 2, 5}},
1433                    {{87, 12}, {0, 7, 3}},
1434                    {{ 7,  4}, {1, 0, 1}},
1435                    {{25,  9}, {0, 11, 1}},
1436                    {{ 5, 11}, {1, 0, 6}},
1437                    {{15,  6}, {1, 1, 1}},
1438                    {{ 4, 11}, {1, 0, 7}},
1439                    {{14,  6}, {1, 2, 1}},
1440                    {{13,  6}, {0, 5, 1}},
1441                    {{12,  6}, {1, 0, 2}},
1442                    {{19,  7}, {1, 5, 1}},
1443                    {{18,  7}, {0, 6, 1}},
1444                    {{17,  7}, {1, 3, 1}},
1445                    {{16,  7}, {1, 4, 1}},
1446                    {{26,  8}, {1, 9, 1}},
1447                    {{25,  8}, {0, 8, 1}},
1448                    {{24,  8}, {0, 9, 1}},
1449                    {{23,  8}, {0, 10, 1}},
1450                    {{22,  8}, {1, 0, 3}},
1451                    {{21,  8}, {1, 6, 1}},
1452                    {{20,  8}, {1, 7, 1}},
1453                    {{19,  8}, {1, 8, 1}},
1454                    {{24,  9}, {0, 12, 1}},
1455                    {{23,  9}, {1, 0, 4}},
1456                    {{22,  9}, {1, 1, 2}},
1457                    {{21,  9}, {1, 10, 1}},
1458                    {{20,  9}, {1, 11, 1}},
1459                    {{19,  9}, {1, 12, 1}},
1460                    {{18,  9}, {1, 13, 1}},
1461                    {{17,  9}, {1, 14, 1}},
1462                    {{ 7, 10}, {0, 13, 1}},
1463                    {{ 6, 10}, {1, 0, 5}},
1464                    {{ 5, 10}, {1, 1, 3}},
1465                    {{ 4, 10}, {1, 2, 2}},
1466                    {{36, 11}, {1, 3, 2}},
1467                    {{37, 11}, {1, 4, 2}},
1468                    {{38, 11}, {1, 15, 1}},
1469                    {{39, 11}, {1, 16, 1}},
1470                    {{88, 12}, {0, 14, 1}},
1471                    {{89, 12}, {1, 0, 8}},
1472                    {{90, 12}, {1, 5, 2}},
1473                    {{91, 12}, {1, 6, 2}},
1474                    {{92, 12}, {1, 17, 1}},
1475                    {{93, 12}, {1, 18, 1}},
1476                    {{94, 12}, {1, 19, 1}},
1477                    {{95, 12}, {1, 20, 1}}
1478            }
1479    };
1480    
1481    /* constants taken from momusys/vm_common/inlcude/max_level.h */
1482    uint8_t const max_level[2][2][64] = {
1483            {
1484                    /* intra = 0, last = 0 */
1485                    {
1486                            12, 6, 4, 3, 3, 3, 3, 2,
1487                            2, 2, 2, 1, 1, 1, 1, 1,
1488                            1, 1, 1, 1, 1, 1, 1, 1,
1489                            1, 1, 1, 0, 0, 0, 0, 0,
1490                            0, 0, 0, 0, 0, 0, 0, 0,
1491                            0, 0, 0, 0, 0, 0, 0, 0,
1492                            0, 0, 0, 0, 0, 0, 0, 0,
1493                            0, 0, 0, 0, 0, 0, 0, 0
1494                    },
1495                    /* intra = 0, last = 1 */
1496                    {
1497                            3, 2, 1, 1, 1, 1, 1, 1,
1498                            1, 1, 1, 1, 1, 1, 1, 1,
1499                            1, 1, 1, 1, 1, 1, 1, 1,
1500                            1, 1, 1, 1, 1, 1, 1, 1,
1501                            1, 1, 1, 1, 1, 1, 1, 1,
1502                            1, 0, 0, 0, 0, 0, 0, 0,
1503                            0, 0, 0, 0, 0, 0, 0, 0,
1504                            0, 0, 0, 0, 0, 0, 0, 0
1505                    }
1506            },
1507            {
1508                    /* intra = 1, last = 0 */
1509                    {
1510                            27, 10, 5, 4, 3, 3, 3, 3,
1511                            2, 2, 1, 1, 1, 1, 1, 0,
1512                            0, 0, 0, 0, 0, 0, 0, 0,
1513                            0, 0, 0, 0, 0, 0, 0, 0,
1514                            0, 0, 0, 0, 0, 0, 0, 0,
1515                            0, 0, 0, 0, 0, 0, 0, 0,
1516                            0, 0, 0, 0, 0, 0, 0, 0,
1517                            0, 0, 0, 0, 0, 0, 0, 0
1518                    },
1519                    /* intra = 1, last = 1 */
1520                    {
1521                            8, 3, 2, 2, 2, 2, 2, 1,
1522                            1, 1, 1, 1, 1, 1, 1, 1,
1523                            1, 1, 1, 1, 1, 0, 0, 0,
1524                            0, 0, 0, 0, 0, 0, 0, 0,
1525                            0, 0, 0, 0, 0, 0, 0, 0,
1526                            0, 0, 0, 0, 0, 0, 0, 0,
1527                            0, 0, 0, 0, 0, 0, 0, 0,
1528                            0, 0, 0, 0, 0, 0, 0, 0
1529                    }
1530            }
1531    };
1532    
1533    uint8_t const max_run[2][2][64] = {
1534            {
1535                    /* intra = 0, last = 0 */
1536                    {
1537                            0, 26, 10, 6, 2, 1, 1, 0,
1538                            0, 0, 0, 0, 0, 0, 0, 0,
1539                            0, 0, 0, 0, 0, 0, 0, 0,
1540                            0, 0, 0, 0, 0, 0, 0, 0,
1541                            0, 0, 0, 0, 0, 0, 0, 0,
1542                            0, 0, 0, 0, 0, 0, 0, 0,
1543                            0, 0, 0, 0, 0, 0, 0, 0,
1544                            0, 0, 0, 0, 0, 0, 0, 0,
1545                    },
1546                    /* intra = 0, last = 1 */
1547                    {
1548                            0, 40, 1, 0, 0, 0, 0, 0,
1549                            0, 0, 0, 0, 0, 0, 0, 0,
1550                            0, 0, 0, 0, 0, 0, 0, 0,
1551                            0, 0, 0, 0, 0, 0, 0, 0,
1552                            0, 0, 0, 0, 0, 0, 0, 0,
1553                            0, 0, 0, 0, 0, 0, 0, 0,
1554                            0, 0, 0, 0, 0, 0, 0, 0,
1555                            0, 0, 0, 0, 0, 0, 0, 0,
1556                    }
1557            },
1558            {
1559                    /* intra = 1, last = 0 */
1560                    {
1561                            0, 14, 9, 7, 3, 2, 1, 1,
1562                            1, 1, 1, 0, 0, 0, 0, 0,
1563                            0, 0, 0, 0, 0, 0, 0, 0,
1564                            0, 0, 0, 0, 0, 0, 0, 0,
1565                            0, 0, 0, 0, 0, 0, 0, 0,
1566                            0, 0, 0, 0, 0, 0, 0, 0,
1567                            0, 0, 0, 0, 0, 0, 0, 0,
1568                            0, 0, 0, 0, 0, 0, 0, 0,
1569                    },
1570                    /* intra = 1, last = 1 */
1571                    {
1572                            0, 20, 6, 1, 0, 0, 0, 0,
1573                            0, 0, 0, 0, 0, 0, 0, 0,
1574                            0, 0, 0, 0, 0, 0, 0, 0,
1575                            0, 0, 0, 0, 0, 0, 0, 0,
1576                            0, 0, 0, 0, 0, 0, 0, 0,
1577                            0, 0, 0, 0, 0, 0, 0, 0,
1578                            0, 0, 0, 0, 0, 0, 0, 0,
1579                            0, 0, 0, 0, 0, 0, 0, 0,
1580                    }
1581            }
1582    };
1583    
1584    /******************************************************************
1585     * encoder tables                                                 *
1586     ******************************************************************/
1587    
1588    VLC sprite_trajectory_code[32768];
1589    
1590    VLC sprite_trajectory_len[15] = {
1591            { 0x00 , 2},
1592            { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1593            { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7F, 7}, { 0xFE, 8},
1594            { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1595    
1596    
1597    /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1598       the sign bit must be added afterwards. */
1599    
1600    /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1601     CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1602     Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1603    
1604    VLC mcbpc_intra_tab[15] = {
1605            {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1606            {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1607            {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1608            {0x00, 0}, {0x03, 3}, {0x03, 6}
1609    };
1610    
1611    /* MCBPC inter.
1612       Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1613    
1614    VLC mcbpc_inter_tab[29] = {
1615            {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1616            {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1617            {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1618            {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1619    };
1620    
1621    const VLC cbpy_tab[16] = {
1622            {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1623            {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1624    };
1625    
1626    const VLC dcy_tab[511] = {
1627            {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1628            {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1629            {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1630            {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1631            {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1632            {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1633            {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1634            {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1635            {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1636            {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1637            {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1638            {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1639            {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1640            {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1641            {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1642            {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1643            {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1644            {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1645            {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1646            {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1647            {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1648            {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1649            {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1650            {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1651            {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1652            {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1653            {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1654            {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1655            {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1656            {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1657            {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1658            {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1659            {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1660            {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1661            {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1662            {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1663            {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1664            {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1665            {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1666            {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1667            {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1668            {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1669            {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1670            {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1671            {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1672            {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1673            {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1674            {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1675            {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1676            {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1677            {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1678            {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1679            {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1680            {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1681            {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1682            {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1683            {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1684            {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1685            {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1686            {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1687            {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1688            {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1689            {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1690            {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1691            {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1692            {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1693            {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1694            {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1695            {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1696            {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1697            {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1698            {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1699            {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1700            {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1701            {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1702            {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1703            {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1704            {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1705            {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1706            {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1707            {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1708            {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1709            {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1710            {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1711            {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1712            {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1713            {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1714            {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1715            {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1716            {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1717            {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1718            {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1719            {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1720            {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1721            {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1722            {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1723            {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1724            {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1725            {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1726            {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1727            {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1728            {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1729            {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1730            {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1731            {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1732            {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1733            {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1734            {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1735            {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1736            {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1737            {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1738            {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1739            {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1740            {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1741            {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1742            {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1743            {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1744            {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1745            {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1746            {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1747            {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1748            {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1749            {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1750            {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1751            {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1752            {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1753            {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1754            {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1755    };
1756    
1757    const VLC dcc_tab[511] = {
1758            {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1759            {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1760            {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1761            {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1762            {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1763            {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1764            {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1765            {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1766            {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1767            {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1768            {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1769            {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1770            {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1771            {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1772            {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1773            {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1774            {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1775            {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1776            {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1777            {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1778            {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1779            {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1780            {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1781            {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1782            {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1783            {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1784            {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1785            {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1786            {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1787            {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1788            {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1789            {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1790            {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1791            {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1792            {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1793            {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1794            {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1795            {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1796            {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1797            {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1798            {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1799            {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1800            {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1801            {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1802            {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1803            {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1804            {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1805            {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1806            {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1807            {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1808            {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1809            {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1810            {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1811            {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1812            {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1813            {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1814            {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1815            {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1816            {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1817            {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1818            {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1819            {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1820            {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1821            {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1822            {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1823            {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1824            {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1825            {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1826            {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1827            {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1828            {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1829            {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1830            {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1831            {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1832            {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1833            {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1834            {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1835            {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1836            {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1837            {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1838            {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1839            {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1840            {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1841            {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1842            {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1843            {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1844            {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1845            {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1846            {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1847            {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1848            {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1849            {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1850            {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1851            {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1852            {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1853            {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1854            {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1855            {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1856            {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1857            {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1858            {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1859            {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1860            {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1861            {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1862            {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1863            {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1864            {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1865            {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1866            {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1867            {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1868            {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1869            {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1870            {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1871            {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1872            {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1873            {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1874            {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1875            {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1876            {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1877            {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1878            {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1879            {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1880            {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1881            {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1882            {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1883            {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1884            {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1885            {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1886    };
1887    
1888    
1889    const VLC mb_motion_table[65] = {
1890            {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1891            {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1892            {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1893            {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1894            {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1895            {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1896            {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1897            {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1898            {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1899            {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1900            {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1901            {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1902            {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1903            {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1904            {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1905            {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1906            {0x04, 13}
1907    };
1908    
1909    
1910    /******************************************************************
1911     * decoder tables                                                 *
1912     ******************************************************************/
1913    
1914    VLC const mcbpc_intra_table[64] = {
1915            {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4},  {4, 4},  {4, 4},  {4, 4},
1916            {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1917            {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1918            {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
1919            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1920            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1921            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1922            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1}
1923    };
1924    
1925    VLC const mcbpc_inter_table[257] = {
1926            {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1927            {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1928            {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1929            {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1930            {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1931            {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1932            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1933            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1934            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1935            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1936            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1937            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1938            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1939            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1940            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1941            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1942            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1943            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1944            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1945            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1946            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1947            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1948            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1949            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1950            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1951            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1952            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1953            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1954            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1955            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1956            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1957            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1958            {0, 1}
1959    };
1960    
1961    VLC const cbpy_table[64] = {
1962            {-1, 0}, {-1, 0}, {6, 6},  {9, 6},  {8, 5},  {8, 5},  {4, 5},  {4, 5},
1963            {2, 5},  {2, 5},  {1, 5},  {1, 5},  {0, 4},  {0, 4},  {0, 4},  {0, 4},
1964            {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1965            {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4},  {5, 4},  {5, 4},  {5, 4},
1966            {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4},  {3, 4},  {3, 4},  {3, 4},
1967            {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4},  {7, 4},  {7, 4},  {7, 4},
1968            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1969            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1970    };
1971    
1972    VLC const TMNMVtab0[] = {
1973            {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1974            {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1975    };
1976    
1977    VLC const TMNMVtab1[] = {
1978            {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1979            {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1980            {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1981            {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1982            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1983            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1984            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1985            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1986            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1987            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1988            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1989            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1990            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1991            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1992            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1993            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1994            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1995            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1996            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1997            {4, 6}, {4, 6}, {4, 6}, {4, 6},
1998            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
1999            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
2000            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
2001            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
2002    };
2003    
2004    VLC const TMNMVtab2[] = {
2005            {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
2006            {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
2007            {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
2008            {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
2009            {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
2010            {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
2011            {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
2012            {24, 10}, {24, 10}, {24, 10}, {24, 10},
2013            {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
2014            {23, 10}, {23, 10}, {23, 10}, {23, 10},
2015            {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
2016            {22, 10}, {22, 10}, {22, 10}, {22, 10},
2017            {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
2018            {21, 10}, {21, 10}, {21, 10}, {21, 10},
2019            {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
2020            {20, 10}, {20, 10}, {20, 10}, {20, 10},
2021            {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
2022            {19, 10}, {19, 10}, {19, 10}, {19, 10},
2023            {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
2024            {18, 10}, {18, 10}, {18, 10}, {18, 10},
2025            {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
2026            {17, 10}, {17, 10}, {17, 10}, {17, 10},
2027            {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
2028            {16, 10}, {16, 10}, {16, 10}, {16, 10},
2029            {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
2030            {15, 10}, {15, 10}, {15, 10}, {15, 10},
2031            {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
2032            {14, 10}, {14, 10}, {14, 10}, {14, 10},
2033            {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
2034            {13, 10}, {13, 10}, {13, 10}, {13, 10},
2035            {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10}
2036    };
2037    
2038    short const dc_threshold[] = {
2039            21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,
2040             8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,
2041            25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,
2042            28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,
2043            30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,
2044            29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,
2045            26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,
2046            29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606
2047    };
2048    
2049    VLC const dc_lum_tab[] = {
2050            {0, 0}, {4, 3}, {3, 3}, {0, 3},
2051            {2, 2}, {2, 2}, {1, 2}, {1, 2},
2052    };
Legend:
Removed from v.809  
changed lines
  Added in v.883
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4