wavelet_utils.h

/* ***** BEGIN LICENSE BLOCK *****
*
* $Id: wavelet_utils.h,v 1.2 2005/01/30 05:11:40 gabest Exp $ $Name:  $
*
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* The Original Code is BBC Research and Development code.
*
* The Initial Developer of the Original Code is the British Broadcasting
* Corporation.
* Portions created by the Initial Developer are Copyright (C) 2004.
* All Rights Reserved.
*
* Contributor(s): Thomas Davies (Original Author), Scott R Ladd
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
* Public License Version 2.1 (the "LGPL"), in which case the provisions of
* the GPL or the LGPL are applicable instead of those above. If you wish to
* allow use of your version of this file only under the terms of the either
* the GPL or LGPL and not to allow others to use your version of this file
* under the MPL, indicate your decision by deleting the provisions above
* and replace them with the notice and other provisions required by the GPL
* or LGPL. If you do not delete the provisions above, a recipient may use
* your version of this file under the terms of any one of the MPL, the GPL
* or the LGPL.
* ***** END LICENSE BLOCK ***** */

#ifndef _WAVELET_UTILS_H_
#define _WAVELET_UTILS_H_

#include <libdirac_common/arrays.h>
#include <libdirac_common/common.h>
#include <vector>
#include <cmath>
#include <iostream>

namespace dirac
{
    //utilities for subband and wavelet transforms
    //Includes fast transform using lifting

    class PicArray;

    class Subband
    {
    public:

        Subband();


        Subband(int xpos, int ypos, int xlen, int ylen);


        Subband(int xpos, int ypos, int xlen, int ylen, int d);

        ~Subband();

        //Default (shallow) copy constructor and operator= used

        int Xl() const {return xln;}
        
        int Xp() const {return xps;}
        
        int Yl() const {return yln;}
        
        int Yp() const {return yps;}
        
        int Max() const {return max_bit;}
        
        double Wt() const {return wgt;}
        
        int Depth() const {return dpth;}
        
        int Scale() const {return (1<<dpth);}
        
        int Qf(int n) const {return qfac[n];}
        
        int Parent() const {return prt;}
        
        std::vector<int> Children() const {return childvec;}
        
        int Child(int n) const {return childvec[n];}

        // ... and sets
        void SetQf(int n, int q)
        {
            if (n >= qfac.First() && n<=qfac.Last() )
                qfac[n]=q;
        }
        
        void SetWt(float w){wgt=w;}
        
        void SetParent(int p){prt=p;}
        
        void SetDepth(int d){dpth=d;}
        
        void SetMax(int m){max_bit=m;};
        
        void SetChildren(std::vector<int>& clist){childvec=clist;}
        
        void AddChild(int c){childvec.push_back(c);}

    private:
        int xps,yps,xln,yln;        //subband bounds
        double wgt;                    //perceptual weight for quantisation
        int dpth;                    //depth in the transform
        OneDArray<int> qfac;        //quantisers
        int prt;                    //position of parent in a subband list
        std::vector<int> childvec;    //positions of children in the subband list
        int max_bit;                //position of the MSB of the largest absolute value
    };

    class SubbandList
    {
    public:
        SubbandList(){}

        ~SubbandList(){}

        //Default (shallow) copy constructor and operator= used
        void Init(const int depth,const int xlen,const int ylen);
        
        int Length() const {return bands.size();}
        
        Subband& operator()(int n){return bands[n-1];}
        
        const Subband& operator()(int n) const {return bands[n-1];}    
        
        void AddBand(Subband& b){bands.push_back(b);}
        
        void Clear(){bands.clear();}
        
    private:    
        std::vector<Subband> bands;
    };


    template <int gain> class PredictStep
    {

    public:

        PredictStep(){}

        // Assume default copy constructor, assignment= and destructor //

        /*
            Do the filtering.
            \param   in_val   the value being predicted
            \param   val1   the first value being used for prediction
            \param   val2   the second value being used for prediction
        */
        void Filter(ValueType& in_val, const ValueType& val1, const ValueType& val2) const;

    private:

    }; 

    template <int gain>
    inline void  PredictStep<gain>::Filter( ValueType& in_val, 
                                                const ValueType& val1, 
                                                const ValueType& val2) const
    {
        in_val -= static_cast< ValueType >( (gain * static_cast< int >( val1 + val2 )) >>12 );
    }

    template <int gain> class UpdateStep
    {

    public:
        UpdateStep(){}

        /*
            Do the filtering.
            \param   in_val   the value being updated
            \param   val1   the first value being used for updating
            \param   val2   the second value being used for updating
        */
        void Filter(ValueType& in_val, const ValueType& val1, const ValueType& val2) const;

    private:

    };  

    template <int gain>
    inline void UpdateStep<gain>::Filter(ValueType& in_val,
                                              const ValueType& val1, 
                                              const ValueType& val2) const
    {
        in_val += static_cast< ValueType >( (gain * static_cast< int >( val1 + val2 )) >>12 );
    }






    class WaveletTransform
    {
    public:
        // WaveletTransform(WaveletTransformParams p);
        WaveletTransform(int d = 4, WltFilter f = DAUB);
            
        virtual ~WaveletTransform();


        void Transform(const Direction d, PicArray& pic_data);
        
        SubbandList& BandList(){return band_list;}
        
        const SubbandList& BandList() const {return band_list;}
        

        void SetBandWeights (const float cpd, 
                             const FrameSort& fsort,
                             const ChromaFormat& cformat,
                             const CompSort csort);

    private:
        //other private variables    
        // WaveletTransformParams params;

        SubbandList band_list;

        int depth;
        
        WltFilter filt_sort;    

        //functions
        WaveletTransform(const WaveletTransform& cpy);
        
        WaveletTransform& operator=(const WaveletTransform& rhs);

        float PerceptualWeight(float xf,float yf,CompSort cs);

        void VHSplit(const int xp, const int yp, const int xl, const int yl, PicArray&pic_data); 

        void VHSynth(const int xp, const int yp, const int xl, const int yl, PicArray& pic_data);
};

} // namespace dirac

#endif

---