[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.18, Sun Dec 14 03:32:01 2003 UTC revision 1.45, Mon Feb 24 11:15:33 2003 UTC
# Line 1  Line 1 
1  /*****************************************************************************   /******************************************************************************
2   *    *                                                                            *
3   *  XVID MPEG-4 VIDEO CODEC    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *
4   *  - MB coding -    *                                                                            *
5   *    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *
6   *  Copyright (C) 2002 Michael Militzer <isibaar@xvid.org>    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
7   *    *  software module in hardware or software products are advised that its     *
8   *  This program is free software ; you can redistribute it and/or modify    *  use may infringe existing patents or copyrights, and any such use         *
9   *  it under the terms of the GNU General Public License as published by    *  would be at such party's own risk.  The original developer of this        *
10   *  the Free Software Foundation ; either version 2 of the License, or    *  software module and his/her company, and subsequent editors and their     *
11   *  (at your option) any later version.    *  companies, will have no liability for use of this software or             *
12   *    *  modifications or derivatives thereof.                                     *
13   *  This program is distributed in the hope that it will be useful,    *                                                                            *
14   *  but WITHOUT ANY WARRANTY ; without even the implied warranty of    *  XviD is free software; you can redistribute it and/or modify it           *
15   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *  under the terms of the GNU General Public License as published by         *
16   *  GNU General Public License for more details.    *  the Free Software Foundation; either version 2 of the License, or         *
17   *    *  (at your option) any later version.                                       *
18   *  You should have received a copy of the GNU General Public License    *                                                                            *
19   *  along with this program ; if not, write to the Free Software    *  XviD is distributed in the hope that it will be useful, but               *
20   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *
21   *    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
22   * $Id$    *  GNU General Public License for more details.                              *
23   *    *                                                                            *
24   ****************************************************************************/    *  You should have received a copy of the GNU General Public License         *
25      *  along with this program; if not, write to the Free Software               *
26      *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *
27      *                                                                            *
28      ******************************************************************************/
29    
30     /******************************************************************************
31      *                                                                            *
32      *  mbcoding.c                                                                *
33      *                                                                            *
34      *  Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org>                  *
35      *                                                                            *
36      *  For more information visit the XviD homepage: http://www.xvid.org         *
37      *                                                                            *
38      ******************************************************************************/
39    
40     /******************************************************************************
41      *                                                                                                                                                        *
42      *  Revision history:                                                         *
43      *                                                                            *
44      *  28.10.2002 GMC support - gruel                                                                                        *
45      *  28.06.2002 added check_resync_marker()                                    *
46      *  14.04.2002 bframe encoding                                                                                            *
47      *  08.03.2002 initial version; isibaar                                                           *
48      *                                                                                                                                                        *
49      ******************************************************************************/
50    
51    
52  #include <stdio.h>  #include <stdio.h>
53  #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  
   
54  #include "../portab.h"  #include "../portab.h"
55  #include "../global.h"  #include "../global.h"
56  #include "bitstream.h"  #include "bitstream.h"
# Line 36  Line 60 
60    
61  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
62    
63    /* #define BIGLUT */
64    
65    #ifdef BIGLUT
66    #define LEVELOFFSET 2048
67    #else
68  #define LEVELOFFSET 32  #define LEVELOFFSET 32
69    #endif
70    
71  static REVERSE_EVENT DCT3D[2][4096];  static REVERSE_EVENT DCT3D[2][4096];
72    
73    #ifdef BIGLUT
74    static VLC coeff_VLC[2][2][4096][64];
75    VLC *intra_table;
76    static VLC *inter_table;
77    #else
78  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
79    #endif
80    
81  /* not really MB related, but VLCs are only available here */  /* not really MB related, but VLCs are only available here */
82  void bs_put_spritetrajectory(Bitstream * bs, const int val)  void bs_put_spritetrajectory(Bitstream * bs, const int val)
# Line 49  Line 86 
86          const int code2 = sprite_trajectory_len[len].code;          const int code2 = sprite_trajectory_len[len].code;
87          const int len2 = sprite_trajectory_len[len].len;          const int len2 = sprite_trajectory_len[len].len;
88    
89  #if 0  //      printf("GMC=%d Code/Len  = %d / %d ",val, code,len);
90          printf("GMC=%d Code/Len  = %d / %d ",val, code,len);  //      printf("Code2 / Len2 = %d / %d \n",code2,len2);
         printf("Code2 / Len2 = %d / %d \n",code2,len2);  
 #endif  
91    
92          BitstreamPutBits(bs, code2, len2);          BitstreamPutBits(bs, code2, len2);
93          if (len) BitstreamPutBits(bs, code, len);          if (len) BitstreamPutBits(bs, code, len);
# Line 78  Line 113 
113          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;
114          int32_t l;          int32_t l;
115    
116    #ifdef BIGLUT
117            intra_table = coeff_VLC[1];
118            inter_table = coeff_VLC[0];
119    #endif
120    
121    
122          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++)
123                  for (i = 0; i < 4096; i++)                  for (i = 0; i < 4096; i++)
124                          DCT3D[intra][i].event.level = 0;                          DCT3D[intra][i].event.level = 0;
125    
126          for (intra = 0; intra < 2; intra++) {          for (intra = 0; intra < 2; intra++)
127                  for (last = 0; last < 2; last++) {                  for (last = 0; last < 2; last++)
128                          for (run = 0; run < 63 + last; run++) {                  {
129                                  for (level = 0; level < (uint32_t)(32 << intra); level++) {                          for (run = 0; run < 63 + last; run++)
130                                    for (level = 0; level < (uint32_t)(32 << intra); level++)
131                                    {
132    #ifdef BIGLUT
133                                            offset = LEVELOFFSET;
134    #else
135                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
136    #endif
137                                          coeff_VLC[intra][last][level + offset][run].len = 128;                                          coeff_VLC[intra][last][level + offset][run].len = 128;
138                                  }                                  }
139                          }                          }
                 }  
         }  
