[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.7, Sat May 3 19:11:58 2003 UTC revision 1.50, Fri Dec 10 04:10:12 2004 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 62  Line 36 
36    
37  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
38    
 /* #define BIGLUT */  
   
 #ifdef BIGLUT  
 #define LEVELOFFSET 2048  
 #else  
39  #define LEVELOFFSET 32  #define LEVELOFFSET 32
 #endif  
40    
41    /* Initialized once during xvid_global call
42     * RO access is thread safe */
43  static REVERSE_EVENT DCT3D[2][4096];  static REVERSE_EVENT DCT3D[2][4096];
   
 #ifdef BIGLUT  
 static VLC coeff_VLC[2][2][4096][64];  
 VLC *intra_table;  
 static VLC *inter_table;  
 #else  
44  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
 #endif  
45    
46  /* not really MB related, but VLCs are only available here */  /* not really MB related, but VLCs are only available here */
47  void bs_put_spritetrajectory(Bitstream * bs, const int val)  void bs_put_spritetrajectory(Bitstream * bs, const int val)
# Line 88  Line 51 
51          const int code2 = sprite_trajectory_len[len].code;          const int code2 = sprite_trajectory_len[len].code;
52          const int len2 = sprite_trajectory_len[len].len;          const int len2 = sprite_trajectory_len[len].len;
53    
54  //      printf("GMC=%d Code/Len  = %d / %d ",val, code,len);  #if 0
55  //      printf("Code2 / Len2 = %d / %d \n",code2,len2);          printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
56            printf("Code2 / Len2 = %d / %d \n",code2,len2);
57    #endif
58    
59          BitstreamPutBits(bs, code2, len2);          BitstreamPutBits(bs, code2, len2);
60          if (len) BitstreamPutBits(bs, code, len);          if (len) BitstreamPutBits(bs, code, len);
# Line 115  Line 80 
80          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
81          int32_t l;          int32_t l;
82    
 #ifdef BIGLUT  
         intra_table = coeff_VLC[1];  
         inter_table = coeff_VLC[0];  
 #endif  
   
   
83          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++)
84                  for (i = 0; i < 4096; i++)                  for (i = 0; i < 4096; i++)
85                          DCT3D[intra][i].event.level = 0;                          DCT3D[intra][i].event.level = 0;
86    
87          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
88                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++) {
89                  {                          for (run = 0; run < 63 + last; run++) {
90                          for (run = 0; run < 63 + last; run++)                                  for (level = 0; level < (uint32_t)(32 << intra); level++) {
                                 for (level = 0; level < (uint32_t)(32 << intra); level++)  
                                 {  
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
91                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
92                                          coeff_VLC[intra][last][level + offset][run].len = 128;                                          coeff_VLC[intra][last][level + offset][run].len = 128;
93                                  }                                  }
94                  }                  }
95                    }
96            }
97    
98          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
99                  for (i = 0; i < 102; i++)                  for (i = 0; i < 102; i++) {
                 {  
 #ifdef BIGLUT  
                         offset = LEVELOFFSET;  
 #else  
100                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
101  #endif  
102                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++)                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++) {
                         {  
103                                  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;
104                                  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;
105                          }                          }
# Line 158  Line 108 
108                                  = coeff_tab[intra][i].vlc.code << 1;                                  = coeff_tab[intra][i].vlc.code << 1;
109                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len
110                                  = coeff_tab[intra][i].vlc.len + 1;                                  = coeff_tab[intra][i].vlc.len + 1;
111  #ifndef BIGLUT  
112                          if (!intra)                          if (!intra) {
 #endif  
                         {  
113                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code
114                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
115                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len
116                                          = coeff_tab[intra][i].vlc.len + 1;                                          = coeff_tab[intra][i].vlc.len + 1;
117                          }                          }
118                  }                  }
119            }
120    
121            for (intra = 0; intra < 2; intra++) {
122                    for (last = 0; last < 2; last++) {
123                            for (run = 0; run < 63 + last; run++) {
124                                    for (level = 1; level < (uint32_t)(32 << intra); level++) {
125    
         for (intra = 0; intra < 2; intra++)  
                 for (last = 0; last < 2; last++)  
                         for (run = 0; run < 63 + last; run++)  
                         {  
                                 for (level = 1; level < (uint32_t)(32 << intra); level++)  
                                 {  
126                                          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])
127                                              continue;                                              continue;
128    
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
129                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
130                      level_esc = level - max_level[intra][last][run];                      level_esc = level - max_level[intra][last][run];
131                                          run_esc = run - 1 - max_run[intra][last][level];                                          run_esc = run - 1 - max_run[intra][last][level];
                                         /*use this test to use shorter esc2 codes when possible  
                                         if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]  
                                                 && !(coeff_VLC[intra][last][level_esc + offset][run].len + 7 + 1  
                                                          > coeff_VLC[intra][last][level + offset][run_esc].code + 7 + 2))*/  
132    
133                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc])                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]) {
                                         {  
134                                                  escape     = ESCAPE1;                                                  escape     = ESCAPE1;
135                                                  escape_len = 7 + 1;                                                  escape_len = 7 + 1;
136                                                  run_esc    = run;                                                  run_esc    = run;
137                                          }                                          } else {
138                                          else                                                  if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {
                                         {  
                                                 if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc])  
                                                 {  
139                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
140                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
141                                                          level_esc  = level;                                                          level_esc  = level;
142                                                  }                                                  } else {
143                                                  else                                                          if (!intra) {
                                                 {  
 #ifndef BIGLUT  
                                                         if (!intra)  
 #endif  
                                                         {  
144                                                                  coeff_VLC[intra][last][level + offset][run].code                                                                  coeff_VLC[intra][last][level + offset][run].code
145                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
146                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
# Line 226  Line 157 
157                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
158                                          coeff_VLC[intra][last][level + offset][run].len                                          coeff_VLC[intra][last][level + offset][run].len
159                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
160  #ifndef BIGLUT  
161                                          if (!intra)                                          if (!intra) {
 #endif  
                                         {  
162                                                  coeff_VLC[intra][last][offset - level][run].code                                                  coeff_VLC[intra][last][offset - level][run].code
163                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
164                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
# Line 238  Line 167 
167                                          }                                          }
168                                  }                                  }
169    
170  #ifdef BIGLUT                                  if (!intra) {
                                 for (level = 32 << intra; level < 2048; level++)  
                                 {  
                                         coeff_VLC[intra][last][level + offset][run].code  
                                                 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;  
                                         coeff_VLC[intra][last][level + offset][run].len = 30;  
   
                                         coeff_VLC[intra][last][offset - level][run].code  
                                                 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;  
                                         coeff_VLC[intra][last][offset - level][run].len = 30;  
                                 }  
 #else  
                                 if (!intra)  
                                 {  
171                                          coeff_VLC[intra][last][0][run].code                                          coeff_VLC[intra][last][0][run].code
172                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
173                                          coeff_VLC[intra][last][0][run].len = 30;                                          coeff_VLC[intra][last][0][run].len = 30;
174                                  }                                  }
 #endif  
175                          }                          }
176  /* init sprite_trajectory tables */                  }
177  /* even if GMC is not specified (it might be used later...) */          }
178    
179            /* init sprite_trajectory tables
180             * even if GMC is not specified (it might be used later...) */
181    
182          sprite_trajectory_code[0+16384].code = 0;          sprite_trajectory_code[0+16384].code = 0;
183          sprite_trajectory_code[0+16384].len = 0;          sprite_trajectory_code[0+16384].len = 0;
184          for (k=0;k<14;k++)          for (k=0;k<14;k++) {
         {  
185                  int limit = (1<<k);                  int limit = (1<<k);
186    
187                  for (l=-(2*limit-1); l <= -limit; l++)                  for (l=-(2*limit-1); l <= -limit; l++) {
                 {  
188                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
189                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
190                  }                  }
191    
192                  for (l=limit; l<= 2*limit-1; l++)                  for (l=limit; l<= 2*limit-1; l++) {
                 {  
193                          sprite_trajectory_code[l+16384].code = l;                          sprite_trajectory_code[l+16384].code = l;
194                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
195                  }                  }
# Line 284  Line 199 
199  static __inline void  static __inline void
200  CodeVector(Bitstream * bs,  CodeVector(Bitstream * bs,
201                     int32_t value,                     int32_t value,
202                     int32_t f_code,                     int32_t f_code)
                    Statistics * pStat)  
203  {  {
204    
205          const int scale_factor = 1 << (f_code - 1);          const int scale_factor = 1 << (f_code - 1);
# Line 297  Line 211 
211          if (value > (cmp - 1))          if (value > (cmp - 1))
212                  value -= 64 * scale_factor;                  value -= 64 * scale_factor;
213    
         pStat->iMvSum += value * value;  
         pStat->iMvCount++;  
   
214          if (value == 0) {          if (value == 0) {
215                  BitstreamPutBits(bs, mb_motion_table[32].code,                  BitstreamPutBits(bs, mb_motion_table[32].code,
216                                                   mb_motion_table[32].len);                                                   mb_motion_table[32].len);
# Line 336  Line 247 
247    
248  }  }
249    
 #ifdef BIGLUT  
   
 static __inline void  
 CodeCoeff(Bitstream * bs,  
                   const int16_t qcoeff[64],  
                   VLC * table,  
                   const uint16_t * zigzag,  
                   uint16_t intra)  
 {  
   
         uint32_t j, last;  
         short v;  
         VLC *vlc;  
   
         j = intra;  
         last = intra;  
   
         while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                 j++;  
   
         do {  
                 vlc = table + 64 * 2048 + (v << 6) + j - last;  
                 last = ++j;  
   
                 /* count zeroes */  
                 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                         j++;  
   
                 /* write code */  
                 if (j != 64) {  
                         BitstreamPutBits(bs, vlc->code, vlc->len);  
                 } else {  
                         vlc += 64 * 4096;  
                         BitstreamPutBits(bs, vlc->code, vlc->len);  
                         break;  
                 }  
         } while (1);  
   
 }  
   
   
   
 /* returns the number of bits required to encode qcoeff */  
 int  
 CodeCoeff_CalcBits(const int16_t qcoeff[64],  
                   VLC * table,  
                   const uint16_t * zigzag,  
                   uint16_t intra)  
 {  
         int bits = 0;  
         uint32_t j, last;  
         short v;  
         VLC *vlc;  
   
         j = intra;  
         last = intra;  
   
         while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                 j++;  
   
         if (j >= 64) return 0;  /* empty block */  
   
         do {  
                 vlc = table + 64 * 2048 + (v << 6) + j - last;  
                 last = ++j;  
   
                 /* count zeroes */  
                 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                         j++;  
   
                 /* write code */  
                 if (j != 64) {  
                         bits += vlc->len;  
                 } else {  
                         vlc += 64 * 4096;  
                         bits += vlc->len;  
                         break;  
                 }  
         } while (1);  
   
         return bits;  
 }  
   
   
 #else  
   
250  static __inline void  static __inline void
251  CodeCoeffInter(Bitstream * bs,  CodeCoeffInter(Bitstream * bs,
252                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 626  Line 451 
451          return bits;          return bits;
452  }  }
453    
454    static const int iDQtab[5] = {
 #endif  
   
   
 static int iDQtab[5] = {  
455          1, 0, -1 /* no change */, 2, 3          1, 0, -1 /* no change */, 2, 3
456  };  };
457  #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]  #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
# Line 648  Line 469 
469    
470          cbpy = pMB->cbp >> 2;          cbpy = pMB->cbp >> 2;
471    
472          // write mcbpc          /* write mcbpc */
473          if (frame->coding_type == I_VOP) {          if (frame->coding_type == I_VOP) {
474                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
475                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
# Line 659  Line 480 
480                                                   mcbpc_inter_tab[mcbpc].len);                                                   mcbpc_inter_tab[mcbpc].len);
481          }          }
482    
483          // ac prediction flag          /* ac prediction flag */
484          if (pMB->acpred_directions[0])          if (pMB->acpred_directions[0])
485                  BitstreamPutBits(bs, 1, 1);                  BitstreamPutBits(bs, 1, 1);
486          else          else
487                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
488    
489          // write cbpy          /* write cbpy */
490          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
491    
492          // write dquant          /* write dquant */
493          if (pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA_Q)
494                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
495    
496          // write interlacing          /* write interlacing */
497          if (frame->vol_flags & XVID_VOL_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
498                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
499          }          }
500          // code block coeffs          /* code block coeffs */
501          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
502                  if (i < 4)                  if (i < 4)
503                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
# Line 692  Line 513 
513    
514                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
515    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);  
 #else  
