[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.46, Mon Mar 22 22:36:23 2004 UTC revision 1.54, Sat Apr 28 16:30:20 2007 UTC
# Line 36  Line 36 
36    
37  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
38    
39    #ifdef _DEBUG
40    # include "../motion/estimation.h"
41    # include "../motion/motion_inlines.h"
42    # include <assert.h>
43    #endif
44    
45    
46  #define LEVELOFFSET 32  #define LEVELOFFSET 32
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];
51  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
52    
# Line 197  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 210  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 453  Line 458 
458          return bits;          return bits;
459  }  }
460    
461  static int iDQtab[5] = {  static const 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 574  Line 579 
579  #endif  #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 */
# Line 608  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 694  Line 720 
720                  scan_tables[2] : scan_tables[0];                  scan_tables[2] : scan_tables[0];
721          int bits;          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)
725                  hence is interpolated from forward & backward frames                  hence is interpolated from forward & backward frames
# Line 743  Line 768 
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);          bits = BitstreamPos(bs);
791          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
# Line 958  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 970  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 982  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          if (mode < 3) {                  cache <<= skip[mode];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
1043    
1044                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
1045    
1046                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1047                          goto error;                          goto error;
# Line 1014  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    
# Line 1056  Line 1096 
1096                          break;                          break;
1097                  }                  }
1098                  coeff += run;                  coeff += run;
1099    
1100    #ifdef _DEBUG
1101                    if(coeff>=64) {
1102                      DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1103                      return;
1104                    }
1105    #endif
1106    
1107                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1108    
1109                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
# Line 1072  Line 1120 
1120  }  }
1121    
1122  void  void
1123  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1124                    Bitstream * bs,
1125                                  int16_t * block,                                  int16_t * block,
1126                                  int direction)                  int direction,
1127                    const int quant,
1128                    const uint16_t *matrix)
1129  {  {
1130    
1131          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1132            const uint16_t quant_m_2 = quant << 1;
1133            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1134          int p;          int p;
1135          int level;          int level;
1136          int run;          int run;
# Line 1092  Line 1145 
1145                  }                  }
1146                  p += run;                  p += run;
1147    
1148                  block[scan[p]] = level;  #ifdef _DEBUG
1149                    if(p>=64)       {
1150                      DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1151                      return;
1152                    }
1153    #endif
1154    
1155                    if (level < 0) {
1156                            level = level*quant_m_2 - quant_add;
1157                            block[scan[p]] = (level >= -2048 ? level : -2048);
1158                    } else {
1159                            level = level * quant_m_2 + quant_add;
1160                            block[scan[p]] = (level <= 2047 ? level : 2047);
1161                    }
1162                    p++;
1163            } while (!last);
1164    }
1165    
1166                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);  void
1167                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */  get_inter_block_mpeg(
1168                    Bitstream * bs,
1169                    int16_t * block,
1170                    int direction,
1171                    const int quant,
1172                    const uint16_t *matrix)
1173    {
1174            const uint16_t *scan = scan_tables[direction];
1175            uint32_t sum = 0;
1176            int p;
1177            int level;
1178            int run;
1179            int last;
1180    
1181                  if (level < -2047 || level > 2047) {          p = 0;
1182                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);          do {
1183                    level = get_coeff(bs, &run, &last, 0, 0);
1184                    if (run == -1) {
1185                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1186                            break;
1187                  }                  }
1188                    p += run;
1189    
1190    #ifdef _DEBUG
1191                    if(p>=64)       {
1192                      DPRINTF(XVID_DEBUG_ERROR,"error: overflow in coefficient index\n");
1193                      return;
1194                    }
1195    #endif
1196    
1197                    if (level < 0) {
1198                            level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1199                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1200                    } else {
1201                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1202                            block[scan[p]] = (level <= 2047 ? level : 2047);
1203                    }
1204    
1205                    sum ^= block[scan[p]];
1206    
1207                  p++;                  p++;
1208          } while (!last);          } while (!last);
1209    
1210            /*      mismatch control */
1211            if ((sum & 1) == 0) {
1212                    block[63] ^= 1;
1213            }
1214  }  }
1215    
1216    
# Line 1882  Line 1990 
1990  };  };
1991    
1992  short const dc_threshold[] = {  short const dc_threshold[] = {
1993          21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,          26708, 29545, 29472, 26223, 30580, 29281,  8293, 29545,
1994           8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,          25632, 29285, 30313, 25701, 26144, 28530,  8301, 26740,
1995          25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,           8293, 20039,  8277, 20551,  8268, 30296, 17513, 25376,
1996          28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,          25711, 25445, 10272, 11825, 11825, 10544,  2606, 28505,
1997          30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,          29301, 29472, 26223, 30580, 29281,  8293, 26980, 29811,
1998          29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,          26994, 30050, 28532,  8306, 24936,  8307, 28532, 26400,
1999          26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,          30313,  8293, 25441, 25955, 29555, 29728,  8303, 29801,
2000          29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606           8307, 28531, 29301, 25955, 25376, 25711, 11877,    10
2001  };  };
2002    
2003  VLC const dc_lum_tab[] = {  VLC const dc_lum_tab[] = {
Legend:
Removed from v.1.46  
changed lines
  Added in v.1.54
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4