[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.2.1, Sun Aug 22 13:15:15 2004 UTC revision 1.60, Fri Dec 31 11:47:44 2010 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  /* Initialized once during xvid_global call
# Line 199  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 212  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 576  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    #if 0 /* #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 610  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 696  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 745  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 960  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 972  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 984  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 1016  Line 1049 
1049                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1050                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1051    
1052                  BitstreamSkip(bs, reverse_event->len);                  if (mode < 2) {
1053                            /* first escape mode, level is offset */
                 if (mode < 2)                   /* first escape mode, level is offset */  
1054                          level += max_level[intra][*last][*run];                          level += max_level[intra][*last][*run];
1055                  else                                    /* second escape mode, run is offset */                  } else {
1056                            /* second escape mode, run is offset */
1057                          *run += max_run[intra][*last][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1058                    }
1059    
1060                    /* Update bitstream position */
1061                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1062    
1063                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1064          }          }
1065    
1066          /* third escape mode - fixed length codes */          /* third escape mode - fixed length codes */
1067          BitstreamSkip(bs, 2);          cache <<= 2;
1068          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1069          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1070          BitstreamSkip(bs, 1);           /* marker */          level = (GET_BITS(cache, 20)&0xfff);
1071          level = BitstreamGetBits(bs, 12);  
1072          BitstreamSkip(bs, 1);           /* marker */          /* Update bitstream position */
1073            BitstreamSkip(bs, 30);
1074    
1075          return (level << 20) >> 20;          return (level << 20) >> 20;
1076    
1077    error:    error:
1078          *run = VLC_ERROR;          *run = 64;
1079          return 0;          return 0;
1080  }  }
1081    
# Line 1049  Line 1087 
1087  {  {
1088    
1089          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1090          int level, run, last;          int level, run, last = 0;
1091    
1092          do {          do {
1093                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
1094                  if (run == -1) {                  coeff += run;
1095                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");                  if (coeff & ~63) {
1096                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1097                          break;                          break;
1098                  }                  }
1099                  coeff += run;  
1100                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
1101    
1102                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[coeff], level);
# Line 1074  Line 1113 
1113  }  }
1114    
1115  void  void
1116  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1117                    Bitstream * bs,
1118                                  int16_t * block,                                  int16_t * block,
1119                                  int direction)                  int direction,
1120                    const int quant,
1121                    const uint16_t *matrix)
1122  {  {
1123    
1124          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1125            const uint16_t quant_m_2 = quant << 1;
1126            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1127          int p;          int p;
1128          int level;          int level;
1129          int run;          int run;
1130          int last;          int last = 0;
1131    
1132          p = 0;          p = 0;
1133          do {          do {
1134                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
1135                  if (run == -1) {                  p += run;
1136                          DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");                  if (p & ~63) {
1137                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1138                          break;                          break;
1139                  }                  }
                 p += run;  
1140    
1141                  block[scan[p]] = level;                  if (level < 0) {
1142                            level = level*quant_m_2 - quant_add;
1143                            block[scan[p]] = (level >= -2048 ? level : -2048);
1144                    } else {
1145                            level = level * quant_m_2 + quant_add;
1146                            block[scan[p]] = (level <= 2047 ? level : 2047);
1147                    }
1148                    p++;
1149            } while (!last);
1150    }
1151    
1152                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);  void
1153                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */  get_inter_block_mpeg(
1154                    Bitstream * bs,
1155                    int16_t * block,
1156                    int direction,
1157                    const int quant,
1158                    const uint16_t *matrix)
1159    {
1160            const uint16_t *scan = scan_tables[direction];
1161            uint32_t sum = 0;
1162            int p;
1163            int level;
1164            int run;
1165            int last = 0;
1166    
1167                  if (level < -2047 || level > 2047) {          p = 0;
1168                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);          do {
1169                    level = get_coeff(bs, &run, &last, 0, 0);
1170                    p += run;
1171                    if (p & ~63) {
1172                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run or index");
1173                            break;
1174                    }
1175    
1176                    if (level < 0) {
1177                            level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1178                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1179                    } else {
1180                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1181                            block[scan[p]] = (level <= 2047 ? level : 2047);
1182                  }                  }
1183    
1184                    sum ^= block[scan[p]];
1185    
1186                  p++;                  p++;
1187          } while (!last);          } while (!last);
1188    
1189            /*      mismatch control */
1190            if ((sum & 1) == 0) {
1191                    block[63] ^= 1;
1192            }
1193  }  }
1194    
1195    
# Line 1884  Line 1969 
1969  };  };
1970    
1971  short const dc_threshold[] = {  short const dc_threshold[] = {
1972          21514, 26984,  8307, 28531, 29798, 24951, 25970, 26912,          26708, 29545, 29472, 26223, 30580, 29281,  8293, 29545,
1973           8307, 25956, 26994, 25974,  8292, 29286, 28015, 29728,          25632, 29285, 30313, 25701, 26144, 28530,  8301, 26740,
1974          25960, 18208, 21838, 18208, 19536, 22560, 26998,  8260,           8293, 20039,  8277, 20551,  8268, 30296, 17513, 25376,
1975          28515, 25956,  8291, 25640, 30309, 27749, 11817, 22794,          25711, 25445, 10272, 11825, 11828, 10544,  2606, 28505,
1976          30063,  8306, 28531, 29798, 24951, 25970, 25632, 29545,          29301, 29472, 26223, 30580, 29281,  8293, 26980, 29811,
1977          29300, 25193, 29813, 29295, 26656, 29537, 29728,  8303,          26994, 30050, 28532,  8306, 24936,  8307, 28532, 26400,
1978          26983, 25974, 24864, 25443, 29541,  8307, 28532, 26912,          30313,  8293, 25441, 25955, 29555, 29728,  8303, 29801,
1979          29556, 29472, 30063, 25458,  8293, 28515, 25956,  2606           8307, 28531, 29301, 25955, 25376, 25711, 11877,    10
1980  };  };
1981    
1982  VLC const dc_lum_tab[] = {  VLC const dc_lum_tab[] = {

Legend:
Removed from v.1.46.2.1  
changed lines
  Added in v.1.60

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4