# Dirac - A Video Codec

Created by the British Broadcasting Corporation.

# common.h

Go to the documentation of this file.

    00001 /* ***** BEGIN LICENSE BLOCK *****
    00002 *
    00003 * $Id: common.h,v 1.52 2007/04/11 08:08:49 tjdwave Exp $ $Name: Dirac_0_7_0 $
    00004 *
    00005 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
    00006 *
    00007 * The contents of this file are subject to the Mozilla Public License
    00008 * Version 1.1 (the "License"); you may not use this file except in compliance
    00009 * with the License. You may obtain a copy of the License at
    00010 * http://www.mozilla.org/MPL/
    00011 *
    00012 * Software distributed under the License is distributed on an "AS IS" basis,
    00013 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
    00014 * the specific language governing rights and limitations under the License.
    00015 *
    00016 * The Original Code is BBC Research and Development code.
    00017 *
    00018 * The Initial Developer of the Original Code is the British Broadcasting
    00019 * Corporation.
    00020 * Portions created by the Initial Developer are Copyright (C) 2004.
    00021 * All Rights Reserved.
    00022 *
    00023 * Contributor(s): Thomas Davies (Original Author),
    00024 *                 Scott R Ladd,
    00025 *                 Tim Borer,
    00026 *                 Anuradha Suraparaju,
    00027 *                 Andrew Kennedy
    00028 *                 Myo Tun (Brunel University, myo.tun@brunel.ac.uk)
    00029 *
    00030 * Alternatively, the contents of this file may be used under the terms of
    00031 * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
    00032 * Public License Version 2.1 (the "LGPL"), in which case the provisions of
    00033 * the GPL or the LGPL are applicable instead of those above. If you wish to
    00034 * allow use of your version of this file only under the terms of the either
    00035 * the GPL or LGPL and not to allow others to use your version of this file
    00036 * under the MPL, indicate your decision by deleting the provisions above
    00037 * and replace them with the notice and other provisions required by the GPL
    00038 * or LGPL. If you do not delete the provisions above, a recipient may use
    00039 * your version of this file under the terms of any one of the MPL, the GPL
    00040 * or the LGPL.
    00041 * ***** END LICENSE BLOCK ***** */
    00042
    00043 #ifndef _COMMON_H_
    00044 #define _COMMON_H_
    00045
    00046 #ifdef  _MSC_VER
    00047 #define  _CRT_SECURE_NO_DEPRECATE
    00048 #endif // _MSC_VER
    00049
    00050 #include <libdirac_common/arrays.h>
    00051 #include <libdirac_common/common_types.h>
    00052 #include <libdirac_common/dirac_assertions.h>
    00053 #include <vector>
    00054 #include <cmath>
    00055 namespace dirac
    00056 {
    00066     //Some basic enumeration types used throughout the codec ...//
    00068
    00070     enum PredMode{ INTRA , REF1_ONLY , REF2_ONLY , REF1AND2, UNDEFINED };
    00071
    00073     enum CompSort{ Y_COMP , U_COMP , V_COMP };
    00074
    00076     enum AddOrSub{ ADD , SUBTRACT };
    00077
    00079     enum Direction { FORWARD , BACKWARD };
    00080
    00082     enum CtxAliases
    00083     {//used for residual coding
    00084         SIGN0_CTX,          // -sign, previous symbol is 0
    00085         SIGN_POS_CTX,       // -sign, previous symbol is +ve
    00086         SIGN_NEG_CTX,       // -sign, previous symbol is -ve
    00087
    00088         // Follow bit contexts
    00089         Z_FBIN1z_CTX,       // -bin 1, parent is zero, neighbours zero
    00090         Z_FBIN1nz_CTX,      // -bin 1, parent is zero, neighbours non-zero
    00091         Z_FBIN2_CTX,        // -bin 2, parent is zero
    00092         Z_FBIN3_CTX,        // -bin 3, parent is zero
    00093         Z_FBIN4_CTX,        // -bin 4, parent is zero
    00094         Z_FBIN5_CTX,        // -bin 5, parent is zero
    00095         Z_FBIN6plus_CTX,    // -bins 6 plus, parent is zero
    00096
    00097         NZ_FBIN1z_CTX,      // -bin 1, parent is non-zero, neighbours zero
    00098         NZ_FBIN1nz_CTX,     // -bin 1, parent is non-zero, neighbours non-zero
    00099         NZ_FBIN2_CTX,       // -bin 2, parent is non-zero
    00100         NZ_FBIN3_CTX,       // -bin 3, parent is non-zero
    00101         NZ_FBIN4_CTX,       // -bin 4, parent is non-zero
    00102         NZ_FBIN5_CTX,       // -bin 5, parent is non-zero
    00103         NZ_FBIN6plus_CTX,   // -bins 6 plus, parent is non-zero
    00104
    00105         // Information bit contexts
    00106         INFO_CTX,
    00107
    00108         BLOCK_SKIP_CTX,     // - blocks are skipped
    00109         Q_OFFSET_FOLLOW_CTX,   // - code block quantiser offset magnitude
    00110         Q_OFFSET_INFO_CTX,  // - code block quantiser offset info context
    00111         Q_OFFSET_SIGN_CTX,   // - code block quantiser offset sign
    00112         TOTAL_COEFF_CTXS   // The total number of coefficient contexts
    00113     };
    00114
    00116     enum MvCtxAliases
    00117     {
    00118         // DC value contexts //
    00120
    00121         DC_FBIN1_CTX,
    00122         DC_FBIN2plus_CTX,
    00123         DC_INFO_CTX,
    00124         DC_SIGN_CTX,
    00125
    00126         // Motion vector contexts //
    00128
    00129
    00130         MV_FBIN1_CTX,
    00131         MV_FBIN2_CTX,
    00132         MV_FBIN3_CTX,
    00133         MV_FBIN4_CTX,
    00134         MV_FBIN5plus_CTX,
    00135
    00136         MV_INFO_CTX,
    00137
    00138         MV_SIGN_CTX,
    00139
    00140
    00141         // Prediction mode contexts
    00142
    00143         PMODE_BIT0_CTX,     // -bit 0, prediction mode value
    00144         PMODE_BIT1_CTX,     // -bin 1, prediction mode value
    00145
    00146
    00147         // Macroblock contexts
    00148
    00149         MB_SPLIT_BIN1_CTX,  // bin 1, MB split mode vals
    00150         MB_SPLIT_BIN2_CTX,  // bin 2, MB split mode vals. Bin 3 not required
    00151
    00152         MB_SPLIT_INFO_CTX,  // info context for MB split mode
    00153
    00154         TOTAL_MV_CTXS       // The total number of motion vector contexts
    00155     };
    00156
    00157
    00163     VideoFormat IntToVideoFormat(int video_format);
    00164
    00170     ChromaFormat IntToChromaFormat(int chroma_format);
    00171
    00177     FrameRateType IntToFrameRateType(int frame_rate_idx);
    00178
    00184     AspectRatioType IntToAspectRatioType(int aspect_ratio_idx);
    00185
    00191     SignalRangeType IntToSignalRangeType(int signal_range_idx);
    00192
    00198     MVPrecisionType IntToMVPrecisionType(int mv_prec);
    00199
    00200     //Classes used throughout the codec//
    00203     class FrameSort
    00204     {
    00205     public:
    00206         FrameSort() { fs = 0x00; } // default intra non-ref
    00207
    00208         void SetIntra() { fs &= 0xfe; }
    00209         void SetInter() { fs |= 0x01; }
    00210         void SetNonRef() { fs &= 0xfd; }
    00211         void SetRef() { fs |= 0x02; }
    00212
    00213         bool IsInter () const { return fs & 0x01; }
    00214         bool IsIntra () const { return !IsInter(); }
    00215         bool IsRef() const { return fs & 0x02; };
    00216         bool IsNonRef() const { return !IsRef(); }
    00217
    00218         void SetIntraNonRef() { SetIntra(); SetNonRef(); }
    00219         void SetIntraRef() { SetIntra(); SetRef(); }
    00220         void SetInterNonRef() { SetInter(); SetNonRef(); }
    00221         void SetInterRef() { SetInter(); SetRef(); }
    00222
    00223         bool IsIntraNonRef() const { return (fs & 0x03) == 0x00; }
    00224         bool IsIntraRef() const { return (fs & 0x03) == 0x02; }
    00225         bool IsInterNonRef() const { return (fs & 0x03) == 0x01; }
    00226         bool IsInterRef() const { return (fs & 0x03) == 0x03; }
    00227
    00228         void Clear() { fs=0x00; }
    00229
    00230         static FrameSort IntraRefFrameSort()
    00231         {
    00232             FrameSort fs;
    00233             fs.SetIntraRef();
    00234             return fs;
    00235         }
    00236
    00237         static FrameSort InterRefFrameSort()
    00238         {
    00239             FrameSort fs;
    00240             fs.SetInterRef();
    00241             return fs;
    00242         }
    00243
    00244         static FrameSort IntraNonRefFrameSort()
    00245         {
    00246             FrameSort fs;
    00247             fs.SetIntraNonRef();
    00248             return fs;
    00249         }
    00250
    00251         static FrameSort InterNonRefFrameSort()
    00252         {
    00253             FrameSort fs;
    00254             fs.SetInterNonRef();
    00255             return fs;
    00256         }
    00257
    00258     private:
    00259         unsigned char fs;
    00260     };
    00261
    00263
    00269     class PicArray: public TwoDArray<ValueType>
    00270     {
    00271     public:
    00273
    00276         PicArray(): TwoDArray<ValueType>(){}
    00277
    00279
    00283         PicArray(int height, int width, CompSort cs=Y_COMP);
    00284
    00285         //copy constructor and assignment= derived by inheritance
    00286
    00288         ~PicArray(){}
    00289
    00291         const CompSort& CSort() const;
    00292
    00294         void SetCSort(const CompSort cs);
    00295
    00296     private:
    00297
    00298         CompSort m_csort;
    00299     };
    00300
    00301
    00303     class CostType
    00304     {
    00305     public:
    00307         double Error;
    00308
    00310         double ENTROPY;
    00311
    00313         double TOTAL;
    00314     };
    00315
    00316
    00318
    00323     class EntropyCorrector
    00324     {
    00325     public:
    00327
    00331         EntropyCorrector(int depth);
    00332
    00334         //NB: Assume default copy constructor, assignment = and destructor//
    00336
    00338
    00342         float Factor(const int bandnum, const FrameSort fsort,const CompSort c) const;
    00343
    00345
    00353         void Update(int bandnum, FrameSort fsort, CompSort c,int est_bits,int actual_bits);
    00354
    00355     private:
    00357         void Init();
    00358
    00359         TwoDArray<float> m_Yfctrs;
    00360         TwoDArray<float> m_Ufctrs;
    00361         TwoDArray<float> m_Vfctrs;
    00362     };
    00363
    00365     class OLBParams
    00366     {
    00367
    00368     public:
    00369
    00371         OLBParams(){}
    00372
    00374         /*
    00375             Constructor rationalises proposed parameters to allow suitable
    00376             overlap and fit in with chroma format
    00377             \param    xblen    the horizontal block length
    00378             \param    yblen    the vertical block length
    00379             \param    xblen    the horizontal block separation
    00380             \param    yblen    the vertical block separation
    00381
    00382         */
    00383         OLBParams(const int xblen, const int yblen,
    00384                   const int xbsep, const int ybsep);
    00385
    00386         // Gets ...
    00387
    00389         int Xblen() const {return m_xblen;}
    00390
    00392         int Yblen() const {return m_yblen;}
    00393
    00395         int Xbsep() const {return m_xbsep;}
    00396
    00398         int Ybsep() const {return m_ybsep;}
    00399
    00401         int Xoffset() const {return m_xoffset;}
    00402
    00404         int Yoffset() const {return m_yoffset;}
    00405
    00406         // ... and sets
    00407
    00409         void SetXblen( int xblen ){ m_xblen = xblen; m_xoffset = (m_xblen-m_xbsep)/2;}
    00410
    00412         void SetYblen( int yblen ){ m_yblen = yblen; m_yoffset = (m_yblen-m_ybsep)/2;}
    00413
    00415         void SetXbsep( int xbsep ){ m_xbsep = xbsep; m_xoffset = (m_xblen-m_xbsep)/2;}
    00416
    00418         void SetYbsep( int ybsep ){ m_ybsep = ybsep; m_yoffset = (m_yblen-m_ybsep)/2;}
    00419
    00420         bool operator == (const OLBParams bparams) const;
    00421
    00422         // overloaded stream operators
    00423         friend std::ostream & operator<< (std::ostream &, OLBParams &);
    00424         friend std::istream & operator>> (std::istream &, OLBParams &);
    00425
    00426
    00427     private:
    00428
    00429         int m_xblen;
    00430         int m_yblen;
    00431         int m_xbsep;
    00432         int m_ybsep;
    00433         int m_xoffset;
    00434         int m_yoffset;
    00435     };
    00436
    00438     class SeqParams
    00439     {
    00440     public:
    00442         SeqParams(const VideoFormat& video_format=VIDEO_FORMAT_CUSTOM,
    00443                   bool set_defaults=true);
    00444
    00446         //NB: Assume default copy constructor, assignment = and destructor//
    00448
    00449         //gets ...
    00451         int Xl() const {return m_xl;}
    00452
    00454         int Yl() const {return m_yl;}
    00455
    00457         ChromaFormat CFormat() const {return m_cformat;}
    00458
    00460         int ChromaWidth() const;
    00461
    00463         int ChromaHeight() const;
    00464
    00466         int BitstreamVersion() const {return m_bs_ver;}
    00467
    00469         VideoFormat GetVideoFormat() const { return m_video_format;}
    00470
    00472         int GetVideoDepth() const { return m_video_depth; }
    00473
    00474         // ... Sets
    00475
    00477         void SetXl(int xlen) {m_xl = xlen;}
    00478
    00480         void SetYl(int ylen) {m_yl = ylen;}
    00481
    00483         void SetCFormat(ChromaFormat cf) {m_cformat=cf;}
    00484
    00486         void SetVideoDepth(int vd){ m_video_depth=vd;}
    00487
    00489         void SetBitstreamVersion(int bs_ver){m_bs_ver=bs_ver;}
    00490
    00491
    00492     private:
    00494         int m_xl;
    00495
    00497         int m_yl;
    00498
    00500         ChromaFormat m_cformat;
    00501
    00503         unsigned char  m_bs_ver;
    00504
    00506         VideoFormat m_video_format;
    00507
    00509         int m_video_depth;
    00510     };
    00511
    00513     class Rational
    00514     {
    00515     public:
    00517         unsigned int m_num;
    00519         unsigned int m_denom;
    00520     };
    00521
    00523     class ParseParams
    00524     {
    00525     public:
    00527         ParseParams(unsigned int au_pnum = 0);
    00528
    00529         // Gets
    00530
    00532         unsigned int AccessUnitPictureNumber() const { return m_au_pnum; }
    00533
    00535         unsigned int MajorVersion() const { return m_major_ver; }
    00536
    00538         unsigned int MinorVersion() const { return m_minor_ver; }
    00539
    00541         unsigned int Profile() const { return m_profile; }
    00542
    00544         unsigned int Level() const { return m_level; }
    00545
    00546         // Sets
    00547
    00549         void SetAccessUnitPictureNumber(unsigned int au_pnum) { m_au_pnum = au_pnum; }
    00550
    00552         void SetMajorVersion(unsigned int major_ver) { m_major_ver = major_ver; }
    00553
    00555         void SetMinorVersion(unsigned int minor_ver) { m_minor_ver = minor_ver; }
    00556
    00558         void SetProfile(unsigned int level) { m_level = level; }
    00559
    00561         void SetLevel(unsigned int profile) { m_profile = profile; }
    00562
    00563     private:
    00565         unsigned int m_au_pnum;
    00567         unsigned int m_major_ver;
    00569         unsigned int m_minor_ver;
    00571         unsigned int m_profile;
    00573         unsigned int m_level;
    00574     };
    00575
    00577     class SourceParams
    00578     {
    00579     public:
    00581         SourceParams (const VideoFormat &vf = VIDEO_FORMAT_CUSTOM,
    00582                       bool set_defaults=true);
    00583
    00585         //NB: Assume default copy constructor, assignment = and destructor//
    00587
    00588         // Gets
    00590         bool Interlace() const { return m_interlace; }
    00591
    00593         bool TopFieldFirst() const { return m_topfieldfirst; }
    00594
    00596         bool SequentialFields() const { return m_seq_fields; }
    00597
    00599         Rational FrameRate() const { return m_framerate; }
    00600
    00602         FrameRateType FrameRateIndex() const { return m_fr_idx; }
    00603
    00605         Rational AspectRatio() const { return m_aspect_ratio; }
    00606
    00608         AspectRatioType AspectRatioIndex() const { return m_asr_idx; }
    00609
    00610         // Clean area parameters
    00612         unsigned int CleanWidth() const { return m_clean_width; }
    00614         unsigned int CleanHeight() const { return m_clean_height; }
    00616         unsigned int LeftOffset() const { return m_left_offset; }
    00618         unsigned int TopOffset() const { return m_top_offset; }
    00619
    00620         // Signal Range parameters
    00621
    00623         SignalRangeType SignalRangeIndex() const { return m_sr_idx; }
    00624
    00626         unsigned int LumaOffset() const { return m_luma_offset; }
    00628         unsigned int LumaExcursion() const { return m_luma_excursion; }
    00630         unsigned int ChromaOffset() const { return m_chroma_offset; }
    00632         unsigned int ChromaExcursion() const { return m_chroma_excursion; }
    00633
    00635         unsigned int ColourSpecificationIndex() const { return m_cs_idx; }
    00636
    00638         ColourPrimaries ColourPrimariesIndex() const { return m_col_primary; }
    00640         ColourMatrix ColourMatrixIndex() const { return m_col_matrix; }
    00642         TransferFunction TransferFunctionIndex() const { return m_transfer_func; }
    00643
    00644         // Sets
    00646         void SetInterlace(bool interlace) { m_interlace = interlace; }
    00647
    00649         void SetTopFieldFirst(bool tff) { m_topfieldfirst = tff; }
    00650
    00652         void SetSequentialFields(bool seq_flds) { m_seq_fields = seq_flds; }
    00653
    00655         void SetFrameRate(const Rational &frate )
    00656         {
    00657             m_fr_idx = FRAMERATE_CUSTOM; m_framerate = frate;
    00658         }
    00659
    00661         void SetFrameRate(unsigned int fr_num, unsigned int fr_denom )
    00662         {
    00663             m_fr_idx = FRAMERATE_CUSTOM;
    00664             m_framerate.m_num = fr_num;
    00665             m_framerate.m_denom = fr_denom;
    00666         }
    00667
    00669         void SetFrameRate(FrameRateType fr);
    00670
    00672         void SetAspectRatio(const Rational &asr)
    00673         {
    00674             m_asr_idx = ASPECT_RATIO_CUSTOM;
    00675             m_aspect_ratio = asr;
    00676         }
    00677
    00679         void SetAspectRatio(unsigned int as_num, unsigned int as_denom )
    00680         {
    00681             m_asr_idx = ASPECT_RATIO_CUSTOM;
    00682             m_aspect_ratio.m_num = as_num;
    00683             m_aspect_ratio.m_denom = as_denom;
    00684         }
    00685
    00687         void SetAspectRatio(AspectRatioType aspect_ratio);
    00688
    00689         // Clean area parameters
    00691         void SetCleanWidth(unsigned int clean_width) { m_clean_width = clean_width; }
    00693         void SetCleanHeight(unsigned int clean_height) { m_clean_height = clean_height; }
    00695         void SetLeftOffset(unsigned int left_offset) { m_left_offset = left_offset; }
    00697         void SetTopOffset(unsigned int top_offset) { m_top_offset = top_offset; }
    00698
    00699         // Signal Range parameters
    00701         void SetSignalRange(SignalRangeType sr);
    00702
    00704         void SetLumaOffset(unsigned int luma_offset) { m_sr_idx = SIGNAL_RANGE_CUSTOM; m_luma_offset = luma_offset; }
    00706         void SetLumaExcursion(unsigned int luma_exc) { m_sr_idx = SIGNAL_RANGE_CUSTOM; m_luma_excursion = luma_exc; }
    00708         void SetChromaOffset(unsigned int chroma_off) { m_sr_idx = SIGNAL_RANGE_CUSTOM; m_chroma_offset = chroma_off; }
    00710         void SetChromaExcursion(unsigned int chroma_exc) { m_sr_idx = SIGNAL_RANGE_CUSTOM; m_chroma_excursion = chroma_exc; }
    00711
    00713         void SetColourSpecification(unsigned int cs_idx);
    00715         void SetColourPrimariesIndex(unsigned int cp);
    00717         void SetColourMatrixIndex(unsigned int cm);
    00719         void SetTransferFunctionIndex(unsigned int tf);
    00720
    00721     private:
    00723         bool m_interlace;
    00724
    00726         bool m_topfieldfirst;
    00727
    00729         bool m_seq_fields;
    00730
    00732         FrameRateType m_fr_idx;
    00733
    00735         Rational m_framerate;
    00736
    00738         AspectRatioType m_asr_idx;
    00739
    00741         Rational m_aspect_ratio;
    00742
    00743         // Clean area parameters
    00744
    00746         unsigned int m_clean_width;
    00747
    00749         unsigned int m_clean_height;
    00750
    00752         unsigned int m_left_offset;
    00753
    00755         unsigned int m_top_offset;
    00756
    00757         // signal range parameters
    00758
    00760         SignalRangeType m_sr_idx;
    00761
    00763         unsigned int m_luma_offset;
    00765         unsigned int m_luma_excursion;
    00767         unsigned int m_chroma_offset;
    00769         unsigned int m_chroma_excursion;
    00770
    00772         unsigned int m_cs_idx;
    00773
    00775         ColourPrimaries m_col_primary;
    00776
    00777         // Colour Matrix index
    00778         ColourMatrix m_col_matrix;
    00779
    00780         // Transfer function index
    00781         TransferFunction m_transfer_func;
    00782     };
    00783
    00785     class FrameParams
    00786     {
    00787
    00788     public:
    00790         FrameParams();
    00791
    00793
    00796         FrameParams(const ChromaFormat& cf, int xlen, int ylen, int c_xlen, int c_ylen, unsigned int video_depth);
    00797
    00799
    00802         FrameParams(const ChromaFormat& cf, const FrameSort& fs);
    00803
    00805         /*
    00806             All data is derived from the sequence parameters
    00807         */
    00808         FrameParams(const SeqParams& sparams);
    00809
    00811         /*
    00812            All data is derived from the sequence parameters
    00813         */
    00814         FrameParams(const SeqParams& sparams, const FrameSort& fs);
    00815
    00817         //NB: Assume default copy constructor, assignment = and destructor//
    00819
    00820         // Gets ...
    00821
    00823         const ChromaFormat& CFormat() const{return m_cformat;}
    00824
    00826         int Xl() const{return m_xl;}
    00827
    00829         int Yl() const{return m_yl;}
    00830
    00832         int ChromaXl() const{return m_chroma_xl;}
    00833
    00835         int ChromaYl() const{return m_chroma_yl;}
    00836
    00838         const FrameSort& FSort() const {return m_fsort;}
    00839
    00841         int FrameNum() const {return m_fnum;}
    00842
    00844         bool IsBFrame() const;
    00845
    00847         int ExpiryTime() const {return m_expiry_time;}
    00848
    00850         bool Output() const {return m_output;}
    00851
    00853         const std::vector<int>& Refs() const {return m_refs;}
    00854
    00856         std::vector<int>& Refs(){return m_refs;}
    00857
    00859         unsigned int NumRefs()const {return m_refs.size();}
    00860
    00862         FrameType GetFrameType () const { return m_frame_type; }
    00863
    00865         ReferenceType GetReferenceType() const { return m_reference_type;}
    00866
    00868         unsigned int GetVideoDepth() const{return m_video_depth;}
    00869
    00870         // ... Sets
    00871
    00873         void SetFSort( const FrameSort& fs );
    00874
    00876         void SetFrameType(const FrameType ftype);
    00877
    00879         void SetReferenceType(const ReferenceType rtype);
    00880
    00882         void SetFrameNum( const int fn ){ m_fnum=fn; }
    00883
    00885         void SetExpiryTime( const int expt ){ m_expiry_time=expt; }
    00886
    00888         void SetAsOutput(){m_output=true;}
    00889
    00891         void SetCFormat(ChromaFormat cf){ m_cformat = cf; }
    00892
    00894         void SetXl(int xl){m_xl = xl; }
    00895
    00897         void SetYl(int yl){m_yl = yl; }
    00898
    00900         void SetChromaXl(int xl){m_chroma_xl = xl; }
    00901
    00903         void SetChromaYl(int yl){m_chroma_yl = yl; }
    00904
    00906         void SetVideoDepth(int vd) { m_video_depth = vd; }
    00907
    00909         std::vector<int>& RetiredFrames() const {return m_retd_list;}
    00910
    00912         std::vector<int>& RetiredFrames() {return m_retd_list;}
    00913
    00914     private:
    00915
    00917         ChromaFormat m_cformat;
    00918
    00920         int m_xl;
    00921
    00923         int m_yl;
    00924
    00926         FrameSort m_fsort;
    00927
    00929         std::vector<int> m_refs;
    00930
    00932         int m_expiry_time;
    00933
    00935         int m_fnum;
    00936
    00938         FrameType m_frame_type;
    00939
    00941         ReferenceType m_reference_type;
    00942
    00944         bool m_output;
    00945
    00947         int m_chroma_xl;
    00948
    00950         int m_chroma_yl;
    00951
    00953         mutable std::vector<int> m_retd_list;
    00954
    00956         unsigned int m_video_depth;
    00957
    00958     };
    00959
    00961     class CodeBlocks
    00962     {
    00963     public:
    00965         CodeBlocks () : m_hblocks(0), m_vblocks(0)
    00966         {}
    00967
    00969         CodeBlocks (unsigned int  hblocks, unsigned int vblocks) :
    00970             m_hblocks(hblocks),
    00971             m_vblocks(vblocks)
    00972             {}
    00973
    00974         // Gets
    00976         unsigned int HorizontalCodeBlocks() const { return m_hblocks; }
    00978         unsigned int VerticalCodeBlocks() const { return m_vblocks; }
    00979         // Sets
    00981         void SetHorizontalCodeBlocks(unsigned int hblocks) { m_hblocks = hblocks; }
    00983         void SetVerticalCodeBlocks(unsigned int vblocks) { m_vblocks = vblocks; }
    00984     private:
    00986         unsigned int m_hblocks;
    00988         unsigned int m_vblocks;
    00989     };
    00991
    00994     class CodecParams
    00995     {
    00996     public:
    00997
    00999         CodecParams(const VideoFormat& vd, FrameType ftype, unsigned int num_refs, bool set_defaults);
    01000
    01002             //NB: Assume default copy constructor, assignment = and destructor//
    01004
    01005         // Gets ...
    01006
    01008         int XNumMB() const {return m_x_num_mb;}
    01009
    01011         int YNumMB() const {return m_y_num_mb;}
    01012
    01014         int XNumBlocks() const {return m_x_num_blocks;}
    01015
    01017         int YNumBlocks() const {return m_y_num_blocks;}
    01018
    01020         bool Verbose() const {return m_verbose;}
    01021
    01023         bool Interlace() const {return m_interlace;}
    01024
    01026         bool TopFieldFirst() const {return m_topfieldfirst;}
    01027
    01029         const OLBParams& LumaBParams(int n) const {return m_lbparams[n];}
    01030
    01032         const OLBParams& ChromaBParams(int n) const {return m_cbparams[n];}
    01033
    01035         int OrigXl() const {return m_orig_xl;}
    01036
    01038         int OrigYl() const {return m_orig_yl;}
    01039
    01041         MVPrecisionType MVPrecision() const { return m_mv_precision; }
    01042
    01044         bool ZeroTransform() const { return m_zero_transform; }
    01045
    01047         WltFilter TransformFilter() const { return m_wlt_filter; }
    01048
    01050         unsigned int TransformDepth() const { return m_wlt_depth; }
    01051
    01053         CodeBlockMode GetCodeBlockMode() const { return m_cb_mode; }
    01054
    01056         bool SpatialPartition() const { return m_spatial_partition; }
    01057
    01059         bool DefaultSpatialPartition() const { return m_def_spatial_partition; }
    01061         const CodeBlocks &GetCodeBlocks(unsigned int level) const;
    01062
    01064         VideoFormat GetVideoFormat() const { return m_video_format; }
    01065
    01067         bool UsingGlobalMotion() const { return m_use_global_motion; }
    01068
    01070         unsigned int FrameWeightsBits() const { return m_frame_weights_bits; }
    01071
    01073         unsigned int Ref1Weight() const { return m_ref1_weight; }
    01074
    01076         unsigned int Ref2Weight() const { return m_ref2_weight; }
    01077
    01078         // ... and Sets
    01080         void SetXNumMB(const int xn){m_x_num_mb=xn;}
    01081
    01083         void SetYNumMB(const int yn){m_y_num_mb=yn;}
    01084
    01086         void SetXNumBlocks(const int xn){m_x_num_blocks=xn;}
    01087
    01089         void SetYNumBlocks(const int yn){m_y_num_blocks=yn;}
    01090
    01092         void SetVerbose(bool v){m_verbose=v;}
    01093
    01095         void SetInterlace(bool intlc){m_interlace=intlc;}
    01096
    01098         void SetTopFieldFirst(bool topf){m_topfieldfirst=topf;}
    01099
    01101         void SetBlockSizes(const OLBParams& olbparams , const ChromaFormat cformat);
    01103         void SetLumaBlockParams(const OLBParams& olbparams) {m_lbparams[2] = olbparams;}
    01104
    01106         void SetOrigXl(const int x){m_orig_xl=x;}
    01107
    01109         void SetOrigYl(const int y){m_orig_yl=y;}
    01110
    01112         void SetMVPrecision(const MVPrecisionType p)
    01113         {
    01114             // Assert in debug mode. Maybe we should throw an exception???
    01115             TESTM((p >=0 && p <=3), "Motion precision value in range 0..3");
    01116             m_mv_precision = p;
    01117         }
    01118
    01119         void SetMVPrecision(const MVPrecisionType p) const
    01120         {
    01121             // Assert in debug mode. Maybe we should throw an exception???
    01122             TESTM((p >=0 && p <=3), "Motion precision value in range 0..3");
    01123             m_mv_precision = p;
    01124         }
    01125
    01127         void SetZeroTransform(bool zero_transform)  { m_zero_transform = zero_transform; }
    01128
    01130         void SetTransformFilter(const WltFilter wf) { m_wlt_filter=wf; }
    01131
    01133         void SetTransformFilter(unsigned int wf_idx);
    01134
    01136         void SetTransformDepth(unsigned int wd);
    01137
    01139         void SetCodeBlockMode(unsigned int cb_mode);
    01140
    01142         void SetSpatialPartition(bool spatial_partition) { m_spatial_partition=spatial_partition; }
    01143
    01145         void SetDefaultSpatialPartition(bool def_spatial_partition) { m_def_spatial_partition=def_spatial_partition; }
    01146
    01148         void  SetCodeBlocks(unsigned int level, unsigned int hblocks, unsigned int vblocks);
    01149
    01151         void  SetDefaultCodeBlocks(const FrameType& ftype);
    01152
    01154         void SetVideoFormat(const VideoFormat vd) { m_video_format=vd; }
    01155
    01157         void SetUsingGlobalMotion(bool gm) { m_use_global_motion=gm; }
    01158
    01160         void SetFrameWeightsPrecision(unsigned int wt_prec) { m_frame_weights_bits=wt_prec; }
    01161
    01163         void SetRef1Weight(unsigned int wt) { m_ref1_weight=wt; }
    01164
    01166         void SetRef2Weight(unsigned int wt) { m_ref2_weight=wt; }
    01167
    01168     protected:
    01170         WltFilter TransformFilter (unsigned int wf_idx);
    01171     private:
    01172
    01174         int m_x_num_mb;
    01175
    01177         int m_y_num_mb;
    01178
    01180         int m_x_num_blocks;
    01181
    01183         int m_y_num_blocks;
    01184
    01186         bool m_verbose;
    01187
    01189         bool m_interlace;
    01190
    01192         bool m_topfieldfirst;
    01193
    01194         OneDArray<OLBParams> m_lbparams;
    01195         OneDArray<OLBParams> m_cbparams;
    01196
    01198         int m_orig_xl;
    01199
    01201         int m_orig_yl;
    01202
    01204         mutable MVPrecisionType m_mv_precision;
    01205
    01207         VideoFormat m_video_format;
    01208
    01210         bool m_use_global_motion;
    01211
    01213         unsigned int m_frame_weights_bits;
    01214
    01216         unsigned int m_ref1_weight;
    01217
    01219         unsigned int m_ref2_weight;
    01220
    01222         bool m_zero_transform;
    01223
    01225         WltFilter m_wlt_filter;
    01226
    01228         unsigned int m_wlt_depth;
    01229
    01231         CodeBlockMode m_cb_mode;
    01232
    01234         bool m_spatial_partition;
    01235
    01237         bool m_def_spatial_partition;
    01238
    01240         OneDArray<CodeBlocks> m_cb;
    01241     };
    01242
    01244
    01247     class EncoderParams: public CodecParams
    01248     {
    01249         //codec params plus parameters relating solely to the operation of the encoder
    01250
    01251     public:
    01253         EncoderParams(const VideoFormat& video_format,
    01254                       FrameType ftype = INTER_FRAME,
    01255                       unsigned int num_refs = 2,
    01256                       bool set_defaults=true);
    01257
    01259             //NB: Assume default copy constructor, assignment = and destructor//
    01260             //This means pointers are copied, not the objects they point to.////
    01262
    01263          // Gets ...
    01264
    01266         bool LocalDecode() const {return m_loc_decode;}
    01267
    01269         bool Lossless() const {return m_lossless;}
    01270
    01272         float Qf() const {return m_qf;}
    01273
    01275
    01280         int NumL1() const {return m_num_L1;}
    01281
    01283         int L1Sep() const {return m_L1_sep;}
    01284
    01286         float UFactor() const {return m_ufactor;}
    01287
    01289         float VFactor() const {return m_vfactor;}
    01290
    01292         float CPD() const {return m_cpd;}
    01293
    01295         bool Denoise() const {return m_denoise;}
    01296
    01298         float ILambda() const {return m_I_lambda;}
    01299
    01301         float L1Lambda() const {return m_L1_lambda;}
    01302
    01304         float L2Lambda() const {return m_L2_lambda;}
    01305
    01307         float L1MELambda() const {return m_L1_me_lambda;}
    01308
    01310         float L2MELambda() const {return m_L2_me_lambda;}
    01311
    01313         int GOPLength() const { if (m_num_L1>0) return (m_num_L1+1)*m_L1_sep;
    01314                                 return (m_num_L1==0) ? 10 : 0; }
    01315
    01317         char * OutputPath() const {return ( char* ) m_output_path.c_str();}
    01318
    01320         const EntropyCorrector& EntropyFactors() const {return *m_ent_correct;}
    01321
    01323         EntropyCorrector& EntropyFactors() {return *m_ent_correct;}
    01324
    01326         WltFilter IntraTransformFilter() { return m_intra_wltfilter; }
    01327
    01329         WltFilter InterTransformFilter() { return m_inter_wltfilter; }
    01330
    01332         int TargetRate() {return m_target_rate;}
    01333
    01334         // ... and Sets
    01335
    01337         void SetLocalDecode( const bool decode ){m_loc_decode=decode;}
    01338
    01340         void SetLossless(const bool l){m_lossless = l;}
    01341
    01343         void SetQf(const float qfac){ m_qf=qfac; CalcLambdas(m_qf); }
    01344
    01346         void SetNumL1(const int nl){m_num_L1=nl;}
    01347
    01349         void SetL1Sep(const int lsep){m_L1_sep=lsep;}
    01350
    01352         void SetUFactor(const float uf){m_ufactor=uf;}
    01353
    01355         void SetVFactor(const float vf){m_vfactor=vf;}
    01356
    01358         void SetCPD(const float cpd){m_cpd=cpd;}
    01359
    01360
    01362         void SetDenoise(const bool denoise){m_denoise=denoise;}
    01363
    01365         void SetOutputPath(const char * op){ m_output_path = op; }
    01366
    01368         void SetEntropyFactors(EntropyCorrector* entcorrect){m_ent_correct=entcorrect;}
    01370         void SetIntraTransformFilter(unsigned int wf_idx);
    01371
    01373         void SetInterTransformFilter(unsigned int wf_idx);
    01374
    01376         void SetIntraTransformFilter(WltFilter wf) { m_intra_wltfilter = wf; }
    01377
    01379         void SetInterTransformFilter(WltFilter wf) { m_inter_wltfilter = wf; }
    01380
    01382         void SetTargetRate(const int rate){m_target_rate = rate;}
    01383     private:
    01384
    01386         void CalcLambdas(const float qf);
    01387
    01388     private:
    01389
    01391         bool m_loc_decode;
    01392
    01394         bool m_lossless;
    01395
    01397         float m_qf;
    01398
    01400         int m_num_L1;
    01401
    01403         int m_L1_sep;
    01404
    01406         float m_ufactor;
    01407
    01409         float m_vfactor;
    01410
    01412         float m_cpd;
    01413
    01415         bool m_denoise;
    01416
    01418         float m_I_lambda;
    01419
    01421         float m_L1_lambda;
    01422
    01424         float m_L2_lambda;
    01425
    01427         float m_L1_me_lambda;
    01428
    01430         float m_L2_me_lambda;
    01431
    01433         EntropyCorrector* m_ent_correct;
    01434
    01436         std::string m_output_path;
    01437
    01439         WltFilter m_intra_wltfilter;
    01440
    01442         WltFilter m_inter_wltfilter;
    01443
    01445         int m_target_rate;
    01446
    01447     };
    01448
    01450
    01453     class DecoderParams: public CodecParams
    01454     {
    01455     public:
    01457         DecoderParams(const VideoFormat& video_format = VIDEO_FORMAT_CIF, FrameType ftype=INTRA_FRAME, unsigned int num_refs = 0, bool set_defaults = false);
    01458
    01460             //NB: Assume default copy constructor, assignment = and destructor//
    01461             //This means pointers are copied, not the objects they point to.////
    01463
    01464
    01465     private:
    01466
    01467     };
    01468
    01470     inline ValueType BChk(const ValueType &num, const ValueType &max)
    01471     {
    01472         if(num < 0) return 0;
    01473         else if(num >= max) return max-1;
    01474         else return num;
    01475     }
    01476
    01478     class QuantiserLists
    01479     {
    01480     public:
    01482         QuantiserLists();
    01483
    01485         inline int QuantFactor4( const int index ) const {return m_qflist4[index]; }
    01486
    01488         inline int IntraQuantOffset4( const int index ) const {return m_intra_offset4[index]; }
    01490         inline int InterQuantOffset4( const int index ) const {return m_inter_offset4[index]; }
    01491
    01493         inline int MaxQIndex() const {return m_max_qindex; }
    01494
    01495
    01496     private:
    01497         unsigned int m_max_qindex;
    01498         OneDArray<int> m_qflist4;
    01499         OneDArray<int> m_intra_offset4;
    01500         OneDArray<int> m_inter_offset4;
    01501
    01502     };
    01503
    01505     static const QuantiserLists dirac_quantiser_lists;
    01506
    01507 } // namespace dirac
    01508
    01509 #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.