Dirac - A Video Codec

Created by the British Broadcasting Corporation.


motion.h
Go to the documentation of this file.
1 /* ***** BEGIN LICENSE BLOCK *****
2 *
3 * $Id: motion.h,v 1.30 2008/10/01 01:26:47 asuraparaju Exp $ $Name: Dirac_1_0_2 $
4 *
5 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
6 *
7 * The contents of this file are subject to the Mozilla Public License
8 * Version 1.1 (the "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 * http://www.mozilla.org/MPL/
11 *
12 * Software distributed under the License is distributed on an "AS IS" basis,
13 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
14 * the specific language governing rights and limitations under the License.
15 *
16 * The Original Code is BBC Research and Development code.
17 *
18 * The Initial Developer of the Original Code is the British Broadcasting
19 * Corporation.
20 * Portions created by the Initial Developer are Copyright (C) 2004.
21 * All Rights Reserved.
22 *
23 * Contributor(s): Thomas Davies (Original Author),
24 * Chris Bowley,
25 * Tim Borer
26 *
27 * Alternatively, the contents of this file may be used under the terms of
28 * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
29 * Public License Version 2.1 (the "LGPL"), in which case the provisions of
30 * the GPL or the LGPL are applicable instead of those above. If you wish to
31 * allow use of your version of this file only under the terms of the either
32 * the GPL or LGPL and not to allow others to use your version of this file
33 * under the MPL, indicate your decision by deleting the provisions above
34 * and replace them with the notice and other provisions required by the GPL
35 * or LGPL. If you do not delete the provisions above, a recipient may use
36 * your version of this file under the terms of any one of the MPL, the GPL
37 * or the LGPL.
38 * ***** END LICENSE BLOCK ***** */
39 
40 #include <libdirac_common/common.h>
41 #include <algorithm>
42 #ifndef _MOTION_H
43 #define _MOTION_H
44 
45 namespace dirac
46 {
48  //classes and functions for motion estimation and compensation//
50 
51  //classes
52 
55 
57  template <class T>
59  {
60  public:
61 
63  MotionVector<T>(T a, T b) : x(a), y(b) {};
65  MotionVector<T>() : x(0), y(0) {};
67  MotionVector<T>(T a) : x(a), y(a) {};
68 
70  inline MotionVector<T> operator+(const MotionVector<T>& argument) const;
71 
73  inline MotionVector<T> operator-(const MotionVector<T>& argument) const;
74 
76  inline MotionVector<T> operator*(const float argument) const;
77 
79  inline MotionVector<T> operator*(const int argument) const;
80 
82  inline MotionVector<T> operator<<(const int argument) const;
83 
85  inline MotionVector<T> operator>>(const int argument) const;
86 
88  T& operator[](const int pos){return ( ( pos==0) ? x : y );}
89 
91  const T& operator[](const int pos) const {return ( ( pos==0) ? x : y );}
92 
93 
95  T x,y;
96 
97  };
98 
99 
100  template <class T>
102  {
103  MotionVector<T> temp;
104  temp.x = x + argument.x;
105  temp.y = y + argument.y;
106 
107  return temp;
108  }
109 
110  template <class T>
112  {
113  MotionVector<T> temp;
114  temp.x = x-argument.x;
115  temp.y = y-argument.y;
116 
117  return temp;
118  }
119 
120  template <class T>
121  inline MotionVector<T> MotionVector<T>::operator*(const float argument) const
122  {
123  MotionVector<T> temp;
124  temp.x = x*argument;
125  temp.y = y*argument;
126 
127  return temp;
128  }
129 
130  template <class T>
131  inline MotionVector<T> MotionVector<T>::operator*(const int argument) const
132  {
133  MotionVector<T> temp;
134  temp.x = x*argument;
135  temp.y = y*argument;
136 
137  return temp;
138  }
139 
140  template <class T>
141  inline MotionVector<T> MotionVector<T>::operator<<(const int argument) const
142  {
143  MotionVector<T> temp;
144  temp.x = x<<argument;
145  temp.y = y<<argument;
146 
147  return temp;
148  }
149 
150  template <class T>
151  inline MotionVector<T> MotionVector<T>::operator>>(const int argument) const
152  {
153  MotionVector<T> temp;
154  temp.x = x>>argument;
155  temp.y = y>>argument;
156 
157  return temp;
158  }
159 
161  template <class T>
162  std::ostream & operator<< (std::ostream & stream, MotionVector<T> & mv)
163  {
164  stream << mv.x << " " << mv.y;
165 
166  return stream;
167  }
168 
170  template <class T>
171  std::istream & operator>> (std::istream & stream, MotionVector<T> & mv)
172  {
173  stream >> mv.x;
174  stream >> mv.y;
175 
176  return stream;
177  }
178 
181 
184 
187 
190 
193  {
194  public:
197  SAD(0.0),
198  mvcost(0.0),
199  total(0.0){}
200 
201  void SetTotal( const float lambda ){total = SAD + lambda*mvcost;}
202 
204  float SAD;
205 
207  float mvcost;
208 
210  float total;
211  };
212 
213 
215 
219  class MvData
220  {
221  public:
223 
228  MvData( const PicturePredParams& predparams , const int num_refs);
229 
231  ~MvData();
232 
235 
238 
240  MvArray& Vectors(const int ref_id){return *( m_vectors[ref_id] );}
241 
243  const MvArray& Vectors(const int ref_id) const {return *( m_vectors[ref_id] );}
244 
246  MvArray& GlobalMotionVectors(const int ref_id){return *( m_gm_vectors[ref_id] );}
247 
249  const MvArray& GlobalMotionVectors(const int ref_id) const {return *( m_gm_vectors[ref_id] );}
250 
252  TwoDArray<ValueType>& DC(CompSort cs){return *( m_dc[cs] );}
253 
255  const TwoDArray<ValueType>& DC(CompSort cs) const {return *( m_dc[cs] );}
256 
258  const OneDArray< TwoDArray<ValueType>* >& DC() const {return m_dc;}
259 
262 
264  const TwoDArray<PredMode>& Mode() const {return m_modes;}
265 
268 
270  const TwoDArray<int>& SBSplit() const{return m_sb_split;}
271 
273  OneDArray<float>& GlobalMotionParameters(const int ref_id) { return *( m_gm_params[ref_id] ); }
274 
276  const OneDArray<float>& GlobalMotionParameters(const int ref_id) const { return *( m_gm_params[ref_id] ); }
277 
278  protected:
279  // A local copy of the picture prediction parameters
281 
282  // Initialises the arrays of data
283  void InitMvData();
284 
285  // The motion vectors
287 
288  // The global motion vectors
290 
291  // The block modes
293 
294  // The DC values
296 
297  // The SB split levels
299 
300  // Global motion model parameters
302 
303 // // Number of reference frames
304 // unsigned int m_num_refs;
305  };
306 
308 
313  class MEData: public MvData
314  {
315  public:
316 
318 
323  MEData( const PicturePredParams& predparams , const int num_refs = 2);
324 
326  ~MEData();
327 
329  void DropRef( int ref_index );
330 
332  TwoDArray<MvCostData>& PredCosts(const int ref_id){ return *( m_pred_costs[ref_id] ); }
333 
335  const TwoDArray<MvCostData>& PredCosts(const int ref_id) const { return *( m_pred_costs[ref_id] ); }
336 
339 
341  const TwoDArray<float>& IntraCosts() const { return m_intra_costs; }
342 
345 
348 
351 
353  const TwoDArray<float>& SBCosts() const { return m_SB_costs; }
354 
356  float IntraBlockRatio() const {return m_intra_block_ratio; }
357 
359  void SetIntraBlockRatio(const float r){ m_intra_block_ratio = r; }
360 
362  void SetLambdaMap( const int num_refs , const float lambda );
363 
365  void SetLambdaMap( const int level , const TwoDArray<float>& l_map , const float wt );
366 
368  const TwoDArray<float>& LambdaMap() const { return m_lambda_map; }
369 
371  TwoDArray<int>& GlobalMotionInliers(const int ref_id){ return *( m_inliers[ref_id] ); }
372 
374  const TwoDArray<int>& GlobalMotionInliers(const int ref_id) const { return *( m_inliers[ref_id] ); }
375 
377  friend std::ostream &operator<< (std::ostream & stream, MEData & me_data);
378 
380  friend std::istream &operator>> (std::istream & stream, MEData & me_data);
381 
382  private:
383  // Initialises the arrays of data
384  void InitMEData();
385 
386  // Finds transitions in the motion vectors
387  void FindTransitions( TwoDArray<bool>& trans_map , const int ref_num );
388 
389  // The costs of predicting each block, for each reference
391 
392  // The costs of predicting each block by DC
394 
395  // The costs of predicting each block bidirectionally
397 
398  // The costs for each macroblock as a whole
400 
401  // A map of the lambda values to use
403 
404  // Global motion inliers
406 
407  // Intra block ratio
409 
410  };
411 
412  //motion estimation and coding stuff
413 
415  int Median( const int val1, const int val2, const int val3);
416 
418  MVector MvMedian(const MVector& mv1,const MVector& mv2,const MVector& mv3);
419 
420 
422  int Median(const std::vector<int>& val_list);
423 
425  MVector MvMedian(const std::vector<MVector>& vect_list);
426 
428  MVector MvMean(const MVector& mv1, const MVector& mv2);
429 
431  inline int Norm2(const MVector& mv){//L^2 norm of a motion vector
432  return mv.x*mv.x+mv.y*mv.y;
433  }
434 
436  inline int Norm1(const MVector& mv){//L^1 norm of a motion vector
437  return abs(mv.x)+abs(mv.y);
438  }
439 
441  unsigned int GetUMean(std::vector<unsigned int>& values);
442 
444  int GetSMean(std::vector<int>& values);
445 
446 } // namespace dirac
447 
448 #endif

© 2004 British Broadcasting Corporation. Dirac code licensed under the Mozilla Public License (MPL) Version 1.1.
HTML documentation generated by Dimitri van Heesch's excellent Doxygen tool.