1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/* The copyright in this software is being made available under the BSD
* License, included below. This software may be subject to other third party
* and contributor rights, including patent rights, and no such rights are
* granted under this license.
*
* Copyright (c) 2010-2022, ITU/ISO/IEC
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
/** \file TEncEntropy.h
\brief entropy encoder class (header)
*/
#ifndef __TENCENTROPY__
#define __TENCENTROPY__
#include "TLibCommon/TComSlice.h"
#include "TLibCommon/TComDataCU.h"
#include "TLibCommon/TComBitStream.h"
#include "TLibCommon/ContextModel.h"
#include "TLibCommon/TComPic.h"
#include "TLibCommon/TComTrQuant.h"
#include "TLibCommon/TComSampleAdaptiveOffset.h"
#include "TLibCommon/TComChromaFormat.h"
class TEncSbac;
class TEncCavlc;
class SEI;
// ====================================================================================================================
// Class definition
// ====================================================================================================================
/// entropy encoder pure class
class TEncEntropyIf
{
public:
virtual Void resetEntropy (const TComSlice *pSlice) = 0;
virtual SliceType determineCabacInitIdx (const TComSlice *pSlice) = 0;
virtual Void setBitstream ( TComBitIf* p ) = 0;
virtual Void resetBits () = 0;
virtual UInt getNumberOfWrittenBits() = 0;
virtual Void codeVPS ( const TComVPS* pcVPS ) = 0;
virtual Void codeSPS ( const TComSPS* pcSPS ) = 0;
virtual Void codePPS ( const TComPPS* pcPPS ) = 0;
virtual Void codeSliceHeader ( TComSlice* pcSlice ) = 0;
virtual Void codeTilesWPPEntryPoint ( TComSlice* pSlice ) = 0;
virtual Void codeTerminatingBit ( UInt uilsLast ) = 0;
virtual Void codeSliceFinish () = 0;
virtual Void codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList ) = 0;
public:
virtual Void codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeSkipFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeMergeIndex ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
virtual Void codePartSize ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
virtual Void codePredMode ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeIPCMInfo ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx ) = 0;
virtual Void codeQtCbf ( TComTU &rTu, const ComponentID compID, const Bool lowestLevel ) = 0;
virtual Void codeQtRootCbf ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeQtCbfZero ( TComTU &rTu, const ChannelType chType ) = 0;
virtual Void codeQtRootCbfZero ( ) = 0;
virtual Void codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool isMultiplePU ) = 0;
virtual Void codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeInterDir ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeRefFrmIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList ) = 0;
virtual Void codeMvd ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList ) = 0;
virtual Void codeCrossComponentPrediction( TComTU &rTu, ComponentID compID ) = 0;
virtual Void codeDeltaQP ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeChromaQpAdjustment( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
virtual Void codeCoeffNxN ( TComTU &rTu, TCoeff* pcCoef, const ComponentID compID ) = 0;
virtual Void codeTransformSkipFlags ( TComTU &rTu, ComponentID component ) = 0;
virtual Void codeSAOBlkParam (SAOBlkParam& saoBlkParam, const BitDepths &bitDepths, Bool* sliceEnabled, Bool leftMergeAvail, Bool aboveMergeAvail, Bool onlyEstMergeInfo = false) =0;
virtual Void estBit (estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType, COEFF_SCAN_TYPE scanType) = 0;
virtual Void codeExplicitRdpcmMode ( TComTU &rTu, const ComponentID compID ) = 0;
virtual ~TEncEntropyIf() {}
};
/// entropy encoder class
class TEncEntropy
{
public:
Void setEntropyCoder ( TEncEntropyIf* e );
Void setBitstream ( TComBitIf* p ) { m_pcEntropyCoderIf->setBitstream(p); }
Void resetBits () { m_pcEntropyCoderIf->resetBits(); }
UInt getNumberOfWrittenBits () { return m_pcEntropyCoderIf->getNumberOfWrittenBits(); }
Void resetEntropy (const TComSlice *pSlice) { m_pcEntropyCoderIf->resetEntropy(pSlice); }
SliceType determineCabacInitIdx (const TComSlice *pSlice) { return m_pcEntropyCoderIf->determineCabacInitIdx(pSlice); }
Void encodeSliceHeader ( TComSlice* pcSlice );
Void encodeTilesWPPEntryPoint( TComSlice* pSlice );
Void encodeTerminatingBit ( UInt uiIsLast );
Void encodeSliceFinish ();
TEncEntropyIf* m_pcEntropyCoderIf;
public:
Void encodeVPS ( const TComVPS* pcVPS);
// SPS
Void encodeSPS ( const TComSPS* pcSPS );
Void encodePPS ( const TComPPS* pcPPS );
Void encodeSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD = false );
Void encodeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
Void encodeSkipFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
Void encodePUWise ( TComDataCU* pcCU, UInt uiAbsPartIdx );
Void encodeInterDirPU ( TComDataCU* pcSubCU, UInt uiAbsPartIdx );
Void encodeRefFrmIdxPU ( TComDataCU* pcSubCU, UInt uiAbsPartIdx, RefPicList eRefList );
Void encodeMvdPU ( TComDataCU* pcSubCU, UInt uiAbsPartIdx, RefPicList eRefList );
Void encodeMVPIdxPU ( TComDataCU* pcSubCU, UInt uiAbsPartIdx, RefPicList eRefList );
Void encodeMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx );
Void encodeMergeIndex ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
Void encodePredMode ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
Void encodePartSize ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD = false );
Void encodeIPCMInfo ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
Void encodePredInfo ( TComDataCU* pcCU, UInt uiAbsPartIdx );
Void encodeIntraDirModeLuma ( TComDataCU* pcCU, UInt absPartIdx, Bool isMultiplePU = false );
Void encodeIntraDirModeChroma( TComDataCU* pcCU, UInt uiAbsPartIdx );
Void encodeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx );
Void encodeQtCbf ( TComTU &rTu, const ComponentID compID, const Bool lowestLevel );
Void encodeQtCbfZero ( TComTU &rTu, const ChannelType chType );
Void encodeQtRootCbfZero ( );
Void encodeQtRootCbf ( TComDataCU* pcCU, UInt uiAbsPartIdx );
Void encodeQP ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
Void encodeChromaQpAdjustment ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
Void encodeCrossComponentPrediction( TComTU &rTu, ComponentID compID );
private:
Void xEncodeTransform ( Bool& bCodeDQP, Bool& codeChromaQpAdj, TComTU &rTu );
public:
Void encodeCoeff ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool& bCodeDQP, Bool& codeChromaQpAdj );
Void encodeCoeffNxN ( TComTU &rTu, TCoeff* pcCoef, const ComponentID compID );
Void estimateBit ( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType, COEFF_SCAN_TYPE scanType);
Void encodeSAOBlkParam(SAOBlkParam& saoBlkParam, const BitDepths &bitDepths, Bool* sliceEnabled, Bool leftMergeAvail, Bool aboveMergeAvail){m_pcEntropyCoderIf->codeSAOBlkParam(saoBlkParam, bitDepths, sliceEnabled, leftMergeAvail, aboveMergeAvail, false);}
static Int countNonZeroCoeffs( TCoeff* pcCoef, UInt uiSize );
};// END CLASS DEFINITION TEncEntropy
//! \}
#endif // __TENCENTROPY__
|
