[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.53, Thu Jan 19 22:25:23 2006 UTC
# Line 36  Line 36 
36    
37  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
38    
 /* #define BIGLUT */  
   
 #ifdef BIGLUT  
 #define LEVELOFFSET 2048  
 #else  
39  #define LEVELOFFSET 32  #define LEVELOFFSET 32
 #endif  
40    
41    /* Initialized once during xvid_global call
42     * RO access is thread safe */
43  static REVERSE_EVENT DCT3D[2][4096];  static REVERSE_EVENT DCT3D[2][4096];
   
 #ifdef BIGLUT  
 static VLC coeff_VLC[2][2][4096][64];  
 VLC *intra_table;  
 static VLC *inter_table;  
 #else  
44  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
 #endif  
45    
46  /* not really MB related, but VLCs are only available here */  /* not really MB related, but VLCs are only available here */
47  void bs_put_spritetrajectory(Bitstream * bs, const int val)  void bs_put_spritetrajectory(Bitstream * bs, const int val)
# Line 91  Line 80 
80          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;          uint32_t i, j, k, intra, last, run,  run_esc, level, level_esc, escape, escape_len, offset;
81          int32_t l;          int32_t l;
82    
 #ifdef BIGLUT  
         intra_table = coeff_VLC[1];  
         inter_table = coeff_VLC[0];  
 #endif  
   
   
83          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++)
84                  for (i = 0; i < 4096; i++)                  for (i = 0; i < 4096; i++)
85                          DCT3D[intra][i].event.level = 0;                          DCT3D[intra][i].event.level = 0;
86    
87          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
88                  for (last = 0; last < 2; last++)                  for (last = 0; last < 2; last++) {
89                  {                          for (run = 0; run < 63 + last; run++) {
90                          for (run = 0; run < 63 + last; run++)                                  for (level = 0; level < (uint32_t)(32 << intra); level++) {
                                 for (level = 0; level < (uint32_t)(32 << intra); level++)  
                                 {  
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
91                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
92                                          coeff_VLC[intra][last][level + offset][run].len = 128;                                          coeff_VLC[intra][last][level + offset][run].len = 128;
93                                  }                                  }
94                  }                  }
95                    }
96            }
97    
98          for (intra = 0; intra < 2; intra++)          for (intra = 0; intra < 2; intra++) {
99                  for (i = 0; i < 102; i++)                  for (i = 0; i < 102; i++) {
                 {  
 #ifdef BIGLUT  
                         offset = LEVELOFFSET;  
 #else  
100                          offset = !intra * LEVELOFFSET;                          offset = !intra * LEVELOFFSET;
101  #endif  
102                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++)                          for (j = 0; j < (uint32_t)(1 << (12 - coeff_tab[intra][i].vlc.len)); j++) {
                         {  
103                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].len       = coeff_tab[intra][i].vlc.len;
104                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;                                  DCT3D[intra][(coeff_tab[intra][i].vlc.code << (12 - coeff_tab[intra][i].vlc.len)) | j].event = coeff_tab[intra][i].event;
105                          }                          }
# Line 134  Line 108 
108                                  = coeff_tab[intra][i].vlc.code << 1;                                  = coeff_tab[intra][i].vlc.code << 1;
109                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len                          coeff_VLC[intra][coeff_tab[intra][i].event.last][coeff_tab[intra][i].event.level + offset][coeff_tab[intra][i].event.run].len
110                                  = coeff_tab[intra][i].vlc.len + 1;                                  = coeff_tab[intra][i].vlc.len + 1;
111  #ifndef BIGLUT  
112                          if (!intra)                          if (!intra) {
 #endif  
                         {  
113                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].code
114                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;                                          = (coeff_tab[intra][i].vlc.code << 1) | 1;
115                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len                                  coeff_VLC[intra][coeff_tab[intra][i].event.last][offset - coeff_tab[intra][i].event.level][coeff_tab[intra][i].event.run].len
116                                          = coeff_tab[intra][i].vlc.len + 1;                                          = coeff_tab[intra][i].vlc.len + 1;
117                          }                          }
118                  }                  }
119            }
120    
121            for (intra = 0; intra < 2; intra++) {
122                    for (last = 0; last < 2; last++) {
123                            for (run = 0; run < 63 + last; run++) {
124                                    for (level = 1; level < (uint32_t)(32 << intra); level++) {
125    
         for (intra = 0; intra < 2; intra++)  
                 for (last = 0; last < 2; last++)  
                         for (run = 0; run < 63 + last; run++)  
                         {  
                                 for (level = 1; level < (uint32_t)(32 << intra); level++)  
                                 {  
126                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])                                          if (level <= max_level[intra][last][run] && run <= max_run[intra][last][level])
127                                              continue;                                              continue;
128    
 #ifdef BIGLUT  
                                         offset = LEVELOFFSET;  
 #else  
129                                          offset = !intra * LEVELOFFSET;                                          offset = !intra * LEVELOFFSET;
 #endif  
130                      level_esc = level - max_level[intra][last][run];                      level_esc = level - max_level[intra][last][run];
131                                          run_esc = run - 1 - max_run[intra][last][level];                                          run_esc = run - 1 - max_run[intra][last][level];
                                         /*use this test to use shorter esc2 codes when possible  
                                         if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]  
                                                 && !(coeff_VLC[intra][last][level_esc + offset][run].len + 7 + 1  
                                                          > coeff_VLC[intra][last][level + offset][run_esc].code + 7 + 2))*/  
132    
133                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc])                                          if (level_esc <= max_level[intra][last][run] && run <= max_run[intra][last][level_esc]) {
                                         {  
134                                                  escape     = ESCAPE1;                                                  escape     = ESCAPE1;
135                                                  escape_len = 7 + 1;                                                  escape_len = 7 + 1;
136                                                  run_esc    = run;                                                  run_esc    = run;
137                                          }                                          } else {
138                                          else                                                  if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc]) {
                                         {  
                                                 if (run_esc <= max_run[intra][last][level] && level <= max_level[intra][last][run_esc])  
                                                 {  
139                                                          escape     = ESCAPE2;                                                          escape     = ESCAPE2;
140                                                          escape_len = 7 + 2;                                                          escape_len = 7 + 2;
141                                                          level_esc  = level;                                                          level_esc  = level;
142                                                  }                                                  } else {
143                                                  else                                                          if (!intra) {
                                                 {  
 #ifndef BIGLUT  
                                                         if (!intra)  
 #endif  
                                                         {  
144                                                                  coeff_VLC[intra][last][level + offset][run].code                                                                  coeff_VLC[intra][last][level + offset][run].code
145                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;                                                                          = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;
146                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;                                                                  coeff_VLC[intra][last][level + offset][run].len = 30;
# Line 202  Line 157 
157                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;                                                  |  coeff_VLC[intra][last][level_esc + offset][run_esc].code;
158                                          coeff_VLC[intra][last][level + offset][run].len                                          coeff_VLC[intra][last][level + offset][run].len
159                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;                                                  = coeff_VLC[intra][last][level_esc + offset][run_esc].len + escape_len;
160  #ifndef BIGLUT  
161                                          if (!intra)                                          if (!intra) {
 #endif  
                                         {  
162                                                  coeff_VLC[intra][last][offset - level][run].code                                                  coeff_VLC[intra][last][offset - level][run].code
163                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)                                                          = (escape << coeff_VLC[intra][last][level_esc + offset][run_esc].len)
164                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;                                                          |  coeff_VLC[intra][last][level_esc + offset][run_esc].code | 1;
# Line 214  Line 167 
167                                          }                                          }
168                                  }                                  }
169    
170  #ifdef BIGLUT                                  if (!intra) {
                                 for (level = 32 << intra; level < 2048; level++)  
                                 {  
                                         coeff_VLC[intra][last][level + offset][run].code  
                                                 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((level & 0xfff) << 1) | 1;  
                                         coeff_VLC[intra][last][level + offset][run].len = 30;  
   
                                         coeff_VLC[intra][last][offset - level][run].code  
                                                 = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-level & 0xfff) << 1) | 1;  
                                         coeff_VLC[intra][last][offset - level][run].len = 30;  
                                 }  
 #else  
                                 if (!intra)  
                                 {  
171                                          coeff_VLC[intra][last][0][run].code                                          coeff_VLC[intra][last][0][run].code
172                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;                                                  = (ESCAPE3 << 21) | (last << 20) | (run << 14) | (1 << 13) | ((-32 & 0xfff) << 1) | 1;
173                                          coeff_VLC[intra][last][0][run].len = 30;                                          coeff_VLC[intra][last][0][run].len = 30;
174                                  }                                  }
 #endif  