140    
141          for (intra = 0; intra < 2; intra++) {          for (intra = 0; intra < 2; intra++)
142                  for (i = 0; i < 102; i++) {                  for (i = 0; i < 102; i++)
143                    {
144    #ifdef BIGLUT
145                            offset = LEVELOFFSET;
146    #else
147                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
148    #endif
149                          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++)
150                            {
151                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;
152                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
153                          }                          }
# Line 106  Line 156 
156                                  = coeff_tab[intra][i].vlc.code << 1;                                  = coeff_tab[intra][i].vlc.code << 1;
157                          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
158                                  = coeff_tab[intra][i].vlc.len + 1;                                  = coeff_tab[intra][i].vlc.len + 1;
159    #ifndef BIGLUT
160                          if (!intra) {                          if (!intra)
161    #endif
162                            {
163                                  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
164                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
165                                  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
166                                          = coeff_tab[intra][i].vlc.len + 1;                                          = coeff_tab[intra][i].vlc.len + 1;
167                          }                          }
168                  }                  }
         }  
   
         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++) {  
169    
170            for (intra = 0; intra < 2; intra++)
171                    for (last = 0; last < 2; last++)
172                            for (run = 0; run < 63 + last; run++)
173                            {
174                                    for (level = 1; level < (uint32_t)(32 << intra); level++)
175                                    {
176                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
177                                              continue;                                              continue;
178    
179    #ifdef BIGLUT
180                                            offset = LEVELOFFSET;
181    #else
182                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
183    #endif
184                      level_esc = level - max_level[intra][last][run];                      level_esc = level - max_level[intra][last][run];
185                                          run_esc = run - 1 - max_run[intra][last][level];                                          run_esc = run - 1 - max_run[intra][last][level];
186                                            /*use this test to use shorter esc2 codes when possible
187                                            if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]
188                                                    && !(coeff_VLC[intra][last][level_esc + offset][run].len + 7 + 1
189                                                             > coeff_VLC[intra][last][level + offset][run_esc].code + 7 + 2))*/
190    
191                                          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])
192                                            {
193                                                  escape     = ESCAPE1;                                                  escape     = ESCAPE1;
194                                                  escape_len = 7 + 1;                                                  escape_len = 7 + 1;
195                                                  run_esc    = run;                                                  run_esc    = run;
196                                          } else {                                          }
197                                                  if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {                                          else
198                                            {
199                                                    if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc])
200                                                    {
201                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
202                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
203                                                          level_esc  = level;                                                          level_esc  = level;
204                                                  } else {                                                  }
205                                                          if (!intra) {                                                  else
206                                                    {
207    #ifndef BIGLUT
208                                                            if (!intra)
209    #endif
210                                                            {
211                                                                  coeff_VLC[intra][last][level + offset][run].code                                                                  coeff_VLC[intra][last][level + offset][run].code
212                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
213                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
# Line 155  Line 224 
224                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
225                                          coeff_VLC[intra][last][level + offset][run].len                                          coeff_VLC[intra][last][level + offset][run].len
226                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
227    #ifndef BIGLUT
228                                          if (!intra) {                                          if (!intra)
229    #endif
230                                            {
231                                                  coeff_VLC[intra][last][offset - level][run].code                                                  coeff_VLC[intra][last][offset - level][run].code
232                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
233                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
# Line 165  Line 236 
236                                          }                                          }
237                                  }                                  }
238    
239                                  if (!intra) {  #ifdef BIGLUT
240                                    for (level = 32 << intra; level < 2048; level++)
241                                    {
242                                            coeff_VLC[intra][last][level + offset][run].code
243                                                    = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
244                                            coeff_VLC[intra][last][level + offset][run].len = 30;
245    
246                                            coeff_VLC[intra][last][offset - level][run].code
247                                                    = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;
248                                            coeff_VLC[intra][last][offset - level][run].len = 30;
249                                    }
250    #else
251                                    if (!intra)
252                                    {
253                                          coeff_VLC[intra][last][0][run].code                                          coeff_VLC[intra][last][0][run].code
254                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
255                                          coeff_VLC[intra][last][0][run].len = 30;                                          coeff_VLC[intra][last][0][run].len = 30;
256                                  }                                  }
257    #endif
258                          }                          }
259                  }  /* init sprite_trajectory tables */
260          }  /* even if GMC is not specified (it might be used later...) */
   
         /* init sprite_trajectory tables  
          * even if GMC is not specified (it might be used later...) */  
