[Dirac-commits] compress/libdirac_common common.cpp, 1.73, 1.74 common.h, 1.77, 1.78 mot_comp.cpp, 1.44, 1.45 mot_comp.h, 1.21, 1.22 video_format_defaults.cpp, 1.32, 1.33

[Anuradha S. <asu...@us...>]

Update of /cvsroot/dirac/compress/libdirac_common
In directory sc8-pr-cvs12.sourceforge.net:/tmp/cvs-serv19546/libdirac_common

Modified Files:
	common.cpp common.h mot_comp.cpp mot_comp.h 
	video_format_defaults.cpp 
Log Message:
Separated off picture prediction parameters.


Author: Thomas Davies <tho...@bb...>


Index: mot_comp.h
===================================================================
RCS file: /cvsroot/dirac/compress/libdirac_common/mot_comp.h,v
retrieving revision 1.21
retrieving revision 1.22
diff -C2 -d -r1.21 -r1.22
*** mot_comp.h	14 Aug 2008 02:30:50 -0000	1.21
--- mot_comp.h	27 Aug 2008 00:17:11 -0000	1.22
***************
*** 61,70 ****
      class Picture;
  
!  
!     //! Abstract Motion compensator class. 
      /*!
!         Motion compensator class, for doing motion compensation with two 
          references and overlapped blocks, using raised-cosine roll-off.
!         This is an abstract class. It must be sub-classed and the 
          BlockPixelPred must be defined in the sub-classes.
      */
--- 61,69 ----
      class Picture;
  
!     //! Abstract Motion compensator class.
      /*!
!         Motion compensator class, for doing motion compensation with two
          references and overlapped blocks, using raised-cosine roll-off.
!         This is an abstract class. It must be sub-classed and the
          BlockPixelPred must be defined in the sub-classes.
      */
***************
*** 77,81 ****
              Constructor initialises using codec parameters.
           */
!         MotionCompensator( const CodecParams &cp );
          //! Destructor
          virtual ~MotionCompensator();
--- 76,80 ----
              Constructor initialises using codec parameters.
           */
!         MotionCompensator( const PicturePredParams &ppp );
          //! Destructor
          virtual ~MotionCompensator();
***************
*** 84,90 ****
          /*!
              Static function that motion compensates a picture. It uses the
!             MV precision value in the CodecParams to instantiate the 
              appropriate MotionCompensation sub-class.
!             \param    cp        Encoder/decoder parameters
              \param    direction whether we're subtracting or adding
              \param    mv_data    the motion vector data
--- 83,89 ----
          /*!
              Static function that motion compensates a picture. It uses the
!             MV precision value in the PicturePredParams to instantiate the
              appropriate MotionCompensation sub-class.
!             \param    ppp        Picture prediction parameters
              \param    direction whether we're subtracting or adding
              \param    mv_data    the motion vector data
***************
*** 92,98 ****
              \param    refptr     Array of pointers to reference pictures.
           */
!         static void CompensatePicture ( const CodecParams &cp, 
!                                       const AddOrSub direction , 
!                                       const MvData& mv_data, 
                                        Picture* in_pic ,
  				      Picture* refptr[2]);
--- 91,97 ----
              \param    refptr     Array of pointers to reference pictures.
           */
!         static void CompensatePicture ( const PicturePredParams &ppp,
!                                       const AddOrSub direction ,
!                                       const MvData& mv_data,
                                        Picture* in_pic ,
  				      Picture* refptr[2]);
***************
*** 100,104 ****
          //! Compensate a picture
          /*!
!             Perform motion compensated addition/subtraction on a picture using 
              parameters
              \param    direction whether we're subtracting or adding
--- 99,103 ----
          //! Compensate a picture
          /*!
!             Perform motion compensated addition/subtraction on a picture using
              parameters
              \param    direction whether we're subtracting or adding
***************
*** 107,113 ****
              \param    refsptr    Array of pointers to reference pictures.
           */
!         void CompensatePicture( const AddOrSub direction , 
                                const MvData& mv_data,
!                               Picture* in_pic , 
                                Picture* refsptr[2] );
  
--- 106,112 ----
              \param    refsptr    Array of pointers to reference pictures.
           */
!         void CompensatePicture( const AddOrSub direction ,
                                const MvData& mv_data,
!                               Picture* in_pic ,
                                Picture* refsptr[2] );
  
***************
*** 121,126 ****
  
          //! Motion-compensate a component
!         void CompensateComponent( Picture* pic , 
!                                   Picture* refsptr[2] , 
                                    const MvData& mv_data , const CompSort cs);
  
--- 120,125 ----
  
          //! Motion-compensate a component
!         void CompensateComponent( Picture* pic ,
!                                   Picture* refsptr[2] ,
                                    const MvData& mv_data , const CompSort cs);
  
***************
*** 135,142 ****
  
          //! Calculates a weighting block.
