[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.44, Fri Feb 21 08:32:34 2003 UTC revision 1.44.2.12, Mon Jun 9 13:52:12 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 86  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 498  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 518  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 559  Line 537 
537          {          {
538                  if ((level = qcoeff[zigzag[i++]]) != 0)                  if ((level = qcoeff[zigzag[i++]]) != 0)
539                  {                  {
540                          abs_level = ABS(prev_level);                          abs_level = abs(prev_level);
541                          abs_level = abs_level < 64 ? abs_level : 0;                          abs_level = abs_level < 64 ? abs_level : 0;
542                          len               = coeff_VLC[1][0][abs_level][prev_run].len;                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
543                          bits      += len!=128 ? len : 30;                          bits      += len!=128 ? len : 30;
# Line 572  Line 550 
550                          run++;                          run++;
551          }          }
552    
553          abs_level = ABS(prev_level);          abs_level = abs(prev_level);
554          abs_level = abs_level < 64 ? abs_level : 0;          abs_level = abs_level < 64 ? abs_level : 0;
555          len               = coeff_VLC[1][1][abs_level][prev_run].len;          len               = coeff_VLC[1][1][abs_level][prev_run].len;
556          bits      += len!=128 ? len : 30;          bits      += len!=128 ? len : 30;
# Line 627  Line 605 
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 639  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 650  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 678  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 711  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 753  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 781  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 790  Line 775 
775    
776  }  }
777    
778  /*  
779  // moved to mbcoding.h so that in can be 'static __inline'  /* moved to mbcoding.h so that in can be 'static __inline' */
780    #if 0
781  void  void
782  MBSkip(Bitstream * bs)  MBSkip(Bitstream * bs)
783  {  {
784          BitstreamPutBit(bs, 1); // not coded          BitstreamPutBit(bs, 1); /* not coded */
785  }  }
786  */  #endif
787    
788  /***************************************************************  /***************************************************************
789   * bframe encoding start   * bframe encoding start
# Line 855  Line 841 
841                  BitstreamPutBit(bs, 1);                  BitstreamPutBit(bs, 1);
842                  return;                  return;
843    
844          default:;                                       // invalid          default:;                                       /* invalid */
845          }          }
846  }  }
847    
# Line 879  Line 865 
865          ------------------------------------------------------------------ */          ------------------------------------------------------------------ */
866    
867          if (mb->mode == MODE_DIRECT_NONE_MV) {          if (mb->mode == MODE_DIRECT_NONE_MV) {
868                  BitstreamPutBit(bs, 1); // skipped                  BitstreamPutBit(bs, 1); /* skipped */
869                  return;                  return;
870          }          }
871    
872          BitstreamPutBit(bs, 0);         // not skipped          BitstreamPutBit(bs, 0);         /* not skipped */
873    
874          if (mb->cbp == 0) {          if (mb->cbp == 0) {
875                  BitstreamPutBit(bs, 1); // cbp == 0                  BitstreamPutBit(bs, 1); /* cbp == 0 */
876          } else {          } else {
877                  BitstreamPutBit(bs, 0); // cbp == xxx                  BitstreamPutBit(bs, 0); /* cbp == xxx */
878          }          }
879    
880          put_bvop_mbtype(bs, mb->mode);          put_bvop_mbtype(bs, mb->mode);
# Line 898  Line 884 
884          }          }
885    
886          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
887                  put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0                  put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */
888          }          }
889    
890          switch (mb->mode) {          switch (mb->mode) {
891                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
892                          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 */
893                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
894                  case MODE_BACKWARD:                  case MODE_BACKWARD:
895                          vcode = bcode;                          vcode = bcode;
# Line 912  Line 898 
898                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
899                          break;                          break;
900                  case MODE_DIRECT:                  case MODE_DIRECT:
901                          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 */
902                          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) */
903                  default: break;                  default: break;
904          }          }
905    
# Line 935  Line 921 
921   ***************************************************************/   ***************************************************************/
922    
923    
924  // for IVOP addbits == 0  /*
925  // for PVOP addbits == fcode - 1   * for IVOP addbits == 0
926  // for BVOP addbits == max(fcode,bcode) - 1   * for PVOP addbits == fcode - 1
927  // returns true or false   * for BVOP addbits == max(fcode,bcode) - 1
928     * returns true or false
929     */
930  int  int
931  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
932  {  {
# Line 1052  Line 1040 
1040                  return data;                  return data;
1041    
1042          res = BitstreamGetBits(bs, fcode - 1);          res = BitstreamGetBits(bs, fcode - 1);
1043          mv = ((ABS(data) - 1) * scale_fac) + res + 1;          mv = ((abs(data) - 1) * scale_fac) + res + 1;
1044    
1045          return data < 0 ? -mv : mv;          return data < 0 ? -mv : mv;
1046    
# Line 1153  Line 1141 
1141                  level = BitstreamGetBits(bs, 8);                  level = BitstreamGetBits(bs, 8);
1142    
1143                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1144                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1145    
1146                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1147          }          }
# Line 1209  Line 1197 
1197          do {          do {
1198                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1199                  if (run == -1) {                  if (run == -1) {
1200                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1201                          break;                          break;
1202                  }                  }
1203                  coeff += run;                  coeff += run;
1204                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1205    
1206                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1207                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));  #if 0
1208                    DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1209    #endif
1210    
1211                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1212                          DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1213                  }                  }
1214                  coeff++;                  coeff++;
1215          } while (!last);          } while (!last);
# Line 1242  Line 1232 
1232          do {          do {
1233                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1234                  if (run == -1) {                  if (run == -1) {
1235                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1236                          break;                          break;
1237                  }                  }
1238                  p += run;                  p += run;
1239    
1240                  block[scan[p]] = level;                  block[scan[p]] = level;
1241    
1242                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);
1243                  // 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)); */
1244    
1245                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1246                          DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);
1247                  }                  }
1248                  p++;                  p++;
1249          } while (!last);          } while (!last);
1250    
1251  }  }
1252    
1253    
1254  /*****************************************************************************  /*****************************************************************************
1255   * VLC tables and other constant arrays   * VLC tables and other constant arrays
1256   ****************************************************************************/   ****************************************************************************/
# Line 1618  Line 1609 
1609          {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}          {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
1610  };  };
1611    
1612  const VLC cbpy_tab[16] = {  const VLC xvid_cbpy_tab[16] = {
1613          {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},          {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
1614          {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}          {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
1615  };  };

Legend:
Removed from v.1.44  
changed lines
  Added in v.1.44.2.12

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