[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.2.6, Sun Apr 27 19:45:52 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>
# Line 88  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 648  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 659  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, xvid_cbpy_tab[cbpy].code, xvid_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, DQ_VALUE2INDEX(pMB->dquant), 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
650    
651          // write interlacing          /* write interlacing */
652          if (frame->vol_flags & XVID_VOL_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 720  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, xvid_cbpy_tab[cbpy].code, xvid_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, DQ_VALUE2INDEX(pMB->dquant), 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
712    
713          // interlacing          /* interlacing */
714          if (frame->vol_flags & XVID_VOL_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 762  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                  {                  {
# Line 790  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 799  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 864  Line 841 
841                  BitstreamPutBit(bs, 1);                  BitstreamPutBit(bs, 1);
842                  return;                  return;
843    
844          default:;                                       // invalid          default:;                                       /* invalid */
845          }          }
846  }  }
847    
# Line 888  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 907  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 921  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 944  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 1162  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 1218  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 1251  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);
# Line 1270  Line 1251 
1251  }  }
1252    
1253    
   
   
   
   
   
 /************************************************************************  
  *               Trellis based R-D optimal quantization                 *  
  *  not really "bitstream" or "mbcoding" related, but needs VLC tables  *  
  *                                                                      *  
  ************************************************************************/  
   
   
 int __inline  
 RunLevel_CalcBits_inter(const int16_t run, int16_t level)  
 {  
         const int esc_length = 30;  
   
         if (!((level+32) & -64))  
                 return coeff_VLC[0][0][level+32][run].len;  
         else  
                 return esc_length;  
 }  
   
 int __inline  
 RunLevelLast_CalcBits_inter(const int16_t run, const int16_t level)  
 {  
         const int esc_length = 30;  
   
         if (!((level+32) & -64))  
                 return coeff_VLC[0][1][level+32][run].len;  
         else  
                 return esc_length;  
 }  
   
   
 int __inline  
 RunLevel_CalcBits_intra(const int16_t run, int16_t level)  
 {  
         const int esc_length = 30;  
         int bits;  
   
         level = abs(level);  
         if (!(level & -64)) {  
                 bits = coeff_VLC[1][0][level][run].len;  
                 if (bits!=128)  
                         return bits;  
         }  
         return esc_length;  
 }  
   
 int __inline  
 RunLevelLast_CalcBits_intra(const int16_t run, int16_t level)  
 {  
         const int esc_length = 30;  
         int bits;  
   
         level = abs(level);  
         if (!(level & -64)) {  
                 bits = coeff_VLC[1][1][level][run].len;  
                 if (bits!=128)  
                         return bits;  
         }  
         return esc_length;  
 }  
   
 /* based on ffmpeg's trellis quant, thanks! */  
 /* (C) 2003 Michael Niedermayer <michaelni@gmx.at> */  
   
 int  
 dct_quantize_trellis_inter_h263_c (int16_t *qcoeff, const int16_t *data, int quant)  
 {  
   
 /* input: original quantized DCT coefficients (to calc distorion)*/  
 /*                already quantized DCT coefficients */  
 /*                quantizer */  
 /* output: modified table of quantized DCT coefficients */  
   
 /* maybe combining quantize&Trellis would be faster (even that it disables MMX quant) */  
   
   int run_tab[65];  
   int level_tab[65];  
   int score_tab[65];  
   int last_run = 0;  
   int last_level = 0;  
   int last_score = 0;  
   int last_i = 0;  
   int coeff[64];  
   int coeff_count[64];  /* is a table useful for this 0-1 (or 1-2) table? */  
   int last_non_zero, i;  
   
   const uint16_t *const zigzag = &scan_tables[0][0];  
         /* ordinary zigzag order, so it's not INTERLACE compatible, yet  */  
   
   const int qmul = 2*quant;  
   const int qadd = ((quant-1)|1);  
   
 /* quant is not needed anymore after this */  
   
   int score_limit = 0;  
   int left_limit = 0;  
   
   const int lambda = (quant * quant * 123 + 64) >> 7;   // default lagrangian  
   
 /*  control lambda through a ENVIRONMENT variable (for automatic optmization) */  
   
 /*  
   const int lfact=123;  // better control of the lagrangian lambda  
   int lambda = (quant * quant * 123 + 64) >> 7; // default lagrangian  
   
   const char * const trellis_lambda = getenv("TRELLIS_LAMBDA");  
   if(trellis_lambda)  
                 lfact = atoi(trellis_lambda);  
   if (lfact < 1)  
         lfact = 123;    // why this value? Who knows? But 123 seems better than 109 = 0.85<<7  
   
   lambda = (quant * quant * lfact + 64) >> 7;   // lagrangian  
 */  
   
   last_non_zero = -1;  
   for (i = 0; i < 64; i++)  
     {  
       const int level = qcoeff[zigzag[i]];  
   
                 if (level) {  
                         last_non_zero = i;  
   
                         if (level>0) {  
                                 if (level==1) {  
                                         coeff[i] = 1;  
                                         coeff_count[i] = 0;  
                                 } else {  
                                         coeff[i] = level;  
                                         coeff_count[i] = 1;  
                                 }  
                         } else {  
                                 if (level==-1) {  
                                         coeff[i] = -1;  
                                         coeff_count[i] = 0;  
                                 } else {  
                                         coeff[i] = level+1;     // because we check coeff[i] and coeff[i]-1  
                                         coeff_count[i] = 1;  
                                 }  
                         }  
             } else {  
                         coeff[i] = ((data[zigzag[i]]>>31)|1); /* +- 1 because of gap */  
                         coeff_count[i] = 0;  
                 }  
     }  
   
   if (last_non_zero < 0)  
       return last_non_zero;  
   
   score_tab[0] = 0;  
   
   for (i = 0; i <= last_non_zero; i++) {  
     int level, run, j;  
     const int dct_coeff = data[zigzag[i]];  
     const int zero_distortion = dct_coeff * dct_coeff;  
     int best_score = 256 * 256 * 256 * 120;  
   
         int distortion;  
         int dequant_err;  
   
         last_score += zero_distortion;  
   
   
 /****************** level loop unrolled: first check coeff[i] *********/  
     level = coeff[i];  
   
         if (level > 0)  // coeff[i]==0 is not possible here  
                 dequant_err = level * qmul + qadd - dct_coeff;  
         else  
                 dequant_err = level * qmul - qadd - dct_coeff;  
   
         distortion = dequant_err*dequant_err;  
   
         for (run = 0; run <= i - left_limit; run++) {  
   
           int score = distortion + lambda*RunLevel_CalcBits_inter(run, level) + score_tab[i - run];  
   
           if (score < best_score)  
             {  
               best_score = score_tab[i + 1] = score;  
               run_tab[i + 1] = run;  
               level_tab[i + 1] = level;  
             }  
         }  
   
         for (run = 0; run <= i - left_limit; run++) {  
           int score = distortion + lambda*RunLevelLast_CalcBits_inter(run, level) + score_tab[i - run];  
   
       if (score < last_score)  
                 {  
                   last_score = score;  
                   last_run = run;  
                   last_level = level;  
                   last_i = i + 1;  
                 }  
     }  
   
 /****************** level loop unrolled: if possible, check coeff[i]-1 *********/  
   
     if (coeff_count[i]) {  
   
                 level--;  
                 dequant_err -= qmul;  
                 distortion = dequant_err*dequant_err;  
   
                 for (run = 0; run <= i - left_limit; run++) {  
                   int score = distortion + lambda*RunLevel_CalcBits_inter(run, level) + score_tab[i-run];  
   
                   if (score < best_score)  
                     {  
                       best_score = score_tab[i + 1] = score;  
                       run_tab[i + 1] = run;  
                       level_tab[i + 1] = level;  
                     }  
                 }  
   
           for (run = 0; run <= i - left_limit; run++) {  
                   int score = distortion + lambda*RunLevelLast_CalcBits_inter(run, level) + score_tab[i-run];  
   
               if (score < last_score)  
                         {  
                           last_score = score;  
                           last_run = run;  
                           last_level = level;  
                           last_i = i + 1;  
                         }  
   
             }  
         } // of check coeff[i]-1  
   
   
 /****************** checking coeff[i]-2 doesn't isn't supported  *********/  
   
 /****************** add distorsion for higher RUN (-> coeff[i]==0) *******/  
     for (j = left_limit; j <= i; j++)  
           score_tab[j] += zero_distortion;  
   
     score_limit += zero_distortion;  
   
     if (score_tab[i + 1] < score_limit)  
           score_limit = score_tab[i + 1];  
   
  // there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level  
  // so we finalize only if we have no chance of getting lower than  score_limit + 1*lambda   anymore  
   
         while (score_tab[left_limit] > score_limit + lambda)  
           left_limit++;  
   
   
   } // end of (i=0;i<=last_non_zero;i++)  
   
   
   last_score = 256 * 256 * 256 * 120;  
   for (i = left_limit; i <= last_non_zero + 1; i++)  
         {  
           int score = score_tab[i];  
           if (i)  
             score += 2*lambda;  /* coded block means 2 extra bits (roughly) */  
   
           if (score < last_score)  
             {  
               last_score = score;  
               last_i = i;  
               last_level = level_tab[i];  
               last_run = run_tab[i];  
             }  
         }  
   
   last_non_zero = last_i - 1;  
   if (last_non_zero < 0)  
     return last_non_zero;  
   
   i = last_i;  
   
   memset(qcoeff,0x00,64*sizeof(int16_t));  
   
   qcoeff[zigzag[last_non_zero]] = last_level;  
   i -= last_run + 1;  
   
   for (; i > 0; i -= run_tab[i] + 1)  
     {  
       qcoeff[zigzag[i-1]] = level_tab[i];  
     }  
   
   return last_non_zero;  
 }  
   
 int  
 dct_quantize_trellis_inter_mpeg_c (int16_t *qcoeff, const int16_t *data, int quant)  
 { return 64; }  
   
   
   
   
   
1254  /*****************************************************************************  /*****************************************************************************
1255   * VLC tables and other constant arrays   * VLC tables and other constant arrays
1256   ****************************************************************************/   ****************************************************************************/
Legend:
Removed from v.1.44.2.6  
changed lines
  Added in v.1.44.2.12
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4