261    
262          sprite_trajectory_code[0+16384].code = 0;          sprite_trajectory_code[0+16384].code = 0;
263          sprite_trajectory_code[0+16384].len = 0;          sprite_trajectory_code[0+16384].len = 0;
264          for (k=0;k<14;k++) {          for (k=0;k<14;k++)
265            {
266                  int limit = (1<<k);                  int limit = (1<<k);
267    
268                  for (l=-(2*limit-1); l <= -limit; l++) {                  for (l=-(2*limit-1); l <= -limit; l++)
269                    {
270                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
271                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
272                  }                  }
273    
274                  for (l=limit; l<= 2*limit-1; l++) {                  for (l=limit; l<= 2*limit-1; l++)
275                    {
276                          sprite_trajectory_code[l+16384].code = l;                          sprite_trajectory_code[l+16384].code = l;
277                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
278                  }                  }
# Line 249  Line 334 
334    
335  }  }
336    
337    #ifdef BIGLUT
338    
339    static __inline void
340    CodeCoeff(Bitstream * bs,
341                      const int16_t qcoeff[64],
342                      VLC * table,
343                      const uint16_t * zigzag,
344                      uint16_t intra)
345    {
346    
347            uint32_t j, last;
348            short v;
349            VLC *vlc;
350    
351            j = intra;
352            last = intra;
353    
354            while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
355                    j++;
356    
357            do {
358                    vlc = table + 64 * 2048 + (v << 6) + j - last;
359                    last = ++j;
360    
361                    /* count zeroes */
362                    while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
363                            j++;
364    
365                    /* write code */
366                    if (j != 64) {
367                            BitstreamPutBits(bs, vlc->code, vlc->len);
368                    } else {
369                            vlc += 64 * 4096;
370                            BitstreamPutBits(bs, vlc->code, vlc->len);
371                            break;
372                    }
373            } while (1);
374    
375    }
376    
377    
378    
379    /* returns the number of bits required to encode qcoeff */
380    int
381    CodeCoeff_CalcBits(const int16_t qcoeff[64],
382                      VLC * table,
383                      const uint16_t * zigzag,
384                      uint16_t intra)
385    {
386            int bits = 0;
387            uint32_t j, last;
388            short v;
389            VLC *vlc;
390    
391            j = intra;
392            last = intra;
393    
394            while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
395                    j++;
396    
397            if (j >= 64) return 0;  /* empty block */
398    
399            do {
400                    vlc = table + 64 * 2048 + (v << 6) + j - last;
401                    last = ++j;
402    
403                    /* count zeroes */
404                    while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)
405                            j++;
406    
407                    /* write code */
408                    if (j != 64) {
409                            bits += vlc->len;
410                    } else {
411                            vlc += 64 * 4096;
412                            bits += vlc->len;
413                            break;
414                    }
415            } while (1);
416    
417            return bits;
418    }
419    
420    
421    #else
422    
423  static __inline void  static __inline void
424  CodeCoeffInter(Bitstream * bs,  CodeCoeffInter(Bitstream * bs,
425                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 327  Line 498 
498          {          {
499                  if ((level = qcoeff[zigzag[i++]]) != 0)                  if ((level = qcoeff[zigzag[i++]]) != 0)
500                  {                  {
501                          abs_level = abs(prev_level);                          abs_level = ABS(prev_level);
502                          abs_level = abs_level < 64 ? abs_level : 0;                          abs_level = abs_level < 64 ? abs_level : 0;
503                          code      = coeff_VLC[1][0][abs_level][prev_run].code;                          code      = coeff_VLC[1][0][abs_level][prev_run].code;
504                          len               = coeff_VLC[1][0][abs_level][prev_run].len;                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
# Line 347  Line 518 
518                          run++;                          run++;
519          }          }
520    
521          abs_level = abs(prev_level);          abs_level = ABS(prev_level);
522          abs_level = abs_level < 64 ? abs_level : 0;          abs_level = abs_level < 64 ? abs_level : 0;
523          code      = coeff_VLC[1][1][abs_level][prev_run].code;          code      = coeff_VLC[1][1][abs_level][prev_run].code;
524          len               = coeff_VLC[1][1][abs_level][prev_run].len;          len               = coeff_VLC[1][1][abs_level][prev_run].len;
# Line 388  Line 559 
559          {          {
560                  if ((level = qcoeff[zigzag[i++]]) != 0)                  if ((level = qcoeff[zigzag[i++]]) != 0)
561                  {                  {
562                          abs_level = abs(prev_level);                          abs_level = ABS(prev_level);
563                          abs_level = abs_level < 64 ? abs_level : 0;                          abs_level = abs_level < 64 ? abs_level : 0;
564                          len               = coeff_VLC[1][0][abs_level][prev_run].len;                          len               = coeff_VLC[1][0][abs_level][prev_run].len;
565                          bits      += len!=128 ? len : 30;                          bits      += len!=128 ? len : 30;
# Line 401  Line 572 
572                          run++;                          run++;
573          }          }
574    
575          abs_level = abs(prev_level);          abs_level = ABS(prev_level);
576          abs_level = abs_level < 64 ? abs_level : 0;          abs_level = abs_level < 64 ? abs_level : 0;
577          len               = coeff_VLC[1][1][abs_level][prev_run].len;          len               = coeff_VLC[1][1][abs_level][prev_run].len;
578          bits      += len!=128 ? len : 30;          bits      += len!=128 ? len : 30;
# Line 453  Line 624 
624          return bits;          return bits;
625  }  }
626    
 static int iDQtab[5] = {  
         1, 0, -1 /* no change */, 2, 3  
 };  
 #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]  
627    
628    #endif
629    
630  static __inline void  static __inline void
631  CodeBlockIntra(const FRAMEINFO * const frame,  CodeBlockIntra(const FRAMEINFO * const frame,
# Line 471  Line 639 
639    
640          cbpy = pMB->cbp >> 2;          cbpy = pMB->cbp >> 2;
641    
642          /* write mcbpc */          // write mcbpc
643          if (frame->coding_type == I_VOP) {          if (frame->coding_type == I_VOP) {
644                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);                  mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
645                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,                  BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code,
# Line 482  Line 650 
650                                                   mcbpc_inter_tab[mcbpc].len);                                                   mcbpc_inter_tab[mcbpc].len);
651          }          }
652    
653          /* ac prediction flag */          // ac prediction flag
654          if (pMB->acpred_directions[0])          if (pMB->acpred_directions[0])
655                  BitstreamPutBits(bs, 1, 1);                  BitstreamPutBits(bs, 1, 1);
656          else          else
657                  BitstreamPutBits(bs, 0, 1);                  BitstreamPutBits(bs, 0, 1);
658    
659          /* write cbpy */          // write cbpy
660          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
661    
662          /* write dquant */          // write dquant
663          if (pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA_Q)
664                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);                  BitstreamPutBits(bs, pMB->dquant, 2);
665    
666          /* write interlacing */          // write interlacing
667          if (frame->vol_flags & XVID_VOL_INTERLACING) {          if (frame->global_flags & XVID_INTERLACING) {
668                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
669          }          }
670          /* code block coeffs */          // code block coeffs
671          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
672                  if (i < 4)                  if (i < 4)
673                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,                          BitstreamPutBits(bs, dcy_tab[qcoeff[i * 64 + 0] + 255].code,
# Line 510  Line 678 
678    
679                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i))) {
680                          const uint16_t *scan_table =                          const uint16_t *scan_table =
681                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                                  frame->global_flags & XVID_ALTERNATESCAN ?
682                                  scan_tables[2] : scan_tables[pMB->acpred_directions[i]];                                  scan_tables[2] : scan_tables[pMB->acpred_directions[i]];
683    
684                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
685    
686    #ifdef BIGLUT
687                            CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);
688    #else
689                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
690    #endif
691    
692                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
693                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 539  Line 711 
711          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);          mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
712          cbpy = 15 - (pMB->cbp >> 2);          cbpy = 15 - (pMB->cbp >> 2);
713    
714          /* write mcbpc */          // write mcbpc
715          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,          BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code,
716                                           mcbpc_inter_tab[mcbpc].len);                                           mcbpc_inter_tab[mcbpc].len);
717    
718          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) )
719                  BitstreamPutBit(bs, pMB->mcsel);                /* mcsel: '0'=local motion, '1'=GMC */                  BitstreamPutBit(bs, pMB->mcsel);                // mcsel: '0'=local motion, '1'=GMC
720    
721          /* write cbpy */          // write cbpy
722          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);          BitstreamPutBits(bs, xvid_cbpy_tab[cbpy].code, xvid_cbpy_tab[cbpy].len);
723    
724          /* write dquant */          // write dquant
725          if (pMB->mode == MODE_INTER_Q)          if (pMB->mode == MODE_INTER_Q)
726                  BitstreamPutBits(bs, DQ_VALUE2INDEX(pMB->dquant), 2);                  BitstreamPutBits(bs, pMB->dquant, 2);
727    
728          /* interlacing */          // interlacing
729          if (frame->vol_flags & XVID_VOL_INTERLACING) {          if (frame->global_flags & XVID_INTERLACING) {
730                  if (pMB->cbp) {                  if (pMB->cbp) {
731                          BitstreamPutBit(bs, pMB->field_dct);                          BitstreamPutBit(bs, pMB->field_dct);
732                          DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", pMB->field_dct);                          DPRINTF(DPRINTF_MB,"codep: field_dct: %i", pMB->field_dct);
733                  }                  }
734    
735                  /* if inter block, write field ME flag */                  // if inter block, write field ME flag
736                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
737                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */                          BitstreamPutBit(bs, pMB->field_pred);
738                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);                          DPRINTF(DPRINTF_MB,"codep: field_pred: %i", pMB->field_pred);
739    
740                          /* write field prediction references */                          // write field prediction references
 #if 0 /* Remove the #if once field_pred is supported */  
741                          if (pMB->field_pred) {                          if (pMB->field_pred) {
742                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
743                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
744                          }                          }
 #endif  
745                  }                  }
746          }          }
747          /* code motion vector(s) if motion is local  */          // code motion vector(s) if motion is local
748          if (!pMB->mcsel)          if (!pMB->mcsel)
749                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
750                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);
# Line 583  Line 753 
753    
754          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
755    
756          /* code block coeffs */          // code block coeffs
757          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
758                  if (pMB->cbp & (1 << (5 - i))) {                  if (pMB->cbp & (1 << (5 - i)))
759                    {
760                          const uint16_t *scan_table =                          const uint16_t *scan_table =
761                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                                  frame->global_flags & XVID_ALTERNATESCAN ?
762                                  scan_tables[2] : scan_tables[0];                                  scan_tables[2] : scan_tables[0];
763    
764    #ifdef BIGLUT
765                            CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);
766    #else
767                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
768    #endif
769                  }                  }
770    
771          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
# Line 606  Line 781 
781                   Statistics * pStat)                   Statistics * pStat)
782  {  {
783          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)
784                          BitstreamPutBit(bs, 0); /* not_coded */                          BitstreamPutBit(bs, 0); // not_coded
785    
786          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
787                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
# Line 615  Line 790 
790    
791  }  }
792    
793    /*
794    // moved to mbcoding.h so that in can be 'static __inline'
795    void
796    MBSkip(Bitstream * bs)
797    {
798            BitstreamPutBit(bs, 1); // not coded
799    }
800    */
801    
802  /***************************************************************  /***************************************************************
803   * bframe encoding start   * bframe encoding start
804   ***************************************************************/   ***************************************************************/
# Line 671  Line 855 
855                  BitstreamPutBit(bs, 1);                  BitstreamPutBit(bs, 1);
856                  return;                  return;
857    
858          default:;                                       /* invalid */          default:;                                       // invalid
859          }          }
860  }  }
861    
862    
863    
864  void  void
865  MBCodingBVOP(const FRAMEINFO * const frame,  MBCodingBVOP(const MACROBLOCK * mb,
                          const MACROBLOCK * mb,  
866                           const int16_t qcoeff[6 * 64],                           const int16_t qcoeff[6 * 64],
867                           const int32_t fcode,                           const int32_t fcode,
868                           const int32_t bcode,                           const int32_t bcode,
869                           Bitstream * bs,                           Bitstream * bs,
870                           Statistics * pStat)                           Statistics * pStat,
871                             int direction)
872  {  {
873          int vcode = fcode;          int vcode = fcode;
874          unsigned int i;          unsigned int i;
875    
         const uint16_t *scan_table =  
                 frame->vop_flags & XVID_VOP_ALTERNATESCAN ?  
                 scan_tables[2] : scan_tables[0];  
         int bits;  
   
   
876  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
877                  when a block is skipped it is decoded DIRECT(0,0)                  when a block is skipped it is decoded DIRECT(0,0)
878                  hence is interpolated from forward & backward frames                  hence is interpolated from forward & backward frames
879          ------------------------------------------------------------------ */          ------------------------------------------------------------------ */
880    
881          if (mb->mode == MODE_DIRECT_NONE_MV) {          if (mb->mode == MODE_DIRECT_NONE_MV) {
882                  BitstreamPutBit(bs, 1); /* skipped */                  BitstreamPutBit(bs, 1); // skipped
883                  return;                  return;
884          }          }
885    
886          BitstreamPutBit(bs, 0);         /* not skipped */          BitstreamPutBit(bs, 0);         // not skipped
887    
888          if (mb->cbp == 0) {          if (mb->cbp == 0) {
889                  BitstreamPutBit(bs, 1); /* cbp == 0 */                  BitstreamPutBit(bs, 1); // cbp == 0
890          } else {          } else {
891                  BitstreamPutBit(bs, 0); /* cbp == xxx */                  BitstreamPutBit(bs, 0); // cbp == xxx
892          }          }
893    
894          put_bvop_mbtype(bs, mb->mode);          put_bvop_mbtype(bs, mb->mode);
# Line 720  Line 898 
898          }          }
899    
900          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {          if (mb->mode != MODE_DIRECT && mb->cbp != 0) {
901                  put_bvop_dbquant(bs, 0);        /* todo: mb->dquant = 0 */                  put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0
         }  
   
         if (frame->vol_flags & XVID_VOL_INTERLACING) {  
                 if (mb->cbp) {  
                         BitstreamPutBit(bs, mb->field_dct);  
                         DPRINTF(XVID_DEBUG_MB,"codep: field_dct: %i\n", mb->field_dct);  
                 }  
   
                 /* if not direct block, write field ME flag */  
                 if (mb->mode != MODE_DIRECT) {  
                         BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */  
   
                         /* write field prediction references */  
 #if 0 /* Remove the #if once field_pred is supported */  
                         if (mb->field_pred) {  
                                 BitstreamPutBit(bs, mb->field_for_top);  
                                 BitstreamPutBit(bs, mb->field_for_bot);  
                         }  
 #endif  
                 }  
902          }          }
903    
   
