cinelerra-5.1/libzmpeg3/video/macroblocks.C

   1 #include "../libzmpeg3.h"
   2
   3 int zslice_decoder_t::
   4 get_macroblock_address()
   5 {
   6   int zcode, val = 0;
   7   while( (zcode = slice_buffer->show_bits(11)) < 24 ) {
   8     if( zcode != 15 ) {     /* Is not macroblock_stuffing */
   9       if( zcode != 8 ) {    /* Is not macroblock_escape */
  10 //zerrs("invalid macroblock_address_increment code %d\n",zcode);
  11         fault = 1;
  12         return 1;
  13       }
  14       val += 33;
  15     }
  16     slice_buffer->flush_bits(11);
  17   }
  18
  19   if( zcode >= 1024 ) {
  20     slice_buffer->flush_bit();
  21     return val + 1;
  22   }
  23
  24   if( zcode >= 128 ) {
  25     zcode >>= 6;
  26     slice_buffer->flush_bits(MBAtab1[zcode].len);
  27     return val + MBAtab1[zcode].val;
  28   }
  29
  30   zcode -= 24;
  31   slice_buffer->flush_bits(MBAtab2[zcode].len);
  32
  33   return val + MBAtab2[zcode].val;
  34 }
  35
  36 /* macroblock_type for pictures with spatial scalability */
  37 inline int zslice_decoder_t::
  38 getsp_imb_type()
  39 {
  40   uint32_t zcode = slice_buffer->show_bits(4);
  41   if( !zcode ) {
  42 //zerrs("invalid macroblock_type code %d\n",zcode);
  43     fault = 1;
  44     return 0;
  45   }
  46
  47   slice_buffer->flush_bits(spIMBtab[zcode].len);
  48   return spIMBtab[zcode].val;
  49 }
  50
  51 inline int zslice_decoder_t::
  52 getsp_pmb_type()
  53 {
  54   int zcode = slice_buffer->show_bits(7);
  55   if( zcode < 2 ) {
  56 //  zerrs("invalid macroblock_type code %d\n",zcode);
  57     fault = 1;
  58     return 0;
  59   }
  60
  61   if( zcode >= 16 ) {
  62     zcode >>= 3;
  63     slice_buffer->flush_bits(spPMBtab0[zcode].len);
  64
  65     return spPMBtab0[zcode].val;
  66   }
  67
  68   slice_buffer->flush_bits(spPMBtab1[zcode].len);
  69   return spPMBtab1[zcode].val;
  70 }
  71
  72 inline int zslice_decoder_t::
  73 getsp_bmb_type()
  74 {
  75   VLCtab_t *p;
  76   int zcode = slice_buffer->show_bits(9);
  77
  78   if( zcode >= 64 )
  79     p = &spBMBtab0[(zcode >> 5) - 2];
  80   else if( zcode >= 16 )
  81     p = &spBMBtab1[(zcode >> 2) - 4];
  82   else if( zcode >= 8 )
  83     p = &spBMBtab2[zcode - 8];
  84   else {
  85 //zerrs("invalid macroblock_type code %d\n",zcode);
  86     fault = 1;
  87     return 0;
  88   }
  89
  90  slice_buffer->flush_bits(p->len);
  91  return p->val;
  92 }
  93
  94 inline int zslice_decoder_t::
  95 get_imb_type()
  96 {
  97   if( slice_buffer->get_bit() ) return 1;
  98   if( !slice_buffer->get_bit() ) {
  99 //zerr("invalid macroblock_type code\n");
 100     fault = 1;
 101     return 0;
 102   }
 103
 104   return 17;
 105 }
 106
 107 inline int zslice_decoder_t::
 108 get_pmb_type()
 109 {
 110   int zcode;
 111   if( (zcode = slice_buffer->show_bits(6)) >= 8 ) {
 112     zcode >>= 3;
 113     slice_buffer->flush_bits(PMBtab0[zcode].len);
 114     return PMBtab0[zcode].val;
 115   }
 116
 117   if( zcode == 0 ) {
 118 //zerrs("invalid macroblock_type code %d\n",zcode);
 119     fault = 1;
 120     return 0;
 121   }
 122
 123   slice_buffer->flush_bits(PMBtab1[zcode].len);
 124   return PMBtab1[zcode].val;
 125 }
 126
 127 inline int zslice_decoder_t::
 128 get_bmb_type()
 129 {
 130   int zcode;
 131   if( (zcode = slice_buffer->show_bits(6)) >= 8 ) {
 132     zcode >>= 2;
 133     slice_buffer->flush_bits(BMBtab0[zcode].len);
 134     return BMBtab0[zcode].val;
 135   }
 136
 137   if( zcode == 0 ) {
 138 //zerrs("invalid macroblock_type code %d\n",zcode);
 139     fault = 1;
 140     return 0;
 141   }
 142
 143   slice_buffer->flush_bits(BMBtab1[zcode].len);
 144   return BMBtab1[zcode].val;
 145 }
 146
 147 inline int zslice_decoder_t::
 148 get_dmb_type()
 149 {
 150   if( !slice_buffer->get_bit() ) {
 151 //zerr("invalid macroblock_type code\n");
 152     fault=1;
 153     return 0;
 154   }
 155
 156   return 1;
 157 }
 158
 159
 160 inline int zslice_decoder_t::
 161 get_snrmb_type()
 162 {
 163   int zcode = slice_buffer->show_bits(3);
 164   if( zcode == 0 ) {
 165 //zerrs("invalid macroblock_type code %d\n",zcode);
 166     fault = 1;
 167     return 0;
 168   }
 169   slice_buffer->flush_bits(SNRMBtab[zcode].len);
 170   return SNRMBtab[zcode].val;
 171 }
 172
 173 int zslice_decoder_t::
 174 get_mb_type()
 175 {
 176   if( video->scalable_mode == sc_SNR )
 177     return get_snrmb_type();
 178   switch(video->pict_type) {
 179   case video_t::pic_type_I:
 180     return video->pict_scal ? getsp_imb_type() : get_imb_type();
 181   case video_t::pic_type_P:
 182     return video->pict_scal ? getsp_pmb_type() : get_pmb_type();
 183   case video_t::pic_type_B:
 184     return video->pict_scal ? getsp_bmb_type() : get_bmb_type();
 185   case video_t::pic_type_D:
 186     return get_dmb_type();
 187   default: /* MPEG-1 only, not implemented */
 188 //zerrs("unknown coding type %d\n",video->pict_type);
 189     break;
 190   }
 191
 192   return 0;
 193 }
 194
 195 int zslice_decoder_t::
 196 macroblock_modes(int *pmb_type, int *pstwtype, int *pstwclass, int *pmotion_type,
 197     int *pmv_count, int *pmv_format, int *pdmv, int *pmvscale, int *pdct_type)
 198 {
 199   int mb_type;
 200   int stwtype, stwcode, stwclass;
 201   int motion_type, mv_count, mv_format, dmv, mvscale;
 202   int dct_type;
 203   static uint8_t stwc_table[3][4] = { {6,3,7,4}, {2,1,5,4}, {2,5,7,4} };
 204   static uint8_t stwclass_table[9] = {0, 1, 2, 1, 1, 2, 3, 3, 4};
 205   motion_type = 0;
 206
 207   /* get macroblock_type */
 208   mb_type = get_mb_type();
 209   if( fault ) return 1;
 210
 211   /* get spatial_temporal_weight_code */
 212   if( mb_type & mb_WEIGHT ) {
 213     if( video->stwc_table_index == 0 )
 214       stwtype = 4;
 215     else {
 216       stwcode = slice_buffer->get_bits(2);
 217       stwtype = stwc_table[video->stwc_table_index - 1][stwcode];
 218     }
 219   }
 220   else
 221     stwtype = (mb_type & mb_CLASS4) ? 8 : 0;
 222
 223   /* derive spatial_temporal_weight_class (Table 7-18) */
 224   stwclass = stwclass_table[stwtype];
 225
 226   /* get frame/field motion type */
 227   if( mb_type & (mb_FORWARD | mb_BACKWARD) ) {
 228     if( video->pict_struct == video_t::pics_FRAME_PICTURE ) {
 229       /* frame_motion_type */
 230       motion_type = video->frame_pred_dct ?
 231         mc_FRAME : slice_buffer->get_bits(2);
 232     }
 233     else {
 234      /* field_motion_type */
 235      motion_type = slice_buffer->get_bits(2);
 236     }
 237   }
 238   else if( (mb_type & mb_INTRA) && video->conceal_mv ) {
 239     /* concealment motion vectors */
 240     motion_type = video->pict_struct == video_t::pics_FRAME_PICTURE ?
 241       mc_FRAME : mc_FIELD;
 242   }
 243
 244   /* derive mv_count, mv_format and dmv, (table 6-17, 6-18) */
 245   if( video->pict_struct == video_t::pics_FRAME_PICTURE ) {
 246     mv_count = (motion_type == mc_FIELD && stwclass < 2) ? 2 : 1;
 247     mv_format = (motion_type == mc_FRAME) ?  mv_FRAME : mv_FIELD;
 248   }
 249   else {
 250     mv_count = (motion_type == mc_16X8) ? 2 : 1;
 251     mv_format = mv_FIELD;
 252   }
 253
 254   dmv = motion_type == mc_DMV ? 1 : 0; /* dual prime */
 255
 256   /* field mv predictions in frame pictures have to be scaled */
 257   mvscale = mv_format == mv_FIELD &&
 258     video->pict_struct == video_t::pics_FRAME_PICTURE ? 1 : 0;
 259
 260   /* get dct_type (frame DCT / field DCT) */
 261   dct_type = video->pict_struct == video_t::pics_FRAME_PICTURE &&
 262     !video->frame_pred_dct && (mb_type & (mb_PATTERN | mb_INTRA)) ?
 263        slice_buffer->get_bit() : 0;
 264
 265   /* return values */
 266   *pmb_type = mb_type;
 267   *pstwtype = stwtype;
 268   *pstwclass = stwclass;
 269   *pmotion_type = motion_type;
 270   *pmv_count = mv_count;
 271   *pmv_format = mv_format;
 272   *pdmv = dmv;
 273   *pmvscale = mvscale;
 274   *pdct_type = dct_type;
 275   return 0;
 276 }