175                          }                          }
176  /* init sprite_trajectory tables */                  }
177  /* even if GMC is not specified (it might be used later...) */          }
178    
179            /* init sprite_trajectory tables
180             * even if GMC is not specified (it might be used later...) */
181    
182          sprite_trajectory_code[0+16384].code = 0;          sprite_trajectory_code[0+16384].code = 0;
183          sprite_trajectory_code[0+16384].len = 0;          sprite_trajectory_code[0+16384].len = 0;
184          for (k=0;k<14;k++)          for (k=0;k<14;k++) {
         {  
185                  int limit = (1<<k);                  int limit = (1<<k);
186    
187                  for (l=-(2*limit-1); l <= -limit; l++)                  for (l=-(2*limit-1); l <= -limit; l++) {
                 {  
188                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;                          sprite_trajectory_code[l+16384].code = (2*limit-1)+l;
189                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
190                  }                  }
191    
192                  for (l=limit; l<= 2*limit-1; l++)                  for (l=limit; l<= 2*limit-1; l++) {
                 {  
193                          sprite_trajectory_code[l+16384].code = l;                          sprite_trajectory_code[l+16384].code = l;
194                          sprite_trajectory_code[l+16384].len = k+1;                          sprite_trajectory_code[l+16384].len = k+1;
195                  }                  }
# Line 260  Line 199 
199  static __inline void  static __inline void
200  CodeVector(Bitstream * bs,  CodeVector(Bitstream * bs,
201                     int32_t value,                     int32_t value,
202                     int32_t f_code,                     int32_t f_code)
                    Statistics * pStat)  
203  {  {
204    
205          const int scale_factor = 1 << (f_code - 1);          const int scale_factor = 1 << (f_code - 1);
# Line 273  Line 211 
211          if (value > (cmp - 1))          if (value > (cmp - 1))
212                  value -= 64 * scale_factor;                  value -= 64 * scale_factor;
213    
         pStat->iMvSum += value * value;  
         pStat->iMvCount++;  
   
214          if (value == 0) {          if (value == 0) {
215                  BitstreamPutBits(bs, mb_motion_table[32].code,                  BitstreamPutBits(bs, mb_motion_table[32].code,
216                                                   mb_motion_table[32].len);                                                   mb_motion_table[32].len);
# Line 312  Line 247 
247    
248  }  }
249    
 #ifdef BIGLUT  
   
 static __inline void  
 CodeCoeff(Bitstream * bs,  
                   const int16_t qcoeff[64],  
                   VLC * table,  
                   const uint16_t * zigzag,  
                   uint16_t intra)  
 {  
   
         uint32_t j, last;  
         short v;  
         VLC *vlc;  
   
         j = intra;  
         last = intra;  
   
         while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                 j++;  
   
         do {  
                 vlc = table + 64 * 2048 + (v << 6) + j - last;  
                 last = ++j;  
   
                 /* count zeroes */  
                 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                         j++;  
   
                 /* write code */  
                 if (j != 64) {  
                         BitstreamPutBits(bs, vlc->code, vlc->len);  
                 } else {  
                         vlc += 64 * 4096;  
                         BitstreamPutBits(bs, vlc->code, vlc->len);  
                         break;  
                 }  
         } while (1);  
   
 }  
   
   
   
 /* returns the number of bits required to encode qcoeff */  
 int  
 CodeCoeff_CalcBits(const int16_t qcoeff[64],  
                   VLC * table,  
                   const uint16_t * zigzag,  
                   uint16_t intra)  
 {  
         int bits = 0;  
         uint32_t j, last;  
         short v;  
         VLC *vlc;  
   
         j = intra;  
         last = intra;  
   
         while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                 j++;  
   
         if (j >= 64) return 0;  /* empty block */  
   
         do {  
                 vlc = table + 64 * 2048 + (v << 6) + j - last;  
                 last = ++j;  
   
                 /* count zeroes */  
                 while (j < 64 && (v = qcoeff[zigzag[j]]) == 0)  
                         j++;  
   
                 /* write code */  
                 if (j != 64) {  
                         bits += vlc->len;  
                 } else {  
                         vlc += 64 * 4096;  
                         bits += vlc->len;  
                         break;  
                 }  
         } while (1);  
   
         return bits;  
 }  
   
   
 #else  
   
250  static __inline void  static __inline void
251  CodeCoeffInter(Bitstream * bs,  CodeCoeffInter(Bitstream * bs,
252                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 602  Line 451 
451          return bits;          return bits;
452  }  }
453    
454    static const int iDQtab[5] = {
 #endif  
   
   
 static int iDQtab[5] = {  
455          1, 0, -1 /* no change */, 2, 3          1, 0, -1 /* no change */, 2, 3
456  };  };
457  #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]  #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
# Line 668  Line 513 
513    
514                          bits = BitstreamPos(bs);                          bits = BitstreamPos(bs);
515    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], intra_table, scan_table, 1);  
 #else  
516                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffIntra(bs, &qcoeff[i * 64], scan_table);
 #endif  
517    
518                          bits = BitstreamPos(bs) - bits;                          bits = BitstreamPos(bs) - bits;
519                          pStat->iTextBits += bits;                          pStat->iTextBits += bits;
# Line 718  Line 559 
559                  }                  }
560    
561                  /* if inter block, write field ME flag */                  /* if inter block, write field ME flag */
562                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) && (pMB->mcsel == 0)) {
563                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, 0 /*pMB->field_pred*/); /* not implemented yet */
564                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);                          DPRINTF(XVID_DEBUG_MB,"codep: field_pred: %i\n", pMB->field_pred);
565    
566                          /* write field prediction references */                          /* write field prediction references */
567    #if 0 /* Remove the #if once field_pred is supported */
568                          if (pMB->field_pred) {                          if (pMB->field_pred) {
569                                  BitstreamPutBit(bs, pMB->field_for_top);                                  BitstreamPutBit(bs, pMB->field_for_top);
570                                  BitstreamPutBit(bs, pMB->field_for_bot);                                  BitstreamPutBit(bs, pMB->field_for_bot);
571                          }                          }
572    #endif
573                  }                  }
574          }          }
575    
576            bits = BitstreamPos(bs);
577    
578          /* code motion vector(s) if motion is local  */          /* code motion vector(s) if motion is local  */
579          if (!pMB->mcsel)          if (!pMB->mcsel)
580                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
581                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode);
582                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode);
583                  }                  }
584    
585            bits = BitstreamPos(bs) - bits;
586            pStat->iMVBits += bits;
587    
588          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
589    
590          /* code block coeffs */          /* code block coeffs */
591          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
592                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
                 {  
593                          const uint16_t *scan_table =                          const uint16_t *scan_table =
594                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
595                                  scan_tables[2] : scan_tables[0];                                  scan_tables[2] : scan_tables[0];
596    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);  
 #else  
