common.h

Go to the documentation of this file.

/* ***** BEGIN LICENSE BLOCK *****
*
* $Id: common.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,
*                 Tim Borer
*
* 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 _COMMON_H_
#define _COMMON_H_

#include <libdirac_common/bit_manager.h>
#include <libdirac_common/arrays.h>
#include <libdirac_common/common_types.h>
#include <vector>
#include <cmath>

namespace dirac
{
    //Some basic enumeration types used throughout the codec ...//

    enum PredMode{ INTRA , REF1_ONLY , REF2_ONLY , REF1AND2 };

    enum CompSort{ Y_COMP , U_COMP , V_COMP , R_COMP , G_COMP , B_COMP };

    enum AddOrSub{ ADD , SUBTRACT };

    enum Direction { FORWARD , BACKWARD };

    enum WltFilter { DAUB , HAAR };

    enum CtxAliases
    {//used for residual coding
        SIGN0_CTX,          //0     -sign, previous symbol is 0
        SIGN_POS_CTX,       //1     -sign, previous symbol is +ve
        SIGN_NEG_CTX,       //2     -sign, previous symbol is -ve
        
        
        Z_BIN1z_CTX,        //3     -bin 1, parent is zero, neighbours zero
        Z_BIN1nz_CTX,       //4     -bin 1, parent is zero, neighbours non-zero
        Z_BIN2_CTX,         //5     -bin 2, parent is zero
        Z_BIN3_CTX,         //6     -bin 3, parent is zero
        Z_BIN4_CTX,         //7     -bin 4, parent is zero
        Z_BIN5plus_CTX,     //8     -bins 5 plus, parent is zero
        
        NZ_BIN1z_CTX,       //9     -bin 1, parent is non-zero, neighbours zero
        NZ_BIN1a_CTX,       //10    -bin 1, parent is non-zero, neighbours small
        NZ_BIN1b_CTX,       //11    -bin 1, parent is non-zero, neighbours large
        NZ_BIN2_CTX,        //12    -bin 2, parent is non-zero
        NZ_BIN3_CTX,        //13    -bin 3, parent is non-zero
        NZ_BIN4_CTX,        //14    -bin 4, parent is non-zero
        NZ_BIN5plus_CTX,    //15    -bins 5 plus, parent is non-zero
        
        ZTz_CTX,            //16    -zerotree, neighbouring symbols are zerotree elements
        ZTnz_CTX,           //17    -zerotree, neighbouring symbols are not zerotree elements
        ZTzb_CTX,           //16    -zerotree, neighbouring symbols are zerotree elements
        ZTnzb_CTX           //17    -zerotree, neighbouring symbols are not zerotree elements
    };

    enum MvCtxAliases
    {
        
        YDC_BIN1_CTX,       //0     -1st bin of DC value for Y
        YDC_BIN2plus_CTX,   //1     -remaining DC bins
        YDC_SIGN0_CTX,      //2     -sign of Y DC value, previous value 0
        UDC_BIN1_CTX,       //3     --ditto
        UDC_BIN2plus_CTX,   //4     --for
        UDC_SIGN0_CTX,      //5     --U
        VDC_BIN1_CTX,       //6     --and
        VDC_BIN2plus_CTX,   //7     --V
        VDC_SIGN0_CTX,      //8     --components
        
        REF1x_BIN1_CTX,     //9     -bin 1, REF1 x vals
        REF1x_BIN2_CTX,     //10    -bin 2, REF1 x vals
        REF1x_BIN3_CTX,     //11    -bin 3, REF1 x vals
        REF1x_BIN4_CTX,     //12    -bin 4, REF1 x vals
        REF1x_BIN5plus_CTX, //13    -bin 5, REF1 x vals
        REF1x_SIGN0_CTX,    //14    -sign, REF1 x vals, previous value 0
        REF1x_SIGNP_CTX,    //15    -sign, REF1 x vals, previous value +ve
        REF1x_SIGNN_CTX,    //16    -sign, REF1 x vals, previous value -ve
        
        REF1y_BIN1_CTX,     //17    -bin 1, REF1 y vals
        REF1y_BIN2_CTX,     //18    -bin 2, REF1 y vals
        REF1y_BIN3_CTX,     //19    -bin 3, REF1 y vals
        REF1y_BIN4_CTX,     //20    -bin 4, REF1 y vals
        REF1y_BIN5plus_CTX, //21    -bin 5, REF1 y vals
        REF1y_SIGN0_CTX,    //22    -sign, REF1 y vals, previous value 0
        REF1y_SIGNP_CTX,    //23    -sign, REF1 y vals, previous value +ve
        REF1y_SIGNN_CTX,    //24    -sign, REF1 y vals, previous value -ve
        
        REF2x_BIN1_CTX,     //25    -bin 1, REF2 x vals
        REF2x_BIN2_CTX,     //26    -bin 2, REF2 x vals
        REF2x_BIN3_CTX,     //27    -bin 3, REF2 x vals
        REF2x_BIN4_CTX,     //28    -bin 4, REF2 x vals
        REF2x_BIN5plus_CTX, //29    -bin 5, REF2 x vals
        REF2x_SIGN0_CTX,    //30    -sign, REF2 x vals, previous value 0
        REF2x_SIGNP_CTX,    //31    -sign, REF1 y vals, previous value +ve
        REF2x_SIGNN_CTX,    //32    -sign, REF1 y vals, previous value -ve
        
        REF2y_BIN1_CTX,     //33    -bin 1, REF2 y vals
        REF2y_BIN2_CTX,     //34    -bin 2, REF2 y vals
        REF2y_BIN3_CTX,     //35    -bin 3, REF2 y vals
        REF2y_BIN4_CTX,     //36    -bin 4, REF2 y vals
        REF2y_BIN5plus_CTX, //37    -bin 5, REF2 y vals
        REF2y_SIGN0_CTX,    //38    -sign, REF2 y vals, previous value 0
        REF2y_SIGNP_CTX,    //39    -sign, REF2 y vals, previous value +ve
        REF2y_SIGNN_CTX,    //40    -sign, REF2 y vals, previous value -ve
        
        PMODE_BIN1_CTX,     //41    -bin 1, prediction mode value
        PMODE_BIN2_CTX,     //42    -bin 2, prediction mode value
        PMODE_BIN3_CTX,     //43    -bin 3, prediction mode value. Bin 4 not required
        
        MB_CMODE_CTX,       //44    -context for MB common block mode
        MB_SPLIT_BIN1_CTX,  //45    -bin1, MB split mode vals
        MB_SPLIT_BIN2_CTX   //46    -bin2, MB split mode vals. Bin 3 not required
        
    };


    //Classes used throughout the codec//



    class PicArray: public TwoDArray<ValueType>
    {
    public:

        PicArray(): TwoDArray<ValueType>(){}
        

        PicArray(int height, int width, CompSort cs=Y_COMP);
        
        //copy constructor and assignment= derived by inheritance
        
        ~PicArray(){}
        
        const CompSort& CSort() const;
        
        void SetCSort(const CompSort cs);
        
    private:
        
        CompSort m_csort;
    };


    class CostType
    {
    public:
        double MSE;
        
        double ENTROPY;
        
        double TOTAL;
    };



    class EntropyCorrector
    {
    public:

        EntropyCorrector(int depth);
        
        //NB: Assume default copy constructor, assignment = and destructor//


        float Factor(const int bandnum, const FrameSort fsort,const CompSort c) const;


        void Update(int bandnum, FrameSort fsort, CompSort c,int est_bits,int actual_bits);
        
    private:
        void Init();

        TwoDArray<float> m_Yfctrs;
        TwoDArray<float> m_Ufctrs;
        TwoDArray<float> m_Vfctrs;
    };

    class OLBParams
    {
        
    public:
        
        OLBParams(){}
        
        /*
            Constructor rationalises proposed parameters to allow suitable 
            overlap and fit in with
            chroma format
            \param    xblen    the horizontal block length    
            \param    yblen    the vertical block length
            \param    xblen    the horizontal block separation
            \param    yblen    the vertical block separation

        */
        OLBParams(const int xblen, int const yblen, int const xbsep, int const ybsep);
        
        // Gets ...
        
        int Xblen() const {return m_xblen;}
        
        int Yblen() const {return m_yblen;}
        
        int Xbsep() const {return m_xbsep;}
        
        int Ybsep() const {return m_ybsep;}
        
        int Xoffset() const {return m_xoffset;}
        
        int Yoffset() const {return m_yoffset;}
        
        // ... and sets
        
        void SetXblen( int xblen ){ m_xblen = xblen; m_xoffset = (m_xblen-m_xbsep)/2;}
        
        void SetYblen( int yblen ){ m_yblen = yblen; m_yoffset = (m_yblen-m_ybsep)/2;}
        
        void SetXbsep( int xbsep ){ m_xbsep = xbsep; m_xoffset = (m_xblen-m_xbsep)/2;}
        
        void SetYbsep( int ybsep ){ m_ybsep = ybsep; m_yoffset = (m_yblen-m_ybsep)/2;}
        
        // overloaded stream operators
        friend std::ostream & operator<< (std::ostream &, OLBParams &);
        friend std::istream & operator>> (std::istream &, OLBParams &);
        
        
    private:
        
        int m_xblen;
        int m_yblen;
        int m_xbsep;
        int m_ybsep;
        int m_xoffset;
        int m_yoffset;
    };

    class SeqParams
    {
    public:        
        SeqParams();
        
        //NB: Assume default copy constructor, assignment = and destructor//
        
        //gets ...
        int Xl() const {return m_xl;}
        
        int Yl() const {return m_yl;}
        
        ChromaFormat CFormat() const {return m_cformat;}
        
        int ChromaWidth() const;
        
        int ChromaHeight() const;
        
        bool Interlace() const {return m_interlace;}
        
        bool TopFieldFirst() const {return m_topfieldfirst;}
        
        int FrameRate() const {return m_framerate;}
        
        int BitstreamVersion() const {return m_bs_ver;}
        
        // ... Sets
        
        void SetXl(int xlen) {m_xl = xlen;}
        
        void SetYl(int ylen) {m_yl = ylen;}
        
        void SetCFormat(ChromaFormat cf) {m_cformat=cf;}
        
        void SetInterlace(bool ilace) {m_interlace=ilace;}
        
        void SetTopFieldFirst(bool tff) {m_topfieldfirst=tff;}
        
        void SetFrameRate(int fr){m_framerate=fr;}
        
        void SetBitstreamVersion(int bs_ver){m_bs_ver=bs_ver;}
        
    private:
        int m_xl;
        
        int m_yl;
        
        ChromaFormat m_cformat;
        
        bool m_interlace;
        
        bool m_topfieldfirst;
        
        int m_framerate;
        
        unsigned char  m_bs_ver;
    };

    class FrameParams 
    {
        
    public:
        FrameParams();
        

        FrameParams(const ChromaFormat& cf, int xlen, int ylen);
        

        FrameParams(const ChromaFormat& cf, const FrameSort& fs);
        
        /*
            All data is derived from the sequence parameters
        */
        FrameParams(const SeqParams& sparams);
        
        /*
           All data is derived from the sequence parameters
        */
        FrameParams(const SeqParams& sparams, const FrameSort& fs);
        
        //NB: Assume default copy constructor, assignment = and destructor//
        
        // Gets ...
        
        const ChromaFormat& CFormat() const{return m_cformat;}
        
        int Xl() const{return m_xl;}
        
        int Yl() const{return m_yl;}
        
        const FrameSort& FSort() const {return m_fsort;}
        
        int FrameNum() const {return m_fnum;}
        
        int ExpiryTime() const {return m_expiry_time;}
        
        bool Output() const {return m_output;}
        
        const std::vector<int>& Refs() const {return m_refs;}
        
        std::vector<int>& Refs(){return m_refs;}
        
        
        // ... Sets
        
        void SetFSort( const FrameSort& fs ){ m_fsort=fs; }
        
        void SetFrameNum( const int fn ){ m_fnum=fn; }
        
        void SetExpiryTime( const int expt ){ m_expiry_time=expt; }
        
        void SetAsOutput(){m_output=true;}
        
    private:
        
        ChromaFormat m_cformat;
        
        int m_xl;
        
        int m_yl;
        
        FrameSort m_fsort;
        
        std::vector<int> m_refs;
        
        int m_expiry_time;
        
        bool m_output;
        
        int m_fnum;        
    };



    class CodecParams
    {
    public:
        
        CodecParams();
        
            //NB: Assume default copy constructor, assignment = and destructor//
        
        // Gets ...    
        
        int XNumMB() const {return m_x_num_mb;}
        
        int YNumMB() const {return m_y_num_mb;}
        
        int XNumBlocks() const {return m_x_num_blocks;}
        
        int YNumBlocks() const {return m_y_num_blocks;}
        
        bool Verbose() const {return m_verbose;}
        
        bool Interlace() const {return m_interlace;}
        
        bool TopFieldFirst() const {return m_topfieldfirst;}    
        
        const OLBParams& LumaBParams(int n) const {return m_lbparams[n];}
        
        const OLBParams& ChromaBParams(int n) const {return m_cbparams[n];}    

        int OrigXl() const {return m_orig_xl;}

        int OrigYl() const {return m_orig_yl;}
        
        // ... and Sets
        void SetXNumMB(const int xn){m_x_num_mb=xn;}    
        
        void SetYNumMB(const int yn){m_y_num_mb=yn;}
        
        void SetXNumBlocks(const int xn){m_x_num_blocks=xn;}
        
        void SetYNumBlocks(const int yn){m_y_num_blocks=yn;}
        
        void SetVerbose(bool v){m_verbose=v;}
        
        void SetInterlace(bool intlc){m_interlace=intlc;}
        
        void SetTopFieldFirst(bool topf){m_topfieldfirst=topf;}
        
        void SetBlockSizes(const OLBParams& olbparams , const ChromaFormat cformat);

        void SetOrigXl(const int x){m_orig_xl=x;}

        void SetOrigYl(const int y){m_orig_yl=y;}

    private:
        
        int m_x_num_mb;
        
        int m_y_num_mb;
        
        int m_x_num_blocks;    
        
        int m_y_num_blocks;
        
        bool m_verbose;
        
        bool m_interlace;
        
        bool m_topfieldfirst;
        
        OneDArray<OLBParams> m_lbparams;
        OneDArray<OLBParams> m_cbparams;

        int m_orig_xl;

        int m_orig_yl;
    };


    class EncoderParams: public CodecParams
    {
        //codec params plus parameters relating solely to the operation of the encoder
        
    public:
        EncoderParams();
        
            //NB: Assume default copy constructor, assignment = and destructor//
            //This means pointers are copied, not the objects they point to.////       
        
         // Gets ...

        float Qf() const {return m_qf;}


        int NumL1() const {return m_num_L1;}

        int L1Sep() const {return m_L1_sep;}

        float UFactor() const {return m_ufactor;}

        float VFactor() const {return m_vfactor;}

        float CPD() const {return m_cpd;}

        float ILambda() const {return m_I_lambda;}

        float L1Lambda() const {return m_L1_lambda;}

        float L2Lambda() const {return m_L2_lambda;}

        float Lambda(const FrameSort& fsort) const;

        float L1MELambda() const {return m_L1_me_lambda;}

        float L2MELambda() const {return m_L2_me_lambda;}

        char * OutputPath() const {return ( char* ) m_output_path.c_str();}
        
        const EntropyCorrector& EntropyFactors() const {return *m_ent_correct;}
        
        EntropyCorrector& EntropyFactors() {return *m_ent_correct;}
        
        const SequenceOutputManager& BitsOut() const {return *m_bit_out;}
        
        SequenceOutputManager& BitsOut() {return *m_bit_out;}
        
        // ... and Sets

        void SetQf(const float qfac){m_qf=qfac;}

        void SetNumL1(const int nl){m_num_L1=nl;}

        void SetL1Sep(const int lsep){m_L1_sep=lsep;}

        void SetUFactor(const float uf){m_ufactor=uf;}

        void SetVFactor(const float vf){m_vfactor=vf;}

        void SetCPD(const float cpd){m_cpd=cpd;}

        void SetILambda(const float l){m_I_lambda=l;}

        void SetL1Lambda(const float l){m_L1_lambda=l;}

        void SetL2Lambda(const float l){m_L2_lambda=l;}

        void SetLambda(const FrameSort& fsort, const float l);

        void SetL1MELambda(const float l){m_L1_me_lambda=l;}

        void SetL2MELambda(const float l){m_L2_me_lambda=l;}

        void SetOutputPath(const char * op){ m_output_path = op; }
        
        void SetEntropyFactors(EntropyCorrector* entcorrect){m_ent_correct=entcorrect;}
        
        void SetBitsOut( SequenceOutputManager* so ){ m_bit_out=so; }
        
    private:
        float m_qf; 
        
        int m_num_L1;
        
        int m_L1_sep;    
        
        float m_ufactor;
        
        float m_vfactor;
        
        float m_cpd;
        
        float m_I_lambda;

        float m_L1_lambda;

        float m_L2_lambda;
        
        float m_L1_me_lambda;

        float m_L2_me_lambda; 
        
        EntropyCorrector* m_ent_correct;
        
        SequenceOutputManager* m_bit_out;   
        
        std::string m_output_path;
    };


    class DecoderParams: public CodecParams
    {
    public:
        DecoderParams():
        CodecParams(),
        m_bit_in(0){}
        
            //NB: Assume default copy constructor, assignment = and destructor//
            //This means pointers are copied, not the objects they point to.////       
        
        const BitInputManager& BitsIn() const {return *m_bit_in;}
        
        BitInputManager& BitsIn() {return *m_bit_in;}
        
        void SetBitsIn(BitInputManager* bi){m_bit_in=bi;}
        
    private:        
        BitInputManager* m_bit_in;
    };

    inline ValueType BChk(const ValueType &num, const ValueType &max)
    {
        if(num < 0) return 0;
        else if(num >= max) return max-1;
        else return num;
    }

} // namespace dirac

#endif

---