!         /*! 
!             Params defines the block parameters so the relevant weighting 
!             arrays can be created.  FullX and FullY refer to whether the 
!             weight should be adjusted for the edge of an image.  eg. 1D 
              Weighting shapes in x direction
                FullX true        FullX false
--- 134,141 ----
  
          //! Calculates a weighting block.
!         /*!
!             Params defines the block parameters so the relevant weighting
!             arrays can be created.  FullX and FullY refer to whether the
!             weight should be adjusted for the edge of an image.  eg. 1D
              Weighting shapes in x direction
                FullX true        FullX false
***************
*** 154,174 ****
          void FlipY(const TwoDArray<ValueType>& Original, TwoDArray<ValueType>& Flipped);
  
!         virtual void CompensateBlock( TwoDArray<ValueType>& pic_data , 
!                               const ImageCoords& pos , 
                                const ImageCoords &orig_pic_size,
                                PredMode block_mode,
                                ValueType dc,
!                               const PicArray& ref1up_data , 
                                const MVector& mv1 ,
!                               const PicArray& ref2up_data , 
                                const MVector& mv2 ,
                                const TwoDArray<ValueType>& Weights );
          //! Predict pixels in a block. Pure virtual. SubClasses need to define it
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data , 
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data , 
                                const MVector& mv) = 0;
!      
          // Adjust the block value based on reference weights
          /*
--- 153,173 ----
          void FlipY(const TwoDArray<ValueType>& Original, TwoDArray<ValueType>& Flipped);
  
!         virtual void CompensateBlock( TwoDArray<ValueType>& pic_data ,
!                               const ImageCoords& pos ,
                                const ImageCoords &orig_pic_size,
                                PredMode block_mode,
                                ValueType dc,
!                               const PicArray& ref1up_data ,
                                const MVector& mv1 ,
!                               const PicArray& ref2up_data ,
                                const MVector& mv2 ,
                                const TwoDArray<ValueType>& Weights );
          //! Predict pixels in a block. Pure virtual. SubClasses need to define it
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data ,
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data ,
                                const MVector& mv) = 0;
! 
          // Adjust the block value based on reference weights
          /*
***************
*** 180,190 ****
          * block_mode  - Block prediction mode.
          *
!         * On return, val1_block will contain the weight reference weight 
          * adjusted block values
          */
!         void AdjustBlockByRefWeights (TwoDArray<ValueType>& val1_block, 
!                                       TwoDArray<ValueType>& val2_block, 
                                        PredMode block_mode);
!      
          // Adjust the block value based spatial weighting matrix
          /*
--- 179,189 ----
          * block_mode  - Block prediction mode.
          *
!         * On return, val1_block will contain the weight reference weight
          * adjusted block values
          */
!         void AdjustBlockByRefWeights (TwoDArray<ValueType>& val1_block,
!                                       TwoDArray<ValueType>& val2_block,
                                        PredMode block_mode);
! 
          // Adjust the block value based spatial weighting matrix
          /*
***************
*** 194,198 ****
          * wt_array  - spatial weighting matrix
          *
!         * On return, val_block will contain the spatial weight adjusted block 
          * values
          */
--- 193,197 ----
          * wt_array  - spatial weighting matrix
          *
!         * On return, val_block will contain the spatial weight adjusted block
          * values
          */
***************
*** 201,215 ****
                                            const TwoDArray<ValueType> &wt_array);
      protected:
!         //variables    
  
          //! The codec parameters
!         CodecParams m_cparams;
  
          //! The chroma format
          ChromaFormat m_cformat;
!         bool luma_or_chroma;    //true if we're doing luma, false if we're coding chroma  
!         
          // A marker saying whether we're doing MC addition or subtraction
!         AddOrSub m_add_or_sub;                    
  
          // Block information
--- 200,214 ----
                                            const TwoDArray<ValueType> &wt_array);
      protected:
!         //variables
  
          //! The codec parameters
!         PicturePredParams m_predparams;
  
          //! The chroma format
          ChromaFormat m_cformat;
!         bool luma_or_chroma;    //true if we're doing luma, false if we're coding chroma
! 
          // A marker saying whether we're doing MC addition or subtraction
!         AddOrSub m_add_or_sub;
  
          // Block information
***************
*** 223,227 ****
      };
  
!     //! Pixel precision Motion compensator class. 
      class MotionCompensator_Pixel : public MotionCompensator
      {
--- 222,226 ----
      };
  
!     //! Pixel precision Motion compensator class.
      class MotionCompensator_Pixel : public MotionCompensator
      {
***************
*** 232,247 ****
              Constructor initialises using codec parameters.
           */
!         MotionCompensator_Pixel (const CodecParams &cp);
  
      private:
!         //! Motion-compensate a block. 
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data , 
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data , 
                                const MVector& mv);
      };
  
!     //! Half Pixel precision Motion compensator class. 
      class MotionCompensator_HalfPixel : public MotionCompensator
      {
--- 231,246 ----
              Constructor initialises using codec parameters.
           */
!         MotionCompensator_Pixel (const PicturePredParams &ppp);
  
      private:
!         //! Motion-compensate a block.
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data ,
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data ,
                                const MVector& mv);
      };
  
!     //! Half Pixel precision Motion compensator class.
      class MotionCompensator_HalfPixel : public MotionCompensator
      {
***************
*** 251,265 ****
              Constructor initialises using codec parameters.
           */
!         MotionCompensator_HalfPixel (const CodecParams &cp);
      private:
!         //! Motion-compensate a block. 
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data , 
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data , 
                                const MVector& mv);
      };
  
!     //! Quarter Pixel precision Motion compensator class. 
      class MotionCompensator_QuarterPixel : public MotionCompensator
      {
--- 250,264 ----
              Constructor initialises using codec parameters.
           */
!         MotionCompensator_HalfPixel (const PicturePredParams &ppp);
      private:
!         //! Motion-compensate a block.
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data ,
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data ,
                                const MVector& mv);
      };
  
