[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.52.2.2, Thu Jun 28 15:00:11 2007 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          /* code motion vector(s) if motion is local  */          /* code motion vector(s) if motion is local  */
576          if (!pMB->mcsel)          if (!pMB->mcsel)
577                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {                  for (i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++) {
578                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].x, frame->fcode);
579                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode, pStat);                          CodeVector(bs, pMB->pmvs[i].y, frame->fcode);
580                  }                  }
581    
582          bits = BitstreamPos(bs);          bits = BitstreamPos(bs);
583    
584          /* code block coeffs */          /* code block coeffs */
585          for (i = 0; i < 6; i++)          for (i = 0; i < 6; i++)
586                  if (pMB->cbp & (1 << (5 - i)))                  if (pMB->cbp & (1 << (5 - i))) {
                 {  
587                          const uint16_t *scan_table =                          const uint16_t *scan_table =
588                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
589                                  scan_tables[2] : scan_tables[0];                                  scan_tables[2] : scan_tables[0];
590    
 #ifdef BIGLUT  
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_table, 0);  
 #else  
591                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
 #endif  
592                  }                  }
593    
594          bits = BitstreamPos(bs) - bits;          bits = BitstreamPos(bs) - bits;
# Line 768  Line 606 
606          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)
607                          BitstreamPutBit(bs, 0); /* not_coded */                          BitstreamPutBit(bs, 0); /* not_coded */
608    
609            if (frame->vop_flags & XVID_VOP_GREYSCALE) {
610                    pMB->cbp &= 0x3C;               /* keep only bits 5-2 */
611                    qcoeff[4*64+0]=0;               /* for INTRA DC value is saved */
612                    qcoeff[5*64+0]=0;
613            }
614    
615          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
616                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
617          else          else
# Line 852  Line 696 
696          const uint16_t *scan_table =          const uint16_t *scan_table =
697                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?                  frame->vop_flags & XVID_VOP_ALTERNATESCAN ?
698                  scan_tables[2] : scan_tables[0];                  scan_tables[2] : scan_tables[0];
699            int bits;
700    
701  /*      ------------------------------------------------------------------  /*      ------------------------------------------------------------------
702                  when a block is skipped it is decoded DIRECT(0,0)                  when a block is skipped it is decoded DIRECT(0,0)
# Line 893  Line 737 
737                          BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */                          BitstreamPutBit(bs, 0 /*mb->field_pred*/); /* field ME not implemented */
738    
739                          /* write field prediction references */                          /* write field prediction references */
740                  /*      if (mb->field_pred) {  #if 0 /* Remove the #if once field_pred is supported */
741                            if (mb->field_pred) {
742                                  BitstreamPutBit(bs, mb->field_for_top);                                  BitstreamPutBit(bs, mb->field_for_top);
743                                  BitstreamPutBit(bs, mb->field_for_bot);                                  BitstreamPutBit(bs, mb->field_for_bot);
744                          }*/                          }
745    #endif
746                  }                  }
747          }          }
748    
749    
750          switch (mb->mode) {          switch (mb->mode) {
751                  case MODE_INTERPOLATE:                  case MODE_INTERPOLATE:
752                          CodeVector(bs, mb->pmvs[1].x, vcode, pStat); /* forward vector of interpolate mode */                          CodeVector(bs, mb->pmvs[1].x, vcode); /* forward vector of interpolate mode */
753                          CodeVector(bs, mb->pmvs[1].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[1].y, vcode);
754                  case MODE_BACKWARD:                  case MODE_BACKWARD:
755                          vcode = bcode;                          vcode = bcode;
756                  case MODE_FORWARD:                  case MODE_FORWARD:
757                          CodeVector(bs, mb->pmvs[0].x, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].x, vcode);
758                          CodeVector(bs, mb->pmvs[0].y, vcode, pStat);                          CodeVector(bs, mb->pmvs[0].y, vcode);
759                          break;                          break;
760                  case MODE_DIRECT:                  case MODE_DIRECT:
761                          CodeVector(bs, mb->pmvs[3].x, 1, pStat);        /* fcode is always 1 for delta vector */                          CodeVector(bs, mb->pmvs[3].x, 1);       /* fcode is always 1 for delta vector */
762                          CodeVector(bs, mb->pmvs[3].y, 1, pStat);        /* prediction is always (0,0) */                          CodeVector(bs, mb->pmvs[3].y, 1);       /* prediction is always (0,0) */
763                  default: break;                  default: break;
764          }          }
765    
766            bits = BitstreamPos(bs);
767          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
768                  if (mb->cbp & (1 << (5 - i))) {                  if (mb->cbp & (1 << (5 - i))) {
769  #ifdef BIGLUT                          CodeCoeffInter(bs, &qcoeff[i * 64], scan_table);
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);  
 #else  
                         CodeCoeffInter(bs, &qcoeff[i * 64], scan_tables[0]);  
 #endif  
770                  }                  }
771          }          }
772            pStat->iTextBits += BitstreamPos(bs) - bits;
773  }  }
774    
775    
# Line 1117  Line 961 
961    
962  }  }
963    
964    #define GET_BITS(cache, n) ((cache)>>(32-(n)))
965    
966  static __inline int  static __inline int
967  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
968                    int *run,                    int *run,
# Line 1129  Line 975 
975          int32_t level;          int32_t level;
976          REVERSE_EVENT *reverse_event;          REVERSE_EVENT *reverse_event;
977    
978            uint32_t cache = BitstreamShowBits(bs, 32);
979    
980          if (short_video_header)         /* inter-VLCs will be used for both intra and inter blocks */          if (short_video_header)         /* inter-VLCs will be used for both intra and inter blocks */
981                  intra = 0;                  intra = 0;
982    
983          if (BitstreamShowBits(bs, 7) != ESCAPE) {          if (GET_BITS(cache, 7) != ESCAPE) {
984                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
985    
986                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
987                          goto error;                          goto error;
# Line 1141  Line 989 
989                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
990                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
991    
992                  BitstreamSkip(bs, reverse_event->len);                  /* Don't forget to update the bitstream position */
993                    BitstreamSkip(bs, reverse_event->len+1);
994    
995                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
996          }          }
997    
998          BitstreamSkip(bs, 7);          /* flush 7bits of cache */
999            cache <<= 7;
1000    
1001          if (short_video_header) {          if (short_video_header) {
1002                  /* escape mode 4 - H.263 type, only used if short_video_header = 1  */                  /* escape mode 4 - H.263 type, only used if short_video_header = 1  */
1003                  *last = BitstreamGetBit(bs);                  *last =  GET_BITS(cache, 1);
1004                  *run = BitstreamGetBits(bs, 6);                  *run  = (GET_BITS(cache, 7) &0x3f);
1005                  level = BitstreamGetBits(bs, 8);                  level = (GET_BITS(cache, 15)&0xff);
1006    
1007                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1008                          DPRINTF(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);
1009    
1010                    /* We've "eaten" 22 bits */
1011                    BitstreamSkip(bs, 22);
1012    
1013                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1014          }          }
1015    
1016          mode = BitstreamShowBits(bs, 2);          if ((mode = GET_BITS(cache, 2)) < 3) {
1017                    const int skip[3] = {1, 1, 2};
1018                    cache <<= skip[mode];
1019    
1020          if (mode < 3) {                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
   
                 reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];  
1021    
1022                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1023                          goto error;                          goto error;
# Line 1173  Line 1025 
1025                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1026                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1027    
1028                  BitstreamSkip(bs, reverse_event->len);                  if (mode < 2) {
1029                            /* first escape mode, level is offset */
                 if (mode < 2)                   /* first escape mode, level is offset */  
1030                          level += max_level[intra][*last][*run];                          level += max_level[intra][*last][*run];
1031                  else                                    /* second escape mode, run is offset */                  } else {
1032                            /* second escape mode, run is offset */
1033                          *run += max_run[intra][*last][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1034                    }
1035    
1036                    /* Update bitstream position */
1037                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1038    
1039                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1040          }          }
1041    
1042          /* third escape mode - fixed length codes */          /* third escape mode - fixed length codes */
1043          BitstreamSkip(bs, 2);          cache <<= 2;
1044          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1045          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1046          BitstreamSkip(bs, 1);           /* marker */          level = (GET_BITS(cache, 20)&0xfff);
1047          level = BitstreamGetBits(bs, 12);  
1048          BitstreamSkip(bs, 1);           /* marker */          /* Update bitstream position */
1049            BitstreamSkip(bs, 30);
1050    
1051          return (level << 20) >> 20;          return (level << 20) >> 20;
1052    
1053    error:    error:
1054          *run = VLC_ERROR;          *run = 64;
1055          return 0;          return 0;
1056  }  }
1057    
# Line 1210  Line 1067 
1067    
1068          do {          do {
1069                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1070                  if (run == -1) {                  coeff += run;
1071                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");                  if (coeff & ~63) {
1072                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1073                          break;                          break;
1074                  }                  }
1075                  coeff += run;  
1076                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1077    
1078                  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 1089 
1089  }  }
1090    
1091  void  void
1092  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1093                    Bitstream * bs,
1094                                  int16_t * block,                                  int16_t * block,
1095                                  int direction)                  int direction,
1096                    const int quant,
1097                    const uint16_t *matrix)
1098  {  {
1099    
1100          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1101            const uint16_t quant_m_2 = quant << 1;
1102            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1103          int p;          int p;
1104          int level;          int level;
1105          int run;          int run;
# Line 1245  Line 1108 
1108          p = 0;          p = 0;
1109          do {          do {
1110                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1111                  if (run == -1) {                  p += run;
1112                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");                  if (p & ~63) {
1113                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1114                          break;                          break;
1115                  }                  }
                 p += run;  
1116    
1117                  block[scan[p]] = level;                  if (level < 0) {
1118                            level = level*quant_m_2 - quant_add;
1119                            block[scan[p]] = (level >= -2048 ? level : -2048);
1120                    } else {
1121                            level = level * quant_m_2 + quant_add;
1122                            block[scan[p]] = (level <= 2047 ? level : 2047);
1123                    }
1124                    p++;
1125            } while (!last);
1126    }
1127    
1128    void
1129    get_inter_block_mpeg(
1130                    Bitstream * bs,
1131                    int16_t * block,
1132                    int direction,
1133                    const int quant,
1134                    const uint16_t *matrix)
1135    {
1136            const uint16_t *scan = scan_tables[direction];
1137            uint32_t sum = 0;
1138            int p;
1139            int level;
1140            int run;
1141            int last;
1142    
1143                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);          p = 0;
1144                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */          do {
1145                    level = get_coeff(bs, &run, &last, 0, 0);
1146                    p += run;
1147                    if (p & ~63) {
1148                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1149                            break;
1150                    }
1151    
1152                  if (level < -2047 || level > 2047) {                  if (level < 0) {
1153                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);                          level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1154                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1155                    } else {
1156                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1157                            block[scan[p]] = (level <= 2047 ? level : 2047);
1158                  }                  }
1159    
1160                    sum ^= block[scan[p]];
1161    
1162                  p++;                  p++;
1163          } while (!last);          } while (!last);
1164    
1165            /*      mismatch control */
1166            if ((sum & 1) == 0) {
1167                    block[63] ^= 1;
1168            }
1169  }  }
1170    
1171    
# Line 2041  Line 1945 
1945  };  };
1946    
1947  short const dc_threshold[] = {  short const dc_threshold[] = {
1948          21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,          26708, 29545, 29472, 26223, 30580, 29281,  8293, 29545,
1949           8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,          25632, 29285, 30313, 25701, 26144, 28530,  8301, 26740,
1950          25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,           8293, 20039,  8277, 20551,  8268, 30296, 17513, 25376,
1951          28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,          25711, 25445, 10272, 11825, 11825, 10544,  2606, 28505,
1952          30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,          29301, 29472, 26223, 30580, 29281,  8293, 26980, 29811,
1953          29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,          26994, 30050, 28532,  8306, 24936,  8307, 28532, 26400,
1954          26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,          30313,  8293, 25441, 25955, 29555, 29728,  8303, 29801,
1955          29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606           8307, 28531, 29301, 25955, 25376, 25711, 11877,    10
1956  };  };
1957    
1958  VLC const dc_lum_tab[] = {  VLC const dc_lum_tab[] = {
Legend:
Removed from v.1.44.2.15  
changed lines
  Added in v.1.52.2.2
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4