libmpeg3/video/macroblocks.c

   1 #include "mpeg3private.h"
   2 #include "mpeg3protos.h"
   3 #include "vlc.h"
   4
   5 #include <stdio.h>
   6
   7 int mpeg3video_get_macroblock_address(mpeg3_slice_t *slice)
   8 {
   9         int code, val = 0;
  10         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  11
  12         while((code = mpeg3slice_showbits(slice_buffer, 11)) < 24)
  13         {
  14 /* Is not macroblock_stuffing */
  15         if(code != 15)
  16                 {
  17 /* Is macroblock_escape */
  18                 if(code == 8)
  19                         {
  20                         val += 33;
  21                 }
  22                 else
  23                         {
  24 /*                      fprintf(stderr, "mpeg3video_get_macroblock_address: invalid macroblock_address_increment code\n"); */
  25                         slice->fault = 1;
  26                         return 1;
  27                 }
  28         }
  29
  30         mpeg3slice_flushbits(slice_buffer, 11);
  31         }
  32
  33         if(code >= 1024)
  34         {
  35         mpeg3slice_flushbit(slice_buffer);
  36         return val + 1;
  37         }
  38
  39         if(code >= 128)
  40         {
  41         code >>= 6;
  42         mpeg3slice_flushbits(slice_buffer, mpeg3_MBAtab1[code].len);
  43         return val + mpeg3_MBAtab1[code].val;
  44         }
  45
  46         code -= 24;
  47         mpeg3slice_flushbits(slice_buffer, mpeg3_MBAtab2[code].len);
  48
  49         return val + mpeg3_MBAtab2[code].val;
  50 }
  51
  52 /* macroblock_type for pictures with spatial scalability */
  53
  54 static inline int mpeg3video_getsp_imb_type(mpeg3_slice_t *slice)
  55 {
  56         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  57         unsigned int code = mpeg3slice_showbits(slice_buffer, 4);
  58         if(!code)
  59         {
  60 /*      fprintf(stderr,"mpeg3video_getsp_imb_type: invalid macroblock_type code\n"); */
  61         slice->fault = 1;
  62         return 0;
  63         }
  64
  65         mpeg3slice_flushbits(slice_buffer, mpeg3_spIMBtab[code].len);
  66         return mpeg3_spIMBtab[code].val;
  67 }
  68
  69 static inline int mpeg3video_getsp_pmb_type(mpeg3_slice_t *slice)
  70 {
  71         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  72         int code = mpeg3slice_showbits(slice_buffer, 7);
  73         if(code < 2)
  74         {
  75 /*      fprintf(stderr,"mpeg3video_getsp_pmb_type: invalid macroblock_type code\n"); */
  76         slice->fault = 1;
  77         return 0;
  78         }
  79
  80         if(code >= 16)
  81         {
  82         code >>= 3;
  83         mpeg3slice_flushbits(slice_buffer, mpeg3_spPMBtab0[code].len);
  84
  85         return mpeg3_spPMBtab0[code].val;
  86         }
  87
  88         mpeg3slice_flushbits(slice_buffer, mpeg3_spPMBtab1[code].len);
  89         return mpeg3_spPMBtab1[code].val;
  90 }
  91
  92 static inline int mpeg3video_getsp_bmb_type(mpeg3_slice_t *slice)
  93 {
  94         mpeg3_VLCtab_t *p;
  95         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  96         int code = mpeg3slice_showbits9(slice_buffer);
  97
  98         if(code >= 64)
  99                 p = &mpeg3_spBMBtab0[(code >> 5) - 2];
 100         else
 101         if(code >= 16)
 102                 p = &mpeg3_spBMBtab1[(code >> 2) - 4];
 103         else
 104         if(code >= 8)
 105                 p = &mpeg3_spBMBtab2[code - 8];
 106         else
 107         {
 108 /*      fprintf(stderr,"mpeg3video_getsp_bmb_type: invalid macroblock_type code\n"); */
 109         slice->fault = 1;
 110         return 0;
 111         }
 112
 113         mpeg3slice_flushbits(slice_buffer, p->len);
 114         return p->val;
 115 }
 116
 117 static inline int mpeg3video_get_imb_type(mpeg3_slice_t *slice)
 118 {
 119         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 120         if(mpeg3slice_getbit(slice_buffer))
 121         {
 122         return 1;
 123         }
 124
 125         if(!mpeg3slice_getbit(slice_buffer))
 126         {
 127 /*      fprintf(stderr,"mpeg3video_get_imb_type: invalid macroblock_type code\n"); */
 128         slice->fault = 1;
 129         }
 130
 131         return 17;
 132 }
 133
 134 static inline int mpeg3video_get_pmb_type(mpeg3_slice_t *slice)
 135 {
 136         int code;
 137         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 138
 139         if((code = mpeg3slice_showbits(slice_buffer, 6)) >= 8)
 140         {
 141         code >>= 3;
 142         mpeg3slice_flushbits(slice_buffer, mpeg3_PMBtab0[code].len);
 143         return mpeg3_PMBtab0[code].val;
 144         }
 145
 146         if(code == 0)
 147         {
 148 /*      fprintf(stderr,"mpeg3video_get_pmb_type: invalid macroblock_type code\n"); */
 149         slice->fault = 1;
 150         return 0;
 151         }
 152
 153         mpeg3slice_flushbits(slice_buffer, mpeg3_PMBtab1[code].len);
 154         return mpeg3_PMBtab1[code].val;
 155 }
 156
 157 static inline int mpeg3video_get_bmb_type(mpeg3_slice_t *slice)
 158 {
 159         int code;
 160         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 161
 162         if((code = mpeg3slice_showbits(slice_buffer, 6)) >= 8)
 163         {
 164         code >>= 2;
 165         mpeg3slice_flushbits(slice_buffer, mpeg3_BMBtab0[code].len);
 166         return mpeg3_BMBtab0[code].val;
 167         }
 168
 169         if(code == 0)
 170         {
 171 /*      fprintf(stderr,"mpeg3video_get_bmb_type: invalid macroblock_type code\n"); */
 172         slice->fault = 1;
 173         return 0;
 174         }
 175
 176         mpeg3slice_flushbits(slice_buffer, mpeg3_BMBtab1[code].len);
 177
 178         return mpeg3_BMBtab1[code].val;
 179 }
 180
 181 static inline int mpeg3video_get_dmb_type(mpeg3_slice_t *slice)
 182 {
 183         if(!mpeg3slice_getbit(slice->slice_buffer))
 184         {
 185 /*      fprintf(stderr,"mpeg3video_get_dmb_type: invalid macroblock_type code\n"); */
 186         slice->fault=1;
 187         }
 188
 189         return 1;
 190 }
 191
 192
 193 static inline int mpeg3video_get_snrmb_type(mpeg3_slice_t *slice)
 194 {
 195         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 196     int code = mpeg3slice_showbits(slice_buffer, 3);
 197
 198     if(code == 0)
 199     {
 200 /*      fprintf(stderr,"mpeg3video_get_snrmb_type: invalid macroblock_type code\n"); */
 201         slice->fault = 1;
 202         return 0;
 203     }
 204
 205     mpeg3slice_flushbits(slice_buffer, mpeg3_SNRMBtab[code].len);
 206     return mpeg3_SNRMBtab[code].val;
 207 }
 208
 209 int mpeg3video_get_mb_type(mpeg3_slice_t *slice, mpeg3video_t *video)
 210 {
 211         if(video->scalable_mode == SC_SNR)
 212         {
 213                 return mpeg3video_get_snrmb_type(slice);
 214         }
 215         else
 216         {
 217         switch(video->pict_type)
 218                 {
 219                 case I_TYPE: return video->pict_scal ? mpeg3video_getsp_imb_type(slice) : mpeg3video_get_imb_type(slice);
 220                 case P_TYPE: return video->pict_scal ? mpeg3video_getsp_pmb_type(slice) : mpeg3video_get_pmb_type(slice);
 221                 case B_TYPE: return video->pict_scal ? mpeg3video_getsp_bmb_type(slice) : mpeg3video_get_bmb_type(slice);
 222                 case D_TYPE: return mpeg3video_get_dmb_type(slice);
 223                 default:
 224                                 /*fprintf(stderr, "mpeg3video_getmbtype: unknown coding type\n"); */
 225                                 break;
 226 /* MPEG-1 only, not implemented */
 227                 }
 228         }
 229
 230         return 0;
 231 }
 232
 233 int mpeg3video_macroblock_modes(mpeg3_slice_t *slice,
 234                 mpeg3video_t *video,
 235                 int *pmb_type,
 236                 int *pstwtype,
 237                 int *pstwclass,
 238                 int *pmotion_type,
 239                 int *pmv_count,
 240                 int *pmv_format,
 241                 int *pdmv,
 242                 int *pmvscale,
 243                 int *pdct_type)
 244 {
 245         int mb_type;
 246         int stwtype, stwcode, stwclass;
 247         int motion_type = 0, mv_count, mv_format, dmv, mvscale;
 248         int dct_type;
 249         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 250         static unsigned char stwc_table[3][4]
 251         = { {6,3,7,4}, {2,1,5,4}, {2,5,7,4} };
 252         static unsigned char stwclass_table[9]
 253         = {0, 1, 2, 1, 1, 2, 3, 3, 4};
 254
 255 /* get macroblock_type */
 256         mb_type = mpeg3video_get_mb_type(slice, video);
 257
 258         if(slice->fault) return 1;
 259
 260 /* get spatial_temporal_weight_code */
 261         if(mb_type & MB_WEIGHT)
 262         {
 263         if(video->stwc_table_index == 0)
 264                 stwtype = 4;
 265         else
 266         {
 267                 stwcode = mpeg3slice_getbits2(slice_buffer);
 268                 stwtype = stwc_table[video->stwc_table_index - 1][stwcode];
 269         }
 270         }
 271         else
 272         stwtype = (mb_type & MB_CLASS4) ? 8 : 0;
 273
 274 /* derive spatial_temporal_weight_class (Table 7-18) */
 275         stwclass = stwclass_table[stwtype];
 276
 277 /* get frame/field motion type */
 278         if(mb_type & (MB_FORWARD | MB_BACKWARD))
 279         {
 280         if(video->pict_struct == FRAME_PICTURE)
 281                 {
 282 /* frame_motion_type */
 283                 motion_type = video->frame_pred_dct ? MC_FRAME : mpeg3slice_getbits2(slice_buffer);
 284         }
 285         else
 286                 {
 287 /* field_motion_type */
 288                 motion_type = mpeg3slice_getbits2(slice_buffer);
 289         }
 290         }
 291         else
 292         if((mb_type & MB_INTRA) && video->conceal_mv)
 293         {
 294 /* concealment motion vectors */
 295         motion_type = (video->pict_struct == FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
 296         }
 297
 298 /* derive mv_count, mv_format and dmv, (table 6-17, 6-18) */
 299         if(video->pict_struct == FRAME_PICTURE)
 300         {
 301         mv_count = (motion_type == MC_FIELD && stwclass < 2) ? 2 : 1;
 302         mv_format = (motion_type == MC_FRAME) ? MV_FRAME : MV_FIELD;
 303         }
 304         else
 305         {
 306         mv_count = (motion_type == MC_16X8) ? 2 : 1;
 307         mv_format = MV_FIELD;
 308         }
 309
 310         dmv = (motion_type == MC_DMV); /* dual prime */
 311
 312 /* field mv predictions in frame pictures have to be scaled */
 313         mvscale = ((mv_format == MV_FIELD) && (video->pict_struct == FRAME_PICTURE));
 314
 315 /* get dct_type (frame DCT / field DCT) */
 316         dct_type = (video->pict_struct == FRAME_PICTURE) &&
 317                 (!video->frame_pred_dct) &&
 318                 (mb_type & (MB_PATTERN | MB_INTRA)) ?
 319                 mpeg3slice_getbit(slice_buffer) : 0;
 320
 321 /* return values */
 322         *pmb_type = mb_type;
 323         *pstwtype = stwtype;
 324         *pstwclass = stwclass;
 325         *pmotion_type = motion_type;
 326         *pmv_count = mv_count;
 327         *pmv_format = mv_format;
 328         *pdmv = dmv;
 329         *pmvscale = mvscale;
 330         *pdct_type = dct_type;
 331         return 0;
 332 }