workbench/classes/datatypes/mpegvideo/mpegmotionvector.c

   1
   2 /*
   3 **
   4 **  $VER: mpegmotionvector.c 1.11 (30.10.97)
   5 **  mpegvideo.datatype 1.11
   6 **
   7 **  This file handles computation of the forward/backward
   8 **  motion vectors.
   9 **
  10 **  Written 1996/1997 by Roland 'Gizzy' Mainz
  11 **
  12 */
  13
  14 /* project includes */
  15 #include "mpegvideo.h"
  16 #include "mpegproto.h"
  17 #include "mpegutil.h"
  18
  19
  20 /*
  21  *--------------------------------------------------------------
  22  *
  23  * ComputeVector --
  24  *
  25  *    Computes motion vector given parameters previously parsed
  26  *      and reconstructed.
  27  *
  28  * Results:
  29  *      Reconstructed motion vector info is put into recon_* parameters
  30  *      passed to this function. Also updated previous motion vector
  31  *      information.
  32  *
  33  * Side effects:
  34  *      None.
  35  *
  36  *--------------------------------------------------------------
  37  */
  38
  39
  40 #define ComputeVector( recon_right_ptr, recon_down_ptr, recon_right_prev, recon_down_prev, f, full_pel_vector, motion_h_code, motion_v_code, motion_h_r, motion_v_r ) \
  41 {                                                                               \
  42     int comp_h_r, comp_v_r;                                                     \
  43     int right_little, right_big, down_little,  down_big;                        \
  44     int max, min, new_vector;                                                   \
  45                                                                                 \
  46     /* The following procedure for the reconstruction of motion vectors         \
  47      * is a direct and simple implementation of the instructions given          \
  48      * in the mpeg December 1991 standard draft.                                \
  49      */                                                                         \
  50                                                                                 \
  51     comp_h_r = ((f == 1) || (motion_h_code == 0))?(0):(f - 1 - motion_h_r);     \
  52     comp_v_r = ((f == 1) || (motion_v_code == 0))?(0):(f - 1 - motion_v_r);     \
  53                                                                                 \
  54     right_little = motion_h_code * f;                                           \
  55                                                                                 \
  56     if( right_little == 0 )                                                     \
  57     {                                                                           \
  58       right_big = 0;                                                            \
  59     }                                                                           \
  60     else                                                                        \
  61     {                                                                           \
  62       if( right_little > 0 )                                                    \
  63       {                                                                         \
  64         right_little = right_little - comp_h_r;                                 \
  65         right_big    = right_little - (f << 5);                                 \
  66       }                                                                         \
  67       else                                                                      \
  68       {                                                                         \
  69         right_little = right_little + comp_h_r;                                 \
  70         right_big    = right_little + (f << 5);                                 \
  71       }                                                                         \
  72     }                                                                           \
  73                                                                                 \
  74     down_little = motion_v_code * f;                                            \
  75                                                                                 \
  76     if( down_little == 0 )                                                      \
  77     {                                                                           \
  78       down_big = 0;                                                             \
  79     }                                                                           \
  80     else                                                                        \
  81     {                                                                           \
  82       if( down_little > 0 )                                                     \
  83       {                                                                         \
  84         down_little = down_little - comp_v_r;                                   \
  85         down_big    = down_little - (f << 5);                                   \
  86       }                                                                         \
  87       else                                                                      \
  88       {                                                                         \
  89         down_little = down_little + comp_v_r;                                   \
  90         down_big    = down_little + (f << 5);                                   \
  91       }                                                                         \
  92     }                                                                           \
  93                                                                                 \
  94     max = (f << 4) - 1;                                                         \
  95     min = -(f << 4);                                                            \
  96                                                                                 \
  97     new_vector = recon_right_prev + right_little;                               \
  98                                                                                 \
  99     if( (new_vector <= max) && (new_vector >= min) )                            \
 100     {                                                                           \
 101       *recon_right_ptr = recon_right_prev + right_little; /* just new_vector */ \
 102     }                                                                           \
 103     else                                                                        \
 104     {                                                                           \
 105       *recon_right_ptr = recon_right_prev + right_big;                          \
 106     }                                                                           \
 107                                                                                 \
 108     recon_right_prev = *recon_right_ptr;                                        \
 109                                                                                 \
 110     if( full_pel_vector )                                                       \
 111     {                                                                           \
 112       *recon_right_ptr = *recon_right_ptr << 1;                                 \
 113     }                                                                           \
 114                                                                                 \
 115     new_vector = recon_down_prev + down_little;                                 \
 116                                                                                 \
 117     if( (new_vector <= max) && (new_vector >= min) )                            \
 118     {                                                                           \
 119       *recon_down_ptr = recon_down_prev + down_little; /* just new_vector */    \
 120     }                                                                           \
 121     else                                                                        \
 122     {                                                                           \
 123       *recon_down_ptr = recon_down_prev + down_big;                             \
 124     }                                                                           \
 125     recon_down_prev = *recon_down_ptr;                                          \
 126                                                                                 \
 127     if( full_pel_vector )                                                       \
 128     {                                                                           \
 129       *recon_down_ptr = *recon_down_ptr << 1;                                   \
 130     }                                                                           \
 131 }
 132
 133
 134 /*
 135  *--------------------------------------------------------------
 136  *
 137  * ComputeForwVector --
 138  *
 139  *    Computes forward motion vector by calling ComputeVector
 140  *      with appropriate parameters.
 141  *
 142  * Results:
 143  *    Reconstructed motion vector placed in recon_right_for_ptr and
 144  *      recon_down_for_ptr.
 145  *
 146  * Side effects:
 147  *      None.
 148  *
 149  *--------------------------------------------------------------
 150  */
 151
 152
 153 void ComputeForwVector( struct MPEGVideoInstData *mvid, int *recon_right_for_ptr, int *recon_down_for_ptr )
 154 {
 155   Pict       *picture;
 156   Macroblock *mblock;
 157
 158   picture = (&(curVidStream -> picture));
 159   mblock  = (&(curVidStream -> mblock));
 160
 161   ComputeVector( recon_right_for_ptr, recon_down_for_ptr,
 162                  (mblock -> recon_right_for_prev),
 163                  (mblock -> recon_down_for_prev),
 164                  (picture -> forw_f), (picture -> full_pel_forw_vector),
 165                  (mblock -> motion_h_forw_code), (mblock -> motion_v_forw_code),
 166                  (mblock -> motion_h_forw_r), (mblock -> motion_v_forw_r) );
 167 }
 168
 169
 170 /*
 171  *--------------------------------------------------------------
 172  *
 173  * ComputeBackVector --
 174  *
 175  *    Computes backward motion vector by calling ComputeVector
 176  *      with appropriate parameters.
 177  *
 178  * Results:
 179  *    Reconstructed motion vector placed in recon_right_back_ptr and
 180  *      recon_down_back_ptr.
 181  *
 182  * Side effects:
 183  *      None.
 184  *
 185  *--------------------------------------------------------------
 186  */
 187
 188
 189 void ComputeBackVector( struct MPEGVideoInstData *mvid, int *recon_right_back_ptr, int *recon_down_back_ptr )
 190 {
 191   Pict       *picture;
 192   Macroblock *mblock;
 193
 194   picture = (&(curVidStream -> picture));
 195   mblock  = (&(curVidStream -> mblock));
 196
 197   ComputeVector( recon_right_back_ptr, recon_down_back_ptr,
 198                  (mblock -> recon_right_back_prev),
 199                  (mblock -> recon_down_back_prev),
 200                  (picture -> back_f), (picture -> full_pel_back_vector),
 201                  (mblock -> motion_h_back_code), (mblock -> motion_v_back_code),
 202                  (mblock -> motion_h_back_r), (mblock -> motion_v_back_r) );
 203
 204 }
 205
 206