[svn] / branches / release-1_1-branch / xvidcore / src / bitstream / mbcoding.c Repository:
ViewVC logotype

Diff of /branches/release-1_1-branch/xvidcore/src/bitstream/mbcoding.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1382, Mon Mar 22 22:36:25 2004 UTC revision 1537, Sun Aug 22 13:16:12 2004 UTC
# Line 19  Line 19 
19   *  along with this program ; if not, write to the Free Software   *  along with this program ; if not, write to the Free Software
20   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21   *   *
22   * $Id: mbcoding.c,v 1.46 2004-03-22 22:36:23 edgomez Exp $   * $Id: mbcoding.c,v 1.48 2004-08-22 13:16:12 edgomez Exp $
23   *   *
24   ****************************************************************************/   ****************************************************************************/
25    
# Line 38  Line 38 
38    
39  #define LEVELOFFSET 32  #define LEVELOFFSET 32
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];
44  static VLC coeff_VLC[2][2][64][64];  static VLC coeff_VLC[2][2][64][64];
45    
# Line 453  Line 455 
455          return bits;          return bits;
456  }  }
457    
458  static int iDQtab[5] = {  static const int iDQtab[5] = {
459          1, 0, -1 /* no change */, 2, 3          1, 0, -1 /* no change */, 2, 3
460  };  };
461  #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]  #define DQ_VALUE2INDEX(value)  iDQtab[(value)+2]
# Line 958  Line 960 
960    
961  }  }
962    
963    #define GET_BITS(cache, n) ((cache)>>(32-(n)))
964    
965  static __inline int  static __inline int
966  get_coeff(Bitstream * bs,  get_coeff(Bitstream * bs,
967                    int *run,                    int *run,
# Line 970  Line 974 
974          int32_t level;          int32_t level;
975          REVERSE_EVENT *reverse_event;          REVERSE_EVENT *reverse_event;
976    
977            uint32_t cache = BitstreamShowBits(bs, 32);
978    
979          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 */
980                  intra = 0;                  intra = 0;
981    
982          if (BitstreamShowBits(bs, 7) != ESCAPE) {          if (GET_BITS(cache, 7) != ESCAPE) {
983                  reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
984    
985                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
986                          goto error;                          goto error;
# Line 982  Line 988 
988                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
989                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
990    
991                  BitstreamSkip(bs, reverse_event->len);                  /* Don't forget to update the bitstream position */
992                    BitstreamSkip(bs, reverse_event->len+1);
993    
994                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
995          }          }
996    
997          BitstreamSkip(bs, 7);          /* flush 7bits of cache */
998            cache <<= 7;
999    
1000          if (short_video_header) {          if (short_video_header) {
1001                  /* 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  */
1002                  *last = BitstreamGetBit(bs);                  *last =  GET_BITS(cache, 1);
1003                  *run = BitstreamGetBits(bs, 6);                  *run  = (GET_BITS(cache, 7) &0x3f);
1004                  level = BitstreamGetBits(bs, 8);                  level = (GET_BITS(cache, 15)&0xff);
1005    
1006                  if (level == 0 || level == 128)                  if (level == 0 || level == 128)
1007                          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);
1008    
1009                    /* We've "eaten" 22 bits */
1010                    BitstreamSkip(bs, 22);
1011    
1012                  return (level << 24) >> 24;                  return (level << 24) >> 24;
1013          }          }
1014    
1015          mode = BitstreamShowBits(bs, 2);          if ((mode = GET_BITS(cache, 2)) < 3) {
1016                    const int skip[3] = {1, 1, 2};
1017                    cache <<= skip[mode];
1018    
1019          if (mode < 3) {                  reverse_event = &DCT3D[intra][GET_BITS(cache, 12)];
                 BitstreamSkip(bs, (mode == 2) ? 2 : 1);  
   
                 reverse_event = &DCT3D[intra][BitstreamShowBits(bs, 12)];  
1020    
1021                  if ((level = reverse_event->event.level) == 0)                  if ((level = reverse_event->event.level) == 0)
1022                          goto error;                          goto error;
# Line 1014  Line 1024 
1024                  *last = reverse_event->event.last;                  *last = reverse_event->event.last;
1025                  *run  = reverse_event->event.run;                  *run  = reverse_event->event.run;
1026    
1027                  BitstreamSkip(bs, reverse_event->len);                  if (mode < 2) {
1028                            /* first escape mode, level is offset */
                 if (mode < 2)                   /* first escape mode, level is offset */  
1029                          level += max_level[intra][*last][*run];                          level += max_level[intra][*last][*run];
1030                  else                                    /* second escape mode, run is offset */                  } else {
1031                            /* second escape mode, run is offset */
1032                          *run += max_run[intra][*last][level] + 1;                          *run += max_run[intra][*last][level] + 1;
1033                    }
1034    
1035                    /* Update bitstream position */
1036                    BitstreamSkip(bs, 7 + skip[mode] + reverse_event->len + 1);
1037    
1038                  return BitstreamGetBits(bs, 1) ? -level : level;                  return (GET_BITS(cache, reverse_event->len+1)&0x01) ? -level : level;
1039          }          }
1040    
1041          /* third escape mode - fixed length codes */          /* third escape mode - fixed length codes */
1042          BitstreamSkip(bs, 2);          cache <<= 2;
1043          *last = BitstreamGetBits(bs, 1);          *last =  GET_BITS(cache, 1);
1044          *run = BitstreamGetBits(bs, 6);          *run  = (GET_BITS(cache, 7)&0x3f);
1045          BitstreamSkip(bs, 1);           /* marker */          level = (GET_BITS(cache, 20)&0xfff);
1046          level = BitstreamGetBits(bs, 12);  
1047          BitstreamSkip(bs, 1);           /* marker */          /* Update bitstream position */
1048            BitstreamSkip(bs, 30);
1049    
1050          return (level << 20) >> 20;          return (level << 20) >> 20;
1051    
# Line 1072  Line 1087 
1087  }  }
1088    
1089  void  void
1090  get_inter_block(Bitstream * bs,  get_inter_block_h263(
1091                    Bitstream * bs,
1092                                  int16_t * block,                                  int16_t * block,
1093                                  int direction)                  int direction,
1094                    const int quant,
1095                    const uint16_t *matrix)
1096  {  {
1097    
1098          const uint16_t *scan = scan_tables[direction];          const uint16_t *scan = scan_tables[direction];
1099            const uint16_t quant_m_2 = quant << 1;
1100            const uint16_t quant_add = (quant & 1 ? quant : quant - 1);
1101          int p;          int p;
1102          int level;          int level;
1103          int run;          int run;
# Line 1092  Line 1112 
1112                  }                  }
1113                  p += run;                  p += run;
1114    
1115                  block[scan[p]] = level;                  if (level < 0) {
1116                            level = level*quant_m_2 - quant_add;
1117                            block[scan[p]] = (level >= -2048 ? level : -2048);
1118                    } else {
1119                            level = level * quant_m_2 + quant_add;
1120                            block[scan[p]] = (level <= 2047 ? level : 2047);
1121                    }
1122                    p++;
1123            } while (!last);
1124    }
1125    
1126    void
1127    get_inter_block_mpeg(
1128                    Bitstream * bs,
1129                    int16_t * block,
1130                    int direction,
1131                    const int quant,
1132                    const uint16_t *matrix)
1133    {
1134            const uint16_t *scan = scan_tables[direction];
1135            uint32_t sum = 0;
1136            int p;
1137            int level;
1138            int run;
1139            int last;
1140    
1141                  DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i\n", scan[p], level);          p = 0;
1142                  /* DPRINTF(XVID_DEBUG_COEFF,"block[%i] %i %08x\n", scan[p], level, BitstreamShowBits(bs, 32)); */          do {
1143                    level = get_coeff(bs, &run, &last, 0, 0);
1144                    if (run == -1) {
1145                            DPRINTF(XVID_DEBUG_ERROR,"fatal: invalid run");
1146                            break;
1147                    }
1148                    p += run;
1149    
1150                  if (level < -2047 || level > 2047) {                  if (level < 0) {
1151                          DPRINTF(XVID_DEBUG_ERROR,"warning: inter overflow %i\n", level);                          level = ((2 * -level + 1) * matrix[scan[p]] * quant) >> 4;
1152                            block[scan[p]] = (level <= 2048 ? -level : -2048);
1153                    } else {
1154                            level = ((2 *  level + 1) * matrix[scan[p]] * quant) >> 4;
1155                            block[scan[p]] = (level <= 2047 ? level : 2047);
1156                  }                  }
1157    
1158                    sum ^= block[scan[p]];
1159    
1160                  p++;                  p++;
1161          } while (!last);          } while (!last);
1162    
1163            /*      mismatch control */
1164            if ((sum & 1) == 0) {
1165                    block[63] ^= 1;
1166            }
1167  }  }
1168    
1169    
Legend:
Removed from v.1382  
changed lines
  Added in v.1537
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4