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

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

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

revision 1.25.2.12, Fri Jan 17 16:05:27 2003 UTC revision 1.44.2.15, Fri Oct 3 13:47:00 2003 UTC
# Line 1  Line 1 
1   /******************************************************************************  /*****************************************************************************
2    *                                                                            *   *
3    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *   *  XVID MPEG-4 VIDEO CODEC
4    *                                                                            *   *  - MB coding -
5    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *   *
6    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *   *  Copyright (C) 2002 Michael Militzer <isibaar@xvid.org>
7    *  software module in hardware or software products are advised that its     *   *
8    *  use may infringe existing patents or copyrights, and any such use         *   *  This program is free software ; you can redistribute it and/or modify
9    *  would be at such party's own risk.  The original developer of this        *   *  it under the terms of the GNU General Public License as published by
10    *  software module and his/her company, and subsequent editors and their     *   *  the Free Software Foundation ; either version 2 of the License, or
11    *  companies, will have no liability for use of this software or             *   *  (at your option) any later version.
12    *  modifications or derivatives thereof.                                     *   *
13    *                                                                            *   *  This program is distributed in the hope that it will be useful,
14    *  XviD is free software; you can redistribute it and/or modify it           *   *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
15    *  under the terms of the GNU General Public License as published by         *   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    *  the Free Software Foundation; either version 2 of the License, or         *   *  GNU General Public License for more details.
17    *  (at your option) any later version.                                       *   *
18    *                                                                            *   *  You should have received a copy of the GNU General Public License
19    *  XviD is distributed in the hope that it will be useful, but               *   *  along with this program ; if not, write to the Free Software
20    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *   *
22    *  GNU General Public License for more details.                              *   * $Id$
23    *                                                                            *   *
24    *  You should have received a copy of the GNU General Public License         *   ****************************************************************************/
   *  along with this program; if not, write to the Free Software               *  
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *  
   *                                                                            *  
   ******************************************************************************/  
   
  /******************************************************************************  
   *                                                                            *  
   *  mbcoding.c                                                                *  
   *                                                                            *  
   *  Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org>                  *  
   *                                                                            *  
   *  For more information visit the XviD homepage: http://www.xvid.org         *  
   *                                                                            *  
   ******************************************************************************/  
   
  /******************************************************************************  
   *                                                                                                                                                        *  
   *  Revision history:                                                         *  
   *                                                                            *  
   *  28.10.2002 GMC support - gruel                                                                                        *  
   *  28.06.2002 added check_resync_marker()                                    *  
   *  14.04.2002 bframe encoding                                                                                            *  
   *  08.03.2002 initial version; isibaar                                                           *  
   *                                                                                                                                                        *  
   ******************************************************************************/  
   
25    
26  #include <stdio.h>  #include <stdio.h>
27  #include <stdlib.h>  #include <stdlib.h>
28    #include <string.h>
29    
30  #include "../portab.h"  #include "../portab.h"
31  #include "../global.h"  #include "../global.h"
32  #include "bitstream.h"  #include "bitstream.h"
# Line 72  Line 48 
48    
49  #ifdef BIGLUT  #ifdef BIGLUT
50  static VLC coeff_VLC[2][2][4096][64];  static VLC coeff_VLC[2][2][4096][64];
51  static VLC *intra_table, *inter_table;  VLC *intra_table;
52    static VLC *inter_table;
53  #else  #else
54  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
55  #endif  #endif
# Line 85  Line 62 
62          const int code2 = sprite_trajectory_len[len].code;          const int code2 = sprite_trajectory_len[len].code;
63          const int len2 = sprite_trajectory_len[len].len;          const int len2 = sprite_trajectory_len[len].len;
64    
65  //      printf("GMC=%d Code/Len  = %d / %d ",val, code,len);  #if 0
66  //      printf("Code2 / Len2 = %d / %d \n",code2,len2);          printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
67            printf("Code2 / Len2 = %d / %d \n",code2,len2);
68    #endif
69    
70          BitstreamPutBits(bs, code2, len2);          BitstreamPutBits(bs, code2, len2);
71          if (len) BitstreamPutBits(bs, code, len);          if (len) BitstreamPutBits(bs, code, len);
# Line 109  Line 88 
88  void  void
89  init_vlc_tables(void)  init_vlc_tables(void)
90  {  {
91          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset, limit;          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
92          int32_t l;          int32_t l;
93    
94  #ifdef BIGLUT  #ifdef BIGLUT
# Line 126  Line 105 
105                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++)
106                  {                  {
107                          for (run = 0; run < 63 + last; run++)                          for (run = 0; run < 63 + last; run++)
108                                  for (level = 0; level < 32 << intra; level++)                                  for (level = 0; level < (uint32_t)(32 << intra); level++)
109                                  {                                  {
110  #ifdef BIGLUT  #ifdef BIGLUT
111                                          offset = LEVELOFFSET;                                          offset = LEVELOFFSET;
# Line 145  Line 124 
124  #else  #else
125                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
126  #endif  #endif
127                          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++)
128                          {                          {
129                                  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;
130                                  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 170  Line 149 
149                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++)
150                          for (run = 0; run < 63 + last; run++)                          for (run = 0; run < 63 + last; run++)
151                          {                          {
152                                  for (level = 1; level < 32 << intra; level++)                                  for (level = 1; level < (uint32_t)(32 << intra); level++)
153                                  {                                  {
154                                          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])
155                                              continue;                                              continue;
# Line 195  Line 174 
174                                          }                                          }
175                                          else                                          else
176                                          {                                          {
177                                                  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])
178                                                  {                                                  {
179                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
180                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
# Line 211  Line 190 
190                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
191                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
192                                                                          coeff_VLC[intra][last][offset - level][run].code                                                                          coeff_VLC[intra][last][offset - level][run].code
193                                                                          = (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;
194                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;                                                                  coeff_VLC[intra][last][offset - level][run].len = 30;
195                                                          }                                                          }
196                                                          continue;                                                          continue;
# Line 373  Line 352 
352    
353  }  }
354    
355    
356    
357    /* returns the number of bits required to encode qcoeff */
358    int
359    CodeCoeff_CalcBits(const int16_t qcoeff[64],
360                      VLC * table,
361                      const uint16_t * zigzag,
362                      uint16_t intra)
363    {
364            int bits = 0;
365            uint32_t j, last;
366            short v;
367            VLC *vlc;
368    
369            j = intra;
370            last = intra;
371    
372            while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
373                    j++;
374    
375            if (j >= 64) return 0;  /* empty block */
376    
377            do {
378                    vlc = table + 64 * 2048 + (v << 6) + j - last;
379                    last = ++j;
380    
381                    /* count zeroes */
382                    while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
383                            j++;
384    
385                    /* write code */
386                    if (j != 64) {
387                            bits += vlc->len;
388                    } else {
389                            vlc += 64 * 4096;
390                            bits += vlc->len;
391                            break;
392                    }
393            } while (1);
394    
395            return bits;
396    }
397    
398    
399  #else  #else
400    
401  static __inline void  static __inline void
# Line 442  Line 465 
465          i       = 1;          i       = 1;
466          run = 0;          run = 0;
467    
468          while (!(level = qcoeff[zigzag[i++]]))          while (i<64 && !(level = qcoeff[zigzag[i++]]))
469                  run++;                  run++;
470    
471          prev_level = level;          prev_level = level;
# Line 453  Line 476 
476          {          {
477                  if ((level = qcoeff[zigzag[i++]]) != 0)                  if ((level = qcoeff[zigzag[i++]]) != 0)
478                  {                  {
479                          abs_level = ABS(prev_level);                          abs_level = abs(prev_level);
480                          abs_level = abs_level < 64 ? abs_level : 0;                          abs_level = abs_level < 64 ? abs_level : 0;
481                          code      = coeff_VLC[1][0][abs_level][prev_run].code;                          code      = coeff_VLC[1][0][abs_level][prev_run].code;
482                          len               = coeff_VLC[1][0][abs_level][prev_run].len;                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
# Line 473  Line 496 
496                          run++;                          run++;
497          }          }
498    
499          abs_level = ABS(prev_level);          abs_level = abs(prev_level);
500          abs_level = abs_level < 64 ? abs_level : 0;          abs_level = abs_level < 64 ? abs_level : 0;
501          code      = coeff_VLC[1][1][abs_level][prev_run].code;          code      = coeff_VLC[1][1][abs_level][prev_run].code;
502          len               = coeff_VLC[1][1][abs_level][prev_run].len;          len               = coeff_VLC[1][1][abs_level][prev_run].len;
# Line 487  Line 510 
510          BitstreamPutBits(bs, code, len);          BitstreamPutBits(bs, code, len);
511  }  }
512    
513    
514    
515    /* returns the number of bits required to encode qcoeff */
516    
517    int
518    CodeCoeffIntra_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
519    {
520            int bits = 0;
521            uint32_t i, abs_level, run, prev_run, len;
522            int32_t level, prev_level;
523    
524            i       = 1;
525            run = 0;
526    
527            while (i<64 && !(level = qcoeff[zigzag[i++]]))
528                    run++;
529    
530            if (i >= 64) return 0;  /* empty block */
531    
532            prev_level = level;
533            prev_run   = run;
534            run = 0;
535    
536            while (i < 64)
537            {
538                    if ((level = qcoeff[zigzag[i++]]) != 0)
539                    {
540                            abs_level = abs(prev_level);
541                            abs_level = abs_level < 64 ? abs_level : 0;
542                            len               = coeff_VLC[1][0][abs_level][prev_run].len;
543                            bits      += len!=128 ? len : 30;
544    
545                            prev_level = level;
546                            prev_run   = run;
547                            run = 0;
548                    }
549                    else
550                            run++;
551            }
552    
553            abs_level = abs(prev_level);
554            abs_level = abs_level < 64 ? abs_level : 0;
555            len               = coeff_VLC[1][1][abs_level][prev_run].len;
556            bits      += len!=128 ? len : 30;
557    
558            return bits;
559    }
560    
561    int
562    CodeCoeffInter_CalcBits(const int16_t qcoeff[64], const uint16_t * zigzag)
563    {
564            uint32_t i, run, prev_run, len;
565            int32_t level, prev_level, level_shifted;
566            int bits = 0;
567    
568            i       = 0;
569            run = 0;
570    
571            while (!(level = qcoeff[zigzag[i++]]))
572                    run++;
573    
574            prev_level = level;
575            prev_run   = run;
576            run = 0;
577    
578            while (i < 64) {
579                    if ((level = qcoeff[zigzag[i++]]) != 0) {
580                            level_shifted = prev_level + 32;
581                            if (!(level_shifted & -64))
582                                    len      = coeff_VLC[0][0][level_shifted][prev_run].len;
583                            else
584                                    len  = 30;
585    
586                            bits += len;
587                            prev_level = level;
588                            prev_run   = run;
589                            run = 0;
590                    }
591                    else
592                            run++;
593            }
594    
595            level_shifted = prev_level + 32;
596            if (!(level_shifted & -64))
597                    len      = coeff_VLC[0][1][level_shifted][prev_run].len;
598            else
599                    len  = 30;
600            bits += len;
601    
602            return bits;
603    }
604    
605    
606  #endif  #endif
607    
608    
609    static int iDQtab[5] = {
610            1, 0, -1 /* no change */, 2, 3
611    };
612    #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
613    
614    
615  static __inline void  static __inline void
616  CodeBlockIntra(const FRAMEINFO * const frame,  CodeBlockIntra(const FRAMEINFO * const frame,
617                             const MACROBLOCK * pMB,                             const MACROBLOCK * pMB,
# Line 501  Line 624 
624    
625          cbpy = pMB->cbp >> 2;          cbpy = pMB->cbp >> 2;
626    
627          // write mcbpc          /* write mcbpc */
628          if (frame->coding_type == I_VOP) {          if (frame->coding_type == I_VOP) {
629                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
630                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
# Line 512  Line 635 
635                                                   mcbpc_inter_tab[mcbpc].len);                                                   mcbpc_inter_tab[mcbpc].len);
636          }          }
637    
638          // ac prediction flag          /* ac prediction flag */
639          if (pMB->acpred_directions[0])          if (pMB->acpred_directions[0])
640                  BitstreamPutBits(bs, 1, 1);                  BitstreamPutBits(bs, 1, 1);
641          else          else
642                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
643    
644          // write cbpy          /* write cbpy */
645          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
646    
647          // write dquant          /* write dquant */
648          if (pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA_Q)
649                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
650    
651          // write interlacing          /* write interlacing */
652          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
653                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
654          }          }
655          // code block coeffs          /* code block coeffs */
656          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
657                  if (i < 4)                  if (i < 4)
658                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
# Line 540  Line 663 
663    
664                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i))) {
665                          const uint16_t *scan_table =                          const uint16_t *scan_table =
666                                  frame->global_flags & XVID_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
667                                  scan_tables[2] : scan_tables[pMB->acpred_directions[i]];                                  scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
668    
669                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
# Line 573  Line 696 
696          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
697          cbpy = 15 - (pMB->cbp >> 2);          cbpy = 15 - (pMB->cbp >> 2);
698    
699          // write mcbpc          /* write mcbpc */
700          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
701                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
702    
703          if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )          if ( (frame->coding_type == S_VOP) && (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) )
704                  BitstreamPutBit(bs, pMB->mcsel);                // mcsel: '0'=local motion, '1'=GMC                  BitstreamPutBit(bs, pMB->mcsel);                /* mcsel: '0'=local motion, '1'=GMC */
705    
706          // write cbpy          /* write cbpy */
707          BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
708    
709          // write dquant          /* write dquant */
710          if (pMB->mode == MODE_INTER_Q)          if (pMB->mode == MODE_INTER_Q)
711                  BitstreamPutBits(bs, pMB->dquant, 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
712    
713          // interlacing          /* interlacing */
714          if (frame->global_flags & XVID_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
715                  if (pMB->cbp) {                  if (pMB->cbp) {
716                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
717                          DPRINTF(DPRINTF_MB,"codep: field_dct: %i", pMB->field_dct);                          DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);
718                  }                  }
719    
720                  // if inter block, write field ME flag                  /* if inter block, write field ME flag */
721                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
722                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, pMB->field_pred);
723                          DPRINTF(DPRINTF_MB,"codep: field_pred: %i", pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
724    
725                          // write field prediction references                          /* write field prediction references */
726                          if (pMB->field_pred) {                          if (pMB->field_pred) {
727                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
728                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
729                          }                          }
730                  }                  }
731          }          }
732          // code motion vector(s) if motion is local          /* code motion vector(s) if motion is local  */
733          if (!pMB->mcsel)          if (!pMB->mcsel)
734                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
735                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
# Line 615  Line 738 
738    
739          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
740    
741          // code block coeffs          /* code block coeffs */
742          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
743                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i)))
744                  {                  {
745                          const uint16_t *scan_table =                          const uint16_t *scan_table =
746                                  frame->global_flags & XVID_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
747                                  scan_tables[2] : scan_tables[0];                                  scan_tables[2] : scan_tables[0];
748    
749  #ifdef BIGLUT  #ifdef BIGLUT
# Line 643  Line 766 
766                   Statistics * pStat)                   Statistics * pStat)
767  {  {
768          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)
769                          BitstreamPutBit(bs, 0); // not_coded                          BitstreamPutBit(bs, 0); /* not_coded */
770    
771          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
772                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
# Line 652  Line 775 
775    
776  }  }
777    
 /*  
 // moved to mbcoding.h so that in can be 'static __inline'  
 void  
 MBSkip(Bitstream * bs)  
 {  
         BitstreamPutBit(bs, 1); // not coded  
 }  
 */  
   