516                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
 #endif  
517    
518                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
519                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 720  Line 537 
537          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
538          cbpy = 15 - (pMB->cbp >> 2);          cbpy = 15 - (pMB->cbp >> 2);
539    
540          // write mcbpc          /* write mcbpc */
541          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
542                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
543    
544          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) )
545                  BitstreamPutBit(bs, pMB->mcsel);                // mcsel: '0'=local motion, '1'=GMC                  BitstreamPutBit(bs, pMB->mcsel);                /* mcsel: '0'=local motion, '1'=GMC */
546    
547          // write cbpy          /* write cbpy */
548          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
549    
550          // write dquant          /* write dquant */
551          if (pMB->mode == MODE_INTER_Q)          if (pMB->mode == MODE_INTER_Q)
552                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);
553    
554          // interlacing          /* interlacing */
555          if (frame->vol_flags & XVID_VOL_INTERLACING) {          if (frame->vol_flags & XVID_VOL_INTERLACING) {
556                  if (pMB->cbp) {                  if (pMB->cbp) {
557                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
558                          DPRINTF(DPRINTF_MB,"codep: field_dct: %i", pMB->field_dct);                          DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);
559                  }                  }
560    
561                  // if inter block, write field ME flag                  /* if inter block, write field ME flag */
562                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
563                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
564                          DPRINTF(DPRINTF_MB,"codep: field_pred: %i", pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
565    
566                          // write field prediction references                          /* write field prediction references */
567    #if 0 /* Remove the #if once field_pred is supported */
568                          if (pMB->field_pred) {                          if (pMB->field_pred) {
569                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
570                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
571                          }                          }
572    #endif
573                  }                  }
574          }          }
575          // code motion vector(s) if motion is local          /* code motion vector(s) if motion is local  */
576          if (!pMB->mcsel)          if (!pMB->mcsel)
577                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
578                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode);
579                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode);
580                  }                  }
581    
582          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
583    
584          // code block coeffs          /* code block coeffs */
585          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
586                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
                 {  
587                          const uint16_t *scan_table =                          const uint16_t *scan_table =
588                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
589                                  scan_tables[2] : scan_tables[0];                                  scan_tables[2] : scan_tables[0];
590    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);  
 #else  
