libmpeg3/video/motion.c

   1 #include "mpeg3private.h"
   2 #include "mpeg3protos.h"
   3 #include "vlc.h"
   4
   5 #include <stdio.h>
   6
   7
   8 /* calculate motion vector component */
   9
  10 void mpeg3video_calc_mv(int *pred, int r_size, int motion_code, int motion_r, int full_pel_vector)
  11 {
  12         int lim = 16 << r_size;
  13         int vec = full_pel_vector ? (*pred >> 1) : (*pred);
  14
  15         if(motion_code > 0)
  16         {
  17         vec += ((motion_code - 1) << r_size) + motion_r + 1;
  18         if(vec >= lim) vec -= lim + lim;
  19         }
  20         else
  21         if(motion_code < 0)
  22         {
  23         vec -= ((-motion_code - 1) << r_size) + motion_r + 1;
  24         if(vec < -lim) vec += lim + lim;
  25         }
  26         *pred = full_pel_vector ? (vec << 1) : vec;
  27 }
  28
  29
  30 /*
  31 int *dmvector, * differential motion vector *
  32 int mvx, int mvy  * decoded mv components (always in field format) *
  33 */
  34 void mpeg3video_calc_dmv(mpeg3video_t *video,
  35                 int DMV[][2],
  36                 int *dmvector,
  37                 int mvx,
  38                 int mvy)
  39 {
  40         if(video->pict_struct == FRAME_PICTURE)
  41         {
  42         if(video->topfirst)
  43                 {
  44 /* vector for prediction of top field from bottom field */
  45                 DMV[0][0] = ((mvx  + (mvx>0)) >> 1) + dmvector[0];
  46                 DMV[0][1] = ((mvy  + (mvy>0)) >> 1) + dmvector[1] - 1;
  47
  48 /* vector for prediction of bottom field from top field */
  49                 DMV[1][0] = ((3 * mvx + (mvx > 0)) >> 1) + dmvector[0];
  50                 DMV[1][1] = ((3 * mvy + (mvy > 0)) >> 1) + dmvector[1] + 1;
  51         }
  52         else
  53                 {
  54 /* vector for prediction of top field from bottom field */
  55                 DMV[0][0] = ((3 * mvx + (mvx>0)) >> 1) + dmvector[0];
  56                 DMV[0][1] = ((3 * mvy + (mvy>0)) >> 1) + dmvector[1] - 1;
  57
  58 /* vector for prediction of bottom field from top field */
  59                 DMV[1][0] = ((mvx + (mvx>0)) >> 1) + dmvector[0];
  60                 DMV[1][1] = ((mvy + (mvy>0)) >> 1) + dmvector[1] + 1;
  61         }
  62         }
  63         else
  64         {
  65 /* vector for prediction from field of opposite 'parity' */
  66         DMV[0][0] = ((mvx + (mvx > 0)) >> 1) + dmvector[0];
  67         DMV[0][1] = ((mvy + (mvy > 0)) >> 1) + dmvector[1];
  68
  69 /* correct for vertical field shift */
  70         if(video->pict_struct == TOP_FIELD)
  71                         DMV[0][1]--;
  72         else
  73                         DMV[0][1]++;
  74         }
  75 }
  76
  77 int mpeg3video_get_mv(mpeg3_slice_t *slice)
  78 {
  79         int code;
  80         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  81
  82         if(mpeg3slice_getbit(slice_buffer))
  83         {
  84         return 0;
  85         }
  86
  87         if((code = mpeg3slice_showbits9(slice_buffer)) >= 64)
  88         {
  89         code >>= 6;
  90         mpeg3slice_flushbits(slice_buffer, mpeg3_MVtab0[code].len);
  91         return mpeg3slice_getbit(slice_buffer) ? -mpeg3_MVtab0[code].val : mpeg3_MVtab0[code].val;
  92         }
  93
  94         if(code >= 24)
  95         {
  96         code >>= 3;
  97         mpeg3slice_flushbits(slice_buffer, mpeg3_MVtab1[code].len);
  98             return mpeg3slice_getbit(slice_buffer) ? -mpeg3_MVtab1[code].val : mpeg3_MVtab1[code].val;
  99         }
 100
 101         if((code -= 12) < 0)
 102         {
 103 /*      fprintf(stdout,"mpeg3video_get_mv: invalid motion_vector code\n"); */
 104         slice->fault = 1;
 105         return 1;
 106         }
 107
 108         mpeg3slice_flushbits(slice_buffer, mpeg3_MVtab2[code].len);
 109         return mpeg3slice_getbit(slice_buffer) ? -mpeg3_MVtab2[code].val : mpeg3_MVtab2[code].val;
 110 }
 111
 112 /* get differential motion vector (for dual prime prediction) */
 113
 114 int mpeg3video_get_dmv(mpeg3_slice_t *slice)
 115 {
 116         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 117         if(mpeg3slice_getbit(slice_buffer))
 118         {
 119         return mpeg3slice_getbit(slice_buffer) ? -1 : 1;
 120         }
 121         else
 122         {
 123         return 0;
 124         }
 125 }
 126
 127
 128
 129 /* get and decode motion vector and differential motion vector */
 130
 131 void mpeg3video_motion_vector(mpeg3_slice_t *slice,
 132                 mpeg3video_t *video,
 133                 int *PMV,
 134                 int *dmvector,
 135                 int h_r_size,
 136                 int v_r_size,
 137                 int dmv,
 138                 int mvscale,
 139                 int full_pel_vector)
 140 {
 141         int motion_r;
 142         int motion_code = mpeg3video_get_mv(slice);
 143         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 144
 145         if(slice->fault) return;
 146         motion_r = (h_r_size != 0 && motion_code != 0) ? mpeg3slice_getbits(slice_buffer, h_r_size) : 0;
 147
 148         mpeg3video_calc_mv(&PMV[0], h_r_size, motion_code, motion_r, full_pel_vector);
 149
 150         if(dmv) dmvector[0] = mpeg3video_get_dmv(slice);
 151
 152         motion_code = mpeg3video_get_mv(slice);
 153         if(slice->fault)  return;
 154         motion_r = (v_r_size != 0 && motion_code != 0) ? mpeg3slice_getbits(slice_buffer, v_r_size) : 0;
 155
 156 /* DIV 2 */
 157         if(mvscale) PMV[1] >>= 1;
 158
 159         mpeg3video_calc_mv(&PMV[1], v_r_size, motion_code, motion_r, full_pel_vector);
 160
 161         if(mvscale) PMV[1] <<= 1;
 162         if(dmv) dmvector[1] = mpeg3video_get_dmv(slice);
 163 }
 164
 165 int mpeg3video_motion_vectors(mpeg3_slice_t *slice,
 166                 mpeg3video_t *video,
 167                 int PMV[2][2][2],
 168                 int dmvector[2],
 169                 int mv_field_sel[2][2],
 170                 int s,
 171                 int mv_count,
 172                 int mv_format,
 173                 int h_r_size,
 174                 int v_r_size,
 175                 int dmv,
 176                 int mvscale)
 177 {
 178         int result = 0;
 179         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 180         if(mv_count == 1)
 181         {
 182                 if(mv_format == MV_FIELD && !dmv)
 183                 {
 184                         mv_field_sel[1][s] = mv_field_sel[0][s] = mpeg3slice_getbit(slice_buffer);
 185                 }
 186
 187         mpeg3video_motion_vector(slice,
 188                         video,
 189                         PMV[0][s],
 190                         dmvector,
 191                         h_r_size,
 192                         v_r_size,
 193                         dmv,
 194                         mvscale,
 195                         0);
 196         if(slice->fault) return 1;
 197
 198 /* update other motion vector predictors */
 199         PMV[1][s][0] = PMV[0][s][0];
 200         PMV[1][s][1] = PMV[0][s][1];
 201         }
 202         else
 203         {
 204         mv_field_sel[0][s] = mpeg3slice_getbit(slice_buffer);
 205         mpeg3video_motion_vector(slice,
 206                         video,
 207                         PMV[0][s],
 208                         dmvector,
 209                         h_r_size,
 210                         v_r_size,
 211                         dmv,
 212                         mvscale,
 213                         0);
 214         if(slice->fault) return 1;
 215
 216         mv_field_sel[1][s] = mpeg3slice_getbit(slice_buffer);
 217         mpeg3video_motion_vector(slice,
 218                         video,
 219                         PMV[1][s],
 220                         dmvector,
 221                         h_r_size,
 222                         v_r_size,
 223                         dmv,
 224                         mvscale,
 225                         0);
 226         if(slice->fault) return 1;
 227         }
 228         return 0;
 229 }