778  /***************************************************************  /***************************************************************
779   * bframe encoding start   * bframe encoding start
780   ***************************************************************/   ***************************************************************/
# Line 717  Line 831 
831                  BitstreamPutBit(bs, 1);                  BitstreamPutBit(bs, 1);
832                  return;                  return;
833    
834          default:;                                       // invalid          default:;                                       /* invalid */
835          }          }
836  }  }
837    
838    
839    
840  void  void
841  MBCodingBVOP(const MACROBLOCK * mb,  MBCodingBVOP(const FRAMEINFO * const frame,
842                             const MACROBLOCK * mb,
843                           const int16_t qcoeff[6 * 64],                           const int16_t qcoeff[6 * 64],
844                           const int32_t fcode,                           const int32_t fcode,
845                           const int32_t bcode,                           const int32_t bcode,
846                           Bitstream * bs,                           Bitstream * bs,
847                           Statistics * pStat,                           Statistics * pStat)
                          int direction)  
848  {  {
849          int vcode = fcode;          int vcode = fcode;
850          unsigned int i;          unsigned int i;
851    
852            const uint16_t *scan_table =
853                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
854                    scan_tables[2] : scan_tables[0];
855    
856    
857  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
858                  when a block is skipped it is decoded DIRECT(0,0)                  when a block is skipped it is decoded DIRECT(0,0)
859                  hence is interpolated from forward & backward frames                  hence is interpolated from forward & backward frames
860          ------------------------------------------------------------------ */          ------------------------------------------------------------------ */
861    
862          if (mb->mode == MODE_DIRECT_NONE_MV) {          if (mb->mode == MODE_DIRECT_NONE_MV) {
863                  BitstreamPutBit(bs, 1); // skipped                  BitstreamPutBit(bs, 1); /* skipped */
864                  return;                  return;
865          }          }
866    
867          BitstreamPutBit(bs, 0);         // not skipped          BitstreamPutBit(bs, 0);         /* not skipped */
868    
869          if (mb->cbp == 0) {          if (mb->cbp == 0) {
870                  BitstreamPutBit(bs, 1); // cbp == 0                  BitstreamPutBit(bs, 1); /* cbp == 0 */
871          } else {          } else {
872                  BitstreamPutBit(bs, 0); // cbp == xxx                  BitstreamPutBit(bs, 0); /* cbp == xxx */
873          }          }
874    
875          put_bvop_mbtype(bs, mb->mode);          put_bvop_mbtype(bs, mb->mode);
# Line 760  Line 879 
879          }          }
880    
881          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
882                  put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0                  put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */
883          }          }
884    
885            if (frame->vol_flags & XVID_VOL_INTERLACING) {
886                    if (mb->cbp) {
887                            BitstreamPutBit(bs, mb->field_dct);
888                            DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);
889                    }
890    
891                    /* if not direct block, write field ME flag */
892                    if (mb->mode != MODE_DIRECT) {
893                            BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
894    
895                            /* write field prediction references */
896                    /*      if (mb->field_pred) {
897                                    BitstreamPutBit(bs, mb->field_for_top);
898                                    BitstreamPutBit(bs, mb->field_for_bot);
899                            }*/
900                    }
901            }
902    
903    
904          switch (mb->mode) {          switch (mb->mode) {
905                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
906                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); //forward vector of interpolate mode                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); /* forward vector of interpolate mode */
907                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
908                  case MODE_BACKWARD:                  case MODE_BACKWARD:
909                          vcode = bcode;                          vcode = bcode;
# Line 774  Line 912 
912                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
913                          break;                          break;
914                  case MODE_DIRECT:                  case MODE_DIRECT:
915                          CodeVector(bs, mb->pmvs[3].x, 1, pStat);        // fcode is always 1 for delta vector                          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)                          CodeVector(bs, mb->pmvs[3].y, 1, pStat);        /* prediction is always (0,0) */
917                  default: break;                  default: break;
918          }          }
919    
# Line 797  Line 935 
935   ***************************************************************/   ***************************************************************/
936    
937    
938  // for IVOP addbits == 0  /*
939  // for PVOP addbits == fcode - 1   * for IVOP addbits == 0
940  // for BVOP addbits == max(fcode,bcode) - 1   * for PVOP addbits == fcode - 1
941  // returns true or false   * for BVOP addbits == max(fcode,bcode) - 1
942     * returns true or false
943     */
944  int  int
945  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
946  {  {
# Line 914  Line 1054 
1054                  return data;                  return data;
1055    
1056          res = BitstreamGetBits(bs, fcode - 1);          res = BitstreamGetBits(bs, fcode - 1);
1057          mv = ((ABS(data) - 1) * scale_fac) + res + 1;          mv = ((abs(data) - 1) * scale_fac) + res + 1;
1058    
1059          return data < 0 ? -mv : mv;          return data < 0 ? -mv : mv;
1060    
# Line 1015  Line 1155 
1155                  level = BitstreamGetBits(bs, 8);                  level = BitstreamGetBits(bs, 8);
1156    
1157                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1158                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1159    
1160                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1161          }          }
# Line 1071  Line 1211 
1211          do {          do {
1212                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1213                  if (run == -1) {                  if (run == -1) {
1214                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1215                          break;                          break;
1216                  }                  }
1217                  coeff += run;                  coeff += run;
1218                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1219    
1220                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1221                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));  #if 0
1222                    DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1223    #endif
1224    
1225                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1226                          DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1227                  }                  }
1228                  coeff++;                  coeff++;
1229          } while (!last);          } while (!last);
# Line 1104  Line 1246 
1246          do {          do {
1247                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1248                  if (run == -1) {                  if (run == -1) {
1249                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1250                          break;                          break;
1251                  }                  }
1252                  p += run;                  p += run;
1253    
1254                  block[scan[p]] = level;                  block[scan[p]] = level;
1255    
1256                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);
1257                  // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */
1258    
1259                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1260                          DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);
1261                  }                  }
1262                  p++;                  p++;
1263          } while (!last);          } while (!last);
1264    
1265  }  }
1266    
1267    
1268    /*****************************************************************************
1269     * VLC tables and other constant arrays
1270     ****************************************************************************/
1271    
1272    VLC_TABLE const coeff_tab[2][102] =
1273    {
1274            /* intra = 0 */
1275            {
1276                    {{ 2,  2}, {0, 0, 1}},
1277                    {{15,  4}, {0, 0, 2}},
1278                    {{21,  6}, {0, 0, 3}},
1279                    {{23,  7}, {0, 0, 4}},
1280                    {{31,  8}, {0, 0, 5}},
1281                    {{37,  9}, {0, 0, 6}},
1282                    {{36,  9}, {0, 0, 7}},
1283                    {{33, 10}, {0, 0, 8}},
1284                    {{32, 10}, {0, 0, 9}},
1285                    {{ 7, 11}, {0, 0, 10}},
1286                    {{ 6, 11}, {0, 0, 11}},
1287                    {{32, 11}, {0, 0, 12}},
1288                    {{ 6,  3}, {0, 1, 1}},
1289                    {{20,  6}, {0, 1, 2}},
1290                    {{30,  8}, {0, 1, 3}},
1291                    {{15, 10}, {0, 1, 4}},
1292                    {{33, 11}, {0, 1, 5}},
1293                    {{80, 12}, {0, 1, 6}},
1294                    {{14,  4}, {0, 2, 1}},
1295                    {{29,  8}, {0, 2, 2}},
1296                    {{14, 10}, {0, 2, 3}},
1297                    {{81, 12}, {0, 2, 4}},
1298                    {{13,  5}, {0, 3, 1}},
1299                    {{35,  9}, {0, 3, 2}},
1300                    {{13, 10}, {0, 3, 3}},
1301                    {{12,  5}, {0, 4, 1}},
1302                    {{34,  9}, {0, 4, 2}},
1303                    {{82, 12}, {0, 4, 3}},
1304                    {{11,  5}, {0, 5, 1}},
1305                    {{12, 10}, {0, 5, 2}},
1306                    {{83, 12}, {0, 5, 3}},
1307                    {{19,  6}, {0, 6, 1}},
1308                    {{11, 10}, {0, 6, 2}},
1309                    {{84, 12}, {0, 6, 3}},
1310                    {{18,  6}, {0, 7, 1}},
1311                    {{10, 10}, {0, 7, 2}},
1312                    {{17,  6}, {0, 8, 1}},
1313                    {{ 9, 10}, {0, 8, 2}},
1314                    {{16,  6}, {0, 9, 1}},
1315                    {{ 8, 10}, {0, 9, 2}},
1316                    {{22,  7}, {0, 10, 1}},
1317                    {{85, 12}, {0, 10, 2}},
1318                    {{21,  7}, {0, 11, 1}},
1319                    {{20,  7}, {0, 12, 1}},
1320                    {{28,  8}, {0, 13, 1}},
1321                    {{27,  8}, {0, 14, 1}},
1322                    {{33,  9}, {0, 15, 1}},
1323                    {{32,  9}, {0, 16, 1}},
1324                    {{31,  9}, {0, 17, 1}},
1325                    {{30,  9}, {0, 18, 1}},
1326                    {{29,  9}, {0, 19, 1}},
1327                    {{28,  9}, {0, 20, 1}},
1328                    {{27,  9}, {0, 21, 1}},
1329                    {{26,  9}, {0, 22, 1}},
1330                    {{34, 11}, {0, 23, 1}},
1331                    {{35, 11}, {0, 24, 1}},
1332                    {{86, 12}, {0, 25, 1}},
1333                    {{87, 12}, {0, 26, 1}},
1334                    {{ 7,  4}, {1, 0, 1}},
1335                    {{25,  9}, {1, 0, 2}},
1336                    {{ 5, 11}, {1, 0, 3}},
1337                    {{15,  6}, {1, 1, 1}},
1338                    {{ 4, 11}, {1, 1, 2}},
1339                    {{14,  6}, {1, 2, 1}},
1340                    {{13,  6}, {1, 3, 1}},
1341                    {{12,  6}, {1, 4, 1}},
1342                    {{19,  7}, {1, 5, 1}},
1343                    {{18,  7}, {1, 6, 1}},
1344                    {{17,  7}, {1, 7, 1}},
1345                    {{16,  7}, {1, 8, 1}},
1346                    {{26,  8}, {1, 9, 1}},
1347                    {{25,  8}, {1, 10, 1}},
1348                    {{24,  8}, {1, 11, 1}},
1349                    {{23,  8}, {1, 12, 1}},
1350                    {{22,  8}, {1, 13, 1}},
1351                    {{21,  8}, {1, 14, 1}},
1352                    {{20,  8}, {1, 15, 1}},
1353                    {{19,  8}, {1, 16, 1}},
1354                    {{24,  9}, {1, 17, 1}},
1355                    {{23,  9}, {1, 18, 1}},
1356                    {{22,  9}, {1, 19, 1}},
1357                    {{21,  9}, {1, 20, 1}},
1358                    {{20,  9}, {1, 21, 1}},
1359                    {{19,  9}, {1, 22, 1}},
1360                    {{18,  9}, {1, 23, 1}},
1361                    {{17,  9}, {1, 24, 1}},
1362                    {{ 7, 10}, {1, 25, 1}},
1363                    {{ 6, 10}, {1, 26, 1}},
1364                    {{ 5, 10}, {1, 27, 1}},
1365                    {{ 4, 10}, {1, 28, 1}},
1366                    {{36, 11}, {1, 29, 1}},
1367                    {{37, 11}, {1, 30, 1}},
1368                    {{38, 11}, {1, 31, 1}},
1369                    {{39, 11}, {1, 32, 1}},
1370                    {{88, 12}, {1, 33, 1}},
1371                    {{89, 12}, {1, 34, 1}},
1372                    {{90, 12}, {1, 35, 1}},
1373                    {{91, 12}, {1, 36, 1}},
1374                    {{92, 12}, {1, 37, 1}},
1375                    {{93, 12}, {1, 38, 1}},
1376                    {{94, 12}, {1, 39, 1}},
1377                    {{95, 12}, {1, 40, 1}}
1378            },
1379            /* intra = 1 */
1380            {
1381                    {{ 2,  2}, {0, 0, 1}},
1382                    {{15,  4}, {0, 0, 3}},
1383                    {{21,  6}, {0, 0, 6}},
1384                    {{23,  7}, {0, 0, 9}},
1385                    {{31,  8}, {0, 0, 10}},
1386                    {{37,  9}, {0, 0, 13}},
1387                    {{36,  9}, {0, 0, 14}},
1388                    {{33, 10}, {0, 0, 17}},
1389                    {{32, 10}, {0, 0, 18}},
1390                    {{ 7, 11}, {0, 0, 21}},
1391                    {{ 6, 11}, {0, 0, 22}},
1392                    {{32, 11}, {0, 0, 23}},
1393                    {{ 6,  3}, {0, 0, 2}},
1394                    {{20,  6}, {0, 1, 2}},
1395                    {{30,  8}, {0, 0, 11}},
1396                    {{15, 10}, {0, 0, 19}},
1397                    {{33, 11}, {0, 0, 24}},
1398                    {{80, 12}, {0, 0, 25}},
1399                    {{14,  4}, {0, 1, 1}},
1400                    {{29,  8}, {0, 0, 12}},
1401                    {{14, 10}, {0, 0, 20}},
1402                    {{81, 12}, {0, 0, 26}},
1403                    {{13,  5}, {0, 0, 4}},
1404                    {{35,  9}, {0, 0, 15}},
1405                    {{13, 10}, {0, 1, 7}},
1406                    {{12,  5}, {0, 0, 5}},
1407                    {{34,  9}, {0, 4, 2}},
1408                    {{82, 12}, {0, 0, 27}},
1409                    {{11,  5}, {0, 2, 1}},
1410                    {{12, 10}, {0, 2, 4}},
1411                    {{83, 12}, {0, 1, 9}},
1412                    {{19,  6}, {0, 0, 7}},
1413                    {{11, 10}, {0, 3, 4}},
1414                    {{84, 12}, {0, 6, 3}},
1415                    {{18,  6}, {0, 0, 8}},
1416                    {{10, 10}, {0, 4, 3}},
1417                    {{17,  6}, {0, 3, 1}},
1418                    {{ 9, 10}, {0, 8, 2}},
1419                    {{16,  6}, {0, 4, 1}},
1420                    {{ 8, 10}, {0, 5, 3}},
1421                    {{22,  7}, {0, 1, 3}},
1422                    {{85, 12}, {0, 1, 10}},
1423                    {{21,  7}, {0, 2, 2}},
1424                    {{20,  7}, {0, 7, 1}},
1425                    {{28,  8}, {0, 1, 4}},
1426                    {{27,  8}, {0, 3, 2}},
1427                    {{33,  9}, {0, 0, 16}},
1428                    {{32,  9}, {0, 1, 5}},
1429                    {{31,  9}, {0, 1, 6}},
1430                    {{30,  9}, {0, 2, 3}},
1431                    {{29,  9}, {0, 3, 3}},
1432                    {{28,  9}, {0, 5, 2}},
1433                    {{27,  9}, {0, 6, 2}},
1434                    {{26,  9}, {0, 7, 2}},
1435                    {{34, 11}, {0, 1, 8}},
1436                    {{35, 11}, {0, 9, 2}},
1437                    {{86, 12}, {0, 2, 5}},
1438                    {{87, 12}, {0, 7, 3}},
1439                    {{ 7,  4}, {1, 0, 1}},
1440                    {{25,  9}, {0, 11, 1}},
1441                    {{ 5, 11}, {1, 0, 6}},
1442                    {{15,  6}, {1, 1, 1}},
1443                    {{ 4, 11}, {1, 0, 7}},
1444                    {{14,  6}, {1, 2, 1}},
1445                    {{13,  6}, {0, 5, 1}},
1446                    {{12,  6}, {1, 0, 2}},
1447                    {{19,  7}, {1, 5, 1}},
1448                    {{18,  7}, {0, 6, 1}},
1449                    {{17,  7}, {1, 3, 1}},
1450                    {{16,  7}, {1, 4, 1}},
1451                    {{26,  8}, {1, 9, 1}},
1452                    {{25,  8}, {0, 8, 1}},
1453                    {{24,  8}, {0, 9, 1}},
1454                    {{23,  8}, {0, 10, 1}},
1455                    {{22,  8}, {1, 0, 3}},
1456                    {{21,  8}, {1, 6, 1}},
1457                    {{20,  8}, {1, 7, 1}},
1458                    {{19,  8}, {1, 8, 1}},
1459                    {{24,  9}, {0, 12, 1}},
1460                    {{23,  9}, {1, 0, 4}},
1461                    {{22,  9}, {1, 1, 2}},
1462                    {{21,  9}, {1, 10, 1}},
1463                    {{20,  9}, {1, 11, 1}},
1464                    {{19,  9}, {1, 12, 1}},
1465                    {{18,  9}, {1, 13, 1}},
1466                    {{17,  9}, {1, 14, 1}},
1467                    {{ 7, 10}, {0, 13, 1}},
1468                    {{ 6, 10}, {1, 0, 5}},
1469                    {{ 5, 10}, {1, 1, 3}},
1470                    {{ 4, 10}, {1, 2, 2}},
1471                    {{36, 11}, {1, 3, 2}},
1472                    {{37, 11}, {1, 4, 2}},
1473                    {{38, 11}, {1, 15, 1}},
1474                    {{39, 11}, {1, 16, 1}},
1475                    {{88, 12}, {0, 14, 1}},
1476                    {{89, 12}, {1, 0, 8}},
1477                    {{90, 12}, {1, 5, 2}},
1478                    {{91, 12}, {1, 6, 2}},
1479                    {{92, 12}, {1, 17, 1}},
1480                    {{93, 12}, {1, 18, 1}},
1481                    {{94, 12}, {1, 19, 1}},
1482                    {{95, 12}, {1, 20, 1}}
1483            }
1484    };
1485    
1486    /* constants taken from momusys/vm_common/inlcude/max_level.h */
1487    uint8_t const max_level[2][2][64] = {
1488            {
1489                    /* intra = 0, last = 0 */
1490                    {
1491                            12, 6, 4, 3, 3, 3, 3, 2,
1492                            2, 2, 2, 1, 1, 1, 1, 1,
1493                            1, 1, 1, 1, 1, 1, 1, 1,
1494                            1, 1, 1, 0, 0, 0, 0, 0,
1495                            0, 0, 0, 0, 0, 0, 0, 0,
1496                            0, 0, 0, 0, 0, 0, 0, 0,
1497                            0, 0, 0, 0, 0, 0, 0, 0,
1498                            0, 0, 0, 0, 0, 0, 0, 0
1499                    },
1500                    /* intra = 0, last = 1 */
1501                    {
1502                            3, 2, 1, 1, 1, 1, 1, 1,
1503                            1, 1, 1, 1, 1, 1, 1, 1,
1504                            1, 1, 1, 1, 1, 1, 1, 1,
1505                            1, 1, 1, 1, 1, 1, 1, 1,
1506                            1, 1, 1, 1, 1, 1, 1, 1,
1507                            1, 0, 0, 0, 0, 0, 0, 0,
1508                            0, 0, 0, 0, 0, 0, 0, 0,
1509                            0, 0, 0, 0, 0, 0, 0, 0
1510                    }
1511            },
1512            {
1513                    /* intra = 1, last = 0 */
1514                    {
1515                            27, 10, 5, 4, 3, 3, 3, 3,
1516                            2, 2, 1, 1, 1, 1, 1, 0,
1517                            0, 0, 0, 0, 0, 0, 0, 0,
1518                            0, 0, 0, 0, 0, 0, 0, 0,
1519                            0, 0, 0, 0, 0, 0, 0, 0,
1520                            0, 0, 0, 0, 0, 0, 0, 0,
1521                            0, 0, 0, 0, 0, 0, 0, 0,
1522                            0, 0, 0, 0, 0, 0, 0, 0
1523                    },
1524                    /* intra = 1, last = 1 */
1525                    {
1526                            8, 3, 2, 2, 2, 2, 2, 1,
1527                            1, 1, 1, 1, 1, 1, 1, 1,
1528                            1, 1, 1, 1, 1, 0, 0, 0,
1529                            0, 0, 0, 0, 0, 0, 0, 0,
1530                            0, 0, 0, 0, 0, 0, 0, 0,
1531                            0, 0, 0, 0, 0, 0, 0, 0,
1532                            0, 0, 0, 0, 0, 0, 0, 0,
1533                            0, 0, 0, 0, 0, 0, 0, 0
1534                    }
1535            }
1536    };
1537    
1538    uint8_t const max_run[2][2][64] = {
1539            {
1540                    /* intra = 0, last = 0 */
1541                    {
1542                            0, 26, 10, 6, 2, 1, 1, 0,
1543                            0, 0, 0, 0, 0, 0, 0, 0,
1544                            0, 0, 0, 0, 0, 0, 0, 0,
1545                            0, 0, 0, 0, 0, 0, 0, 0,
1546                            0, 0, 0, 0, 0, 0, 0, 0,
1547                            0, 0, 0, 0, 0, 0, 0, 0,
1548                            0, 0, 0, 0, 0, 0, 0, 0,
1549                            0, 0, 0, 0, 0, 0, 0, 0,
1550                    },
1551                    /* intra = 0, last = 1 */
1552                    {
1553                            0, 40, 1, 0, 0, 0, 0, 0,
1554                            0, 0, 0, 0, 0, 0, 0, 0,
1555                            0, 0, 0, 0, 0, 0, 0, 0,
1556                            0, 0, 0, 0, 0, 0, 0, 0,
1557                            0, 0, 0, 0, 0, 0, 0, 0,
1558                            0, 0, 0, 0, 0, 0, 0, 0,
1559                            0, 0, 0, 0, 0, 0, 0, 0,
1560                            0, 0, 0, 0, 0, 0, 0, 0,
1561                    }
1562            },
1563            {
1564                    /* intra = 1, last = 0 */
1565                    {
1566                            0, 14, 9, 7, 3, 2, 1, 1,
1567                            1, 1, 1, 0, 0, 0, 0, 0,
1568                            0, 0, 0, 0, 0, 0, 0, 0,
1569                            0, 0, 0, 0, 0, 0, 0, 0,
1570                            0, 0, 0, 0, 0, 0, 0, 0,
1571                            0, 0, 0, 0, 0, 0, 0, 0,
1572                            0, 0, 0, 0, 0, 0, 0, 0,
1573                            0, 0, 0, 0, 0, 0, 0, 0,
1574                    },
1575                    /* intra = 1, last = 1 */
1576                    {
1577                            0, 20, 6, 1, 0, 0, 0, 0,
1578                            0, 0, 0, 0, 0, 0, 0, 0,
1579                            0, 0, 0, 0, 0, 0, 0, 0,
1580                            0, 0, 0, 0, 0, 0, 0, 0,
1581                            0, 0, 0, 0, 0, 0, 0, 0,
1582                            0, 0, 0, 0, 0, 0, 0, 0,
1583                            0, 0, 0, 0, 0, 0, 0, 0,
1584                            0, 0, 0, 0, 0, 0, 0, 0,
1585                    }
1586            }
1587    };
1588    
1589    /******************************************************************
1590     * encoder tables                                                 *
1591     ******************************************************************/
1592    
1593    VLC sprite_trajectory_code[32768];
1594    
1595    VLC sprite_trajectory_len[15] = {
1596            { 0x00 , 2},
1597            { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1598            { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},
1599            { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1600    
1601    
1602    /* DCT coefficients. Four tables, two for last = 0, two for last = 1.
1603       the sign bit must be added afterwards. */
1604    
1605    /* MCBPC Indexing by cbpc in first two bits, mode in last two.
1606     CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
1607     Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
1608    
1609    VLC mcbpc_intra_tab[15] = {
1610            {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
1611            {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
1612            {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
1613            {0x00, 0}, {0x03, 3}, {0x03, 6}
1614    };
1615    
1616    /* MCBPC inter.
1617       Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
1618    
1619    VLC mcbpc_inter_tab[29] = {
1620            {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
1621            {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
1622            {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
1623            {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1624    };
1625    
1626    const VLC xvid_cbpy_tab[16] = {
1627            {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1628            {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1629    };
1630    
1631    const VLC dcy_tab[511] = {
1632            {0x100, 15}, {0x101, 15}, {0x102, 15}, {0x103, 15},
1633            {0x104, 15}, {0x105, 15}, {0x106, 15}, {0x107, 15},
1634            {0x108, 15}, {0x109, 15}, {0x10a, 15}, {0x10b, 15},
1635            {0x10c, 15}, {0x10d, 15}, {0x10e, 15}, {0x10f, 15},
1636            {0x110, 15}, {0x111, 15}, {0x112, 15}, {0x113, 15},
1637            {0x114, 15}, {0x115, 15}, {0x116, 15}, {0x117, 15},
1638            {0x118, 15}, {0x119, 15}, {0x11a, 15}, {0x11b, 15},
1639            {0x11c, 15}, {0x11d, 15}, {0x11e, 15}, {0x11f, 15},
1640            {0x120, 15}, {0x121, 15}, {0x122, 15}, {0x123, 15},
1641            {0x124, 15}, {0x125, 15}, {0x126, 15}, {0x127, 15},
1642            {0x128, 15}, {0x129, 15}, {0x12a, 15}, {0x12b, 15},
1643            {0x12c, 15}, {0x12d, 15}, {0x12e, 15}, {0x12f, 15},
1644            {0x130, 15}, {0x131, 15}, {0x132, 15}, {0x133, 15},
1645            {0x134, 15}, {0x135, 15}, {0x136, 15}, {0x137, 15},
1646            {0x138, 15}, {0x139, 15}, {0x13a, 15}, {0x13b, 15},
1647            {0x13c, 15}, {0x13d, 15}, {0x13e, 15}, {0x13f, 15},
1648            {0x140, 15}, {0x141, 15}, {0x142, 15}, {0x143, 15},
1649            {0x144, 15}, {0x145, 15}, {0x146, 15}, {0x147, 15},
1650            {0x148, 15}, {0x149, 15}, {0x14a, 15}, {0x14b, 15},
1651            {0x14c, 15}, {0x14d, 15}, {0x14e, 15}, {0x14f, 15},
1652            {0x150, 15}, {0x151, 15}, {0x152, 15}, {0x153, 15},
1653            {0x154, 15}, {0x155, 15}, {0x156, 15}, {0x157, 15},
1654            {0x158, 15}, {0x159, 15}, {0x15a, 15}, {0x15b, 15},
1655            {0x15c, 15}, {0x15d, 15}, {0x15e, 15}, {0x15f, 15},
1656            {0x160, 15}, {0x161, 15}, {0x162, 15}, {0x163, 15},
1657            {0x164, 15}, {0x165, 15}, {0x166, 15}, {0x167, 15},
1658            {0x168, 15}, {0x169, 15}, {0x16a, 15}, {0x16b, 15},
1659            {0x16c, 15}, {0x16d, 15}, {0x16e, 15}, {0x16f, 15},
1660            {0x170, 15}, {0x171, 15}, {0x172, 15}, {0x173, 15},
1661            {0x174, 15}, {0x175, 15}, {0x176, 15}, {0x177, 15},
1662            {0x178, 15}, {0x179, 15}, {0x17a, 15}, {0x17b, 15},
1663            {0x17c, 15}, {0x17d, 15}, {0x17e, 15}, {0x17f, 15},
1664            {0x80, 13}, {0x81, 13}, {0x82, 13}, {0x83, 13},
1665            {0x84, 13}, {0x85, 13}, {0x86, 13}, {0x87, 13},
1666            {0x88, 13}, {0x89, 13}, {0x8a, 13}, {0x8b, 13},
1667            {0x8c, 13}, {0x8d, 13}, {0x8e, 13}, {0x8f, 13},
1668            {0x90, 13}, {0x91, 13}, {0x92, 13}, {0x93, 13},
1669            {0x94, 13}, {0x95, 13}, {0x96, 13}, {0x97, 13},
1670            {0x98, 13}, {0x99, 13}, {0x9a, 13}, {0x9b, 13},
1671            {0x9c, 13}, {0x9d, 13}, {0x9e, 13}, {0x9f, 13},
1672            {0xa0, 13}, {0xa1, 13}, {0xa2, 13}, {0xa3, 13},
1673            {0xa4, 13}, {0xa5, 13}, {0xa6, 13}, {0xa7, 13},
1674            {0xa8, 13}, {0xa9, 13}, {0xaa, 13}, {0xab, 13},
1675            {0xac, 13}, {0xad, 13}, {0xae, 13}, {0xaf, 13},
1676            {0xb0, 13}, {0xb1, 13}, {0xb2, 13}, {0xb3, 13},
1677            {0xb4, 13}, {0xb5, 13}, {0xb6, 13}, {0xb7, 13},
1678            {0xb8, 13}, {0xb9, 13}, {0xba, 13}, {0xbb, 13},
1679            {0xbc, 13}, {0xbd, 13}, {0xbe, 13}, {0xbf, 13},
1680            {0x40, 11}, {0x41, 11}, {0x42, 11}, {0x43, 11},
1681            {0x44, 11}, {0x45, 11}, {0x46, 11}, {0x47, 11},
1682            {0x48, 11}, {0x49, 11}, {0x4a, 11}, {0x4b, 11},
1683            {0x4c, 11}, {0x4d, 11}, {0x4e, 11}, {0x4f, 11},
1684            {0x50, 11}, {0x51, 11}, {0x52, 11}, {0x53, 11},
1685            {0x54, 11}, {0x55, 11}, {0x56, 11}, {0x57, 11},
1686            {0x58, 11}, {0x59, 11}, {0x5a, 11}, {0x5b, 11},
1687            {0x5c, 11}, {0x5d, 11}, {0x5e, 11}, {0x5f, 11},
1688            {0x20, 9}, {0x21, 9}, {0x22, 9}, {0x23, 9},
1689            {0x24, 9}, {0x25, 9}, {0x26, 9}, {0x27, 9},
1690            {0x28, 9}, {0x29, 9}, {0x2a, 9}, {0x2b, 9},
1691            {0x2c, 9}, {0x2d, 9}, {0x2e, 9}, {0x2f, 9},
1692            {0x10, 7}, {0x11, 7}, {0x12, 7}, {0x13, 7},
1693            {0x14, 7}, {0x15, 7}, {0x16, 7}, {0x17, 7},
1694            {0x10, 6}, {0x11, 6}, {0x12, 6}, {0x13, 6},
1695            {0x08, 4}, {0x09, 4}, {0x06, 3}, {0x03, 3},
1696            {0x07, 3}, {0x0a, 4}, {0x0b, 4}, {0x14, 6},
1697            {0x15, 6}, {0x16, 6}, {0x17, 6}, {0x18, 7},
1698            {0x19, 7}, {0x1a, 7}, {0x1b, 7}, {0x1c, 7},
1699            {0x1d, 7}, {0x1e, 7}, {0x1f, 7}, {0x30, 9},
1700            {0x31, 9}, {0x32, 9}, {0x33, 9}, {0x34, 9},
1701            {0x35, 9}, {0x36, 9}, {0x37, 9}, {0x38, 9},
1702            {0x39, 9}, {0x3a, 9}, {0x3b, 9}, {0x3c, 9},
1703            {0x3d, 9}, {0x3e, 9}, {0x3f, 9}, {0x60, 11},
1704            {0x61, 11}, {0x62, 11}, {0x63, 11}, {0x64, 11},
1705            {0x65, 11}, {0x66, 11}, {0x67, 11}, {0x68, 11},
1706            {0x69, 11}, {0x6a, 11}, {0x6b, 11}, {0x6c, 11},
1707            {0x6d, 11}, {0x6e, 11}, {0x6f, 11}, {0x70, 11},
1708            {0x71, 11}, {0x72, 11}, {0x73, 11}, {0x74, 11},
1709            {0x75, 11}, {0x76, 11}, {0x77, 11}, {0x78, 11},
1710            {0x79, 11}, {0x7a, 11}, {0x7b, 11}, {0x7c, 11},
1711            {0x7d, 11}, {0x7e, 11}, {0x7f, 11}, {0xc0, 13},
1712            {0xc1, 13}, {0xc2, 13}, {0xc3, 13}, {0xc4, 13},
1713            {0xc5, 13}, {0xc6, 13}, {0xc7, 13}, {0xc8, 13},
1714            {0xc9, 13}, {0xca, 13}, {0xcb, 13}, {0xcc, 13},
1715            {0xcd, 13}, {0xce, 13}, {0xcf, 13}, {0xd0, 13},
1716            {0xd1, 13}, {0xd2, 13}, {0xd3, 13}, {0xd4, 13},
1717            {0xd5, 13}, {0xd6, 13}, {0xd7, 13}, {0xd8, 13},
1718            {0xd9, 13}, {0xda, 13}, {0xdb, 13}, {0xdc, 13},
1719            {0xdd, 13}, {0xde, 13}, {0xdf, 13}, {0xe0, 13},
1720            {0xe1, 13}, {0xe2, 13}, {0xe3, 13}, {0xe4, 13},
1721            {0xe5, 13}, {0xe6, 13}, {0xe7, 13}, {0xe8, 13},
1722            {0xe9, 13}, {0xea, 13}, {0xeb, 13}, {0xec, 13},
1723            {0xed, 13}, {0xee, 13}, {0xef, 13}, {0xf0, 13},
1724            {0xf1, 13}, {0xf2, 13}, {0xf3, 13}, {0xf4, 13},
1725            {0xf5, 13}, {0xf6, 13}, {0xf7, 13}, {0xf8, 13},
1726            {0xf9, 13}, {0xfa, 13}, {0xfb, 13}, {0xfc, 13},
1727            {0xfd, 13}, {0xfe, 13}, {0xff, 13}, {0x180, 15},
1728            {0x181, 15}, {0x182, 15}, {0x183, 15}, {0x184, 15},
1729            {0x185, 15}, {0x186, 15}, {0x187, 15}, {0x188, 15},
1730            {0x189, 15}, {0x18a, 15}, {0x18b, 15}, {0x18c, 15},
1731            {0x18d, 15}, {0x18e, 15}, {0x18f, 15}, {0x190, 15},
1732            {0x191, 15}, {0x192, 15}, {0x193, 15}, {0x194, 15},
1733            {0x195, 15}, {0x196, 15}, {0x197, 15}, {0x198, 15},
1734            {0x199, 15}, {0x19a, 15}, {0x19b, 15}, {0x19c, 15},
1735            {0x19d, 15}, {0x19e, 15}, {0x19f, 15}, {0x1a0, 15},
1736            {0x1a1, 15}, {0x1a2, 15}, {0x1a3, 15}, {0x1a4, 15},
1737            {0x1a5, 15}, {0x1a6, 15}, {0x1a7, 15}, {0x1a8, 15},
1738            {0x1a9, 15}, {0x1aa, 15}, {0x1ab, 15}, {0x1ac, 15},
1739            {0x1ad, 15}, {0x1ae, 15}, {0x1af, 15}, {0x1b0, 15},
1740            {0x1b1, 15}, {0x1b2, 15}, {0x1b3, 15}, {0x1b4, 15},
1741            {0x1b5, 15}, {0x1b6, 15}, {0x1b7, 15}, {0x1b8, 15},
1742            {0x1b9, 15}, {0x1ba, 15}, {0x1bb, 15}, {0x1bc, 15},
1743            {0x1bd, 15}, {0x1be, 15}, {0x1bf, 15}, {0x1c0, 15},
1744            {0x1c1, 15}, {0x1c2, 15}, {0x1c3, 15}, {0x1c4, 15},
1745            {0x1c5, 15}, {0x1c6, 15}, {0x1c7, 15}, {0x1c8, 15},
1746            {0x1c9, 15}, {0x1ca, 15}, {0x1cb, 15}, {0x1cc, 15},
1747            {0x1cd, 15}, {0x1ce, 15}, {0x1cf, 15}, {0x1d0, 15},
1748            {0x1d1, 15}, {0x1d2, 15}, {0x1d3, 15}, {0x1d4, 15},
1749            {0x1d5, 15}, {0x1d6, 15}, {0x1d7, 15}, {0x1d8, 15},
1750            {0x1d9, 15}, {0x1da, 15}, {0x1db, 15}, {0x1dc, 15},
1751            {0x1dd, 15}, {0x1de, 15}, {0x1df, 15}, {0x1e0, 15},
1752            {0x1e1, 15}, {0x1e2, 15}, {0x1e3, 15}, {0x1e4, 15},
1753            {0x1e5, 15}, {0x1e6, 15}, {0x1e7, 15}, {0x1e8, 15},
1754            {0x1e9, 15}, {0x1ea, 15}, {0x1eb, 15}, {0x1ec, 15},
1755            {0x1ed, 15}, {0x1ee, 15}, {0x1ef, 15}, {0x1f0, 15},
1756            {0x1f1, 15}, {0x1f2, 15}, {0x1f3, 15}, {0x1f4, 15},
1757            {0x1f5, 15}, {0x1f6, 15}, {0x1f7, 15}, {0x1f8, 15},
1758            {0x1f9, 15}, {0x1fa, 15}, {0x1fb, 15}, {0x1fc, 15},
1759            {0x1fd, 15}, {0x1fe, 15}, {0x1ff, 15},
1760    };
1761    
1762    const VLC dcc_tab[511] = {
1763            {0x100, 16}, {0x101, 16}, {0x102, 16}, {0x103, 16},
1764            {0x104, 16}, {0x105, 16}, {0x106, 16}, {0x107, 16},
1765            {0x108, 16}, {0x109, 16}, {0x10a, 16}, {0x10b, 16},
1766            {0x10c, 16}, {0x10d, 16}, {0x10e, 16}, {0x10f, 16},
1767            {0x110, 16}, {0x111, 16}, {0x112, 16}, {0x113, 16},
1768            {0x114, 16}, {0x115, 16}, {0x116, 16}, {0x117, 16},
1769            {0x118, 16}, {0x119, 16}, {0x11a, 16}, {0x11b, 16},
1770            {0x11c, 16}, {0x11d, 16}, {0x11e, 16}, {0x11f, 16},
1771            {0x120, 16}, {0x121, 16}, {0x122, 16}, {0x123, 16},
1772            {0x124, 16}, {0x125, 16}, {0x126, 16}, {0x127, 16},
1773            {0x128, 16}, {0x129, 16}, {0x12a, 16}, {0x12b, 16},
1774            {0x12c, 16}, {0x12d, 16}, {0x12e, 16}, {0x12f, 16},
1775            {0x130, 16}, {0x131, 16}, {0x132, 16}, {0x133, 16},
1776            {0x134, 16}, {0x135, 16}, {0x136, 16}, {0x137, 16},
1777            {0x138, 16}, {0x139, 16}, {0x13a, 16}, {0x13b, 16},
1778            {0x13c, 16}, {0x13d, 16}, {0x13e, 16}, {0x13f, 16},
1779            {0x140, 16}, {0x141, 16}, {0x142, 16}, {0x143, 16},
1780            {0x144, 16}, {0x145, 16}, {0x146, 16}, {0x147, 16},
1781            {0x148, 16}, {0x149, 16}, {0x14a, 16}, {0x14b, 16},
1782            {0x14c, 16}, {0x14d, 16}, {0x14e, 16}, {0x14f, 16},
1783            {0x150, 16}, {0x151, 16}, {0x152, 16}, {0x153, 16},
1784            {0x154, 16}, {0x155, 16}, {0x156, 16}, {0x157, 16},
1785            {0x158, 16}, {0x159, 16}, {0x15a, 16}, {0x15b, 16},
1786            {0x15c, 16}, {0x15d, 16}, {0x15e, 16}, {0x15f, 16},
1787            {0x160, 16}, {0x161, 16}, {0x162, 16}, {0x163, 16},
1788            {0x164, 16}, {0x165, 16}, {0x166, 16}, {0x167, 16},
1789            {0x168, 16}, {0x169, 16}, {0x16a, 16}, {0x16b, 16},
1790            {0x16c, 16}, {0x16d, 16}, {0x16e, 16}, {0x16f, 16},
1791            {0x170, 16}, {0x171, 16}, {0x172, 16}, {0x173, 16},
1792            {0x174, 16}, {0x175, 16}, {0x176, 16}, {0x177, 16},
1793            {0x178, 16}, {0x179, 16}, {0x17a, 16}, {0x17b, 16},
1794            {0x17c, 16}, {0x17d, 16}, {0x17e, 16}, {0x17f, 16},
1795            {0x80, 14}, {0x81, 14}, {0x82, 14}, {0x83, 14},
1796            {0x84, 14}, {0x85, 14}, {0x86, 14}, {0x87, 14},
1797            {0x88, 14}, {0x89, 14}, {0x8a, 14}, {0x8b, 14},
1798            {0x8c, 14}, {0x8d, 14}, {0x8e, 14}, {0x8f, 14},
1799            {0x90, 14}, {0x91, 14}, {0x92, 14}, {0x93, 14},
1800            {0x94, 14}, {0x95, 14}, {0x96, 14}, {0x97, 14},
1801            {0x98, 14}, {0x99, 14}, {0x9a, 14}, {0x9b, 14},
1802            {0x9c, 14}, {0x9d, 14}, {0x9e, 14}, {0x9f, 14},
1803            {0xa0, 14}, {0xa1, 14}, {0xa2, 14}, {0xa3, 14},
1804            {0xa4, 14}, {0xa5, 14}, {0xa6, 14}, {0xa7, 14},
1805            {0xa8, 14}, {0xa9, 14}, {0xaa, 14}, {0xab, 14},
1806            {0xac, 14}, {0xad, 14}, {0xae, 14}, {0xaf, 14},
1807            {0xb0, 14}, {0xb1, 14}, {0xb2, 14}, {0xb3, 14},
1808            {0xb4, 14}, {0xb5, 14}, {0xb6, 14}, {0xb7, 14},
1809            {0xb8, 14}, {0xb9, 14}, {0xba, 14}, {0xbb, 14},
1810            {0xbc, 14}, {0xbd, 14}, {0xbe, 14}, {0xbf, 14},
1811            {0x40, 12}, {0x41, 12}, {0x42, 12}, {0x43, 12},
1812            {0x44, 12}, {0x45, 12}, {0x46, 12}, {0x47, 12},
1813            {0x48, 12}, {0x49, 12}, {0x4a, 12}, {0x4b, 12},
1814            {0x4c, 12}, {0x4d, 12}, {0x4e, 12}, {0x4f, 12},
1815            {0x50, 12}, {0x51, 12}, {0x52, 12}, {0x53, 12},
1816            {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12},
1817            {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
1818            {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
1819            {0x20, 10}, {0x21, 10}, {0x22, 10}, {0x23, 10},
1820            {0x24, 10}, {0x25, 10}, {0x26, 10}, {0x27, 10},
1821            {0x28, 10}, {0x29, 10}, {0x2a, 10}, {0x2b, 10},
1822            {0x2c, 10}, {0x2d, 10}, {0x2e, 10}, {0x2f, 10},
1823            {0x10, 8}, {0x11, 8}, {0x12, 8}, {0x13, 8},
1824            {0x14, 8}, {0x15, 8}, {0x16, 8}, {0x17, 8},
1825            {0x08, 6}, {0x09, 6}, {0x0a, 6}, {0x0b, 6},
1826            {0x04, 4}, {0x05, 4}, {0x04, 3}, {0x03, 2},
1827            {0x05, 3}, {0x06, 4}, {0x07, 4}, {0x0c, 6},
1828            {0x0d, 6}, {0x0e, 6}, {0x0f, 6}, {0x18, 8},
1829            {0x19, 8}, {0x1a, 8}, {0x1b, 8}, {0x1c, 8},
1830            {0x1d, 8}, {0x1e, 8}, {0x1f, 8}, {0x30, 10},
1831            {0x31, 10}, {0x32, 10}, {0x33, 10}, {0x34, 10},
1832            {0x35, 10}, {0x36, 10}, {0x37, 10}, {0x38, 10},
1833            {0x39, 10}, {0x3a, 10}, {0x3b, 10}, {0x3c, 10},
1834            {0x3d, 10}, {0x3e, 10}, {0x3f, 10}, {0x60, 12},
1835            {0x61, 12}, {0x62, 12}, {0x63, 12}, {0x64, 12},
1836            {0x65, 12}, {0x66, 12}, {0x67, 12}, {0x68, 12},
1837            {0x69, 12}, {0x6a, 12}, {0x6b, 12}, {0x6c, 12},
1838            {0x6d, 12}, {0x6e, 12}, {0x6f, 12}, {0x70, 12},
1839            {0x71, 12}, {0x72, 12}, {0x73, 12}, {0x74, 12},
1840            {0x75, 12}, {0x76, 12}, {0x77, 12}, {0x78, 12},
1841            {0x79, 12}, {0x7a, 12}, {0x7b, 12}, {0x7c, 12},
1842            {0x7d, 12}, {0x7e, 12}, {0x7f, 12}, {0xc0, 14},
1843            {0xc1, 14}, {0xc2, 14}, {0xc3, 14}, {0xc4, 14},
1844            {0xc5, 14}, {0xc6, 14}, {0xc7, 14}, {0xc8, 14},
1845            {0xc9, 14}, {0xca, 14}, {0xcb, 14}, {0xcc, 14},
1846            {0xcd, 14}, {0xce, 14}, {0xcf, 14}, {0xd0, 14},
1847            {0xd1, 14}, {0xd2, 14}, {0xd3, 14}, {0xd4, 14},
1848            {0xd5, 14}, {0xd6, 14}, {0xd7, 14}, {0xd8, 14},
1849            {0xd9, 14}, {0xda, 14}, {0xdb, 14}, {0xdc, 14},
1850            {0xdd, 14}, {0xde, 14}, {0xdf, 14}, {0xe0, 14},
1851            {0xe1, 14}, {0xe2, 14}, {0xe3, 14}, {0xe4, 14},
1852            {0xe5, 14}, {0xe6, 14}, {0xe7, 14}, {0xe8, 14},
1853            {0xe9, 14}, {0xea, 14}, {0xeb, 14}, {0xec, 14},
1854            {0xed, 14}, {0xee, 14}, {0xef, 14}, {0xf0, 14},
1855            {0xf1, 14}, {0xf2, 14}, {0xf3, 14}, {0xf4, 14},
1856            {0xf5, 14}, {0xf6, 14}, {0xf7, 14}, {0xf8, 14},
1857            {0xf9, 14}, {0xfa, 14}, {0xfb, 14}, {0xfc, 14},
1858            {0xfd, 14}, {0xfe, 14}, {0xff, 14}, {0x180, 16},
1859            {0x181, 16}, {0x182, 16}, {0x183, 16}, {0x184, 16},
1860            {0x185, 16}, {0x186, 16}, {0x187, 16}, {0x188, 16},
1861            {0x189, 16}, {0x18a, 16}, {0x18b, 16}, {0x18c, 16},
1862            {0x18d, 16}, {0x18e, 16}, {0x18f, 16}, {0x190, 16},
1863            {0x191, 16}, {0x192, 16}, {0x193, 16}, {0x194, 16},
1864            {0x195, 16}, {0x196, 16}, {0x197, 16}, {0x198, 16},
1865            {0x199, 16}, {0x19a, 16}, {0x19b, 16}, {0x19c, 16},
1866            {0x19d, 16}, {0x19e, 16}, {0x19f, 16}, {0x1a0, 16},
1867            {0x1a1, 16}, {0x1a2, 16}, {0x1a3, 16}, {0x1a4, 16},
1868            {0x1a5, 16}, {0x1a6, 16}, {0x1a7, 16}, {0x1a8, 16},
1869            {0x1a9, 16}, {0x1aa, 16}, {0x1ab, 16}, {0x1ac, 16},
1870            {0x1ad, 16}, {0x1ae, 16}, {0x1af, 16}, {0x1b0, 16},
1871            {0x1b1, 16}, {0x1b2, 16}, {0x1b3, 16}, {0x1b4, 16},
1872            {0x1b5, 16}, {0x1b6, 16}, {0x1b7, 16}, {0x1b8, 16},
1873            {0x1b9, 16}, {0x1ba, 16}, {0x1bb, 16}, {0x1bc, 16},
1874            {0x1bd, 16}, {0x1be, 16}, {0x1bf, 16}, {0x1c0, 16},
1875            {0x1c1, 16}, {0x1c2, 16}, {0x1c3, 16}, {0x1c4, 16},
1876            {0x1c5, 16}, {0x1c6, 16}, {0x1c7, 16}, {0x1c8, 16},
1877            {0x1c9, 16}, {0x1ca, 16}, {0x1cb, 16}, {0x1cc, 16},
1878            {0x1cd, 16}, {0x1ce, 16}, {0x1cf, 16}, {0x1d0, 16},
1879            {0x1d1, 16}, {0x1d2, 16}, {0x1d3, 16}, {0x1d4, 16},
1880            {0x1d5, 16}, {0x1d6, 16}, {0x1d7, 16}, {0x1d8, 16},
1881            {0x1d9, 16}, {0x1da, 16}, {0x1db, 16}, {0x1dc, 16},
1882            {0x1dd, 16}, {0x1de, 16}, {0x1df, 16}, {0x1e0, 16},
1883            {0x1e1, 16}, {0x1e2, 16}, {0x1e3, 16}, {0x1e4, 16},
1884            {0x1e5, 16}, {0x1e6, 16}, {0x1e7, 16}, {0x1e8, 16},
1885            {0x1e9, 16}, {0x1ea, 16}, {0x1eb, 16}, {0x1ec, 16},
1886            {0x1ed, 16}, {0x1ee, 16}, {0x1ef, 16}, {0x1f0, 16},
1887            {0x1f1, 16}, {0x1f2, 16}, {0x1f3, 16}, {0x1f4, 16},
1888            {0x1f5, 16}, {0x1f6, 16}, {0x1f7, 16}, {0x1f8, 16},
1889            {0x1f9, 16}, {0x1fa, 16}, {0x1fb, 16}, {0x1fc, 16},
1890            {0x1fd, 16}, {0x1fe, 16}, {0x1ff, 16},
1891    };
1892    
1893    
1894    const VLC mb_motion_table[65] = {
1895            {0x05, 13}, {0x07, 13}, {0x05, 12}, {0x07, 12},
1896            {0x09, 12}, {0x0b, 12}, {0x0d, 12}, {0x0f, 12},
1897            {0x09, 11}, {0x0b, 11}, {0x0d, 11}, {0x0f, 11},
1898            {0x11, 11}, {0x13, 11}, {0x15, 11}, {0x17, 11},
1899            {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11},
1900            {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10},
1901            {0x17, 10}, {0x07, 8}, {0x09, 8}, {0x0b, 8},
1902            {0x07, 7}, {0x03, 5}, {0x03, 4}, {0x03, 3},
1903            {0x01, 1}, {0x02, 3}, {0x02, 4}, {0x02, 5},
1904            {0x06, 7}, {0x0a, 8}, {0x08, 8}, {0x06, 8},
1905            {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11},
1906            {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11},
1907            {0x18, 11}, {0x16, 11}, {0x14, 11}, {0x12, 11},
1908            {0x10, 11}, {0x0e, 11}, {0x0c, 11}, {0x0a, 11},
1909            {0x08, 11}, {0x0e, 12}, {0x0c, 12}, {0x0a, 12},
1910            {0x08, 12}, {0x06, 12}, {0x04, 12}, {0x06, 13},
1911            {0x04, 13}
1912    };
1913    
1914    
1915    /******************************************************************
1916     * decoder tables                                                 *
1917     ******************************************************************/
1918    
1919    VLC const mcbpc_intra_table[64] = {
1920            {-1, 0}, {20, 6}, {36, 6}, {52, 6}, {4, 4},  {4, 4},  {4, 4},  {4, 4},
1921            {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
1922            {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3},
1923            {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
1924            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1925            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1926            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},
1927            {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1},  {3, 1}
1928    };
1929    
1930    VLC const mcbpc_inter_table[257] = {
1931            {VLC_ERROR, 0}, {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8},
1932            {19, 8}, {19, 8}, {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7},
1933            {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
1934            {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
1935            {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
1936            {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
1937            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1938            {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
1939            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1940            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1941            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1942            {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
1943            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1944            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1945            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
1946            {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
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            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1951            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1952            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1953            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
1954            {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 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            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1959            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1960            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1961            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1962            {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
1963            {0, 1}
1964    };
1965    
1966    VLC const cbpy_table[64] = {
1967            {-1, 0}, {-1, 0}, {6, 6},  {9, 6},  {8, 5},  {8, 5},  {4, 5},  {4, 5},
1968            {2, 5},  {2, 5},  {1, 5},  {1, 5},  {0, 4},  {0, 4},  {0, 4},  {0, 4},
1969            {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
1970            {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4},  {5, 4},  {5, 4},  {5, 4},
1971            {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4},  {3, 4},  {3, 4},  {3, 4},
1972            {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4},  {7, 4},  {7, 4},  {7, 4},
1973            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2},
1974            {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}, {15, 2}
1975    };
1976    
1977    VLC const TMNMVtab0[] = {
1978            {3, 4}, {-3, 4}, {2, 3}, {2, 3}, {-2, 3}, {-2, 3}, {1, 2},
1979            {1, 2}, {1, 2}, {1, 2}, {-1, 2}, {-1, 2}, {-1, 2}, {-1, 2}
1980    };
1981    
1982    VLC const TMNMVtab1[] = {
1983            {12, 10}, {-12, 10}, {11, 10}, {-11, 10},
1984            {10, 9}, {10, 9}, {-10, 9}, {-10, 9},
1985            {9, 9}, {9, 9}, {-9, 9}, {-9, 9},
1986            {8, 9}, {8, 9}, {-8, 9}, {-8, 9},
1987            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1988            {7, 7}, {7, 7}, {7, 7}, {7, 7},
1989            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1990            {-7, 7}, {-7, 7}, {-7, 7}, {-7, 7},
1991            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1992            {6, 7}, {6, 7}, {6, 7}, {6, 7},
1993            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1994            {-6, 7}, {-6, 7}, {-6, 7}, {-6, 7},
1995            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1996            {5, 7}, {5, 7}, {5, 7}, {5, 7},
1997            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
1998            {-5, 7}, {-5, 7}, {-5, 7}, {-5, 7},
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            {4, 6}, {4, 6}, {4, 6}, {4, 6},
2003            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
2004            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
2005            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6},
2006            {-4, 6}, {-4, 6}, {-4, 6}, {-4, 6}
2007    };
2008    
2009    VLC const TMNMVtab2[] = {
2010            {32, 12}, {-32, 12}, {31, 12}, {-31, 12},
2011            {30, 11}, {30, 11}, {-30, 11}, {-30, 11},
2012            {29, 11}, {29, 11}, {-29, 11}, {-29, 11},
2013            {28, 11}, {28, 11}, {-28, 11}, {-28, 11},
2014            {27, 11}, {27, 11}, {-27, 11}, {-27, 11},
2015            {26, 11}, {26, 11}, {-26, 11}, {-26, 11},
2016            {25, 11}, {25, 11}, {-25, 11}, {-25, 11},
2017            {24, 10}, {24, 10}, {24, 10}, {24, 10},
2018            {-24, 10}, {-24, 10}, {-24, 10}, {-24, 10},
2019            {23, 10}, {23, 10}, {23, 10}, {23, 10},
2020            {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10},
2021            {22, 10}, {22, 10}, {22, 10}, {22, 10},
2022            {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
2023            {21, 10}, {21, 10}, {21, 10}, {21, 10},
2024            {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
2025            {20, 10}, {20, 10}, {20, 10}, {20, 10},
2026            {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10},
2027            {19, 10}, {19, 10}, {19, 10}, {19, 10},
2028            {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
2029            {18, 10}, {18, 10}, {18, 10}, {18, 10},
2030            {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10},
2031            {17, 10}, {17, 10}, {17, 10}, {17, 10},
2032            {-17, 10}, {-17, 10}, {-17, 10}, {-17, 10},
2033            {16, 10}, {16, 10}, {16, 10}, {16, 10},
2034            {-16, 10}, {-16, 10}, {-16, 10}, {-16, 10},
2035            {15, 10}, {15, 10}, {15, 10}, {15, 10},
2036            {-15, 10}, {-15, 10}, {-15, 10}, {-15, 10},
2037            {14, 10}, {14, 10}, {14, 10}, {14, 10},
2038            {-14, 10}, {-14, 10}, {-14, 10}, {-14, 10},
2039            {13, 10}, {13, 10}, {13, 10}, {13, 10},
2040            {-13, 10}, {-13, 10}, {-13, 10}, {-13, 10}
2041    };
2042    
2043    short const dc_threshold[] = {
2044            21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,
2045             8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,
2046            25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,
2047            28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,
2048            30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,
2049            29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,
2050            26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,
2051            29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606
2052    };
2053    
2054    VLC const dc_lum_tab[] = {
2055            {0, 0}, {4, 3}, {3, 3}, {0, 3},
2056            {2, 2}, {2, 2}, {1, 2}, {1, 2},
2057    };
Legend:
Removed from v.1.25.2.12  
changed lines
  Added in v.1.44.2.15
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4