591                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
 #endif  
592                  }                  }
593    
594          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
# Line 790  Line 604 
604                   Statistics * pStat)                   Statistics * pStat)
605  {  {
606          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)
607                          BitstreamPutBit(bs, 0); // not_coded                          BitstreamPutBit(bs, 0); /* not_coded */
608    
609            if (frame->vop_flags & XVID_VOP_GREYSCALE) {
610                    pMB->cbp &= 0x3C;               /* keep only bits 5-2 */
611                    qcoeff[4*64+0]=0;               /* for INTRA DC value is saved */
612                    qcoeff[5*64+0]=0;
613            }
614    
615          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
616                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
# Line 799  Line 619 
619    
620  }  }
621    
 /*  
 // moved to mbcoding.h so that in can be 'static __inline'  
 void  
 MBSkip(Bitstream * bs)  
 {  
         BitstreamPutBit(bs, 1); // not coded  
 }  
 */  
   
622  /***************************************************************  /***************************************************************
623   * bframe encoding start   * bframe encoding start
624   ***************************************************************/   ***************************************************************/
# Line 864  Line 675 
675                  BitstreamPutBit(bs, 1);                  BitstreamPutBit(bs, 1);
676                  return;                  return;
677    
678          default:;                                       // invalid          default:;                                       /* invalid */
679          }          }
680  }  }
681    
682    
683    
684  void  void
685  MBCodingBVOP(const MACROBLOCK * mb,  MBCodingBVOP(const FRAMEINFO * const frame,
686                             const MACROBLOCK * mb,
687                           const int16_t qcoeff[6 * 64],                           const int16_t qcoeff[6 * 64],
688                           const int32_t fcode,                           const int32_t fcode,
689                           const int32_t bcode,                           const int32_t bcode,
690                           Bitstream * bs,                           Bitstream * bs,
691                           Statistics * pStat,                           Statistics * pStat)
                          int direction)  