!     //! Quarter Pixel precision Motion compensator class.
      class MotionCompensator_QuarterPixel : public MotionCompensator
      {
***************
*** 269,283 ****
              Constructor initialises using codec parameters.
           */
!         MotionCompensator_QuarterPixel (const CodecParams &cp);
      private:
!         //! Motion-compensate a block. 
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data , 
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data , 
                                const MVector& mv);
      };
  
!     //! Eighth Pixel precision Motion compensator class. 
      class MotionCompensator_EighthPixel : public MotionCompensator
      {
--- 268,282 ----
              Constructor initialises using codec parameters.
           */
!         MotionCompensator_QuarterPixel (const PicturePredParams &ppp);
      private:
!         //! Motion-compensate a block.
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data ,
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data ,
                                const MVector& mv);
      };
  
!     //! Eighth Pixel precision Motion compensator class.
      class MotionCompensator_EighthPixel : public MotionCompensator
      {
***************
*** 287,297 ****
              Constructor initialises using codec parameters.
           */
!         MotionCompensator_EighthPixel (const CodecParams &cp);
      private:
!         //! Motion-compensate a block. 
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data , 
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data , 
                                const MVector& mv);
      };
--- 286,296 ----
              Constructor initialises using codec parameters.
           */
!         MotionCompensator_EighthPixel (const PicturePredParams &ppp);
      private:
!         //! Motion-compensate a block.
!         virtual void BlockPixelPred( TwoDArray<ValueType>& block_data ,
                                const ImageCoords& pos,
                                const ImageCoords &orig_pic_size,
!                               const PicArray& refup_data ,
                                const MVector& mv);
      };

Index: common.cpp
===================================================================
RCS file: /cvsroot/dirac/compress/libdirac_common/common.cpp,v
retrieving revision 1.73
retrieving revision 1.74
diff -C2 -d -r1.73 -r1.74
*** common.cpp	14 Aug 2008 01:04:26 -0000	1.73
--- common.cpp	27 Aug 2008 00:17:10 -0000	1.74
***************
*** 205,224 ****
  }
  
! // Codec params functions
! 
! CodecParams::CodecParams(const VideoFormat &vd, PictureType ftype, unsigned int num_refs, bool set_defaults):
!     m_x_num_mb(0),
!     m_y_num_mb(0),
!     m_x_num_blocks(0),
!     m_y_num_blocks(0),
!     m_lbparams(3),
!     m_cbparams(3),
!     m_video_format(vd)
! {
!     if (set_defaults)
!         SetDefaultCodecParameters(*this, ftype, num_refs);
! }
! 
! void CodecParams::SetBlockSizes(const OLBParams& olbparams , const ChromaFormat cformat)
  {
      //given the raw overlapped block parameters, set the modified internal parameters to
--- 205,209 ----
  }
  
! void PicturePredParams::SetBlockSizes(const OLBParams& olbparams , const ChromaFormat cformat)
  {
      //given the raw overlapped block parameters, set the modified internal parameters to
***************
*** 345,348 ****
--- 330,343 ----
  }
  
+ 
+ // Codec params functions
+ 
+ CodecParams::CodecParams(const VideoFormat &vd, PictureType ftype, unsigned int num_refs, bool set_defaults):
+    m_video_format(vd)
+ {
+     if (set_defaults)
+         SetDefaultCodecParameters(*this, ftype, num_refs);
+ }
+ 
  WltFilter CodecParams::TransformFilter (unsigned int wf_idx)
  {

Index: common.h
===================================================================
RCS file: /cvsroot/dirac/compress/libdirac_common/common.h,v
retrieving revision 1.77
retrieving revision 1.78
diff -C2 -d -r1.77 -r1.78
*** common.h	14 Aug 2008 00:51:08 -0000	1.77
--- common.h	27 Aug 2008 00:17:10 -0000	1.78
***************
*** 963,966 ****
--- 963,1095 ----
          unsigned int m_vblocks;
      };