904          switch (mb->mode) {          switch (mb->mode) {
905                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
906                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); /* forward vector of interpolate mode */                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); //forward vector of interpolate mode
907                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);
908                  case MODE_BACKWARD:                  case MODE_BACKWARD:
909                          vcode = bcode;                          vcode = bcode;
# Line 755  Line 912 
912                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);
913                          break;                          break;
914                  case MODE_DIRECT:                  case MODE_DIRECT:
915                          CodeVector(bs, mb->pmvs[3].x, 1, pStat);        /* fcode is always 1 for delta vector */                          CodeVector(bs, mb->pmvs[3].x, 1, pStat);        // fcode is always 1 for delta vector
916                          CodeVector(bs, mb->pmvs[3].y, 1, pStat);        /* prediction is always (0,0) */                          CodeVector(bs, mb->pmvs[3].y, 1, pStat);        // prediction is always (0,0)
917                  default: break;                  default: break;
918          }          }
919    
         bits = BitstreamPos(bs);  
920          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
921                  if (mb->cbp & (1 << (5 - i))) {                  if (mb->cbp & (1 << (5 - i))) {
922                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);  #ifdef BIGLUT
923                            CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);
924    #else
925                            CodeCoeffInter(bs, &qcoeff[i * 64], scan_tables[0]);
926    #endif
927                  }                  }
928          }          }
         pStat->iTextBits += BitstreamPos(bs) - bits;  