692  {  {
693          int vcode = fcode;          int vcode = fcode;
694          unsigned int i;          unsigned int i;
695    
696            const uint16_t *scan_table =
697                    frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
698                    scan_tables[2] : scan_tables[0];
699            int bits;
700    
701  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
702                  when a block is skipped it is decoded DIRECT(0,0)                  when a block is skipped it is decoded DIRECT(0,0)
703                  hence is interpolated from forward & backward frames                  hence is interpolated from forward & backward frames
704          ------------------------------------------------------------------ */          ------------------------------------------------------------------ */
705    
706          if (mb->mode == MODE_DIRECT_NONE_MV) {          if (mb->mode == MODE_DIRECT_NONE_MV) {
707                  BitstreamPutBit(bs, 1); // skipped                  BitstreamPutBit(bs, 1); /* skipped */
708                  return;                  return;
709          }          }
710    
711          BitstreamPutBit(bs, 0);         // not skipped          BitstreamPutBit(bs, 0);         /* not skipped */
712    
713          if (mb->cbp == 0) {          if (mb->cbp == 0) {
714                  BitstreamPutBit(bs, 1); // cbp == 0                  BitstreamPutBit(bs, 1); /* cbp == 0 */
715          } else {          } else {
716                  BitstreamPutBit(bs, 0); // cbp == xxx                  BitstreamPutBit(bs, 0); /* cbp == xxx */
717          }          }
718    
719          put_bvop_mbtype(bs, mb->mode);          put_bvop_mbtype(bs, mb->mode);
# Line 907  Line 723 
723          }          }
724    
725          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
726                  put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0                  put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */
727            }
728    
729            if (frame->vol_flags & XVID_VOL_INTERLACING) {
730                    if (mb->cbp) {
731                            BitstreamPutBit(bs, mb->field_dct);
732                            DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);
733                    }
734    
735                    /* if not direct block, write field ME flag */
736                    if (mb->mode != MODE_DIRECT) {
737                            BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
738    
739                            /* write field prediction references */
740    #if 0 /* Remove the #if once field_pred is supported */
741                            if (mb->field_pred) {
742                                    BitstreamPutBit(bs, mb->field_for_top);
743                                    BitstreamPutBit(bs, mb->field_for_bot);
744                            }
745    #endif
746                    }
747          }          }
748    
749    
750          switch (mb->mode) {          switch (mb->mode) {
751                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
752                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); //forward vector of interpolate mode                          CodeVector(bs, mb->pmvs[1].x, vcode); /* forward vector of interpolate mode */
753                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode);
754                  case MODE_BACKWARD:                  case MODE_BACKWARD:
755                          vcode = bcode;                          vcode = bcode;
756                  case MODE_FORWARD:                  case MODE_FORWARD:
757                          CodeVector(bs, mb->pmvs[0].x, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].x, vcode);
758                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode);
759                          break;                          break;
760                  case MODE_DIRECT:                  case MODE_DIRECT:
761                          CodeVector(bs, mb->pmvs[3].x, 1, pStat);        // fcode is always 1 for delta vector                          CodeVector(bs, mb->pmvs[3].x, 1);       /* fcode is always 1 for delta vector */
762                          CodeVector(bs, mb->pmvs[3].y, 1, pStat);        // prediction is always (0,0)                          CodeVector(bs, mb->pmvs[3].y, 1);       /* prediction is always (0,0) */
763                  default: break;                  default: break;
764          }          }
765    
766            bits = BitstreamPos(bs);
767          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
768                  if (mb->cbp & (1 << (5 - i))) {                  if (mb->cbp & (1 << (5 - i))) {
769  #ifdef BIGLUT                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);  
 #else  
                         CodeCoeffInter(bs, &qcoeff[i * 64], scan_tables[0]);  
 #endif  
770                  }                  }
771          }          }
772            pStat->iTextBits += BitstreamPos(bs) - bits;
773  }  }
774    
775    
# Line 944  Line 779 
779   ***************************************************************/   ***************************************************************/
780    
781    
782  // for IVOP addbits == 0  /*
783  // for PVOP addbits == fcode - 1   * for IVOP addbits == 0
784  // for BVOP addbits == max(fcode,bcode) - 1   * for PVOP addbits == fcode - 1
785  // returns true or false   * for BVOP addbits == max(fcode,bcode) - 1
786     * returns true or false
787     */
788  int  int
789  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
790  {  {
# Line 1124  Line 961 
961    
962  }  }
963    
964    #define GET_BITS(cache, n) ((cache)>>(32-(n)))
965    
966  static __inline int  static __inline int
967  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
968                    int *run,                    int *run,
# Line 1136  Line 975 
975          int32_t level;          int32_t level;
976          REVERSE_EVENT *reverse_event;          REVERSE_EVENT *reverse_event;
977    
978            uint32_t cache = BitstreamShowBits(bs, 32);
979    
980          if (short_video_header)         /* inter-VLCs will be used for both intra and inter blocks */          if (short_video_header)         /* inter-VLCs will be used for both intra and inter blocks */
981                  intra = 0;                  intra = 0;
982    
983          if (BitstreamShowBits(bs, 7) != ESCAPE) {          if (GET_BITS(cache, 7) != ESCAPE) {
984                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
985    
986                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
987                          goto error;                          goto error;
# Line 1148  Line 989 
989                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
990                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
991    
992                  BitstreamSkip(bs, reverse_event->len);                  /* Don't forget to update the bitstream position */
993                    BitstreamSkip(bs, reverse_event->len+1);
994    
995                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
996          }          }
997    
998          BitstreamSkip(bs, 7);          /* flush 7bits of cache */
999            cache <<= 7;
1000    
1001          if (short_video_header) {          if (short_video_header) {
1002                  /* escape mode 4 - H.263 type, only used if short_video_header = 1  */                  /* escape mode 4 - H.263 type, only used if short_video_header = 1  */
1003                  *last = BitstreamGetBit(bs);                  *last =  GET_BITS(cache, 1);
1004                  *run = BitstreamGetBits(bs, 6);                  *run  = (GET_BITS(cache, 7) &0x3f);
1005                  level = BitstreamGetBits(bs, 8);                  level = (GET_BITS(cache, 15)&0xff);
1006    
1007                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1008                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1009    
1010                    /* We've "eaten" 22 bits */
1011                    BitstreamSkip(bs, 22);
1012    
1013                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1014          }          }
1015    
1016          mode = BitstreamShowBits(bs, 2);          if ((mode = GET_BITS(cache, 2)) < 3) {
1017                    const int skip[3] = {1, 1, 2};
1018          if (mode < 3) {                  cache <<= skip[mode];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
1019    
1020                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1021    
1022                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1023                          goto error;                          goto error;
# Line 1180  Line 1025 
1025                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1026                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1027    
1028                  BitstreamSkip(bs, reverse_event->len);                  if (mode < 2) {
1029                            /* first escape mode, level is offset */
                 if (mode < 2)                   /* first escape mode, level is offset */  
1030                          level += max_level[intra][*last][*run];                          level += max_level[intra][*last][*run];
1031                  else                                    /* second escape mode, run is offset */                  } else {
1032                            /* second escape mode, run is offset */
1033                          *run += max_run[intra][*last][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1034                    }
1035    
1036                    /* Update bitstream position */
1037                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1038    
1039                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1040          }          }
1041    
1042          /* third escape mode - fixed length codes */          /* third escape mode - fixed length codes */
1043          BitstreamSkip(bs, 2);          cache <<= 2;
1044          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1045          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1046          BitstreamSkip(bs, 1);           /* marker */          level = (GET_BITS(cache, 20)&0xfff);
1047          level = BitstreamGetBits(bs, 12);  
1048          BitstreamSkip(bs, 1);           /* marker */          /* Update bitstream position */
1049            BitstreamSkip(bs, 30);
1050    
1051          return (level << 20) >> 20;          return (level << 20) >> 20;
1052    
# Line 1218  Line 1068 
1068          do {          do {
1069                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1070                  if (run == -1) {                  if (run == -1) {
1071                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1072                          break;                          break;
1073                  }                  }
1074                  coeff += run;                  coeff += run;
1075                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1076    
1077                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
1078                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));  #if 0
1079                    DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));
1080    #endif
1081    
1082                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1083                          DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);                          DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);
1084                  }                  }
1085                  coeff++;                  coeff++;
1086          } while (!last);          } while (!last);
# Line 1236  Line 1088 
1088  }  }
1089    
1090  void  void
1091  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1092                    Bitstream * bs,
1093                                  int16_t * block,                                  int16_t * block,
1094                                  int direction)                  int direction,
1095                    const int quant,
1096                    const uint16_t *matrix)
1097  {  {
1098    
1099          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1100            const uint16_t quant_m_2 = quant << 1;
1101            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1102          int p;          int p;
1103          int level;          int level;
1104          int run;          int run;
# Line 1251  Line 1108 
1108          do {          do {
1109                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1110                  if (run == -1) {                  if (run == -1) {
1111                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1112                          break;                          break;
1113                  }                  }
1114                  p += run;                  p += run;
1115    
1116                  block[scan[p]] = level;                  if (level < 0) {
1117                            level = level*quant_m_2 - quant_add;
1118                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);                          block[scan[p]] = (level >= -2048 ? level : -2048);
1119                  // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));                  } else {
1120                            level = level * quant_m_2 + quant_add;
1121                  if (level < -2047 || level > 2047) {                          block[scan[p]] = (level <= 2047 ? level : 2047);
                         DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);  
1122                  }                  }
1123                  p++;                  p++;
1124          } while (!last);          } while (!last);
   
 }  
   
   
   
   
   
   
   
 /************************************************************************  
  *               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;  
1125  }  }
1126    
1127  int __inline  void
1128  RunLevelLast_CalcBits_intra(const int16_t run, int16_t level)  get_inter_block_mpeg(
1129                    Bitstream * bs,
1130                    int16_t * block,
1131                    int direction,
1132                    const int quant,
1133                    const uint16_t *matrix)
1134  {  {
1135          const int esc_length = 30;          const uint16_t *scan = scan_tables[direction];
1136          int bits;          uint32_t sum = 0;
1137            int p;
1138            int level;
1139            int run;
1140            int last;
1141    
1142          level = abs(level);          p = 0;
1143          if (!(level & -64)) {          do {
1144                  bits = coeff_VLC[1][1][level][run].len;                  level = get_coeff(bs, &run, &last, 0, 0);
1145                  if (bits!=128)                  if (run == -1) {
1146                          return bits;                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1147          }                          break;
         return esc_length;  
1148  }  }
1149                    p += run;
1150    
1151  /* based on ffmpeg's trellis quant, thanks! */                  if (level < 0) {
1152  /* (C) 2003 Michael Niedermayer <michaelni@gmx.at> */                          level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1153                            block[scan[p]] = (level <= 2048 ? -level : -2048);
 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;  
1154                                  } else {                                  } else {
1155                                          coeff[i] = level;                          level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1156                                          coeff_count[i] = 1;                          block[scan[p]] = (level <= 2047 ? level : 2047);
                                 }  
                         } 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;  
             }  