+ 
+     //! Structure to hold motion parameters when motion comp is used
+     class PicturePredParams
+     {
+     public:
+         PicturePredParams():
+ 	m_lbparams(3),
+         m_cbparams(3) {}
+ 
+         //! Return the global motion flag used for encoding/decoding
+         bool UsingGlobalMotion() const { return m_use_global_motion; }
+ 
+         //! Return the number of picture weight precision bits
+         unsigned int PictureWeightsBits() const { return m_picture_weights_bits; }
+ 
+         //! Return the Ref1 weight
+         int Ref1Weight() const { return m_ref1_weight; }
+ 
+         //! Return the Ref2 weight
+         int Ref2Weight() const { return m_ref2_weight; }
+ 
+         bool CustomRefWeights()
+         {
+             return (m_picture_weights_bits != 1 ||
+                     m_ref1_weight != 1 ||
+                     m_ref2_weight != 1);
+         }
+ 
+         //! Return the number of macroblocks horizontally
+         int XNumMB() const {return m_x_num_mb;}
+ 
+         //! Return the number of macroblocks vertically
+         int YNumMB() const {return m_y_num_mb;}
+ 
+         //! Return the number of blocks horizontally
+         int XNumBlocks() const {return m_x_num_blocks;}
+ 
+         //! Returns the number of blocks vertically
+         int YNumBlocks() const {return m_y_num_blocks;}
+ 
+         //! Return the Luma block parameters for each macroblock splitting level
+         const OLBParams& LumaBParams(int n) const {return m_lbparams[n];}
+ 
+         //! Return the Chroma block parameters for each macroblock splitting level
+         const OLBParams& ChromaBParams(int n) const {return m_cbparams[n];}
+ 
+         //! Return the number of accuracy bits used for motion vectors
+         MVPrecisionType MVPrecision() const { return m_mv_precision; }
+ 
+         //! Set how many MBs there are horizontally
+         void SetXNumMB(const int xn){m_x_num_mb=xn;}
+ 
+         //! Set how many MBs there are vertically
+         void SetYNumMB(const int yn){m_y_num_mb=yn;}
+ 
+         //! Set how many blocks there are horizontally
+         void SetXNumBlocks(const int xn){m_x_num_blocks=xn;}
+ 
+         //! Set how many blocks there are vertically
+         void SetYNumBlocks(const int yn){m_y_num_blocks=yn;}
+ 
+         //! Set the block sizes for all MB splitting levels given these prototype block sizes for level=2
+         void SetBlockSizes(const OLBParams& olbparams , const ChromaFormat cformat);
+ 
+         //! Set block level luma params
+         void SetLumaBlockParams(const OLBParams& olbparams) {m_lbparams[2] = olbparams;}
+ 
+         //! Set the number of accuracy bits for motion vectors
+         void SetMVPrecision(const MVPrecisionType p)
+         {
+             // Assert in debug mode. Maybe we should throw an exception???
+             TESTM((p >=0 && p <=3), "Motion precision value in range 0..3");
+             m_mv_precision = p;
+         }
+ 
+         void SetMVPrecision(const MVPrecisionType p) const
+         {
+             // Assert in debug mode. Maybe we should throw an exception???
+             TESTM((p >=0 && p <=3), "Motion precision value in range 0..3");
+             m_mv_precision = p;
+         }
+ 
+         //! Set the wavelet filter used for picture (de)coding
+         void SetUsingGlobalMotion(bool gm) { m_use_global_motion=gm; }
+ 
+         //! Set the picture weight precision bits used for (de)coding
+         void SetPictureWeightsPrecision(unsigned int wt_prec) { m_picture_weights_bits=wt_prec; }
+ 
+         //! Set the ref 1 picture weight
+         void SetRef1Weight(int wt) { m_ref1_weight=wt; }
+ 
+         //! Set the ref 2 picture weight
+         void SetRef2Weight(int wt) { m_ref2_weight=wt; }
+ 
+     private:
+ 
+         //! The number of macroblocks horizontally
+         int m_x_num_mb;
+ 
+         //! The number of macroblocks verticaly
+         int m_y_num_mb;
+ 
+         //! The number of blocks horizontally
+         int m_x_num_blocks;
+ 
+         //! The number of blocks vertically
+         int m_y_num_blocks;
+ 
+         OneDArray<OLBParams> m_lbparams;
+ 
+         OneDArray<OLBParams> m_cbparams;
+ 
+         //! The precision of motion vectors (number of accuracy bits eg 1=half-pel accuracy)
+         mutable MVPrecisionType m_mv_precision;
+ 
+         //! picture predicion parameters - precision
+         unsigned int m_picture_weights_bits;
+ 
+         //! picture predicion parameters - reference picture 1 weight
+         int m_ref1_weight;
+ 
+         //! picture predicion parameters - reference picture 2 weight
+         int m_ref2_weight;
+ 
+         //! Global motion fields
+         bool m_use_global_motion;
+ 
+     };
+ 
      //! Parameters common to coder and decoder operation
      /*!
***************
*** 983,997 ****
          // Gets ...
  
-         //! Return the number of macroblocks horizontally
-         int XNumMB() const {return m_x_num_mb;}
- 
-         //! Return the number of macroblocks vertically
-         int YNumMB() const {return m_y_num_mb;}
- 
-         //! Return the number of blocks horizontally
-         int XNumBlocks() const {return m_x_num_blocks;}
- 
-         //! Returns the number of blocks vertically
-         int YNumBlocks() const {return m_y_num_blocks;}
  
          //! Returns the picture coding mode (independent of source format)
--- 1112,1115 ----
***************
*** 1003,1007 ****
  
          //! Returns true if the pictures are being coded as fields (mode 1 or 3)
!         bool FieldCoding() const { return  (m_pic_coding_mode==1); } 
  
          //! Returns true if the topmost field comes first in time when coding
--- 1121,1125 ----
  
          //! Returns true if the pictures are being coded as fields (mode 1 or 3)
!         bool FieldCoding() const { return  (m_pic_coding_mode==1); }
  
          //! Returns true if the topmost field comes first in time when coding
***************
*** 1026,1038 ****
          unsigned int ChromaDepth() const { return m_chroma_depth; }
  
-         //! Return the Luma block parameters for each macroblock splitting level
-         const OLBParams& LumaBParams(int n) const {return m_lbparams[n];}
- 
-         //! Return the Chroma block parameters for each macroblock splitting level
-         const OLBParams& ChromaBParams(int n) const {return m_cbparams[n];}
- 
-         //! Return the number of accuracy bits used for motion vectors
-         MVPrecisionType MVPrecision() const { return m_mv_precision; }
- 
          //! Return zero transform flag being used for picture (de)coding
          bool ZeroTransform() const { return m_zero_transform; }
--- 1144,1147 ----
***************
*** 1056,1090 ****
          VideoFormat GetVideoFormat() const { return m_video_format; }
  
!         //! Return the global motion flag used for encoding/decoding
!         bool UsingGlobalMotion() const { return m_use_global_motion; }
! 
!         //! Return the number of picture weight precision bits
!         unsigned int PictureWeightsBits() const { return m_picture_weights_bits; }
! 
!         //! Return the Ref1 weight
!         int Ref1Weight() const { return m_ref1_weight; }
! 
!         //! Return the Ref2 weight
!         int Ref2Weight() const { return m_ref2_weight; }
! 
!         bool CustomRefWeights()
!         {
!             return (m_picture_weights_bits != 1 ||
!                     m_ref1_weight != 1 ||
!                     m_ref2_weight != 1);
!         }
!         // ... and Sets
!         //! Set how many MBs there are horizontally
!         void SetXNumMB(const int xn){m_x_num_mb=xn;}
! 
!         //! Set how many MBs there are vertically
!         void SetYNumMB(const int yn){m_y_num_mb=yn;}
! 
!         //! Set how many blocks there are horizontally
!         void SetXNumBlocks(const int xn){m_x_num_blocks=xn;}
  
!         //! Set how many blocks there are vertically
!         void SetYNumBlocks(const int yn){m_y_num_blocks=yn;}
  
          //! Sets whether input is coded as fields or quincunxially
          void SetPictureCodingMode(int pic_coding){m_pic_coding_mode=pic_coding;}
--- 1165,1175 ----
          VideoFormat GetVideoFormat() const { return m_video_format; }
  
! 	//! Return the picture prediction params
! 	PicturePredParams& GetPicPredParams(){return m_picpredparams;}
  
!         //! Return the picture prediction params
! 	const PicturePredParams& GetPicPredParams() const {return m_picpredparams;}
  
+        // ... and Sets
          //! Sets whether input is coded as fields or quincunxially
          void SetPictureCodingMode(int pic_coding){m_pic_coding_mode=pic_coding;}
***************
*** 1111,1135 ****
          void SetChromaDepth(unsigned int chroma_depth) { m_chroma_depth = chroma_depth; }
  
!         //! Set the block sizes for all MB splitting levels given these prototype block sizes for level=2
!         void SetBlockSizes(const OLBParams& olbparams , const ChromaFormat cformat);
!         //! Set block level luma params
!         void SetLumaBlockParams(const OLBParams& olbparams) {m_lbparams[2] = olbparams;}
! 
!         //! Set the number of accuracy bits for motion vectors
!         void SetMVPrecision(const MVPrecisionType p)
!         {
!             // Assert in debug mode. Maybe we should throw an exception???
!             TESTM((p >=0 && p <=3), "Motion precision value in range 0..3");
!             m_mv_precision = p;
!         }
! 
!         void SetMVPrecision(const MVPrecisionType p) const
!         {
!             // Assert in debug mode. Maybe we should throw an exception???
!             TESTM((p >=0 && p <=3), "Motion precision value in range 0..3");
!             m_mv_precision = p;
!         }
! 
!         //! Set the zero transform flag being used for picture (de)coding
          void SetZeroTransform(bool zero_transform)  { m_zero_transform = zero_transform; }
  
--- 1196,1200 ----
          void SetChromaDepth(unsigned int chroma_depth) { m_chroma_depth = chroma_depth; }
  
!        //! Set the zero transform flag being used for picture (de)coding
          void SetZeroTransform(bool zero_transform)  { m_zero_transform = zero_transform; }
  
***************
*** 1155,1175 ****
          void SetVideoFormat(const VideoFormat vd) { m_video_format=vd; }
  
!         //! Set the wavelet filter used for picture (de)coding
!         void SetUsingGlobalMotion(bool gm) { m_use_global_motion=gm; }
! 
!         //! Set the picture weight precision bits used for (de)coding
!         void SetPictureWeightsPrecision(unsigned int wt_prec) { m_picture_weights_bits=wt_prec; }
! 
!         //! Set the ref 1 picture weight
!         void SetRef1Weight(int wt) { m_ref1_weight=wt; }
! 
!         //! Set the ref 2 picture weight
!         void SetRef2Weight(int wt) { m_ref2_weight=wt; }
! 
!     protected:
          //! Return the Wavelet filter associated with the wavelet index
          WltFilter TransformFilter (unsigned int wf_idx);
      private:
  
          //! The picture coding mode
          int m_pic_coding_mode;
--- 1220,1231 ----
          void SetVideoFormat(const VideoFormat vd) { m_video_format=vd; }
  
!    protected:
          //! Return the Wavelet filter associated with the wavelet index
          WltFilter TransformFilter (unsigned int wf_idx);
      private:
  
+         //! The picture prediction parameters
+ 	PicturePredParams m_picpredparams;
+ 
          //! The picture coding mode
          int m_pic_coding_mode;
***************
*** 1196,1234 ****
          unsigned int m_chroma_depth;
  
!         //! The number of macroblocks horizontally
!         int m_x_num_mb;
! 
!         //! The number of macroblocks verticaly
!         int m_y_num_mb;
! 
!         //! The number of blocks horizontally
!         int m_x_num_blocks;
! 
!         //! The number of blocks vertically
!         int m_y_num_blocks;
! 
!         OneDArray<OLBParams> m_lbparams;
! 
!         OneDArray<OLBParams> m_cbparams;
! 
!         //! The precision of motion vectors (number of accuracy bits eg 1=half-pel accuracy)
!         mutable MVPrecisionType m_mv_precision;
! 
!         //! The video format being used
          VideoFormat m_video_format;
  
!         //! Global motion fields
!         bool m_use_global_motion;
! 
!         //! picture predicion parameters - precision
!         unsigned int m_picture_weights_bits;
! 
!         //! picture predicion parameters - reference picture 1 weight
!         int m_ref1_weight;
! 
!         //! picture predicion parameters - reference picture 2 weight
!         int m_ref2_weight;
! 
!         //! Zero transform flag
          bool m_zero_transform;
  
--- 1252,1259 ----
          unsigned int m_chroma_depth;
  
!        //! The video format being used
          VideoFormat m_video_format;
  
!        //! Zero transform flag
          bool m_zero_transform;
  

Index: video_format_defaults.cpp
===================================================================
RCS file: /cvsroot/dirac/compress/libdirac_common/video_format_defaults.cpp,v
retrieving revision 1.32
retrieving revision 1.33
diff -C2 -d -r1.32 -r1.33
*** video_format_defaults.cpp	25 Aug 2008 03:15:20 -0000	1.32
--- video_format_defaults.cpp	27 Aug 2008 00:17:11 -0000	1.33
***************
*** 103,115 ****
          ASSERTM (num_refs > 0 && num_refs < 3, "Number of reference frames should be 1 or 2 fo INTER frames" );
          OLBParams bparams;
!         cparams.SetUsingGlobalMotion(false);
          SetDefaultBlockParameters(bparams, cparams.GetVideoFormat());
!         cparams.SetLumaBlockParams(bparams);
!         cparams.SetPictureCodingMode(0);
!         cparams.SetMVPrecision(MV_PRECISION_HALF_PIXEL);
          // NOTE: FIXME - need to add global motion params here
!         cparams.SetPictureWeightsPrecision(1);
!         cparams.SetRef1Weight(1);
!         cparams.SetRef2Weight(1);
      }
  }
--- 103,116 ----
          ASSERTM (num_refs > 0 && num_refs < 3, "Number of reference frames should be 1 or 2 fo INTER frames" );
          OLBParams bparams;
! 	PicturePredParams& predparams = cparams.GetPicPredParams();
!         predparams.SetUsingGlobalMotion(false);
          SetDefaultBlockParameters(bparams, cparams.GetVideoFormat());
!         predparams.SetLumaBlockParams(bparams);
!         predparams.SetMVPrecision(MV_PRECISION_HALF_PIXEL);
          // NOTE: FIXME - need to add global motion params here
!         predparams.SetPictureWeightsPrecision(1);
!         predparams.SetRef1Weight(1);
!         predparams.SetRef2Weight(1);
!         cparams.SetPictureCodingMode(0);
      }
  }
***************
*** 347,351 ****
      encparams.SetLossless(false);
      encparams.SetQf(5.5f);
!     encparams.SetMVPrecision(MV_PRECISION_QUARTER_PIXEL);
      encparams.SetUsingAC(true);
  
--- 348,352 ----
      encparams.SetLossless(false);
      encparams.SetQf(5.5f);
!     encparams.GetPicPredParams().SetMVPrecision(MV_PRECISION_HALF_PIXEL);
      encparams.SetUsingAC(true);
  

Index: mot_comp.cpp
===================================================================
RCS file: /cvsroot/dirac/compress/libdirac_common/mot_comp.cpp,v
retrieving revision 1.44
retrieving revision 1.45
diff -C2 -d -r1.44 -r1.45
*** mot_comp.cpp	14 Aug 2008 02:23:18 -0000	1.44
--- mot_comp.cpp	27 Aug 2008 00:17:10 -0000	1.45
***************
*** 59,65 ****
  // Convenience function to perform motion compensation on a picture
  // Static function that motion compensates a picture. It uses the
! // MV precision value in the CodecParams to instantiate the
  // appropriate MotionCompensation sub-class.
! void MotionCompensator::CompensatePicture(const CodecParams &cp,
                                          const AddOrSub direction ,
                                          const MvData& mv_data,
--- 59,65 ----
  // Convenience function to perform motion compensation on a picture
  // Static function that motion compensates a picture. It uses the
! // MV precision value in the PicturePredParams to instantiate the
  // appropriate MotionCompensation sub-class.
! void MotionCompensator::CompensatePicture(const PicturePredParams &ppp,
                                          const AddOrSub direction ,
                                          const MvData& mv_data,
***************
*** 67,75 ****
  					Picture* refsptr[2])
  {
!     switch (cp.MVPrecision())
      {
      case MV_PRECISION_EIGHTH_PIXEL:
      {
!         MotionCompensator_EighthPixel my_comp(cp);
          my_comp.CompensatePicture( direction , mv_data, in_pic, refsptr);
          break;
--- 67,75 ----
  					Picture* refsptr[2])
  {
!     switch (ppp.MVPrecision())
      {
      case MV_PRECISION_EIGHTH_PIXEL:
      {
!         MotionCompensator_EighthPixel my_comp(ppp);
          my_comp.CompensatePicture( direction , mv_data, in_pic, refsptr);
          break;
***************
*** 77,81 ****
      case MV_PRECISION_HALF_PIXEL:
      {
!         MotionCompensator_HalfPixel my_comp(cp);
          my_comp.CompensatePicture( direction , mv_data, in_pic, refsptr);
          break;
--- 77,81 ----
      case MV_PRECISION_HALF_PIXEL:
      {
!         MotionCompensator_HalfPixel my_comp(ppp);
          my_comp.CompensatePicture( direction , mv_data, in_pic, refsptr);
          break;
***************
*** 83,87 ****
      case MV_PRECISION_PIXEL:
      {
!         MotionCompensator_Pixel my_comp(cp);
          my_comp.CompensatePicture( direction , mv_data, in_pic, refsptr);
          break;
--- 83,87 ----
      case MV_PRECISION_PIXEL:
      {
!         MotionCompensator_Pixel my_comp(ppp);
          my_comp.CompensatePicture( direction , mv_data, in_pic, refsptr);
          break;
***************
*** 90,94 ****
      default:
      {
!         MotionCompensator_QuarterPixel my_comp(cp);
          my_comp.CompensatePicture( direction , mv_data, in_pic, refsptr);
          break;
--- 90,94 ----
      default:
      {
!         MotionCompensator_QuarterPixel my_comp(ppp);
          my_comp.CompensatePicture( direction , mv_data, in_pic, refsptr);
          break;
***************
*** 103,109 ****
  // motion compensation. Creates the necessary arithmetic objects and
  // calls ReConfig to create weighting blocks to fit the values within
! // m_cparams.
! MotionCompensator::MotionCompensator( const CodecParams &cp ):
!     m_cparams(cp),
      luma_or_chroma(true)
  {
--- 103,109 ----
  // motion compensation. Creates the necessary arithmetic objects and
  // calls ReConfig to create weighting blocks to fit the values within
! // m_predparams.
! MotionCompensator::MotionCompensator( const PicturePredParams &ppp ):
!     m_predparams(ppp),
      luma_or_chroma(true)
  {
***************
*** 196,202 ****
  {
      if (luma_or_chroma)
!         m_bparams = m_cparams.LumaBParams(2);
      else
!         m_bparams = m_cparams.ChromaBParams(2);
  
      // Calculate the shift required in horizontal and vertical direction for
--- 196,202 ----
  {
      if (luma_or_chroma)
!         m_bparams = m_predparams.LumaBParams(2);
      else
!         m_bparams = m_predparams.ChromaBParams(2);
  
      // Calculate the shift required in horizontal and vertical direction for
***************
*** 205,209 ****
      // Total shift = shift assuming equal picture weights +
      //               picture weights precision
!     int blocks_per_mb_row = m_cparams.XNumBlocks()/m_cparams.XNumMB();
      int blocks_per_sb_row = blocks_per_mb_row>>1;
      int mb_xlen = m_bparams.Xblen()*blocks_per_mb_row - (m_bparams.Xblen()-m_bparams.Xbsep())*(blocks_per_mb_row-1);
--- 205,209 ----
      // Total shift = shift assuming equal picture weights +
      //               picture weights precision
!     int blocks_per_mb_row = m_predparams.XNumBlocks()/m_predparams.XNumMB();
      int blocks_per_sb_row = blocks_per_mb_row>>1;
      int mb_xlen = m_bparams.Xblen()*blocks_per_mb_row - (m_bparams.Xblen()-m_bparams.Xbsep())*(blocks_per_mb_row-1);
***************
*** 311,315 ****
      const int y_end_data = pic_data_out.FirstY() + std::min(pic_data_out.LengthY(), pic_size.y );
  
!     const int blocks_per_mb_row = m_cparams.XNumBlocks()/m_cparams.XNumMB();
      const int blocks_per_sb_row = blocks_per_mb_row>>1;
  
--- 311,315 ----
      const int y_end_data = pic_data_out.FirstY() + std::min(pic_data_out.LengthY(), pic_size.y );
  
!     const int blocks_per_mb_row = m_predparams.XNumBlocks()/m_predparams.XNumMB();
      const int blocks_per_sb_row = blocks_per_mb_row>>1;
  
***************
*** 318,324 ****
      // processed 
      int y_num_blocks = std::min((NUM_USED_BLKS(pic_size.y,m_bparams.Ybsep(),m_bparams.Yblen())), 
!                        m_cparams.YNumBlocks());
      int x_num_blocks = std::min((NUM_USED_BLKS(pic_size.x,m_bparams.Xbsep(),m_bparams.Xblen())),  
!                        m_cparams.XNumBlocks());
  
      //Loop over all the block rows
--- 318,324 ----
      // processed 
      int y_num_blocks = std::min((NUM_USED_BLKS(pic_size.y,m_bparams.Ybsep(),m_bparams.Yblen())), 
!                        m_predparams.YNumBlocks());
      int x_num_blocks = std::min((NUM_USED_BLKS(pic_size.x,m_bparams.Xbsep(),m_bparams.Xblen())),  
!                        m_predparams.XNumBlocks());
  
      //Loop over all the block rows
***************
*** 618,625 ****
          return;
  
!     if (m_cparams.CustomRefWeights())
      {
          int ref_wt_prec_bias = 1;
!         for (int i = m_cparams.PictureWeightsBits()-1; i > 0; --i)
          {
              ref_wt_prec_bias <<= 1;
--- 618,625 ----
          return;
  
!     if (m_predparams.CustomRefWeights())
      {
          int ref_wt_prec_bias = 1;
!         for (int i = m_predparams.PictureWeightsBits()-1; i > 0; --i)
          {
              ref_wt_prec_bias <<= 1;
***************
*** 631,636 ****
                  for (int x = 0; x < val1_block.LengthX(); ++x)
                  {
!                     val1_block[y][x] *= (m_cparams.Ref1Weight() + 
!                                    m_cparams.Ref2Weight());
                  }
              }
--- 631,636 ----
                  for (int x = 0; x < val1_block.LengthX(); ++x)
                  {
!                     val1_block[y][x] *= (m_predparams.Ref1Weight() +
!                                    m_predparams.Ref2Weight());
                  }
              }
***************
*** 642,647 ****
                  for (int x = 0; x < val1_block.LengthX(); ++x)
                  {
!                     val1_block[y][x] *= m_cparams.Ref1Weight();
!                     val2_block[y][x] *= m_cparams.Ref2Weight();
                      val1_block[y][x] += val2_block[y][x];
                  }
--- 642,647 ----
                  for (int x = 0; x < val1_block.LengthX(); ++x)
                  {
!                     val1_block[y][x] *= m_predparams.Ref1Weight();
!                     val2_block[y][x] *= m_predparams.Ref2Weight();
                      val1_block[y][x] += val2_block[y][x];
                  }
***************
*** 652,656 ****
              for (int x = 0; x < val1_block.LengthX(); ++x)
              {
!                 val1_block[y][x] = (val1_block[y][x] + ref_wt_prec_bias) >> m_cparams.PictureWeightsBits();
              }
          }
--- 652,656 ----
              for (int x = 0; x < val1_block.LengthX(); ++x)
              {
!                 val1_block[y][x] = (val1_block[y][x] + ref_wt_prec_bias) >> m_predparams.PictureWeightsBits();
              }
          }
***************
*** 831,836 ****
  // Motion Compesation class that provides pixel precision compensation
  
! MotionCompensator_Pixel::MotionCompensator_Pixel( const CodecParams &cp ) :
!     MotionCompensator( cp )
  {}
  
--- 831,836 ----
  // Motion Compesation class that provides pixel precision compensation
  
! MotionCompensator_Pixel::MotionCompensator_Pixel( const PicturePredParams &ppp ) :
!     MotionCompensator( ppp )
  {}
  
***************
*** 899,908 ****
  
  // Motion Compesation class that provides half-pixel precision compensation
! MotionCompensator_HalfPixel::MotionCompensator_HalfPixel( const CodecParams &cp ) :
!     MotionCompensator( cp )
  {}
  
  #if !defined (HAVE_MMX)
! void MotionCompensator_HalfPixel::BlockPixelPred( 
                                    TwoDArray<ValueType> &block_data ,
                                    const ImageCoords& pos ,
--- 899,908 ----
  
  // Motion Compesation class that provides half-pixel precision compensation
! MotionCompensator_HalfPixel::MotionCompensator_HalfPixel( const PicturePredParams &ppp ) :
!     MotionCompensator( ppp )
  {}
  
  #if !defined (HAVE_MMX)
! void MotionCompensator_HalfPixel::BlockPixelPred(
                                    TwoDArray<ValueType> &block_data ,
                                    const ImageCoords& pos ,
***************
*** 915,919 ****
      const ImageCoords ref_start( ( start_pos.x<<1 ) + mv.x ,( start_pos.y<<1 ) + mv.y );
  
!     //An additional stage to make sure the block to be copied does not fall 
      //outsidethe reference image.
      const int refXlen = refup_data.LengthX();
--- 915,919 ----
      const ImageCoords ref_start( ( start_pos.x<<1 ) + mv.x ,( start_pos.y<<1 ) + mv.y );
  
!     //An additional stage to make sure the block to be copied does not fall
      //outsidethe reference image.
      const int refXlen = refup_data.LengthX();
***************
*** 958,962 ****
          {
               for( int x=0 , rx=ref_start.x , bx=BChk(rx,trueRefXlen);
!                   x<block_data.LengthX() ; 
                    ++x, ++block_curr, rx+=2 , bx=BChk(rx,trueRefXlen))
               {
--- 958,962 ----
          {
               for( int x=0 , rx=ref_start.x , bx=BChk(rx,trueRefXlen);
!                   x<block_data.LengthX() ;
                    ++x, ++block_curr, rx+=2 , bx=BChk(rx,trueRefXlen))
               {
***************
*** 969,974 ****
  
  // Motion Compesation class that provides quarter-pixel precision compensation
! MotionCompensator_QuarterPixel::MotionCompensator_QuarterPixel( const CodecParams &cp ) :
!     MotionCompensator( cp )
  {}
  
--- 969,974 ----
  
  // Motion Compesation class that provides quarter-pixel precision compensation
! MotionCompensator_QuarterPixel::MotionCompensator_QuarterPixel( const PicturePredParams &ppp ) :
!     MotionCompensator( ppp )
  {}
  
***************
*** 1093,1098 ****
  // Motion Compesation class that provides one eighth-pixel precision
  // compensation
! MotionCompensator_EighthPixel::MotionCompensator_EighthPixel( const CodecParams &cp ) :
!     MotionCompensator( cp )
  {}
  
--- 1093,1098 ----
  // Motion Compesation class that provides one eighth-pixel precision
  // compensation
! MotionCompensator_EighthPixel::MotionCompensator_EighthPixel( const PicturePredParams &ppp ) :
!     MotionCompensator( ppp )
  {}