597                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
 #endif  
598                  }                  }
599    
600          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
# Line 768  Line 612 
612          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)
613                          BitstreamPutBit(bs, 0); /* not_coded */                          BitstreamPutBit(bs, 0); /* not_coded */
614    
615            if (frame->vop_flags & XVID_VOP_GREYSCALE) {
616                    pMB->cbp &= 0x3C;               /* keep only bits 5-2 */
617                    qcoeff[4*64+0]=0;               /* for INTRA DC value is saved */
618                    qcoeff[5*64+0]=0;
619            }
620    
621          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
622                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
623          else          else
# Line 852  Line 702 
702          const uint16_t *scan_table =          const uint16_t *scan_table =
703                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
704                  scan_tables[2] : scan_tables[0];                  scan_tables[2] : scan_tables[0];
705            int bits;
706    
707  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
708                  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 743 
743                          BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */                          BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
744    
745                          /* write field prediction references */                          /* write field prediction references */
746                  /*      if (mb->field_pred) {  #if 0 /* Remove the #if once field_pred is supported */
747                            if (mb->field_pred) {
748                                  BitstreamPutBit(bs, mb->field_for_top);                                  BitstreamPutBit(bs, mb->field_for_top);
749                                  BitstreamPutBit(bs, mb->field_for_bot);                                  BitstreamPutBit(bs, mb->field_for_bot);
750                          }*/                          }
751    #endif
752                  }                  }
753          }          }
754    
755            bits = BitstreamPos(bs);
756    
757          switch (mb->mode) {          switch (mb->mode) {
758                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
759                          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 */
760                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode);
761                  case MODE_BACKWARD:                  case MODE_BACKWARD:
762                          vcode = bcode;                          vcode = bcode;
763                  case MODE_FORWARD:                  case MODE_FORWARD:
764                          CodeVector(bs, mb->pmvs[0].x, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].x, vcode);
765                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode);
766                          break;                          break;
767                  case MODE_DIRECT:                  case MODE_DIRECT:
768                          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 */
769                          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) */
770                  default: break;                  default: break;
771          }          }
772            pStat->iMVBits += BitstreamPos(bs) - bits;
773    
774            bits = BitstreamPos(bs);
775          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
776                  if (mb->cbp & (1 << (5 - i))) {                  if (mb->cbp & (1 << (5 - i))) {
777  #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  
778                  }                  }
779          }          }
780            pStat->iTextBits += BitstreamPos(bs) - bits;
781  }  }
782    
783    
# Line 1117  Line 969 
969    
970  }  }
971    
972    #define GET_BITS(cache, n) ((cache)>>(32-(n)))
973    
974  static __inline int  static __inline int
975  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
976                    int *run,                    int *run,
# Line 1129  Line 983 
983          int32_t level;          int32_t level;
984          REVERSE_EVENT *reverse_event;          REVERSE_EVENT *reverse_event;
985    
986            uint32_t cache = BitstreamShowBits(bs, 32);
987    
988          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 */
989                  intra = 0;                  intra = 0;
990    
991          if (BitstreamShowBits(bs, 7) != ESCAPE) {          if (GET_BITS(cache, 7) != ESCAPE) {
992                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
993    
994                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
995                          goto error;                          goto error;
# Line 1141  Line 997 
997                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
998                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
999    
1000                  BitstreamSkip(bs, reverse_event->len);                  /* Don't forget to update the bitstream position */
1001                    BitstreamSkip(bs, reverse_event->len+1);
1002    
1003                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1004          }          }
1005    
1006          BitstreamSkip(bs, 7);          /* flush 7bits of cache */
1007            cache <<= 7;
1008    
1009          if (short_video_header) {          if (short_video_header) {
1010                  /* 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  */
1011                  *last = BitstreamGetBit(bs);                  *last =  GET_BITS(cache, 1);
1012                  *run = BitstreamGetBits(bs, 6);                  *run  = (GET_BITS(cache, 7) &0x3f);
1013                  level = BitstreamGetBits(bs, 8);                  level = (GET_BITS(cache, 15)&0xff);
1014    
1015                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1016                          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);
1017    
1018                    /* We've "eaten" 22 bits */
1019                    BitstreamSkip(bs, 22);
1020    
1021                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1022          }          }
1023    
1024          mode = BitstreamShowBits(bs, 2);          if ((mode = GET_BITS(cache, 2)) < 3) {
1025                    const int skip[3] = {1, 1, 2};
1026          if (mode < 3) {                  cache <<= skip[mode];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
1027    
1028                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1029    
1030                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1031                          goto error;                          goto error;
# Line 1173  Line 1033 
1033                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1034                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1035    
1036                  BitstreamSkip(bs, reverse_event->len);                  if (mode < 2) {
1037                            /* first escape mode, level is offset */
                 if (mode < 2)                   /* first escape mode, level is offset */  
1038                          level += max_level[intra][*last][*run];                          level += max_level[intra][*last][*run];
1039                  else                                    /* second escape mode, run is offset */                  } else {
1040                            /* second escape mode, run is offset */
1041                          *run += max_run[intra][*last][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1042                    }
1043    
1044                  return BitstreamGetBits(bs, 1) ? -level : level;                  /* Update bitstream position */
1045                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1046    
1047                    return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1048          }          }
1049    
1050          /* third escape mode - fixed length codes */          /* third escape mode - fixed length codes */
1051          BitstreamSkip(bs, 2);          cache <<= 2;
1052          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1053          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1054          BitstreamSkip(bs, 1);           /* marker */          level = (GET_BITS(cache, 20)&0xfff);
1055          level = BitstreamGetBits(bs, 12);  
1056          BitstreamSkip(bs, 1);           /* marker */          /* Update bitstream position */
1057            BitstreamSkip(bs, 30);
1058    
1059          return (level << 20) >> 20;          return (level << 20) >> 20;
1060    
# Line 1215  Line 1080 
1080                          break;                          break;
1081                  }                  }
1082                  coeff += run;                  coeff += run;
1083    
1084    #ifdef _DEBUG
1085                    if(coeff>=64) {
1086                      DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1087                      return;
1088                    }
1089    #endif
1090    
1091                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1092    
1093                  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 1104 
1104  }  }
1105    
1106  void  void
1107  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1108                    Bitstream * bs,
1109                                  int16_t * block,                                  int16_t * block,
1110                                  int direction)                  int direction,
1111                    const int quant,
1112                    const uint16_t *matrix)
1113  {  {
1114    
1115          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1116            const uint16_t quant_m_2 = quant << 1;
1117            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1118          int p;          int p;
1119          int level;          int level;
1120          int run;          int run;
# Line 1251  Line 1129 
1129                  }                  }
1130                  p += run;                  p += run;
1131    
1132                  block[scan[p]] = level;  #ifdef _DEBUG
1133                    if(p>=64)       {
1134                      DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1135                      return;
1136                    }
1137    #endif
1138    
1139                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);                  if (level < 0) {
1140                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */                          level = level*quant_m_2 - quant_add;
1141                            block[scan[p]] = (level >= -2048 ? level : -2048);
1142                    } else {
1143                            level = level * quant_m_2 + quant_add;
1144                            block[scan[p]] = (level <= 2047 ? level : 2047);
1145                    }
1146                    p++;
1147            } while (!last);
1148    }
1149    
1150                  if (level < -2047 || level > 2047) {  void
1151                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);  get_inter_block_mpeg(
1152                    Bitstream * bs,
1153                    int16_t * block,
1154                    int direction,
1155                    const int quant,
1156                    const uint16_t *matrix)
1157    {
1158            const uint16_t *scan = scan_tables[direction];
1159            uint32_t sum = 0;
1160            int p;
1161            int level;
1162            int run;
1163            int last;
1164    
1165            p = 0;
1166            do {
1167                    level = get_coeff(bs, &run, &last, 0, 0);
1168                    if (run == -1) {
1169                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1170                            break;
1171                  }                  }
1172                    p += run;
1173    
1174    #ifdef _DEBUG
1175                    if(p>=64)       {
1176                      DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1177                      return;
1178                    }
1179    #endif
1180    
1181                    if (level < 0) {
1182                            level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1183                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1184                    } else {
1185                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1186                            block[scan[p]] = (level <= 2047 ? level : 2047);
1187                    }
1188    
1189                    sum ^= block[scan[p]];
1190    
1191                  p++;                  p++;
1192          } while (!last);          } while (!last);
1193    
1194            /*      mismatch control */
1195            if ((sum & 1) == 0) {
1196                    block[63] ^= 1;
1197            }
1198  }  }
1199    
1200    
# Line 2041  Line 1974 
1974  };  };
1975    
1976  short const dc_threshold[] = {  short const dc_threshold[] = {
1977          21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,          26708, 29545, 29472, 26223, 30580, 29281,  8293, 29545,
1978           8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,          25632, 29285, 30313, 25701, 26144, 28530,  8301, 26740,
1979          25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,           8293, 20039,  8277, 20551,  8268, 30296, 17513, 25376,
1980          28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,          25711, 25445, 10272, 11825, 11825, 10544,  2606, 28505,
1981          30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,          29301, 29472, 26223, 30580, 29281,  8293, 26980, 29811,
1982          29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,          26994, 30050, 28532,  8306, 24936,  8307, 28532, 26400,
1983          26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,          30313,  8293, 25441, 25955, 29555, 29728,  8303, 29801,
1984          29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606           8307, 28531, 29301, 25955, 25376, 25711, 11877,    10
1985  };  };
1986    
1987  VLC const dc_lum_tab[] = {  VLC const dc_lum_tab[] = {
Legend:
Removed from v.1.44.2.15  
changed lines
  Added in v.1.53
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4