1157          }          }
1158    
1159          for (run = 0; run <= i - left_limit; run++) {                  sum ^= block[scan[p]];
           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;  
                 }  
     }  
1160    
1161  /****************** level loop unrolled: if possible, check coeff[i]-1 *********/                  p++;
1162            } while (!last);
     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_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;  
1163    
1164    for (; i > 0; i -= run_tab[i] + 1)          /*      mismatch control */
1165      {          if ((sum & 1) == 0) {
1166        qcoeff[zigzag[i-1]] = level_tab[i];                  block[63] ^= 1;
1167      }      }
   
   return last_non_zero;  
1168  }  }
1169    
 int  
 dct_quantize_trellis_inter_mpeg_c (int16_t *qcoeff, const int16_t *data, int quant)  
 { return 64; }  
   
   
   
   
1170    
1171  /*****************************************************************************  /*****************************************************************************
1172   * VLC tables and other constant arrays   * VLC tables and other constant arrays
# Line 1881  Line 1498 
1498  VLC sprite_trajectory_len[15] = {  VLC sprite_trajectory_len[15] = {
1499          { 0x00 , 2},          { 0x00 , 2},
1500          { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},          { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1501          { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7F, 7}, { 0xFE, 8},          { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},
1502          { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };          { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1503    
1504    
Legend:
Removed from v.1.44.2.7  
changed lines
  Added in v.1.50
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4