source: 3DVCSoftware/branches/HTM-14.1-update-dev3/source/Lib/TLibEncoder/TEncSbac.cpp @ 1270

Last change on this file since 1270 was 1270, checked in by tech, 9 years ago

Merged 14.1-update-dev4-Qualcomm@1266

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