[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.15, Fri Oct 3 13:47:00 2003 UTC revision 1.57, Wed Nov 26 01:04:34 2008 UTC
# Line 36  Line 36 
36    
37  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
38    
39  /* #define BIGLUT */  #ifdef _DEBUG
40    # include "../motion/estimation.h"
41    # include "../motion/motion_inlines.h"
42    # include <assert.h>
43    #endif
44    
45    
 #ifdef BIGLUT  
 #define LEVELOFFSET 2048  
 #else  
46  #define LEVELOFFSET 32  #define LEVELOFFSET 32
 #endif  
47    
48    /* Initialized once during xvid_global call
49     * RO access is thread safe */
50  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  
51  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
 #endif  
52    
53  /* not really MB related, but VLCs are only available here */  /* not really MB related, but VLCs are only available here */
54  void bs_put_spritetrajectory(Bitstream * bs, const int val)  void bs_put_spritetrajectory(Bitstream * bs, const int val)
# Line 91  Line 87 
87          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;
88          int32_t l;          int32_t l;
89    
 #ifdef BIGLUT  
         intra_table = coeff_VLC[1];  
         inter_table = coeff_VLC[0];  
 #endif  
   
   
90          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++)
91                  for (i = 0; i < 4096; i++)                  for (i = 0; i < 4096; i++)
92                          DCT3D[intra][i].event.level = 0;                          DCT3D[intra][i].event.level = 0;
93    
94          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
95                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++) {
96                  {                          for (run = 0; run < 63 + last; run++) {
97                          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  
98                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
99                                          coeff_VLC[intra][last][level + offset][run].len = 128;                                          coeff_VLC[intra][last][level + offset][run].len = 128;
100                                  }                                  }
101                  }                  }
102                    }
103            }
104    
105          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
106                  for (i = 0; i < 102; i++)                  for (i = 0; i < 102; i++) {
                 {  
 #ifdef BIGLUT  
                         offset = LEVELOFFSET;  
 #else  
107                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
108  #endif  
109                          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++) {
                         {  
110                                  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;
111                                  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;
112                          }                          }
# Line 134  Line 115 
115                                  = coeff_tab[intra][i].vlc.code << 1;                                  = coeff_tab[intra][i].vlc.code << 1;
116                          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
117                                  = coeff_tab[intra][i].vlc.len + 1;                                  = coeff_tab[intra][i].vlc.len + 1;
118  #ifndef BIGLUT  
119                          if (!intra)                          if (!intra) {
 #endif  
                         {  
120                                  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
121                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
122                                  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
123                                          = coeff_tab[intra][i].vlc.len + 1;                                          = coeff_tab[intra][i].vlc.len + 1;
124                          }                          }
125                  }                  }
126            }
127    
128            for (intra = 0; intra < 2; intra++) {
129                    for (last = 0; last < 2; last++) {
130                            for (run = 0; run < 63 + last; run++) {
131                                    for (level = 1; level < (uint32_t)(32 << intra); level++) {
132    
         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++)  
                                 {  
133                                          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])
134                                              continue;                                              continue;
135    
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
136                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
137                      level_esc = level - max_level[intra][last][run];                      level_esc = level - max_level[intra][last][run];
138                                          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))*/  
139    
140                                          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]) {
                                         {  
141                                                  escape     = ESCAPE1;                                                  escape     = ESCAPE1;
142                                                  escape_len = 7 + 1;                                                  escape_len = 7 + 1;
143                                                  run_esc    = run;                                                  run_esc    = run;
144                                          }                                          } else {
145                                          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])  
                                                 {  
146                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
147                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
148                                                          level_esc  = level;                                                          level_esc  = level;
149                                                  }                                                  } else {
150                                                  else                                                          if (!intra) {
                                                 {  
 #ifndef BIGLUT  
                                                         if (!intra)  
 #endif  
                                                         {  
151                                                                  coeff_VLC[intra][last][level + offset][run].code                                                                  coeff_VLC[intra][last][level + offset][run].code
152                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
153                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
# Line 202  Line 164 
164                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
165                                          coeff_VLC[intra][last][level + offset][run].len                                          coeff_VLC[intra][last][level + offset][run].len
166                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
167  #ifndef BIGLUT  
168                                          if (!intra)                                          if (!intra) {
 #endif  
                                         {  
169                                                  coeff_VLC[intra][last][offset - level][run].code                                                  coeff_VLC[intra][last][offset - level][run].code
170                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
171                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
# Line 214  Line 174 
174                                          }                                          }
175                                  }                                  }
176    
177  #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)  
                                 {  
178                                          coeff_VLC[intra][last][0][run].code                                          coeff_VLC[intra][last][0][run].code
179                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
180                                          coeff_VLC[intra][last][0][run].len = 30;                                          coeff_VLC[intra][last][0][run].len = 30;
181                                  }                                  }
 #endif  
182                          }                          }
183  /* init sprite_trajectory tables */                  }
184  /* even if GMC is not specified (it might be used later...) */          }
185    
186            /* init sprite_trajectory tables
187             * even if GMC is not specified (it might be used later...) */
188    
189          sprite_trajectory_code[0+16384].code = 0;          sprite_trajectory_code[0+16384].code = 0;
190          sprite_trajectory_code[0+16384].len = 0;          sprite_trajectory_code[0+16384].len = 0;
191          for (k=0;k<14;k++)          for (k=0;k<14;k++) {
         {  
192                  int limit = (1<<k);                  int limit = (1<<k);
193    
194                  for (l=-(2*limit-1); l <= -limit; l++)                  for (l=-(2*limit-1); l <= -limit; l++) {
                 {  
195                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
196                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
197                  }                  }
198    
199                  for (l=limit; l<= 2*limit-1; l++)                  for (l=limit; l<= 2*limit-1; l++) {
                 {  
200                          sprite_trajectory_code[l+16384].code = l;                          sprite_trajectory_code[l+16384].code = l;
201                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
202                  }                  }
# Line 260  Line 206 
206  static __inline void  static __inline void
207  CodeVector(Bitstream * bs,  CodeVector(Bitstream * bs,
208                     int32_t value,                     int32_t value,
209                     int32_t f_code,                     int32_t f_code)
                    Statistics * pStat)  
210  {  {
211    
212          const int scale_factor = 1 << (f_code - 1);          const int scale_factor = 1 << (f_code - 1);
# Line 273  Line 218 
218          if (value > (cmp - 1))          if (value > (cmp - 1))
219                  value -= 64 * scale_factor;                  value -= 64 * scale_factor;
220    
         pStat->iMvSum += value * value;  
         pStat->iMvCount++;  
   
221          if (value == 0) {          if (value == 0) {
222                  BitstreamPutBits(bs, mb_motion_table[32].code,                  BitstreamPutBits(bs, mb_motion_table[32].code,
223                                                   mb_motion_table[32].len);                                                   mb_motion_table[32].len);
# Line 312  Line 254 
254    
255  }  }
256    
 #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  
   
257  static __inline void  static __inline void
258  CodeCoeffInter(Bitstream * bs,  CodeCoeffInter(Bitstream * bs,
259                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 602  Line 458 
458          return bits;          return bits;
459  }  }
460    
461    static const int iDQtab[5] = {
 #endif  
   
   
 static int iDQtab[5] = {  
462          1, 0, -1 /* no change */, 2, 3          1, 0, -1 /* no change */, 2, 3
463  };  };
464  #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]  #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
# Line 668  Line 520 
520    
521                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
522    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);  
 #else  
523                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
 #endif  
524    
525                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
526                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 718  Line 566 
566                  }                  }
567    
568                  /* if inter block, write field ME flag */                  /* if inter block, write field ME flag */
569                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
570                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
571                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
572    
573                          /* write field prediction references */                          /* write field prediction references */
574    #if 0 /* Remove the #if once field_pred is supported */
575                          if (pMB->field_pred) {                          if (pMB->field_pred) {
576                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
577                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
578                          }                          }
579    #endif
580                  }                  }
581          }          }
582    
583            bits = BitstreamPos(bs);
584    
585          /* code motion vector(s) if motion is local  */          /* code motion vector(s) if motion is local  */
586          if (!pMB->mcsel)          if (!pMB->mcsel)
587                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
588                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode);
589                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode);
590    
591    #ifdef _DEBUG
592                            if (i == 0) /* for simplicity */ {
593                                    int coded_length = BitstreamPos(bs) - bits;
594                                    int estimated_length = d_mv_bits(pMB->pmvs[i].x, pMB->pmvs[i].y, zeroMV, frame->fcode, 0);
595                                    assert(estimated_length == coded_length);
596                                    d_mv_bits(pMB->pmvs[i].x, pMB->pmvs[i].y, zeroMV, frame->fcode, 0);
597                  }                  }
598    #endif
599                    }
600    
601            bits = BitstreamPos(bs) - bits;
602            pStat->iMVBits += bits;
603    
604          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
605    
606          /* code block coeffs */          /* code block coeffs */
607          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
608                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
                 {  
609                          const uint16_t *scan_table =                          const uint16_t *scan_table =
610                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
611                                  scan_tables[2] : scan_tables[0];                                  scan_tables[2] : scan_tables[0];
612    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);  
 #else  