929  }  }
930    
931    
# Line 776  Line 935 
935   ***************************************************************/   ***************************************************************/
936    
937    
938  /*  // for IVOP addbits == 0
939   * for IVOP addbits == 0  // for PVOP addbits == fcode - 1
940   * for PVOP addbits == fcode - 1  // for BVOP addbits == max(fcode,bcode) - 1
941   * for BVOP addbits == max(fcode,bcode) - 1  // returns true or false
  * returns true or false  
  */  
942  int  int
943  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
944  {  {
# Line 895  Line 1052 
1052                  return data;                  return data;
1053    
1054          res = BitstreamGetBits(bs, fcode - 1);          res = BitstreamGetBits(bs, fcode - 1);
1055          mv = ((abs(data) - 1) * scale_fac) + res + 1;          mv = ((ABS(data) - 1) * scale_fac) + res + 1;
1056    
1057          return data < 0 ? -mv : mv;          return data < 0 ? -mv : mv;
1058    
# Line 996  Line 1153 
1153                  level = BitstreamGetBits(bs, 8);                  level = BitstreamGetBits(bs, 8);
1154    
1155                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1156                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);                          DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);
1157    
1158                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1159          }          }
# Line 1052  Line 1209 
1209          do {          do {
1210                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1211                  if (run == -1) {                  if (run == -1) {
1212                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");
1213                          break;                          break;
1214                  }                  }
1215                  coeff += run;                  coeff += run;
1216                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1217    
1218                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);
1219  #if 0                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));
                 DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[coeff], level, BitstreamShowBits(bs, 32));  
 #endif  
