source: 3DVCSoftware/branches/HTM-14.1-update-dev1-HHI/source/Lib/TLibEncoder/TEncSbac.cpp @ 1209

Last change on this file since 1209 was 1209, checked in by hhi, 9 years ago

Alignment and reactivation of DMM and depth encoder optimizations:

  • new macro NH_3D_DMM for DMM functionality, including several clean-ups.
  • new macro NH_3D_SDC for SDC functionality, currently only used for covering common SDC and DMM parts.
  • new macro NH_3D_ENC_DEPTH for encoder optimizations related to depth.
  • temporary macro TEMP_SDC_CLEANUP for covering several proposed cleanups related to SDC and DMM.
  • Property svn:eol-style set to native
File size: 91.5 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2015, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TEncSbac.cpp
35    \brief    SBAC encoder class
36*/
37
38#include "TEncTop.h"
39#include "TEncSbac.h"
40#include "TLibCommon/TComTU.h"
41
42#include <map>
43#include <algorithm>
44
45#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
46#include "../TLibCommon/Debug.h"
47#endif
48
49
50//! \ingroup TLibEncoder
51//! \{
52
53// ====================================================================================================================
54// Constructor / destructor / create / destroy
55// ====================================================================================================================
56
57TEncSbac::TEncSbac()
58// new structure here
59: m_pcBitIf                            ( NULL )
60, m_pcBinIf                            ( NULL )
61, m_numContextModels                   ( 0 )
62, m_cCUSplitFlagSCModel                ( 1,             1,                      NUM_SPLIT_FLAG_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
63, m_cCUSkipFlagSCModel                 ( 1,             1,                      NUM_SKIP_FLAG_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
64#if H_3D
65, m_cCUDISFlagSCModel                  ( 1,             1,                      NUM_DIS_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
66, m_cCUDISTypeSCModel                  ( 1,             1,                      NUM_DIS_TYPE_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
67#endif
68, m_cCUMergeFlagExtSCModel             ( 1,             1,                      NUM_MERGE_FLAG_EXT_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
69, m_cCUMergeIdxExtSCModel              ( 1,             1,                      NUM_MERGE_IDX_EXT_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
70#if H_3D_ARP
71, m_cCUPUARPWSCModel                   ( 1,             1,                      NUM_ARPW_CTX                         , m_contextModels + m_numContextModels, m_numContextModels)
72#endif                                                                                                               
73#if H_3D_IC                                                                                                         
74, m_cCUICFlagSCModel                   ( 1,             1,                      NUM_IC_FLAG_CTX                      , m_contextModels + m_numContextModels, m_numContextModels)
75#endif
76, m_cCUPartSizeSCModel                 ( 1,             1,                      NUM_PART_SIZE_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
77, m_cCUPredModeSCModel                 ( 1,             1,                      NUM_PRED_MODE_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
78, m_cCUIntraPredSCModel                ( 1,             1,                      NUM_INTRA_PREDICT_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
79, m_cCUChromaPredSCModel               ( 1,             1,                      NUM_CHROMA_PRED_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
80, m_cCUDeltaQpSCModel                  ( 1,             1,                      NUM_DELTA_QP_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
81, m_cCUInterDirSCModel                 ( 1,             1,                      NUM_INTER_DIR_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
82, m_cCURefPicSCModel                   ( 1,             1,                      NUM_REF_NO_CTX                       , m_contextModels + m_numContextModels, m_numContextModels)
83, m_cCUMvdSCModel                      ( 1,             1,                      NUM_MV_RES_CTX                       , m_contextModels + m_numContextModels, m_numContextModels)
84, m_cCUQtCbfSCModel                    ( 1,             NUM_QT_CBF_CTX_SETS,    NUM_QT_CBF_CTX_PER_SET               , m_contextModels + m_numContextModels, m_numContextModels)
85, m_cCUTransSubdivFlagSCModel          ( 1,             1,                      NUM_TRANS_SUBDIV_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
86, m_cCUQtRootCbfSCModel                ( 1,             1,                      NUM_QT_ROOT_CBF_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
87, m_cCUSigCoeffGroupSCModel            ( 1,             2,                      NUM_SIG_CG_FLAG_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
88, m_cCUSigSCModel                      ( 1,             1,                      NUM_SIG_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
89, m_cCuCtxLastX                        ( 1,             NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY                 , m_contextModels + m_numContextModels, m_numContextModels)
90, m_cCuCtxLastY                        ( 1,             NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY                 , m_contextModels + m_numContextModels, m_numContextModels)
91, m_cCUOneSCModel                      ( 1,             1,                      NUM_ONE_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
92, m_cCUAbsSCModel                      ( 1,             1,                      NUM_ABS_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
93, m_cMVPIdxSCModel                     ( 1,             1,                      NUM_MVP_IDX_CTX                      , m_contextModels + m_numContextModels, m_numContextModels)
94, m_cSaoMergeSCModel                   ( 1,             1,                      NUM_SAO_MERGE_FLAG_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
95, m_cSaoTypeIdxSCModel                 ( 1,             1,                      NUM_SAO_TYPE_IDX_CTX                 , m_contextModels + m_numContextModels, m_numContextModels)
96, m_cTransformSkipSCModel              ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_TRANSFORMSKIP_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
97, m_CUTransquantBypassFlagSCModel      ( 1,             1,                      NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX    , m_contextModels + m_numContextModels, m_numContextModels)
98, m_explicitRdpcmFlagSCModel           ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_EXPLICIT_RDPCM_FLAG_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
99, m_explicitRdpcmDirSCModel            ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_EXPLICIT_RDPCM_DIR_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
100, m_cCrossComponentPredictionSCModel   ( 1,             1,                      NUM_CROSS_COMPONENT_PREDICTION_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
101, m_ChromaQpAdjFlagSCModel             ( 1,             1,                      NUM_CHROMA_QP_ADJ_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
102, m_ChromaQpAdjIdcSCModel              ( 1,             1,                      NUM_CHROMA_QP_ADJ_IDC_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
103
104#if NH_3D_DMM
105, m_cNotDmmFlagSCModel                 ( 1,             1,                      NUM_NOTDMM_FLAG_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
106, m_cDmmModeSCModel                    ( 1,             1,                      NUM_DMM_MODE_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
107#endif
108#if NH_3D_DMM || NH_3D_SDC
109, m_cDdcDataSCModel                    ( 1,             1,                      NUM_DDC_DATA_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
110#endif
111#if H_3D_DIM_SDC                                                                                                     
112, m_cSDCResidualFlagSCModel            ( 1,             1,                      SDC_NUM_RESIDUAL_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
113, m_cSDCResidualSCModel                ( 1,             1,                      SDC_NUM_RESIDUAL_CTX                 , m_contextModels + m_numContextModels, m_numContextModels)
114, m_cSDCFlagSCModel                    ( 1,             1,                       NUM_SDC_FLAG_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
115, m_cDdcFlagSCModel                    ( 1,             1,                      NUM_DDC_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
116#endif                                                                                                         
117#if H_3D_DBBP                                                                                                 
118, m_cDBBPFlagSCModel                   ( 1,             1,                       DBBP_NUM_FLAG_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
119#endif
120{
121  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
122}
123
124TEncSbac::~TEncSbac()
125{
126}
127
128// ====================================================================================================================
129// Public member functions
130// ====================================================================================================================
131
132Void TEncSbac::resetEntropy           (const TComSlice *pSlice)
133{
134  Int  iQp              = pSlice->getSliceQp();
135  SliceType eSliceType  = pSlice->getSliceType();
136
137  SliceType encCABACTableIdx = pSlice->getEncCABACTableIdx();
138  if (!pSlice->isIntra() && (encCABACTableIdx==B_SLICE || encCABACTableIdx==P_SLICE) && pSlice->getPPS()->getCabacInitPresentFlag())
139  {
140    eSliceType = encCABACTableIdx;
141  }
142
143  m_cCUSplitFlagSCModel.initBuffer                ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
144  m_cCUSkipFlagSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
145#if H_3D
146  m_cCUDISFlagSCModel.initBuffer                  ( eSliceType, iQp, (UChar*)INIT_DIS_FLAG );
147  m_cCUDISTypeSCModel.initBuffer                  ( eSliceType, iQp, (UChar*)INIT_DIS_TYPE );
148#endif
149  m_cCUMergeFlagExtSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
150  m_cCUMergeIdxExtSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
151#if H_3D_ARP
152  m_cCUPUARPWSCModel.initBuffer                   ( eSliceType, iQp, (UChar*)INIT_ARPW );
153#endif
154#if H_3D_IC
155  m_cCUICFlagSCModel.initBuffer                   ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
156#endif
157  m_cCUPartSizeSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
158  m_cCUPredModeSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
159  m_cCUIntraPredSCModel.initBuffer                ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
160  m_cCUChromaPredSCModel.initBuffer               ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
161  m_cCUInterDirSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
162  m_cCUMvdSCModel.initBuffer                      ( eSliceType, iQp, (UChar*)INIT_MVD );
163  m_cCURefPicSCModel.initBuffer                   ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
164  m_cCUDeltaQpSCModel.initBuffer                  ( eSliceType, iQp, (UChar*)INIT_DQP );
165  m_cCUQtCbfSCModel.initBuffer                    ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
166  m_cCUQtRootCbfSCModel.initBuffer                ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
167  m_cCUSigCoeffGroupSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
168  m_cCUSigSCModel.initBuffer                      ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
169  m_cCuCtxLastX.initBuffer                        ( eSliceType, iQp, (UChar*)INIT_LAST );
170  m_cCuCtxLastY.initBuffer                        ( eSliceType, iQp, (UChar*)INIT_LAST );
171  m_cCUOneSCModel.initBuffer                      ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
172  m_cCUAbsSCModel.initBuffer                      ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
173  m_cMVPIdxSCModel.initBuffer                     ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
174  m_cCUTransSubdivFlagSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
175  m_cSaoMergeSCModel.initBuffer                   ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_FLAG );
176  m_cSaoTypeIdxSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
177  m_cTransformSkipSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
178  m_CUTransquantBypassFlagSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
179  m_explicitRdpcmFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_EXPLICIT_RDPCM_FLAG);
180  m_explicitRdpcmDirSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_EXPLICIT_RDPCM_DIR);
181  m_cCrossComponentPredictionSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_CROSS_COMPONENT_PREDICTION  );
182  m_ChromaQpAdjFlagSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CHROMA_QP_ADJ_FLAG );
183  m_ChromaQpAdjIdcSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_CHROMA_QP_ADJ_IDC );
184
185#if NH_3D_DMM
186  m_cNotDmmFlagSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_NOTDMM_FLAG );
187  m_cDmmModeSCModel.initBuffer                    ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
188#endif
189#if NH_3D_DMM || NH_3D_SDC
190  m_cDdcDataSCModel.initBuffer                    ( eSliceType, iQp, (UChar*)INIT_DDC_DATA );
191#endif
192#if H_3D_DIM_SDC                                 
193  m_cSDCResidualFlagSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
194  m_cSDCResidualSCModel.initBuffer                ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
195  m_cSDCFlagSCModel.initBuffer                    ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
196  m_cDdcFlagSCModel.initBuffer                    ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
197#endif                                           
198#if H_3D_DBBP                                   
199  m_cDBBPFlagSCModel.initBuffer                   ( eSliceType, iQp, (UChar*)INIT_DBBP_FLAG );
200#endif
201
202  for (UInt statisticIndex = 0; statisticIndex < RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS ; statisticIndex++)
203  {
204    m_golombRiceAdaptationStatistics[statisticIndex] = 0;
205  }
206
207  m_pcBinIf->start();
208
209  return;
210}
211
212/** The function does the following:
213 * If current slice type is P/B then it determines the distance of initialisation type 1 and 2 from the current CABAC states and
214 * stores the index of the closest table.  This index is used for the next P/B slice when cabac_init_present_flag is true.
215 */
216SliceType TEncSbac::determineCabacInitIdx(const TComSlice *pSlice)
217{
218  Int  qp              = pSlice->getSliceQp();
219
220  if (!pSlice->isIntra())
221  {
222    SliceType aSliceTypeChoices[] = {B_SLICE, P_SLICE};
223
224    UInt bestCost             = MAX_UINT;
225    SliceType bestSliceType   = aSliceTypeChoices[0];
226    for (UInt idx=0; idx<2; idx++)
227    {
228      UInt curCost          = 0;
229      SliceType curSliceType  = aSliceTypeChoices[idx];
230
231      curCost  = m_cCUSplitFlagSCModel.calcCost                ( curSliceType, qp, (UChar*)INIT_SPLIT_FLAG );
232      curCost += m_cCUSkipFlagSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_SKIP_FLAG );
233#if H_3D
234      curCost += m_cCUDISFlagSCModel.calcCost                  ( curSliceType, qp, (UChar*)INIT_DIS_FLAG );
235      curCost += m_cCUDISTypeSCModel.calcCost                  ( curSliceType, qp, (UChar*)INIT_DIS_TYPE );
236#endif
237      curCost += m_cCUMergeFlagExtSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT);
238      curCost += m_cCUMergeIdxExtSCModel.calcCost              ( curSliceType, qp, (UChar*)INIT_MERGE_IDX_EXT);
239#if H_3D_ARP
240      curCost += m_cCUPUARPWSCModel.calcCost                   ( curSliceType, qp, (UChar*)INIT_ARPW );
241#endif                                                     
242#if H_3D_IC                                               
243      curCost += m_cCUICFlagSCModel.calcCost                   ( curSliceType, qp, (UChar*)INIT_IC_FLAG );
244#endif                                                     
245#if H_3D_DIM_SDC                                           
246      curCost += m_cSDCFlagSCModel.calcCost                    ( curSliceType, qp, (UChar*)INIT_SDC_FLAG );
247#endif                                                     
248#if H_3D_DBBP                                             
249      curCost += m_cDBBPFlagSCModel.calcCost                   ( curSliceType, qp, (UChar*)INIT_DBBP_FLAG );
250#endif
251      curCost += m_cCUPartSizeSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_PART_SIZE );
252      curCost += m_cCUPredModeSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_PRED_MODE );
253      curCost += m_cCUIntraPredSCModel.calcCost                ( curSliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
254      curCost += m_cCUChromaPredSCModel.calcCost               ( curSliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
255      curCost += m_cCUInterDirSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_INTER_DIR );
256      curCost += m_cCUMvdSCModel.calcCost                      ( curSliceType, qp, (UChar*)INIT_MVD );
257      curCost += m_cCURefPicSCModel.calcCost                   ( curSliceType, qp, (UChar*)INIT_REF_PIC );
258      curCost += m_cCUDeltaQpSCModel.calcCost                  ( curSliceType, qp, (UChar*)INIT_DQP );
259      curCost += m_cCUQtCbfSCModel.calcCost                    ( curSliceType, qp, (UChar*)INIT_QT_CBF );
260      curCost += m_cCUQtRootCbfSCModel.calcCost                ( curSliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
261      curCost += m_cCUSigCoeffGroupSCModel.calcCost            ( curSliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
262      curCost += m_cCUSigSCModel.calcCost                      ( curSliceType, qp, (UChar*)INIT_SIG_FLAG );
263      curCost += m_cCuCtxLastX.calcCost                        ( curSliceType, qp, (UChar*)INIT_LAST );
264      curCost += m_cCuCtxLastY.calcCost                        ( curSliceType, qp, (UChar*)INIT_LAST );
265      curCost += m_cCUOneSCModel.calcCost                      ( curSliceType, qp, (UChar*)INIT_ONE_FLAG );
266      curCost += m_cCUAbsSCModel.calcCost                      ( curSliceType, qp, (UChar*)INIT_ABS_FLAG );
267      curCost += m_cMVPIdxSCModel.calcCost                     ( curSliceType, qp, (UChar*)INIT_MVP_IDX );
268      curCost += m_cCUTransSubdivFlagSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
269      curCost += m_cSaoMergeSCModel.calcCost                   ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_FLAG );
270      curCost += m_cSaoTypeIdxSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
271      curCost += m_cTransformSkipSCModel.calcCost              ( curSliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
272      curCost += m_CUTransquantBypassFlagSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
273      curCost += m_explicitRdpcmFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_FLAG);
274      curCost += m_explicitRdpcmDirSCModel.calcCost            ( curSliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_DIR);
275      curCost += m_cCrossComponentPredictionSCModel.calcCost   ( curSliceType, qp, (UChar*)INIT_CROSS_COMPONENT_PREDICTION );
276      curCost += m_ChromaQpAdjFlagSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_FLAG );
277      curCost += m_ChromaQpAdjIdcSCModel.calcCost              ( curSliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_IDC );
278#if NH_3D_DMM
279      curCost += m_cNotDmmFlagSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_NOTDMM_FLAG ); 
280      curCost += m_cDmmModeSCModel.calcCost                    ( curSliceType, qp, (UChar*)INIT_DMM_MODE );
281#endif
282#if NH_3D_DMM || NH_3D_SDC
283      curCost += m_cDdcDataSCModel.calcCost                    ( curSliceType, qp, (UChar*)INIT_DDC_DATA );
284#endif
285
286      if (curCost < bestCost)
287      {
288        bestSliceType = curSliceType;
289        bestCost      = curCost;
290      }
291    }
292    return bestSliceType;
293  }
294  else
295  {
296    return I_SLICE;
297  }
298}
299
300#if H_3D
301  m_cCUDISFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_FLAG );
302  m_cCUDISTypeSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_TYPE );
303#endif
304#if H_3D_ARP
305  m_cCUPUARPWSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_ARPW );
306#endif
307#if H_3D_IC
308  m_cCUICFlagSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
309#endif
310#if H_3D_DIM_SDC
311  m_cSDCResidualFlagSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
312  m_cSDCResidualSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
313  m_cSDCFlagSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
314  m_cDdcFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
315#endif
316#if H_3D_DBBP
317  m_cDBBPFlagSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_DBBP_FLAG );
318#endif
319
320
321Void TEncSbac::codeVPS( const TComVPS* /*pcVPS*/ )
322{
323  assert (0);
324  return;
325}
326
327Void TEncSbac::codeSPS( const TComSPS* /*pcSPS*/ )
328{
329  assert (0);
330  return;
331}
332
333Void TEncSbac::codePPS( const TComPPS* /*pcPPS*/ )
334{
335  assert (0);
336  return;
337}
338
339Void TEncSbac::codeSliceHeader( TComSlice* /*pcSlice*/ )
340{
341  assert (0);
342  return;
343}
344
345Void TEncSbac::codeTilesWPPEntryPoint( TComSlice* /*pSlice*/ )
346{
347  assert (0);
348  return;
349}
350
351Void TEncSbac::codeTerminatingBit( UInt uilsLast )
352{
353  m_pcBinIf->encodeBinTrm( uilsLast );
354}
355
356Void TEncSbac::codeSliceFinish()
357{
358  m_pcBinIf->finish();
359}
360
361Void TEncSbac::xWriteUnarySymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset )
362{
363  m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[0] );
364
365  if( 0 == uiSymbol)
366  {
367    return;
368  }
369
370  while( uiSymbol-- )
371  {
372    m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ iOffset ] );
373  }
374
375  return;
376}
377
378Void TEncSbac::xWriteUnaryMaxSymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
379{
380  if (uiMaxSymbol == 0)
381  {
382    return;
383  }
384
385  m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ 0 ] );
386
387  if ( uiSymbol == 0 )
388  {
389    return;
390  }
391
392  Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
393
394  while( --uiSymbol )
395  {
396    m_pcBinIf->encodeBin( 1, pcSCModel[ iOffset ] );
397  }
398  if( bCodeLast )
399  {
400    m_pcBinIf->encodeBin( 0, pcSCModel[ iOffset ] );
401  }
402
403  return;
404}
405
406Void TEncSbac::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
407{
408  UInt bins = 0;
409  Int numBins = 0;
410
411  while( uiSymbol >= (UInt)(1<<uiCount) )
412  {
413    bins = 2 * bins + 1;
414    numBins++;
415    uiSymbol -= 1 << uiCount;
416    uiCount  ++;
417  }
418  bins = 2 * bins + 0;
419  numBins++;
420
421  bins = (bins << uiCount) | uiSymbol;
422  numBins += uiCount;
423
424  assert( numBins <= 32 );
425  m_pcBinIf->encodeBinsEP( bins, numBins );
426}
427
428#if H_3D
429Void TEncSbac::codeDIS( TComDataCU* pcCU, UInt uiAbsPartIdx )
430{
431  UInt uiSymbol = pcCU->getDISFlag(uiAbsPartIdx ) ? 1 : 0;
432  m_pcBinIf->encodeBin( uiSymbol, m_cCUDISFlagSCModel.get( 0, 0, 0 ) );
433  if(uiSymbol)
434  {
435    UInt uiUnaryIdx = (UInt) pcCU->getDISType(uiAbsPartIdx);
436    UInt uiNumCand  = 4;
437
438    if ( uiNumCand > 1 )
439    {
440      for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
441      {
442        const UInt uiSymbol2 = ui == uiUnaryIdx ? 0 : 1;
443        if ( ui == 0 )
444        {
445          m_pcBinIf->encodeBin( uiSymbol2, m_cCUDISTypeSCModel.get( 0, 0, 0 ) );
446        }
447        else
448        {
449          m_pcBinIf->encodeBinEP( uiSymbol2 );
450        }
451        if( uiSymbol2 == 0 )
452        {
453          break;
454        }
455      }
456    }
457  }
458}
459#endif
460
461
462/** Coding of coeff_abs_level_minus3
463 * \param symbol                  value of coeff_abs_level_minus3
464 * \param rParam                  reference to Rice parameter
465 * \param useLimitedPrefixLength
466 * \param maxLog2TrDynamicRange
467 */
468Void TEncSbac::xWriteCoefRemainExGolomb ( UInt symbol, UInt &rParam, const Bool useLimitedPrefixLength, const Int maxLog2TrDynamicRange )
469{
470  Int codeNumber  = (Int)symbol;
471  UInt length;
472
473  if (codeNumber < (COEF_REMAIN_BIN_REDUCTION << rParam))
474  {
475    length = codeNumber>>rParam;
476    m_pcBinIf->encodeBinsEP( (1<<(length+1))-2 , length+1);
477    m_pcBinIf->encodeBinsEP((codeNumber%(1<<rParam)),rParam);
478  }
479  else if (useLimitedPrefixLength)
480  {
481    const UInt maximumPrefixLength = (32 - (COEF_REMAIN_BIN_REDUCTION + maxLog2TrDynamicRange));
482
483    UInt prefixLength = 0;
484    UInt suffixLength = MAX_UINT;
485    UInt codeValue    = (symbol >> rParam) - COEF_REMAIN_BIN_REDUCTION;
486
487    if (codeValue >= ((1 << maximumPrefixLength) - 1))
488    {
489      prefixLength = maximumPrefixLength;
490      suffixLength = maxLog2TrDynamicRange - rParam;
491    }
492    else
493    {
494      while (codeValue > ((2 << prefixLength) - 2))
495      {
496        prefixLength++;
497      }
498
499      suffixLength = prefixLength + 1; //+1 for the separator bit
500    }
501
502    const UInt suffix = codeValue - ((1 << prefixLength) - 1);
503
504    const UInt totalPrefixLength = prefixLength + COEF_REMAIN_BIN_REDUCTION;
505    const UInt prefix            = (1 << totalPrefixLength) - 1;
506    const UInt rParamBitMask     = (1 << rParam) - 1;
507
508    m_pcBinIf->encodeBinsEP(  prefix,                                        totalPrefixLength      ); //prefix
509    m_pcBinIf->encodeBinsEP(((suffix << rParam) | (symbol & rParamBitMask)), (suffixLength + rParam)); //separator, suffix, and rParam bits
510  }
511  else
512  {
513    length = rParam;
514    codeNumber  = codeNumber - ( COEF_REMAIN_BIN_REDUCTION << rParam);
515
516    while (codeNumber >= (1<<length))
517    {
518      codeNumber -=  (1<<(length++));
519    }
520
521    m_pcBinIf->encodeBinsEP((1<<(COEF_REMAIN_BIN_REDUCTION+length+1-rParam))-2,COEF_REMAIN_BIN_REDUCTION+length+1-rParam);
522    m_pcBinIf->encodeBinsEP(codeNumber,length);
523  }
524}
525// SBAC RD
526Void  TEncSbac::load ( const TEncSbac* pSrc)
527{
528  this->xCopyFrom(pSrc);
529}
530
531Void  TEncSbac::loadIntraDirMode( const TEncSbac* pSrc, const ChannelType chType )
532{
533  m_pcBinIf->copyState( pSrc->m_pcBinIf );
534  if (isLuma(chType))
535  {
536    this->m_cCUIntraPredSCModel      .copyFrom( &pSrc->m_cCUIntraPredSCModel       );
537  }
538  else
539  {
540    this->m_cCUChromaPredSCModel     .copyFrom( &pSrc->m_cCUChromaPredSCModel      );
541  }
542}
543
544#if NH_3D_DMM
545Void TEncSbac::loadIntraDepthDmm( const TEncSbac* pSrc )
546{
547  m_pcBinIf->copyState( pSrc->m_pcBinIf );
548  this->m_cNotDmmFlagSCModel.copyFrom( &pSrc->m_cNotDmmFlagSCModel );
549  this->m_cDmmModeSCModel   .copyFrom( &pSrc->m_cDmmModeSCModel );
550}
551#endif
552
553
554Void  TEncSbac::store( TEncSbac* pDest) const
555{
556  pDest->xCopyFrom( this );
557}
558
559
560Void TEncSbac::xCopyFrom( const TEncSbac* pSrc )
561{
562  m_pcBinIf->copyState( pSrc->m_pcBinIf );
563  xCopyContextsFrom(pSrc);
564}
565
566Void TEncSbac::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
567{
568  Int iSymbol = pcCU->getMVPIdx(eRefList, uiAbsPartIdx);
569  Int iNum = AMVP_MAX_NUM_CANDS;
570
571  xWriteUnaryMaxSymbol(iSymbol, m_cMVPIdxSCModel.get(0), 1, iNum-1);
572#if H_MV_ENC_DEC_TRAC
573#if ENC_DEC_TRACE
574  if ( eRefList == REF_PIC_LIST_0 )
575  {
576    DTRACE_PU("mvp_l0_flag", iSymbol)
577  }
578  else
579  {
580    DTRACE_PU("mvp_l1_flag", iSymbol)
581  }
582#endif
583#endif
584}
585
586Void TEncSbac::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
587{
588  PartSize eSize         = pcCU->getPartitionSize( uiAbsPartIdx );
589#if H_3D_QTLPC
590  Bool    bLimQtPredFlag = pcCU->getPic()->getSlice(0)->getQtPredFlag();
591  TComPic *pcTexture     = pcCU->getSlice()->getTexturePic();
592  Bool bDepthMapDetect   = (pcTexture != NULL);
593  Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
594
595  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
596
597  Bool depthDependent = false;
598  UInt uiTexturePart = eSize;
599
600#if H_3D_FCO
601  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag && pcTexture->getReconMark())
602#else
603  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag )
604#endif
605  {
606    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
607    UInt uiCUIdx            = (pcCU->getZorderIdxInCU() == 0) ? uiAbsPartIdx : pcCU->getZorderIdxInCU();
608    assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth);
609    if(pcTextureCU->getDepth(uiCUIdx) == uiDepth )
610    {
611      depthDependent = true;
612      uiTexturePart = pcTextureCU->getPartitionSize( uiCUIdx );
613    }
614    if (pcTextureCU->getDepth(uiCUIdx) == uiDepth && pcTextureCU->getPartitionSize( uiCUIdx ) == SIZE_2Nx2N)
615    {
616      assert( eSize == SIZE_2Nx2N );
617      return;
618    }
619  }
620#endif
621  const UInt log2DiffMaxMinCodingBlockSize = pcCU->getSlice()->getSPS()->getLog2DiffMaxMinCodingBlockSize();
622
623  if ( pcCU->isIntra( uiAbsPartIdx ) )
624  {
625    if( uiDepth == log2DiffMaxMinCodingBlockSize )
626    {
627      m_pcBinIf->encodeBin( eSize == SIZE_2Nx2N? 1 : 0, m_cCUPartSizeSCModel.get( 0, 0, 0 ) );
628#if H_MV_ENC_DEC_TRAC
629      DTRACE_CU("part_mode", eSize == SIZE_2Nx2N? 1 : 0)
630#endif       
631
632    }
633    return;
634  }
635#if H_MV_ENC_DEC_TRAC         
636  DTRACE_CU("part_mode", eSize )
637#endif       
638#if H_3D_QTLPC
639    if (depthDependent==false || uiTexturePart == SIZE_NxN|| uiTexturePart == SIZE_2Nx2N)
640    {
641#endif
642
643  switch(eSize)
644  {
645    case SIZE_2Nx2N:
646    {
647      m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
648      break;
649    }
650    case SIZE_2NxN:
651    case SIZE_2NxnU:
652    case SIZE_2NxnD:
653    {
654      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
655      m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
656      if ( pcCU->getSlice()->getSPS()->getUseAMP() && uiDepth < log2DiffMaxMinCodingBlockSize )
657      {
658        if (eSize == SIZE_2NxN)
659        {
660          m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
661        }
662        else
663        {
664          m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
665          m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
666        }
667      }
668      break;
669    }
670    case SIZE_Nx2N:
671    case SIZE_nLx2N:
672    case SIZE_nRx2N:
673    {
674      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
675      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
676
677      if( uiDepth == log2DiffMaxMinCodingBlockSize && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
678      {
679        m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
680      }
681
682      if ( pcCU->getSlice()->getSPS()->getUseAMP() && uiDepth < log2DiffMaxMinCodingBlockSize )
683      {
684        if (eSize == SIZE_Nx2N)
685        {
686          m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
687        }
688        else
689        {
690          m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
691          m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
692        }
693      }
694      break;
695    }
696    case SIZE_NxN:
697    {
698      if( uiDepth == log2DiffMaxMinCodingBlockSize && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
699      {
700        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
701        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
702        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
703      }
704      break;
705    }
706    default:
707    {
708      assert(0);
709      break;
710    }
711  }
712#if H_3D_QTLPC
713    }
714    else if(uiTexturePart == SIZE_2NxN || uiTexturePart == SIZE_2NxnU || uiTexturePart == SIZE_2NxnD)
715    {
716      //assert(eSize!=SIZE_NxN);
717      //assert(eSize!=SIZE_Nx2N);
718      //assert(eSize==SIZE_2Nx2N || eSize==SIZE_2NxN || eSize==SIZE_2NxnU || eSize==SIZE_2NxnD);
719      switch(eSize)
720      {
721      case SIZE_2Nx2N:
722        {
723          m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
724          break;
725        }
726      case SIZE_2NxN:
727        {
728          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
729          if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
730          {     
731            m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
732          }
733          break;
734        }
735      case SIZE_2NxnU:
736      case SIZE_2NxnD:
737        {
738          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
739          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
740          m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
741          break;
742        }
743      default:
744        {
745          assert(0);
746        }
747      }
748    }
749    else if(uiTexturePart == SIZE_Nx2N|| uiTexturePart==SIZE_nLx2N || uiTexturePart==SIZE_nRx2N)
750    {
751      //assert(eSize!=SIZE_NxN);
752      //assert(eSize!=SIZE_2NxN);
753      //assert(eSize==SIZE_2Nx2N ||eSize==SIZE_Nx2N || eSize==SIZE_nLx2N || eSize==SIZE_nRx2N);
754      switch(eSize)
755      {
756      case SIZE_2Nx2N:
757        {
758          m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
759          break;
760        }
761      case SIZE_Nx2N:
762        {
763          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
764          if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
765          {     
766            m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
767          }
768          break;
769        }
770      case SIZE_nLx2N:
771      case SIZE_nRx2N:
772        {
773          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
774          m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
775          m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
776          break;
777        }
778      default:
779        {
780          assert(0);
781        }
782      }
783    }
784    else
785    {
786      printf("uiTexturePart=%d",uiTexturePart);
787      assert(0);
788    }
789#endif
790
791}
792
793
794/** code prediction mode
795 * \param pcCU
796 * \param uiAbsPartIdx
797 * \returns Void
798 */
799Void TEncSbac::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
800{
801#if H_3D_DIM_SDC
802  if ( pcCU->getSlice()->isIntra() )
803  {
804    assert( pcCU->isIntra(uiAbsPartIdx) );
805    return;
806  }
807#endif
808 
809  // get context function is here
810  m_pcBinIf->encodeBin( pcCU->isIntra( uiAbsPartIdx ) ? 1 : 0, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
811#if H_MV_ENC_DEC_TRAC
812  DTRACE_CU("pred_mode_flag", pcCU->isIntra( uiAbsPartIdx ) ? 1 : 0); 
813#endif
814
815}
816
817Void TEncSbac::codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
818{
819  UInt uiSymbol = pcCU->getCUTransquantBypass(uiAbsPartIdx);
820  m_pcBinIf->encodeBin( uiSymbol, m_CUTransquantBypassFlagSCModel.get( 0, 0, 0 ) );
821#if H_MV_ENC_DEC_TRAC
822  DTRACE_CU("cu_transquant_bypass_flag", uiSymbol); 
823#endif
824
825}
826
827/** code skip flag
828 * \param pcCU
829 * \param uiAbsPartIdx
830 * \returns Void
831 */
832Void TEncSbac::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
833{
834  // get context function is here
835  UInt uiSymbol = pcCU->isSkipped( uiAbsPartIdx ) ? 1 : 0;
836  UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx ) ;
837  m_pcBinIf->encodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
838#if !H_MV_ENC_DEC_TRAC
839  DTRACE_CABAC_VL( g_nSymbolCounter++ );
840  DTRACE_CABAC_T( "\tSkipFlag" );
841  DTRACE_CABAC_T( "\tuiCtxSkip: ");
842  DTRACE_CABAC_V( uiCtxSkip );
843  DTRACE_CABAC_T( "\tuiSymbol: ");
844  DTRACE_CABAC_V( uiSymbol );
845  DTRACE_CABAC_T( "\n");
846#else
847  DTRACE_CU("cu_skip_flag", uiSymbol); 
848#endif
849}
850
851/** code merge flag
852 * \param pcCU
853 * \param uiAbsPartIdx
854 * \returns Void
855 */
856Void TEncSbac::codeMergeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
857{
858  const UInt uiSymbol = pcCU->getMergeFlag( uiAbsPartIdx ) ? 1 : 0;
859  m_pcBinIf->encodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) );
860
861#if H_MV_ENC_DEC_TRAC
862  DTRACE_PU("merge_flag", uiSymbol); 
863#else
864  DTRACE_CABAC_VL( g_nSymbolCounter++ );
865  DTRACE_CABAC_T( "\tMergeFlag: " );
866  DTRACE_CABAC_V( uiSymbol );
867  DTRACE_CABAC_T( "\tAddress: " );
868  DTRACE_CABAC_V( pcCU->getCtuRsAddr() );
869  DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
870  DTRACE_CABAC_V( uiAbsPartIdx );
871  DTRACE_CABAC_T( "\n" );
872#endif
873}
874
875/** code merge index
876 * \param pcCU
877 * \param uiAbsPartIdx
878 * \returns Void
879 */
880Void TEncSbac::codeMergeIndex( TComDataCU* pcCU, UInt uiAbsPartIdx )
881{
882  UInt uiUnaryIdx = pcCU->getMergeIndex( uiAbsPartIdx );
883  UInt uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
884  if ( uiNumCand > 1 )
885  {
886    for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
887    {
888      const UInt uiSymbol = ui == uiUnaryIdx ? 0 : 1;
889      if ( ui==0 )
890      {
891        m_pcBinIf->encodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) );
892      }
893      else
894      {
895        m_pcBinIf->encodeBinEP( uiSymbol );
896      }
897      if( uiSymbol == 0 )
898      {
899        break;
900      }
901    }
902#if H_MV_ENC_DEC_TRAC
903    DTRACE_PU("merge_idx", uiUnaryIdx); 
904#endif
905  }
906#if !H_MV_ENC_DEC_TRAC
907  DTRACE_CABAC_VL( g_nSymbolCounter++ );
908  DTRACE_CABAC_T( "\tparseMergeIndex()" );
909  DTRACE_CABAC_T( "\tuiMRGIdx= " );
910  DTRACE_CABAC_V( pcCU->getMergeIndex( uiAbsPartIdx ) );
911  DTRACE_CABAC_T( "\n" );
912#endif
913}
914
915#if H_3D_ARP
916Void TEncSbac::codeARPW( TComDataCU* pcCU, UInt uiAbsPartIdx )
917{
918  Int  iW = (Int)pcCU->getARPW( uiAbsPartIdx );
919  Int  iMaxW = pcCU->getSlice()->getARPStepNum() - 1;
920  assert( iMaxW > 0);
921
922  Int nOffset = pcCU->getCTXARPWFlag(uiAbsPartIdx);
923  Int nBinNum = iW + ( iW != iMaxW );
924  m_pcBinIf->encodeBin( iW ? 1 : 0 , m_cCUPUARPWSCModel.get( 0, 0, 0 + nOffset ) );
925  if( nBinNum > 1 )
926  {
927     m_pcBinIf->encodeBin( ( iW == iMaxW ) ? 1 : 0, m_cCUPUARPWSCModel.get( 0, 0, 2 ) );
928  }
929#if H_MV_ENC_DEC_TRAC
930  DTRACE_CU("iv_res_pred_weight_idx", iW); 
931#endif
932}
933#endif
934
935#if H_3D_IC
936/** code Illumination Compensation flag
937 * \param pcCU
938 * \param uiAbsPartIdx
939 * \returns Void
940 */
941Void TEncSbac::codeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
942{
943  // get context function is here
944  UInt uiSymbol = pcCU->getICFlag( uiAbsPartIdx ) ? 1 : 0;
945  m_pcBinIf->encodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, 0 ) );
946#if !H_MV_ENC_DEC_TRAC
947  DTRACE_CABAC_VL( g_nSymbolCounter++ );
948  DTRACE_CABAC_T( "\tICFlag" );
949  DTRACE_CABAC_T( "\tuiSymbol: ");
950  DTRACE_CABAC_V( uiSymbol );
951  DTRACE_CABAC_T( "\n");
952#else
953  DTRACE_CU("ic_flag", uiSymbol ); 
954#endif
955}
956#endif
957
958
959Void TEncSbac::codeSplitFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
960{
961  if( uiDepth == pcCU->getSlice()->getSPS()->getLog2DiffMaxMinCodingBlockSize() )
962  {
963    return;
964  }
965
966  UInt uiCtx           = pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth );
967  UInt uiCurrSplitFlag = ( pcCU->getDepth( uiAbsPartIdx ) > uiDepth ) ? 1 : 0;
968
969  assert( uiCtx < 3 );
970#if H_3D_QTLPC
971  Bool bCodeSplitFlag    = true;
972
973 
974  Bool    bLimQtPredFlag = pcCU->getPic()->getSlice(0)->getQtPredFlag(); 
975  TComPic *pcTexture     = pcCU->getSlice()->getTexturePic();
976  Bool bDepthMapDetect   = (pcTexture != NULL);
977  Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
978
979  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
980
981#if H_3D_FCO
982  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag && pcTexture->getReconMark() )
983#else
984  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag  )
985#endif
986  {
987    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
988    UInt uiCUIdx            = (pcCU->getZorderIdxInCU() == 0) ? uiAbsPartIdx : pcCU->getZorderIdxInCU();
989    assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth);
990    bCodeSplitFlag          = (pcTextureCU->getDepth(uiCUIdx) > uiDepth);
991  }
992
993  if(!bCodeSplitFlag)
994  {
995    assert(uiCurrSplitFlag == 0);
996    return;
997  }
998#endif
999
1000  m_pcBinIf->encodeBin( uiCurrSplitFlag, m_cCUSplitFlagSCModel.get( 0, 0, uiCtx ) );
1001#if !H_MV_ENC_DEC_TRAC
1002  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1003  DTRACE_CABAC_T( "\tSplitFlag\n" )
1004#else
1005  DTRACE_CU("split_cu_flag", uiCurrSplitFlag ); 
1006#endif
1007  return;
1008}
1009
1010Void TEncSbac::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
1011{
1012  m_pcBinIf->encodeBin( uiSymbol, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiCtx ) );
1013#if !H_MV_ENC_DEC_TRAC
1014  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1015  DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
1016  DTRACE_CABAC_T( "\tsymbol=" )
1017  DTRACE_CABAC_V( uiSymbol )
1018  DTRACE_CABAC_T( "\tctx=" )
1019  DTRACE_CABAC_V( uiCtx )
1020  DTRACE_CABAC_T( "\n" )
1021#else
1022  DTRACE_TU("split_transform_flag", uiSymbol )
1023#endif
1024
1025}
1026
1027
1028Void TEncSbac::codeIntraDirLumaAng( TComDataCU* pcCU, UInt absPartIdx, Bool isMultiple)
1029{
1030  UInt dir[4],j;
1031  Int preds[4][NUM_MOST_PROBABLE_MODES] = {{-1, -1, -1},{-1, -1, -1},{-1, -1, -1},{-1, -1, -1}};
1032  Int predIdx[4] ={ -1,-1,-1,-1};
1033  PartSize mode = pcCU->getPartitionSize( absPartIdx );
1034  UInt partNum = isMultiple?(mode==SIZE_NxN?4:1):1;
1035  UInt partOffset = ( pcCU->getPic()->getNumPartitionsInCtu() >> ( pcCU->getDepth(absPartIdx) << 1 ) ) >> 2;
1036  for (j=0;j<partNum;j++)
1037  {
1038    dir[j] = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j );
1039#if NH_3D_DMM
1040    if( pcCU->getSlice()->getIntraSdcWedgeFlag() ||  pcCU->getSlice()->getIntraContourFlag() )
1041    {
1042      xCodeIntraDepthMode( pcCU, absPartIdx+partOffset*j );
1043      xCodeDmmData       ( pcCU, absPartIdx+partOffset*j );
1044    }
1045    if( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
1046    {
1047#endif
1048    pcCU->getIntraDirPredictor(absPartIdx+partOffset*j, preds[j], COMPONENT_Y);
1049    for(UInt i = 0; i < NUM_MOST_PROBABLE_MODES; i++)
1050    {
1051      if(dir[j] == preds[j][i])
1052      {
1053        predIdx[j] = i;
1054      }
1055    }
1056    m_pcBinIf->encodeBin((predIdx[j] != -1)? 1 : 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
1057#if H_MV_ENC_DEC_TRAC
1058      DTRACE_CU("prev_intra_luma_pred_flag", (predIdx[j] != -1)? 1 : 0); 
1059#endif
1060#if NH_3D_DMM
1061    }
1062#endif
1063
1064  }
1065  for (j=0;j<partNum;j++)
1066  {
1067#if NH_3D_DMM
1068    if( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
1069    {
1070#endif
1071    if(predIdx[j] != -1)
1072    {
1073      m_pcBinIf->encodeBinEP( predIdx[j] ? 1 : 0 );
1074      if (predIdx[j])
1075      {
1076        m_pcBinIf->encodeBinEP( predIdx[j]-1 );
1077      }
1078#if H_MV_ENC_DEC_TRAC
1079        DTRACE_CU("mpm_idx", predIdx[j] ); 
1080#endif
1081    }
1082    else
1083    {
1084      if (preds[j][0] > preds[j][1])
1085      {
1086        std::swap(preds[j][0], preds[j][1]);
1087      }
1088      if (preds[j][0] > preds[j][2])
1089      {
1090        std::swap(preds[j][0], preds[j][2]);
1091      }
1092      if (preds[j][1] > preds[j][2])
1093      {
1094        std::swap(preds[j][1], preds[j][2]);
1095      }
1096      for(Int i = (Int(NUM_MOST_PROBABLE_MODES) - 1); i >= 0; i--)
1097      {
1098        dir[j] = dir[j] > preds[j][i] ? dir[j] - 1 : dir[j];
1099      }
1100      m_pcBinIf->encodeBinsEP( dir[j], 5 );
1101#if H_MV_ENC_DEC_TRAC
1102        DTRACE_CU("rem_intra_luma_pred_mode", dir[j] ); 
1103#endif
1104    }
1105#if NH_3D_DMM
1106    }
1107#endif
1108  }
1109  return;
1110}
1111
1112Void TEncSbac::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
1113{
1114  UInt uiIntraDirChroma = pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx );
1115
1116  if( uiIntraDirChroma == DM_CHROMA_IDX )
1117  {
1118    m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1119#if H_MV_ENC_DEC_TRAC
1120    DTRACE_CU("intra_chroma_pred_mode", 0 ); 
1121#endif
1122  }
1123  else
1124  {
1125    m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1126
1127    UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
1128    pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
1129
1130    for( Int i = 0; i < NUM_CHROMA_MODE - 1; i++ )
1131    {
1132      if( uiIntraDirChroma == uiAllowedChromaDir[i] )
1133      {
1134        uiIntraDirChroma = i;
1135        break;
1136      }
1137    }
1138
1139    m_pcBinIf->encodeBinsEP( uiIntraDirChroma, 2 );
1140#if H_MV_ENC_DEC_TRAC
1141    DTRACE_CU("intra_chroma_pred_mode", uiIntraDirChroma ); 
1142#endif
1143
1144  }
1145
1146  return;
1147}
1148
1149Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
1150{
1151  const UInt uiInterDir = pcCU->getInterDir( uiAbsPartIdx ) - 1;
1152  const UInt uiCtx      = pcCU->getCtxInterDir( uiAbsPartIdx );
1153  ContextModel *pCtx    = m_cCUInterDirSCModel.get( 0 );
1154
1155  if (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N || pcCU->getHeight(uiAbsPartIdx) != 8 )
1156  {
1157    m_pcBinIf->encodeBin( uiInterDir == 2 ? 1 : 0, *( pCtx + uiCtx ) );
1158  }
1159
1160  if (uiInterDir < 2)
1161  {
1162    m_pcBinIf->encodeBin( uiInterDir, *( pCtx + 4 ) );
1163  }
1164#if H_MV_ENC_DEC_TRAC
1165  DTRACE_PU("inter_pred_idc", uiInterDir ); 
1166#endif
1167
1168  return;
1169}
1170
1171Void TEncSbac::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1172{
1173  Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
1174  ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
1175  m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
1176
1177  if( iRefFrame > 0 )
1178  {
1179    UInt uiRefNum = pcCU->getSlice()->getNumRefIdx( eRefList ) - 2;
1180    pCtx++;
1181    iRefFrame--;
1182    for( UInt ui = 0; ui < uiRefNum; ++ui )
1183    {
1184      const UInt uiSymbol = ui == iRefFrame ? 0 : 1;
1185      if( ui == 0 )
1186      {
1187        m_pcBinIf->encodeBin( uiSymbol, *pCtx );
1188      }
1189      else
1190      {
1191        m_pcBinIf->encodeBinEP( uiSymbol );
1192      }
1193      if( uiSymbol == 0 )
1194      {
1195        break;
1196      }
1197    }
1198  }
1199#if H_MV_ENC_DEC_TRAC
1200#if ENC_DEC_TRACE
1201    iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx ); 
1202    if ( eRefList == REF_PIC_LIST_0 )
1203    {
1204      DTRACE_PU("ref_idx_l0", iRefFrame)
1205    }
1206    else
1207    {
1208      DTRACE_PU("ref_idx_l1", iRefFrame)
1209    }
1210#endif
1211#endif
1212  return;
1213}
1214
1215Void TEncSbac::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1216{
1217  if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
1218  {
1219    return;
1220  }
1221
1222  const TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefList );
1223  const Int iHor = pcCUMvField->getMvd( uiAbsPartIdx ).getHor();
1224  const Int iVer = pcCUMvField->getMvd( uiAbsPartIdx ).getVer();
1225  ContextModel* pCtx = m_cCUMvdSCModel.get( 0 );
1226
1227  m_pcBinIf->encodeBin( iHor != 0 ? 1 : 0, *pCtx );
1228  m_pcBinIf->encodeBin( iVer != 0 ? 1 : 0, *pCtx );
1229
1230  const Bool bHorAbsGr0 = iHor != 0;
1231  const Bool bVerAbsGr0 = iVer != 0;
1232  const UInt uiHorAbs   = 0 > iHor ? -iHor : iHor;
1233  const UInt uiVerAbs   = 0 > iVer ? -iVer : iVer;
1234  pCtx++;
1235
1236  if( bHorAbsGr0 )
1237  {
1238    m_pcBinIf->encodeBin( uiHorAbs > 1 ? 1 : 0, *pCtx );
1239  }
1240
1241  if( bVerAbsGr0 )
1242  {
1243    m_pcBinIf->encodeBin( uiVerAbs > 1 ? 1 : 0, *pCtx );
1244  }
1245
1246  if( bHorAbsGr0 )
1247  {
1248    if( uiHorAbs > 1 )
1249    {
1250      xWriteEpExGolomb( uiHorAbs-2, 1 );
1251    }
1252
1253    m_pcBinIf->encodeBinEP( 0 > iHor ? 1 : 0 );
1254  }
1255
1256  if( bVerAbsGr0 )
1257  {
1258    if( uiVerAbs > 1 )
1259    {
1260      xWriteEpExGolomb( uiVerAbs-2, 1 );
1261    }
1262
1263    m_pcBinIf->encodeBinEP( 0 > iVer ? 1 : 0 );
1264  }
1265
1266  return;
1267}
1268
1269Void TEncSbac::codeCrossComponentPrediction( TComTU &rTu, ComponentID compID )
1270{
1271  TComDataCU *pcCU = rTu.getCU();
1272
1273  if( isLuma(compID) || !pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag() )
1274  {
1275    return;
1276  }
1277
1278  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
1279
1280  if (!pcCU->isIntra(uiAbsPartIdx) || (pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx ) == DM_CHROMA_IDX))
1281  {
1282    DTRACE_CABAC_VL( g_nSymbolCounter++ )
1283    DTRACE_CABAC_T("\tparseCrossComponentPrediction()")
1284    DTRACE_CABAC_T( "\tAddr=" )
1285    DTRACE_CABAC_V( compID )
1286    DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1287    DTRACE_CABAC_V( uiAbsPartIdx )
1288
1289    Int alpha = pcCU->getCrossComponentPredictionAlpha( uiAbsPartIdx, compID );
1290    ContextModel *pCtx = m_cCrossComponentPredictionSCModel.get(0, 0) + ((compID == COMPONENT_Cr) ? (NUM_CROSS_COMPONENT_PREDICTION_CTX >> 1) : 0);
1291    m_pcBinIf->encodeBin(((alpha != 0) ? 1 : 0), pCtx[0]);
1292
1293    if (alpha != 0)
1294    {
1295      static const Int log2AbsAlphaMinus1Table[8] = { 0, 1, 1, 2, 2, 2, 3, 3 };
1296      assert(abs(alpha) <= 8);
1297
1298      if (abs(alpha)>1)
1299      {
1300        m_pcBinIf->encodeBin(1, pCtx[1]);
1301        xWriteUnaryMaxSymbol( log2AbsAlphaMinus1Table[abs(alpha) - 1] - 1, (pCtx + 2), 1, 2 );
1302      }
1303      else
1304      {
1305        m_pcBinIf->encodeBin(0, pCtx[1]);
1306      }
1307      m_pcBinIf->encodeBin( ((alpha < 0) ? 1 : 0), pCtx[4] );
1308    }
1309    DTRACE_CABAC_T( "\tAlpha=" )
1310    DTRACE_CABAC_V( pcCU->getCrossComponentPredictionAlpha( uiAbsPartIdx, compID ) )
1311    DTRACE_CABAC_T( "\n" )
1312  }
1313}
1314
1315Void TEncSbac::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
1316{
1317  Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
1318
1319  Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
1320  iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
1321
1322  UInt uiAbsDQp = (UInt)((iDQp > 0)? iDQp  : (-iDQp));
1323  UInt TUValue = min((Int)uiAbsDQp, CU_DQP_TU_CMAX);
1324  xWriteUnaryMaxSymbol( TUValue, &m_cCUDeltaQpSCModel.get( 0, 0, 0 ), 1, CU_DQP_TU_CMAX);
1325  if( uiAbsDQp >= CU_DQP_TU_CMAX )
1326  {
1327    xWriteEpExGolomb( uiAbsDQp - CU_DQP_TU_CMAX, CU_DQP_EG_k );
1328  }
1329
1330  if ( uiAbsDQp > 0)
1331  {
1332    UInt uiSign = (iDQp > 0 ? 0 : 1);
1333    m_pcBinIf->encodeBinEP(uiSign);
1334  }
1335
1336  return;
1337}
1338
1339/** code chroma qp adjustment, converting from the internal table representation
1340 * \returns Void
1341 */
1342Void TEncSbac::codeChromaQpAdjustment( TComDataCU* cu, UInt absPartIdx )
1343{
1344  Int internalIdc = cu->getChromaQpAdj( absPartIdx );
1345  Int chromaQpOffsetListLen = cu->getSlice()->getPPS()->getPpsRangeExtension().getChromaQpOffsetListLen();
1346  /* internal_idc == 0 => flag = 0
1347   * internal_idc > 1 => code idc value (if table size warrents) */
1348  m_pcBinIf->encodeBin( internalIdc > 0, m_ChromaQpAdjFlagSCModel.get( 0, 0, 0 ) );
1349
1350  if (internalIdc > 0 && chromaQpOffsetListLen > 1)
1351  {
1352    xWriteUnaryMaxSymbol( internalIdc - 1, &m_ChromaQpAdjIdcSCModel.get( 0, 0, 0 ), 0, chromaQpOffsetListLen - 1 );
1353  }
1354}
1355
1356Void TEncSbac::codeQtCbf( TComTU &rTu, const ComponentID compID, const Bool lowestLevel )
1357{
1358  TComDataCU* pcCU = rTu.getCU();
1359
1360  const UInt absPartIdx   = rTu.GetAbsPartIdxTU(compID);
1361  const UInt TUDepth      = rTu.GetTransformDepthRel();
1362        UInt uiCtx        = pcCU->getCtxQtCbf( rTu, toChannelType(compID) );
1363  const UInt contextSet   = toChannelType(compID);
1364
1365  const UInt width        = rTu.getRect(compID).width;
1366  const UInt height       = rTu.getRect(compID).height;
1367  const Bool canQuadSplit = (width >= (MIN_TU_SIZE * 2)) && (height >= (MIN_TU_SIZE * 2));
1368
1369  //             Since the CBF for chroma is coded at the highest level possible, if sub-TUs are
1370  //             to be coded for a 4x8 chroma TU, their CBFs must be coded at the highest 4x8 level
1371  //             (i.e. where luma TUs are 8x8 rather than 4x4)
1372  //    ___ ___
1373  //   |   |   | <- 4 x (8x8 luma + 4x8 4:2:2 chroma)
1374  //   |___|___|    each quadrant has its own chroma CBF
1375  //   |   |   | _ _ _ _
1376  //   |___|___|        |
1377  //   <--16--->        V
1378  //                   _ _
1379  //                  |_|_| <- 4 x 4x4 luma + 1 x 4x8 4:2:2 chroma
1380  //                  |_|_|    no chroma CBF is coded - instead the parent CBF is inherited
1381  //                  <-8->    if sub-TUs are present, their CBFs had to be coded at the parent level
1382
1383  const UInt lowestTUDepth = TUDepth + ((!lowestLevel && !canQuadSplit) ? 1 : 0); //unsplittable TUs inherit their parent's CBF
1384
1385  if ((width != height) && (lowestLevel || !canQuadSplit)) //if sub-TUs are present
1386  {
1387    const UInt subTUDepth        = lowestTUDepth + 1;                      //if this is the lowest level of the TU-tree, the sub-TUs are directly below. Otherwise, this must be the level above the lowest level (as specified above)
1388    const UInt partIdxesPerSubTU = rTu.GetAbsPartIdxNumParts(compID) >> 1;
1389
1390    for (UInt subTU = 0; subTU < 2; subTU++)
1391    {
1392      const UInt subTUAbsPartIdx = absPartIdx + (subTU * partIdxesPerSubTU);
1393      const UInt uiCbf           = pcCU->getCbf(subTUAbsPartIdx, compID, subTUDepth);
1394
1395      m_pcBinIf->encodeBin(uiCbf, m_cCUQtCbfSCModel.get(0, contextSet, uiCtx));
1396#if !H_MV_ENC_DEC_TRAC
1397      DTRACE_CABAC_VL( g_nSymbolCounter++ )
1398      DTRACE_CABAC_T( "\tparseQtCbf()" )
1399      DTRACE_CABAC_T( "\tsub-TU=" )
1400      DTRACE_CABAC_V( subTU )
1401      DTRACE_CABAC_T( "\tsymbol=" )
1402      DTRACE_CABAC_V( uiCbf )
1403      DTRACE_CABAC_T( "\tctx=" )
1404      DTRACE_CABAC_V( uiCtx )
1405      DTRACE_CABAC_T( "\tetype=" )
1406      DTRACE_CABAC_V( compID )
1407      DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1408      DTRACE_CABAC_V( subTUAbsPartIdx )
1409      DTRACE_CABAC_T( "\n" )
1410#else
1411      if ( compID == COMPONENT_Cb )
1412      {
1413        DTRACE_TU("cbf_cb", uiCbf )
1414      }
1415      else if ( compID == COMPONENT_Cr )
1416      {
1417        DTRACE_TU("cbf_cr", uiCbf )
1418      }
1419      else
1420      {
1421        DTRACE_TU("cbf_luma", uiCbf )
1422      }
1423#endif
1424    }
1425  }
1426  else
1427  {
1428    const UInt uiCbf = pcCU->getCbf( absPartIdx, compID, lowestTUDepth );
1429    m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, contextSet, uiCtx ) );
1430#if !H_MV_ENC_DEC_TRAC
1431    DTRACE_CABAC_VL( g_nSymbolCounter++ )
1432    DTRACE_CABAC_T( "\tparseQtCbf()" )
1433    DTRACE_CABAC_T( "\tsymbol=" )
1434    DTRACE_CABAC_V( uiCbf )
1435    DTRACE_CABAC_T( "\tctx=" )
1436    DTRACE_CABAC_V( uiCtx )
1437    DTRACE_CABAC_T( "\tetype=" )
1438    DTRACE_CABAC_V( compID )
1439    DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1440    DTRACE_CABAC_V( rTu.GetAbsPartIdxTU(compID) )
1441    DTRACE_CABAC_T( "\n" )
1442#else
1443    if ( compID == COMPONENT_Cb )
1444    {
1445      DTRACE_TU("cbf_cb", uiCbf )
1446    }
1447    else if ( compID == COMPONENT_Cr )
1448    {
1449      DTRACE_TU("cbf_cr", uiCbf )
1450    }
1451    else
1452    {
1453      DTRACE_TU("cbf_luma", uiCbf )
1454    }
1455#endif
1456
1457  }
1458}
1459
1460
1461Void TEncSbac::codeTransformSkipFlags (TComTU &rTu, ComponentID component )
1462{
1463  TComDataCU* pcCU=rTu.getCU();
1464  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
1465
1466  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1467  {
1468    return;
1469  }
1470
1471  if (!TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(component), pcCU->getSlice()->getPPS()->getPpsRangeExtension().getLog2MaxTransformSkipBlockSize()))
1472  {
1473    return;
1474  }
1475
1476  UInt useTransformSkip = pcCU->getTransformSkip( uiAbsPartIdx,component);
1477  m_pcBinIf->encodeBin( useTransformSkip, m_cTransformSkipSCModel.get( 0, toChannelType(component), 0 ) );
1478#if !H_MV_ENC_DEC_TRAC
1479  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1480  DTRACE_CABAC_T("\tparseTransformSkip()");
1481  DTRACE_CABAC_T( "\tsymbol=" )
1482  DTRACE_CABAC_V( useTransformSkip )
1483  DTRACE_CABAC_T( "\tAddr=" )
1484  DTRACE_CABAC_V( pcCU->getCtuRsAddr() )
1485  DTRACE_CABAC_T( "\tetype=" )
1486  DTRACE_CABAC_V( component )
1487  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1488  DTRACE_CABAC_V( rTu.GetAbsPartIdxTU() )
1489  DTRACE_CABAC_T( "\n" )
1490#endif
1491}
1492
1493
1494/** Code I_PCM information.
1495 * \param pcCU pointer to CU
1496 * \param uiAbsPartIdx CU index
1497 * \returns Void
1498 */
1499Void TEncSbac::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
1500{
1501  UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
1502
1503  Bool writePCMSampleFlag = pcCU->getIPCMFlag(uiAbsPartIdx);
1504
1505  m_pcBinIf->encodeBinTrm (uiIPCM);
1506#if H_MV_ENC_DEC_TRAC         
1507  DTRACE_CU("pcm_flag", uiIPCM)
1508#endif
1509  if (writePCMSampleFlag)
1510  {
1511    m_pcBinIf->encodePCMAlignBits();
1512
1513    const UInt minCoeffSizeY = pcCU->getPic()->getMinCUWidth() * pcCU->getPic()->getMinCUHeight();
1514    const UInt offsetY       = minCoeffSizeY * uiAbsPartIdx;
1515    for (UInt ch=0; ch < pcCU->getPic()->getNumberValidComponents(); ch++)
1516    {
1517      const ComponentID compID = ComponentID(ch);
1518      const UInt offset = offsetY >> (pcCU->getPic()->getComponentScaleX(compID) + pcCU->getPic()->getComponentScaleY(compID));
1519      Pel * pPCMSample  = pcCU->getPCMSample(compID) + offset;
1520      const UInt width  = pcCU->getWidth (uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleX(compID);
1521      const UInt height = pcCU->getHeight(uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleY(compID);
1522      const UInt sampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepth(toChannelType(compID));
1523      for (UInt y=0; y<height; y++)
1524      {
1525        for (UInt x=0; x<width; x++)
1526        {
1527          UInt sample = pPCMSample[x];
1528          m_pcBinIf->xWritePCMCode(sample, sampleBits);
1529        }
1530        pPCMSample += width;
1531      }
1532    }
1533    m_pcBinIf->resetBac();
1534  }
1535}
1536
1537Void TEncSbac::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
1538{
1539  UInt uiCbf = pcCU->getQtRootCbf( uiAbsPartIdx );
1540  UInt uiCtx = 0;
1541  m_pcBinIf->encodeBin( uiCbf , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
1542#if !H_MV_ENC_DEC_TRAC
1543  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1544  DTRACE_CABAC_T( "\tparseQtRootCbf()" )
1545  DTRACE_CABAC_T( "\tsymbol=" )
1546  DTRACE_CABAC_V( uiCbf )
1547  DTRACE_CABAC_T( "\tctx=" )
1548  DTRACE_CABAC_V( uiCtx )
1549  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1550  DTRACE_CABAC_V( uiAbsPartIdx )
1551  DTRACE_CABAC_T( "\n" )
1552#else
1553  DTRACE_CU( "rqt_root_cbf", uiCbf )
1554#endif
1555}
1556
1557Void TEncSbac::codeQtCbfZero( TComTU & rTu, const ChannelType chType )
1558{
1559  // this function is only used to estimate the bits when cbf is 0
1560  // and will never be called when writing the bistream. do not need to write log
1561  UInt uiCbf = 0;
1562  UInt uiCtx = rTu.getCU()->getCtxQtCbf( rTu, chType );
1563
1564  m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, chType, uiCtx ) );
1565}
1566
1567Void TEncSbac::codeQtRootCbfZero( )
1568{
1569  // this function is only used to estimate the bits when cbf is 0
1570  // and will never be called when writing the bistream. do not need to write log
1571  UInt uiCbf = 0;
1572  UInt uiCtx = 0;
1573  m_pcBinIf->encodeBin( uiCbf , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
1574}
1575
1576/** Encode (X,Y) position of the last significant coefficient
1577 * \param uiPosX     X component of last coefficient
1578 * \param uiPosY     Y component of last coefficient
1579 * \param width      Block width
1580 * \param height     Block height
1581 * \param component  chroma component ID
1582 * \param uiScanIdx  scan type (zig-zag, hor, ver)
1583 * This method encodes the X and Y component within a block of the last significant coefficient.
1584 */
1585Void TEncSbac::codeLastSignificantXY( UInt uiPosX, UInt uiPosY, Int width, Int height, ComponentID component, UInt uiScanIdx )
1586{
1587  // swap
1588  if( uiScanIdx == SCAN_VER )
1589  {
1590    swap( uiPosX, uiPosY );
1591    swap( width,  height );
1592  }
1593
1594  UInt uiCtxLast;
1595  UInt uiGroupIdxX    = g_uiGroupIdx[ uiPosX ];
1596  UInt uiGroupIdxY    = g_uiGroupIdx[ uiPosY ];
1597
1598  ContextModel *pCtxX = m_cCuCtxLastX.get( 0, toChannelType(component) );
1599  ContextModel *pCtxY = m_cCuCtxLastY.get( 0, toChannelType(component) );
1600
1601  Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
1602  getLastSignificantContextParameters(component, width, height, blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY);
1603
1604  //------------------
1605
1606  // posX
1607
1608  for( uiCtxLast = 0; uiCtxLast < uiGroupIdxX; uiCtxLast++ )
1609  {
1610    m_pcBinIf->encodeBin( 1, *( pCtxX + blkSizeOffsetX + (uiCtxLast >>shiftX) ) );
1611  }
1612  if( uiGroupIdxX < g_uiGroupIdx[ width - 1 ])
1613  {
1614    m_pcBinIf->encodeBin( 0, *( pCtxX + blkSizeOffsetX + (uiCtxLast >>shiftX) ) );
1615  }
1616
1617  // posY
1618
1619  for( uiCtxLast = 0; uiCtxLast < uiGroupIdxY; uiCtxLast++ )
1620  {
1621    m_pcBinIf->encodeBin( 1, *( pCtxY + blkSizeOffsetY + (uiCtxLast >>shiftY) ) );
1622  }
1623  if( uiGroupIdxY < g_uiGroupIdx[ height - 1 ])
1624  {
1625    m_pcBinIf->encodeBin( 0, *( pCtxY + blkSizeOffsetY + (uiCtxLast >>shiftY) ) );
1626  }
1627
1628  // EP-coded part
1629
1630  if ( uiGroupIdxX > 3 )
1631  {
1632    UInt uiCount = ( uiGroupIdxX - 2 ) >> 1;
1633    uiPosX       = uiPosX - g_uiMinInGroup[ uiGroupIdxX ];
1634    for (Int i = uiCount - 1 ; i >= 0; i-- )
1635    {
1636      m_pcBinIf->encodeBinEP( ( uiPosX >> i ) & 1 );
1637    }
1638  }
1639  if ( uiGroupIdxY > 3 )
1640  {
1641    UInt uiCount = ( uiGroupIdxY - 2 ) >> 1;
1642    uiPosY       = uiPosY - g_uiMinInGroup[ uiGroupIdxY ];
1643    for ( Int i = uiCount - 1 ; i >= 0; i-- )
1644    {
1645      m_pcBinIf->encodeBinEP( ( uiPosY >> i ) & 1 );
1646    }
1647  }
1648}
1649
1650
1651Void TEncSbac::codeCoeffNxN( TComTU &rTu, TCoeff* pcCoef, const ComponentID compID )
1652{
1653  TComDataCU* pcCU=rTu.getCU();
1654  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU(compID);
1655  const TComRectangle &tuRect=rTu.getRect(compID);
1656  const UInt uiWidth=tuRect.width;
1657  const UInt uiHeight=tuRect.height;
1658  const TComSPS &sps=*(pcCU->getSlice()->getSPS());
1659#if !H_MV_ENC_DEC_TRAC
1660
1661  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1662  DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
1663  DTRACE_CABAC_V( compID )
1664  DTRACE_CABAC_T( "\twidth=" )
1665  DTRACE_CABAC_V( uiWidth )
1666  DTRACE_CABAC_T( "\theight=" )
1667  DTRACE_CABAC_V( uiHeight )
1668  DTRACE_CABAC_T( "\tdepth=" )
1669//  DTRACE_CABAC_V( rTu.GetTransformDepthTotalAdj(compID) )
1670  DTRACE_CABAC_V( rTu.GetTransformDepthTotal() )
1671  DTRACE_CABAC_T( "\tabspartidx=" )
1672  DTRACE_CABAC_V( uiAbsPartIdx )
1673  DTRACE_CABAC_T( "\ttoCU-X=" )
1674  DTRACE_CABAC_V( pcCU->getCUPelX() )
1675  DTRACE_CABAC_T( "\ttoCU-Y=" )
1676  DTRACE_CABAC_V( pcCU->getCUPelY() )
1677  DTRACE_CABAC_T( "\tCU-addr=" )
1678  DTRACE_CABAC_V(  pcCU->getCtuRsAddr() )
1679  DTRACE_CABAC_T( "\tinCU-X=" )
1680//  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1681  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
1682  DTRACE_CABAC_T( "\tinCU-Y=" )
1683// DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1684  DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
1685  DTRACE_CABAC_T( "\tpredmode=" )
1686  DTRACE_CABAC_V(  pcCU->getPredictionMode( uiAbsPartIdx ) )
1687  DTRACE_CABAC_T( "\n" )
1688#endif
1689
1690  //--------------------------------------------------------------------------------------------------
1691
1692  if( uiWidth > sps.getMaxTrSize() )
1693  {
1694    std::cerr << "ERROR: codeCoeffNxN was passed a TU with dimensions larger than the maximum allowed size" << std::endl;
1695    assert(false);
1696    exit(1);
1697  }
1698
1699  // compute number of significant coefficients
1700  UInt uiNumSig = TEncEntropy::countNonZeroCoeffs(pcCoef, uiWidth * uiHeight);
1701
1702  if ( uiNumSig == 0 )
1703  {
1704    std::cerr << "ERROR: codeCoeffNxN called for empty TU!" << std::endl;
1705    assert(false);
1706    exit(1);
1707  }
1708
1709  //--------------------------------------------------------------------------------------------------
1710
1711  //set parameters
1712
1713  const ChannelType  chType            = toChannelType(compID);
1714  const UInt         uiLog2BlockWidth  = g_aucConvertToBit[ uiWidth  ] + 2;
1715  const UInt         uiLog2BlockHeight = g_aucConvertToBit[ uiHeight ] + 2;
1716
1717  const ChannelType  channelType       = toChannelType(compID);
1718  const Bool         extendedPrecision = sps.getSpsRangeExtension().getExtendedPrecisionProcessingFlag();
1719
1720  const Bool         alignCABACBeforeBypass = sps.getSpsRangeExtension().getCabacBypassAlignmentEnabledFlag();
1721  const Int          maxLog2TrDynamicRange  = sps.getMaxLog2TrDynamicRange(channelType);
1722
1723  Bool beValid;
1724
1725  {
1726    Int uiIntraMode = -1;
1727    const Bool       bIsLuma = isLuma(compID);
1728    Int isIntra = pcCU->isIntra(uiAbsPartIdx) ? 1 : 0;
1729    if ( isIntra )
1730    {
1731      uiIntraMode = pcCU->getIntraDir( toChannelType(compID), uiAbsPartIdx );
1732
1733      const UInt partsPerMinCU = 1<<(2*(sps.getMaxTotalCUDepth() - sps.getLog2DiffMaxMinCodingBlockSize()));
1734      uiIntraMode = (uiIntraMode==DM_CHROMA_IDX && !bIsLuma) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, rTu.GetChromaFormat(), partsPerMinCU)) : uiIntraMode;
1735      uiIntraMode = ((rTu.GetChromaFormat() == CHROMA_422) && !bIsLuma) ? g_chroma422IntraAngleMappingTable[uiIntraMode] : uiIntraMode;
1736    }
1737
1738    Int transformSkip = pcCU->getTransformSkip( uiAbsPartIdx,compID) ? 1 : 0;
1739    Bool rdpcm_lossy = ( transformSkip && isIntra && ( (uiIntraMode == HOR_IDX) || (uiIntraMode == VER_IDX) ) ) && pcCU->isRDPCMEnabled(uiAbsPartIdx);
1740
1741    if ( (pcCU->getCUTransquantBypass(uiAbsPartIdx)) || rdpcm_lossy )
1742    {
1743      beValid = false;
1744      if ( (!pcCU->isIntra(uiAbsPartIdx)) && pcCU->isRDPCMEnabled(uiAbsPartIdx))
1745      {
1746        codeExplicitRdpcmMode( rTu, compID);
1747      }
1748    }
1749    else
1750    {
1751      beValid = pcCU->getSlice()->getPPS()->getSignHideFlag();
1752    }
1753  }
1754
1755  //--------------------------------------------------------------------------------------------------
1756
1757  if(pcCU->getSlice()->getPPS()->getUseTransformSkip())
1758  {
1759    codeTransformSkipFlags(rTu, compID);
1760    if(pcCU->getTransformSkip(uiAbsPartIdx, compID) && !pcCU->isIntra(uiAbsPartIdx) && pcCU->isRDPCMEnabled(uiAbsPartIdx))
1761    {
1762      //  This TU has coefficients and is transform skipped. Check whether is inter coded and if yes encode the explicit RDPCM mode
1763      codeExplicitRdpcmMode( rTu, compID);
1764
1765      if(pcCU->getExplicitRdpcmMode(compID, uiAbsPartIdx) != RDPCM_OFF)
1766      {
1767        //  Sign data hiding is avoided for horizontal and vertical explicit RDPCM modes
1768        beValid = false;
1769      }
1770    }
1771  }
1772
1773  //--------------------------------------------------------------------------------------------------
1774
1775  const Bool  bUseGolombRiceParameterAdaptation = sps.getSpsRangeExtension().getPersistentRiceAdaptationEnabledFlag();
1776        UInt &currentGolombRiceStatistic        = m_golombRiceAdaptationStatistics[rTu.getGolombRiceStatisticsIndex(compID)];
1777
1778  //select scans
1779  TUEntropyCodingParameters codingParameters;
1780  getTUEntropyCodingParameters(codingParameters, rTu, compID);
1781
1782  //----- encode significance map -----
1783
1784  // Find position of last coefficient
1785  Int scanPosLast = -1;
1786  Int posLast;
1787
1788
1789  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
1790
1791  memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
1792  do
1793  {
1794    posLast = codingParameters.scan[ ++scanPosLast ];
1795
1796    if( pcCoef[ posLast ] != 0 )
1797    {
1798      // get L1 sig map
1799      UInt uiPosY   = posLast >> uiLog2BlockWidth;
1800      UInt uiPosX   = posLast - ( uiPosY << uiLog2BlockWidth );
1801
1802      UInt uiBlkIdx = (codingParameters.widthInGroups * (uiPosY >> MLS_CG_LOG2_HEIGHT)) + (uiPosX >> MLS_CG_LOG2_WIDTH);
1803      uiSigCoeffGroupFlag[ uiBlkIdx ] = 1;
1804
1805      uiNumSig--;
1806    }
1807  } while ( uiNumSig > 0 );
1808
1809  // Code position of last coefficient
1810  Int posLastY = posLast >> uiLog2BlockWidth;
1811  Int posLastX = posLast - ( posLastY << uiLog2BlockWidth );
1812  codeLastSignificantXY(posLastX, posLastY, uiWidth, uiHeight, compID, codingParameters.scanType);
1813
1814  //===== code significance flag =====
1815  ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, chType );
1816  ContextModel * const baseCtx = m_cCUSigSCModel.get( 0, 0 ) + getSignificanceMapContextOffset(compID);
1817
1818  const Int  iLastScanSet  = scanPosLast >> MLS_CG_SIZE;
1819
1820  UInt c1                  = 1;
1821  UInt uiGoRiceParam       = 0;
1822  Int  iScanPosSig         = scanPosLast;
1823
1824  for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
1825  {
1826    Int numNonZero = 0;
1827    Int  iSubPos   = iSubSet << MLS_CG_SIZE;
1828    uiGoRiceParam  = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
1829    Bool updateGolombRiceStatistics = bUseGolombRiceParameterAdaptation; //leave the statistics at 0 when not using the adaptation system
1830    UInt coeffSigns = 0;
1831
1832    Int absCoeff[1 << MLS_CG_SIZE];
1833
1834    Int lastNZPosInCG  = -1;
1835    Int firstNZPosInCG = 1 << MLS_CG_SIZE;
1836
1837    Bool escapeDataPresentInGroup = false;
1838
1839    if( iScanPosSig == scanPosLast )
1840    {
1841      absCoeff[ 0 ] = Int(abs( pcCoef[ posLast ] ));
1842      coeffSigns    = ( pcCoef[ posLast ] < 0 );
1843      numNonZero    = 1;
1844      lastNZPosInCG  = iScanPosSig;
1845      firstNZPosInCG = iScanPosSig;
1846      iScanPosSig--;
1847    }
1848
1849    // encode significant_coeffgroup_flag
1850    Int iCGBlkPos = codingParameters.scanCG[ iSubSet ];
1851    Int iCGPosY   = iCGBlkPos / codingParameters.widthInGroups;
1852    Int iCGPosX   = iCGBlkPos - (iCGPosY * codingParameters.widthInGroups);
1853
1854    if( iSubSet == iLastScanSet || iSubSet == 0)
1855    {
1856      uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
1857    }
1858    else
1859    {
1860      UInt uiSigCoeffGroup   = (uiSigCoeffGroupFlag[ iCGBlkPos ] != 0);
1861      UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups );
1862      m_pcBinIf->encodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
1863    }
1864
1865    // encode significant_coeff_flag
1866    if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
1867    {
1868      const Int patternSigCtx = TComTrQuant::calcPatternSigCtx(uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups);
1869
1870      UInt uiBlkPos, uiSig, uiCtxSig;
1871      for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
1872      {
1873        uiBlkPos  = codingParameters.scan[ iScanPosSig ];
1874        uiSig     = (pcCoef[ uiBlkPos ] != 0);
1875        if( iScanPosSig > iSubPos || iSubSet == 0 || numNonZero )
1876        {
1877          uiCtxSig  = TComTrQuant::getSigCtxInc( patternSigCtx, codingParameters, iScanPosSig, uiLog2BlockWidth, uiLog2BlockHeight, chType );
1878          m_pcBinIf->encodeBin( uiSig, baseCtx[ uiCtxSig ] );
1879        }
1880        if( uiSig )
1881        {
1882          absCoeff[ numNonZero ] = Int(abs( pcCoef[ uiBlkPos ] ));
1883          coeffSigns = 2 * coeffSigns + ( pcCoef[ uiBlkPos ] < 0 );
1884          numNonZero++;
1885          if( lastNZPosInCG == -1 )
1886          {
1887            lastNZPosInCG = iScanPosSig;
1888          }
1889          firstNZPosInCG = iScanPosSig;
1890        }
1891      }
1892    }
1893    else
1894    {
1895      iScanPosSig = iSubPos - 1;
1896    }
1897
1898    if( numNonZero > 0 )
1899    {
1900      Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= SBH_THRESHOLD );
1901
1902      const UInt uiCtxSet = getContextSetIndex(compID, iSubSet, (c1 == 0));
1903      c1 = 1;
1904
1905      ContextModel *baseCtxMod = m_cCUOneSCModel.get( 0, 0 ) + (NUM_ONE_FLAG_CTX_PER_SET * uiCtxSet);
1906
1907      Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
1908      Int firstC2FlagIdx = -1;
1909      for( Int idx = 0; idx < numC1Flag; idx++ )
1910      {
1911        UInt uiSymbol = absCoeff[ idx ] > 1;
1912        m_pcBinIf->encodeBin( uiSymbol, baseCtxMod[c1] );
1913        if( uiSymbol )
1914        {
1915          c1 = 0;
1916
1917          if (firstC2FlagIdx == -1)
1918          {
1919            firstC2FlagIdx = idx;
1920          }
1921          else //if a greater-than-one has been encountered already this group
1922          {
1923            escapeDataPresentInGroup = true;
1924          }
1925        }
1926        else if( (c1 < 3) && (c1 > 0) )
1927        {
1928          c1++;
1929        }
1930      }
1931
1932      if (c1 == 0)
1933      {
1934        baseCtxMod = m_cCUAbsSCModel.get( 0, 0 ) + (NUM_ABS_FLAG_CTX_PER_SET * uiCtxSet);
1935        if ( firstC2FlagIdx != -1)
1936        {
1937          UInt symbol = absCoeff[ firstC2FlagIdx ] > 2;
1938          m_pcBinIf->encodeBin( symbol, baseCtxMod[0] );
1939          if (symbol != 0)
1940          {
1941            escapeDataPresentInGroup = true;
1942          }
1943        }
1944      }
1945
1946      escapeDataPresentInGroup = escapeDataPresentInGroup || (numNonZero > C1FLAG_NUMBER);
1947
1948      if (escapeDataPresentInGroup && alignCABACBeforeBypass)
1949      {
1950        m_pcBinIf->align();
1951      }
1952
1953      if( beValid && signHidden )
1954      {
1955        m_pcBinIf->encodeBinsEP( (coeffSigns >> 1), numNonZero-1 );
1956      }
1957      else
1958      {
1959        m_pcBinIf->encodeBinsEP( coeffSigns, numNonZero );
1960      }
1961
1962      Int iFirstCoeff2 = 1;
1963      if (escapeDataPresentInGroup)
1964      {
1965        for ( Int idx = 0; idx < numNonZero; idx++ )
1966        {
1967          UInt baseLevel  = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2 ) : 1;
1968
1969          if( absCoeff[ idx ] >= baseLevel)
1970          {
1971            const UInt escapeCodeValue = absCoeff[idx] - baseLevel;
1972
1973            xWriteCoefRemainExGolomb( escapeCodeValue, uiGoRiceParam, extendedPrecision, maxLog2TrDynamicRange );
1974
1975            if (absCoeff[idx] > (3 << uiGoRiceParam))
1976            {
1977              uiGoRiceParam = bUseGolombRiceParameterAdaptation ? (uiGoRiceParam + 1) : (std::min<UInt>((uiGoRiceParam + 1), 4));
1978            }
1979
1980            if (updateGolombRiceStatistics)
1981            {
1982              const UInt initialGolombRiceParameter = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
1983
1984              if (escapeCodeValue >= (3 << initialGolombRiceParameter))
1985              {
1986                currentGolombRiceStatistic++;
1987              }
1988              else if (((escapeCodeValue * 2) < (1 << initialGolombRiceParameter)) && (currentGolombRiceStatistic > 0))
1989              {
1990                currentGolombRiceStatistic--;
1991              }
1992
1993              updateGolombRiceStatistics = false;
1994            }
1995          }
1996
1997          if(absCoeff[ idx ] >= 2)
1998          {
1999            iFirstCoeff2 = 0;
2000          }
2001        }
2002      }
2003    }
2004  }
2005#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
2006  printSBACCoeffData(posLastX, posLastY, uiWidth, uiHeight, compID, uiAbsPartIdx, codingParameters.scanType, pcCoef, pcCU->getSlice()->getFinalized());
2007#endif
2008
2009  return;
2010}
2011
2012/** code SAO offset sign
2013 * \param code sign value
2014 */
2015Void TEncSbac::codeSAOSign( UInt code )
2016{
2017  m_pcBinIf->encodeBinEP( code );
2018}
2019
2020Void TEncSbac::codeSaoMaxUvlc    ( UInt code, UInt maxSymbol )
2021{
2022  if (maxSymbol == 0)
2023  {
2024    return;
2025  }
2026
2027  Int i;
2028  Bool bCodeLast = ( maxSymbol > code );
2029
2030  if ( code == 0 )
2031  {
2032    m_pcBinIf->encodeBinEP( 0 );
2033  }
2034  else
2035  {
2036    m_pcBinIf->encodeBinEP( 1 );
2037    for ( i=0; i<code-1; i++ )
2038    {
2039      m_pcBinIf->encodeBinEP( 1 );
2040    }
2041    if( bCodeLast )
2042    {
2043      m_pcBinIf->encodeBinEP( 0 );
2044    }
2045  }
2046}
2047
2048/** Code SAO EO class or BO band position
2049 */
2050Void TEncSbac::codeSaoUflc       ( UInt uiLength, UInt uiCode )
2051{
2052  m_pcBinIf->encodeBinsEP ( uiCode, uiLength );
2053}
2054
2055/** Code SAO merge flags
2056 */
2057Void TEncSbac::codeSaoMerge       ( UInt uiCode )
2058{
2059  m_pcBinIf->encodeBin(((uiCode == 0) ? 0 : 1),  m_cSaoMergeSCModel.get( 0, 0, 0 ));
2060}
2061
2062/** Code SAO type index
2063 */
2064Void TEncSbac::codeSaoTypeIdx       ( UInt uiCode)
2065{
2066  if (uiCode == 0)
2067  {
2068    m_pcBinIf->encodeBin( 0, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2069  }
2070  else
2071  {
2072    m_pcBinIf->encodeBin( 1, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2073    m_pcBinIf->encodeBinEP( uiCode == 1 ? 0 : 1 );
2074  }
2075}
2076
2077Void TEncSbac::codeSAOOffsetParam(ComponentID compIdx, SAOOffset& ctbParam, Bool sliceEnabled, const Int channelBitDepth)
2078{
2079  UInt uiSymbol;
2080  if(!sliceEnabled)
2081  {
2082    assert(ctbParam.modeIdc == SAO_MODE_OFF);
2083    return;
2084  }
2085  const Bool bIsFirstCompOfChType = (getFirstComponentOfChannel(toChannelType(compIdx)) == compIdx);
2086
2087  //type
2088  if(bIsFirstCompOfChType)
2089  {
2090    //sao_type_idx_luma or sao_type_idx_chroma
2091    if(ctbParam.modeIdc == SAO_MODE_OFF)
2092    {
2093      uiSymbol =0;
2094    }
2095    else if(ctbParam.typeIdc == SAO_TYPE_BO) //BO
2096    {
2097      uiSymbol = 1;
2098    }
2099    else
2100    {
2101      assert(ctbParam.typeIdc < SAO_TYPE_START_BO); //EO
2102      uiSymbol = 2;
2103    }
2104    codeSaoTypeIdx(uiSymbol);
2105  }
2106
2107  if(ctbParam.modeIdc == SAO_MODE_NEW)
2108  {
2109    Int numClasses = (ctbParam.typeIdc == SAO_TYPE_BO)?4:NUM_SAO_EO_CLASSES;
2110    Int offset[4];
2111    Int k=0;
2112    for(Int i=0; i< numClasses; i++)
2113    {
2114      if(ctbParam.typeIdc != SAO_TYPE_BO && i == SAO_CLASS_EO_PLAIN)
2115      {
2116        continue;
2117      }
2118      Int classIdx = (ctbParam.typeIdc == SAO_TYPE_BO)?(  (ctbParam.typeAuxInfo+i)% NUM_SAO_BO_CLASSES   ):i;
2119      offset[k] = ctbParam.offset[classIdx];
2120      k++;
2121    }
2122
2123    const Int  maxOffsetQVal = TComSampleAdaptiveOffset::getMaxOffsetQVal(channelBitDepth);
2124    for(Int i=0; i< 4; i++)
2125    {
2126      codeSaoMaxUvlc((offset[i]<0)?(-offset[i]):(offset[i]),  maxOffsetQVal ); //sao_offset_abs
2127    }
2128
2129
2130    if(ctbParam.typeIdc == SAO_TYPE_BO)
2131    {
2132      for(Int i=0; i< 4; i++)
2133      {
2134        if(offset[i] != 0)
2135        {
2136          codeSAOSign((offset[i]< 0)?1:0);
2137        }
2138      }
2139
2140      codeSaoUflc(NUM_SAO_BO_CLASSES_LOG2, ctbParam.typeAuxInfo ); //sao_band_position
2141    }
2142    else //EO
2143    {
2144      if(bIsFirstCompOfChType)
2145      {
2146        assert(ctbParam.typeIdc - SAO_TYPE_START_EO >=0);
2147        codeSaoUflc(NUM_SAO_EO_TYPES_LOG2, ctbParam.typeIdc - SAO_TYPE_START_EO ); //sao_eo_class_luma or sao_eo_class_chroma
2148      }
2149    }
2150
2151  }
2152}
2153
2154
2155Void TEncSbac::codeSAOBlkParam(SAOBlkParam& saoBlkParam, const BitDepths &bitDepths
2156                              , Bool* sliceEnabled
2157                              , Bool leftMergeAvail
2158                              , Bool aboveMergeAvail
2159                              , Bool onlyEstMergeInfo // = false
2160                              )
2161{
2162
2163  Bool isLeftMerge = false;
2164  Bool isAboveMerge= false;
2165
2166  if(leftMergeAvail)
2167  {
2168    isLeftMerge = ((saoBlkParam[COMPONENT_Y].modeIdc == SAO_MODE_MERGE) && (saoBlkParam[COMPONENT_Y].typeIdc == SAO_MERGE_LEFT));
2169    codeSaoMerge( isLeftMerge?1:0  ); //sao_merge_left_flag
2170  }
2171
2172  if( aboveMergeAvail && !isLeftMerge)
2173  {
2174    isAboveMerge = ((saoBlkParam[COMPONENT_Y].modeIdc == SAO_MODE_MERGE) && (saoBlkParam[COMPONENT_Y].typeIdc == SAO_MERGE_ABOVE));
2175    codeSaoMerge( isAboveMerge?1:0  ); //sao_merge_left_flag
2176  }
2177
2178  if(onlyEstMergeInfo)
2179  {
2180    return; //only for RDO
2181  }
2182
2183  if(!isLeftMerge && !isAboveMerge) //not merge mode
2184  {
2185    for(Int compIdx=0; compIdx < MAX_NUM_COMPONENT; compIdx++)
2186    {
2187      codeSAOOffsetParam(ComponentID(compIdx), saoBlkParam[compIdx], sliceEnabled[compIdx], bitDepths.recon[toChannelType(ComponentID(compIdx))]);
2188    }
2189  }
2190}
2191
2192/*!
2193 ****************************************************************************
2194 * \brief
2195 *   estimate bit cost for CBP, significant map and significant coefficients
2196 ****************************************************************************
2197 */
2198Void TEncSbac::estBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
2199{
2200  estCBFBit( pcEstBitsSbac );
2201
2202  estSignificantCoeffGroupMapBit( pcEstBitsSbac, chType );
2203
2204  // encode significance map
2205  estSignificantMapBit( pcEstBitsSbac, width, height, chType );
2206
2207  // encode last significant position
2208  estLastSignificantPositionBit( pcEstBitsSbac, width, height, chType );
2209
2210  // encode significant coefficients
2211  estSignificantCoefficientsBit( pcEstBitsSbac, chType );
2212
2213  memcpy(pcEstBitsSbac->golombRiceAdaptationStatistics, m_golombRiceAdaptationStatistics, (sizeof(UInt) * RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS));
2214}
2215
2216/*!
2217 ****************************************************************************
2218 * \brief
2219 *    estimate bit cost for each CBP bit
2220 ****************************************************************************
2221 */
2222Void TEncSbac::estCBFBit( estBitsSbacStruct* pcEstBitsSbac )
2223{
2224  ContextModel *pCtx = m_cCUQtCbfSCModel.get( 0 );
2225
2226  for( UInt uiCtxInc = 0; uiCtxInc < (NUM_QT_CBF_CTX_SETS * NUM_QT_CBF_CTX_PER_SET); uiCtxInc++ )
2227  {
2228    pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
2229    pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
2230  }
2231
2232  pCtx = m_cCUQtRootCbfSCModel.get( 0 );
2233
2234  for( UInt uiCtxInc = 0; uiCtxInc < 4; uiCtxInc++ )
2235  {
2236    pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
2237    pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
2238  }
2239}
2240
2241
2242/*!
2243 ****************************************************************************
2244 * \brief
2245 *    estimate SAMBAC bit cost for significant coefficient group map
2246 ****************************************************************************
2247 */
2248Void TEncSbac::estSignificantCoeffGroupMapBit( estBitsSbacStruct* pcEstBitsSbac, ChannelType chType )
2249{
2250  Int firstCtx = 0, numCtx = NUM_SIG_CG_FLAG_CTX;
2251
2252  for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2253  {
2254    for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2255    {
2256      pcEstBitsSbac->significantCoeffGroupBits[ ctxIdx ][ uiBin ] = m_cCUSigCoeffGroupSCModel.get(  0, chType, ctxIdx ).getEntropyBits( uiBin );
2257    }
2258  }
2259}
2260
2261
2262/*!
2263 ****************************************************************************
2264 * \brief
2265 *    estimate SAMBAC bit cost for significant coefficient map
2266 ****************************************************************************
2267 */
2268Void TEncSbac::estSignificantMapBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
2269{
2270  //--------------------------------------------------------------------------------------------------
2271
2272  //set up the number of channels and context variables
2273
2274  const UInt firstComponent = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
2275  const UInt lastComponent  = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
2276
2277  //----------------------------------------------------------
2278
2279  Int firstCtx = MAX_INT;
2280  Int numCtx   = MAX_INT;
2281
2282  if      ((width == 4) && (height == 4))
2283  {
2284    firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_4x4];
2285    numCtx   = significanceMapContextSetSize [chType][CONTEXT_TYPE_4x4];
2286  }
2287  else if ((width == 8) && (height == 8))
2288  {
2289    firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_8x8];
2290    numCtx   = significanceMapContextSetSize [chType][CONTEXT_TYPE_8x8];
2291  }
2292  else
2293  {
2294    firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_NxN];
2295    numCtx   = significanceMapContextSetSize [chType][CONTEXT_TYPE_NxN];
2296  }
2297
2298  //--------------------------------------------------------------------------------------------------
2299
2300  //fill the data for the significace map
2301
2302  for (UInt component = firstComponent; component <= lastComponent; component++)
2303  {
2304    const UInt contextOffset = getSignificanceMapContextOffset(ComponentID(component));
2305
2306    if (firstCtx > 0)
2307    {
2308      for( UInt bin = 0; bin < 2; bin++ ) //always get the DC
2309      {
2310        pcEstBitsSbac->significantBits[ contextOffset ][ bin ] = m_cCUSigSCModel.get( 0, 0, contextOffset ).getEntropyBits( bin );
2311      }
2312    }
2313
2314    // This could be made optional, but would require this function to have knowledge of whether the
2315    // TU is transform-skipped or transquant-bypassed and whether the SPS flag is set
2316    for( UInt bin = 0; bin < 2; bin++ )
2317    {
2318      const Int ctxIdx = significanceMapContextSetStart[chType][CONTEXT_TYPE_SINGLE];
2319      pcEstBitsSbac->significantBits[ contextOffset + ctxIdx ][ bin ] = m_cCUSigSCModel.get( 0, 0, (contextOffset + ctxIdx) ).getEntropyBits( bin );
2320    }
2321
2322    for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2323    {
2324      for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2325      {
2326        pcEstBitsSbac->significantBits[ contextOffset + ctxIdx ][ uiBin ] = m_cCUSigSCModel.get(  0, 0, (contextOffset + ctxIdx) ).getEntropyBits( uiBin );
2327      }
2328    }
2329  }
2330
2331  //--------------------------------------------------------------------------------------------------
2332}
2333
2334
2335/*!
2336 ****************************************************************************
2337 * \brief
2338 *    estimate bit cost of significant coefficient
2339 ****************************************************************************
2340 */
2341
2342Void TEncSbac::estLastSignificantPositionBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
2343{
2344  //--------------------------------------------------------------------------------------------------.
2345
2346  //set up the number of channels
2347
2348  const UInt firstComponent = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
2349  const UInt lastComponent  = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
2350
2351  //--------------------------------------------------------------------------------------------------
2352
2353  //fill the data for the last-significant-coefficient position
2354
2355  for (UInt componentIndex = firstComponent; componentIndex <= lastComponent; componentIndex++)
2356  {
2357    const ComponentID component = ComponentID(componentIndex);
2358
2359    Int iBitsX = 0, iBitsY = 0;
2360
2361    Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
2362    getLastSignificantContextParameters(ComponentID(component), width, height, blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY);
2363
2364    Int ctx;
2365
2366    const ChannelType channelType = toChannelType(ComponentID(component));
2367
2368    ContextModel *const pCtxX = m_cCuCtxLastX.get( 0, channelType );
2369    ContextModel *const pCtxY = m_cCuCtxLastY.get( 0, channelType );
2370    Int          *const lastXBitsArray = pcEstBitsSbac->lastXBits[channelType];
2371    Int          *const lastYBitsArray = pcEstBitsSbac->lastYBits[channelType];
2372
2373    //------------------------------------------------
2374
2375    //X-coordinate
2376
2377    for (ctx = 0; ctx < g_uiGroupIdx[ width - 1 ]; ctx++)
2378    {
2379      Int ctxOffset = blkSizeOffsetX + (ctx >>shiftX);
2380      lastXBitsArray[ ctx ] = iBitsX + pCtxX[ ctxOffset ].getEntropyBits( 0 );
2381      iBitsX += pCtxX[ ctxOffset ].getEntropyBits( 1 );
2382    }
2383
2384    lastXBitsArray[ctx] = iBitsX;
2385
2386    //------------------------------------------------
2387
2388    //Y-coordinate
2389
2390    for (ctx = 0; ctx < g_uiGroupIdx[ height - 1 ]; ctx++)
2391    {
2392      Int ctxOffset = blkSizeOffsetY + (ctx >>shiftY);
2393      lastYBitsArray[ ctx ] = iBitsY + pCtxY[ ctxOffset ].getEntropyBits( 0 );
2394      iBitsY += pCtxY[ ctxOffset ].getEntropyBits( 1 );
2395    }
2396
2397    lastYBitsArray[ctx] = iBitsY;
2398
2399  } //end of component loop
2400
2401  //--------------------------------------------------------------------------------------------------
2402}
2403
2404
2405/*!
2406 ****************************************************************************
2407 * \brief
2408 *    estimate bit cost of significant coefficient
2409 ****************************************************************************
2410 */
2411Void TEncSbac::estSignificantCoefficientsBit( estBitsSbacStruct* pcEstBitsSbac, ChannelType chType )
2412{
2413  ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0);
2414  ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0);
2415
2416  const UInt oneStartIndex = ((isLuma(chType)) ? (0)                     : (NUM_ONE_FLAG_CTX_LUMA));
2417  const UInt oneStopIndex  = ((isLuma(chType)) ? (NUM_ONE_FLAG_CTX_LUMA) : (NUM_ONE_FLAG_CTX));
2418  const UInt absStartIndex = ((isLuma(chType)) ? (0)                     : (NUM_ABS_FLAG_CTX_LUMA));
2419  const UInt absStopIndex  = ((isLuma(chType)) ? (NUM_ABS_FLAG_CTX_LUMA) : (NUM_ABS_FLAG_CTX));
2420
2421  for (Int ctxIdx = oneStartIndex; ctxIdx < oneStopIndex; ctxIdx++)
2422  {
2423    pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
2424    pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );
2425  }
2426
2427  for (Int ctxIdx = absStartIndex; ctxIdx < absStopIndex; ctxIdx++)
2428  {
2429    pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
2430    pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );
2431  }
2432}
2433
2434/**
2435 - Initialize our context information from the nominated source.
2436 .
2437 \param pSrc From where to copy context information.
2438 */
2439Void TEncSbac::xCopyContextsFrom( const TEncSbac* pSrc )
2440{
2441  memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
2442  memcpy(m_golombRiceAdaptationStatistics, pSrc->m_golombRiceAdaptationStatistics, (sizeof(UInt) * RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS));
2443}
2444
2445Void  TEncSbac::loadContexts ( const TEncSbac* pSrc)
2446{
2447  xCopyContextsFrom(pSrc);
2448}
2449
2450/** Performs CABAC encoding of the explicit RDPCM mode
2451 * \param rTu current TU data structure
2452 * \param compID component identifier
2453 */
2454Void TEncSbac::codeExplicitRdpcmMode( TComTU &rTu, const ComponentID compID )
2455{
2456  TComDataCU *cu = rTu.getCU();
2457  const TComRectangle &rect = rTu.getRect(compID);
2458  const UInt absPartIdx   = rTu.GetAbsPartIdxTU(compID);
2459  const UInt tuHeight = g_aucConvertToBit[rect.height];
2460  const UInt tuWidth  = g_aucConvertToBit[rect.width];
2461
2462  assert(tuHeight == tuWidth);
2463  assert(tuHeight < 4);
2464
2465  UInt explicitRdpcmMode = cu->getExplicitRdpcmMode(compID, absPartIdx);
2466
2467  if( explicitRdpcmMode == RDPCM_OFF )
2468  {
2469    m_pcBinIf->encodeBin (0, m_explicitRdpcmFlagSCModel.get (0, toChannelType(compID), 0));
2470  }
2471  else if( explicitRdpcmMode == RDPCM_HOR || explicitRdpcmMode == RDPCM_VER )
2472  {
2473    m_pcBinIf->encodeBin (1, m_explicitRdpcmFlagSCModel.get (0, toChannelType(compID), 0));
2474    if(explicitRdpcmMode == RDPCM_HOR)
2475    {
2476      m_pcBinIf->encodeBin ( 0, m_explicitRdpcmDirSCModel.get(0, toChannelType(compID), 0));
2477    }
2478    else
2479    {
2480      m_pcBinIf->encodeBin ( 1, m_explicitRdpcmDirSCModel.get(0, toChannelType(compID), 0));
2481    }
2482  }
2483  else
2484  {
2485    assert(0);
2486  }
2487}
2488
2489#if NH_3D_DMM || H_3D_DIM_SDC || H_3D_INTER_SDC
2490Void TEncSbac::codeDeltaDC( TComDataCU* pcCU, UInt absPartIdx )
2491{
2492#if H_3D_DIM_SDC || H_3D_INTER_SDC
2493  if( !(pcCU->getSDCFlag( absPartIdx )) )
2494#endif
2495#if NH_3D_DMM
2496    if( !(pcCU->isIntra( absPartIdx ) && isDmmMode( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) )) )
2497#endif
2498    assert( 0 );
2499
2500  UInt uiNumSegments = 1;
2501#if NH_3D_DMM
2502  uiNumSegments = isDmmMode( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) ) ? 2 : 1;
2503#endif
2504
2505  UInt hasDeltaDC = 1;
2506#if H_3D_DIM_SDC
2507  if( pcCU->isIntra( absPartIdx ) && pcCU->getSDCFlag( absPartIdx ))
2508  {
2509    if( uiNumSegments == 1 )
2510    {
2511      hasDeltaDC = pcCU->getSDCSegmentDCOffset( 0, absPartIdx ) ? 1 : 0;
2512    }
2513    else
2514    {
2515      hasDeltaDC = ( pcCU->getSDCSegmentDCOffset( 0, absPartIdx ) || pcCU->getSDCSegmentDCOffset( 1, absPartIdx ) ) ? 1 : 0;
2516    }
2517    m_pcBinIf->encodeBin( hasDeltaDC, m_cDdcFlagSCModel.get( 0, 0, 0 ) );
2518  }
2519#endif
2520
2521  if( hasDeltaDC )
2522  {
2523    for( UInt segment = 0; segment < uiNumSegments; segment++ )
2524    {
2525      Pel deltaDC = 0;
2526      if( pcCU->isIntra( absPartIdx ) )
2527      {
2528#if H_3D_DIM_SDC
2529        if( pcCU->getSDCFlag( absPartIdx ) )
2530        {
2531          deltaDC = pcCU->getSDCSegmentDCOffset( segment, absPartIdx );
2532        }
2533        else
2534        {
2535#endif
2536#if NH_3D_DMM
2537        deltaDC = pcCU->getDmmDeltaDC( getDmmType( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) ), segment, absPartIdx );
2538#endif
2539#if H_3D_DIM_SDC
2540        }
2541#endif
2542      }
2543#if H_3D_INTER_SDC
2544      else
2545      {
2546        deltaDC = pcCU->getSDCSegmentDCOffset( segment, absPartIdx );
2547      }
2548#endif
2549      xCodeDeltaDC( deltaDC, uiNumSegments );
2550    }
2551  }
2552}
2553
2554Void TEncSbac::xCodeDeltaDC( Pel valDeltaDC, UInt uiNumSeg )
2555{
2556  xWriteExGolombLevelDdc( UInt( abs( valDeltaDC ) - ( uiNumSeg > 1 ? 0 : 1 ) ) );
2557  if( valDeltaDC != 0 )
2558  {
2559    UInt uiSign = valDeltaDC > 0 ? 0 : 1;
2560    m_pcBinIf->encodeBinEP( uiSign );
2561  }
2562}
2563
2564Void TEncSbac::xWriteExGolombLevelDdc( UInt uiSymbol )
2565{
2566  if( uiSymbol )
2567  {
2568    m_pcBinIf->encodeBin( 1, m_cDdcDataSCModel.get(0, 0, 0) );
2569    UInt uiCount = 0;
2570    Bool bNoExGo = ( uiSymbol < 3 );
2571
2572    while( --uiSymbol && ++uiCount < 3 )
2573    {
2574      m_pcBinIf->encodeBin( 1, m_cDdcDataSCModel.get(0, 0, 0) );
2575    }
2576    if( bNoExGo )
2577    {
2578      m_pcBinIf->encodeBin( 0, m_cDdcDataSCModel.get(0, 0, 0) );
2579    }
2580    else
2581    {
2582      xWriteEpExGolomb( uiSymbol, 0 );
2583    }
2584  }
2585  else
2586  {
2587    m_pcBinIf->encodeBin( 0, m_cDdcDataSCModel.get(0, 0, 0) );
2588  }
2589
2590  return;
2591}
2592#endif
2593
2594#if NH_3D_DMM
2595Void TEncSbac::xCodeIntraDepthMode( TComDataCU* pcCU, UInt absPartIdx )
2596{
2597  UInt dir = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx );
2598
2599  if( ( pcCU->getSlice()->getSPS()->getMaxCUWidth() >> pcCU->getDepth( absPartIdx ) ) < 64 ) //DMM and HEVC intra modes are both allowed
2600  {
2601    m_pcBinIf->encodeBin( isDmmMode( dir ) ? 0 : 1, m_cNotDmmFlagSCModel.get( 0, 0, 0 ) );
2602  }
2603  if( isDmmMode( dir ) )
2604  {
2605    UInt uiCodeIdx = 0;
2606
2607    switch( getDmmType( dir ) )
2608    {
2609    case DMM1_IDX: uiCodeIdx = 0; break;
2610    case DMM4_IDX: uiCodeIdx = 1; break;
2611    default:                      break;
2612    }
2613    //mode coding
2614    if( pcCU->getSlice()->getIntraSdcWedgeFlag() && pcCU->getSlice()->getIntraContourFlag())
2615    {
2616      m_pcBinIf->encodeBin( uiCodeIdx == 0 ? 0 : 1, m_cDmmModeSCModel.get( 0, 0, 0 ) );
2617    }
2618  }
2619}
2620
2621Void TEncSbac::xCodeDmmData( TComDataCU* pcCU, UInt absPartIdx )
2622{
2623  UInt dir = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx );
2624  switch( getDmmType( dir ) )
2625  {
2626  case( DMM1_IDX ): { xCodeDmm1WedgeIdx( pcCU->getDmm1WedgeTabIdx( absPartIdx ), g_dmm1TabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] ); } break;
2627  case( DMM4_IDX ): break;
2628  default:          break;
2629  }
2630}
2631
2632Void TEncSbac::xCodeDmm1WedgeIdx( UInt uiTabIdx, Int iNumBit )
2633{
2634  for ( Int i = 0; i < iNumBit; i++ )
2635  {
2636    m_pcBinIf->encodeBinEP( ( uiTabIdx >> i ) & 1 );
2637  }
2638}
2639#endif
2640
2641#if H_3D_INTER_SDC
2642Void TEncSbac::codeSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2643{
2644  UInt uiSymbol = pcCU->getSDCFlag( uiAbsPartIdx ) ? 1 : 0;
2645  UInt uiCtxSDCFlag = pcCU->getCtxSDCFlag( uiAbsPartIdx );
2646  DTRACE_CU("dc_only_flag", uiSymbol)
2647  m_pcBinIf->encodeBin( uiSymbol, m_cSDCFlagSCModel.get( 0, 0, uiCtxSDCFlag ) );
2648}
2649
2650#endif
2651
2652#if H_3D_DBBP
2653Void TEncSbac::codeDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2654{
2655  PartSize ePartSize = pcCU->getPartitionSize( uiAbsPartIdx );
2656  AOF( ePartSize == SIZE_2NxN || ePartSize == SIZE_Nx2N );
2657  AOF( pcCU->getSlice()->getDepthBasedBlkPartFlag() ); 
2658  AOF( !pcCU->getSlice()->getIsDepth() );
2659 
2660  UInt uiSymbol = pcCU->getDBBPFlag( uiAbsPartIdx ) ? 1 : 0;
2661  m_pcBinIf->encodeBin( uiSymbol, m_cDBBPFlagSCModel.get( 0, 0, 0 ) );
2662  DTRACE_CU("dbbp_flag", uiSymbol)
2663}
2664#endif
2665
2666//! \}
Note: See TracBrowser for help on using the repository browser.