/***************************************************************************** * Copyright (C) 2013-2020 MulticoreWare, Inc * * Author: Steve Borho * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA. * * This program is also available under a commercial proprietary license. * For more information, contact us at license @ x265.com. *****************************************************************************/ #ifndef X265_FRAMEDATA_H #define X265_FRAMEDATA_H #include "common.h" #include "slice.h" #include "cudata.h" namespace X265_NS { // private namespace class PicYuv; class JobProvider; #define INTER_MODES 4 // 2Nx2N, 2NxN, Nx2N, AMP modes #define INTRA_MODES 3 // DC, Planar, Angular modes /* Current frame stats for 2 pass */ struct FrameStats { int mvBits; /* MV bits (MV+Ref+Block Type) */ int coeffBits; /* Texture bits (DCT coefs) */ int miscBits; int intra8x8Cnt; int inter8x8Cnt; int skip8x8Cnt; /* CU type counts stored as percentage */ double percent8x8Intra; double percent8x8Inter; double percent8x8Skip; double avgLumaDistortion; double avgChromaDistortion; double avgPsyEnergy; double avgSsimEnergy; double avgResEnergy; double percentIntraNxN; double percentSkipCu[NUM_CU_DEPTH]; double percentMergeCu[NUM_CU_DEPTH]; double percentIntraDistribution[NUM_CU_DEPTH][INTRA_MODES]; double percentInterDistribution[NUM_CU_DEPTH][3]; // 2Nx2N, RECT, AMP modes percentage double ipCostRatio; uint64_t cntIntraNxN; uint64_t totalCu; uint64_t totalCtu; uint64_t lumaDistortion; uint64_t chromaDistortion; uint64_t psyEnergy; int64_t ssimEnergy; uint64_t resEnergy; uint64_t cntSkipCu[NUM_CU_DEPTH]; uint64_t cntMergeCu[NUM_CU_DEPTH]; uint64_t cntInter[NUM_CU_DEPTH]; uint64_t cntIntra[NUM_CU_DEPTH]; uint64_t cuInterDistribution[NUM_CU_DEPTH][INTER_MODES]; uint64_t cuIntraDistribution[NUM_CU_DEPTH][INTRA_MODES]; uint64_t totalPu[NUM_CU_DEPTH + 1]; uint64_t cntSkipPu[NUM_CU_DEPTH]; uint64_t cntIntraPu[NUM_CU_DEPTH]; uint64_t cntAmp[NUM_CU_DEPTH]; uint64_t cnt4x4; uint64_t cntInterPu[NUM_CU_DEPTH][INTER_MODES - 1]; uint64_t cntMergePu[NUM_CU_DEPTH][INTER_MODES - 1]; /* Feature values per row for dynamic refinement */ uint64_t rowRdDyn[MAX_NUM_DYN_REFINE]; uint32_t rowVarDyn[MAX_NUM_DYN_REFINE]; uint32_t rowCntDyn[MAX_NUM_DYN_REFINE]; FrameStats() { memset(this, 0, sizeof(FrameStats)); } }; /* Per-frame data that is used during encodes and referenced while the picture * is available for reference. A FrameData instance is attached to a Frame as it * comes out of the lookahead. Frames which are not being encoded do not have a * FrameData instance. These instances are re-used once the encoded frame has * no active references. They hold the Slice instance and the 'official' CTU * data structures. They are maintained in a free-list pool along together with * a reconstructed image PicYuv in order to conserve memory. */ class FrameData { public: Slice* m_slice; SAOParam* m_saoParam; const x265_param* m_param; FrameData* m_freeListNext; PicYuv* m_reconPic[NUM_RECON_VERSION]; bool m_bHasReferences; /* used during DPB/RPS updates */ int m_frameEncoderID; /* the ID of the FrameEncoder encoding this frame */ JobProvider* m_jobProvider; CUDataMemPool m_cuMemPool; CUData* m_picCTU; RPS* m_spsrps; int m_spsrpsIdx; /* Rate control data used during encode and by references */ struct RCStatCU { uint32_t totalBits; /* total bits to encode this CTU */ uint32_t vbvCost; /* sum of lowres costs for 16x16 sub-blocks */ uint32_t intraVbvCost; /* sum of lowres intra costs for 16x16 sub-blocks */ uint64_t avgCost[4]; /* stores the avg cost of CU's in frame for each depth */ uint32_t count[4]; /* count and avgCost only used by Analysis at RD0..4 */ double baseQp; /* Qp of Cu set from RateControl/Vbv (only used by frame encoder) */ }; struct RCStatRow { uint32_t numEncodedCUs; /* ctuAddr of last encoded CTU in row */ uint32_t encodedBits; /* sum of 'totalBits' of encoded CTUs */ uint32_t satdForVbv; /* sum of lowres (estimated) costs for entire row */ uint32_t intraSatdForVbv; /* sum of lowres (estimated) intra costs for entire row */ uint32_t rowSatd; uint32_t rowIntraSatd; double rowQp; double rowQpScale; double sumQpRc; double sumQpAq; }; RCStatCU* m_cuStat; RCStatRow* m_rowStat; FrameStats m_frameStats; // stats of current frame for multi-pass encodes /* data needed for periodic intra refresh */ struct PeriodicIR { uint32_t pirStartCol; uint32_t pirEndCol; int framesSinceLastPir; }; PeriodicIR m_pir; double m_avgQpRc; /* avg QP as decided by rate-control */ double m_avgQpAq; /* avg QP as decided by AQ in addition to rate-control */ double m_rateFactor; /* calculated based on the Frame QP */ int m_picCsp; uint32_t* m_meIntegral[INTEGRAL_PLANE_NUM]; // 12 integral planes for 32x32, 32x24, 32x8, 24x32, 16x16, 16x12, 16x4, 12x16, 8x32, 8x8, 4x16 and 4x4. uint32_t* m_meBuffer[INTEGRAL_PLANE_NUM]; FrameData(); bool create(const x265_param& param, const SPS& sps, int csp); void reinit(const SPS& sps); void destroy(); inline CUData* getPicCTU(uint32_t ctuAddr) { return &m_picCTU[ctuAddr]; } }; } #endif // ifndef X265_FRAMEDATA_H