# 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.39 2006/06/12 12:11:52 asuraparaju Exp $ $Name: Dirac_0_6_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 *
    00029 * Alternatively, the contents of this file may be used under the terms of
    00030 * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
    00031 * Public License Version 2.1 (the "LGPL"), in which case the provisions of
    00032 * the GPL or the LGPL are applicable instead of those above. If you wish to
    00033 * allow use of your version of this file only under the terms of the either
    00034 * the GPL or LGPL and not to allow others to use your version of this file
    00035 * under the MPL, indicate your decision by deleting the provisions above
    00036 * and replace them with the notice and other provisions required by the GPL
    00037 * or LGPL. If you do not delete the provisions above, a recipient may use
    00038 * your version of this file under the terms of any one of the MPL, the GPL
    00039 * or the LGPL.
    00040 * ***** END LICENSE BLOCK ***** */
    00041
    00042 #ifndef _COMMON_H_
    00043 #define _COMMON_H_
    00044
    00045 #include <libdirac_common/arrays.h>
    00046 #include <libdirac_common/common_types.h>
    00047 #include <libdirac_common/dirac_assertions.h>
    00048 #include <vector>
    00049 #include <cmath>
    00050 namespace dirac
    00051 {
    00061     //Some basic enumeration types used throughout the codec ...//
    00063
    00065     enum PredMode{ INTRA , REF1_ONLY , REF2_ONLY , REF1AND2, UNDEFINED };
    00066
    00068     enum CompSort{ Y_COMP , U_COMP , V_COMP };
    00069
    00071     enum AddOrSub{ ADD , SUBTRACT };
    00072
    00074     enum Direction { FORWARD , BACKWARD };
    00075
    00077     enum CtxAliases
    00078     {//used for residual coding
    00079         SIGN0_CTX,          // -sign, previous symbol is 0
    00080         SIGN_POS_CTX,       // -sign, previous symbol is +ve
    00081         SIGN_NEG_CTX,       // -sign, previous symbol is -ve
    00082
    00083         // Follow bit contexts
    00084         Z_FBIN1z_CTX,       // -bin 1, parent is zero, neighbours zero
    00085         Z_FBIN1nz_CTX,      // -bin 1, parent is zero, neighbours non-zero
    00086         Z_FBIN2_CTX,        // -bin 2, parent is zero
    00087         Z_FBIN3_CTX,        // -bin 3, parent is zero
    00088         Z_FBIN4_CTX,        // -bin 4, parent is zero
    00089         Z_FBIN5_CTX,        // -bin 5, parent is zero
    00090         Z_FBIN6plus_CTX,    // -bins 6 plus, parent is zero
    00091
    00092         NZ_FBIN1z_CTX,      // -bin 1, parent is non-zero, neighbours zero
    00093         NZ_FBIN1nz_CTX,     // -bin 1, parent is non-zero, neighbours non-zero
    00094         NZ_FBIN2_CTX,       // -bin 2, parent is non-zero
    00095         NZ_FBIN3_CTX,       // -bin 3, parent is non-zero
    00096         NZ_FBIN4_CTX,       // -bin 4, parent is non-zero
    00097         NZ_FBIN5_CTX,       // -bin 5, parent is non-zero
    00098         NZ_FBIN6plus_CTX,   // -bins 6 plus, parent is non-zero
    00099
    00100         // Information bit contexts
    00101         INFO_CTX,
    00102
    00103         BLOCK_SKIP_CTX,     // - blocks are skipped
    00104         Q_OFFSET_FOLLOW_CTX,   // - code block quantiser offset magnitude
    00105         Q_OFFSET_INFO_CTX,  // - code block quantiser offset info context
    00106         Q_OFFSET_SIGN_CTX,   // - code block quantiser offset sign
    00107         TOTAL_COEFF_CTXS   // The total number of coefficient contexts
    00108     };
    00109
    00111     enum MvCtxAliases
    00112     {
    00113         // DC value contexts //
    00115
    00116         // Luma
    00117         YDC_FBIN1_CTX,       // -bin 1 of follow bits
    00118         YDC_FBIN2plus_CTX,   // -remaining follow bins
    00119         YDC_INFO_CTX,        // -info bit context
    00120         YDC_SIGN_CTX,        // -sign context
    00121
    00122         UDC_FBIN1_CTX,
    00123         UDC_FBIN2plus_CTX,
    00124         UDC_INFO_CTX,
    00125         UDC_SIGN_CTX,
    00126
    00127         VDC_FBIN1_CTX,
    00128         VDC_FBIN2plus_CTX,
    00129         VDC_INFO_CTX,
    00130         VDC_SIGN_CTX,
    00131
    00132
    00133         // Motion vector contexts //
    00135
    00136         REF1x_FBIN1_CTX,     // -bin 1 of follow bits
    00137         REF1x_FBIN2_CTX,     // -bin 2 of follow bits
    00138         REF1x_FBIN3_CTX,     // -bin 3 of follows bits
    00139         REF1x_FBIN4_CTX,     // -bin 4 of follow bits
    00140         REF1x_FBIN5plus_CTX, // -bins 5 plus of follow bits
    00141
    00142         REF1x_INFO_CTX,      // context for information bits
    00143
    00144         REF1x_SIGN_CTX,      // -sign
    00145
    00146
    00147         REF1y_FBIN1_CTX,
    00148         REF1y_FBIN2_CTX,
    00149         REF1y_FBIN3_CTX,
    00150         REF1y_FBIN4_CTX,
    00151         REF1y_FBIN5plus_CTX,
    00152
    00153         REF1y_INFO_CTX,
    00154
    00155         REF1y_SIGN_CTX,
    00156
    00157         REF2x_FBIN1_CTX,
    00158         REF2x_FBIN2_CTX,
    00159         REF2x_FBIN3_CTX,
    00160         REF2x_FBIN4_CTX,
    00161         REF2x_FBIN5plus_CTX,
    00162
    00163         REF2x_INFO_CTX,
    00164
    00165         REF2x_SIGN_CTX,
    00166
    00167         REF2y_FBIN1_CTX,
    00168         REF2y_FBIN2_CTX,
    00169         REF2y_FBIN3_CTX,
    00170         REF2y_FBIN4_CTX,
    00171         REF2y_FBIN5plus_CTX,
    00172
    00173         REF2y_INFO_CTX,
    00174
    00175         REF2y_SIGN_CTX,
    00176
    00177
    00178         // Prediction mode contexts
    00179
    00180         PMODE_BIT0_CTX,     // -bit 0, prediction mode value
    00181         PMODE_BIT1_CTX,     // -bin 1, prediction mode value
    00182
    00183
    00184         // Macroblock contexts
    00185
    00186         MB_CMODE_CTX,       // -context for MB common block mode
    00187
    00188         MB_SPLIT_BIN1_CTX,  // bin 1, MB split mode vals
    00189         MB_SPLIT_BIN2_CTX,  // bin 2, MB split mode vals. Bin 3 not required
    00190
    00191         MB_SPLIT_INFO_CTX,  // info context for MB split mode
    00192
    00193         TOTAL_MV_CTXS       // The total number of motion vector contexts
    00194     };
    00195
    00196
    00202     VideoFormat IntToVideoFormat(int video_format);
    00203
    00209     ChromaFormat IntToChromaFormat(int chroma_format);
    00210
    00216     FrameRateType IntToFrameRateType(int frame_rate_idx);
    00217
    00223     AspectRatioType IntToAspectRatioType(int aspect_ratio_idx);
    00224
    00230     SignalRangeType IntToSignalRangeType(int signal_range_idx);
    00231
    00237     MVPrecisionType IntToMVPrecisionType(int mv_prec);
    00238
    00239     //Classes used throughout the codec//
    00242     class FrameSort
    00243     {
    00244     public:
    00245         FrameSort() { fs = 0x00; } // default intra non-ref
    00246
    00247         void SetIntra() { fs &= 0xfe; }
    00248         void SetInter() { fs |= 0x01; }
    00249         void SetNonRef() { fs &= 0xfd; }
    00250         void SetRef() { fs |= 0x02; }
    00251
    00252         bool IsInter () const { return fs & 0x01; }
    00253         bool IsIntra () const { return !IsInter(); }
    00254         bool IsRef() const { return fs & 0x02; };
    00255         bool IsNonRef() const { return !IsRef(); }
    00256
    00257         void SetIntraNonRef() { SetIntra(); SetNonRef(); }
    00258         void SetIntraRef() { SetIntra(); SetRef(); }
    00259         void SetInterNonRef() { SetInter(); SetNonRef(); }
    00260         void SetInterRef() { SetInter(); SetRef(); }
    00261
    00262         bool IsIntraNonRef() const { return (fs & 0x03) == 0x00; }
    00263         bool IsIntraRef() const { return (fs & 0x03) == 0x02; }
    00264         bool IsInterNonRef() const { return (fs & 0x03) == 0x01; }
    00265         bool IsInterRef() const { return (fs & 0x03) == 0x03; }
    00266
    00267         void Clear() { fs=0x00; }
    00268
    00269         static FrameSort IntraRefFrameSort()
    00270         {
    00271             FrameSort fs;
    00272             fs.SetIntraRef();
    00273             return fs;
    00274         }
    00275
    00276         static FrameSort InterRefFrameSort()
    00277         {
    00278             FrameSort fs;
    00279             fs.SetInterRef();
    00280             return fs;
    00281         }
    00282
    00283         static FrameSort IntraNonRefFrameSort()
    00284         {
    00285             FrameSort fs;
    00286             fs.SetIntraNonRef();
    00287             return fs;
    00288         }
    00289
    00290         static FrameSort InterNonRefFrameSort()
    00291         {
    00292             FrameSort fs;
    00293             fs.SetInterNonRef();
    00294             return fs;
    00295         }
    00296
    00297     private:
    00298         unsigned char fs;
    00299     };
    00300
    00302
    00308     class PicArray: public TwoDArray<ValueType>
    00309     {
    00310     public:
    00312
    00315         PicArray(): TwoDArray<ValueType>(){}
    00316
    00318
    00322         PicArray(int height, int width, CompSort cs=Y_COMP);
    00323
    00324         //copy constructor and assignment= derived by inheritance
    00325
    00327         ~PicArray(){}
    00328
    00330         const CompSort& CSort() const;
    00331
    00333         void SetCSort(const CompSort cs);
    00334
    00335     private:
    00336
    00337         CompSort m_csort;
    00338     };
    00339
    00340
    00342     class CostType
    00343     {
    00344     public:
    00346         double MSE;
    00347
    00349         double ENTROPY;
    00350
    00352         double TOTAL;
    00353     };
    00354
    00355
    00357
    00362     class EntropyCorrector
    00363     {
    00364     public:
    00366
    00370         EntropyCorrector(int depth);
    00371
    00373         //NB: Assume default copy constructor, assignment = and destructor//
    00375
    00377
    00381         float Factor(const int bandnum, const FrameSort fsort,const CompSort c) const;
    00382
    00384
    00392         void Update(int bandnum, FrameSort fsort, CompSort c,int est_bits,int actual_bits);
    00393
    00394     private:
    00396         void Init();
    00397
    00398         TwoDArray<float> m_Yfctrs;
    00399         TwoDArray<float> m_Ufctrs;
    00400         TwoDArray<float> m_Vfctrs;
    00401     };
    00402
    00404     class OLBParams
    00405     {
    00406
    00407     public:
    00408
    00410         OLBParams(){}
    00411
    00413         /*
    00414             Constructor rationalises proposed parameters to allow suitable
    00415             overlap and fit in with chroma format
    00416             \param    xblen    the horizontal block length
    00417             \param    yblen    the vertical block length
    00418             \param    xblen    the horizontal block separation
    00419             \param    yblen    the vertical block separation
    00420
    00421         */
    00422         OLBParams(const int xblen, const int yblen,
    00423                   const int xbsep, const int ybsep);
    00424
    00425         // Gets ...
    00426
    00428         int Xblen() const {return m_xblen;}
    00429
    00431         int Yblen() const {return m_yblen;}
    00432
    00434         int Xbsep() const {return m_xbsep;}
    00435
    00437         int Ybsep() const {return m_ybsep;}
    00438
    00440         int Xoffset() const {return m_xoffset;}
    00441
    00443         int Yoffset() const {return m_yoffset;}
    00444
    00445         // ... and sets
    00446
    00448         void SetXblen( int xblen ){ m_xblen = xblen; m_xoffset = (m_xblen-m_xbsep)/2;}
    00449
    00451         void SetYblen( int yblen ){ m_yblen = yblen; m_yoffset = (m_yblen-m_ybsep)/2;}
    00452
    00454         void SetXbsep( int xbsep ){ m_xbsep = xbsep; m_xoffset = (m_xblen-m_xbsep)/2;}
    00455
    00457         void SetYbsep( int ybsep ){ m_ybsep = ybsep; m_yoffset = (m_yblen-m_ybsep)/2;}
    00458
    00459         bool operator == (const OLBParams bparams) const;
    00460
    00461         // overloaded stream operators
    00462         friend std::ostream & operator<< (std::ostream &, OLBParams &);
    00463         friend std::istream & operator>> (std::istream &, OLBParams &);
    00464
    00465
    00466     private:
    00467
    00468         int m_xblen;
    00469         int m_yblen;
    00470         int m_xbsep;
    00471         int m_ybsep;
    00472         int m_xoffset;
    00473         int m_yoffset;
    00474     };
    00475
    00477     class SeqParams
    00478     {
    00479     public:
    00481         SeqParams(const VideoFormat& video_format=VIDEO_FORMAT_CUSTOM,
    00482                   bool set_defaults=true);
    00483
    00485         //NB: Assume default copy constructor, assignment = and destructor//
    00487
    00488         //gets ...
    00490         int Xl() const {return m_xl;}
    00491
    00493         int Yl() const {return m_yl;}
    00494
    00496         ChromaFormat CFormat() const {return m_cformat;}
    00497
    00499         int ChromaWidth() const;
    00500
    00502         int ChromaHeight() const;
    00503
    00505         int BitstreamVersion() const {return m_bs_ver;}
    00506
    00508         VideoFormat GetVideoFormat() const { return m_video_format;}
    00509
    00511         int GetVideoDepth() const { return m_video_depth; }
    00512
    00513         // ... Sets
    00514
    00516         void SetXl(int xlen) {m_xl = xlen;}
    00517
    00519         void SetYl(int ylen) {m_yl = ylen;}
    00520
    00522         void SetCFormat(ChromaFormat cf) {m_cformat=cf;}
    00523
    00525         void SetVideoDepth(int vd){ m_video_depth=vd;}
    00526
    00528         void SetBitstreamVersion(int bs_ver){m_bs_ver=bs_ver;}
    00529
    00530
    00531     private:
    00533         int m_xl;
    00534
    00536         int m_yl;
    00537
    00539         ChromaFormat m_cformat;
    00540
    00542         unsigned char  m_bs_ver;
    00543
    00545         VideoFormat m_video_format;
    00546
    00548         int m_video_depth;
    00549     };
    00550
    00552     class Rational
    00553     {
    00554     public:
    00556         unsigned int m_num;
    00558         unsigned int m_denom;
    00559     };
    00560
    00562     class ParseParams
    00563     {
    00564     public:
    00566         ParseParams(unsigned int au_pnum = 0);
    00567
    00568         // Gets
    00569
    00571         unsigned int AccessUnitPictureNumber() const { return m_au_pnum; }
    00572
    00574         unsigned int MajorVersion() const { return m_major_ver; }
    00575
    00577         unsigned int MinorVersion() const { return m_minor_ver; }
    00578
    00580         unsigned int Profile() const { return m_profile; }
    00581
    00583         unsigned int Level() const { return m_level; }
    00584
    00585         // Sets
    00586
    00588         void SetAccessUnitPictureNumber(unsigned int au_pnum) { m_au_pnum = au_pnum; }
    00589
    00591         void SetMajorVersion(unsigned int major_ver) { m_major_ver = major_ver; }
    00592
    00594         void SetMinorVersion(unsigned int minor_ver) { m_minor_ver = minor_ver; }
    00595
    00597         void SetProfile(unsigned int level) { m_level = level; }
    00598
    00600         void SetLevel(unsigned int profile) { m_profile = profile; }
    00601
    00602     private:
    00604         unsigned int m_au_pnum;
    00606         unsigned int m_major_ver;
    00608         unsigned int m_minor_ver;
    00610         unsigned int m_profile;
    00612         unsigned int m_level;
    00613     };
    00614
    00616     class SourceParams
    00617     {
    00618     public:
    00620         SourceParams (const VideoFormat &vf = VIDEO_FORMAT_CUSTOM,
    00621                       bool set_defaults=true);
    00622
    00624         //NB: Assume default copy constructor, assignment = and destructor//
    00626
    00627         // Gets
    00629         bool Interlace() const { return m_interlace; }
    00630
    00632         bool TopFieldFirst() const { return m_topfieldfirst; }
    00633
    00635         bool SequentialFields() const { return m_seq_fields; }
    00636
    00638         Rational FrameRate() const { return m_framerate; }
    00639
    00641         FrameRateType FrameRateIndex() const { return m_fr_idx; }
    00642
    00644         Rational AspectRatio() const { return m_aspect_ratio; }
    00645
    00647         AspectRatioType AspectRatioIndex() const { return m_asr_idx; }
    00648
    00649         // Clean area parameters
    00651         unsigned int CleanWidth() const { return m_clean_width; }
    00653         unsigned int CleanHeight() const { return m_clean_height; }
    00655         unsigned int LeftOffset() const { return m_left_offset; }
    00657         unsigned int TopOffset() const { return m_top_offset; }
    00658
    00659         // Signal Range parameters
    00660
    00662         SignalRangeType SignalRangeIndex() const { return m_sr_idx; }
    00663
    00665         unsigned int LumaOffset() const { return m_luma_offset; }
    00667         unsigned int LumaExcursion() const { return m_luma_excursion; }
    00669         unsigned int ChromaOffset() const { return m_chroma_offset; }
    00671         unsigned int ChromaExcursion() const { return m_chroma_excursion; }
    00672
    00674         unsigned int ColourSpecificationIndex() const { return m_cs_idx; }
    00675
    00677         ColourPrimaries ColourPrimariesIndex() const { return m_col_primary; }
    00679         ColourMatrix ColourMatrixIndex() const { return m_col_matrix; }
    00681         TransferFunction TransferFunctionIndex() const { return m_transfer_func; }
    00682
    00683         // Sets
    00685         void SetInterlace(bool interlace) { m_interlace = interlace; }
    00686
    00688         void SetTopFieldFirst(bool tff) { m_topfieldfirst = tff; }
    00689
    00691         void SetSequentialFields(bool seq_flds) { m_seq_fields = seq_flds; }
    00692
    00694         void SetFrameRate(const Rational &frate )
    00695         {
    00696             m_fr_idx = FRAMERATE_CUSTOM; m_framerate = frate;
    00697         }
    00698
    00700         void SetFrameRate(unsigned int fr_num, unsigned int fr_denom )
    00701         {
    00702             m_fr_idx = FRAMERATE_CUSTOM;
    00703             m_framerate.m_num = fr_num;
    00704             m_framerate.m_denom = fr_denom;
    00705         }
    00706
    00708         void SetFrameRate(FrameRateType fr);
    00709
    00711         void SetAspectRatio(const Rational &asr)
    00712         {
    00713             m_asr_idx = ASPECT_RATIO_CUSTOM;
    00714             m_aspect_ratio = asr;
    00715         }
    00716
    00718         void SetAspectRatio(unsigned int as_num, unsigned int as_denom )
    00719         {
    00720             m_asr_idx = ASPECT_RATIO_CUSTOM;
    00721             m_aspect_ratio.m_num = as_num;
    00722             m_aspect_ratio.m_denom = as_denom;
    00723         }
    00724
    00726         void SetAspectRatio(AspectRatioType aspect_ratio);
    00727
    00728         // Clean area parameters
    00730         void SetCleanWidth(unsigned int clean_width) { m_clean_width = clean_width; }
    00732         void SetCleanHeight(unsigned int clean_height) { m_clean_height = clean_height; }
    00734         void SetLeftOffset(unsigned int left_offset) { m_left_offset = left_offset; }
    00736         void SetTopOffset(unsigned int top_offset) { m_top_offset = top_offset; }
    00737
    00738         // Signal Range parameters
    00740         void SetSignalRange(SignalRangeType sr);
    00741
    00743         void SetLumaOffset(unsigned int luma_offset) { m_sr_idx = SIGNAL_RANGE_CUSTOM; m_luma_offset = luma_offset; }
    00745         void SetLumaExcursion(unsigned int luma_exc) { m_sr_idx = SIGNAL_RANGE_CUSTOM; m_luma_excursion = luma_exc; }
    00747         void SetChromaOffset(unsigned int chroma_off) { m_sr_idx = SIGNAL_RANGE_CUSTOM; m_chroma_offset = chroma_off; }
    00749         void SetChromaExcursion(unsigned int chroma_exc) { m_sr_idx = SIGNAL_RANGE_CUSTOM; m_chroma_excursion = chroma_exc; }
    00750
    00752         void SetColourSpecification(unsigned int cs_idx);
    00754         void SetColourPrimariesIndex(unsigned int cp);
    00756         void SetColourMatrixIndex(unsigned int cm);
    00758         void SetTransferFunctionIndex(unsigned int tf);
    00759
    00760     private:
    00762         bool m_interlace;
    00763
    00765         bool m_topfieldfirst;
    00766
    00768         bool m_seq_fields;
    00769
    00771         FrameRateType m_fr_idx;
    00772
    00774         Rational m_framerate;
    00775
    00777         AspectRatioType m_asr_idx;
    00778
    00780         Rational m_aspect_ratio;
    00781
    00782         // Clean area parameters
    00783
    00785         unsigned int m_clean_width;
    00786
    00788         unsigned int m_clean_height;
    00789
    00791         unsigned int m_left_offset;
    00792
    00794         unsigned int m_top_offset;
    00795
    00796         // signal range parameters
    00797
    00799         SignalRangeType m_sr_idx;
    00800
    00802         unsigned int m_luma_offset;
    00804         unsigned int m_luma_excursion;
    00806         unsigned int m_chroma_offset;
    00808         unsigned int m_chroma_excursion;
    00809
    00811         unsigned int m_cs_idx;
    00812
    00814         ColourPrimaries m_col_primary;
    00815
    00816         // Colour Matrix index
    00817         ColourMatrix m_col_matrix;
    00818
    00819         // Transfer function index
    00820         TransferFunction m_transfer_func;
    00821     };
    00822
    00824     class FrameParams
    00825     {
    00826
    00827     public:
    00829         FrameParams();
    00830
    00832
    00835         FrameParams(const ChromaFormat& cf, int xlen, int ylen, int c_xlen, int c_ylen, unsigned int video_depth);
    00836
    00838
    00841         FrameParams(const ChromaFormat& cf, const FrameSort& fs);
    00842
    00844         /*
    00845             All data is derived from the sequence parameters
    00846         */
    00847         FrameParams(const SeqParams& sparams);
    00848
    00850         /*
    00851            All data is derived from the sequence parameters
    00852         */
    00853         FrameParams(const SeqParams& sparams, const FrameSort& fs);
    00854
    00856         //NB: Assume default copy constructor, assignment = and destructor//
    00858
    00859         // Gets ...
    00860
    00862         const ChromaFormat& CFormat() const{return m_cformat;}
    00863
    00865         int Xl() const{return m_xl;}
    00866
    00868         int Yl() const{return m_yl;}
    00869
    00871         int ChromaXl() const{return m_chroma_xl;}
    00872
    00874         int ChromaYl() const{return m_chroma_yl;}
    00875
    00877         const FrameSort& FSort() const {return m_fsort;}
    00878
    00880         int FrameNum() const {return m_fnum;}
    00881
    00883         int ExpiryTime() const {return m_expiry_time;}
    00884
    00886         bool Output() const {return m_output;}
    00887
    00889         const std::vector<int>& Refs() const {return m_refs;}
    00890
    00892         std::vector<int>& Refs(){return m_refs;}
    00893
    00895         unsigned int NumRefs()const {return m_refs.size();}
    00896
    00898         FrameType GetFrameType () const { return m_frame_type; }
    00899
    00901         ReferenceType GetReferenceType() const { return m_reference_type;}
    00902
    00904         unsigned int GetVideoDepth() const{return m_video_depth;}
    00905
    00906         // ... Sets
    00907
    00909         void SetFSort( const FrameSort& fs ){ m_fsort=fs; }
    00910
    00912         void SetFrameType(const FrameType& frame_type) { m_frame_type=frame_type; }
    00913
    00915         void SetReferenceType(const ReferenceType& ref_type) { m_reference_type=ref_type; }
    00916
    00918         void SetFrameNum( const int fn ){ m_fnum=fn; }
    00919
    00921         void SetExpiryTime( const int expt ){ m_expiry_time=expt; }
    00922
    00924         void SetAsOutput(){m_output=true;}
    00925
    00927         void SetCFormat(ChromaFormat cf){ m_cformat = cf; }
    00928
    00930         void SetXl(int xl){m_xl = xl; }
    00931
    00933         void SetYl(int yl){m_yl = yl; }
    00934
    00936         void SetChromaXl(int xl){m_chroma_xl = xl; }
    00937
    00939         void SetChromaYl(int yl){m_chroma_yl = yl; }
    00940
    00942         void SetVideoDepth(int vd) { m_video_depth = vd; }
    00943
    00945         std::vector<int>& RetiredFrames() const {return m_retd_list;}
    00946
    00948         std::vector<int>& RetiredFrames() {return m_retd_list;}
    00949
    00950     private:
    00951
    00953         ChromaFormat m_cformat;
    00954
    00956         int m_xl;
    00957
    00959         int m_yl;
    00960
    00962         FrameSort m_fsort;
    00963
    00965         std::vector<int> m_refs;
    00966
    00968         int m_expiry_time;
    00969
    00971         bool m_output;
    00972
    00974         int m_fnum;
    00975
    00977         FrameType m_frame_type;
    00978
    00980         ReferenceType m_reference_type;
    00981
    00983         int m_chroma_xl;
    00984
    00986         int m_chroma_yl;
    00987
    00989         mutable std::vector<int> m_retd_list;
    00990
    00992         unsigned int m_video_depth;
    00993
    00994     };
    00995
    00997     class CodeBlocks
    00998     {
    00999     public:
    01001         CodeBlocks () : m_hblocks(0), m_vblocks(0)
    01002         {}
    01003
    01005         CodeBlocks (unsigned int  hblocks, unsigned int vblocks) :
    01006             m_hblocks(hblocks),
    01007             m_vblocks(vblocks)
    01008             {}
    01009
    01010         // Gets
    01012         unsigned int HorizontalCodeBlocks() const { return m_hblocks; }
    01014         unsigned int VerticalCodeBlocks() const { return m_vblocks; }
    01015         // Sets
    01017         void SetHorizontalCodeBlocks(unsigned int hblocks) { m_hblocks = hblocks; }
    01019         void SetVerticalCodeBlocks(unsigned int vblocks) { m_vblocks = vblocks; }
    01020     private:
    01022         unsigned int m_hblocks;
    01024         unsigned int m_vblocks;
    01025     };
    01027
    01030     class CodecParams
    01031     {
    01032     public:
    01033
    01035         CodecParams(const VideoFormat& vd, FrameType ftype, bool set_defaults);
    01036
    01038             //NB: Assume default copy constructor, assignment = and destructor//
    01040
    01041         // Gets ...
    01042
    01044         int XNumMB() const {return m_x_num_mb;}
    01045
    01047         int YNumMB() const {return m_y_num_mb;}
    01048
    01050         int XNumBlocks() const {return m_x_num_blocks;}
    01051
    01053         int YNumBlocks() const {return m_y_num_blocks;}
    01054
    01056         bool Verbose() const {return m_verbose;}
    01057
    01059         bool Interlace() const {return m_interlace;}
    01060
    01062         bool TopFieldFirst() const {return m_topfieldfirst;}
    01063
    01065         const OLBParams& LumaBParams(int n) const {return m_lbparams[n];}
    01066
    01068         const OLBParams& ChromaBParams(int n) const {return m_cbparams[n];}
    01069
    01071         int OrigXl() const {return m_orig_xl;}
    01072
    01074         int OrigYl() const {return m_orig_yl;}
    01075
    01077         MVPrecisionType MVPrecision() const { return m_mv_precision; }
    01078
    01080         bool ZeroTransform() const { return m_zero_transform; }
    01081
    01083         WltFilter TransformFilter() const { return m_wlt_filter; }
    01084
    01086         unsigned int TransformDepth() const { return m_wlt_depth; }
    01087
    01089         CodeBlockMode GetCodeBlockMode() const { return m_cb_mode; }
    01090
    01092         bool SpatialPartition() const { return m_spatial_partition; }
    01093
    01095         bool DefaultSpatialPartition() const { return m_def_spatial_partition; }
    01097         const CodeBlocks &GetCodeBlocks(unsigned int level) const;
    01098
    01100         VideoFormat GetVideoFormat() const { return m_video_format; }
    01101
    01103         bool UsingGlobalMotion() const { return m_use_global_motion; }
    01104
    01106         unsigned int FrameWeightsBits() const { return m_frame_weights_bits; }
    01107
    01109         unsigned int Ref1Weight() const { return m_ref1_weight; }
    01110
    01112         unsigned int Ref2Weight() const { return m_ref2_weight; }
    01113
    01114         // ... and Sets
    01116         void SetXNumMB(const int xn){m_x_num_mb=xn;}
    01117
    01119         void SetYNumMB(const int yn){m_y_num_mb=yn;}
    01120
    01122         void SetXNumBlocks(const int xn){m_x_num_blocks=xn;}
    01123
    01125         void SetYNumBlocks(const int yn){m_y_num_blocks=yn;}
    01126
    01128         void SetVerbose(bool v){m_verbose=v;}
    01129
    01131         void SetInterlace(bool intlc){m_interlace=intlc;}
    01132
    01134         void SetTopFieldFirst(bool topf){m_topfieldfirst=topf;}
    01135
    01137         void SetBlockSizes(const OLBParams& olbparams , const ChromaFormat cformat);
    01139         void SetLumaBlockParams(const OLBParams& olbparams) {m_lbparams[2] = olbparams;}
    01140
    01142         void SetOrigXl(const int x){m_orig_xl=x;}
    01143
    01145         void SetOrigYl(const int y){m_orig_yl=y;}
    01146
    01148         void SetMVPrecision(const MVPrecisionType p)
    01149         {
    01150             // Assert in debug mode. Maybe we should throw an exception???
    01151             TESTM((p >=0 && p <=3), "Motion precision value in range 0..3");
    01152             m_mv_precision = p;
    01153         }
    01154
    01156         void SetZeroTransform(bool zero_transform)  { m_zero_transform = zero_transform; }
    01157
    01159         void SetTransformFilter(const WltFilter wf) { m_wlt_filter=wf; }
    01160
    01162         void SetTransformFilter(unsigned int wf_idx);
    01163
    01165         void SetTransformDepth(unsigned int wd);
    01166
    01168         void SetCodeBlockMode(unsigned int cb_mode);
    01169
    01171         void SetSpatialPartition(bool spatial_partition) { m_spatial_partition=spatial_partition; }
    01172
    01174         void SetDefaultSpatialPartition(bool def_spatial_partition) { m_def_spatial_partition=def_spatial_partition; }
    01175
    01177         void  SetCodeBlocks(unsigned int level, unsigned int hblocks, unsigned int vblocks);
    01178
    01180         void  SetDefaultCodeBlocks(const FrameType& ftype);
    01181
    01183         void SetVideoFormat(const VideoFormat vd) { m_video_format=vd; }
    01184
    01186         void SetUsingGlobalMotion(bool gm) { m_use_global_motion=gm; }
    01187
    01189         void SetFrameWeightsPrecision(unsigned int wt_prec) { m_frame_weights_bits=wt_prec; }
    01190
    01192         void SetRef1Weight(unsigned int wt) { m_ref1_weight=wt; }
    01193
    01195         void SetRef2Weight(unsigned int wt) { m_ref2_weight=wt; }
    01196
    01197     private:
    01198
    01200         int m_x_num_mb;
    01201
    01203         int m_y_num_mb;
    01204
    01206         int m_x_num_blocks;
    01207
    01209         int m_y_num_blocks;
    01210
    01212         bool m_verbose;
    01213
    01215         bool m_interlace;
    01216
    01218         bool m_topfieldfirst;
    01219
    01220         OneDArray<OLBParams> m_lbparams;
    01221         OneDArray<OLBParams> m_cbparams;
    01222
    01224         int m_orig_xl;
    01225
    01227         int m_orig_yl;
    01228
    01230         MVPrecisionType m_mv_precision;
    01231
    01233         VideoFormat m_video_format;
    01234
    01236         bool m_use_global_motion;
    01237
    01239         unsigned int m_frame_weights_bits;
    01240
    01242         unsigned int m_ref1_weight;
    01243
    01245         unsigned int m_ref2_weight;
    01246
    01248         bool m_zero_transform;
    01249
    01251         WltFilter m_wlt_filter;
    01252
    01254         unsigned int m_wlt_depth;
    01255
    01257         CodeBlockMode m_cb_mode;
    01258
    01260         bool m_spatial_partition;
    01261
    01263         bool m_def_spatial_partition;
    01264
    01266         OneDArray<CodeBlocks> m_cb;
    01267     };
    01268
    01270
    01273     class EncoderParams: public CodecParams
    01274     {
    01275         //codec params plus parameters relating solely to the operation of the encoder
    01276
    01277     public:
    01279         EncoderParams(const VideoFormat& video_format,
    01280                       FrameType ftype = INTER_FRAME,
    01281                       bool set_defaults=true);
    01282
    01284             //NB: Assume default copy constructor, assignment = and destructor//
    01285             //This means pointers are copied, not the objects they point to.////
    01287
    01288          // Gets ...
    01289
    01291         bool LocalDecode() const {return m_loc_decode;}
    01292
    01294         bool Lossless() const {return m_lossless;}
    01295
    01297         float Qf() const {return m_qf;}
    01298
    01300
    01305         int NumL1() const {return m_num_L1;}
    01306
    01308         int L1Sep() const {return m_L1_sep;}
    01309
    01311         float UFactor() const {return m_ufactor;}
    01312
    01314         float VFactor() const {return m_vfactor;}
    01315
    01317         float CPD() const {return m_cpd;}
    01318
    01320         float ILambda() const {return m_I_lambda;}
    01321
    01323         float L1Lambda() const {return m_L1_lambda;}
    01324
    01326         float L2Lambda() const {return m_L2_lambda;}
    01327
    01329         float Lambda(const FrameSort& fsort) const;
    01330
    01332         float L1MELambda() const {return m_L1_me_lambda;}
    01333
    01335         float L2MELambda() const {return m_L2_me_lambda;}
    01336
    01338         int GOPLength() const { if (m_num_L1>0) return (m_num_L1+1)*m_L1_sep;
    01339                                 return (m_num_L1==0) ? 10 : 0; }
    01340
    01342         char * OutputPath() const {return ( char* ) m_output_path.c_str();}
    01343
    01345         const EntropyCorrector& EntropyFactors() const {return *m_ent_correct;}
    01346
    01348         EntropyCorrector& EntropyFactors() {return *m_ent_correct;}
    01349
    01350         // ... and Sets
    01351
    01353         void SetLocalDecode( const bool decode ){m_loc_decode=decode;}
    01354
    01356         void SetLossless(const bool l){m_lossless = l;}
    01357
    01359         void SetQf(const float qfac){m_qf=qfac;}
    01360
    01362         void SetNumL1(const int nl){m_num_L1=nl;}
    01363
    01365         void SetL1Sep(const int lsep){m_L1_sep=lsep;}
    01366
    01368         void SetUFactor(const float uf){m_ufactor=uf;}
    01369
    01371         void SetVFactor(const float vf){m_vfactor=vf;}
    01372
    01374         void SetCPD(const float cpd){m_cpd=cpd;}
    01375
    01377         void SetILambda(const float l){m_I_lambda=l;}
    01378
    01380         void SetL1Lambda(const float l){m_L1_lambda=l;}
    01381
    01383         void SetL2Lambda(const float l){m_L2_lambda=l;}
    01384
    01386         void SetLambda(const FrameSort& fsort, const float l);
    01387
    01389         void SetL1MELambda(const float l){m_L1_me_lambda=l;}
    01390
    01392         void SetL2MELambda(const float l){m_L2_me_lambda=l;}
    01393
    01395         void SetOutputPath(const char * op){ m_output_path = op; }
    01396
    01398         void SetEntropyFactors(EntropyCorrector* entcorrect){m_ent_correct=entcorrect;}
    01399
    01400     private:
    01401
    01403         bool m_loc_decode;
    01404
    01406         bool m_lossless;
    01407
    01409         float m_qf;
    01410
    01412         int m_num_L1;
    01413
    01415         int m_L1_sep;
    01416
    01418         float m_ufactor;
    01419
    01421         float m_vfactor;
    01422
    01424         float m_cpd;
    01425
    01427         float m_I_lambda;
    01428
    01430         float m_L1_lambda;
    01431
    01433         float m_L2_lambda;
    01434
    01436         float m_L1_me_lambda;
    01437
    01439         float m_L2_me_lambda;
    01440
    01442         EntropyCorrector* m_ent_correct;
    01443
    01445         std::string m_output_path;
    01446
    01447
    01448     };
    01449
    01451
    01454     class DecoderParams: public CodecParams
    01455     {
    01456     public:
    01458         DecoderParams(const VideoFormat& video_format = VIDEO_FORMAT_CIF, FrameType ftype=INTRA_FRAME, bool set_defaults = false);
    01459
    01461             //NB: Assume default copy constructor, assignment = and destructor//
    01462             //This means pointers are copied, not the objects they point to.////
    01464
    01465
    01466     private:
    01467
    01468     };
    01469
    01471     inline ValueType BChk(const ValueType &num, const ValueType &max)
    01472     {
    01473         if(num < 0) return 0;
    01474         else if(num >= max) return max-1;
    01475         else return num;
    01476     }
    01477
    01479     class QuantiserLists
    01480     {
    01481     public:
    01483         QuantiserLists();
    01484
    01486         inline int QuantFactor4( const int index ) const {return m_qflist4[index]; }
    01487
    01489         inline int QuantOffset4( const int index ) const {return m_offset4[index]; }
    01490
    01492         inline int MaxQIndex() const {return m_max_qindex; }
    01493
    01494
    01495     private:
    01496         unsigned int m_max_qindex;
    01497         OneDArray<int> m_qflist4;
    01498         OneDArray<int> m_offset4;
    01499
    01500     };
    01501
    01503     static const QuantiserLists dirac_quantiser_lists;
    01504
    01505 } // namespace dirac
    01506
    01507 #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.