Coverage Report

Created: 2022-08-24 06:17

/src/x265/source/common/framedata.h
Line
Count
Source
1
/*****************************************************************************
2
* Copyright (C) 2013-2020 MulticoreWare, Inc
3
*
4
* Author: Steve Borho <steve@borho.org>
5
*
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; either version 2 of the License, or
9
* (at your option) any later version.
10
*
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
* GNU General Public License for more details.
15
*
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the Free Software
18
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
19
*
20
* This program is also available under a commercial proprietary license.
21
* For more information, contact us at license @ x265.com.
22
*****************************************************************************/
23
24
#ifndef X265_FRAMEDATA_H
25
#define X265_FRAMEDATA_H
26
27
#include "common.h"
28
#include "slice.h"
29
#include "cudata.h"
30
31
namespace X265_NS {
32
// private namespace
33
34
class PicYuv;
35
class JobProvider;
36
37
205k
#define INTER_MODES 4 // 2Nx2N, 2NxN, Nx2N, AMP modes
38
164k
#define INTRA_MODES 3 // DC, Planar, Angular modes
39
40
/* Current frame stats for 2 pass */
41
struct FrameStats
42
{
43
    int         mvBits;    /* MV bits (MV+Ref+Block Type) */
44
    int         coeffBits; /* Texture bits (DCT coefs) */
45
    int         miscBits;
46
47
    int         intra8x8Cnt;
48
    int         inter8x8Cnt;
49
    int         skip8x8Cnt;
50
51
    /* CU type counts stored as percentage */
52
    double      percent8x8Intra;
53
    double      percent8x8Inter;
54
    double      percent8x8Skip;
55
    double      avgLumaDistortion;
56
    double      avgChromaDistortion;
57
    double      avgPsyEnergy;
58
    double      avgSsimEnergy;
59
    double      avgResEnergy;
60
    double      percentIntraNxN;
61
    double      percentSkipCu[NUM_CU_DEPTH];
62
    double      percentMergeCu[NUM_CU_DEPTH];
63
    double      percentIntraDistribution[NUM_CU_DEPTH][INTRA_MODES];
64
    double      percentInterDistribution[NUM_CU_DEPTH][3];           // 2Nx2N, RECT, AMP modes percentage
65
    double      ipCostRatio;
66
67
    uint64_t    cntIntraNxN;
68
    uint64_t    totalCu;
69
    uint64_t    totalCtu;
70
    uint64_t    lumaDistortion;
71
    uint64_t    chromaDistortion;
72
    uint64_t    psyEnergy;
73
    int64_t     ssimEnergy;
74
    uint64_t    resEnergy;
75
    uint64_t    cntSkipCu[NUM_CU_DEPTH];
76
    uint64_t    cntMergeCu[NUM_CU_DEPTH];
77
    uint64_t    cntInter[NUM_CU_DEPTH];
78
    uint64_t    cntIntra[NUM_CU_DEPTH];
79
    uint64_t    cuInterDistribution[NUM_CU_DEPTH][INTER_MODES];
80
    uint64_t    cuIntraDistribution[NUM_CU_DEPTH][INTRA_MODES];
81
82
83
    uint64_t    totalPu[NUM_CU_DEPTH + 1];
84
    uint64_t    cntSkipPu[NUM_CU_DEPTH];
85
    uint64_t    cntIntraPu[NUM_CU_DEPTH];
86
    uint64_t    cntAmp[NUM_CU_DEPTH];
87
    uint64_t    cnt4x4;
88
    uint64_t    cntInterPu[NUM_CU_DEPTH][INTER_MODES - 1];
89
    uint64_t    cntMergePu[NUM_CU_DEPTH][INTER_MODES - 1];
90
91
    /* Feature values per row for dynamic refinement */
92
    uint64_t       rowRdDyn[MAX_NUM_DYN_REFINE];
93
    uint32_t       rowVarDyn[MAX_NUM_DYN_REFINE];
94
    uint32_t       rowCntDyn[MAX_NUM_DYN_REFINE];
95
96
    FrameStats()
97
29.5k
    {
98
29.5k
        memset(this, 0, sizeof(FrameStats));
99
29.5k
    }
100
};
101
102
/* Per-frame data that is used during encodes and referenced while the picture
103
 * is available for reference. A FrameData instance is attached to a Frame as it
104
 * comes out of the lookahead. Frames which are not being encoded do not have a
105
 * FrameData instance. These instances are re-used once the encoded frame has
106
 * no active references. They hold the Slice instance and the 'official' CTU
107
 * data structures. They are maintained in a free-list pool along together with
108
 * a reconstructed image PicYuv in order to conserve memory. */
109
class FrameData
110
{
111
public:
112
113
    Slice*         m_slice;
114
    SAOParam*      m_saoParam;
115
    const x265_param* m_param;
116
117
    FrameData*     m_freeListNext;
118
    PicYuv*        m_reconPic;
119
    bool           m_bHasReferences;   /* used during DPB/RPS updates */
120
    int            m_frameEncoderID;   /* the ID of the FrameEncoder encoding this frame */
121
    JobProvider*   m_jobProvider;
122
123
    CUDataMemPool  m_cuMemPool;
124
    CUData*        m_picCTU;
125
126
    RPS*           m_spsrps;
127
    int            m_spsrpsIdx;
128
129
    /* Rate control data used during encode and by references */
130
    struct RCStatCU
131
    {
132
        uint32_t totalBits;     /* total bits to encode this CTU */
133
        uint32_t vbvCost;       /* sum of lowres costs for 16x16 sub-blocks */
134
        uint32_t intraVbvCost;  /* sum of lowres intra costs for 16x16 sub-blocks */
135
        uint64_t avgCost[4];    /* stores the avg cost of CU's in frame for each depth */
136
        uint32_t count[4];      /* count and avgCost only used by Analysis at RD0..4 */
137
        double   baseQp;        /* Qp of Cu set from RateControl/Vbv (only used by frame encoder) */
138
    };
139
140
    struct RCStatRow
141
    {
142
        uint32_t numEncodedCUs; /* ctuAddr of last encoded CTU in row */
143
        uint32_t encodedBits;   /* sum of 'totalBits' of encoded CTUs */
144
        uint32_t satdForVbv;    /* sum of lowres (estimated) costs for entire row */
145
        uint32_t intraSatdForVbv; /* sum of lowres (estimated) intra costs for entire row */
146
        uint32_t rowSatd;
147
        uint32_t rowIntraSatd;
148
        double   rowQp;
149
        double   rowQpScale;
150
        double   sumQpRc;
151
        double   sumQpAq;
152
    };
153
154
    RCStatCU*      m_cuStat;
155
    RCStatRow*     m_rowStat;
156
    FrameStats     m_frameStats; // stats of current frame for multi-pass encodes
157
    /* data needed for periodic intra refresh */
158
    struct PeriodicIR
159
    {
160
        uint32_t   pirStartCol;
161
        uint32_t   pirEndCol;
162
        int        framesSinceLastPir;
163
    };
164
165
    PeriodicIR     m_pir;
166
    double         m_avgQpRc;    /* avg QP as decided by rate-control */
167
    double         m_avgQpAq;    /* avg QP as decided by AQ in addition to rate-control */
168
    double         m_rateFactor; /* calculated based on the Frame QP */
169
    int            m_picCsp;
170
171
    uint32_t*              m_meIntegral[INTEGRAL_PLANE_NUM];       // 12 integral planes for 32x32, 32x24, 32x8, 24x32, 16x16, 16x12, 16x4, 12x16, 8x32, 8x8, 4x16 and 4x4.
172
    uint32_t*              m_meBuffer[INTEGRAL_PLANE_NUM];
173
174
    FrameData();
175
176
    bool create(const x265_param& param, const SPS& sps, int csp);
177
    void reinit(const SPS& sps);
178
    void destroy();
179
86.4M
    inline CUData* getPicCTU(uint32_t ctuAddr) { return &m_picCTU[ctuAddr]; }
180
};
181
182
}
183
#endif // ifndef X265_FRAMEDATA_H