source: 3DVCSoftware/branches/HTM-6.2-dev3-RWTH-Fix/source/Lib/TLibEncoder/TEncSbac.cpp @ 414

Last change on this file since 414 was 414, checked in by rwth, 11 years ago
  • renamed LGE_CONCATENATE to LGE_CONCATENATE_D0141
  • Property svn:eol-style set to native
File size: 91.6 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-2012, 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
41#include <map>
42#include <algorithm>
43
44#if RWTH_SDC_DLT_B0036
45#define GetNumDepthValues()     (pcCU->getSlice()->getSPS()->getNumDepthValues())
46#define GetBitsPerDepthValue()  (pcCU->getSlice()->getSPS()->getBitsPerDepthValue())
47#if LGE_CONCATENATE_D0141
48#define PrefixThreshold ( ((GetNumDepthValues() * 3) >> 2) )
49#define BitsPerSuffix ( (UInt)ceil( Log2(GetNumDepthValues() - PrefixThreshold) ) )
50#endif
51#endif
52
53//! \ingroup TLibEncoder
54//! \{
55
56// ====================================================================================================================
57// Constructor / destructor / create / destroy
58// ====================================================================================================================
59
60TEncSbac::TEncSbac()
61// new structure here
62: m_pcBitIf                   ( NULL )
63, m_pcSlice                   ( NULL )
64, m_pcBinIf                   ( NULL )
65, m_bAlfCtrl                  ( false )
66, m_uiCoeffCost               ( 0 )
67, m_uiMaxAlfCtrlDepth         ( 0 )
68, m_numContextModels          ( 0 )
69, m_cCUSplitFlagSCModel       ( 1,             1,               NUM_SPLIT_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels )
70, m_cCUSkipFlagSCModel        ( 1,             1,               NUM_SKIP_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
71#if LGE_ILLUCOMP_B0045
72, m_cCUICFlagSCModel          ( 1,             1,               NUM_IC_FLAG_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
73#endif
74, m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        , m_contextModels + m_numContextModels, m_numContextModels)
75, m_cCUMergeIdxExtSCModel     ( 1,             1,               NUM_MERGE_IDX_EXT_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
76#if H3D_IVRP
77, m_cResPredFlagSCModel       ( 1,             1,               NUM_RES_PRED_FLAG_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
78#endif
79, m_cCUPartSizeSCModel        ( 1,             1,               NUM_PART_SIZE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
80, m_cCUPredModeSCModel        ( 1,             1,               NUM_PRED_MODE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
81, m_cCUAlfCtrlFlagSCModel     ( 1,             1,               NUM_ALF_CTRL_FLAG_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
82, m_cCUIntraPredSCModel       ( 1,             1,               NUM_ADI_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
83, m_cCUChromaPredSCModel      ( 1,             1,               NUM_CHROMA_PRED_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
84, m_cCUDeltaQpSCModel         ( 1,             1,               NUM_DELTA_QP_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
85, m_cCUInterDirSCModel        ( 1,             1,               NUM_INTER_DIR_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
86, m_cCURefPicSCModel          ( 1,             1,               NUM_REF_NO_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
87, m_cCUMvdSCModel             ( 1,             1,               NUM_MV_RES_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
88, m_cCUQtCbfSCModel           ( 1,             2,               NUM_QT_CBF_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
89, m_cCUTransSubdivFlagSCModel ( 1,             1,               NUM_TRANS_SUBDIV_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
90, m_cCUQtRootCbfSCModel       ( 1,             1,               NUM_QT_ROOT_CBF_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
91, m_cCUSigCoeffGroupSCModel   ( 1,             2,               NUM_SIG_CG_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
92, m_cCUSigSCModel             ( 1,             1,               NUM_SIG_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
93, m_cCuCtxLastX               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          , m_contextModels + m_numContextModels, m_numContextModels)
94, m_cCuCtxLastY               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          , m_contextModels + m_numContextModels, m_numContextModels)
95, m_cCUOneSCModel             ( 1,             1,               NUM_ONE_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
96, m_cCUAbsSCModel             ( 1,             1,               NUM_ABS_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
97, m_cMVPIdxSCModel            ( 1,             1,               NUM_MVP_IDX_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
98, m_cALFFlagSCModel           ( 1,             1,               NUM_ALF_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
99, m_cALFUvlcSCModel           ( 1,             1,               NUM_ALF_UVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
100, m_cALFSvlcSCModel           ( 1,             1,               NUM_ALF_SVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
101, m_cCUAMPSCModel             ( 1,             1,               NUM_CU_AMP_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
102, m_cSaoFlagSCModel           ( 1,             1,               NUM_SAO_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
103, m_cSaoUvlcSCModel           ( 1,             1,               NUM_SAO_UVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
104, m_cSaoSvlcSCModel           ( 1,             1,               NUM_SAO_SVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
105, m_cSaoMergeLeftSCModel      ( 1,             1,               NUM_SAO_MERGE_LEFT_FLAG_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
106, m_cSaoMergeUpSCModel        ( 1,             1,               NUM_SAO_MERGE_UP_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
107, m_cSaoTypeIdxSCModel        ( 1,             1,               NUM_SAO_TYPE_IDX_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
108#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
109#if !PKU_QC_DEPTH_INTRA_UNI_D0195
110, m_cDmmFlagSCModel           ( 1,             1,               NUM_DMM_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
111, m_cDmmModeSCModel           ( 1,             1,               NUM_DMM_MODE_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
112#endif
113, m_cDmmDataSCModel           ( 1,             1,               NUM_DMM_DATA_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
114#endif
115#if LGE_EDGE_INTRA_A0070
116, m_cEdgeIntraSCModel         ( 1,             1,               NUM_EDGE_INTRA_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
117#if LGE_EDGE_INTRA_DELTA_DC
118, m_cEdgeIntraDeltaDCSCModel  ( 1,             1,               NUM_EDGE_INTRA_DELTA_DC_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
119#endif
120#endif
121#if RWTH_SDC_DLT_B0036
122#if !PKU_QC_DEPTH_INTRA_UNI_D0195
123, m_cSDCFlagSCModel             ( 1,             1,                 SDC_NUM_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
124#else
125, m_cDepthModeModel             ( 1,             1,                 DEPTH_MODE_NUM_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
126, m_cDmmDeltaFlagModel             ( 1,             1,                 DMM_DELTA_NUM_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
127#endif
128#if RWTH_SDC_CTX_SIMPL_D0032
129, m_cSDCResidualFlagSCModel     ( 1,             1,  SDC_NUM_RESIDUAL_FLAG_CTX  , m_contextModels + m_numContextModels, m_numContextModels)
130, m_cSDCResidualSCModel         ( 1,             1,  SDC_NUM_RESIDUAL_CTX       , m_contextModels + m_numContextModels, m_numContextModels)
131, m_cSDCPredModeSCModel             ( 1,             3,                 SDC_NUM_PRED_MODE_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
132#else
133, m_cSDCResidualFlagSCModel     ( 1,             2,  SDC_NUM_RESIDUAL_FLAG_CTX  , m_contextModels + m_numContextModels, m_numContextModels)
134, m_cSDCResidualSignFlagSCModel ( 1,             2,  SDC_NUM_SIGN_FLAG_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
135, m_cSDCResidualSCModel         ( 1,             2,  SDC_NUM_RESIDUAL_CTX       , m_contextModels + m_numContextModels, m_numContextModels)
136, m_cSDCPredModeSCModel             ( 1,             3,                 SDC_NUM_PRED_MODE_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
137#endif
138#endif
139{
140  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
141  m_iSliceGranularity = 0;
142}
143
144TEncSbac::~TEncSbac()
145{
146}
147
148// ====================================================================================================================
149// Public member functions
150// ====================================================================================================================
151
152Void TEncSbac::resetEntropy           ()
153{
154  Int  iQp              = m_pcSlice->getSliceQp();
155  SliceType eSliceType  = m_pcSlice->getSliceType();
156 
157#if CABAC_INIT_FLAG
158  Int  encCABACTableIdx = m_pcSlice->getPPS()->getEncCABACTableIdx();
159  if (!m_pcSlice->isIntra() && (encCABACTableIdx==B_SLICE || encCABACTableIdx==P_SLICE) && m_pcSlice->getPPS()->getCabacInitPresentFlag())
160  {
161    eSliceType = (SliceType) encCABACTableIdx;
162  }
163#endif
164
165  m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
166 
167  m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
168#if LGE_ILLUCOMP_B0045
169  m_cCUICFlagSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
170#endif
171  m_cCUAlfCtrlFlagSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
172  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
173  m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
174#if H3D_IVRP
175  m_cResPredFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
176#endif
177  m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
178  m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
179  m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
180  m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
181  m_cCUChromaPredSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
182  m_cCUInterDirSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
183  m_cCUMvdSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MVD );
184  m_cCURefPicSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
185  m_cCUDeltaQpSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DQP );
186  m_cCUQtCbfSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
187  m_cCUQtRootCbfSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
188  m_cCUSigCoeffGroupSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
189  m_cCUSigSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
190  m_cCuCtxLastX.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
191  m_cCuCtxLastY.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
192  m_cCUOneSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
193  m_cCUAbsSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
194  m_cMVPIdxSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
195  m_cALFFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_FLAG );
196  m_cALFUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_UVLC );
197  m_cALFSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_SVLC );
198  m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
199  m_cSaoFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_FLAG );
200  m_cSaoUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
201  m_cSaoSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
202  m_cSaoMergeLeftSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
203  m_cSaoMergeUpSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
204  m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
205#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
206#if !PKU_QC_DEPTH_INTRA_UNI_D0195
207  m_cDmmFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_FLAG );
208  m_cDmmModeSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
209#endif
210  m_cDmmDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_DATA );
211#endif
212#if LGE_EDGE_INTRA_A0070
213  m_cEdgeIntraSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_EDGE_INTRA );
214#if LGE_EDGE_INTRA_DELTA_DC
215  m_cEdgeIntraDeltaDCSCModel.initBuffer  ( eSliceType, iQp, (UChar*)INIT_EDGE_INTRA_DELTA_DC );
216#endif
217#endif
218#if RWTH_SDC_DLT_B0036
219#if !PKU_QC_DEPTH_INTRA_UNI_D0195
220  m_cSDCFlagSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
221#else
222  m_cDepthModeModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_DEPTHMODE_FLAG );
223  m_cDmmDeltaFlagModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMMDELTA_FLAG );
224#endif
225  m_cSDCResidualFlagSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
226  m_cSDCResidualSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
227#if !RWTH_SDC_CTX_SIMPL_D0032
228  m_cSDCResidualSignFlagSCModel.initBuffer  ( eSliceType, iQp, (UChar*)INIT_SDC_SIGN_FLAG );
229#endif
230  m_cSDCPredModeSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_SDC_PRED_MODE );
231#endif
232
233  // new structure
234  m_uiLastQp = iQp;
235 
236  m_pcBinIf->start();
237 
238  return;
239}
240
241#if CABAC_INIT_FLAG
242/** The function does the following:
243 * If current slice type is P/B then it determines the distance of initialisation type 1 and 2 from the current CABAC states and
244 * stores the index of the closest table.  This index is used for the next P/B slice when cabac_init_present_flag is true.
245 */
246Void TEncSbac::determineCabacInitIdx()
247{
248  Int  qp              = m_pcSlice->getSliceQp();
249
250  if (!m_pcSlice->isIntra())
251  {
252    SliceType aSliceTypeChoices[] = {B_SLICE, P_SLICE};
253
254    UInt bestCost             = MAX_UINT;
255    SliceType bestSliceType   = aSliceTypeChoices[0];
256    for (UInt idx=0; idx<2; idx++)
257    {
258      UInt curCost          = 0;
259      SliceType curSliceType  = aSliceTypeChoices[idx];
260
261      curCost  = m_cCUSplitFlagSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_SPLIT_FLAG );
262      curCost += m_cCUSkipFlagSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SKIP_FLAG );
263#if LGE_ILLUCOMP_B0045
264      curCost += m_cCUICFlagSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_IC_FLAG );
265#endif
266      curCost += m_cCUAlfCtrlFlagSCModel.calcCost     ( curSliceType, qp, (UChar*)INIT_ALF_CTRL_FLAG );
267      curCost += m_cCUMergeFlagExtSCModel.calcCost    ( curSliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT);
268      curCost += m_cCUMergeIdxExtSCModel.calcCost     ( curSliceType, qp, (UChar*)INIT_MERGE_IDX_EXT);
269#if H3D_IVRP
270      curCost += m_cResPredFlagSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_RES_PRED_FLAG);
271#endif
272      curCost += m_cCUPartSizeSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_PART_SIZE );
273      curCost += m_cCUAMPSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_CU_AMP_POS );
274      curCost += m_cCUPredModeSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_PRED_MODE );
275      curCost += m_cCUIntraPredSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
276      curCost += m_cCUChromaPredSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
277      curCost += m_cCUInterDirSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_INTER_DIR );
278      curCost += m_cCUMvdSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_MVD );
279      curCost += m_cCURefPicSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_REF_PIC );
280      curCost += m_cCUDeltaQpSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_DQP );
281      curCost += m_cCUQtCbfSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_QT_CBF );
282      curCost += m_cCUQtRootCbfSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
283      curCost += m_cCUSigCoeffGroupSCModel.calcCost   ( curSliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
284      curCost += m_cCUSigSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_SIG_FLAG );
285      curCost += m_cCuCtxLastX.calcCost               ( curSliceType, qp, (UChar*)INIT_LAST );
286      curCost += m_cCuCtxLastY.calcCost               ( curSliceType, qp, (UChar*)INIT_LAST );
287      curCost += m_cCUOneSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_ONE_FLAG );
288      curCost += m_cCUAbsSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_ABS_FLAG );
289      curCost += m_cMVPIdxSCModel.calcCost            ( curSliceType, qp, (UChar*)INIT_MVP_IDX );
290      curCost += m_cALFFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_ALF_FLAG );
291      curCost += m_cALFUvlcSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_ALF_UVLC );
292      curCost += m_cALFSvlcSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_ALF_SVLC );
293      curCost += m_cCUTransSubdivFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
294      curCost += m_cSaoFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_SAO_FLAG );
295      curCost += m_cSaoUvlcSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_SAO_UVLC );
296      curCost += m_cSaoSvlcSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_SAO_SVLC );
297      curCost += m_cSaoMergeLeftSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
298      curCost += m_cSaoMergeUpSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
299      curCost += m_cSaoTypeIdxSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
300
301      if (curCost < bestCost)
302      {
303        bestSliceType = curSliceType;
304        bestCost      = curCost;
305      }
306    }
307    m_pcSlice->getPPS()->setEncCABACTableIdx( bestSliceType );
308  }
309  else
310  {
311    m_pcSlice->getPPS()->setEncCABACTableIdx( I_SLICE );
312  } 
313
314  #if CABAC_INIT_FLAG && FIX_POZNAN_CABAC_INIT_FLAG
315    m_pcSlice->getPPS()->setEncPrevPOC( m_pcSlice->getPOC() );
316  #endif
317}
318#endif
319
320
321/** The function does the followng: Write out terminate bit. Flush CABAC. Intialize CABAC states. Start CABAC.
322 */
323Void TEncSbac::updateContextTables( SliceType eSliceType, Int iQp, Bool bExecuteFinish )
324{
325  m_pcBinIf->encodeBinTrm(1);
326  if (bExecuteFinish) m_pcBinIf->finish();
327  m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
328 
329  m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
330#if LGE_ILLUCOMP_B0045
331  m_cCUICFlagSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
332#endif
333  m_cCUAlfCtrlFlagSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
334  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
335  m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
336#if H3D_IVRP
337  m_cResPredFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
338#endif
339  m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
340  m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
341  m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
342  m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
343  m_cCUChromaPredSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
344  m_cCUInterDirSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
345  m_cCUMvdSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MVD );
346  m_cCURefPicSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
347  m_cCUDeltaQpSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DQP );
348  m_cCUQtCbfSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
349  m_cCUQtRootCbfSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
350  m_cCUSigCoeffGroupSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
351  m_cCUSigSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
352  m_cCuCtxLastX.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
353  m_cCuCtxLastY.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
354  m_cCUOneSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
355  m_cCUAbsSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
356  m_cMVPIdxSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
357  m_cALFFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_FLAG );
358  m_cALFUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_UVLC );
359  m_cALFSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_SVLC );
360  m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
361  m_cSaoFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_FLAG );
362  m_cSaoUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
363  m_cSaoSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
364  m_cSaoMergeLeftSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
365  m_cSaoMergeUpSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
366  m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
367#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
368#if !PKU_QC_DEPTH_INTRA_UNI_D0195
369  m_cDmmFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_FLAG );
370  m_cDmmModeSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
371#endif
372  m_cDmmDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_DATA );
373#endif
374#if RWTH_SDC_DLT_B0036
375#if !PKU_QC_DEPTH_INTRA_UNI_D0195
376  m_cSDCFlagSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
377#else
378  m_cDepthModeModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_DEPTHMODE_FLAG );
379  m_cDmmDeltaFlagModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMMDELTA_FLAG );
380#endif
381  m_cSDCResidualFlagSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
382  m_cSDCResidualSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
383#if !RWTH_SDC_CTX_SIMPL_D0032
384  m_cSDCResidualSignFlagSCModel.initBuffer  ( eSliceType, iQp, (UChar*)INIT_SDC_SIGN_FLAG );
385#endif
386  m_cSDCPredModeSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_SDC_PRED_MODE );
387#endif
388 
389  m_pcBinIf->start();
390}
391
392Void TEncSbac::writeTileMarker( UInt uiTileIdx, UInt uiBitsUsed )
393{
394  for (Int iShift=uiBitsUsed-1; iShift>=0; iShift--)
395  {
396    m_pcBinIf->encodeBinEP ( (uiTileIdx & (1 << iShift)) >> iShift );
397  }
398}
399
400void TEncSbac::codeSEI(const SEI&)
401{
402  assert(0);
403}
404
405#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
406Void TEncSbac::codeVPS( TComVPS* pcVPS )
407{
408  assert (0);
409  return;
410}
411#endif
412
413#if HHI_MPI || H3D_QTL
414Void TEncSbac::codeSPS( TComSPS* pcSPS, Bool bIsDepth )
415#else
416Void TEncSbac::codeSPS( TComSPS* pcSPS )
417#endif
418{
419  assert (0);
420  return;
421}
422
423Void TEncSbac::codePPS( TComPPS* pcPPS )
424{
425  assert (0);
426  return;
427}
428
429Void TEncSbac::codeSliceHeader( TComSlice* pcSlice )
430{
431  assert (0);
432  return;
433}
434
435Void TEncSbac::codeTilesWPPEntryPoint( TComSlice* pSlice )
436{
437  assert (0);
438  return;
439}
440
441Void TEncSbac::codeTerminatingBit( UInt uilsLast )
442{
443  m_pcBinIf->encodeBinTrm( uilsLast );
444}
445
446Void TEncSbac::codeSliceFinish()
447{
448  m_pcBinIf->finish();
449}
450
451Void TEncSbac::codeFlush()
452{
453  m_pcBinIf->flush();
454}
455
456Void TEncSbac::encodeStart()
457{
458  m_pcBinIf->start();
459}
460
461Void TEncSbac::xWriteUnarySymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset )
462{
463  m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[0] );
464 
465  if( 0 == uiSymbol)
466  {
467    return;
468  }
469 
470  while( uiSymbol-- )
471  {
472    m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ iOffset ] );
473  }
474 
475  return;
476}
477
478Void TEncSbac::xWriteUnaryMaxSymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
479{
480  if (uiMaxSymbol == 0)
481  {
482    return;
483  }
484 
485  m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ 0 ] );
486 
487  if ( uiSymbol == 0 )
488  {
489    return;
490  }
491 
492  Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
493 
494  while( --uiSymbol )
495  {
496    m_pcBinIf->encodeBin( 1, pcSCModel[ iOffset ] );
497  }
498  if( bCodeLast )
499  {
500    m_pcBinIf->encodeBin( 0, pcSCModel[ iOffset ] );
501  }
502 
503  return;
504}
505
506Void TEncSbac::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
507{
508  UInt bins = 0;
509  Int numBins = 0;
510 
511  while( uiSymbol >= (UInt)(1<<uiCount) )
512  {
513    bins = 2 * bins + 1;
514    numBins++;
515    uiSymbol -= 1 << uiCount;
516    uiCount  ++;
517  }
518  bins = 2 * bins + 0;
519  numBins++;
520 
521  bins = (bins << uiCount) | uiSymbol;
522  numBins += uiCount;
523 
524  assert( numBins <= 32 );
525  m_pcBinIf->encodeBinsEP( bins, numBins );
526}
527
528/** Coding of coeff_abs_level_minus3
529 * \param uiSymbol value of coeff_abs_level_minus3
530 * \param ruiGoRiceParam reference to Rice parameter
531 * \returns Void
532 */
533Void TEncSbac::xWriteGoRiceExGolomb( UInt uiSymbol, UInt &ruiGoRiceParam )
534{
535  UInt uiMaxVlc     = g_auiGoRiceRange[ ruiGoRiceParam ];
536  Bool bExGolomb    = ( uiSymbol > uiMaxVlc );
537  UInt uiCodeWord   = min<UInt>( uiSymbol, ( uiMaxVlc + 1 ) );
538  UInt uiQuotient   = uiCodeWord >> ruiGoRiceParam;
539  UInt uiMaxPreLen  = g_auiGoRicePrefixLen[ ruiGoRiceParam ];
540 
541  UInt binValues;
542  Int numBins;
543 
544  if ( uiQuotient >= uiMaxPreLen )
545  {
546    numBins = uiMaxPreLen;
547    binValues = ( 1 << numBins ) - 1;
548  }
549  else
550  {
551    numBins = uiQuotient + 1;
552    binValues = ( 1 << numBins ) - 2;
553  }
554 
555  m_pcBinIf->encodeBinsEP( ( binValues << ruiGoRiceParam ) + uiCodeWord - ( uiQuotient << ruiGoRiceParam ), numBins + ruiGoRiceParam );
556 
557  ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( uiSymbol, 23 ) ];
558 
559  if( bExGolomb )
560  {
561    uiSymbol -= uiMaxVlc + 1;
562    xWriteEpExGolomb( uiSymbol, 0 );
563  }
564}
565
566// SBAC RD
567Void  TEncSbac::load ( TEncSbac* pSrc)
568{
569  this->xCopyFrom(pSrc);
570}
571
572Void  TEncSbac::loadIntraDirModeLuma( TEncSbac* pSrc)
573{
574  m_pcBinIf->copyState( pSrc->m_pcBinIf );
575 
576  this->m_cCUIntraPredSCModel      .copyFrom( &pSrc->m_cCUIntraPredSCModel       );
577}
578
579#if PKU_QC_DEPTH_INTRA_UNI_D0195
580Void TEncSbac::loadDepthMode( TEncSbac* pSrc)
581{
582  m_pcBinIf->copyState( pSrc->m_pcBinIf );
583
584  this->m_cDepthModeModel      .copyFrom( &pSrc->m_cDepthModeModel       );
585  this->m_cDmmDeltaFlagModel   .copyFrom( &pSrc->m_cDmmDeltaFlagModel       );
586}
587#endif
588Void  TEncSbac::store( TEncSbac* pDest)
589{
590  pDest->xCopyFrom( this );
591}
592
593
594Void TEncSbac::xCopyFrom( TEncSbac* pSrc )
595{
596  m_pcBinIf->copyState( pSrc->m_pcBinIf );
597 
598  this->m_uiCoeffCost = pSrc->m_uiCoeffCost;
599  this->m_uiLastQp    = pSrc->m_uiLastQp;
600 
601  memcpy( m_contextModels, pSrc->m_contextModels, m_numContextModels * sizeof( ContextModel ) );
602}
603
604#if H3D_IVMP
605Void TEncSbac::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum )
606#else
607Void TEncSbac::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
608#endif
609{
610  Int iSymbol = pcCU->getMVPIdx(eRefList, uiAbsPartIdx);
611#if H3D_IVMP
612#else
613  Int iNum = AMVP_MAX_NUM_CANDS;
614#endif
615
616  xWriteUnaryMaxSymbol(iSymbol, m_cMVPIdxSCModel.get(0), 1, iNum-1);
617}
618
619Void TEncSbac::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
620{
621  PartSize eSize         = pcCU->getPartitionSize( uiAbsPartIdx );
622
623#if H3D_QTL
624  TComSPS *sps           = pcCU->getPic()->getSlice(0)->getSPS();
625  TComPic *pcTexture     = pcCU->getSlice()->getTexturePic();
626  Bool bDepthMapDetect   = (pcTexture != NULL);
627  Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
628 
629  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
630  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC() && pcCU->getPic()->getReduceBitsFlag())
631  {
632    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
633    UInt uiCUIdx            = (pcCU->getZorderIdxInCU() == 0) ? uiAbsPartIdx : pcCU->getZorderIdxInCU();
634    assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth);
635    if (pcTextureCU->getDepth(uiCUIdx) == uiDepth && pcTextureCU->getPartitionSize( uiCUIdx ) != SIZE_NxN)
636    {
637      assert( eSize == SIZE_2Nx2N );
638      return;
639    }
640  }
641#endif
642
643  if ( pcCU->isIntra( uiAbsPartIdx ) )
644  {
645    if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
646    {
647      m_pcBinIf->encodeBin( eSize == SIZE_2Nx2N? 1 : 0, m_cCUPartSizeSCModel.get( 0, 0, 0 ) );
648    }
649    return;
650  }
651 
652  switch(eSize)
653  {
654  case SIZE_2Nx2N:
655    {
656      m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
657      break;
658    }
659  case SIZE_2NxN:
660  case SIZE_2NxnU:
661  case SIZE_2NxnD:
662    {
663      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
664      m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
665      if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
666      {
667        if (eSize == SIZE_2NxN)
668        {
669          m_pcBinIf->encodeBin(1, m_cCUAMPSCModel.get( 0, 0, 0 ));
670        }
671        else
672        {
673          m_pcBinIf->encodeBin(0, m_cCUAMPSCModel.get( 0, 0, 0 ));         
674          m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
675        }
676      }
677      break;
678    }
679  case SIZE_Nx2N:
680  case SIZE_nLx2N:
681  case SIZE_nRx2N:
682    {
683      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
684      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
685      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getSlice()->getSPS()->getDisInter4x4() && pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
686      {
687        m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
688      }
689      if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
690      {
691        if (eSize == SIZE_Nx2N)
692        {
693          m_pcBinIf->encodeBin(1, m_cCUAMPSCModel.get( 0, 0, 0 ));
694        }
695        else
696        {
697          m_pcBinIf->encodeBin(0, m_cCUAMPSCModel.get( 0, 0, 0 ));
698          m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
699        }
700      }
701      break;
702    }
703  case SIZE_NxN:
704    {
705      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getSlice()->getSPS()->getDisInter4x4() && pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
706      {
707        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
708        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
709        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
710      }
711      break;
712    }
713  default:
714    {
715      assert(0);
716    }
717  }
718}
719
720/** code prediction mode
721 * \param pcCU
722 * \param uiAbsPartIdx 
723 * \returns Void
724 */
725Void TEncSbac::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
726{
727#if RWTH_SDC_DLT_B0036
728  if ( pcCU->getSlice()->isIntra() )
729  {
730    assert( pcCU->isIntra(uiAbsPartIdx) );
731    return;
732  }
733#endif
734 
735  // get context function is here
736  Int iPredMode = pcCU->getPredictionMode( uiAbsPartIdx );
737  m_pcBinIf->encodeBin( iPredMode == MODE_INTER ? 0 : 1, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
738}
739
740Void TEncSbac::codeAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
741{
742  if (!m_bAlfCtrl)
743    return;
744 
745  if( pcCU->getDepth(uiAbsPartIdx) > m_uiMaxAlfCtrlDepth && !pcCU->isFirstAbsZorderIdxInDepth(uiAbsPartIdx, m_uiMaxAlfCtrlDepth))
746  {
747    return;
748  }
749 
750  const UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0;
751  m_pcBinIf->encodeBin( uiSymbol, *m_cCUAlfCtrlFlagSCModel.get( 0 ) );
752}
753
754Void TEncSbac::codeAlfCtrlDepth()
755{
756  if (!m_bAlfCtrl)
757    return;
758 
759  UInt uiDepth = m_uiMaxAlfCtrlDepth;
760  xWriteUnaryMaxSymbol(uiDepth, m_cALFUvlcSCModel.get(0), 1, g_uiMaxCUDepth-1);
761}
762
763/** code skip flag
764 * \param pcCU
765 * \param uiAbsPartIdx
766 * \returns Void
767 */
768Void TEncSbac::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
769{
770  // get context function is here
771  UInt uiSymbol = pcCU->isSkipped( uiAbsPartIdx ) ? 1 : 0;
772  UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx ) ;
773  m_pcBinIf->encodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
774  DTRACE_CABAC_VL( g_nSymbolCounter++ );
775  DTRACE_CABAC_T( "\tSkipFlag" );
776  DTRACE_CABAC_T( "\tuiCtxSkip: ");
777  DTRACE_CABAC_V( uiCtxSkip );
778  DTRACE_CABAC_T( "\tuiSymbol: ");
779  DTRACE_CABAC_V( uiSymbol );
780  DTRACE_CABAC_T( "\n");
781}
782
783#if LGE_ILLUCOMP_B0045
784/** code Illumination Compensation flag
785 * \param pcCU
786 * \param uiAbsPartIdx
787 * \returns Void
788 */
789Void TEncSbac::codeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
790{
791  // get context function is here
792  UInt uiSymbol = pcCU->getICFlag( uiAbsPartIdx ) ? 1 : 0;
793  UInt uiCtxIC  = pcCU->getCtxICFlag( uiAbsPartIdx ) ;
794  m_pcBinIf->encodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, uiCtxIC ) );
795  DTRACE_CABAC_VL( g_nSymbolCounter++ );
796  DTRACE_CABAC_T( "\tICFlag" );
797  DTRACE_CABAC_T( "\tuiCtxIC: ");
798  DTRACE_CABAC_V( uiCtxIC );
799  DTRACE_CABAC_T( "\tuiSymbol: ");
800  DTRACE_CABAC_V( uiSymbol );
801  DTRACE_CABAC_T( "\n");
802}
803#endif
804
805/** code merge flag
806 * \param pcCU
807 * \param uiAbsPartIdx
808 * \returns Void
809 */
810Void TEncSbac::codeMergeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
811{
812  const UInt uiSymbol = pcCU->getMergeFlag( uiAbsPartIdx ) ? 1 : 0;
813  m_pcBinIf->encodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) );
814
815  DTRACE_CABAC_VL( g_nSymbolCounter++ );
816  DTRACE_CABAC_T( "\tMergeFlag: " );
817  DTRACE_CABAC_V( uiSymbol );
818  DTRACE_CABAC_T( "\tAddress: " );
819  DTRACE_CABAC_V( pcCU->getAddr() );
820  DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
821  DTRACE_CABAC_V( uiAbsPartIdx );
822  DTRACE_CABAC_T( "\n" );
823}
824
825/** code merge index
826 * \param pcCU
827 * \param uiAbsPartIdx
828 * \returns Void
829 */
830Void TEncSbac::codeMergeIndex( TComDataCU* pcCU, UInt uiAbsPartIdx )
831{
832  UInt uiNumCand = MRG_MAX_NUM_CANDS;
833  UInt uiUnaryIdx = pcCU->getMergeIndex( uiAbsPartIdx );
834  uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
835#if HHI_MPI
836  const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
837  if( bMVIAvailable )
838  {
839    const Bool bUseMVI = pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1;
840    if( bUseMVI )
841    {
842      uiUnaryIdx = (UInt)HHI_MPI_MERGE_POS;
843    }
844    else if( (Int)uiUnaryIdx >= (Int)HHI_MPI_MERGE_POS )
845    {
846      uiUnaryIdx++;
847    }
848  }
849#endif
850  if ( uiNumCand > 1 )
851  {
852    for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
853    {
854      const UInt uiSymbol = ui == uiUnaryIdx ? 0 : 1;
855      if ( ui==0 )
856      {
857        m_pcBinIf->encodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) );
858      }
859      else
860      {
861        m_pcBinIf->encodeBinEP( uiSymbol );
862      }
863      if( uiSymbol == 0 )
864      {
865        break;
866      }
867    }
868  }
869  DTRACE_CABAC_VL( g_nSymbolCounter++ );
870  DTRACE_CABAC_T( "\tparseMergeIndex()" );
871  DTRACE_CABAC_T( "\tuiMRGIdx= " );
872  DTRACE_CABAC_V( pcCU->getMergeIndex( uiAbsPartIdx ) );
873  DTRACE_CABAC_T( "\n" );
874}
875
876#if H3D_IVRP
877Void
878TEncSbac::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
879{
880  UInt  uiCtx     = pcCU->getCtxResPredFlag( uiAbsPartIdx );
881  UInt  uiSymbol  = ( pcCU->getResPredFlag( uiAbsPartIdx ) ? 1 : 0 );
882  m_pcBinIf->encodeBin( uiSymbol, m_cResPredFlagSCModel.get( 0, 0, uiCtx ) );
883}
884#endif
885
886Void TEncSbac::codeSplitFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
887{
888  if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
889    return;
890 
891  UInt uiCtx           = pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth );
892  UInt uiCurrSplitFlag = ( pcCU->getDepth( uiAbsPartIdx ) > uiDepth ) ? 1 : 0;
893 
894  assert( uiCtx < 3 );
895
896#if H3D_QTL
897  Bool bCodeSplitFlag    = true;
898
899  TComSPS *sps           = pcCU->getPic()->getSlice(0)->getSPS();
900  TComPic *pcTexture     = pcCU->getSlice()->getTexturePic();
901  Bool bDepthMapDetect   = (pcTexture != NULL);
902  Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
903
904  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
905  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC() && pcCU->getPic()->getReduceBitsFlag())
906  {
907    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
908    UInt uiCUIdx            = (pcCU->getZorderIdxInCU() == 0) ? uiAbsPartIdx : pcCU->getZorderIdxInCU();
909    assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth);
910    bCodeSplitFlag          = (pcTextureCU->getDepth(uiCUIdx) > uiDepth);
911  }
912
913  if(!bCodeSplitFlag)
914  {
915    assert(uiCurrSplitFlag == 0);
916    return;
917  }
918#endif
919
920  m_pcBinIf->encodeBin( uiCurrSplitFlag, m_cCUSplitFlagSCModel.get( 0, 0, uiCtx ) );
921  DTRACE_CABAC_VL( g_nSymbolCounter++ )
922  DTRACE_CABAC_T( "\tSplitFlag\n" )
923  return;
924}
925
926Void TEncSbac::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
927{
928  m_pcBinIf->encodeBin( uiSymbol, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiCtx ) );
929  DTRACE_CABAC_VL( g_nSymbolCounter++ )
930  DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
931  DTRACE_CABAC_T( "\tsymbol=" )
932  DTRACE_CABAC_V( uiSymbol )
933  DTRACE_CABAC_T( "\tctx=" )
934  DTRACE_CABAC_V( uiCtx )
935  DTRACE_CABAC_T( "\n" )
936}
937
938#if LGE_EDGE_INTRA_A0070
939Void TEncSbac::xCodeEdgeIntraInfo( TComDataCU* pcCU, UInt uiPartIdx )
940{
941  UInt   uiDepth        = pcCU->getDepth( uiPartIdx ) + (pcCU->getPartitionSize( uiPartIdx ) == SIZE_NxN ? 1 : 0);
942  UInt   uiCtxEdgeIntra = pcCU->getCtxEdgeIntra( uiPartIdx );
943  UChar* pucSymbolList  = pcCU->getEdgeCode( uiPartIdx );
944  UChar  ucEdgeNumber   = pcCU->getEdgeNumber( uiPartIdx );
945  Bool   bLeft          = pcCU->getEdgeLeftFirst( uiPartIdx );
946  UChar  ucStart        = pcCU->getEdgeStartPos( uiPartIdx );
947  UInt   uiSymbol;
948
949  // 1. Top(0) or Left(1)
950  uiSymbol = (bLeft == false) ? 0 : 1;
951  m_pcBinIf->encodeBinEP( uiSymbol );
952
953  // 2. Start position (lowest bit first)
954  uiSymbol = ucStart;
955  for( UInt ui = 6; ui > uiDepth; ui-- ) // 64(0)->6, 32(1)->5, 16(2)->4, 8(3)->3, 4(4)->2
956  {
957    m_pcBinIf->encodeBinEP( uiSymbol & 0x1 );
958    uiSymbol >>= 1;
959  }
960
961  // 3. Number of edges
962  uiSymbol = ucEdgeNumber > 0 ? ucEdgeNumber - 1 : 0;
963  for( UInt ui = 7; ui > uiDepth; ui-- ) // 64(0)->7, 32(1)->6, 16(2)->5, 8(3)->4, 4(4)->3
964  {
965    m_pcBinIf->encodeBinEP( uiSymbol & 0x1 );
966    uiSymbol >>= 1;
967  }
968
969  if(uiSymbol != 0)
970  {
971    printf(" ucEdgeNumber %d at depth %d\n",ucEdgeNumber, uiDepth);
972    assert(false);
973  }
974
975  // 4. Edges
976  for( Int iPtr2 = 0; iPtr2 < ucEdgeNumber; iPtr2++ )
977  {
978    UInt uiReorderSymbol = pucSymbolList[iPtr2];
979
980    //printf ("Ptr = %d, Symbol = %d\n", iPtr2, uiSymbol);
981
982    // Left-friendly direction (Top start)
983    // 0 (   0deg) => 0
984    // 1 (  45deg) => 10
985    // 2 ( -45deg) => 110
986    // 3 (  90deg) => 1110
987    // 4 ( -90deg) => 11110
988    // 5 ( 135deg) => 111110
989    // 6 (-135deg) => 111111
990    // Right-friendly direction (Left start)
991    // 0 (   0deg) => 0
992    // 2 ( -45deg) => 10
993    // 1 (  45deg) => 110
994    // 4 ( -90deg) => 1110
995    // 3 (  90deg) => 11110
996    // 6 (-135deg) => 111110
997    // 5 ( 135deg) => 111111
998
999    // refer to a paper "An efficient chain code with Huffman coding"
1000
1001    for( UInt ui = 0; ui < uiReorderSymbol; ui++ )
1002    {
1003      m_pcBinIf->encodeBin( 1, m_cEdgeIntraSCModel.get( 0, 0, uiCtxEdgeIntra ) );
1004    }
1005
1006    if( uiReorderSymbol != 6 )
1007      m_pcBinIf->encodeBin( 0, m_cEdgeIntraSCModel.get( 0, 0, uiCtxEdgeIntra ) );
1008  }
1009}
1010#endif
1011#if PKU_QC_DEPTH_INTRA_UNI_D0195
1012Void TEncSbac::codeDepthIntraMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
1013{
1014  UInt uiCodeWordTable[3][9] =    {{0, 0, 0, 2, 0,6, 0, 0, 7},{0, 2, 3, 4, 5, 6, 14, 31, 30},{0, 2, 0, 0, 0, 0, 3, 0, 0}};
1015  UInt uiCodeWordLenTable[3][9] = {{0, 1, 0, 2, 0,3, 0, 0, 3},{2, 3, 3, 3, 3, 3,  4,  5,  5},{1, 2, 0, 0, 0, 0, 2, 0, 0}};
1016  UInt uiDir = pcCU->getLumaIntraDir(uiAbsPartIdx);
1017  Bool bSdcFlag = pcCU->getSDCFlag(uiAbsPartIdx);
1018  UInt uiPuIdx = ( pcCU->getWidth(uiAbsPartIdx) == 64 )? 2 : ( ( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && pcCU->getWidth(uiAbsPartIdx) == 8 ) ? 0 : 1 );
1019  UInt uiCodeIdx = 0;
1020  if ( bSdcFlag ) 
1021  { 
1022    switch(uiDir)
1023    {
1024      case PLANAR_IDX: uiCodeIdx = 0; break;
1025      case DC_IDX:     uiCodeIdx = 6; break;
1026      default:         uiCodeIdx = 2;
1027    }
1028  }
1029  else if ( uiDir>=EDGE_INTRA_IDX ) 
1030  { 
1031    uiCodeIdx = 8; 
1032  }
1033  else if ( uiDir<NUM_INTRA_MODE ) 
1034  { 
1035    uiCodeIdx = 1; 
1036  }
1037  else 
1038  {
1039    if (uiDir== DMM_WEDGE_FULL_IDX     || uiDir==DMM_WEDGE_FULL_D_IDX     )     {uiCodeIdx = 3;}
1040    if (uiDir== DMM_CONTOUR_PREDTEX_IDX|| uiDir==DMM_CONTOUR_PREDTEX_D_IDX)     {uiCodeIdx = 4;}
1041    if (uiDir== DMM_WEDGE_PREDTEX_IDX  || uiDir==DMM_WEDGE_PREDTEX_D_IDX  )     {uiCodeIdx = 5;}
1042    if (uiDir== DMM_WEDGE_PREDDIR_IDX  || uiDir==DMM_WEDGE_PREDDIR_D_IDX  )     {uiCodeIdx = 7;}
1043  }
1044  //mode coding
1045  for (UInt i=0; i<uiCodeWordLenTable[uiPuIdx][uiCodeIdx]; i++)
1046  {
1047    UInt uiBit = uiCodeWordTable[uiPuIdx][uiCodeIdx] & ( 1<<(uiCodeWordLenTable[uiPuIdx][uiCodeIdx]-i-1) );
1048    UInt uiCtxDepthMode = uiPuIdx*3 + ( i >= 2? 2 : i );
1049    m_pcBinIf->encodeBin( uiBit!=0 , m_cDepthModeModel.get(0, 0, uiCtxDepthMode) );
1050  }
1051}
1052Void TEncSbac::codeDepthModelingTable( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bSdcRD)
1053{
1054  UInt uiDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
1055  Bool bSdcFlag =  pcCU->getSDCFlag(uiAbsPartIdx);
1056  Bool bDmmFlag = (uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX &&(!bSdcFlag))? 1:0;
1057
1058  codeDepthIntraMode(pcCU,uiAbsPartIdx);
1059 
1060  if (uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX )//DMM modes or SDC DMM1
1061  {
1062    assert(pcCU->getWidth(uiAbsPartIdx)<64);
1063    assert(pcCU->getWidth(uiAbsPartIdx)<64);
1064    if( uiDir == DMM_WEDGE_FULL_IDX || uiDir == DMM_WEDGE_FULL_D_IDX)             { xCodeWedgeFullInfo     ( pcCU, uiAbsPartIdx ); }
1065    else if( uiDir == DMM_WEDGE_PREDTEX_IDX || uiDir == DMM_WEDGE_PREDTEX_D_IDX ) { xCodeWedgePredTexInfo  ( pcCU, uiAbsPartIdx ); }
1066    else if( uiDir == DMM_WEDGE_PREDDIR_IDX || uiDir == DMM_WEDGE_PREDDIR_D_IDX)  { xCodeWedgePredDirInfo  ( pcCU, uiAbsPartIdx ); }
1067  } 
1068  else if(uiDir >= EDGE_INTRA_IDX)//CCM mode
1069  {
1070    assert(pcCU->getWidth(uiAbsPartIdx)<64);
1071    xCodeEdgeIntraInfo( pcCU, uiAbsPartIdx );
1072  }
1073
1074  if (bDmmFlag)
1075  {
1076    m_pcBinIf->encodeBin( (uiDir&1) , m_cDmmDeltaFlagModel.get(0, 0, 0) );
1077    if (uiDir&1)
1078    {
1079      Int iDeltaDC1 = 0,iDeltaDC2 = 0;
1080      if ( uiDir == DMM_WEDGE_FULL_D_IDX )
1081      {
1082        iDeltaDC1 = pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx );
1083        iDeltaDC2 = pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx );
1084      }
1085      else if ( uiDir == DMM_WEDGE_PREDTEX_D_IDX )
1086      {
1087        iDeltaDC1 = pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx );
1088        iDeltaDC2 = pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx );
1089      }
1090      else if ( uiDir == DMM_WEDGE_PREDDIR_D_IDX )
1091      {
1092        iDeltaDC1 = pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx );
1093        iDeltaDC2 = pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx );
1094      }
1095      else if ( uiDir == DMM_CONTOUR_PREDTEX_D_IDX )
1096      {
1097        iDeltaDC1 = pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx );
1098        iDeltaDC2 = pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx );
1099
1100      }
1101
1102      for ( Int i = 0; i < 2; i++ )
1103      {
1104        Int iDeltaDC = (i==0)? iDeltaDC1 : iDeltaDC2;
1105        xWriteExGolombLevel( UInt( abs( iDeltaDC ) ), m_cDmmDataSCModel.get(0, 0, 1) );
1106        if ( iDeltaDC != 0 )
1107        {
1108          UInt uiSign = iDeltaDC > 0 ? 0 : 1;
1109          m_pcBinIf->encodeBinEP( uiSign );
1110        }
1111      }
1112    }
1113  }
1114  else if (uiDir>=EDGE_INTRA_IDX)
1115  {
1116    m_pcBinIf->encodeBin( (uiDir == EDGE_INTRA_DELTA_IDX), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 0) );
1117    if( uiDir == EDGE_INTRA_DELTA_IDX )
1118    {
1119      Int iDeltaDC0 = pcCU->getEdgeDeltaDC0( uiAbsPartIdx );
1120      Int iDeltaDC1 = pcCU->getEdgeDeltaDC1( uiAbsPartIdx );
1121
1122      for ( Int i = 0; i < 2; i++ )
1123      {
1124        Int iDeltaDC = (i==0)? iDeltaDC0 : iDeltaDC1;
1125        xWriteExGolombLevel( UInt( abs( iDeltaDC ) ), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
1126        if ( iDeltaDC != 0 )
1127        {
1128          UInt uiSign = iDeltaDC > 0 ? 0 : 1;
1129          m_pcBinIf->encodeBinEP( uiSign );
1130        }
1131      }
1132    }
1133  }
1134  if (pcCU->getSDCFlag(uiAbsPartIdx))//SDC mode
1135  {
1136    assert(pcCU->getPartitionSize(uiAbsPartIdx)==SIZE_2Nx2N);
1137    UInt uiNumSegments = ( uiDir == DC_IDX || uiDir == PLANAR_IDX )? 1 : 2;
1138    if(!bSdcRD)
1139    {
1140      for (int uiSeg=0; uiSeg<uiNumSegments; uiSeg++)
1141      {
1142        codeSDCResidualData(pcCU, uiAbsPartIdx, uiSeg);
1143      }
1144    }
1145  }
1146}
1147#endif
1148Void TEncSbac::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx
1149#if PKU_QC_DEPTH_INTRA_UNI_D0195
1150                                   , Bool bSdcRD
1151#endif
1152                                   )
1153{
1154  UInt uiDir         = pcCU->getLumaIntraDir( uiAbsPartIdx );
1155
1156#if !PKU_QC_DEPTH_INTRA_UNI_D0195
1157#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1158  if( pcCU->getSlice()->getSPS()->getUseDMM() && pcCU->getWidth( uiAbsPartIdx ) <= DMM_WEDGEMODEL_MAX_SIZE )
1159  {
1160#if LGE_EDGE_INTRA_A0070
1161    m_pcBinIf->encodeBin( uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX, m_cDmmFlagSCModel.get(0, 0, 0) );
1162#else
1163    m_pcBinIf->encodeBin( uiDir >= NUM_INTRA_MODE, m_cDmmFlagSCModel.get(0, 0, 0) );
1164#endif
1165  }
1166#if LGE_EDGE_INTRA_A0070
1167  if( uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX )
1168#else
1169  if( uiDir >= NUM_INTRA_MODE )
1170#endif
1171  {
1172    assert( pcCU->getWidth( uiAbsPartIdx ) <= DMM_WEDGEMODEL_MAX_SIZE );
1173    UInt uiDMMode = uiDir - NUM_INTRA_MODE;
1174
1175#if HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
1176    m_pcBinIf->encodeBin( (uiDMMode & 0x01),      m_cDmmModeSCModel.get(0, 0, 0) );
1177    m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cDmmModeSCModel.get(0, 0, 0) );
1178
1179    if( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
1180    {
1181      m_pcBinIf->encodeBin( (uiDMMode & 0x04) >> 2, m_cDmmModeSCModel.get(0, 0, 0) );
1182    }
1183#else
1184    m_pcBinIf->encodeBin( (uiDMMode & 0x01),      m_cDmmModeSCModel.get(0, 0, 0) );
1185
1186    if( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
1187    {
1188      m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cDmmModeSCModel.get(0, 0, 0) );
1189    }
1190#endif
1191#if HHI_DMM_WEDGE_INTRA
1192    if( uiDir == DMM_WEDGE_FULL_IDX )          { xCodeWedgeFullInfo          ( pcCU, uiAbsPartIdx ); }
1193    if( uiDir == DMM_WEDGE_FULL_D_IDX )        { xCodeWedgeFullDeltaInfo     ( pcCU, uiAbsPartIdx ); }
1194    if( uiDir == DMM_WEDGE_PREDDIR_IDX )       { xCodeWedgePredDirInfo       ( pcCU, uiAbsPartIdx ); }
1195    if( uiDir == DMM_WEDGE_PREDDIR_D_IDX )     { xCodeWedgePredDirDeltaInfo  ( pcCU, uiAbsPartIdx ); }
1196#endif
1197#if HHI_DMM_PRED_TEX
1198
1199#if FLEX_CODING_ORDER_M23723
1200    if ( !pcCU->getSlice()->getSPS()->getUseDMM34() )
1201    {
1202      assert( uiDir != DMM_WEDGE_PREDTEX_D_IDX );
1203      assert( uiDir != DMM_CONTOUR_PREDTEX_D_IDX );
1204    }
1205#endif
1206
1207    if( uiDir == DMM_WEDGE_PREDTEX_D_IDX )     { xCodeWedgePredTexDeltaInfo  ( pcCU, uiAbsPartIdx ); }
1208#if LGE_DMM3_SIMP_C0044
1209    if( uiDir == DMM_WEDGE_PREDTEX_IDX )       { xCodeWedgePredTexInfo       ( pcCU, uiAbsPartIdx ); }
1210#endif
1211    if( uiDir == DMM_CONTOUR_PREDTEX_D_IDX )   { xCodeContourPredTexDeltaInfo( pcCU, uiAbsPartIdx ); }
1212#endif
1213  }
1214  else
1215#if LGE_EDGE_INTRA_A0070
1216    if ( uiDir >= EDGE_INTRA_IDX)
1217    {
1218      m_pcBinIf->encodeBin( 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
1219      m_pcBinIf->encodeBinsEP( 63, 6 );
1220      xCodeEdgeIntraInfo( pcCU, uiAbsPartIdx );
1221#if LGE_EDGE_INTRA_DELTA_DC
1222      m_pcBinIf->encodeBin( (uiDir == EDGE_INTRA_DELTA_IDX), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 0) );
1223      if( uiDir == EDGE_INTRA_DELTA_IDX )
1224      {
1225        Int iDeltaDC0 = pcCU->getEdgeDeltaDC0( uiAbsPartIdx );
1226        Int iDeltaDC1 = pcCU->getEdgeDeltaDC1( uiAbsPartIdx );
1227
1228        xWriteExGolombLevel( UInt( abs( iDeltaDC0 ) ), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
1229        if ( iDeltaDC0 != 0 )
1230        {
1231          UInt uiSign = iDeltaDC0 > 0 ? 0 : 1;
1232          m_pcBinIf->encodeBinEP( uiSign );
1233        }
1234        xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
1235        if ( iDeltaDC1 != 0 )
1236        {
1237          UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
1238          m_pcBinIf->encodeBinEP( uiSign );
1239        }
1240      }
1241#endif
1242    }
1243    else
1244#endif // LGE_EDGE_INTRA
1245  {
1246#endif
1247#if LGE_EDGE_INTRA_A0070
1248  Bool bCodeEdgeIntra = false;
1249  if( pcCU->getSlice()->getSPS()->isDepth() )
1250  {
1251    UInt uiPUWidth = pcCU->getWidth( uiAbsPartIdx ) >> (pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ? 1 : 0);
1252    if( uiPUWidth <= LGE_EDGE_INTRA_MAX_SIZE && uiPUWidth >= LGE_EDGE_INTRA_MIN_SIZE )
1253      bCodeEdgeIntra = true;
1254  }
1255#endif
1256#else
1257  if (pcCU->getSlice()->getSPS()->isDepth())
1258  {
1259    codeDepthModelingTable(pcCU, uiAbsPartIdx, bSdcRD);
1260  }
1261  if (pcCU->getLumaIntraDir(uiAbsPartIdx)<NUM_INTRA_MODE && !pcCU->getSDCFlag(uiAbsPartIdx))
1262  {
1263#endif
1264  Int uiPreds[3] = {-1, -1, -1};
1265  Int uiPredNum = pcCU->getIntraDirLumaPredictor(uiAbsPartIdx, uiPreds); 
1266
1267  Int uiPredIdx = -1;
1268
1269  for(UInt i = 0; i < uiPredNum; i++)
1270  {
1271    if(uiDir == uiPreds[i])
1272    {
1273      uiPredIdx = i;
1274    }
1275  }
1276 
1277  if(uiPredIdx != -1)
1278  {
1279    m_pcBinIf->encodeBin( 1, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
1280    m_pcBinIf->encodeBinEP( uiPredIdx ? 1 : 0 );
1281    if (uiPredIdx)
1282    {
1283      m_pcBinIf->encodeBinEP( uiPredIdx-1 );
1284    }
1285  }
1286  else
1287  {
1288    m_pcBinIf->encodeBin( 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
1289 
1290    if (uiPreds[0] > uiPreds[1])
1291    { 
1292      std::swap(uiPreds[0], uiPreds[1]); 
1293    }
1294    if (uiPreds[0] > uiPreds[2])
1295    {
1296      std::swap(uiPreds[0], uiPreds[2]);
1297    }
1298    if (uiPreds[1] > uiPreds[2])
1299    {
1300      std::swap(uiPreds[1], uiPreds[2]);
1301    }
1302
1303    for(Int i = (uiPredNum - 1); i >= 0; i--)
1304    {
1305      uiDir = uiDir > uiPreds[i] ? uiDir - 1 : uiDir;
1306    }
1307
1308    m_pcBinIf->encodeBinsEP( uiDir, 5 );
1309#if !PKU_QC_DEPTH_INTRA_UNI_D0195
1310#if LGE_EDGE_INTRA_A0070
1311  if (bCodeEdgeIntra)
1312    if (uiDir == 31) m_pcBinIf->encodeBinsEP(0,1);
1313#endif
1314#endif
1315   }
1316#if PKU_QC_DEPTH_INTRA_UNI_D0195
1317  }
1318#else
1319#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1320  }
1321#endif
1322#endif
1323
1324  return;
1325}
1326
1327Void TEncSbac::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
1328{
1329  UInt uiIntraDirChroma = pcCU->getChromaIntraDir( uiAbsPartIdx );
1330
1331  if( uiIntraDirChroma == DM_CHROMA_IDX ) 
1332  {
1333    m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1334  } 
1335  else if( uiIntraDirChroma == LM_CHROMA_IDX )
1336  {
1337    m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1338    m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 1 ) );
1339  }
1340  else
1341  { 
1342    UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
1343    pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
1344
1345    for( Int i = 0; i < NUM_CHROMA_MODE - 2; i++ )
1346    {
1347      if( uiIntraDirChroma == uiAllowedChromaDir[i] )
1348      {
1349        uiIntraDirChroma = i;
1350        break;
1351      }
1352    }
1353    m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1354
1355    if (pcCU->getSlice()->getSPS()->getUseLMChroma())
1356    {
1357      m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 1 ));
1358    }
1359    m_pcBinIf->encodeBinsEP( uiIntraDirChroma, 2 );
1360  }
1361  return;
1362}
1363
1364Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
1365{
1366  const UInt uiInterDir = pcCU->getInterDir( uiAbsPartIdx ) - 1;
1367  const UInt uiCtx      = pcCU->getCtxInterDir( uiAbsPartIdx );
1368  ContextModel *pCtx    = m_cCUInterDirSCModel.get( 0 );
1369  m_pcBinIf->encodeBin( uiInterDir == 2 ? 1 : 0, *( pCtx + uiCtx ) );
1370
1371  return;
1372}
1373
1374Void TEncSbac::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1375{
1376  if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getInterDir( uiAbsPartIdx ) != 3)
1377  {
1378    Int iRefFrame = pcCU->getSlice()->getRefIdxOfLC(eRefList, pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx ));
1379
1380    ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
1381    m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
1382
1383    if( iRefFrame > 0 )
1384    {
1385      xWriteUnaryMaxSymbol( iRefFrame - 1, pCtx + 1, 1, pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_C )-2 );
1386    }
1387#if MERL_VSP_C0152
1388    else if (iRefFrame < 0) // NOT_VALID
1389    {
1390      assert(0);
1391    }
1392#endif
1393  }
1394  else
1395  {
1396    Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
1397    ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
1398    m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
1399   
1400    if( iRefFrame > 0 )
1401    {
1402      xWriteUnaryMaxSymbol( iRefFrame - 1, pCtx + 1, 1, pcCU->getSlice()->getNumRefIdx( eRefList )-2 );
1403    }
1404#if MERL_VSP_C0152
1405    else if (iRefFrame < 0) // NOT_VALID
1406    {
1407      assert(0);
1408    }
1409#endif
1410  }
1411  return;
1412}
1413
1414Void TEncSbac::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1415{
1416  if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
1417  {
1418    return;
1419  }
1420
1421  const TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefList );
1422  const Int iHor = pcCUMvField->getMvd( uiAbsPartIdx ).getHor();
1423  const Int iVer = pcCUMvField->getMvd( uiAbsPartIdx ).getVer();
1424  ContextModel* pCtx = m_cCUMvdSCModel.get( 0 );
1425
1426  m_pcBinIf->encodeBin( iHor != 0 ? 1 : 0, *pCtx );
1427  m_pcBinIf->encodeBin( iVer != 0 ? 1 : 0, *pCtx );
1428
1429  const Bool bHorAbsGr0 = iHor != 0;
1430  const Bool bVerAbsGr0 = iVer != 0;
1431  const UInt uiHorAbs   = 0 > iHor ? -iHor : iHor;
1432  const UInt uiVerAbs   = 0 > iVer ? -iVer : iVer;
1433  pCtx++;
1434
1435  if( bHorAbsGr0 )
1436  {
1437    m_pcBinIf->encodeBin( uiHorAbs > 1 ? 1 : 0, *pCtx );
1438  }
1439
1440  if( bVerAbsGr0 )
1441  {
1442    m_pcBinIf->encodeBin( uiVerAbs > 1 ? 1 : 0, *pCtx );
1443  }
1444
1445  if( bHorAbsGr0 )
1446  {
1447    if( uiHorAbs > 1 )
1448    {
1449      xWriteEpExGolomb( uiHorAbs-2, 1 );
1450    }
1451
1452    m_pcBinIf->encodeBinEP( 0 > iHor ? 1 : 0 );
1453  }
1454
1455  if( bVerAbsGr0 )
1456  {
1457    if( uiVerAbs > 1 )
1458    {
1459      xWriteEpExGolomb( uiVerAbs-2, 1 );
1460    }
1461
1462    m_pcBinIf->encodeBinEP( 0 > iVer ? 1 : 0 );
1463  }
1464 
1465  return;
1466}
1467
1468Void TEncSbac::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
1469{
1470  Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
1471 
1472  Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffsetY();
1473  iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
1474
1475  if ( iDQp == 0 )
1476  {
1477    m_pcBinIf->encodeBin( 0, m_cCUDeltaQpSCModel.get( 0, 0, 0 ) );
1478  }
1479  else
1480  {
1481    m_pcBinIf->encodeBin( 1, m_cCUDeltaQpSCModel.get( 0, 0, 0 ) );
1482   
1483    UInt uiSign = (iDQp > 0 ? 0 : 1);
1484
1485    m_pcBinIf->encodeBinEP(uiSign);
1486
1487    assert(iDQp >= -(26+(qpBdOffsetY/2)));
1488    assert(iDQp <=  (25+(qpBdOffsetY/2)));
1489
1490    UInt uiMaxAbsDQpMinus1 = 24 + (qpBdOffsetY/2) + (uiSign);
1491    UInt uiAbsDQpMinus1 = (UInt)((iDQp > 0)? iDQp  : (-iDQp)) - 1;
1492    xWriteUnaryMaxSymbol( uiAbsDQpMinus1, &m_cCUDeltaQpSCModel.get( 0, 0, 1 ), 1, uiMaxAbsDQpMinus1);
1493  }
1494 
1495  return;
1496}
1497
1498Void TEncSbac::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
1499{
1500  UInt uiCbf = pcCU->getCbf     ( uiAbsPartIdx, eType, uiTrDepth );
1501  UInt uiCtx = pcCU->getCtxQtCbf( uiAbsPartIdx, eType, uiTrDepth );
1502  m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, eType ? TEXT_CHROMA : eType, uiCtx ) );
1503  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1504  DTRACE_CABAC_T( "\tparseQtCbf()" )
1505  DTRACE_CABAC_T( "\tsymbol=" )
1506  DTRACE_CABAC_V( uiCbf )
1507  DTRACE_CABAC_T( "\tctx=" )
1508  DTRACE_CABAC_V( uiCtx )
1509  DTRACE_CABAC_T( "\tetype=" )
1510  DTRACE_CABAC_V( eType )
1511  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1512  DTRACE_CABAC_V( uiAbsPartIdx )
1513  DTRACE_CABAC_T( "\n" )
1514}
1515
1516/** Code I_PCM information.
1517 * \param pcCU pointer to CU
1518 * \param uiAbsPartIdx CU index
1519 * \param numIPCM the number of succesive IPCM blocks with the same size
1520 * \param firstIPCMFlag
1521 * \returns Void
1522 */
1523Void TEncSbac::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Int numIPCM, Bool firstIPCMFlag)
1524{
1525  UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
1526
1527  Bool writePCMSampleFlag = pcCU->getIPCMFlag(uiAbsPartIdx);
1528
1529  if( uiIPCM == 0 || firstIPCMFlag)
1530  {
1531    m_pcBinIf->encodeBinTrm (uiIPCM);
1532
1533    if ( firstIPCMFlag )
1534    {
1535      m_pcBinIf->encodeNumSubseqIPCM( numIPCM - 1 );
1536      m_pcBinIf->encodePCMAlignBits();
1537    }
1538  }
1539
1540  if (writePCMSampleFlag)
1541  {
1542    UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
1543    UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
1544    UInt uiChromaOffset = uiLumaOffset>>2;
1545    Pel* piPCMSample;
1546    UInt uiWidth;
1547    UInt uiHeight;
1548    UInt uiSampleBits;
1549    UInt uiX, uiY;
1550
1551    piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
1552    uiWidth = pcCU->getWidth(uiAbsPartIdx);
1553    uiHeight = pcCU->getHeight(uiAbsPartIdx);
1554    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
1555
1556    for(uiY = 0; uiY < uiHeight; uiY++)
1557    {
1558      for(uiX = 0; uiX < uiWidth; uiX++)
1559      {
1560        UInt uiSample = piPCMSample[uiX];
1561
1562        m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
1563      }
1564      piPCMSample += uiWidth;
1565    }
1566
1567    piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
1568    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
1569    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
1570    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1571
1572    for(uiY = 0; uiY < uiHeight; uiY++)
1573    {
1574      for(uiX = 0; uiX < uiWidth; uiX++)
1575      {
1576        UInt uiSample = piPCMSample[uiX];
1577
1578        m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
1579      }
1580      piPCMSample += uiWidth;
1581    }
1582
1583    piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
1584    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
1585    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
1586    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1587
1588    for(uiY = 0; uiY < uiHeight; uiY++)
1589    {
1590      for(uiX = 0; uiX < uiWidth; uiX++)
1591      {
1592        UInt uiSample = piPCMSample[uiX];
1593
1594        m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
1595      }
1596      piPCMSample += uiWidth;
1597    }
1598    numIPCM--;
1599    if(numIPCM == 0)
1600    {
1601      m_pcBinIf->resetBac();
1602    }
1603  }
1604}
1605
1606Void TEncSbac::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
1607{
1608  UInt uiCbf = pcCU->getQtRootCbf( uiAbsPartIdx );
1609  UInt uiCtx = 0;
1610  m_pcBinIf->encodeBin( uiCbf , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
1611  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1612  DTRACE_CABAC_T( "\tparseQtRootCbf()" )
1613  DTRACE_CABAC_T( "\tsymbol=" )
1614  DTRACE_CABAC_V( uiCbf )
1615  DTRACE_CABAC_T( "\tctx=" )
1616  DTRACE_CABAC_V( uiCtx )
1617  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1618  DTRACE_CABAC_V( uiAbsPartIdx )
1619  DTRACE_CABAC_T( "\n" )
1620}
1621
1622/** Encode (X,Y) position of the last significant coefficient
1623 * \param uiPosX X component of last coefficient
1624 * \param uiPosY Y component of last coefficient
1625 * \param width  Block width
1626 * \param height Block height
1627 * \param eTType plane type / luminance or chrominance
1628 * \param uiScanIdx scan type (zig-zag, hor, ver)
1629 * This method encodes the X and Y component within a block of the last significant coefficient.
1630 */
1631Void TEncSbac::codeLastSignificantXY( UInt uiPosX, UInt uiPosY, Int width, Int height, TextType eTType, UInt uiScanIdx )
1632{ 
1633  // swap
1634  if( uiScanIdx == SCAN_VER )
1635  {
1636    swap( uiPosX, uiPosY );
1637  }
1638
1639  UInt uiCtxLast;
1640  ContextModel *pCtxX = m_cCuCtxLastX.get( 0, eTType );
1641  ContextModel *pCtxY = m_cCuCtxLastY.get( 0, eTType );
1642  UInt uiGroupIdxX    = g_uiGroupIdx[ uiPosX ];
1643  UInt uiGroupIdxY    = g_uiGroupIdx[ uiPosY ];
1644
1645  // posX
1646  Int widthCtx = eTType? 4: width;
1647  const UInt *puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ widthCtx ] * ( g_aucConvertToBit[ widthCtx ] + 3 ) );
1648  for( uiCtxLast = 0; uiCtxLast < uiGroupIdxX; uiCtxLast++ )
1649  {
1650    if (eTType)
1651    {
1652      m_pcBinIf->encodeBin( 1, *( pCtxX + (uiCtxLast>>g_aucConvertToBit[ width ]) ) );
1653    }
1654    else
1655    {
1656      m_pcBinIf->encodeBin( 1, *( pCtxX + puiCtxIdxX[ uiCtxLast ] ) );
1657    }
1658  }
1659  if( uiGroupIdxX < g_uiGroupIdx[ width - 1 ])
1660  {
1661    if ( eTType )
1662    {
1663      m_pcBinIf->encodeBin( 0, *( pCtxX + (uiCtxLast>>g_aucConvertToBit[ width ]) ) );
1664    }
1665    else
1666    {
1667      m_pcBinIf->encodeBin( 0, *( pCtxX + puiCtxIdxX[ uiCtxLast ] ) );
1668    }
1669  }
1670
1671  // posY
1672  Int heightCtx = eTType? 4: height;
1673  const UInt *puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ heightCtx ] * ( g_aucConvertToBit[ heightCtx ] + 3 ) );
1674  for( uiCtxLast = 0; uiCtxLast < uiGroupIdxY; uiCtxLast++ )
1675  {
1676    if (eTType)
1677    {
1678      m_pcBinIf->encodeBin( 1, *( pCtxY + (uiCtxLast>>g_aucConvertToBit[ height ])));
1679    }
1680    else
1681    {
1682      m_pcBinIf->encodeBin( 1, *( pCtxY + puiCtxIdxY[ uiCtxLast ] ) );
1683    }
1684  }
1685  if( uiGroupIdxY < g_uiGroupIdx[ height - 1 ])
1686  {
1687    if (eTType)
1688    {
1689      m_pcBinIf->encodeBin( 0, *( pCtxY + (uiCtxLast>>g_aucConvertToBit[ height ]) ) );
1690    }
1691    else
1692    {
1693      m_pcBinIf->encodeBin( 0, *( pCtxY + puiCtxIdxY[ uiCtxLast ] ) );
1694    }
1695    }
1696  if ( uiGroupIdxX > 3 )
1697  {     
1698    UInt uiCount = ( uiGroupIdxX - 2 ) >> 1;
1699    uiPosX       = uiPosX - g_uiMinInGroup[ uiGroupIdxX ];
1700    for (Int i = uiCount - 1 ; i >= 0; i-- )
1701    {
1702      m_pcBinIf->encodeBinEP( ( uiPosX >> i ) & 1 );
1703    }
1704  }
1705  if ( uiGroupIdxY > 3 )
1706  {     
1707    UInt uiCount = ( uiGroupIdxY - 2 ) >> 1;
1708    uiPosY       = uiPosY - g_uiMinInGroup[ uiGroupIdxY ];
1709    for ( Int i = uiCount - 1 ; i >= 0; i-- )
1710    {
1711      m_pcBinIf->encodeBinEP( ( uiPosY >> i ) & 1 );
1712    }
1713  }
1714}
1715
1716Void TEncSbac::codeCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
1717{
1718  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1719  DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
1720  DTRACE_CABAC_V( eTType )
1721  DTRACE_CABAC_T( "\twidth=" )
1722  DTRACE_CABAC_V( uiWidth )
1723  DTRACE_CABAC_T( "\theight=" )
1724  DTRACE_CABAC_V( uiHeight )
1725  DTRACE_CABAC_T( "\tdepth=" )
1726  DTRACE_CABAC_V( uiDepth )
1727  DTRACE_CABAC_T( "\tabspartidx=" )
1728  DTRACE_CABAC_V( uiAbsPartIdx )
1729  DTRACE_CABAC_T( "\ttoCU-X=" )
1730  DTRACE_CABAC_V( pcCU->getCUPelX() )
1731  DTRACE_CABAC_T( "\ttoCU-Y=" )
1732  DTRACE_CABAC_V( pcCU->getCUPelY() )
1733  DTRACE_CABAC_T( "\tCU-addr=" )
1734  DTRACE_CABAC_V(  pcCU->getAddr() )
1735  DTRACE_CABAC_T( "\tinCU-X=" )
1736  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1737  DTRACE_CABAC_T( "\tinCU-Y=" )
1738  DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1739  DTRACE_CABAC_T( "\tpredmode=" )
1740  DTRACE_CABAC_V(  pcCU->getPredictionMode( uiAbsPartIdx ) )
1741  DTRACE_CABAC_T( "\n" )
1742
1743  if( uiWidth > m_pcSlice->getSPS()->getMaxTrSize() )
1744  {
1745    uiWidth  = m_pcSlice->getSPS()->getMaxTrSize();
1746    uiHeight = m_pcSlice->getSPS()->getMaxTrSize();
1747  }
1748 
1749  UInt uiNumSig = 0;
1750 
1751  // compute number of significant coefficients
1752  uiNumSig = TEncEntropy::countNonZeroCoeffs(pcCoef, uiWidth * uiHeight);
1753 
1754  if ( uiNumSig == 0 )
1755    return;
1756 
1757  eTType = eTType == TEXT_LUMA ? TEXT_LUMA : ( eTType == TEXT_NONE ? TEXT_NONE : TEXT_CHROMA );
1758 
1759  //----- encode significance map -----
1760  const UInt   uiLog2BlockSize   = g_aucConvertToBit[ uiWidth ] + 2;
1761  UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
1762  if (uiScanIdx == SCAN_ZIGZAG)
1763  {
1764    // Map zigzag to diagonal scan
1765    uiScanIdx = SCAN_DIAG;
1766  }
1767  Int blockType = uiLog2BlockSize;
1768  if (uiWidth != uiHeight)
1769  {
1770    uiScanIdx = SCAN_DIAG;
1771    blockType = 4;
1772  }
1773 
1774  const UInt * scan;
1775  if (uiWidth == uiHeight)
1776  {
1777    scan = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize - 1 ];
1778  }
1779  else
1780  {
1781    scan = g_sigScanNSQT[ uiLog2BlockSize - 2 ];
1782  }
1783 
1784  UInt const tsig = pcCU->getSlice()->getPPS()->getTSIG();
1785#if LOSSLESS_CODING
1786  Bool beValid; 
1787  if (pcCU->isLosslessCoded(uiAbsPartIdx))
1788  {
1789    beValid = false;
1790  }
1791  else 
1792  {
1793    beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
1794  }
1795#else
1796  Bool beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
1797#endif
1798
1799  // Find position of last coefficient
1800  Int scanPosLast = -1;
1801  Int posLast;
1802
1803  const UInt * scanCG;
1804  if (uiWidth == uiHeight)
1805  {
1806    scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize > 3 ? uiLog2BlockSize-2-1 : 0 ];
1807    if( uiLog2BlockSize == 3 )
1808    {
1809      scanCG = g_sigLastScan8x8[ uiScanIdx ];
1810    }
1811    else if( uiLog2BlockSize == 5 )
1812    {
1813      scanCG = g_sigLastScanCG32x32;
1814    }
1815  }
1816  else
1817  {
1818    scanCG = g_sigCGScanNSQT[ uiLog2BlockSize - 2 ];
1819  }
1820  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
1821  static const UInt uiShift = MLS_CG_SIZE >> 1;
1822  const UInt uiNumBlkSide = uiWidth >> uiShift;
1823
1824    ::memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
1825
1826    do
1827    {
1828      posLast = scan[ ++scanPosLast ];
1829
1830      // get L1 sig map
1831      UInt uiPosY    = posLast >> uiLog2BlockSize;
1832      UInt uiPosX    = posLast - ( uiPosY << uiLog2BlockSize );
1833      UInt uiBlkIdx  = uiNumBlkSide * (uiPosY >> uiShift) + (uiPosX >> uiShift);
1834      if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR || uiScanIdx == SCAN_VER) )
1835      {
1836        if( uiScanIdx == SCAN_HOR )
1837        {
1838          uiBlkIdx = uiPosY >> 1;
1839        }
1840        else if( uiScanIdx == SCAN_VER )
1841        {
1842          uiBlkIdx = uiPosX >> 1;
1843        }
1844      }
1845      if( pcCoef[ posLast ] )
1846      {
1847        uiSigCoeffGroupFlag[ uiBlkIdx ] = 1;
1848      }
1849
1850      uiNumSig -= ( pcCoef[ posLast ] != 0 );
1851    }
1852    while ( uiNumSig > 0 );
1853
1854  // Code position of last coefficient
1855  Int posLastY = posLast >> uiLog2BlockSize;
1856  Int posLastX = posLast - ( posLastY << uiLog2BlockSize );
1857  codeLastSignificantXY(posLastX, posLastY, uiWidth, uiHeight, eTType, uiScanIdx);
1858 
1859  //===== code significance flag =====
1860  ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, eTType );
1861  ContextModel * const baseCtx = (eTType==TEXT_LUMA) ? m_cCUSigSCModel.get( 0, 0 ) : m_cCUSigSCModel.get( 0, 0 ) + NUM_SIG_FLAG_CTX_LUMA;
1862
1863
1864  const Int  iLastScanSet      = scanPosLast >> LOG2_SCAN_SET_SIZE;
1865  UInt uiNumOne                = 0;
1866  UInt uiGoRiceParam           = 0;
1867  Int  iScanPosSig             = scanPosLast;
1868
1869  for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
1870  {
1871    Int numNonZero = 0;
1872    Int  iSubPos     = iSubSet << LOG2_SCAN_SET_SIZE;
1873    uiGoRiceParam    = 0;
1874    Int absCoeff[16];
1875    UInt coeffSigns = 0;
1876
1877    Int lastNZPosInCG = -1, firstNZPosInCG = SCAN_SET_SIZE;
1878
1879    if( iScanPosSig == scanPosLast )
1880    {
1881      absCoeff[ 0 ] = abs( pcCoef[ posLast ] );
1882      coeffSigns    = ( pcCoef[ posLast ] < 0 );
1883      numNonZero    = 1;
1884      lastNZPosInCG  = iScanPosSig;
1885      firstNZPosInCG = iScanPosSig;
1886      iScanPosSig--;
1887    }
1888
1889      // encode significant_coeffgroup_flag
1890      Int iCGBlkPos = scanCG[ iSubSet ];
1891      Int iCGPosY   = iCGBlkPos / uiNumBlkSide;
1892      Int iCGPosX   = iCGBlkPos - (iCGPosY * uiNumBlkSide);
1893      if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR || uiScanIdx == SCAN_VER) )
1894      {
1895        iCGPosY = (uiScanIdx == SCAN_HOR ? iCGBlkPos : 0);
1896        iCGPosX = (uiScanIdx == SCAN_VER ? iCGBlkPos : 0);
1897      }
1898      if( iSubSet == iLastScanSet || iSubSet == 0)
1899      {
1900        uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
1901      }
1902      else
1903      {
1904          UInt uiSigCoeffGroup   = (uiSigCoeffGroupFlag[ iCGBlkPos ] != 0);
1905          UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight );
1906          m_pcBinIf->encodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
1907      }
1908     
1909      // encode significant_coeff_flag
1910      if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
1911      {
1912        UInt uiBlkPos, uiPosY, uiPosX, uiSig, uiCtxSig;
1913        for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
1914        {
1915          uiBlkPos  = scan[ iScanPosSig ]; 
1916          uiPosY    = uiBlkPos >> uiLog2BlockSize;
1917          uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
1918          uiSig     = (pcCoef[ uiBlkPos ] != 0);
1919          if( iScanPosSig > iSubPos || iSubSet == 0 || numNonZero )
1920          {
1921            uiCtxSig  = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
1922            m_pcBinIf->encodeBin( uiSig, baseCtx[ uiCtxSig ] );
1923          }
1924          if( uiSig )
1925          {
1926            absCoeff[ numNonZero ] = abs( pcCoef[ uiBlkPos ] );
1927            coeffSigns = 2 * coeffSigns + ( pcCoef[ uiBlkPos ] < 0 );
1928            numNonZero++;
1929            if( lastNZPosInCG == -1 )
1930            {
1931              lastNZPosInCG = iScanPosSig;
1932            }
1933            firstNZPosInCG = iScanPosSig;
1934          }
1935        }
1936      }
1937      else
1938      {
1939        iScanPosSig = iSubPos - 1;
1940      }
1941
1942    if( numNonZero > 0 )
1943    {
1944      Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= (Int)tsig );
1945
1946      UInt c1 = 1;
1947      UInt uiCtxSet = (iSubSet > 0 && eTType==TEXT_LUMA) ? 2 : 0;
1948     
1949      if( uiNumOne > 0 )
1950      {
1951        uiCtxSet++;
1952      }
1953     
1954      uiNumOne       >>= 1;
1955      ContextModel *baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUOneSCModel.get( 0, 0 ) + 4 * uiCtxSet : m_cCUOneSCModel.get( 0, 0 ) + NUM_ONE_FLAG_CTX_LUMA + 4 * uiCtxSet;
1956     
1957      Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
1958      Int firstC2FlagIdx = -1;
1959      for( Int idx = 0; idx < numC1Flag; idx++ )
1960      {
1961        UInt uiSymbol = absCoeff[ idx ] > 1;
1962        m_pcBinIf->encodeBin( uiSymbol, baseCtxMod[c1] );
1963        if( uiSymbol )
1964        {
1965          c1 = 0;
1966
1967          if (firstC2FlagIdx == -1)
1968          {
1969            firstC2FlagIdx = idx;
1970          }
1971        }
1972        else if( (c1 < 3) && (c1 > 0) )
1973        {
1974          c1++;
1975        }
1976      }
1977     
1978      if (c1 == 0)
1979      {
1980
1981        baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + uiCtxSet;
1982        if ( firstC2FlagIdx != -1)
1983        {
1984          UInt symbol = absCoeff[ firstC2FlagIdx ] > 2;
1985          m_pcBinIf->encodeBin( symbol, baseCtxMod[0] );
1986        }
1987      }
1988     
1989      if( beValid && signHidden )
1990      {
1991        m_pcBinIf->encodeBinsEP( (coeffSigns >> 1), numNonZero-1 );
1992      }
1993      else
1994      {
1995        m_pcBinIf->encodeBinsEP( coeffSigns, numNonZero );
1996      }
1997     
1998      Int iFirstCoeff2 = 1;   
1999      if (c1 == 0 || numNonZero > C1FLAG_NUMBER)
2000      {
2001        for ( Int idx = 0; idx < numNonZero; idx++ )
2002        {
2003          UInt baseLevel  = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2 ) : 1;
2004
2005          if( absCoeff[ idx ] >= baseLevel)
2006          {
2007            xWriteGoRiceExGolomb( absCoeff[ idx ] - baseLevel, uiGoRiceParam ); 
2008          }
2009          if(absCoeff[ idx ] >= 2) 
2010          {
2011            iFirstCoeff2 = 0;
2012            uiNumOne++;
2013          }
2014        }       
2015      }
2016    }
2017    else
2018    {
2019      uiNumOne >>= 1;
2020    }
2021  }
2022
2023  return;
2024}
2025
2026Void TEncSbac::codeAlfFlag       ( UInt uiCode )
2027{
2028  UInt uiSymbol = ( ( uiCode == 0 ) ? 0 : 1 );
2029  m_pcBinIf->encodeBin( uiSymbol, m_cALFFlagSCModel.get( 0, 0, 0 ) );
2030}
2031
2032Void TEncSbac::codeAlfCtrlFlag( UInt uiSymbol )
2033{
2034  m_pcBinIf->encodeBin( uiSymbol, m_cCUAlfCtrlFlagSCModel.get( 0, 0, 0) );
2035}
2036
2037Void TEncSbac::codeAlfUvlc       ( UInt uiCode )
2038{
2039  Int i;
2040 
2041  if ( uiCode == 0 )
2042  {
2043    m_pcBinIf->encodeBin( 0, m_cALFUvlcSCModel.get( 0, 0, 0 ) );
2044  }
2045  else
2046  {
2047    m_pcBinIf->encodeBin( 1, m_cALFUvlcSCModel.get( 0, 0, 0 ) );
2048    for ( i=0; i<uiCode-1; i++ )
2049    {
2050      m_pcBinIf->encodeBin( 1, m_cALFUvlcSCModel.get( 0, 0, 1 ) );
2051    }
2052    m_pcBinIf->encodeBin( 0, m_cALFUvlcSCModel.get( 0, 0, 1 ) );
2053  }
2054}
2055
2056Void TEncSbac::codeAlfSvlc       ( Int iCode )
2057{
2058  Int i;
2059 
2060  if ( iCode == 0 )
2061  {
2062    m_pcBinIf->encodeBin( 0, m_cALFSvlcSCModel.get( 0, 0, 0 ) );
2063  }
2064  else
2065  {
2066    m_pcBinIf->encodeBin( 1, m_cALFSvlcSCModel.get( 0, 0, 0 ) );
2067   
2068    // write sign
2069    if ( iCode > 0 )
2070    {
2071      m_pcBinIf->encodeBin( 0, m_cALFSvlcSCModel.get( 0, 0, 1 ) );
2072    }
2073    else
2074    {
2075      m_pcBinIf->encodeBin( 1, m_cALFSvlcSCModel.get( 0, 0, 1 ) );
2076      iCode = -iCode;
2077    }
2078   
2079    // write magnitude
2080    for ( i=0; i<iCode-1; i++ )
2081    {
2082      m_pcBinIf->encodeBin( 1, m_cALFSvlcSCModel.get( 0, 0, 2 ) );
2083    }
2084    m_pcBinIf->encodeBin( 0, m_cALFSvlcSCModel.get( 0, 0, 2 ) );
2085  }
2086}
2087
2088Void TEncSbac::codeSaoFlag       ( UInt uiCode )
2089{
2090  UInt uiSymbol = ( ( uiCode == 0 ) ? 0 : 1 );
2091  m_pcBinIf->encodeBin( uiSymbol, m_cSaoFlagSCModel.get( 0, 0, 0 ) );
2092}
2093
2094Void TEncSbac::codeSaoUvlc       ( UInt uiCode )
2095{
2096  Int i;
2097
2098  if ( uiCode == 0 )
2099  {
2100    m_pcBinIf->encodeBin( 0, m_cSaoUvlcSCModel.get( 0, 0, 0 ) );
2101  }
2102  else
2103  {
2104    m_pcBinIf->encodeBin( 1, m_cSaoUvlcSCModel.get( 0, 0, 0 ) );
2105    for ( i=0; i<uiCode-1; i++ )
2106    {
2107      m_pcBinIf->encodeBin( 1, m_cSaoUvlcSCModel.get( 0, 0, 1 ) );
2108    }
2109    m_pcBinIf->encodeBin( 0, m_cSaoUvlcSCModel.get( 0, 0, 1 ) );
2110  }
2111}
2112
2113Void TEncSbac::codeSaoSvlc       ( Int iCode )
2114{
2115  Int i;
2116
2117  if ( iCode == 0 )
2118  {
2119    m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 0 ) );
2120  }
2121  else
2122  {
2123    m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 0 ) );
2124
2125    // write sign
2126    if ( iCode > 0 )
2127    {
2128      m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 1 ) );
2129    }
2130    else
2131    {
2132      m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 1 ) );
2133      iCode = -iCode;
2134    }
2135
2136    // write magnitude
2137    for ( i=0; i<iCode-1; i++ )
2138    {
2139      m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 2 ) );
2140    }
2141    m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 2 ) );
2142  }
2143}
2144/** Code SAO band position
2145 * \param uiCode
2146 */
2147Void TEncSbac::codeSaoUflc       ( UInt uiCode )
2148{
2149  for (Int i=0;i<5;i++)
2150  {
2151    m_pcBinIf->encodeBinEP ( (uiCode>>i) &0x01 );
2152  }
2153}
2154/** Code SAO merge left flag
2155 * \param uiCode
2156 * \param uiCompIdx
2157 */
2158Void TEncSbac::codeSaoMergeLeft       ( UInt uiCode, UInt uiCompIdx )
2159{
2160  if (uiCode == 0)
2161  {
2162    m_pcBinIf->encodeBin(0,  m_cSaoMergeLeftSCModel.get( 0, 0, uiCompIdx ));
2163  }
2164  else
2165  {
2166    m_pcBinIf->encodeBin(1,  m_cSaoMergeLeftSCModel.get( 0, 0, uiCompIdx ));
2167  }
2168}
2169/** Code SAO merge up flag
2170 * \param uiCode
2171 */
2172Void TEncSbac::codeSaoMergeUp       ( UInt uiCode)
2173{
2174  if (uiCode == 0)
2175  {
2176    m_pcBinIf->encodeBin(0,  m_cSaoMergeUpSCModel.get( 0, 0, 0 ));
2177  }
2178  else
2179  {
2180    m_pcBinIf->encodeBin(1,  m_cSaoMergeUpSCModel.get( 0, 0, 0 ));
2181  }
2182}
2183/** Code SAO type index
2184 * \param uiCode
2185 */
2186Void TEncSbac::codeSaoTypeIdx       ( UInt uiCode)
2187{
2188  Int i;
2189  if ( uiCode == 0 )
2190  {
2191    m_pcBinIf->encodeBin( 0, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2192  }
2193  else
2194  {
2195    m_pcBinIf->encodeBin( 1, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2196    for ( i=0; i<uiCode-1; i++ )
2197    {
2198      m_pcBinIf->encodeBin( 1, m_cSaoTypeIdxSCModel.get( 0, 0, 1 ) );
2199    }
2200    m_pcBinIf->encodeBin( 0, m_cSaoTypeIdxSCModel.get( 0, 0, 1 ) );
2201  }
2202}
2203/*!
2204 ****************************************************************************
2205 * \brief
2206 *   estimate bit cost for CBP, significant map and significant coefficients
2207 ****************************************************************************
2208 */
2209Void TEncSbac::estBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType )
2210{
2211  estCBFBit( pcEstBitsSbac, 0, eTType );
2212
2213  estSignificantCoeffGroupMapBit( pcEstBitsSbac, 0, eTType );
2214 
2215  // encode significance map
2216  estSignificantMapBit( pcEstBitsSbac, width, height, eTType );
2217 
2218  // encode significant coefficients
2219  estSignificantCoefficientsBit( pcEstBitsSbac, 0, eTType );
2220}
2221
2222/*!
2223 ****************************************************************************
2224 * \brief
2225 *    estimate bit cost for each CBP bit
2226 ****************************************************************************
2227 */
2228Void TEncSbac::estCBFBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
2229{
2230  ContextModel *pCtx = m_cCUQtCbfSCModel.get( 0 );
2231
2232  for( UInt uiCtxInc = 0; uiCtxInc < 3*NUM_QT_CBF_CTX; uiCtxInc++ )
2233  {
2234    pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
2235    pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
2236  }
2237
2238  pCtx = m_cCUQtRootCbfSCModel.get( 0 );
2239 
2240  for( UInt uiCtxInc = 0; uiCtxInc < 4; uiCtxInc++ )
2241  {
2242    pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
2243    pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
2244  }
2245}
2246
2247
2248/*!
2249 ****************************************************************************
2250 * \brief
2251 *    estimate SAMBAC bit cost for significant coefficient group map
2252 ****************************************************************************
2253 */
2254Void TEncSbac::estSignificantCoeffGroupMapBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
2255{
2256  Int firstCtx = 0, numCtx = NUM_SIG_CG_FLAG_CTX;
2257
2258  for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2259  {
2260    for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2261    {
2262      pcEstBitsSbac->significantCoeffGroupBits[ ctxIdx ][ uiBin ] = m_cCUSigCoeffGroupSCModel.get(  0, eTType, ctxIdx ).getEntropyBits( uiBin );
2263    }
2264  }
2265}
2266
2267
2268/*!
2269 ****************************************************************************
2270 * \brief
2271 *    estimate SAMBAC bit cost for significant coefficient map
2272 ****************************************************************************
2273 */
2274Void TEncSbac::estSignificantMapBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType )
2275{
2276  Int firstCtx = 0, numCtx = (eTType == TEXT_LUMA) ? 9 : 6;
2277  if (std::max(width, height) >= 16)
2278  {
2279    firstCtx = (eTType == TEXT_LUMA) ? 20 : 17;
2280    numCtx = (eTType == TEXT_LUMA) ? 7 : 4;   
2281  }
2282  else if (width == 8)
2283  {
2284    firstCtx = (eTType == TEXT_LUMA) ? 9 : 6;
2285    numCtx = 11;
2286  }
2287 
2288  if (eTType == TEXT_LUMA )
2289  {
2290    for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2291    {
2292      for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2293      {
2294        pcEstBitsSbac->significantBits[ ctxIdx ][ uiBin ] = m_cCUSigSCModel.get(  0, 0, ctxIdx ).getEntropyBits( uiBin );
2295      }
2296    }
2297  }
2298  else
2299  {
2300    for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2301    {
2302      for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2303      {
2304        pcEstBitsSbac->significantBits[ ctxIdx ][ uiBin ] = m_cCUSigSCModel.get(  0, 0, NUM_SIG_FLAG_CTX_LUMA + ctxIdx ).getEntropyBits( uiBin );
2305      }
2306    }
2307  }
2308  Int iBitsX = 0, iBitsY = 0;
2309  const UInt *puiCtxIdx;
2310  Int ctx;
2311  Int widthCtx = eTType? 4 : width;
2312  puiCtxIdx = g_uiLastCtx + (g_aucConvertToBit[ widthCtx ]*(g_aucConvertToBit[ widthCtx ]+3));
2313  ContextModel *pCtxX      = m_cCuCtxLastX.get( 0, eTType );
2314  for (ctx = 0; ctx < g_uiGroupIdx[ width - 1 ]; ctx++)
2315  {
2316    Int ctxOffset = puiCtxIdx[ ctx ];
2317    if (eTType)
2318    {
2319      Int ctxOffsetC =  ctx>>g_aucConvertToBit[ width ];
2320      pcEstBitsSbac->lastXBits[ ctx ] = iBitsX + pCtxX[ ctxOffsetC ].getEntropyBits( 0 );
2321      iBitsX += pCtxX[ ctxOffsetC].getEntropyBits( 1 );
2322    }
2323    else
2324    {
2325      pcEstBitsSbac->lastXBits[ ctx ] = iBitsX + pCtxX[ ctxOffset ].getEntropyBits( 0 );
2326      iBitsX += pCtxX[ ctxOffset ].getEntropyBits( 1 );
2327    }
2328    }
2329  pcEstBitsSbac->lastXBits[ctx] = iBitsX;
2330
2331  Int heightCtx = eTType? 4 : height;
2332  puiCtxIdx = g_uiLastCtx + (g_aucConvertToBit[ heightCtx ]*(g_aucConvertToBit[ heightCtx ]+3));
2333  ContextModel *pCtxY      = m_cCuCtxLastY.get( 0, eTType );
2334  for (ctx = 0; ctx < g_uiGroupIdx[ height - 1 ]; ctx++)
2335  {
2336    Int ctxOffset = puiCtxIdx[ ctx ];
2337    if (eTType)
2338    {
2339      Int ctxOffsetC =  ctx>>g_aucConvertToBit[ height ];
2340      pcEstBitsSbac->lastYBits[ ctx ] = iBitsY + pCtxY[ ctxOffsetC ].getEntropyBits( 0 );
2341      iBitsY += pCtxY[ctxOffsetC].getEntropyBits( 1 );
2342    }
2343    else
2344    {
2345      pcEstBitsSbac->lastYBits[ ctx ] = iBitsY + pCtxY[ ctxOffset ].getEntropyBits( 0 );
2346      iBitsY += pCtxY[ ctxOffset ].getEntropyBits( 1 );
2347    }
2348    }
2349  pcEstBitsSbac->lastYBits[ctx] = iBitsY;
2350}
2351
2352/*!
2353 ****************************************************************************
2354 * \brief
2355 *    estimate bit cost of significant coefficient
2356 ****************************************************************************
2357 */
2358Void TEncSbac::estSignificantCoefficientsBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
2359{
2360  if (eTType==TEXT_LUMA)
2361  {
2362    ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0);
2363    ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0);
2364
2365    for (Int ctxIdx = 0; ctxIdx < NUM_ONE_FLAG_CTX_LUMA; ctxIdx++)
2366    {
2367      pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
2368      pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );   
2369    }
2370
2371    for (Int ctxIdx = 0; ctxIdx < NUM_ABS_FLAG_CTX_LUMA; ctxIdx++)
2372    {
2373      pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
2374      pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );   
2375    }
2376  }
2377  else
2378  {
2379    ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0) + NUM_ONE_FLAG_CTX_LUMA;
2380    ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0) + NUM_ABS_FLAG_CTX_LUMA;
2381
2382    for (Int ctxIdx = 0; ctxIdx < NUM_ONE_FLAG_CTX_CHROMA; ctxIdx++)
2383    {
2384      pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
2385      pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );   
2386    }
2387
2388    for (Int ctxIdx = 0; ctxIdx < NUM_ABS_FLAG_CTX_CHROMA; ctxIdx++)
2389    {
2390      pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
2391      pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );   
2392    }
2393  }
2394}
2395
2396/**
2397 - Initialize our context information from the nominated source.
2398 .
2399 \param pSrc From where to copy context information.
2400 */
2401Void TEncSbac::xCopyContextsFrom( TEncSbac* pSrc )
2402{ 
2403  memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
2404}
2405
2406Void  TEncSbac::loadContexts ( TEncSbac* pScr)
2407{
2408  this->xCopyContextsFrom(pScr);
2409}
2410
2411#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX || (LGE_EDGE_INTRA_A0070 && LGE_EDGE_INTRA_DELTA_DC)
2412Void TEncSbac::xWriteExGolombLevel( UInt uiSymbol, ContextModel& rcSCModel  )
2413{
2414  if( uiSymbol )
2415  {
2416    m_pcBinIf->encodeBin( 1, rcSCModel );
2417    UInt uiCount = 0;
2418    Bool bNoExGo = (uiSymbol < 13);
2419
2420    while( --uiSymbol && ++uiCount < 13 )
2421    {
2422      m_pcBinIf->encodeBin( 1, rcSCModel );
2423    }
2424    if( bNoExGo )
2425    {
2426      m_pcBinIf->encodeBin( 0, rcSCModel );
2427    }
2428    else
2429    {
2430      xWriteEpExGolomb( uiSymbol, 0 );
2431    }
2432  }
2433  else
2434  {
2435    m_pcBinIf->encodeBin( 0, rcSCModel );
2436  }
2437
2438  return;
2439}
2440#endif
2441#if HHI_DMM_WEDGE_INTRA
2442Void TEncSbac::xCodeWedgeFullInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2443{
2444  Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
2445  Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
2446
2447  UInt uiTabIdx = pcCU->getWedgeFullTabIdx( uiAbsPartIdx );
2448
2449  for ( Int i = 0; i < iBits; i++ )
2450  {
2451    m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmmDataSCModel.get(0, 0, 0) );
2452  }
2453}
2454
2455Void TEncSbac::xCodeWedgeFullDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2456{
2457  Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
2458  Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
2459
2460  UInt uiTabIdx = pcCU->getWedgeFullTabIdx( uiAbsPartIdx );
2461
2462  for ( Int i = 0; i < iBits; i++ )
2463  {
2464    m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmmDataSCModel.get(0, 0, 0) );
2465  }
2466
2467  Int iDeltaDC1 = pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx );
2468  Int iDeltaDC2 = pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx );
2469
2470  xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2471  if ( iDeltaDC1 != 0 )
2472  {
2473    UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
2474    m_pcBinIf->encodeBinEP( uiSign );
2475  }
2476  xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2477  if ( iDeltaDC2 != 0 )
2478  {
2479    UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
2480    m_pcBinIf->encodeBinEP( uiSign );
2481  }
2482}
2483
2484Void TEncSbac::xCodeWedgePredDirInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2485{
2486  if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
2487  {
2488    Int iDeltaEnd = pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx );
2489    m_pcBinIf->encodeBin( (iDeltaEnd!=0), m_cDmmDataSCModel.get(0, 0, 2) );
2490
2491    if( iDeltaEnd != 0 )
2492    {
2493      UInt uiAbsValMinus1 = abs(iDeltaEnd)-1;
2494      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01),      m_cDmmDataSCModel.get(0, 0, 2) );
2495      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cDmmDataSCModel.get(0, 0, 2) );
2496
2497      UInt uiSign = iDeltaEnd > 0 ? 0 : 1;
2498      m_pcBinIf->encodeBinEP( uiSign );
2499    }
2500  }
2501}
2502
2503Void TEncSbac::xCodeWedgePredDirDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2504{
2505  if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
2506  {
2507    Int iDeltaEnd = pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx );
2508    m_pcBinIf->encodeBin( (iDeltaEnd!=0), m_cDmmDataSCModel.get(0, 0, 2) );
2509
2510    if( iDeltaEnd != 0 )
2511    {
2512      UInt uiAbsValMinus1 = abs(iDeltaEnd)-1;
2513      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01),      m_cDmmDataSCModel.get(0, 0, 2) );
2514      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cDmmDataSCModel.get(0, 0, 2) );
2515
2516      UInt uiSign = iDeltaEnd > 0 ? 0 : 1;
2517      m_pcBinIf->encodeBinEP( uiSign );
2518    }
2519  }
2520
2521  Int iDeltaDC1 = pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx );
2522  Int iDeltaDC2 = pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx );
2523
2524  xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2525  if ( iDeltaDC1 != 0 )
2526  {
2527    UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
2528    m_pcBinIf->encodeBinEP( uiSign );
2529  }
2530  xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2531  if ( iDeltaDC2 != 0 )
2532  {
2533    UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
2534    m_pcBinIf->encodeBinEP( uiSign );
2535  }
2536}
2537#endif
2538#if HHI_DMM_PRED_TEX
2539#if LGE_DMM3_SIMP_C0044
2540Void TEncSbac::xCodeWedgePredTexInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2541{
2542  Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
2543  Int iBits = g_aucWedgeTexPredBitsListIdx[iIntraIdx];
2544
2545  UInt uiTabIdx = pcCU->getWedgePredTexIntraTabIdx( uiAbsPartIdx );
2546
2547  for ( Int i = 0; i < iBits; i++ )
2548  {
2549    m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmmDataSCModel.get(0, 0, 3) );
2550  }
2551}
2552#endif
2553
2554Void TEncSbac::xCodeWedgePredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2555{
2556#if LGE_DMM3_SIMP_C0044
2557  xCodeWedgePredTexInfo( pcCU, uiAbsPartIdx );
2558#endif
2559  Int iDeltaDC1 = pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx );
2560  Int iDeltaDC2 = pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx );
2561
2562  xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2563  if ( iDeltaDC1 != 0 )
2564  {
2565    UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
2566    m_pcBinIf->encodeBinEP( uiSign );
2567  }
2568  xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2569  if ( iDeltaDC2 != 0 )
2570  {
2571    UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
2572    m_pcBinIf->encodeBinEP( uiSign );
2573  }
2574}
2575
2576Void TEncSbac::xCodeContourPredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2577{
2578  Int iDeltaDC1 = pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx );
2579  Int iDeltaDC2 = pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx );
2580
2581  xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2582  if ( iDeltaDC1 != 0 )
2583  {
2584    UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
2585    m_pcBinIf->encodeBinEP( uiSign );
2586  }
2587  xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2588  if ( iDeltaDC2 != 0 )
2589  {
2590    UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
2591    m_pcBinIf->encodeBinEP( uiSign );
2592  }
2593}
2594#endif
2595
2596#if RWTH_SDC_DLT_B0036
2597#if !PKU_QC_DEPTH_INTRA_UNI_D0195
2598Void TEncSbac::codeSDCPredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
2599{
2600  assert( pcCU->getSlice()->getSPS()->isDepth() );
2601  assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
2602  assert( pcCU->getSDCFlag(uiAbsPartIdx) );
2603 
2604  UInt uiPredMode     = pcCU->getLumaIntraDir(uiAbsPartIdx);
2605  UInt uiCtx          = 0;
2606 
2607  UInt uiMPModeIdx    = 0;
2608 
2609  for(Int i=0; i<RWTH_SDC_NUM_PRED_MODES-1; i++)
2610  {
2611    UInt uiBit = (uiPredMode == g_auiSDCPredModes[uiMPModeIdx]) ? 1 : 0;
2612#if INTEL_SDC64_D0193
2613    if( !(pcCU->getWidth(uiAbsPartIdx) == 64 && i == 1))
2614#endif
2615    m_pcBinIf->encodeBin( uiBit, m_cSDCPredModeSCModel.get( 0, i, uiCtx ) );
2616   
2617    // if mode is most probable mode, we are done here
2618    if ( uiBit == 1 )
2619      break;
2620   
2621    // else: get next most probable pred mode
2622    uiMPModeIdx = (uiMPModeIdx+1)%RWTH_SDC_NUM_PRED_MODES;
2623  }
2624 
2625#if HHI_DMM_WEDGE_INTRA
2626  if( uiPredMode == DMM_WEDGE_FULL_IDX )          { xCodeWedgeFullInfo          ( pcCU, uiAbsPartIdx ); }
2627  if( uiPredMode == DMM_WEDGE_PREDDIR_IDX )       { xCodeWedgePredDirInfo       ( pcCU, uiAbsPartIdx ); }
2628#endif
2629 
2630  AOF(uiPredMode == g_auiSDCPredModes[uiMPModeIdx]);
2631}
2632
2633Void TEncSbac::codeSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2634{
2635  // get context function is here
2636  UInt uiSymbol = pcCU->getSDCFlag( uiAbsPartIdx ) ? 1 : 0;
2637  UInt uiCtxSDCFlag = pcCU->getCtxSDCFlag( uiAbsPartIdx );
2638  m_pcBinIf->encodeBin( uiSymbol, m_cSDCFlagSCModel.get( 0, 0, uiCtxSDCFlag ) );
2639 
2640}
2641#endif
2642
2643Void TEncSbac::codeSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment )
2644{
2645  assert( pcCU->getSlice()->getSPS()->isDepth() );
2646  assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
2647  assert( pcCU->getSDCFlag(uiAbsPartIdx) );
2648  assert( uiSegment < 2 );
2649 
2650  Pel segmentDCOffset = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
2651 
2652  UInt uiResidual = segmentDCOffset == 0 ? 0 : 1;
2653  UInt uiSign     = segmentDCOffset < 0 ? 1 : 0;
2654  UInt uiAbsIdx   = abs(segmentDCOffset);
2655#if !LGE_CONCATENATE_D0141
2656  UInt uiBit = 0;
2657#endif
2658 
2659  UInt uiMaxResidualBits  = GetBitsPerDepthValue();
2660  assert( uiMaxResidualBits <= g_uiBitDepth );
2661 
2662  // residual flag
2663#if RWTH_SDC_CTX_SIMPL_D0032
2664  m_pcBinIf->encodeBin( uiResidual, m_cSDCResidualFlagSCModel.get( 0, 0, 0 ) );
2665#else
2666  m_pcBinIf->encodeBin( uiResidual, m_cSDCResidualFlagSCModel.get( 0, uiSegment, 0 ) ); //TODO depthmap: more sophisticated context selection
2667#endif
2668 
2669  if (uiResidual)
2670  {
2671    // encode sign bit of residual
2672#if RWTH_SDC_CTX_SIMPL_D0032
2673    m_pcBinIf->encodeBinEP( uiSign );
2674#else
2675    m_pcBinIf->encodeBin( uiSign, m_cSDCResidualSignFlagSCModel.get( 0, uiSegment, 0 ) ); //TODO depthmap: more sophisticated context selection
2676#endif
2677       
2678    assert(uiAbsIdx < GetNumDepthValues());
2679   
2680    // encode residual magnitude
2681    uiAbsIdx -= 1;
2682#if LGE_CONCATENATE_D0141
2683    //prefix part
2684    if ( uiAbsIdx == 0 )
2685        m_pcBinIf->encodeBin( 0, m_cSDCResidualSCModel.get(0, 0, 0) );
2686    else
2687    {
2688        UInt l = uiAbsIdx;
2689        UInt k = 0;
2690        while ( l > 0 && k < PrefixThreshold )
2691        {
2692            m_pcBinIf->encodeBin( 1, m_cSDCResidualSCModel.get(0, 0, 0) );
2693            l--;
2694            k++;
2695        }
2696        if ( uiAbsIdx < PrefixThreshold )
2697            m_pcBinIf->encodeBin( 0, m_cSDCResidualSCModel.get(0, 0, 0) );
2698        //suffix part
2699        else
2700        {
2701            uiAbsIdx -= PrefixThreshold;
2702            UInt uiSuffixLength = BitsPerSuffix;
2703            UInt uiBitInfo = 0;
2704            for ( Int i = 0; i < uiSuffixLength; i++)
2705            {
2706                uiBitInfo = ( uiAbsIdx & ( 1 << i ) ) >> i;
2707                m_pcBinIf->encodeBinEP( uiBitInfo);
2708            }
2709        }
2710    }
2711#else
2712    for (Int i=0; i<uiMaxResidualBits; i++)
2713    {
2714      uiBit = (uiAbsIdx & (1<<i))>>i;
2715     
2716#if RWTH_SDC_CTX_SIMPL_D0032
2717      m_pcBinIf->encodeBin( uiBit, m_cSDCResidualSCModel.get( 0, 0, i ) );
2718#else
2719      m_pcBinIf->encodeBin( uiBit, m_cSDCResidualSCModel.get( 0, uiSegment, i ) ); //TODO depthmap: more sophisticated context selection
2720#endif
2721    }
2722#endif
2723   
2724  }
2725}
2726#endif
2727//! \}
Note: See TracBrowser for help on using the repository browser.