613                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
 #endif  
614                  }                  }
615    
616          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
# Line 768  Line 628 
628          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)
629                          BitstreamPutBit(bs, 0); /* not_coded */                          BitstreamPutBit(bs, 0); /* not_coded */
630    
631            if (frame->vop_flags & XVID_VOP_GREYSCALE) {
632                    pMB->cbp &= 0x3C;               /* keep only bits 5-2 */
633                    qcoeff[4*64+0]=0;               /* for INTRA DC value is saved */
634                    qcoeff[5*64+0]=0;
635            }
636    
637          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
638                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
639          else          else
# Line 852  Line 718 
718          const uint16_t *scan_table =          const uint16_t *scan_table =
719                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
720                  scan_tables[2] : scan_tables[0];                  scan_tables[2] : scan_tables[0];
721            int bits;
722    
723  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
724                  when a block is skipped it is decoded DIRECT(0,0)                  when a block is skipped it is decoded DIRECT(0,0)
# Line 893  Line 759 
759                          BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */                          BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
760    
761                          /* write field prediction references */                          /* write field prediction references */
762                  /*      if (mb->field_pred) {  #if 0 /* Remove the #if once field_pred is supported */
763                            if (mb->field_pred) {
764                                  BitstreamPutBit(bs, mb->field_for_top);                                  BitstreamPutBit(bs, mb->field_for_top);
765                                  BitstreamPutBit(bs, mb->field_for_bot);                                  BitstreamPutBit(bs, mb->field_for_bot);
766                          }*/                          }
767    #endif
768                  }                  }
769          }          }
770    
771            bits = BitstreamPos(bs);
772    
773          switch (mb->mode) {          switch (mb->mode) {
774                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
775                          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 */
776                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode);
777                  case MODE_BACKWARD:                  case MODE_BACKWARD:
778                          vcode = bcode;                          vcode = bcode;
779                  case MODE_FORWARD:                  case MODE_FORWARD:
780                          CodeVector(bs, mb->pmvs[0].x, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].x, vcode);
781                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode);
782                          break;                          break;
783                  case MODE_DIRECT:                  case MODE_DIRECT:
784                          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 */
785                          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) */
786                  default: break;                  default: break;
787          }          }
788            pStat->iMVBits += BitstreamPos(bs) - bits;
789    
790            bits = BitstreamPos(bs);
791          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
792                  if (mb->cbp & (1 << (5 - i))) {                  if (mb->cbp & (1 << (5 - i))) {
793  #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  
794                  }                  }
795          }          }
796            pStat->iTextBits += BitstreamPos(bs) - bits;
797  }  }
798    
799    
# Line 1117  Line 985 
985    
986  }  }
987    
988    #define GET_BITS(cache, n) ((cache)>>(32-(n)))
989    
990  static __inline int  static __inline int
991  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
992                    int *run,                    int *run,
# Line 1129  Line 999 
999          int32_t level;          int32_t level;
1000          REVERSE_EVENT *reverse_event;          REVERSE_EVENT *reverse_event;
1001    
1002            uint32_t cache = BitstreamShowBits(bs, 32);
1003    
1004          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 */
1005                  intra = 0;                  intra = 0;
1006    
1007          if (BitstreamShowBits(bs, 7) != ESCAPE) {          if (GET_BITS(cache, 7) != ESCAPE) {
1008                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1009    
1010                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1011                          goto error;                          goto error;
# Line 1141  Line 1013 
1013                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1014                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1015    
1016                  BitstreamSkip(bs, reverse_event->len);                  /* Don't forget to update the bitstream position */
1017                    BitstreamSkip(bs, reverse_event->len+1);
1018    
1019                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1020          }          }
1021    
1022          BitstreamSkip(bs, 7);          /* flush 7bits of cache */
1023            cache <<= 7;
1024    
1025          if (short_video_header) {          if (short_video_header) {
1026                  /* 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  */
1027                  *last = BitstreamGetBit(bs);                  *last =  GET_BITS(cache, 1);
1028                  *run = BitstreamGetBits(bs, 6);                  *run  = (GET_BITS(cache, 7) &0x3f);
1029                  level = BitstreamGetBits(bs, 8);                  level = (GET_BITS(cache, 15)&0xff);
1030    
1031                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1032                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);                          DPRINTF(XVID_DEBUG_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d\n", level);
1033    
1034                    /* We've "eaten" 22 bits */
1035                    BitstreamSkip(bs, 22);
1036    
1037                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1038          }          }
1039    
1040          mode = BitstreamShowBits(bs, 2);          if ((mode = GET_BITS(cache, 2)) < 3) {
1041                    const int skip[3] = {1, 1, 2};
1042                    cache <<= skip[mode];
1043    
1044          if (mode < 3) {                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
   
                 reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];  
1045    
1046                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1047                          goto error;                          goto error;
# Line 1173  Line 1049 
1049                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1050                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1051    
1052                  BitstreamSkip(bs, reverse_event->len);                  if (mode < 2) {
1053                            /* first escape mode, level is offset */
                 if (mode < 2)                   /* first escape mode, level is offset */  
1054                          level += max_level[intra][*last][*run];                          level += max_level[intra][*last][*run];
1055                  else                                    /* second escape mode, run is offset */                  } else {
1056                            /* second escape mode, run is offset */
1057                          *run += max_run[intra][*last][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1058                    }
1059    
1060                    /* Update bitstream position */
1061                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1062    
1063                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1064          }          }
1065    
1066          /* third escape mode - fixed length codes */          /* third escape mode - fixed length codes */
1067          BitstreamSkip(bs, 2);          cache <<= 2;
1068          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1069          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1070          BitstreamSkip(bs, 1);           /* marker */          level = (GET_BITS(cache, 20)&0xfff);
1071          level = BitstreamGetBits(bs, 12);  
1072          BitstreamSkip(bs, 1);           /* marker */          /* Update bitstream position */
1073            BitstreamSkip(bs, 30);
1074    
1075          return (level << 20) >> 20;          return (level << 20) >> 20;
1076    
1077    error:    error:
1078          *run = VLC_ERROR;          *run = 64;
1079          return 0;          return 0;
1080  }  }
1081    
# Line 1206  Line 1087 
1087  {  {
1088    
1089          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1090          int level, run, last;          int level, run, last = 0;
1091    
1092          do {          do {
1093                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1094                  if (run == -1) {                  coeff += run;
1095                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");                  if (coeff & ~63) {
1096                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1097                          break;                          break;
1098                  }                  }
1099                  coeff += run;  
1100                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1101    
1102                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
# Line 1231  Line 1113 
1113  }  }
1114    
1115  void  void
1116  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1117                    Bitstream * bs,
1118                                  int16_t * block,                                  int16_t * block,
1119                                  int direction)                  int direction,
1120                    const int quant,
1121                    const uint16_t *matrix)
1122  {  {
1123    
1124          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1125            const uint16_t quant_m_2 = quant << 1;
1126            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1127          int p;          int p;
1128          int level;          int level;
1129          int run;          int run;
1130          int last;          int last = 0;
1131    
1132          p = 0;          p = 0;
1133          do {          do {
1134                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1135                  if (run == -1) {                  p += run;
1136                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");                  if (p & ~63) {
1137                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1138                          break;                          break;
1139                  }                  }
                 p += run;  
1140    
1141                  block[scan[p]] = level;                  if (level < 0) {
1142                            level = level*quant_m_2 - quant_add;
1143                            block[scan[p]] = (level >= -2048 ? level : -2048);
1144                    } else {
1145                            level = level * quant_m_2 + quant_add;
1146                            block[scan[p]] = (level <= 2047 ? level : 2047);
1147                    }
1148                    p++;
1149            } while (!last);
1150    }
1151    
1152    void
1153    get_inter_block_mpeg(
1154                    Bitstream * bs,
1155                    int16_t * block,
1156                    int direction,
1157                    const int quant,
1158                    const uint16_t *matrix)
1159    {
1160            const uint16_t *scan = scan_tables[direction];
1161            uint32_t sum = 0;
1162            int p;
1163            int level;
1164            int run;
1165            int last = 0;
1166    
1167                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);          p = 0;
1168                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */          do {
1169                    level = get_coeff(bs, &run, &last, 0, 0);
1170                    p += run;
1171                    if (p & ~63) {
1172                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1173                            break;
1174                    }
1175    
1176                  if (level < -2047 || level > 2047) {                  if (level < 0) {
1177                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);                          level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1178                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1179                    } else {
1180                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1181                            block[scan[p]] = (level <= 2047 ? level : 2047);
1182                  }                  }
1183    
1184                    sum ^= block[scan[p]];
1185    
1186                  p++;                  p++;
1187          } while (!last);          } while (!last);
1188    
1189            /*      mismatch control */
1190            if ((sum & 1) == 0) {
1191                    block[63] ^= 1;
1192            }
1193  }  }
1194    
1195    
# Line 2041  Line 1969 
1969  };  };
1970    
1971  short const dc_threshold[] = {  short const dc_threshold[] = {
1972          21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,          26708, 29545, 29472, 26223, 30580, 29281,  8293, 29545,
1973           8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,          25632, 29285, 30313, 25701, 26144, 28530,  8301, 26740,
1974          25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,           8293, 20039,  8277, 20551,  8268, 30296, 17513, 25376,
1975          28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,          25711, 25445, 10272, 11825, 11825, 10544,  2606, 28505,
1976          30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,          29301, 29472, 26223, 30580, 29281,  8293, 26980, 29811,
1977          29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,          26994, 30050, 28532,  8306, 24936,  8307, 28532, 26400,
1978          26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,          30313,  8293, 25441, 25955, 29555, 29728,  8303, 29801,
1979          29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606           8307, 28531, 29301, 25955, 25376, 25711, 11877,    10
1980  };  };
1981    
1982  VLC const dc_lum_tab[] = {  VLC const dc_lum_tab[] = {
Legend:
Removed from v.1.44.2.15  
changed lines
  Added in v.1.57
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4