1220    
1221                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1222                          DPRINTF(XVID_DEBUG_ERROR,"warning: intra_overflow %i\n", level);                          DPRINTF(DPRINTF_ERROR,"warning: intra_overflow %i", level);
1223                  }                  }
1224                  coeff++;                  coeff++;
1225          } while (!last);          } while (!last);
# Line 1087  Line 1242 
1242          do {          do {
1243                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1244                  if (run == -1) {                  if (run == -1) {
1245                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");                          DPRINTF(DPRINTF_ERROR,"fatal: invalid run");
1246                          break;                          break;
1247                  }                  }
1248                  p += run;                  p += run;
1249    
1250                  block[scan[p]] = level;                  block[scan[p]] = level;
1251    
1252                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);
1253                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */                  // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));
1254    
1255                  if (level < -2047 || level > 2047) {                  if (level < -2047 || level > 2047) {
1256                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);                          DPRINTF(DPRINTF_ERROR,"warning: inter overflow %i", level);
1257                  }                  }
1258                  p++;                  p++;
1259          } while (!last);          } while (!last);
1260    
1261  }  }
1262    
   
1263  /*****************************************************************************  /*****************************************************************************
1264   * VLC tables and other constant arrays   * VLC tables and other constant arrays
1265   ****************************************************************************/   ****************************************************************************/
# Line 1436  Line 1590 
1590  VLC sprite_trajectory_len[15] = {  VLC sprite_trajectory_len[15] = {
1591          { 0x00 , 2},          { 0x00 , 2},
1592          { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},          { 0x02 , 3}, { 0x03, 3}, { 0x04, 3}, { 0x05, 3}, { 0x06, 3},
1593          { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7E, 7}, { 0xFE, 8},          { 0x0E , 4}, { 0x1E, 5}, { 0x3E, 6}, { 0x7F, 7}, { 0xFE, 8},
1594          { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };          { 0x1FE, 9}, {0x3FE,10}, {0x7FE,11}, {0xFFE,12} };
1595    
1596    
Legend:
Removed from v.1.44.2.18  
changed lines
  Added in v.1.45
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4