Changeset 56 in 3DVCSoftware for trunk/source/Lib/TLibEncoder/TEncSbac.cpp


Ignore:
Timestamp:
11 May 2012, 21:20:17 (12 years ago)
Author:
hschwarz
Message:

updated trunk (move to HM6.1)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibEncoder/TEncSbac.cpp

    r42 r56  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license.
     4 * granted under this license. 
    55 *
    6  * Copyright (c) 2010-2011, ISO/IEC
     6 * Copyright (c) 2010-2012, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    1515 *    this list of conditions and the following disclaimer in the documentation
    1616 *    and/or other materials provided with the distribution.
    17  *  * Neither the name of the ISO/IEC nor the names of its contributors may
     17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
    1818 *    be used to endorse or promote products derived from this software without
    1919 *    specific prior written permission.
     
    3232 */
    3333
    34 
    35 
    3634/** \file     TEncSbac.cpp
    3735    \brief    SBAC encoder class
     
    4240
    4341#include <map>
    44 
    45 extern UChar  stateMappingTable[113];
    46 extern Int entropyBits[128];
     42#include <algorithm>
     43
     44//! \ingroup TLibEncoder
     45//! \{
    4746
    4847// ====================================================================================================================
     
    5857, m_uiCoeffCost               ( 0 )
    5958, m_uiMaxAlfCtrlDepth         ( 0 )
    60 , m_cCUSplitFlagSCModel       ( 1,             1,               NUM_SPLIT_FLAG_CTX            )
    61 , m_cCUSkipFlagSCModel        ( 1,             1,               NUM_SKIP_FLAG_CTX            )
    62 , m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        )
    63 , m_cCUMergeIdxExtSCModel     ( 1,             1,               NUM_MERGE_IDX_EXT_CTX         )
    64 , m_cCUMVMergeIdxExtSCModel   ( 1,             1,               NUM_MV_MERGE_IDX_EXT_CTX      )
    65 , m_cResPredFlagSCModel       ( 1,             1,               NUM_RES_PRED_FLAG_CTX         )
    66 , m_cCUPartSizeSCModel        ( 1,             1,               NUM_PART_SIZE_CTX             )
    67 , m_cCUPredModeSCModel        ( 1,             1,               NUM_PRED_MODE_CTX             )
    68 , m_cCUAlfCtrlFlagSCModel     ( 1,             1,               NUM_ALF_CTRL_FLAG_CTX         )
    69 , m_cCUIntraPredSCModel       ( 1,             1,               NUM_ADI_CTX                   )
    70 #if ADD_PLANAR_MODE
    71 , m_cPlanarFlagSCModel        ( 1,             1,               NUM_PLANARFLAG_CTX            )
    72 #endif
    73 , m_cCUChromaPredSCModel      ( 1,             1,               NUM_CHROMA_PRED_CTX           )
    74 , m_cCUDeltaQpSCModel         ( 1,             1,               NUM_DELTA_QP_CTX              )
    75 , m_cCUInterDirSCModel        ( 1,             1,               NUM_INTER_DIR_CTX             )
    76 , m_cCURefPicSCModel          ( 1,             1,               NUM_REF_NO_CTX                )
    77 , m_cCUMvdSCModel             ( 1,             2,               NUM_MV_RES_CTX                )
    78 , m_cCUQtCbfSCModel           ( 1,             3,               NUM_QT_CBF_CTX                )
    79 , m_cCUTransSubdivFlagSCModel ( 1,             1,               NUM_TRANS_SUBDIV_FLAG_CTX     )
    80 , m_cCUQtRootCbfSCModel       ( 1,             1,               NUM_QT_ROOT_CBF_CTX           )
    81 #if SIMPLE_CONTEXT_SIG
    82 , m_cCUSigSCModel             ( 4,             2,               NUM_SIG_FLAG_CTX              )
    83 #else
    84 , m_cCUSigSCModel             ( MAX_CU_DEPTH,  2,               NUM_SIG_FLAG_CTX              )
    85 #endif
    86 #if PCP_SIGMAP_SIMPLE_LAST
    87 , m_cCuCtxLastX               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          )
    88 , m_cCuCtxLastY               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          )
    89 #else
    90 , m_cCULastSCModel            ( MAX_CU_DEPTH,  2,               NUM_LAST_FLAG_CTX             )
    91 #endif
    92 , m_cCUOneSCModel             ( 1,             2,               NUM_ONE_FLAG_CTX              )
    93 , m_cCUAbsSCModel             ( 1,             2,               NUM_ABS_FLAG_CTX              )
    94 , m_cMVPIdxSCModel            ( 1,             1,               NUM_MVP_IDX_CTX               )
    95 , m_cALFFlagSCModel           ( 1,             1,               NUM_ALF_FLAG_CTX              )
    96 , m_cALFUvlcSCModel           ( 1,             1,               NUM_ALF_UVLC_CTX              )
    97 , m_cALFSvlcSCModel           ( 1,             1,               NUM_ALF_SVLC_CTX              )
    98 #if MTK_SAO
    99 , m_cAOFlagSCModel            ( 1,             1,               NUM_AO_FLAG_CTX              )
    100 , m_cAOUvlcSCModel            ( 1,             1,               NUM_AO_UVLC_CTX              )
    101 , m_cAOSvlcSCModel            ( 1,             1,               NUM_AO_SVLC_CTX              )
    102 #endif
    103 , m_cViewIdxSCModel           ( 1,             1,               NUM_VIEW_IDX_CTX              )
     59, m_numContextModels          ( 0 )
     60, m_cCUSplitFlagSCModel       ( 1,             1,               NUM_SPLIT_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels )
     61, m_cCUSkipFlagSCModel        ( 1,             1,               NUM_SKIP_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     62, m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        , m_contextModels + m_numContextModels, m_numContextModels)
     63, m_cCUMergeIdxExtSCModel     ( 1,             1,               NUM_MERGE_IDX_EXT_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
     64#if HHI_INTER_VIEW_RESIDUAL_PRED
     65, m_cResPredFlagSCModel       ( 1,             1,               NUM_RES_PRED_FLAG_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
     66#endif
     67, m_cCUPartSizeSCModel        ( 1,             1,               NUM_PART_SIZE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     68, m_cCUPredModeSCModel        ( 1,             1,               NUM_PRED_MODE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     69, m_cCUAlfCtrlFlagSCModel     ( 1,             1,               NUM_ALF_CTRL_FLAG_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
     70, m_cCUIntraPredSCModel       ( 1,             1,               NUM_ADI_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
     71, m_cCUChromaPredSCModel      ( 1,             1,               NUM_CHROMA_PRED_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
     72, m_cCUDeltaQpSCModel         ( 1,             1,               NUM_DELTA_QP_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     73, m_cCUInterDirSCModel        ( 1,             1,               NUM_INTER_DIR_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
     74, m_cCURefPicSCModel          ( 1,             1,               NUM_REF_NO_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
     75, m_cCUMvdSCModel             ( 1,             1,               NUM_MV_RES_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
     76, m_cCUQtCbfSCModel           ( 1,             2,               NUM_QT_CBF_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
     77, m_cCUTransSubdivFlagSCModel ( 1,             1,               NUM_TRANS_SUBDIV_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
     78, m_cCUQtRootCbfSCModel       ( 1,             1,               NUM_QT_ROOT_CBF_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
     79, m_cCUSigCoeffGroupSCModel   ( 1,             2,               NUM_SIG_CG_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
     80, m_cCUSigSCModel             ( 1,             1,               NUM_SIG_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     81, m_cCuCtxLastX               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          , m_contextModels + m_numContextModels, m_numContextModels)
     82, m_cCuCtxLastY               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          , m_contextModels + m_numContextModels, m_numContextModels)
     83, m_cCUOneSCModel             ( 1,             1,               NUM_ONE_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     84, m_cCUAbsSCModel             ( 1,             1,               NUM_ABS_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     85, m_cMVPIdxSCModel            ( 1,             1,               NUM_MVP_IDX_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
     86, m_cALFFlagSCModel           ( 1,             1,               NUM_ALF_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     87, m_cALFUvlcSCModel           ( 1,             1,               NUM_ALF_UVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     88, m_cALFSvlcSCModel           ( 1,             1,               NUM_ALF_SVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     89#if AMP_CTX
     90, m_cCUAMPSCModel             ( 1,             1,               NUM_CU_AMP_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
     91#else
     92, m_cCUXPosiSCModel           ( 1,             1,               NUM_CU_X_POS_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     93, m_cCUYPosiSCModel           ( 1,             1,               NUM_CU_Y_POS_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     94#endif
     95, m_cSaoFlagSCModel           ( 1,             1,               NUM_SAO_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     96, m_cSaoUvlcSCModel           ( 1,             1,               NUM_SAO_UVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     97, m_cSaoSvlcSCModel           ( 1,             1,               NUM_SAO_SVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     98#if SAO_UNIT_INTERLEAVING
     99, m_cSaoMergeLeftSCModel      ( 1,             1,               NUM_SAO_MERGE_LEFT_FLAG_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
     100, m_cSaoMergeUpSCModel        ( 1,             1,               NUM_SAO_MERGE_UP_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
     101, m_cSaoTypeIdxSCModel        ( 1,             1,               NUM_SAO_TYPE_IDX_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
     102#endif
    104103#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    105 , m_cIntraDMMSCModel          ( 1,             1,               NUM_DMM_CTX                   )
    106 , m_cIntraWedgeSCModel        ( 1,             1,               NUM_WEDGE_CTX                 )
    107 #endif
    108 {
    109 
     104, m_cDmmFlagSCModel           ( 1,             1,               NUM_DMM_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     105, m_cDmmModeSCModel           ( 1,             1,               NUM_DMM_MODE_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     106, m_cDmmDataSCModel           ( 1,             1,               NUM_DMM_DATA_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     107#endif
     108{
     109  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
     110  m_iSliceGranularity = 0;
    110111}
    111112
     
    123124  SliceType eSliceType  = m_pcSlice->getSliceType();
    124125 
    125   m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (Short*)INIT_SPLIT_FLAG );
    126  
    127   m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (Short*)INIT_SKIP_FLAG );
    128   m_cCUAlfCtrlFlagSCModel.initBuffer     ( eSliceType, iQp, (Short*)INIT_ALF_CTRL_FLAG );
    129   m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (Short*)INIT_MERGE_FLAG_EXT);
    130   m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (Short*)INIT_MERGE_IDX_EXT);
    131   m_cCUMVMergeIdxExtSCModel.initBuffer   ( eSliceType, iQp, (Short*)INIT_MV_MERGE_IDX_EXT );
    132   m_cResPredFlagSCModel.initBuffer       ( eSliceType, iQp, (Short*)INIT_RES_PRED_FLAG );
    133   m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (Short*)INIT_PART_SIZE );
    134   m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (Short*)INIT_PRED_MODE );
    135   m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (Short*)INIT_INTRA_PRED_MODE );
    136 #if ADD_PLANAR_MODE
    137   m_cPlanarFlagSCModel.initBuffer        ( eSliceType, iQp, (Short*)INIT_PLANARFLAG );
    138 #endif
    139   m_cCUChromaPredSCModel.initBuffer      ( eSliceType, iQp, (Short*)INIT_CHROMA_PRED_MODE );
    140   m_cCUInterDirSCModel.initBuffer        ( eSliceType, iQp, (Short*)INIT_INTER_DIR );
    141   m_cCUMvdSCModel.initBuffer             ( eSliceType, iQp, (Short*)INIT_MVD );
    142   m_cCURefPicSCModel.initBuffer          ( eSliceType, iQp, (Short*)INIT_REF_PIC );
    143   m_cCUDeltaQpSCModel.initBuffer         ( eSliceType, iQp, (Short*)INIT_DQP );
    144   m_cCUQtCbfSCModel.initBuffer           ( eSliceType, iQp, (Short*)INIT_QT_CBF );
    145   m_cCUQtRootCbfSCModel.initBuffer       ( eSliceType, iQp, (Short*)INIT_QT_ROOT_CBF );
    146   m_cCUSigSCModel.initBuffer             ( eSliceType, iQp, (Short*)INIT_SIG_FLAG );
    147 #if PCP_SIGMAP_SIMPLE_LAST
    148   m_cCuCtxLastX.initBuffer               ( eSliceType, iQp, (Short*)INIT_LAST_X );
    149   m_cCuCtxLastY.initBuffer               ( eSliceType, iQp, (Short*)INIT_LAST_Y );
    150 #else
    151   m_cCULastSCModel.initBuffer            ( eSliceType, iQp, (Short*)INIT_LAST_FLAG );
    152 #endif
    153   m_cCUOneSCModel.initBuffer             ( eSliceType, iQp, (Short*)INIT_ONE_FLAG );
    154   m_cCUAbsSCModel.initBuffer             ( eSliceType, iQp, (Short*)INIT_ABS_FLAG );
    155   m_cMVPIdxSCModel.initBuffer            ( eSliceType, iQp, (Short*)INIT_MVP_IDX );
    156   m_cALFFlagSCModel.initBuffer           ( eSliceType, iQp, (Short*)INIT_ALF_FLAG );
    157   m_cALFUvlcSCModel.initBuffer           ( eSliceType, iQp, (Short*)INIT_ALF_UVLC );
    158   m_cALFSvlcSCModel.initBuffer           ( eSliceType, iQp, (Short*)INIT_ALF_SVLC );
    159   m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (Short*)INIT_TRANS_SUBDIV_FLAG );
    160 #if MTK_SAO
    161   m_cAOFlagSCModel.initBuffer           ( eSliceType, iQp, (Short*)INIT_AO_FLAG );
    162   m_cAOUvlcSCModel.initBuffer           ( eSliceType, iQp, (Short*)INIT_AO_UVLC );
    163   m_cAOSvlcSCModel.initBuffer           ( eSliceType, iQp, (Short*)INIT_AO_SVLC );
    164 #endif
    165   m_cViewIdxSCModel.initBuffer           ( eSliceType, iQp, (Short*)INIT_VIEW_IDX );
     126#if CABAC_INIT_FLAG
     127  Int  encCABACTableIdx = m_pcSlice->getPPS()->getEncCABACTableIdx();
     128  if (!m_pcSlice->isIntra() && (encCABACTableIdx==B_SLICE || encCABACTableIdx==P_SLICE) && m_pcSlice->getPPS()->getCabacInitPresentFlag())
     129  {
     130    eSliceType = (SliceType) encCABACTableIdx;
     131  }
     132#endif
     133
     134  m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
     135 
     136  m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
     137  m_cCUAlfCtrlFlagSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
     138  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
     139  m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
     140#if HHI_INTER_VIEW_RESIDUAL_PRED
     141  m_cResPredFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
     142#endif
     143  m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
     144#if AMP_CTX
     145  m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
     146#else
     147  m_cCUXPosiSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_CU_X_POS );
     148  m_cCUYPosiSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_CU_Y_POS );
     149#endif
     150  m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
     151  m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
     152  m_cCUChromaPredSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
     153  m_cCUInterDirSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
     154  m_cCUMvdSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MVD );
     155  m_cCURefPicSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
     156  m_cCUDeltaQpSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DQP );
     157  m_cCUQtCbfSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
     158  m_cCUQtRootCbfSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
     159  m_cCUSigCoeffGroupSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
     160  m_cCUSigSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
     161  m_cCuCtxLastX.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
     162  m_cCuCtxLastY.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
     163  m_cCUOneSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
     164  m_cCUAbsSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
     165  m_cMVPIdxSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
     166  m_cALFFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_FLAG );
     167  m_cALFUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_UVLC );
     168  m_cALFSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_SVLC );
     169  m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
     170  m_cSaoFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_FLAG );
     171  m_cSaoUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
     172  m_cSaoSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
     173#if SAO_UNIT_INTERLEAVING
     174  m_cSaoMergeLeftSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
     175  m_cSaoMergeUpSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
     176  m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
     177#endif
    166178#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    167   m_cIntraDMMSCModel.initBuffer          ( eSliceType, iQp, (Short*)INIT_INTRA_DMM );
    168   m_cIntraWedgeSCModel.initBuffer        ( eSliceType, iQp, (Short*)INIT_INTRA_WEDGELET );
     179  m_cDmmFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_FLAG );
     180  m_cDmmModeSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
     181  m_cDmmDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_DATA );
    169182#endif
    170183
     
    177190}
    178191
    179 #if BITSTREAM_EXTRACTION
    180 Void TEncSbac::codeNALUnitHeader( NalUnitType eNalUnitType, NalRefIdc eNalRefIdc, UInt TemporalId, UInt uiLayerId )
    181 #else
    182 Void TEncSbac::codeNALUnitHeader( NalUnitType eNalUnitType, NalRefIdc eNalRefIdc, UInt TemporalId, Bool bOutputFlag )
     192#if CABAC_INIT_FLAG
     193/** The function does the following:
     194 * If current slice type is P/B then it determines the distance of initialisation type 1 and 2 from the current CABAC states and
     195 * stores the index of the closest table.  This index is used for the next P/B slice when cabac_init_present_flag is true.
     196 */
     197Void TEncSbac::determineCabacInitIdx()
     198{
     199  Int  qp              = m_pcSlice->getSliceQp();
     200
     201  if (!m_pcSlice->isIntra())
     202  {
     203    SliceType aSliceTypeChoices[] = {B_SLICE, P_SLICE};
     204
     205    UInt bestCost             = MAX_UINT;
     206    SliceType bestSliceType   = aSliceTypeChoices[0];
     207    for (UInt idx=0; idx<2; idx++)
     208    {
     209      UInt curCost          = 0;
     210      SliceType curSliceType  = aSliceTypeChoices[idx];
     211
     212      curCost  = m_cCUSplitFlagSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_SPLIT_FLAG );
     213      curCost += m_cCUSkipFlagSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SKIP_FLAG );
     214      curCost += m_cCUAlfCtrlFlagSCModel.calcCost     ( curSliceType, qp, (UChar*)INIT_ALF_CTRL_FLAG );
     215      curCost += m_cCUMergeFlagExtSCModel.calcCost    ( curSliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT);
     216      curCost += m_cCUMergeIdxExtSCModel.calcCost     ( curSliceType, qp, (UChar*)INIT_MERGE_IDX_EXT);
     217#if HHI_INTER_VIEW_RESIDUAL_PRED
     218      curCost += m_cResPredFlagSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_RES_PRED_FLAG);
     219#endif
     220      curCost += m_cCUPartSizeSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_PART_SIZE );
     221#if AMP_CTX
     222      curCost += m_cCUAMPSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_CU_AMP_POS );
     223#else
     224      curCost += m_cCUXPosiSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_CU_X_POS );
     225      curCost += m_cCUYPosiSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_CU_Y_POS );
     226#endif
     227      curCost += m_cCUPredModeSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_PRED_MODE );
     228      curCost += m_cCUIntraPredSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
     229      curCost += m_cCUChromaPredSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
     230      curCost += m_cCUInterDirSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_INTER_DIR );
     231      curCost += m_cCUMvdSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_MVD );
     232      curCost += m_cCURefPicSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_REF_PIC );
     233      curCost += m_cCUDeltaQpSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_DQP );
     234      curCost += m_cCUQtCbfSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_QT_CBF );
     235      curCost += m_cCUQtRootCbfSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
     236      curCost += m_cCUSigCoeffGroupSCModel.calcCost   ( curSliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
     237      curCost += m_cCUSigSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_SIG_FLAG );
     238      curCost += m_cCuCtxLastX.calcCost               ( curSliceType, qp, (UChar*)INIT_LAST );
     239      curCost += m_cCuCtxLastY.calcCost               ( curSliceType, qp, (UChar*)INIT_LAST );
     240      curCost += m_cCUOneSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_ONE_FLAG );
     241      curCost += m_cCUAbsSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_ABS_FLAG );
     242      curCost += m_cMVPIdxSCModel.calcCost            ( curSliceType, qp, (UChar*)INIT_MVP_IDX );
     243      curCost += m_cALFFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_ALF_FLAG );
     244      curCost += m_cALFUvlcSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_ALF_UVLC );
     245      curCost += m_cALFSvlcSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_ALF_SVLC );
     246      curCost += m_cCUTransSubdivFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
     247      curCost += m_cSaoFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_SAO_FLAG );
     248      curCost += m_cSaoUvlcSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_SAO_UVLC );
     249      curCost += m_cSaoSvlcSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_SAO_SVLC );
     250#if SAO_UNIT_INTERLEAVING
     251      curCost += m_cSaoMergeLeftSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
     252      curCost += m_cSaoMergeUpSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
     253      curCost += m_cSaoTypeIdxSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
     254#endif
     255
     256      if (curCost < bestCost)
     257      {
     258        bestSliceType = curSliceType;
     259        bestCost      = curCost;
     260      }
     261    }
     262    m_pcSlice->getPPS()->setEncCABACTableIdx( bestSliceType );
     263  }
     264  else
     265  {
     266    m_pcSlice->getPPS()->setEncCABACTableIdx( I_SLICE );
     267  } 
     268}
     269#endif
     270
     271
     272/** The function does the followng: Write out terminate bit. Flush CABAC. Intialize CABAC states. Start CABAC.
     273 */
     274Void TEncSbac::updateContextTables( SliceType eSliceType, Int iQp, Bool bExecuteFinish )
     275{
     276  m_pcBinIf->encodeBinTrm(1);
     277  if (bExecuteFinish) m_pcBinIf->finish();
     278  m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
     279 
     280  m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
     281  m_cCUAlfCtrlFlagSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
     282  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
     283  m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
     284#if HHI_INTER_VIEW_RESIDUAL_PRED
     285  m_cResPredFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
     286#endif
     287  m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
     288#if AMP_CTX
     289  m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
     290#else
     291  m_cCUXPosiSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_CU_X_POS );
     292  m_cCUYPosiSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_CU_Y_POS );
     293#endif
     294  m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
     295  m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
     296  m_cCUChromaPredSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
     297  m_cCUInterDirSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
     298  m_cCUMvdSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MVD );
     299  m_cCURefPicSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
     300  m_cCUDeltaQpSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DQP );
     301  m_cCUQtCbfSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
     302  m_cCUQtRootCbfSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
     303  m_cCUSigCoeffGroupSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
     304  m_cCUSigSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
     305  m_cCuCtxLastX.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
     306  m_cCuCtxLastY.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
     307  m_cCUOneSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
     308  m_cCUAbsSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
     309  m_cMVPIdxSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
     310  m_cALFFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_FLAG );
     311  m_cALFUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_UVLC );
     312  m_cALFSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_ALF_SVLC );
     313  m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
     314  m_cSaoFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_FLAG );
     315  m_cSaoUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
     316  m_cSaoSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
     317#if SAO_UNIT_INTERLEAVING
     318  m_cSaoMergeLeftSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
     319  m_cSaoMergeUpSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
     320  m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
     321#endif
     322#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
     323  m_cDmmFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_FLAG );
     324  m_cDmmModeSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
     325  m_cDmmDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DMM_DATA );
     326#endif
     327 
     328  m_pcBinIf->start();
     329}
     330
     331Void TEncSbac::writeTileMarker( UInt uiTileIdx, UInt uiBitsUsed )
     332{
     333  for (Int iShift=uiBitsUsed-1; iShift>=0; iShift--)
     334  {
     335    m_pcBinIf->encodeBinEP ( (uiTileIdx & (1 << iShift)) >> iShift );
     336  }
     337}
     338
     339void TEncSbac::codeSEI(const SEI&)
     340{
     341  assert(0);
     342}
     343
     344#if HHI_MPI
     345Void TEncSbac::codeSPS( TComSPS* pcSPS, Bool bIsDepth )
     346#else
     347Void TEncSbac::codeSPS( TComSPS* pcSPS )
    183348#endif
    184349{
     
    187352}
    188353
    189 void TEncSbac::codeSEI(const SEI&)
    190 {
    191   assert(0);
    192 }
    193 
    194 Void TEncSbac::codeSPS( TComSPS* pcSPS )
     354Void TEncSbac::codePPS( TComPPS* pcPPS )
    195355{
    196356  assert (0);
     
    198358}
    199359
    200 Void TEncSbac::codePPS( TComPPS* pcPPS )
     360Void TEncSbac::codeSliceHeader( TComSlice* pcSlice )
    201361{
    202362  assert (0);
     
    204364}
    205365
    206 Void TEncSbac::codeSliceHeader( TComSlice* pcSlice )
     366#if TILES_WPP_ENTRY_POINT_SIGNALLING
     367Void TEncSbac::codeTilesWPPEntryPoint( TComSlice* pSlice )
    207368{
    208369  assert (0);
    209370  return;
    210371}
     372#else
     373Void TEncSbac::codeSliceHeaderSubstreamTable( TComSlice* pcSlice )
     374{
     375  assert (0);
     376}
     377#endif
    211378
    212379Void TEncSbac::codeTerminatingBit( UInt uilsLast )
     
    220387}
    221388
    222 
     389#if OL_FLUSH
     390Void TEncSbac::codeFlush()
     391{
     392  m_pcBinIf->flush();
     393}
     394
     395Void TEncSbac::encodeStart()
     396{
     397  m_pcBinIf->start();
     398}
     399#endif
    223400
    224401Void TEncSbac::xWriteUnarySymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset )
     
    269446Void TEncSbac::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
    270447{
     448  UInt bins = 0;
     449  Int numBins = 0;
     450 
    271451  while( uiSymbol >= (UInt)(1<<uiCount) )
    272452  {
    273     m_pcBinIf->encodeBinEP( 1 );
    274     uiSymbol -= 1<<uiCount;
     453    bins = 2 * bins + 1;
     454    numBins++;
     455    uiSymbol -= 1 << uiCount;
    275456    uiCount  ++;
    276457  }
    277   m_pcBinIf->encodeBinEP( 0 );
    278   while( uiCount-- )
    279   {
    280     m_pcBinIf->encodeBinEP( (uiSymbol>>uiCount) & 1 );
    281   }
    282  
    283   return;
    284 }
    285 
    286 #if E253
     458  bins = 2 * bins + 0;
     459  numBins++;
     460 
     461  bins = (bins << uiCount) | uiSymbol;
     462  numBins += uiCount;
     463 
     464  assert( numBins <= 32 );
     465  m_pcBinIf->encodeBinsEP( bins, numBins );
     466}
     467
    287468/** Coding of coeff_abs_level_minus3
    288469 * \param uiSymbol value of coeff_abs_level_minus3
     
    292473Void TEncSbac::xWriteGoRiceExGolomb( UInt uiSymbol, UInt &ruiGoRiceParam )
    293474{
    294   UInt uiCount      = 0;
    295475  UInt uiMaxVlc     = g_auiGoRiceRange[ ruiGoRiceParam ];
    296476  Bool bExGolomb    = ( uiSymbol > uiMaxVlc );
    297477  UInt uiCodeWord   = min<UInt>( uiSymbol, ( uiMaxVlc + 1 ) );
    298478  UInt uiQuotient   = uiCodeWord >> ruiGoRiceParam;
    299   UInt uiUnaryPart  = uiQuotient;
    300   UInt uiRemainder  = 1;
    301479  UInt uiMaxPreLen  = g_auiGoRicePrefixLen[ ruiGoRiceParam ];
    302 
    303   if( uiUnaryPart )
    304   {
    305     m_pcBinIf->encodeBinEP( 1 );
    306     uiCount++;
    307 
    308     while( --uiUnaryPart && uiCount < uiMaxPreLen )
    309     {
    310       m_pcBinIf->encodeBinEP( 1 );
    311       uiCount++;
    312     }
    313 
    314     if( uiCount < uiMaxPreLen )
    315     {
    316       m_pcBinIf->encodeBinEP( uiUnaryPart ? 1 : 0 );
    317     }
     480 
     481  UInt binValues;
     482  Int numBins;
     483 
     484  if ( uiQuotient >= uiMaxPreLen )
     485  {
     486    numBins = uiMaxPreLen;
     487    binValues = ( 1 << numBins ) - 1;
    318488  }
    319489  else
    320490  {
    321     m_pcBinIf->encodeBinEP( 0 );
    322   }
    323 
    324   for( UInt ui = 0; ui < ruiGoRiceParam; ui++ )
    325   {
    326     m_pcBinIf->encodeBinEP( ( uiRemainder & uiCodeWord ) ? 1 : 0 );
    327     uiRemainder = uiRemainder << 1;
    328   }
    329 
     491    numBins = uiQuotient + 1;
     492    binValues = ( 1 << numBins ) - 2;
     493  }
     494 
     495  m_pcBinIf->encodeBinsEP( ( binValues << ruiGoRiceParam ) + uiCodeWord - ( uiQuotient << ruiGoRiceParam ), numBins + ruiGoRiceParam );
     496 
     497#if EIGHT_BITS_RICE_CODE
     498  ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( uiSymbol, 23 ) ];
     499#else
    330500  ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( uiSymbol, 15 ) ];
    331 
     501#endif
     502 
    332503  if( bExGolomb )
    333504  {
     
    335506    xWriteEpExGolomb( uiSymbol, 0 );
    336507  }
    337 
    338   return;
    339 }
    340 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    341 Void TEncSbac::xWriteExGolombLevel( UInt uiSymbol, ContextModel& rcSCModel  )
    342 {
    343   if( uiSymbol )
    344   {
    345     m_pcBinIf->encodeBin( 1, rcSCModel );
    346     UInt uiCount = 0;
    347     Bool bNoExGo = (uiSymbol < 13);
    348 
    349     while( --uiSymbol && ++uiCount < 13 )
    350     {
    351       m_pcBinIf->encodeBin( 1, rcSCModel );
    352     }
    353     if( bNoExGo )
    354     {
    355       m_pcBinIf->encodeBin( 0, rcSCModel );
    356     }
    357     else
    358     {
    359       xWriteEpExGolomb( uiSymbol, 0 );
    360     }
    361   }
    362   else
    363   {
    364     m_pcBinIf->encodeBin( 0, rcSCModel );
    365   }
    366 
    367   return;
    368 }
    369 #endif
    370 #else
    371 Void TEncSbac::xWriteExGolombLevel( UInt uiSymbol, ContextModel& rcSCModel  )
    372 {
    373   if( uiSymbol )
    374   {
    375     m_pcBinIf->encodeBin( 1, rcSCModel );
    376     UInt uiCount = 0;
    377     Bool bNoExGo = (uiSymbol < 13);
    378    
    379     while( --uiSymbol && ++uiCount < 13 )
    380     {
    381       m_pcBinIf->encodeBin( 1, rcSCModel );
    382     }
    383     if( bNoExGo )
    384     {
    385       m_pcBinIf->encodeBin( 0, rcSCModel );
    386     }
    387     else
    388     {
    389       xWriteEpExGolomb( uiSymbol, 0 );
    390     }
    391   }
    392   else
    393   {
    394     m_pcBinIf->encodeBin( 0, rcSCModel );
    395   }
    396  
    397   return;
    398 }
    399 #endif
     508}
    400509
    401510// SBAC RD
    402 Void  TEncSbac::load ( TEncSbac* pScr)
    403 {
    404   this->xCopyFrom(pScr);
    405 }
     511Void  TEncSbac::load ( TEncSbac* pSrc)
     512{
     513  this->xCopyFrom(pSrc);
     514}
     515
     516Void  TEncSbac::loadIntraDirModeLuma( TEncSbac* pSrc)
     517{
     518  m_pcBinIf->copyState( pSrc->m_pcBinIf );
     519 
     520  this->m_cCUIntraPredSCModel      .copyFrom( &pSrc->m_cCUIntraPredSCModel       );
     521}
     522
    406523
    407524Void  TEncSbac::store( TEncSbac* pDest)
     
    418535  this->m_uiLastQp    = pSrc->m_uiLastQp;
    419536 
    420   this->m_cCUSplitFlagSCModel      .copyFrom( &pSrc->m_cCUSplitFlagSCModel       );
    421   this->m_cCUSkipFlagSCModel       .copyFrom( &pSrc->m_cCUSkipFlagSCModel        );
    422   this->m_cCUMergeFlagExtSCModel  .copyFrom( &pSrc->m_cCUMergeFlagExtSCModel);
    423   this->m_cCUMergeIdxExtSCModel   .copyFrom( &pSrc->m_cCUMergeIdxExtSCModel);
    424   this->m_cCUMVMergeIdxExtSCModel .copyFrom( &pSrc->m_cCUMVMergeIdxExtSCModel );
    425   this->m_cResPredFlagSCModel     .copyFrom( &pSrc->m_cResPredFlagSCModel        );
    426   this->m_cCUPartSizeSCModel       .copyFrom( &pSrc->m_cCUPartSizeSCModel        );
    427   this->m_cCUPredModeSCModel       .copyFrom( &pSrc->m_cCUPredModeSCModel        );
    428   this->m_cCUIntraPredSCModel      .copyFrom( &pSrc->m_cCUIntraPredSCModel       );
    429 #if ADD_PLANAR_MODE
    430   this->m_cPlanarFlagSCModel       .copyFrom( &pSrc->m_cPlanarFlagSCModel        );
    431 #endif
    432   this->m_cCUChromaPredSCModel     .copyFrom( &pSrc->m_cCUChromaPredSCModel      );
    433   this->m_cCUDeltaQpSCModel        .copyFrom( &pSrc->m_cCUDeltaQpSCModel         );
    434   this->m_cCUInterDirSCModel       .copyFrom( &pSrc->m_cCUInterDirSCModel        );
    435   this->m_cCURefPicSCModel         .copyFrom( &pSrc->m_cCURefPicSCModel          );
    436   this->m_cCUMvdSCModel            .copyFrom( &pSrc->m_cCUMvdSCModel             );
    437   this->m_cCUQtCbfSCModel          .copyFrom( &pSrc->m_cCUQtCbfSCModel           );
    438   this->m_cCUTransSubdivFlagSCModel.copyFrom( &pSrc->m_cCUTransSubdivFlagSCModel );
    439   this->m_cCUQtRootCbfSCModel      .copyFrom( &pSrc->m_cCUQtRootCbfSCModel       );
    440   this->m_cCUSigSCModel            .copyFrom( &pSrc->m_cCUSigSCModel             );
    441 #if PCP_SIGMAP_SIMPLE_LAST
    442   this->m_cCuCtxLastX              .copyFrom( &pSrc->m_cCuCtxLastX               );
    443   this->m_cCuCtxLastY              .copyFrom( &pSrc->m_cCuCtxLastY               );
    444 #else
    445   this->m_cCULastSCModel           .copyFrom( &pSrc->m_cCULastSCModel            );
    446 #endif
    447   this->m_cCUOneSCModel            .copyFrom( &pSrc->m_cCUOneSCModel             );
    448   this->m_cCUAbsSCModel            .copyFrom( &pSrc->m_cCUAbsSCModel             );
    449   this->m_cMVPIdxSCModel           .copyFrom( &pSrc->m_cMVPIdxSCModel            );
    450   this->m_cViewIdxSCModel          .copyFrom( &pSrc->m_cViewIdxSCModel           );
    451 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    452   this->m_cIntraDMMSCModel         .copyFrom( &pSrc->m_cIntraDMMSCModel          );
    453   this->m_cIntraWedgeSCModel       .copyFrom( &pSrc->m_cIntraWedgeSCModel        );
    454 #endif
    455 }
    456 
     537  memcpy( m_contextModels, pSrc->m_contextModels, m_numContextModels * sizeof( ContextModel ) );
     538}
     539
     540#if HHI_INTER_VIEW_MOTION_PRED
     541Void TEncSbac::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum )
     542#else
    457543Void TEncSbac::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
     544#endif
    458545{
    459546  Int iSymbol = pcCU->getMVPIdx(eRefList, uiAbsPartIdx);
    460   Int iNum    = pcCU->getMVPNum(eRefList, uiAbsPartIdx);
     547#if HHI_INTER_VIEW_MOTION_PRED
     548#else
     549  Int iNum = AMVP_MAX_NUM_CANDS;
     550#endif
    461551
    462552  xWriteUnaryMaxSymbol(iSymbol, m_cMVPIdxSCModel.get(0), 1, iNum-1);
     
    466556{
    467557  PartSize eSize         = pcCU->getPartitionSize( uiAbsPartIdx );
    468  
    469   if ( pcCU->getSlice()->isInterB() && pcCU->isIntra( uiAbsPartIdx ) )
    470   {
    471     m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    472 #if HHI_RMP_SWITCH
    473     if( pcCU->getSlice()->getSPS()->getUseRMP() )
    474 #endif
    475     {
    476       m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
    477       m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
    478     }
    479 #if HHI_DISABLE_INTER_NxN_SPLIT
     558  if ( pcCU->isIntra( uiAbsPartIdx ) )
     559  {
    480560    if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    481 #endif
    482     {
    483       m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 3) );
    484     }
    485 #if MTK_DISABLE_INTRA_NxN_SPLIT
    486     if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    487 #endif
    488     {
    489       m_pcBinIf->encodeBin( (eSize == SIZE_2Nx2N? 0 : 1), m_cCUPartSizeSCModel.get( 0, 0, 4) );
    490     }
    491     return;
    492   }
    493  
    494   if ( pcCU->isIntra( uiAbsPartIdx ) )
    495   {
    496 #if MTK_DISABLE_INTRA_NxN_SPLIT
    497     if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    498 #endif
    499561    {
    500562      m_pcBinIf->encodeBin( eSize == SIZE_2Nx2N? 1 : 0, m_cCUPartSizeSCModel.get( 0, 0, 0 ) );
     
    511573    }
    512574    case SIZE_2NxN:
     575    case SIZE_2NxnU:
     576    case SIZE_2NxnD:
    513577    {
    514578      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    515579      m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
    516      
     580      if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
     581      {
     582        if (eSize == SIZE_2NxN)
     583        {
     584#if AMP_CTX           
     585          m_pcBinIf->encodeBin(1, m_cCUAMPSCModel.get( 0, 0, 0 ));
     586#else
     587          m_pcBinIf->encodeBin(1, m_cCUYPosiSCModel.get( 0, 0, 0 ));
     588#endif
     589        }
     590        else
     591        {
     592#if AMP_CTX
     593          m_pcBinIf->encodeBin(0, m_cCUAMPSCModel.get( 0, 0, 0 ));         
     594          m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
     595#else
     596          m_pcBinIf->encodeBin(0, m_cCUYPosiSCModel.get( 0, 0, 0 ));
     597          m_pcBinIf->encodeBin((eSize == SIZE_2NxnU? 0: 1), m_cCUYPosiSCModel.get( 0, 0, 1 ));
     598#endif
     599        }
     600      }
    517601      break;
    518602    }
    519603    case SIZE_Nx2N:
     604    case SIZE_nLx2N:
     605    case SIZE_nRx2N:
    520606    {
    521607      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    522608      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
    523       m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
    524      
     609      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getSlice()->getSPS()->getDisInter4x4() && pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
     610      {
     611        m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
     612      }
     613      if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
     614      {
     615        if (eSize == SIZE_Nx2N)
     616        {
     617#if AMP_CTX
     618          m_pcBinIf->encodeBin(1, m_cCUAMPSCModel.get( 0, 0, 0 ));
     619#else
     620          m_pcBinIf->encodeBin(1, m_cCUXPosiSCModel.get( 0, 0, 0 ));
     621#endif
     622        }
     623        else
     624        {
     625#if AMP_CTX
     626          m_pcBinIf->encodeBin(0, m_cCUAMPSCModel.get( 0, 0, 0 ));
     627          m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
     628#else
     629          m_pcBinIf->encodeBin(0, m_cCUXPosiSCModel.get( 0, 0, 0 ));
     630          m_pcBinIf->encodeBin((eSize == SIZE_nLx2N? 0: 1), m_cCUXPosiSCModel.get( 0, 0, 1 ));
     631#endif
     632        }
     633      }
    525634      break;
    526635    }
    527636    case SIZE_NxN:
    528637    {
    529 #if HHI_DISABLE_INTER_NxN_SPLIT
    530       if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    531 #endif
     638      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getSlice()->getSPS()->getDisInter4x4() && pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
    532639      {
    533640        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    534 #if HHI_RMP_SWITCH
    535         if( pcCU->getSlice()->getSPS()->getUseRMP() )
    536 #endif
    537         {
    538           m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
    539           m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
    540         }
    541        
    542         if (pcCU->getSlice()->isInterB())
    543         {
    544           m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 3) );
    545         }
     641        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
     642        m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
    546643      }
    547644      break;
     
    563660  // get context function is here
    564661  Int iPredMode = pcCU->getPredictionMode( uiAbsPartIdx );
    565   if (pcCU->getSlice()->isInterB() )
    566   {
    567     return;
    568   }
    569 
    570   m_pcBinIf->encodeBin( iPredMode == MODE_INTER ? 0 : 1, m_cCUPredModeSCModel.get( 0, 0, 1 ) );
     662  m_pcBinIf->encodeBin( iPredMode == MODE_INTER ? 0 : 1, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
    571663}
    572664
     
    581673  }
    582674 
    583   // get context function is here
    584   UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0;
    585  
    586   m_pcBinIf->encodeBin( uiSymbol, m_cCUAlfCtrlFlagSCModel.get( 0, 0, pcCU->getCtxAlfCtrlFlag( uiAbsPartIdx) ) );
     675  const UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0;
     676  m_pcBinIf->encodeBin( uiSymbol, *m_cCUAlfCtrlFlagSCModel.get( 0 ) );
    587677}
    588678
     
    607697  UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx ) ;
    608698  m_pcBinIf->encodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
    609   DTRACE_CABAC_V( g_nSymbolCounter++ );
     699  DTRACE_CABAC_VL( g_nSymbolCounter++ );
    610700  DTRACE_CABAC_T( "\tSkipFlag" );
    611701  DTRACE_CABAC_T( "\tuiCtxSkip: ");
     
    623713Void TEncSbac::codeMergeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
    624714{
    625   UInt uiCtx = 0;
    626 #if CHANGE_MERGE_CONTEXT
    627   uiCtx = pcCU->getCtxMergeFlag( uiAbsPartIdx );
    628 #else
    629   for(UInt uiIter = 0; uiIter < MRG_MAX_NUM_CANDS; uiIter++ )
    630   {
    631     if( pcCU->getNeighbourCandIdx( uiIter, uiAbsPartIdx ) == uiIter + 1 )
    632     {
    633       if( uiIter == 0 )
    634       {
    635         uiCtx++;
    636       }
    637       else if( uiIter == 1 )
    638       {
    639         uiCtx++;
    640       }
    641     }
    642   }
    643 #endif
    644   UInt uiSymbol = pcCU->getMergeFlag( uiAbsPartIdx ) ? 1 : 0;
    645   m_pcBinIf->encodeBin( uiSymbol, m_cCUMergeFlagExtSCModel.get( 0, 0, uiCtx ) );
    646 
    647   DTRACE_CABAC_V( g_nSymbolCounter++ );
     715  const UInt uiSymbol = pcCU->getMergeFlag( uiAbsPartIdx ) ? 1 : 0;
     716  m_pcBinIf->encodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) );
     717
     718  DTRACE_CABAC_VL( g_nSymbolCounter++ );
    648719  DTRACE_CABAC_T( "\tMergeFlag: " );
    649720  DTRACE_CABAC_V( uiSymbol );
     
    652723  DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
    653724  DTRACE_CABAC_V( uiAbsPartIdx );
    654   for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    655   {
    656     DTRACE_CABAC_T( "\tNumMrgCand: " );
    657     DTRACE_CABAC_V( ui );
    658     DTRACE_CABAC_T( "\t==\t" );
    659     DTRACE_CABAC_V( UInt( pcCU->getNeighbourCandIdx( ui, uiAbsPartIdx ) ) );
    660   }
    661725  DTRACE_CABAC_T( "\n" );
    662726}
    663 
    664 
    665 
    666 #if HHI_INTER_VIEW_MOTION_PRED || HHI_MPI
    667 Void TEncSbac::codeMergeIndexMV( TComDataCU* pcCU, UInt uiAbsPartIdx )
    668 {
    669   //--- set number of candidates and availability ---
    670   Bool  abAvailable[ MRG_MAX_NUM_CANDS ];
    671   UInt  uiNumCand = 0;
    672 #if HHI_MPI
    673   const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
    674   const UInt uiMviMergePos = bMVIAvailable ? HHI_MPI_MERGE_POS : MRG_MAX_NUM_CANDS;
    675 #endif
    676   for( UInt uiIdx = 0; uiIdx < MRG_MAX_NUM_CANDS; uiIdx++ )
    677   {
    678 #if HHI_MPI
    679     if( uiIdx == uiMviMergePos )
    680     {
    681       abAvailable[ uiIdx ] = true;
    682       uiNumCand++;
    683     }
    684     else if( uiIdx > uiMviMergePos )
    685     {
    686       if( ( abAvailable[ uiIdx ] = ( pcCU->getNeighbourCandIdx( uiIdx - 1, uiAbsPartIdx ) == uiIdx ) ) )
    687       {
    688         uiNumCand++;
    689       }
    690     }
    691     else
    692 #endif
    693     if( ( abAvailable[ uiIdx ] = ( pcCU->getNeighbourCandIdx( uiIdx, uiAbsPartIdx ) == uiIdx + 1 ) ) )
    694     {
    695       uiNumCand++;
    696     }
    697   }
    698   AOF( uiNumCand > 1 );
    699 
    700   //--- determine contexts ---
    701   AOF( NUM_MV_MERGE_IDX_EXT_CTX >= MRG_MAX_NUM_CANDS - 1 );
    702   UInt  auiCtx[ MRG_MAX_NUM_CANDS - 1 ];
    703   for( UInt uiIdx = 0; uiIdx < MRG_MAX_NUM_CANDS - 1; uiIdx++ )
    704   {
    705     auiCtx[ uiIdx ] = MRG_MAX_NUM_CANDS;
    706     if( uiNumCand > uiIdx + 1 )
    707     {
    708       Bool bAvComb    = false;
    709       for( UInt uiCId = uiIdx; uiCId < MRG_MAX_NUM_CANDS - 1; uiCId++ )
    710       {
    711         bAvComb = ( bAvComb || abAvailable[ uiCId ] );
    712         if( abAvailable[ uiCId + 1 ] && bAvComb )
    713         {
    714           auiCtx[ uiIdx ] = uiCId;
    715           break;
    716         }
    717       }
    718       AOT( auiCtx[ uiIdx ] == MRG_MAX_NUM_CANDS );
    719     }
    720   }
    721 
    722   //--- determine unary index ---
    723   UInt  uiMergeIdx  = pcCU->getMergeIndex( uiAbsPartIdx );
    724 #if HHI_MPI
    725   if( bMVIAvailable )
    726   {
    727     const Bool bUseMVI = pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1;
    728     if( bUseMVI )
    729     {
    730       uiMergeIdx = HHI_MPI_MERGE_POS;
    731     }
    732     else if( uiMergeIdx >= HHI_MPI_MERGE_POS )
    733     {
    734       uiMergeIdx++;
    735     }
    736   }
    737 #endif
    738   UInt  uiUnaryIdx  = uiMergeIdx;
    739   for( UInt uiIdx = 0; uiIdx < uiMergeIdx; uiIdx++ )
    740   {
    741     if( ! abAvailable[ uiIdx ] )
    742     {
    743       uiUnaryIdx--;
    744     }
    745   }
    746 
    747   //--- code unary index ---
    748   for( UInt ui = 0; ui < uiNumCand - 1; ui++ )
    749   {
    750     const UInt uiSymbol = ( ui == uiUnaryIdx ? 0 : 1 );
    751     m_pcBinIf->encodeBin( uiSymbol, m_cCUMVMergeIdxExtSCModel.get( 0, 0, auiCtx[ui] ) );
    752     if( uiSymbol == 0 )
    753     {
    754       break;
    755     }
    756   }
    757 
    758   //--- trace ---
    759   DTRACE_CABAC_V( g_nSymbolCounter++ );
    760   DTRACE_CABAC_T( "\tparseMergeIndex():" );
    761   DTRACE_CABAC_T( "   MRGIdx = " );
    762   DTRACE_CABAC_V( uiMergeIdx );
    763   DTRACE_CABAC_T( "   UnaryIdx = " );
    764   DTRACE_CABAC_V( uiUnaryIdx );
    765   DTRACE_CABAC_T( "   NumCand = " );
    766   DTRACE_CABAC_V( uiNumCand );
    767   DTRACE_CABAC_T( "   Availibility = " );
    768   for( UInt uiIdx = 0; uiIdx < MRG_MAX_NUM_CANDS; uiIdx++ )
    769   {
    770     DTRACE_CABAC_V( abAvailable[ uiIdx ] ? 1 : 0 );
    771   }
    772   DTRACE_CABAC_T( "   Contexts = " );
    773   for( UInt uiIdx = 0; uiIdx < MRG_MAX_NUM_CANDS - 1; uiIdx++ )
    774   {
    775     DTRACE_CABAC_V( auiCtx[ uiIdx ] );
    776   }
    777   DTRACE_CABAC_T( "\n" );
    778 }
    779 #endif
    780 
    781727
    782728/** code merge index
     
    787733Void TEncSbac::codeMergeIndex( TComDataCU* pcCU, UInt uiAbsPartIdx )
    788734{
    789 #if HHI_INTER_VIEW_MOTION_PRED || HHI_MPI
    790 #if HHI_INTER_VIEW_MOTION_PRED && HHI_MPI
    791   if( ( pcCU->getSlice()->getSPS()->getViewId() > 0 && ( pcCU->getSlice()->getSPS()->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE ) ||
    792       ( pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) )
    793 #elif HHI_MPI
    794   if( pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
    795 #else
    796   if( pcCU->getSlice()->getSPS()->getViewId() > 0 && ( pcCU->getSlice()->getSPS()->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE )
    797 #endif
    798   {
    799     codeMergeIndexMV( pcCU, uiAbsPartIdx );
    800     return;
    801   }
    802 #endif
    803 
    804   Bool bLeftInvolved = false;
    805   Bool bAboveInvolved = false;
    806   Bool bCollocatedInvolved = false;
    807   Bool bCornerInvolved = false;
    808   Bool bCornerBLInvolved = false;
    809   UInt uiNumCand = 0;
    810   for( UInt uiIter = 0; uiIter < MRG_MAX_NUM_CANDS; ++uiIter )
    811   {
    812     if( pcCU->getNeighbourCandIdx( uiIter, uiAbsPartIdx ) == uiIter + 1 )
    813     {
    814       uiNumCand++;
    815       if( uiIter == 0 )
    816       {
    817         bLeftInvolved = true;
    818       }
    819       else if( uiIter == 1 )
    820       {
    821         bAboveInvolved = true;
    822       }
    823       else if( uiIter == 2 )
    824       {
    825         bCollocatedInvolved = true;
    826       }
    827       else if( uiIter == 3 )
    828       {
    829         bCornerInvolved = true;
    830       }
    831       else if( uiIter == 4 )
    832       {
    833         bCornerBLInvolved = true;
    834       }
    835     }
    836   }
    837   assert( uiNumCand > 1 );
    838 
    839   UInt auiCtx[4] = { 0, 0, 0, 3 };
    840   if( bLeftInvolved && bAboveInvolved )
    841   {
    842     auiCtx[0] = 0;
    843   }
    844   else if( bLeftInvolved || bAboveInvolved )
    845   {
    846     auiCtx[0] = bCollocatedInvolved ? 1 : 2;
    847   }
    848   else
    849   {
    850     auiCtx[0] = bCollocatedInvolved ? 2 : 3;
    851   }
    852 
    853   if( uiNumCand >= 3 )
    854   {
    855     if( bAboveInvolved )
    856     {
    857       auiCtx[1] = bCollocatedInvolved ? 1 : 2;
    858     }
    859     else
    860     {
    861       auiCtx[1] = bCollocatedInvolved ? 2 : 3;
    862     }
    863   }
    864 
    865   if( uiNumCand >= 4 )
    866   {
    867     auiCtx[2] =  bCollocatedInvolved ? 2 : 3;
    868   }
    869 
     735  UInt uiNumCand = MRG_MAX_NUM_CANDS;
     736#if !MRG_IDX_CTX_RED
     737  UInt auiCtx[4] = { 0, 1, 2, 3 };
     738#endif
    870739  UInt uiUnaryIdx = pcCU->getMergeIndex( uiAbsPartIdx );
    871 
    872   if( !bCornerInvolved && uiUnaryIdx > 3 )
    873   {
    874     --uiUnaryIdx;
    875   }
    876   if( !bCollocatedInvolved && uiUnaryIdx > 2 )
    877   {
    878     --uiUnaryIdx;
    879   }
    880   if( !bAboveInvolved && uiUnaryIdx > 1 )
    881   {
    882     --uiUnaryIdx;
    883   }
    884   if( !bLeftInvolved && uiUnaryIdx > 0 )
    885   {
    886     --uiUnaryIdx;
    887   }
    888 
    889   for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
    890   {
    891     const UInt uiSymbol = ui == uiUnaryIdx ? 0 : 1;
    892     m_pcBinIf->encodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, auiCtx[ui] ) );
    893     if( uiSymbol == 0 )
    894     {
    895       break;
    896     }
    897   }
    898 
    899   DTRACE_CABAC_V( g_nSymbolCounter++ );
     740  uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
     741#if HHI_MPI
     742  const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
     743  if( bMVIAvailable )
     744  {
     745    const Bool bUseMVI = pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1;
     746    if( bUseMVI )
     747    {
     748      uiUnaryIdx = HHI_MPI_MERGE_POS;
     749    }
     750    else if( uiUnaryIdx >= HHI_MPI_MERGE_POS )
     751    {
     752      uiUnaryIdx++;
     753    }
     754  }
     755#endif
     756  if ( uiNumCand > 1 )
     757  {
     758    for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
     759    {
     760      const UInt uiSymbol = ui == uiUnaryIdx ? 0 : 1;
     761#if MRG_IDX_CTX_RED
     762      if ( ui==0 )
     763      {
     764        m_pcBinIf->encodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) );
     765      }
     766      else
     767      {
     768        m_pcBinIf->encodeBinEP( uiSymbol );
     769      }
     770#else
     771      m_pcBinIf->encodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, auiCtx[ui] ) );
     772#endif
     773      if( uiSymbol == 0 )
     774      {
     775        break;
     776      }
     777    }
     778  }
     779  DTRACE_CABAC_VL( g_nSymbolCounter++ );
    900780  DTRACE_CABAC_T( "\tparseMergeIndex()" );
    901781  DTRACE_CABAC_T( "\tuiMRGIdx= " );
    902782  DTRACE_CABAC_V( pcCU->getMergeIndex( uiAbsPartIdx ) );
    903   DTRACE_CABAC_T( "\tuiNumCand= " );
    904   DTRACE_CABAC_V( uiNumCand );
    905   DTRACE_CABAC_T( "\tbLeftInvolved= " );
    906   DTRACE_CABAC_V( bLeftInvolved );
    907   DTRACE_CABAC_T( "\tbAboveInvolved= " );
    908   DTRACE_CABAC_V( bAboveInvolved );
    909   DTRACE_CABAC_T( "\tbCollocatedInvolved= " );
    910   DTRACE_CABAC_V( bCollocatedInvolved );
    911   DTRACE_CABAC_T( "\tbCornerRTInvolved= " );
    912   DTRACE_CABAC_V( bCornerInvolved );
    913   DTRACE_CABAC_T( "\tbCornerBLInvolved= " );
    914   DTRACE_CABAC_V( bCornerBLInvolved );
    915783  DTRACE_CABAC_T( "\n" );
    916784}
    917785
    918 
    919786#if HHI_INTER_VIEW_RESIDUAL_PRED
    920 Void 
     787Void
    921788TEncSbac::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
    922789{
    923   UInt  uiCtx     = 0;
     790  UInt  uiCtx     = pcCU->getCtxResPredFlag( uiAbsPartIdx );
    924791  UInt  uiSymbol  = ( pcCU->getResPredFlag( uiAbsPartIdx ) ? 1 : 0 );
    925792  m_pcBinIf->encodeBin( uiSymbol, m_cResPredFlagSCModel.get( 0, 0, uiCtx ) );
     
    927794#endif
    928795
    929 
    930796Void TEncSbac::codeSplitFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    931797{
     
    938804  assert( uiCtx < 3 );
    939805  m_pcBinIf->encodeBin( uiCurrSplitFlag, m_cCUSplitFlagSCModel.get( 0, 0, uiCtx ) );
    940   DTRACE_CABAC_V( g_nSymbolCounter++ )
     806  DTRACE_CABAC_VL( g_nSymbolCounter++ )
    941807  DTRACE_CABAC_T( "\tSplitFlag\n" )
    942808  return;
     
    946812{
    947813  m_pcBinIf->encodeBin( uiSymbol, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiCtx ) );
    948   DTRACE_CABAC_V( g_nSymbolCounter++ )
     814  DTRACE_CABAC_VL( g_nSymbolCounter++ )
    949815  DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
    950816  DTRACE_CABAC_T( "\tsymbol=" )
     
    954820  DTRACE_CABAC_T( "\n" )
    955821}
    956 
    957 #if HHI_DMM_WEDGE_INTRA
    958 Void TEncSbac::xCodeWedgeFullInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
    959 {
    960   Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
    961   Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
    962 
    963   UInt uiTabIdx = pcCU->getWedgeFullTabIdx( uiAbsPartIdx );
    964 
    965   for ( Int i = 0; i < iBits; i++ )
    966   {
    967     m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cIntraWedgeSCModel.get(0, 0, 0) );
    968   }
    969 }
    970 
    971 Void TEncSbac::xCodeWedgeFullDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
    972    {
    973   Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
    974   Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
    975 
    976   UInt uiTabIdx = pcCU->getWedgeFullTabIdx( uiAbsPartIdx );
    977 
    978   for ( Int i = 0; i < iBits; i++ )
    979   {
    980     m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cIntraWedgeSCModel.get(0, 0, 0) );
    981   }
    982 
    983   Int iDeltaDC1 = pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx );
    984   Int iDeltaDC2 = pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx );
    985 
    986    xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cIntraWedgeSCModel.get(0, 0, 1) );
    987    if ( iDeltaDC1 != 0 )
    988    {
    989      UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
    990      m_pcBinIf->encodeBinEP( uiSign );
    991    }
    992    xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cIntraWedgeSCModel.get(0, 0, 1) );
    993    if ( iDeltaDC2 != 0 )
    994    {
    995      UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
    996      m_pcBinIf->encodeBinEP( uiSign );
    997    }
    998 }
    999 
    1000 Void TEncSbac::xCodeWedgePredDirInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1001 {
    1002   if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
    1003   {
    1004     Int iDeltaEnd = pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx );
    1005     m_pcBinIf->encodeBin( (iDeltaEnd!=0), m_cIntraWedgeSCModel.get(0, 0, 3) );
    1006 
    1007     if( iDeltaEnd != 0 )
    1008     {
    1009       UInt uiAbsValMinus1 = abs(iDeltaEnd)-1;
    1010       m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01),      m_cIntraWedgeSCModel.get(0, 0, 3) );
    1011       m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cIntraWedgeSCModel.get(0, 0, 3) );
    1012 
    1013       UInt uiSign = iDeltaEnd > 0 ? 0 : 1;
    1014       m_pcBinIf->encodeBinEP( uiSign );
    1015     }
    1016   }
    1017 }
    1018 
    1019 Void TEncSbac::xCodeWedgePredDirDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1020 {
    1021   if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
    1022   {
    1023     Int iDeltaEnd = pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx );
    1024     m_pcBinIf->encodeBin( (iDeltaEnd!=0), m_cIntraWedgeSCModel.get(0, 0, 3) );
    1025 
    1026     if( iDeltaEnd != 0 )
    1027   {
    1028       UInt uiAbsValMinus1 = abs(iDeltaEnd)-1;
    1029       m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01),      m_cIntraWedgeSCModel.get(0, 0, 3) );
    1030       m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cIntraWedgeSCModel.get(0, 0, 3) );
    1031 
    1032       UInt uiSign = iDeltaEnd > 0 ? 0 : 1;
    1033       m_pcBinIf->encodeBinEP( uiSign );
    1034     }
    1035   }
    1036  
    1037   Int iDeltaDC1 = pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx );
    1038   Int iDeltaDC2 = pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx );
    1039 
    1040   xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cIntraWedgeSCModel.get(0, 0, 1) );
    1041   if ( iDeltaDC1 != 0 )
    1042   {
    1043     UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
    1044     m_pcBinIf->encodeBinEP( uiSign );
    1045   }
    1046   xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cIntraWedgeSCModel.get(0, 0, 1) );
    1047   if ( iDeltaDC2 != 0 )
    1048   {
    1049     UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
    1050     m_pcBinIf->encodeBinEP( uiSign );
    1051   }
    1052 }
    1053 #endif
    1054 #if HHI_DMM_PRED_TEX
    1055 Void TEncSbac::xCodeWedgePredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1056 {
    1057   Int iDeltaDC1 = pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx );
    1058   Int iDeltaDC2 = pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx );
    1059 
    1060   xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cIntraWedgeSCModel.get(0, 0, 1) );
    1061   if ( iDeltaDC1 != 0 )
    1062   {
    1063     UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
    1064     m_pcBinIf->encodeBinEP( uiSign );
    1065   }
    1066   xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cIntraWedgeSCModel.get(0, 0, 1) );
    1067   if ( iDeltaDC2 != 0 )
    1068   {
    1069     UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
    1070     m_pcBinIf->encodeBinEP( uiSign );
    1071   }
    1072 }
    1073 
    1074 Void TEncSbac::xCodeContourPredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1075 {
    1076   Int iDeltaDC1 = pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx );
    1077   Int iDeltaDC2 = pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx );
    1078 
    1079   xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cIntraWedgeSCModel.get(0, 0, 1) );
    1080   if ( iDeltaDC1 != 0 )
    1081   {
    1082     UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
    1083     m_pcBinIf->encodeBinEP( uiSign );
    1084   }
    1085   xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cIntraWedgeSCModel.get(0, 0, 1) );
    1086   if ( iDeltaDC2 != 0 )
    1087   {
    1088     UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
    1089     m_pcBinIf->encodeBinEP( uiSign );
    1090   }
    1091 }
    1092 #endif
    1093 
    1094 #if MTK_DCM_MPM
    1095822Void TEncSbac::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1096823{
    1097   UInt uiDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
     824  UInt uiDir         = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1098825
    1099826#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    1100   if ( pcCU->getSlice()->getSPS()->isDepth() && pcCU->getSlice()->getSPS()->getUseDMM() && pcCU->getWidth( uiAbsPartIdx ) < 64 )
    1101   {
    1102     m_pcBinIf->encodeBin( uiDir > MAX_MODE_ID_INTRA_DIR, m_cIntraDMMSCModel.get(0, 0, 0) );
    1103   }
    1104   if( uiDir > MAX_MODE_ID_INTRA_DIR )
    1105   {
    1106     assert( pcCU->getWidth( uiAbsPartIdx ) < 64 );
    1107     UInt uiDMMode = uiDir - (MAX_MODE_ID_INTRA_DIR+1);
     827  if( pcCU->getSlice()->getSPS()->getUseDMM() && pcCU->getWidth( uiAbsPartIdx ) <= DMM_WEDGEMODEL_MAX_SIZE )
     828  {
     829    m_pcBinIf->encodeBin( uiDir >= NUM_INTRA_MODE, m_cDmmFlagSCModel.get(0, 0, 0) );
     830  }
     831  if( uiDir >= NUM_INTRA_MODE )
     832  {
     833    assert( pcCU->getWidth( uiAbsPartIdx ) <= DMM_WEDGEMODEL_MAX_SIZE );
     834    UInt uiDMMode = uiDir - NUM_INTRA_MODE;
    1108835
    1109836#if HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
    1110     m_pcBinIf->encodeBin( (uiDMMode & 0x01),      m_cIntraDMMSCModel.get(0, 0, 1) );
    1111     m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cIntraDMMSCModel.get(0, 0, 1) );
    1112 
    1113       if ( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
    1114       {
    1115       m_pcBinIf->encodeBin( (uiDMMode & 0x04) >> 2, m_cIntraDMMSCModel.get(0, 0, 1) );
    1116         }
    1117 #else
    1118                                   m_pcBinIf->encodeBin( (uiDMMode & 0x01),      m_cIntraDMMSCModel.get(0, 0, 1) );
    1119 
    1120     if ( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
    1121     {
    1122       m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cIntraDMMSCModel.get(0, 0, 1) );
     837    m_pcBinIf->encodeBin( (uiDMMode & 0x01),      m_cDmmModeSCModel.get(0, 0, 0) );
     838    m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cDmmModeSCModel.get(0, 0, 0) );
     839
     840    if( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
     841    {
     842      m_pcBinIf->encodeBin( (uiDMMode & 0x04) >> 2, m_cDmmModeSCModel.get(0, 0, 0) );
     843    }
     844#else
     845    m_pcBinIf->encodeBin( (uiDMMode & 0x01),      m_cDmmModeSCModel.get(0, 0, 0) );
     846
     847    if( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
     848    {
     849      m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cDmmModeSCModel.get(0, 0, 0) );
    1123850    }
    1124851#endif
     
    1130857#endif
    1131858#if HHI_DMM_PRED_TEX
    1132 #if FLEX_CODING_ORDER
    1133     if ( !pcCU->getSlice()->getSPS()->getUseDMM34() )
    1134     {
    1135       assert( uiDir != DMM_WEDGE_PREDTEX_D_IDX );
    1136       assert( uiDir != DMM_CONTOUR_PREDTEX_D_IDX );
    1137     }
    1138 #endif
    1139859    if( uiDir == DMM_WEDGE_PREDTEX_D_IDX )     { xCodeWedgePredTexDeltaInfo  ( pcCU, uiAbsPartIdx ); }
    1140860    if( uiDir == DMM_CONTOUR_PREDTEX_D_IDX )   { xCodeContourPredTexDeltaInfo( pcCU, uiAbsPartIdx ); }
     
    1142862  }
    1143863  else
    1144 #endif
    1145   {
     864  {
     865#endif
     866#if !LOGI_INTRA_NAME_3MPM
    1146867  Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
    1147 #if ADD_PLANAR_MODE
    1148   UInt planarFlag    = 0;
    1149   if (uiDir == PLANAR_IDX)
    1150   {
    1151     uiDir = 2;
    1152     planarFlag = 1;
    1153   }
    1154 #endif
    1155  
     868#endif
     869 
     870#if LOGI_INTRA_NAME_3MPM
     871  Int uiPreds[3] = {-1, -1, -1};
     872#else
    1156873  Int uiPreds[2] = {-1, -1};
     874#endif
    1157875  Int uiPredNum = pcCU->getIntraDirLumaPredictor(uiAbsPartIdx, uiPreds); 
    1158876
     
    1170888  {
    1171889    m_pcBinIf->encodeBin( 1, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
    1172     if(uiPredNum == 2)
    1173     {
    1174       m_pcBinIf->encodeBin( uiPredIdx, m_cCUIntraPredSCModel.get( 0, 0, 2 ) );
    1175     }
    1176 
     890#if LOGI_INTRA_NAME_3MPM
     891    m_pcBinIf->encodeBinEP( uiPredIdx ? 1 : 0 );
     892    if (uiPredIdx)
     893    {
     894      m_pcBinIf->encodeBinEP( uiPredIdx-1 );
     895    }
     896#else
     897    m_pcBinIf->encodeBinEP( uiPredIdx );
     898#endif
    1177899  }
    1178900  else
     
    1180902    m_pcBinIf->encodeBin( 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
    1181903 
     904#if LOGI_INTRA_NAME_3MPM
     905    if (uiPreds[0] > uiPreds[1])
     906    {
     907      std::swap(uiPreds[0], uiPreds[1]);
     908    }
     909    if (uiPreds[0] > uiPreds[2])
     910    {
     911      std::swap(uiPreds[0], uiPreds[2]);
     912    }
     913    if (uiPreds[1] > uiPreds[2])
     914    {
     915      std::swap(uiPreds[1], uiPreds[2]);
     916    }
     917#endif
     918
    1182919    for(Int i = (uiPredNum - 1); i >= 0; i--)
    1183920    {
     
    1185922    }
    1186923
    1187     if ( g_aucIntraModeBitsAng[iIntraIdx] < 6 )
    1188     {
    1189       m_pcBinIf->encodeBin((uiDir & 0x01), m_cCUIntraPredSCModel.get(0, 0, 1));
    1190       if ( g_aucIntraModeBitsAng[iIntraIdx] > 2 ) { m_pcBinIf->encodeBin((uiDir & 0x02) >> 1, m_cCUIntraPredSCModel.get(0, 0, 1));}
    1191       if ( g_aucIntraModeBitsAng[iIntraIdx] > 3 ) { m_pcBinIf->encodeBin((uiDir & 0x04) >> 2, m_cCUIntraPredSCModel.get(0, 0, 1));}
    1192       if ( g_aucIntraModeBitsAng[iIntraIdx] > 4 ) { m_pcBinIf->encodeBin((uiDir & 0x08) >> 3, m_cCUIntraPredSCModel.get(0, 0, 1));}
     924#if LOGI_INTRA_NAME_3MPM
     925    m_pcBinIf->encodeBinsEP( uiDir, 5 );
     926#else
     927    if ( uiDir < 31 )
     928    {
     929      m_pcBinIf->encodeBinsEP( uiDir, g_aucIntraModeBitsAng[ iIntraIdx ] - 1 );
    1193930    }
    1194931    else
    1195932    {
    1196       if (uiDir < 31){ // uiDir is here 0...32, 5 bits for uiDir 0...30, 31 is an escape code for coding one more bit for 31 and 32
    1197         m_pcBinIf->encodeBin((uiDir & 0x01),      m_cCUIntraPredSCModel.get(0, 0, 1));
    1198         m_pcBinIf->encodeBin((uiDir & 0x02) >> 1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1199         m_pcBinIf->encodeBin((uiDir & 0x04) >> 2, m_cCUIntraPredSCModel.get(0, 0, 1));
    1200         m_pcBinIf->encodeBin((uiDir & 0x08) >> 3, m_cCUIntraPredSCModel.get(0, 0, 1));
    1201         m_pcBinIf->encodeBin((uiDir & 0x10) >> 4, m_cCUIntraPredSCModel.get(0, 0, 1));
    1202       }
    1203       else{
    1204         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1205         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1206         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1207         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1208         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1209         m_pcBinIf->encodeBin((uiDir == 32) ? 1 : 0, m_cCUIntraPredSCModel.get(0, 0, 1));
    1210        }
    1211      }
     933      m_pcBinIf->encodeBinsEP( 31, 5 );
     934      m_pcBinIf->encodeBinEP( uiDir - 31 );
     935    }
     936#endif
    1212937   }
    1213 #if ADD_PLANAR_MODE
    1214   uiDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1215   if ( (uiDir == PLANAR_IDX) || (uiDir == 2) )
    1216   {
    1217     m_pcBinIf->encodeBin( planarFlag, m_cPlanarFlagSCModel.get(0,0,0) );
    1218   }
    1219 #endif
    1220   }
     938#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
     939  }
     940#endif
    1221941  return;
    1222942}
    1223 #else
    1224 Void TEncSbac::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1225 {
    1226   UInt uiDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1227 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    1228   if ( pcCU->getSlice()->getSPS()->isDepth() && pcCU->getSlice()->getSPS()->getUseDMM() && pcCU->getWidth( uiAbsPartIdx ) < 64 )
    1229   {
    1230     m_pcBinIf->encodeBin( uiDir > MAX_MODE_ID_INTRA_DIR, m_cIntraDMMSCModel.get(0, 0, 0) );
    1231   }
    1232   if( uiDir > MAX_MODE_ID_INTRA_DIR )
    1233   {
    1234     assert( pcCU->getWidth( uiAbsPartIdx ) < 64 );
    1235     UInt uiDMMode = uiDir - (MAX_MODE_ID_INTRA_DIR+1);
    1236 
    1237 #if HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
    1238     m_pcBinIf->encodeBin( (uiDMMode & 0x01),      m_cIntraDMMSCModel.get(0, 0, 1) );
    1239     m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cIntraDMMSCModel.get(0, 0, 1) );
    1240 
    1241       if ( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
    1242       {
    1243       m_pcBinIf->encodeBin( (uiDMMode & 0x04) >> 2, m_cIntraDMMSCModel.get(0, 0, 1) );
    1244         }
    1245 #else
    1246         m_pcBinIf->encodeBin( (uiDMMode & 0x01),      m_cIntraDMMSCModel.get(0, 0, 1) );
    1247 
    1248       if ( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
    1249       {
    1250       m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cIntraDMMSCModel.get(0, 0, 1) );
    1251       }
    1252 #endif
    1253 #if HHI_DMM_WEDGE_INTRA
    1254     if( uiDir == DMM_WEDGE_FULL_IDX )          { xCodeWedgeFullInfo          ( pcCU, uiAbsPartIdx ); }
    1255     if( uiDir == DMM_WEDGE_FULL_D_IDX )        { xCodeWedgeFullDeltaInfo     ( pcCU, uiAbsPartIdx ); }
    1256     if( uiDir == DMM_WEDGE_PREDDIR_IDX )       { xCodeWedgePredDirInfo       ( pcCU, uiAbsPartIdx ); }
    1257     if( uiDir == DMM_WEDGE_PREDDIR_D_IDX )     { xCodeWedgePredDirDeltaInfo  ( pcCU, uiAbsPartIdx ); }
    1258 #endif
    1259 #if HHI_DMM_PRED_TEX
    1260     if( uiDir == DMM_WEDGE_PREDTEX_D_IDX )     { xCodeWedgePredTexDeltaInfo  ( pcCU, uiAbsPartIdx ); }
    1261     if( uiDir == DMM_CONTOUR_PREDTEX_D_IDX )   { xCodeContourPredTexDeltaInfo( pcCU, uiAbsPartIdx ); }
    1262 #endif
     943
     944Void TEncSbac::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
     945{
     946  UInt uiIntraDirChroma = pcCU->getChromaIntraDir( uiAbsPartIdx );
     947
     948  if( uiIntraDirChroma == DM_CHROMA_IDX )
     949  {
     950    m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
     951  }
     952  else if( uiIntraDirChroma == LM_CHROMA_IDX )
     953  {
     954    m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
     955    m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 1 ) );
    1263956  }
    1264957  else
    1265 #endif
    1266   {
    1267   Int  iMostProbable = pcCU->getMostProbableIntraDirLuma( uiAbsPartIdx );
    1268 #if ADD_PLANAR_MODE
    1269   UInt planarFlag    = 0;
    1270   if (uiDir == PLANAR_IDX)
    1271   {
    1272     uiDir = 2;
    1273     planarFlag = 1;
    1274   }
    1275 #endif
    1276  
    1277   if (uiDir == iMostProbable)
    1278     m_pcBinIf->encodeBin( 1, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
     958  {
     959    UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
     960    pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
     961
     962    for( Int i = 0; i < NUM_CHROMA_MODE - 2; i++ )
     963    {
     964      if( uiIntraDirChroma == uiAllowedChromaDir[i] )
     965      {
     966        uiIntraDirChroma = i;
     967        break;
     968      }
     969    }
     970    m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
     971
     972    if (pcCU->getSlice()->getSPS()->getUseLMChroma())
     973    {
     974      m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 1 ));
     975    }
     976#if  CHROMA_MODE_CODING
     977    m_pcBinIf->encodeBinsEP( uiIntraDirChroma, 2 );
     978#else
     979    xWriteUnaryMaxSymbol( uiIntraDirChroma, m_cCUChromaPredSCModel.get( 0, 0 ) + 1, 0, 3 );
     980#endif
     981  }
     982  return;
     983}
     984
     985Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
     986{
     987  const UInt uiInterDir = pcCU->getInterDir( uiAbsPartIdx ) - 1;
     988  const UInt uiCtx      = pcCU->getCtxInterDir( uiAbsPartIdx );
     989  ContextModel *pCtx    = m_cCUInterDirSCModel.get( 0 );
     990  m_pcBinIf->encodeBin( uiInterDir == 2 ? 1 : 0, *( pCtx + uiCtx ) );
     991
     992  return;
     993}
     994
     995Void TEncSbac::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
     996{
     997  if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getInterDir( uiAbsPartIdx ) != 3)
     998  {
     999    Int iRefFrame = pcCU->getSlice()->getRefIdxOfLC(eRefList, pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx ));
     1000
     1001    ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
     1002    m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
     1003
     1004    if( iRefFrame > 0 )
     1005    {
     1006      xWriteUnaryMaxSymbol( iRefFrame - 1, pCtx + 1, 1, pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_C )-2 );
     1007    }
     1008  }
    12791009  else
    12801010  {
    1281     m_pcBinIf->encodeBin( 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
    1282     uiDir = uiDir > iMostProbable ? uiDir - 1 : uiDir;
    1283     Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
    1284     if ( g_aucIntraModeBitsAng[iIntraIdx] < 6 )
    1285     {
    1286       m_pcBinIf->encodeBin((uiDir & 0x01), m_cCUIntraPredSCModel.get(0, 0, 1));
    1287       if ( g_aucIntraModeBitsAng[iIntraIdx] > 2 ) m_pcBinIf->encodeBin((uiDir & 0x02) >> 1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1288       if ( g_aucIntraModeBitsAng[iIntraIdx] > 3 ) m_pcBinIf->encodeBin((uiDir & 0x04) >> 2, m_cCUIntraPredSCModel.get(0, 0, 1));
    1289       if ( g_aucIntraModeBitsAng[iIntraIdx] > 4 ) m_pcBinIf->encodeBin((uiDir & 0x08) >> 3, m_cCUIntraPredSCModel.get(0, 0, 1));
    1290     }
    1291     else
    1292     {
    1293       if (uiDir < 31)
    1294       { // uiDir is here 0...32, 5 bits for uiDir 0...30, 31 is an escape code for coding one more bit for 31 and 32
    1295         m_pcBinIf->encodeBin((uiDir & 0x01),      m_cCUIntraPredSCModel.get(0, 0, 1));
    1296         m_pcBinIf->encodeBin((uiDir & 0x02) >> 1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1297         m_pcBinIf->encodeBin((uiDir & 0x04) >> 2, m_cCUIntraPredSCModel.get(0, 0, 1));
    1298         m_pcBinIf->encodeBin((uiDir & 0x08) >> 3, m_cCUIntraPredSCModel.get(0, 0, 1));
    1299         m_pcBinIf->encodeBin((uiDir & 0x10) >> 4, m_cCUIntraPredSCModel.get(0, 0, 1));
    1300       }
    1301       else
    1302       {
    1303         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1304         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1305         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1306         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1307         m_pcBinIf->encodeBin(1, m_cCUIntraPredSCModel.get(0, 0, 1));
    1308         m_pcBinIf->encodeBin((uiDir == 32) ? 1 : 0, m_cCUIntraPredSCModel.get(0, 0, 1));
    1309       }
    1310     }
    1311   }
    1312  
    1313 #if ADD_PLANAR_MODE
    1314   uiDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1315   if ( (uiDir == PLANAR_IDX) || (uiDir == 2) )
    1316   {
    1317     m_pcBinIf->encodeBin( planarFlag, m_cPlanarFlagSCModel.get(0,0,0) );
    1318   }
    1319 #endif
     1011    Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
     1012    ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
     1013    m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
     1014   
     1015    if( iRefFrame > 0 )
     1016    {
     1017      xWriteUnaryMaxSymbol( iRefFrame - 1, pCtx + 1, 1, pcCU->getSlice()->getNumRefIdx( eRefList )-2 );
     1018    }
    13201019  }
    13211020  return;
    13221021}
    1323 #endif
    1324 Void TEncSbac::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1325 {
    1326   UInt uiCtx            = pcCU->getCtxIntraDirChroma( uiAbsPartIdx );
    1327   UInt uiIntraDirChroma = pcCU->getChromaIntraDir   ( uiAbsPartIdx );
    1328 #if ADD_PLANAR_MODE
    1329   UInt planarFlag       = 0;
    1330   if (uiIntraDirChroma == PLANAR_IDX)
    1331   {
    1332     uiIntraDirChroma = 2;
    1333     planarFlag = 1;
    1334   }
    1335 #endif
    1336  
    1337 #if CHROMA_CODEWORD
    1338   UInt uiMode = pcCU->getLumaIntraDir(uiAbsPartIdx);
    1339 #if ADD_PLANAR_MODE
    1340   if ( (uiMode == 2 ) || (uiMode == PLANAR_IDX) )
    1341   {
    1342     uiMode = 4;
    1343   }
    1344 #endif
    1345 
    1346 #if LM_CHROMA
    1347 
    1348   Bool bUseLMFlag = pcCU->getSlice()->getSPS()->getUseLMChroma();
    1349 
    1350   Int  iMaxMode = bUseLMFlag ? 3 : 4;
    1351 
    1352   Int  iMax = uiMode < iMaxMode ? 2 : 3;
    1353  
    1354   //switch codeword
    1355   if (uiIntraDirChroma == 4)
    1356   {
    1357     uiIntraDirChroma = 0;
    1358   }
    1359   else if (uiIntraDirChroma == 3 && bUseLMFlag )
    1360   {
    1361     uiIntraDirChroma = 1;
     1022
     1023Void TEncSbac::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
     1024{
     1025#if H0111_MVD_L1_ZERO
     1026  if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
     1027  {
     1028    return;
     1029  }
     1030#endif
     1031
     1032  const TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefList );
     1033  const Int iHor = pcCUMvField->getMvd( uiAbsPartIdx ).getHor();
     1034  const Int iVer = pcCUMvField->getMvd( uiAbsPartIdx ).getVer();
     1035  ContextModel* pCtx = m_cCUMvdSCModel.get( 0 );
     1036
     1037  m_pcBinIf->encodeBin( iHor != 0 ? 1 : 0, *pCtx );
     1038  m_pcBinIf->encodeBin( iVer != 0 ? 1 : 0, *pCtx );
     1039
     1040  const Bool bHorAbsGr0 = iHor != 0;
     1041  const Bool bVerAbsGr0 = iVer != 0;
     1042  const UInt uiHorAbs   = 0 > iHor ? -iHor : iHor;
     1043  const UInt uiVerAbs   = 0 > iVer ? -iVer : iVer;
     1044  pCtx++;
     1045
     1046  if( bHorAbsGr0 )
     1047  {
     1048    m_pcBinIf->encodeBin( uiHorAbs > 1 ? 1 : 0, *pCtx );
     1049  }
     1050
     1051  if( bVerAbsGr0 )
     1052  {
     1053    m_pcBinIf->encodeBin( uiVerAbs > 1 ? 1 : 0, *pCtx );
     1054  }
     1055
     1056  if( bHorAbsGr0 )
     1057  {
     1058    if( uiHorAbs > 1 )
     1059    {
     1060      xWriteEpExGolomb( uiHorAbs-2, 1 );
     1061    }
     1062
     1063    m_pcBinIf->encodeBinEP( 0 > iHor ? 1 : 0 );
     1064  }
     1065
     1066  if( bVerAbsGr0 )
     1067  {
     1068    if( uiVerAbs > 1 )
     1069    {
     1070      xWriteEpExGolomb( uiVerAbs-2, 1 );
     1071    }
     1072
     1073    m_pcBinIf->encodeBinEP( 0 > iVer ? 1 : 0 );
     1074  }
     1075 
     1076  return;
     1077}
     1078
     1079Void TEncSbac::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1080{
     1081  Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
     1082 
     1083#if H0736_AVC_STYLE_QP_RANGE
     1084  Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffsetY();
     1085  iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
     1086#else
     1087#if LOSSLESS_CODING
     1088  if(pcCU->getSlice()->getSPS()->getUseLossless())
     1089  {
     1090    if(iDQp > 25)
     1091    {
     1092      iDQp = iDQp - 52;
     1093    }
     1094    if(iDQp < -26)
     1095    {
     1096      iDQp = iDQp + 52;
     1097    }
     1098  }
     1099#endif
     1100#endif
     1101
     1102  if ( iDQp == 0 )
     1103  {
     1104    m_pcBinIf->encodeBin( 0, m_cCUDeltaQpSCModel.get( 0, 0, 0 ) );
    13621105  }
    13631106  else
    13641107  {
    1365     if (uiIntraDirChroma < uiMode)
    1366       uiIntraDirChroma++;
    1367 
    1368     if (bUseLMFlag)
    1369       uiIntraDirChroma++;
    1370 
    1371 #if CHROMA_CODEWORD_SWITCH
    1372     uiIntraDirChroma = ChromaMapping[iMax-2][uiIntraDirChroma];
    1373 #endif
    1374 
    1375   }
    1376 
    1377 
    1378 #else // <-- LM_CHROMA
    1379   Int  iMax = uiMode < 4 ? 2 : 3;
    1380  
    1381   //switch codeword
    1382   if (uiIntraDirChroma == 4) {
    1383     uiIntraDirChroma = 0;
    1384   }
    1385 #if CHROMA_CODEWORD_SWITCH
    1386   else {
    1387     if (uiIntraDirChroma < uiMode) {
    1388       uiIntraDirChroma++;
    1389     }
    1390     uiIntraDirChroma = ChromaMapping[iMax-2][uiIntraDirChroma];
    1391   }
    1392 #else
    1393   else if (uiIntraDirChroma < uiMode) {
    1394     uiIntraDirChroma++;
    1395   }
    1396 #endif
    1397 #endif // <-- LM_CHROMA
    1398  
    1399   if ( 0 == uiIntraDirChroma )
    1400   {
    1401     m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, uiCtx ) );
    1402   }
    1403   else
    1404   {
    1405     m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, uiCtx ) );
    1406     xWriteUnaryMaxSymbol( uiIntraDirChroma - 1, m_cCUChromaPredSCModel.get( 0, 0 ) + 3, 0, iMax );
    1407   }
    1408 #else // CHROMA_CODEWORD
    1409   if ( 0 == uiIntraDirChroma )
    1410   {
    1411     m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, uiCtx ) );
    1412   }
    1413   else
    1414   {
    1415     m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, uiCtx ) );
    1416     xWriteUnaryMaxSymbol( uiIntraDirChroma - 1, m_cCUChromaPredSCModel.get( 0, 0 ) + 3, 0, 3 );
    1417   }
    1418 #endif
    1419 
    1420 #if ADD_PLANAR_MODE
    1421   uiIntraDirChroma = pcCU->getChromaIntraDir( uiAbsPartIdx );
    1422 #if CHROMA_CODEWORD
    1423   uiMode = pcCU->getLumaIntraDir(uiAbsPartIdx);
    1424   mapPlanartoDC( uiIntraDirChroma );
    1425   mapPlanartoDC( uiMode );
    1426   if ( (uiIntraDirChroma == 2) && (uiMode != 2) )
    1427 #else
    1428   if ( (uiIntraDirChroma == PLANAR_IDX) || (uiIntraDirChroma == 2) )
    1429 #endif
    1430   {
    1431     m_pcBinIf->encodeBin( planarFlag, m_cPlanarFlagSCModel.get(0,0,1) );
    1432   }
    1433 #endif
    1434   return;
    1435 }
    1436 
    1437 Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1438 {
    1439   UInt uiInterDir = pcCU->getInterDir   ( uiAbsPartIdx );
    1440   UInt uiCtx      = pcCU->getCtxInterDir( uiAbsPartIdx );
    1441   uiInterDir--;
    1442   m_pcBinIf->encodeBin( ( uiInterDir == 2 ? 1 : 0 ), m_cCUInterDirSCModel.get( 0, 0, uiCtx ) );
    1443  
    1444   if ( pcCU->getSlice()->getNoBackPredFlag() )
    1445   {
    1446     assert( uiInterDir != 1 );
    1447     return;
    1448   }
    1449  
    1450 #if DCM_COMB_LIST
    1451   if ( uiInterDir < 2 && pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 0)
    1452 #else
    1453   if ( uiInterDir < 2 )
    1454 #endif
    1455   {
    1456     m_pcBinIf->encodeBin( uiInterDir, m_cCUInterDirSCModel.get( 0, 0, 3 ) );
    1457   }
    1458  
    1459   return;
    1460 }
    1461 
    1462 Void TEncSbac::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
    1463 {
    1464 #if DCM_COMB_LIST
    1465   if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getInterDir( uiAbsPartIdx ) != 3)
    1466   {
    1467     Int iRefFrame = pcCU->getSlice()->getRefIdxOfLC(eRefList, pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx ));
    1468     UInt uiCtx;
    1469 
    1470     uiCtx = pcCU->getCtxRefIdx( uiAbsPartIdx, RefPicList(pcCU->getSlice()->getListIdFromIdxOfLC(0)) );
    1471 
    1472     m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), m_cCURefPicSCModel.get( 0, 0, uiCtx ) );
    1473 
    1474     if ( iRefFrame > 0 )
    1475     {
    1476       xWriteUnaryMaxSymbol( iRefFrame - 1, &m_cCURefPicSCModel.get( 0, 0, 4 ), 1, pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_C )-2 );
    1477     }
    1478   }
    1479   else
    1480   {
    1481 #endif
    1482   Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
    1483  
    1484   UInt uiCtx = pcCU->getCtxRefIdx( uiAbsPartIdx, eRefList );
    1485  
    1486   m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), m_cCURefPicSCModel.get( 0, 0, uiCtx ) );
    1487  
    1488   if ( iRefFrame > 0 )
    1489   {
    1490     xWriteUnaryMaxSymbol( iRefFrame - 1, &m_cCURefPicSCModel.get( 0, 0, 4 ), 1, pcCU->getSlice()->getNumRefIdx( eRefList )-2 );
    1491   }
    1492 #if DCM_COMB_LIST
    1493   }
    1494 #endif
    1495   return;
    1496 }
    1497 
    1498 Void TEncSbac::codeViewIdx(Int iViewIdx)
    1499 {
    1500   assert(0) ; // not implemented yet
    1501   xWriteUnaryMaxSymbol(iViewIdx, &m_cViewIdxSCModel.get( 0, 0, 4),1, MAX_NUMBER_VIEWS   );
    1502 }
    1503 
    1504 Void TEncSbac::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
    1505 {
    1506   TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefList );
    1507   Int iHor = pcCUMvField->getMvd( uiAbsPartIdx ).getHor();
    1508   Int iVer = pcCUMvField->getMvd( uiAbsPartIdx ).getVer();
    1509  
    1510   UInt uiAbsPartIdxL, uiAbsPartIdxA;
    1511 #if MVD_CTX
    1512   Int iHorPredL, iVerPredL;
    1513   Int iHorPredA, iVerPredA;
    1514 #else
    1515   Int iHorPred, iVerPred;
    1516 #endif
    1517 
    1518   TComDataCU* pcCUL   = pcCU->getPULeft ( uiAbsPartIdxL, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
    1519   TComDataCU* pcCUA   = pcCU->getPUAbove( uiAbsPartIdxA, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
    1520  
    1521   TComCUMvField* pcCUMvFieldL = ( pcCUL == NULL || pcCUL->isIntra( uiAbsPartIdxL ) ) ? NULL : pcCUL->getCUMvField( eRefList );
    1522   TComCUMvField* pcCUMvFieldA = ( pcCUA == NULL || pcCUA->isIntra( uiAbsPartIdxA ) ) ? NULL : pcCUA->getCUMvField( eRefList );
    1523  
    1524 #if MVD_CTX
    1525   iHorPredA = ( (pcCUMvFieldA == NULL) ? 0 : pcCUMvFieldA->getMvd( uiAbsPartIdxA ).getAbsHor() );
    1526   iVerPredA = ( (pcCUMvFieldA == NULL) ? 0 : pcCUMvFieldA->getMvd( uiAbsPartIdxA ).getAbsVer() );
    1527   iHorPredL = ( (pcCUMvFieldL == NULL) ? 0 : pcCUMvFieldL->getMvd( uiAbsPartIdxL ).getAbsHor() );
    1528   iVerPredL = ( (pcCUMvFieldL == NULL) ? 0 : pcCUMvFieldL->getMvd( uiAbsPartIdxL ).getAbsVer() );
    1529 
    1530   xWriteMvd( iHor, iHorPredL, iHorPredA, 0 );
    1531   xWriteMvd( iVer, iVerPredL, iVerPredA, 1 );
    1532 #else 
    1533   iHorPred = ( (pcCUMvFieldL == NULL) ? 0 : pcCUMvFieldL->getMvd( uiAbsPartIdxL ).getAbsHor() ) +
    1534   ( (pcCUMvFieldA == NULL) ? 0 : pcCUMvFieldA->getMvd( uiAbsPartIdxA ).getAbsHor() );
    1535   iVerPred = ( (pcCUMvFieldL == NULL) ? 0 : pcCUMvFieldL->getMvd( uiAbsPartIdxL ).getAbsVer() ) +
    1536   ( (pcCUMvFieldA == NULL) ? 0 : pcCUMvFieldA->getMvd( uiAbsPartIdxA ).getAbsVer() );
    1537 
    1538   xWriteMvd( iHor, iHorPred, 0 );
    1539   xWriteMvd( iVer, iVerPred, 1 );
    1540 #endif
    1541 
    1542  
    1543   return;
    1544 }
    1545 
    1546 Void TEncSbac::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1547 {
    1548   Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getSlice()->getSliceQp();
    1549  
    1550   if ( iDQp == 0 )
    1551   {
    1552     m_pcBinIf->encodeBin( 0, m_cCUDeltaQpSCModel.get( 0, 0, 0 ) );
    1553   }
    1554   else
    1555   {
    15561108    m_pcBinIf->encodeBin( 1, m_cCUDeltaQpSCModel.get( 0, 0, 0 ) );
    1557    
    1558     UInt uiDQp = (UInt)( iDQp > 0 ? ( 2 * iDQp - 2 ) : ( -2 * iDQp - 1 ) );
    1559     xWriteUnarySymbol( uiDQp, &m_cCUDeltaQpSCModel.get( 0, 0, 2 ), 1 );
     1109   
     1110    UInt uiSign = (iDQp > 0 ? 0 : 1);
     1111#if !H0736_AVC_STYLE_QP_RANGE
     1112    UInt uiQpBdOffsetY = 6*(g_uiBitIncrement + g_uiBitDepth - 8);
     1113#endif
     1114
     1115    m_pcBinIf->encodeBinEP(uiSign);
     1116
     1117#if H0736_AVC_STYLE_QP_RANGE
     1118    assert(iDQp >= -(26+(qpBdOffsetY/2)));
     1119    assert(iDQp <=  (25+(qpBdOffsetY/2)));
     1120
     1121    UInt uiMaxAbsDQpMinus1 = 24 + (qpBdOffsetY/2) + (uiSign);
     1122#else
     1123    assert(iDQp >= -(26+(Int)(uiQpBdOffsetY/2)));
     1124    assert(iDQp <=  (25+(Int)(uiQpBdOffsetY/2)));
     1125
     1126    UInt uiMaxAbsDQpMinus1 = 24 + (uiQpBdOffsetY/2) + (uiSign);
     1127#endif
     1128    UInt uiAbsDQpMinus1 = (UInt)((iDQp > 0)? iDQp  : (-iDQp)) - 1;
     1129    xWriteUnaryMaxSymbol( uiAbsDQpMinus1, &m_cCUDeltaQpSCModel.get( 0, 0, 1 ), 1, uiMaxAbsDQpMinus1);
    15601130  }
    15611131 
     
    15671137  UInt uiCbf = pcCU->getCbf     ( uiAbsPartIdx, eType, uiTrDepth );
    15681138  UInt uiCtx = pcCU->getCtxQtCbf( uiAbsPartIdx, eType, uiTrDepth );
    1569   m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, eType ? eType - 1 : eType, uiCtx ) );
    1570   DTRACE_CABAC_V( g_nSymbolCounter++ )
     1139  m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, eType ? TEXT_CHROMA : eType, uiCtx ) );
     1140  DTRACE_CABAC_VL( g_nSymbolCounter++ )
    15711141  DTRACE_CABAC_T( "\tparseQtCbf()" )
    15721142  DTRACE_CABAC_T( "\tsymbol=" )
     
    15811151}
    15821152
    1583 UInt xCheckCoeffPlainCNoRecur( const TCoeff* pcCoef, UInt uiSize, UInt uiDepth )
    1584 {
    1585   UInt uiNumofCoeff = 0;
    1586   UInt ui = uiSize>>uiDepth;
    1587   {
    1588     UInt x, y;
    1589     const TCoeff* pCeoff = pcCoef;
    1590     for( y=0 ; y<ui ; y++ )
    1591     {
    1592       for( x=0 ; x<ui ; x++ )
    1593       {
    1594         if( pCeoff[x] != 0 )
    1595         {
    1596           uiNumofCoeff++;
    1597         }
    1598       }
    1599       pCeoff += uiSize;
    1600     }
    1601   }
    1602   return uiNumofCoeff;
     1153#if BURST_IPCM
     1154/** Code I_PCM information.
     1155 * \param pcCU pointer to CU
     1156 * \param uiAbsPartIdx CU index
     1157 * \param numIPCM the number of succesive IPCM blocks with the same size
     1158 * \param firstIPCMFlag
     1159 * \returns Void
     1160 */
     1161Void TEncSbac::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Int numIPCM, Bool firstIPCMFlag)
     1162#else
     1163/** Code I_PCM information.
     1164 * \param pcCU pointer to CU
     1165 * \param uiAbsPartIdx CU index
     1166 * \returns Void
     1167 *
     1168 * If I_PCM flag indicates that the CU is I_PCM, code its PCM alignment bits and codes. 
     1169 */
     1170Void TEncSbac::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx)
     1171#endif
     1172{
     1173  UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
     1174
     1175#if BURST_IPCM
     1176  Bool writePCMSampleFlag = pcCU->getIPCMFlag(uiAbsPartIdx);
     1177
     1178  if( uiIPCM == 0 || firstIPCMFlag)
     1179  {
     1180    m_pcBinIf->encodeBinTrm (uiIPCM);
     1181
     1182    if ( firstIPCMFlag )
     1183    {
     1184      m_pcBinIf->encodeNumSubseqIPCM( numIPCM - 1 );
     1185      m_pcBinIf->encodePCMAlignBits();
     1186    }
     1187  }
     1188#else
     1189  m_pcBinIf->encodeBinTrm (uiIPCM);
     1190#endif
     1191
     1192#if BURST_IPCM
     1193  if (writePCMSampleFlag)
     1194#else
     1195  if (uiIPCM)
     1196#endif
     1197  {
     1198#if !BURST_IPCM
     1199    m_pcBinIf->encodePCMAlignBits();
     1200#endif
     1201    UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
     1202    UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
     1203    UInt uiChromaOffset = uiLumaOffset>>2;
     1204    Pel* piPCMSample;
     1205    UInt uiWidth;
     1206    UInt uiHeight;
     1207    UInt uiSampleBits;
     1208    UInt uiX, uiY;
     1209
     1210    piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
     1211    uiWidth = pcCU->getWidth(uiAbsPartIdx);
     1212    uiHeight = pcCU->getHeight(uiAbsPartIdx);
     1213    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
     1214
     1215    for(uiY = 0; uiY < uiHeight; uiY++)
     1216    {
     1217      for(uiX = 0; uiX < uiWidth; uiX++)
     1218      {
     1219        UInt uiSample = piPCMSample[uiX];
     1220
     1221        m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
     1222      }
     1223      piPCMSample += uiWidth;
     1224    }
     1225
     1226    piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
     1227    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
     1228    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
     1229    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
     1230
     1231    for(uiY = 0; uiY < uiHeight; uiY++)
     1232    {
     1233      for(uiX = 0; uiX < uiWidth; uiX++)
     1234      {
     1235        UInt uiSample = piPCMSample[uiX];
     1236
     1237        m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
     1238      }
     1239      piPCMSample += uiWidth;
     1240    }
     1241
     1242    piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
     1243    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
     1244    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
     1245    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
     1246
     1247    for(uiY = 0; uiY < uiHeight; uiY++)
     1248    {
     1249      for(uiX = 0; uiX < uiWidth; uiX++)
     1250      {
     1251        UInt uiSample = piPCMSample[uiX];
     1252
     1253        m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
     1254      }
     1255      piPCMSample += uiWidth;
     1256    }
     1257#if BURST_IPCM
     1258    numIPCM--;
     1259    if(numIPCM == 0)
     1260    {
     1261      m_pcBinIf->resetBac();
     1262    }
     1263#else
     1264    m_pcBinIf->resetBac();
     1265#endif
     1266  }
    16031267}
    16041268
     
    16061270{
    16071271  UInt uiCbf = pcCU->getQtRootCbf( uiAbsPartIdx );
    1608   UInt uiCtx = pcCU->getCtxQtRootCbf( uiAbsPartIdx );
     1272  UInt uiCtx = 0;
    16091273  m_pcBinIf->encodeBin( uiCbf , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
    1610   DTRACE_CABAC_V( g_nSymbolCounter++ )
     1274  DTRACE_CABAC_VL( g_nSymbolCounter++ )
    16111275  DTRACE_CABAC_T( "\tparseQtRootCbf()" )
    16121276  DTRACE_CABAC_T( "\tsymbol=" )
     
    16191283}
    16201284
    1621 Void TEncSbac::xCheckCoeff( TCoeff* pcCoef, UInt uiSize, UInt uiDepth, UInt& uiNumofCoeff, UInt& uiPart )
    1622 {
    1623   UInt ui = uiSize>>uiDepth;
    1624   if( uiPart == 0 )
    1625   {
    1626     if( ui <= 4 )
    1627     {
    1628       UInt x, y;
    1629       TCoeff* pCeoff = pcCoef;
    1630       for( y=0 ; y<ui ; y++ )
    1631       {
    1632         for( x=0 ; x<ui ; x++ )
    1633         {
    1634           if( pCeoff[x] != 0 )
    1635           {
    1636             uiNumofCoeff++;
    1637           }
    1638         }
    1639         pCeoff += uiSize;
    1640       }
    1641     }
    1642     else
    1643     {
    1644       xCheckCoeff( pcCoef,                            uiSize, uiDepth+1, uiNumofCoeff, uiPart ); uiPart++; //1st Part
    1645       xCheckCoeff( pcCoef             + (ui>>1),      uiSize, uiDepth+1, uiNumofCoeff, uiPart ); uiPart++; //2nd Part
    1646       xCheckCoeff( pcCoef + (ui>>1)*uiSize,           uiSize, uiDepth+1, uiNumofCoeff, uiPart ); uiPart++; //3rd Part
    1647       xCheckCoeff( pcCoef + (ui>>1)*uiSize + (ui>>1), uiSize, uiDepth+1, uiNumofCoeff, uiPart );           //4th Part
    1648     }
    1649   }
    1650   else
    1651   {
    1652     UInt x, y;
    1653     TCoeff* pCeoff = pcCoef;
    1654     for( y=0 ; y<ui ; y++ )
    1655     {
    1656       for( x=0 ; x<ui ; x++ )
    1657       {
    1658         if( pCeoff[x] != 0 )
    1659         {
    1660           uiNumofCoeff++;
    1661         }
    1662       }
    1663       pCeoff += uiSize;
    1664     }
    1665   }
    1666 }
    1667 
    1668 UInt xCheckCoeffPlainCNoRecur( const TCoeff* pcCoef, UInt uiSize, UInt uiDepth );
    1669 
    1670 #if PCP_SIGMAP_SIMPLE_LAST
    16711285/** Encode (X,Y) position of the last significant coefficient
    16721286 * \param uiPosX X component of last coefficient
    16731287 * \param uiPosY Y component of last coefficient
    1674  * \param uiWidth block width
     1288 * \param width  Block width
     1289 * \param height Block height
    16751290 * \param eTType plane type / luminance or chrominance
    1676  * \param uiCTXIdx block size context
    16771291 * \param uiScanIdx scan type (zig-zag, hor, ver)
    1678  * \returns Void
    16791292 * This method encodes the X and Y component within a block of the last significant coefficient.
    16801293 */
    1681 __inline Void TEncSbac::codeLastSignificantXY( UInt uiPosX, UInt uiPosY, const UInt uiWidth, const TextType eTType, const UInt uiCTXIdx, const UInt uiScanIdx )
     1294Void TEncSbac::codeLastSignificantXY( UInt uiPosX, UInt uiPosY, Int width, Int height, TextType eTType, UInt uiScanIdx )
    16821295
    1683   UInt  uiCtxLast;
    1684   const UInt uiCtxOffset = g_uiCtxXYOffset[uiCTXIdx];
    1685 
     1296  // swap
    16861297  if( uiScanIdx == SCAN_VER )
    16871298  {
     
    16891300  }
    16901301
    1691   for(uiCtxLast=0; uiCtxLast<uiPosX; uiCtxLast++)
    1692   {
    1693     m_pcBinIf->encodeBin( 0, m_cCuCtxLastX.get( 0, eTType, uiCtxOffset + g_uiCtxXY[uiCtxLast] ) );
    1694   }
    1695   if(uiPosX < uiWidth - 1)
    1696   {
    1697     m_pcBinIf->encodeBin( 1, m_cCuCtxLastX.get( 0, eTType, uiCtxOffset + g_uiCtxXY[uiCtxLast] ) );
    1698   }
    1699 
    1700   for(uiCtxLast=0; uiCtxLast<uiPosY; uiCtxLast++)
    1701   {
    1702     m_pcBinIf->encodeBin( 0, m_cCuCtxLastY.get( 0, eTType, uiCtxOffset + g_uiCtxXY[uiCtxLast] ) );
    1703   }
    1704   if(uiPosY < uiWidth - 1)
    1705   {
    1706     m_pcBinIf->encodeBin( 1, m_cCuCtxLastY.get( 0, eTType, uiCtxOffset + g_uiCtxXY[uiCtxLast] ) );
    1707   }
    1708 }
    1709 #endif
    1710 
    1711 Void TEncSbac::codeCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType, Bool bRD )
    1712 {
    1713   DTRACE_CABAC_V( g_nSymbolCounter++ )
     1302  UInt uiCtxLast;
     1303  ContextModel *pCtxX = m_cCuCtxLastX.get( 0, eTType );
     1304  ContextModel *pCtxY = m_cCuCtxLastY.get( 0, eTType );
     1305  UInt uiGroupIdxX    = g_uiGroupIdx[ uiPosX ];
     1306  UInt uiGroupIdxY    = g_uiGroupIdx[ uiPosY ];
     1307
     1308  // posX
     1309#if LAST_CTX_REDUCTION
     1310  Int widthCtx = eTType? 4: width;
     1311  const UInt *puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ widthCtx ] * ( g_aucConvertToBit[ widthCtx ] + 3 ) );
     1312#else
     1313  const UInt *puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ width ] * ( g_aucConvertToBit[ width ] + 3 ) );
     1314#endif
     1315  for( uiCtxLast = 0; uiCtxLast < uiGroupIdxX; uiCtxLast++ )
     1316  {
     1317#if LAST_CTX_REDUCTION
     1318    if (eTType)
     1319    {
     1320      m_pcBinIf->encodeBin( 1, *( pCtxX + (uiCtxLast>>g_aucConvertToBit[ width ]) ) );
     1321    }
     1322    else
     1323    {
     1324#endif
     1325      m_pcBinIf->encodeBin( 1, *( pCtxX + puiCtxIdxX[ uiCtxLast ] ) );
     1326#if LAST_CTX_REDUCTION
     1327    }
     1328#endif
     1329  }
     1330  if( uiGroupIdxX < g_uiGroupIdx[ width - 1 ])
     1331  {
     1332#if LAST_CTX_REDUCTION
     1333    if ( eTType )
     1334    {
     1335      m_pcBinIf->encodeBin( 0, *( pCtxX + (uiCtxLast>>g_aucConvertToBit[ width ]) ) );
     1336    }
     1337    else
     1338    {
     1339#endif
     1340      m_pcBinIf->encodeBin( 0, *( pCtxX + puiCtxIdxX[ uiCtxLast ] ) );
     1341#if LAST_CTX_REDUCTION
     1342    }
     1343#endif
     1344  }
     1345
     1346  // posY
     1347#if LAST_CTX_REDUCTION
     1348  Int heightCtx = eTType? 4: height;
     1349  const UInt *puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ heightCtx ] * ( g_aucConvertToBit[ heightCtx ] + 3 ) );
     1350#else
     1351  const UInt *puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ height ] * ( g_aucConvertToBit[ height ] + 3 ) );
     1352#endif
     1353  for( uiCtxLast = 0; uiCtxLast < uiGroupIdxY; uiCtxLast++ )
     1354  {
     1355#if LAST_CTX_REDUCTION
     1356    if (eTType)
     1357    {
     1358      m_pcBinIf->encodeBin( 1, *( pCtxY + (uiCtxLast>>g_aucConvertToBit[ height ])));
     1359    }
     1360    else
     1361    {
     1362#endif
     1363      m_pcBinIf->encodeBin( 1, *( pCtxY + puiCtxIdxY[ uiCtxLast ] ) );
     1364#if LAST_CTX_REDUCTION
     1365    }
     1366#endif
     1367  }
     1368  if( uiGroupIdxY < g_uiGroupIdx[ height - 1 ])
     1369  {
     1370#if LAST_CTX_REDUCTION
     1371    if (eTType)
     1372    {
     1373      m_pcBinIf->encodeBin( 0, *( pCtxY + (uiCtxLast>>g_aucConvertToBit[ height ]) ) );
     1374    }
     1375    else
     1376    {
     1377#endif
     1378      m_pcBinIf->encodeBin( 0, *( pCtxY + puiCtxIdxY[ uiCtxLast ] ) );
     1379#if LAST_CTX_REDUCTION
     1380    }
     1381#endif
     1382    }
     1383  if ( uiGroupIdxX > 3 )
     1384  {     
     1385    UInt uiCount = ( uiGroupIdxX - 2 ) >> 1;
     1386    uiPosX       = uiPosX - g_uiMinInGroup[ uiGroupIdxX ];
     1387    for (Int i = uiCount - 1 ; i >= 0; i-- )
     1388    {
     1389      m_pcBinIf->encodeBinEP( ( uiPosX >> i ) & 1 );
     1390    }
     1391  }
     1392  if ( uiGroupIdxY > 3 )
     1393  {     
     1394    UInt uiCount = ( uiGroupIdxY - 2 ) >> 1;
     1395    uiPosY       = uiPosY - g_uiMinInGroup[ uiGroupIdxY ];
     1396    for ( Int i = uiCount - 1 ; i >= 0; i-- )
     1397    {
     1398      m_pcBinIf->encodeBinEP( ( uiPosY >> i ) & 1 );
     1399    }
     1400  }
     1401}
     1402
     1403Void TEncSbac::codeCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
     1404{
     1405  DTRACE_CABAC_VL( g_nSymbolCounter++ )
    17141406  DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
    17151407  DTRACE_CABAC_V( eTType )
     
    17351427  DTRACE_CABAC_V(  pcCU->getPredictionMode( uiAbsPartIdx ) )
    17361428  DTRACE_CABAC_T( "\n" )
     1429
    17371430  if( uiWidth > m_pcSlice->getSPS()->getMaxTrSize() )
    17381431  {
     
    17421435 
    17431436  UInt uiNumSig = 0;
    1744   UInt uiCTXIdx = 0;
    1745  
    1746   switch( uiWidth )
    1747   {
    1748     case  2: uiCTXIdx = 6; break;
    1749     case  4: uiCTXIdx = 5; break;
    1750     case  8: uiCTXIdx = 4; break;
    1751     case 16: uiCTXIdx = 3; break;
    1752     case 32: uiCTXIdx = 2; break;
    1753     case 64: uiCTXIdx = 1; break;
    1754     default: uiCTXIdx = 0; break;
    1755   }
    17561437 
    17571438  // compute number of significant coefficients
    1758   UInt  uiPart = 0;
    1759   xCheckCoeff(pcCoef, uiWidth, 0, uiNumSig, uiPart );
    1760  
    1761   if ( bRD )
    1762   {
    1763     UInt uiTempDepth = uiDepth - pcCU->getDepth( uiAbsPartIdx );
    1764     pcCU->setCbfSubParts( ( uiNumSig ? 1 : 0 ) << uiTempDepth, eTType, uiAbsPartIdx, uiDepth );
    1765   }
     1439  uiNumSig = TEncEntropy::countNonZeroCoeffs(pcCoef, uiWidth * uiHeight);
    17661440 
    17671441  if ( uiNumSig == 0 )
     
    17721446  //----- encode significance map -----
    17731447  const UInt   uiLog2BlockSize   = g_aucConvertToBit[ uiWidth ] + 2;
    1774   const UInt   uiMaxNumCoeff     = 1 << ( uiLog2BlockSize << 1 );
    1775 #if !PCP_SIGMAP_SIMPLE_LAST
    1776   const UInt   uiMaxNumCoeffM1   = uiMaxNumCoeff - 1;
    1777 #endif
    1778   const UInt   uiNum4x4Blk       = max<UInt>( 1, uiMaxNumCoeff >> 4 );
    1779 #if QC_MDCS
    1780   const UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
    1781 #endif //QC_MDCS
    1782  
    1783 #if PCP_SIGMAP_SIMPLE_LAST
    1784     //===== code last coeff =====
    1785     UInt uiScanPosLast = 0, uiPosLastX, uiPosLastY;
    1786     for( UInt uiScanPos = 0; uiScanPos < uiMaxNumCoeff; uiScanPos++ )
    1787     {
    1788 #if QC_MDCS
    1789       UInt uiBlkPos    = g_auiSigLastScan[uiScanIdx][uiLog2BlockSize-1][uiScanPos];
    1790 #else
    1791       UInt  uiBlkPos   = g_auiFrameScanXY[ uiLog2BlockSize-1 ][ uiScanPos ];
    1792 #endif //QC_MDCS
    1793       uiPosLastY = uiBlkPos >> uiLog2BlockSize;
    1794       uiPosLastX = uiBlkPos - ( uiPosLastY << uiLog2BlockSize );
    1795 
    1796       if( pcCoef[ uiBlkPos ] != 0 )
    1797       {
    1798         uiNumSig--;
    1799         if( uiNumSig == 0 )
     1448  UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
     1449  if (uiScanIdx == SCAN_ZIGZAG)
     1450  {
     1451    // Map zigzag to diagonal scan
     1452    uiScanIdx = SCAN_DIAG;
     1453  }
     1454  Int blockType = uiLog2BlockSize;
     1455  if (uiWidth != uiHeight)
     1456  {
     1457    uiScanIdx = SCAN_DIAG;
     1458    blockType = 4;
     1459  }
     1460 
     1461  const UInt * scan;
     1462  if (uiWidth == uiHeight)
     1463  {
     1464    scan = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize - 1 ];
     1465  }
     1466  else
     1467  {
     1468    scan = g_sigScanNSQT[ uiLog2BlockSize - 2 ];
     1469  }
     1470 
     1471#if MULTIBITS_DATA_HIDING
     1472  UInt const tsig = pcCU->getSlice()->getPPS()->getTSIG();
     1473#if LOSSLESS_CODING
     1474  Bool beValid;
     1475  if (pcCU->isLosslessCoded(uiAbsPartIdx))
     1476  {
     1477    beValid = false;
     1478  }
     1479  else
     1480  {
     1481    beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
     1482  }
     1483#else
     1484  Bool beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
     1485#endif
     1486#endif
     1487
     1488  // Find position of last coefficient
     1489  Int scanPosLast = -1;
     1490  Int posLast;
     1491
     1492  const UInt * scanCG;
     1493  if (uiWidth == uiHeight)
     1494  {
     1495    scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize > 3 ? uiLog2BlockSize-2-1 : 0 ];
     1496#if MULTILEVEL_SIGMAP_EXT
     1497    if( uiLog2BlockSize == 3 )
     1498    {
     1499      scanCG = g_sigLastScan8x8[ uiScanIdx ];
     1500    }
     1501    else if( uiLog2BlockSize == 5 )
     1502    {
     1503      scanCG = g_sigLastScanCG32x32;
     1504    }
     1505#endif
     1506  }
     1507  else
     1508  {
     1509    scanCG = g_sigCGScanNSQT[ uiLog2BlockSize - 2 ];
     1510  }
     1511  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
     1512  static const UInt uiShift = MLS_CG_SIZE >> 1;
     1513  const UInt uiNumBlkSide = uiWidth >> uiShift;
     1514
     1515#if !MULTILEVEL_SIGMAP_EXT
     1516  if( blockType > 3 )
     1517  {
     1518#endif
     1519    ::memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
     1520
     1521    do
     1522    {
     1523      posLast = scan[ ++scanPosLast ];
     1524
     1525      // get L1 sig map
     1526      UInt uiPosY    = posLast >> uiLog2BlockSize;
     1527      UInt uiPosX    = posLast - ( uiPosY << uiLog2BlockSize );
     1528      UInt uiBlkIdx  = uiNumBlkSide * (uiPosY >> uiShift) + (uiPosX >> uiShift);
     1529#if MULTILEVEL_SIGMAP_EXT
     1530      if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR || uiScanIdx == SCAN_VER) )
     1531      {
     1532        if( uiScanIdx == SCAN_HOR )
    18001533        {
    1801           codeLastSignificantXY(uiPosLastX, uiPosLastY, uiWidth, eTType, uiCTXIdx, uiScanIdx);
    1802           uiScanPosLast = uiScanPos;
    1803           break;
     1534          uiBlkIdx = uiPosY >> 1;
    18041535        }
    1805       }
    1806     }
    1807 
    1808     //===== code significance flag =====
    1809     {
    1810       for( UInt uiScanPos = 0; uiScanPos < uiScanPosLast; uiScanPos++ )
    1811       {
    1812 #if QC_MDCS
    1813         UInt uiBlkPos   = g_auiSigLastScan[uiScanIdx][uiLog2BlockSize-1][uiScanPos];
    1814 #else
    1815         UInt  uiBlkPos  = g_auiFrameScanXY[ uiLog2BlockSize-1 ][ uiScanPos ];
    1816 #endif //QC_MDCS
    1817         UInt  uiPosY    = uiBlkPos >> uiLog2BlockSize;
    1818         UInt  uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
    1819         UInt  uiSig     = pcCoef[ uiBlkPos ] != 0 ? 1 : 0;
    1820         UInt  uiCtxSig  = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, uiLog2BlockSize, uiWidth );
    1821 #if SIMPLE_CONTEXT_SIG
    1822         if( uiCtxSig < 4 || eTType)
     1536        else if( uiScanIdx == SCAN_VER )
    18231537        {
    1824           m_pcBinIf->encodeBin( uiSig, m_cCUSigSCModel.get( uiCTXIdx-2, eTType, uiCtxSig ) );
     1538          uiBlkIdx = uiPosX >> 1;
     1539        }
     1540      }
     1541#endif
     1542      if( pcCoef[ posLast ] )
     1543      {
     1544        uiSigCoeffGroupFlag[ uiBlkIdx ] = 1;
     1545      }
     1546
     1547      uiNumSig -= ( pcCoef[ posLast ] != 0 );
     1548    }
     1549    while ( uiNumSig > 0 );
     1550#if !MULTILEVEL_SIGMAP_EXT
     1551  }
     1552  else
     1553  {
     1554 
     1555  do
     1556  {
     1557    posLast = scan[ ++scanPosLast ];
     1558    uiNumSig -= ( pcCoef[ posLast ] != 0 );
     1559  }
     1560  while ( uiNumSig > 0 );
     1561
     1562  }
     1563#endif
     1564
     1565  // Code position of last coefficient
     1566  Int posLastY = posLast >> uiLog2BlockSize;
     1567  Int posLastX = posLast - ( posLastY << uiLog2BlockSize );
     1568  codeLastSignificantXY(posLastX, posLastY, uiWidth, uiHeight, eTType, uiScanIdx);
     1569 
     1570  //===== code significance flag =====
     1571  ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, eTType );
     1572  ContextModel * const baseCtx = (eTType==TEXT_LUMA) ? m_cCUSigSCModel.get( 0, 0 ) : m_cCUSigSCModel.get( 0, 0 ) + NUM_SIG_FLAG_CTX_LUMA;
     1573
     1574
     1575  const Int  iLastScanSet      = scanPosLast >> LOG2_SCAN_SET_SIZE;
     1576  UInt uiNumOne                = 0;
     1577  UInt uiGoRiceParam           = 0;
     1578  Int  iScanPosSig             = scanPosLast;
     1579
     1580  for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
     1581  {
     1582    Int numNonZero = 0;
     1583    Int  iSubPos     = iSubSet << LOG2_SCAN_SET_SIZE;
     1584    uiGoRiceParam    = 0;
     1585    Int absCoeff[16];
     1586    UInt coeffSigns = 0;
     1587
     1588#if MULTIBITS_DATA_HIDING
     1589    Int lastNZPosInCG = -1, firstNZPosInCG = SCAN_SET_SIZE;
     1590#endif
     1591
     1592    if( iScanPosSig == scanPosLast )
     1593    {
     1594      absCoeff[ 0 ] = abs( pcCoef[ posLast ] );
     1595      coeffSigns    = ( pcCoef[ posLast ] < 0 );
     1596      numNonZero    = 1;
     1597#if MULTIBITS_DATA_HIDING
     1598      lastNZPosInCG  = iScanPosSig;
     1599      firstNZPosInCG = iScanPosSig;
     1600#endif
     1601      iScanPosSig--;
     1602    }
     1603
     1604#if !MULTILEVEL_SIGMAP_EXT
     1605    if( blockType > 3 )
     1606    {
     1607#endif
     1608      // encode significant_coeffgroup_flag
     1609      Int iCGBlkPos = scanCG[ iSubSet ];
     1610      Int iCGPosY   = iCGBlkPos / uiNumBlkSide;
     1611      Int iCGPosX   = iCGBlkPos - (iCGPosY * uiNumBlkSide);
     1612#if MULTILEVEL_SIGMAP_EXT
     1613      if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR || uiScanIdx == SCAN_VER) )
     1614      {
     1615        iCGPosY = (uiScanIdx == SCAN_HOR ? iCGBlkPos : 0);
     1616        iCGPosX = (uiScanIdx == SCAN_VER ? iCGBlkPos : 0);
     1617      }
     1618#endif
     1619#if !REMOVE_INFER_SIGGRP
     1620      Bool bInferredCGFlag = false;
     1621#endif
     1622#if REMOVE_INFER_SIGGRP
     1623      if( iSubSet == iLastScanSet || iSubSet == 0)
     1624#else     
     1625      if( iSubSet == iLastScanSet )
     1626#endif
     1627      {
     1628        uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
     1629      }
     1630      else
     1631      {
     1632#if !REMOVE_INFER_SIGGRP
     1633#if MULTILEVEL_SIGMAP_EXT
     1634        if( !TComTrQuant::bothCGNeighboursOne( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight ) && ( iSubSet ) )
     1635#else
     1636        if( !TComTrQuant::bothCGNeighboursOne( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight ) && ( iSubSet ) )
     1637#endif
     1638        {
     1639#endif
     1640          UInt uiSigCoeffGroup   = (uiSigCoeffGroupFlag[ iCGBlkPos ] != 0);
     1641#if MULTILEVEL_SIGMAP_EXT
     1642          UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight );
     1643#else
     1644          UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight );
     1645#endif
     1646          m_pcBinIf->encodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
     1647#if !REMOVE_INFER_SIGGRP
    18251648        }
    18261649        else
    18271650        {
    1828           m_pcBinIf->encodeBin( uiSig, m_cCUSigSCModel.get( uiCTXIdx-2 ? uiCTXIdx-2 : 1, eTType, uiCtxSig ) );
     1651          uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
     1652          bInferredCGFlag = true;
    18291653        }
    1830 #else
    1831         m_pcBinIf->encodeBin( uiSig, m_cCUSigSCModel.get( uiCTXIdx, eTType, uiCtxSig ) );
    1832 #endif
    1833       }
    1834     }
    1835 
    1836 #else
    1837   for( UInt uiScanPos = 0; uiScanPos < uiMaxNumCoeffM1; uiScanPos++ )
    1838   {
    1839 #if QC_MDCS
    1840     UInt uiBlkPos   = g_auiSigLastScan[uiScanIdx][uiLog2BlockSize-1][uiScanPos];
    1841 #else
    1842     UInt  uiBlkPos  = g_auiFrameScanXY[ uiLog2BlockSize-1 ][ uiScanPos ];
    1843 #endif //QC_MDCS
    1844     UInt  uiPosY    = uiBlkPos >> uiLog2BlockSize;
    1845     UInt  uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
    1846    
    1847     //===== code significance flag =====
    1848     UInt  uiSig    = pcCoef[ uiBlkPos ] != 0 ? 1 : 0;
    1849     UInt  uiCtxSig = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, uiLog2BlockSize, uiWidth );
    1850 #if SIMPLE_CONTEXT_SIG
    1851       if( uiCtxSig < 4 || eTType)
    1852       {
    1853         m_pcBinIf->encodeBin( uiSig, m_cCUSigSCModel.get( uiCTXIdx-2, eTType, uiCtxSig ) );
    1854       }
    1855       else
    1856       {
    1857         m_pcBinIf->encodeBin( uiSig, m_cCUSigSCModel.get( uiCTXIdx-2 ? uiCTXIdx-2 : 1, eTType, uiCtxSig ) );
    1858       }
    1859 #else
    1860     m_pcBinIf->encodeBin( uiSig, m_cCUSigSCModel.get( uiCTXIdx, eTType, uiCtxSig ) );
    1861 #endif
    1862     if( uiSig )
    1863     {
    1864       uiNumSig--;
     1654#endif
     1655      }
    18651656     
    1866       //===== code last flag =====
    1867       UInt  uiLast    = ( uiNumSig == 0 ) ? 1 : 0;
    1868       UInt  uiCtxLast = TComTrQuant::getLastCtxInc( uiPosX, uiPosY, uiLog2BlockSize );
    1869       m_pcBinIf->encodeBin( uiLast, m_cCULastSCModel.get( uiCTXIdx, eTType, uiCtxLast ) );
    1870      
    1871       if( uiLast )
    1872       {
    1873         break;
    1874       }
    1875     }
    1876   }
    1877 #endif
    1878   /*
    1879    * Sign and bin0 PCP (Section 3.2 and 3.3 of JCTVC-B088)
    1880    */
    1881   Int  c1, c2;
    1882   UInt uiSign;
    1883   UInt uiAbs;
    1884 #if E253
    1885   UInt uiGoRiceParam = 0;
    1886 #endif
    1887 
    1888   if( uiNum4x4Blk > 1 )
    1889   {
    1890     Bool b1stBlk  = true;
    1891     UInt uiNumOne = 0;
    1892    
    1893     for( UInt uiSubBlk = 0; uiSubBlk < uiNum4x4Blk; uiSubBlk++ )
    1894     {
    1895       UInt uiCtxSet    = 0;
    1896       UInt uiSubNumSig = 0;
    1897       UInt uiSubPosX   = 0;
    1898       UInt uiSubPosY   = 0;
    1899 #if E253
    1900       uiGoRiceParam    = 0;
    1901 #endif
    1902 
    1903       uiSubPosX = g_auiFrameScanX[ g_aucConvertToBit[ uiWidth ] - 1 ][ uiSubBlk ] << 2;
    1904       uiSubPosY = g_auiFrameScanY[ g_aucConvertToBit[ uiWidth ] - 1 ][ uiSubBlk ] << 2;
    1905      
    1906       TCoeff* piCurr = &pcCoef[ uiSubPosX + uiSubPosY * uiWidth ];
    1907      
    1908       for( UInt uiY = 0; uiY < 4; uiY++ )
    1909       {
    1910         for( UInt uiX = 0; uiX < 4; uiX++ )
     1657      // encode significant_coeff_flag
     1658      if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
     1659      {
     1660        UInt uiBlkPos, uiPosY, uiPosX, uiSig, uiCtxSig;
     1661        for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
    19111662        {
    1912           if( piCurr[ uiX ] )
     1663          uiBlkPos  = scan[ iScanPosSig ];
     1664          uiPosY    = uiBlkPos >> uiLog2BlockSize;
     1665          uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
     1666          uiSig     = (pcCoef[ uiBlkPos ] != 0);
     1667#if REMOVE_INFER_SIGGRP
     1668          if( iScanPosSig > iSubPos || iSubSet == 0 || numNonZero )
     1669#else
     1670          if( iScanPosSig > iSubPos || bInferredCGFlag || numNonZero )
     1671#endif
    19131672          {
    1914             uiSubNumSig++;
     1673            uiCtxSig  = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
     1674            m_pcBinIf->encodeBin( uiSig, baseCtx[ uiCtxSig ] );
     1675          }
     1676          if( uiSig )
     1677          {
     1678            absCoeff[ numNonZero ] = abs( pcCoef[ uiBlkPos ] );
     1679            coeffSigns = 2 * coeffSigns + ( pcCoef[ uiBlkPos ] < 0 );
     1680            numNonZero++;
     1681#if MULTIBITS_DATA_HIDING
     1682            if( lastNZPosInCG == -1 )
     1683            {
     1684              lastNZPosInCG = iScanPosSig;
     1685            }
     1686            firstNZPosInCG = iScanPosSig;
     1687#endif
    19151688          }
    19161689        }
    1917         piCurr += uiWidth;
    1918       }
     1690      }
     1691      else
     1692      {
     1693        iScanPosSig = iSubPos - 1;
     1694      }
     1695#if !MULTILEVEL_SIGMAP_EXT
     1696    }
     1697    else
     1698    {
     1699
     1700    for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
     1701    {
     1702      UInt  uiBlkPos  = scan[ iScanPosSig ];
     1703      UInt  uiPosY    = uiBlkPos >> uiLog2BlockSize;
     1704      UInt  uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
     1705      UInt  uiSig     = 0;
     1706      if( pcCoef[ uiBlkPos ] != 0 )
     1707      {
     1708        uiSig = 1;
     1709        absCoeff[ numNonZero ] = abs( pcCoef[ uiBlkPos ] );
     1710        coeffSigns = 2 * coeffSigns + ( pcCoef[ uiBlkPos ] < 0 );
     1711        numNonZero++;
     1712#if MULTIBITS_DATA_HIDING
     1713        if( lastNZPosInCG == -1 )
     1714        {
     1715          lastNZPosInCG = iScanPosSig;
     1716        }
     1717        firstNZPosInCG = iScanPosSig;
     1718#endif
     1719      }     
     1720      UInt  uiCtxSig  = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
     1721      m_pcBinIf->encodeBin( uiSig, baseCtx[ uiCtxSig ] );
     1722    }
     1723
     1724    }
     1725#endif
     1726
     1727    if( numNonZero > 0 )
     1728    {
     1729#if MULTIBITS_DATA_HIDING
     1730      Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= (Int)tsig );
     1731#endif  // MULTIBITS_DATA_HIDING
     1732
     1733      UInt c1 = 1;
     1734#if !RESTRICT_GR1GR2FLAG_NUMBER
     1735      UInt c2 = 0;
     1736#endif
     1737#if LEVEL_CTX_LUMA_RED
     1738      UInt uiCtxSet = (iSubSet > 0 && eTType==TEXT_LUMA) ? 2 : 0;
     1739#else
     1740      UInt uiCtxSet = (iSubSet > 0 && eTType==TEXT_LUMA) ? 3 : 0;
     1741#endif
    19191742     
    1920       if( uiSubNumSig > 0 )
    1921       {
    1922         c1 = 1;
    1923         c2 = 0;
    1924        
    1925         if( b1stBlk )
     1743      if( uiNumOne > 0 )
     1744      {
     1745        uiCtxSet++;
     1746#if !LEVEL_CTX_LUMA_RED
     1747        if( uiNumOne > 3 && eTType==TEXT_LUMA)
    19261748        {
    1927           b1stBlk  = false;
    1928           uiCtxSet = 5;
     1749          uiCtxSet++;
    19291750        }
    1930         else
    1931         {
    1932           uiCtxSet = ( uiNumOne >> 2 ) + 1;
    1933           uiNumOne = 0;
    1934         }
    1935        
    1936         for( UInt uiScanPos = 0; uiScanPos < 16; uiScanPos++ )
    1937         {
    1938           UInt  uiBlkPos  = g_auiFrameScanXY[ 1 ][ 15 - uiScanPos ];
    1939           UInt  uiPosY    = uiBlkPos >> 2;
    1940           UInt  uiPosX    = uiBlkPos - ( uiPosY << 2 );
    1941           UInt  uiIndex   = ( ( uiSubPosY + uiPosY ) << uiLog2BlockSize ) + uiSubPosX + uiPosX;
    1942          
    1943           if( pcCoef[ uiIndex ]  )
    1944           {
    1945             if( pcCoef[ uiIndex ] > 0) { uiAbs = static_cast<UInt>( pcCoef[ uiIndex ]);  uiSign = 0; }
    1946             else                       { uiAbs = static_cast<UInt>(-pcCoef[ uiIndex ]);  uiSign = 1; }
    1947            
    1948             UInt uiCtx    = min<UInt>(c1, 4);
    1949             UInt uiSymbol = uiAbs > 1 ? 1 : 0;
    1950             m_pcBinIf->encodeBin( uiSymbol, m_cCUOneSCModel.get( 0, eTType, ( uiCtxSet << 2 ) + uiCtxSet + uiCtx ) );
    1951            
    1952             if( uiSymbol )
    1953             {
    1954               c1     = 0;
    1955             }
    1956             else if( c1 )
    1957             {
    1958               c1++;
    1959             }
    1960           }
    1961         }
    1962        
    1963         for( UInt uiScanPos = 0; uiScanPos < 16; uiScanPos++ )
    1964         {
    1965           UInt  uiBlkPos  = g_auiFrameScanXY[ 1 ][ 15 - uiScanPos ];
    1966           UInt  uiPosY    = uiBlkPos >> 2;
    1967           UInt  uiPosX    = uiBlkPos - ( uiPosY << 2 );
    1968           UInt  uiIndex   = ( ( uiSubPosY + uiPosY ) << uiLog2BlockSize ) + uiSubPosX + uiPosX;
    1969          
    1970           if( pcCoef[ uiIndex ]  )
    1971           {
    1972             if( pcCoef[ uiIndex ] > 0) { uiAbs = static_cast<UInt>( pcCoef[ uiIndex ]);  uiSign = 0; }
    1973             else                       { uiAbs = static_cast<UInt>(-pcCoef[ uiIndex ]);  uiSign = 1; }
    1974            
    1975             UInt uiSymbol = uiAbs > 1 ? 1 : 0;
    1976            
    1977             if( uiSymbol )
    1978             {
    1979               UInt uiCtx  = min<UInt>(c2, 4);
    1980               uiAbs -= 2;
    1981               c2++;
    1982               uiNumOne++;
    1983 #if E253
    1984               uiSymbol = uiAbs > 0 ? 1 : 0;
    1985 
    1986               m_pcBinIf->encodeBin( uiSymbol, m_cCUAbsSCModel.get( 0, eTType, ( uiCtxSet << 2 ) + uiCtxSet + uiCtx ) );
    1987 
    1988               if( uiSymbol )
    1989               {
    1990                 uiAbs -= 1;
    1991                 xWriteGoRiceExGolomb( uiAbs, uiGoRiceParam );
    1992               }
    1993 #else
    1994               xWriteExGolombLevel( uiAbs, m_cCUAbsSCModel.get( 0, eTType, ( uiCtxSet << 2 ) + uiCtxSet + uiCtx ) );
    1995 #endif
    1996             }
    1997           }
    1998         }
    1999        
    2000         for( UInt uiScanPos = 0; uiScanPos < 16; uiScanPos++ )
    2001         {
    2002           UInt  uiBlkPos  = g_auiFrameScanXY[ 1 ][ 15 - uiScanPos ];
    2003           UInt  uiPosY    = uiBlkPos >> 2;
    2004           UInt  uiPosX    = uiBlkPos - ( uiPosY << 2 );
    2005           UInt  uiIndex   = ( ( uiSubPosY + uiPosY ) << uiLog2BlockSize ) + uiSubPosX + uiPosX;
    2006          
    2007           if( pcCoef[ uiIndex ]  )
    2008           {
    2009             if( pcCoef[ uiIndex ] > 0) { uiAbs = static_cast<UInt>( pcCoef[ uiIndex ]);  uiSign = 0; }
    2010             else                       { uiAbs = static_cast<UInt>(-pcCoef[ uiIndex ]);  uiSign = 1; }
    2011             m_pcBinIf->encodeBinEP( uiSign );
    2012           }
    2013         }
    2014        
    2015       }
    2016     }
    2017   }
    2018   else
    2019   {
    2020     c1 = 1;
    2021     c2 = 0;
    2022    
    2023     for( UInt uiScanPos = 0; uiScanPos < 16; uiScanPos++ )
    2024     {
    2025       UInt uiIndex = g_auiFrameScanXY[ 1 ][ 15 - uiScanPos ];
     1751#endif
     1752      }
    20261753     
    2027       if( pcCoef[ uiIndex ]  )
    2028       {
    2029         if( pcCoef[ uiIndex ] > 0) { uiAbs = static_cast<UInt>( pcCoef[ uiIndex ]);  uiSign = 0; }
    2030         else                       { uiAbs = static_cast<UInt>(-pcCoef[ uiIndex ]);  uiSign = 1; }
    2031        
    2032         UInt uiCtx    = min<UInt>(c1, 4);
    2033         UInt uiSymbol = uiAbs > 1 ? 1 : 0;
    2034         m_pcBinIf->encodeBin( uiSymbol, m_cCUOneSCModel.get( 0, eTType, uiCtx ) );
    2035        
     1754      uiNumOne       >>= 1;
     1755      ContextModel *baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUOneSCModel.get( 0, 0 ) + 4 * uiCtxSet : m_cCUOneSCModel.get( 0, 0 ) + NUM_ONE_FLAG_CTX_LUMA + 4 * uiCtxSet;
     1756     
     1757#if RESTRICT_GR1GR2FLAG_NUMBER
     1758      Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
     1759      Int firstC2FlagIdx = -1;
     1760      for( Int idx = 0; idx < numC1Flag; idx++ )
     1761#else
     1762      for ( Int idx = 0; idx < numNonZero; idx++ )
     1763#endif
     1764      {
     1765        UInt uiSymbol = absCoeff[ idx ] > 1;
     1766        m_pcBinIf->encodeBin( uiSymbol, baseCtxMod[c1] );
    20361767        if( uiSymbol )
    20371768        {
    20381769          c1 = 0;
     1770
     1771#if RESTRICT_GR1GR2FLAG_NUMBER
     1772          if (firstC2FlagIdx == -1)
     1773          {
     1774            firstC2FlagIdx = idx;
     1775          }
     1776#endif
    20391777        }
    2040         else if( c1 )
     1778        else if( (c1 < 3) && (c1 > 0) )
    20411779        {
    20421780          c1++;
    20431781        }
    20441782      }
    2045     }
    2046    
    2047     for( UInt uiScanPos = 0; uiScanPos < 16; uiScanPos++ )
    2048     {
    2049       UInt uiIndex = g_auiFrameScanXY[ 1 ][ 15 - uiScanPos ];
    20501783     
    2051       if( pcCoef[ uiIndex ]  )
    2052       {
    2053         if( pcCoef[ uiIndex ] > 0) { uiAbs = static_cast<UInt>( pcCoef[ uiIndex ]);  uiSign = 0; }
    2054         else                       { uiAbs = static_cast<UInt>(-pcCoef[ uiIndex ]);  uiSign = 1; }
    2055        
    2056         UInt uiSymbol = uiAbs > 1 ? 1 : 0;
    2057        
    2058         if( uiSymbol )
     1784      if (c1 == 0)
     1785      {
     1786
     1787#if RESTRICT_GR1GR2FLAG_NUMBER
     1788        baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + uiCtxSet;
     1789        if ( firstC2FlagIdx != -1)
    20591790        {
    2060           UInt uiCtx  = min<UInt>(c2, 4);
    2061           uiAbs -= 2;
    2062           c2++;
    2063 #if E253
    2064           uiSymbol = uiAbs > 0 ? 1 : 0;
    2065 
    2066           m_pcBinIf->encodeBin( uiSymbol, m_cCUAbsSCModel.get( 0, eTType, uiCtx ) );
    2067 
    2068           if( uiSymbol )
     1791          UInt symbol = absCoeff[ firstC2FlagIdx ] > 2;
     1792          m_pcBinIf->encodeBin( symbol, baseCtxMod[0] );
     1793        }
     1794#else   
     1795        baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + 3 * uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + 3 * uiCtxSet;
     1796        for ( Int idx = 0; idx < numNonZero; idx++ )
     1797        {
     1798          if( absCoeff[ idx ] > 1 )
    20691799          {
    2070             uiAbs -= 1;
    2071             xWriteGoRiceExGolomb( uiAbs, uiGoRiceParam );
     1800            UInt symbol = absCoeff[ idx ] > 2;
     1801            m_pcBinIf->encodeBin( symbol, baseCtxMod[c2] );
     1802            c2 += (c2 < 2);
     1803            uiNumOne++;
    20721804          }
    2073 #else
    2074           xWriteExGolombLevel( uiAbs, m_cCUAbsSCModel.get( 0, eTType, uiCtx ) );
    2075 #endif
    20761805        }
    2077       }
    2078     }
    2079    
    2080     for( UInt uiScanPos = 0; uiScanPos < 16; uiScanPos++ )
    2081     {
    2082       UInt uiIndex = g_auiFrameScanXY[ 1 ][ 15 - uiScanPos ];
     1806#endif
     1807      }
    20831808     
    2084       if( pcCoef[ uiIndex ]  )
    2085       {
    2086         if( pcCoef[ uiIndex ] > 0) { uiAbs = static_cast<UInt>( pcCoef[ uiIndex ]);  uiSign = 0; }
    2087         else                       { uiAbs = static_cast<UInt>(-pcCoef[ uiIndex ]);  uiSign = 1; }
    2088        
    2089         m_pcBinIf->encodeBinEP( uiSign );
    2090       }
    2091     }
    2092   }
    2093   return;
    2094 }
    2095 
    2096 #if MVD_CTX
    2097 /** Encode a motion vector difference
    2098  * \param iMvd motion vector difference
    2099  * \param uiAbsSumL motion vector difference of left PU
    2100  * \param uiAbsSumA motion vector difference of above PU
    2101  * \param uiCtx index for context set based on vertical or horizontal component
    2102  */
    2103 Void TEncSbac::xWriteMvd( Int iMvd, UInt uiAbsSumL, UInt uiAbsSumA, UInt uiCtx )
    2104 #else
    2105 Void TEncSbac::xWriteMvd( Int iMvd, UInt uiAbsSum, UInt uiCtx )
    2106 #endif
    2107 {
    2108   UInt uiLocalCtx = 0;
    2109 #if MVD_CTX
    2110   uiLocalCtx += (uiAbsSumA>16) ? 1 : 0;
    2111   uiLocalCtx += (uiAbsSumL>16) ? 1 : 0;
    2112 #else
    2113   if ( uiAbsSum >= 3 )
    2114   {
    2115     uiLocalCtx += ( uiAbsSum > 32 ) ? 2 : 1;
    2116   }
    2117 #endif
    2118 
    2119   UInt uiSymbol = ( 0 == iMvd ) ? 0 : 1;
    2120   m_pcBinIf->encodeBin( uiSymbol, m_cCUMvdSCModel.get( 0, uiCtx, uiLocalCtx ) );
    2121   if ( 0 == uiSymbol )
    2122   {
    2123     return;
    2124   }
    2125  
    2126   UInt uiSign = 0;
    2127   if ( 0 > iMvd )
    2128   {
    2129     uiSign = 1;
    2130     iMvd   = -iMvd;
    2131   }
    2132   xWriteExGolombMvd( iMvd-1, &m_cCUMvdSCModel.get( 0, uiCtx, 3 ), 3 );
    2133   m_pcBinIf->encodeBinEP( uiSign );
    2134  
    2135   return;
    2136 }
    2137 
    2138 Void  TEncSbac::xWriteExGolombMvd( UInt uiSymbol, ContextModel* pcSCModel, UInt uiMaxBin )
    2139 {
    2140   if ( ! uiSymbol )
    2141   {
    2142     m_pcBinIf->encodeBin( 0, *pcSCModel );
    2143     return;
    2144   }
    2145  
    2146   m_pcBinIf->encodeBin( 1, *pcSCModel );
    2147  
    2148   Bool bNoExGo = ( uiSymbol < 8 );
    2149   UInt uiCount = 1;
    2150   pcSCModel++;
    2151  
    2152   while ( --uiSymbol && ++uiCount <= 8 )
    2153   {
    2154     m_pcBinIf->encodeBin( 1, *pcSCModel );
    2155     if ( uiCount == 2 )
    2156     {
    2157       pcSCModel++;
    2158     }
    2159     if ( uiCount == uiMaxBin )
    2160     {
    2161       pcSCModel++;
    2162     }
    2163   }
    2164  
    2165   if ( bNoExGo )
    2166   {
    2167     m_pcBinIf->encodeBin( 0, *pcSCModel );
    2168   }
    2169   else
    2170   {
    2171     xWriteEpExGolomb( uiSymbol, 3 );
    2172   }
    2173  
     1809#if MULTIBITS_DATA_HIDING
     1810      if( beValid && signHidden )
     1811      {
     1812        m_pcBinIf->encodeBinsEP( (coeffSigns >> 1), numNonZero-1 );
     1813      }
     1814      else
     1815      {
     1816        m_pcBinIf->encodeBinsEP( coeffSigns, numNonZero );
     1817      }
     1818#else
     1819      m_pcBinIf->encodeBinsEP( coeffSigns, numNonZero );
     1820#endif
     1821     
     1822#if RESTRICT_GR1GR2FLAG_NUMBER
     1823      Int iFirstCoeff2 = 1;   
     1824      if (c1 == 0 || numNonZero > C1FLAG_NUMBER)
     1825#else
     1826      if (c1 == 0)
     1827#endif
     1828      {
     1829        for ( Int idx = 0; idx < numNonZero; idx++ )
     1830        {
     1831#if RESTRICT_GR1GR2FLAG_NUMBER
     1832          UInt baseLevel  = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2 ) : 1;
     1833
     1834          if( absCoeff[ idx ] >= baseLevel)
     1835          {
     1836            xWriteGoRiceExGolomb( absCoeff[ idx ] - baseLevel, uiGoRiceParam );
     1837          }
     1838          if(absCoeff[ idx ] >= 2) 
     1839          {
     1840            iFirstCoeff2 = 0;
     1841            uiNumOne++;
     1842          }
     1843#else
     1844          if ( absCoeff[ idx ] > 2 )
     1845          {
     1846            xWriteGoRiceExGolomb( absCoeff[ idx ]  - 3, uiGoRiceParam );           
     1847          }
     1848#endif
     1849        }       
     1850      }
     1851    }
     1852    else
     1853    {
     1854      uiNumOne >>= 1;
     1855    }
     1856  }
     1857
    21741858  return;
    21751859}
     
    21811865}
    21821866
    2183 #if TSB_ALF_HEADER
    2184 Void TEncSbac::codeAlfFlagNum( UInt uiCode, UInt minValue )
    2185 {
    2186   UInt uiLength = 0;
    2187   UInt maxValue = (minValue << (this->getMaxAlfCtrlDepth()*2));
    2188   assert((uiCode>=minValue)&&(uiCode<=maxValue));
    2189   UInt temp = maxValue - minValue;
    2190   for(UInt i=0; i<32; i++)
    2191   {
    2192     if(temp&0x1)
    2193     {
    2194       uiLength = i+1;
    2195     }
    2196     temp = (temp >> 1);
    2197   }
    2198   UInt uiSymbol = uiCode - minValue;
    2199   if(uiLength)
    2200   {
    2201     while( uiLength-- )
    2202     {
    2203       m_pcBinIf->encodeBinEP( (uiSymbol>>uiLength) & 0x1 );
    2204     }
    2205   }
    2206 }
    2207 
    22081867Void TEncSbac::codeAlfCtrlFlag( UInt uiSymbol )
    22091868{
    22101869  m_pcBinIf->encodeBin( uiSymbol, m_cCUAlfCtrlFlagSCModel.get( 0, 0, 0) );
    22111870}
    2212 #endif
    22131871
    22141872Void TEncSbac::codeAlfUvlc       ( UInt uiCode )
     
    22631921}
    22641922
    2265 #if MTK_SAO
    2266 Void TEncSbac::codeAoFlag       ( UInt uiCode )
     1923Void TEncSbac::codeSaoFlag       ( UInt uiCode )
    22671924{
    22681925  UInt uiSymbol = ( ( uiCode == 0 ) ? 0 : 1 );
    2269   m_pcBinIf->encodeBin( uiSymbol, m_cAOFlagSCModel.get( 0, 0, 0 ) );
    2270 }
    2271 Void TEncSbac::codeAoUvlc       ( UInt uiCode )
     1926  m_pcBinIf->encodeBin( uiSymbol, m_cSaoFlagSCModel.get( 0, 0, 0 ) );
     1927}
     1928
     1929Void TEncSbac::codeSaoUvlc       ( UInt uiCode )
    22721930{
    22731931  Int i;
     
    22751933  if ( uiCode == 0 )
    22761934  {
    2277     m_pcBinIf->encodeBin( 0, m_cAOUvlcSCModel.get( 0, 0, 0 ) );
     1935    m_pcBinIf->encodeBin( 0, m_cSaoUvlcSCModel.get( 0, 0, 0 ) );
    22781936  }
    22791937  else
    22801938  {
    2281     m_pcBinIf->encodeBin( 1, m_cAOUvlcSCModel.get( 0, 0, 0 ) );
     1939    m_pcBinIf->encodeBin( 1, m_cSaoUvlcSCModel.get( 0, 0, 0 ) );
    22821940    for ( i=0; i<uiCode-1; i++ )
    22831941    {
    2284       m_pcBinIf->encodeBin( 1, m_cAOUvlcSCModel.get( 0, 0, 1 ) );
    2285     }
    2286     m_pcBinIf->encodeBin( 0, m_cAOUvlcSCModel.get( 0, 0, 1 ) );
    2287   }
    2288 }
    2289 Void TEncSbac::codeAoSvlc       ( Int iCode )
     1942      m_pcBinIf->encodeBin( 1, m_cSaoUvlcSCModel.get( 0, 0, 1 ) );
     1943    }
     1944    m_pcBinIf->encodeBin( 0, m_cSaoUvlcSCModel.get( 0, 0, 1 ) );
     1945  }
     1946}
     1947
     1948Void TEncSbac::codeSaoSvlc       ( Int iCode )
    22901949{
    22911950  Int i;
     
    22931952  if ( iCode == 0 )
    22941953  {
    2295     m_pcBinIf->encodeBin( 0, m_cAOSvlcSCModel.get( 0, 0, 0 ) );
     1954    m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 0 ) );
    22961955  }
    22971956  else
    22981957  {
    2299     m_pcBinIf->encodeBin( 1, m_cAOSvlcSCModel.get( 0, 0, 0 ) );
     1958    m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 0 ) );
    23001959
    23011960    // write sign
    23021961    if ( iCode > 0 )
    23031962    {
    2304       m_pcBinIf->encodeBin( 0, m_cAOSvlcSCModel.get( 0, 0, 1 ) );
     1963      m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 1 ) );
    23051964    }
    23061965    else
    23071966    {
    2308       m_pcBinIf->encodeBin( 1, m_cAOSvlcSCModel.get( 0, 0, 1 ) );
     1967      m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 1 ) );
    23091968      iCode = -iCode;
    23101969    }
     
    23131972    for ( i=0; i<iCode-1; i++ )
    23141973    {
    2315       m_pcBinIf->encodeBin( 1, m_cAOSvlcSCModel.get( 0, 0, 2 ) );
    2316     }
    2317     m_pcBinIf->encodeBin( 0, m_cAOSvlcSCModel.get( 0, 0, 2 ) );
    2318   }
    2319 }
    2320 #endif
    2321 
     1974      m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 2 ) );
     1975    }
     1976    m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 2 ) );
     1977  }
     1978}
     1979#if SAO_UNIT_INTERLEAVING
     1980/** Code SAO band position
     1981 * \param uiCode
     1982 */
     1983Void TEncSbac::codeSaoUflc       ( UInt uiCode )
     1984{
     1985  for (Int i=0;i<5;i++)
     1986  {
     1987    m_pcBinIf->encodeBinEP ( (uiCode>>i) &0x01 );
     1988  }
     1989}
     1990/** Code SAO merge left flag
     1991 * \param uiCode
     1992 * \param uiCompIdx
     1993 */
     1994Void TEncSbac::codeSaoMergeLeft       ( UInt uiCode, UInt uiCompIdx )
     1995{
     1996  if (uiCode == 0)
     1997  {
     1998    m_pcBinIf->encodeBin(0,  m_cSaoMergeLeftSCModel.get( 0, 0, uiCompIdx ));
     1999  }
     2000  else
     2001  {
     2002    m_pcBinIf->encodeBin(1,  m_cSaoMergeLeftSCModel.get( 0, 0, uiCompIdx ));
     2003  }
     2004}
     2005/** Code SAO merge up flag
     2006 * \param uiCode
     2007 */
     2008Void TEncSbac::codeSaoMergeUp       ( UInt uiCode)
     2009{
     2010  if (uiCode == 0)
     2011  {
     2012    m_pcBinIf->encodeBin(0,  m_cSaoMergeUpSCModel.get( 0, 0, 0 ));
     2013  }
     2014  else
     2015  {
     2016    m_pcBinIf->encodeBin(1,  m_cSaoMergeUpSCModel.get( 0, 0, 0 ));
     2017  }
     2018}
     2019/** Code SAO type index
     2020 * \param uiCode
     2021 */
     2022Void TEncSbac::codeSaoTypeIdx       ( UInt uiCode)
     2023{
     2024  Int i;
     2025  if ( uiCode == 0 )
     2026  {
     2027    m_pcBinIf->encodeBin( 0, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
     2028  }
     2029  else
     2030  {
     2031    m_pcBinIf->encodeBin( 1, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
     2032    for ( i=0; i<uiCode-1; i++ )
     2033    {
     2034      m_pcBinIf->encodeBin( 1, m_cSaoTypeIdxSCModel.get( 0, 0, 1 ) );
     2035    }
     2036    m_pcBinIf->encodeBin( 0, m_cSaoTypeIdxSCModel.get( 0, 0, 1 ) );
     2037  }
     2038}
     2039#endif
    23222040/*!
    23232041 ****************************************************************************
     
    23262044 ****************************************************************************
    23272045 */
    2328 Void TEncSbac::estBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
     2046Void TEncSbac::estBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType )
    23292047{
    23302048  estCBFBit( pcEstBitsSbac, 0, eTType );
     2049
     2050  estSignificantCoeffGroupMapBit( pcEstBitsSbac, 0, eTType );
    23312051 
    23322052  // encode significance map
    2333   estSignificantMapBit( pcEstBitsSbac, uiCTXIdx, eTType );
     2053  estSignificantMapBit( pcEstBitsSbac, width, height, eTType );
    23342054 
    23352055  // encode significant coefficients
    2336   estSignificantCoefficientsBit( pcEstBitsSbac, uiCTXIdx, eTType );
     2056  estSignificantCoefficientsBit( pcEstBitsSbac, 0, eTType );
    23372057}
    23382058
     
    23472067  ContextModel *pCtx = m_cCUQtCbfSCModel.get( 0 );
    23482068
    2349   for( UInt uiCtxInc = 0; uiCtxInc < 45; uiCtxInc++ )
    2350   {
    2351     pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 0 ] = biari_no_bits( 0, pCtx[ uiCtxInc ] );
    2352     pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 1 ] = biari_no_bits( 1, pCtx[ uiCtxInc ] );
    2353   }
    2354 
     2069  for( UInt uiCtxInc = 0; uiCtxInc < 3*NUM_QT_CBF_CTX; uiCtxInc++ )
     2070  {
     2071    pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
     2072    pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
     2073  }
     2074
     2075  pCtx = m_cCUQtRootCbfSCModel.get( 0 );
     2076 
    23552077  for( UInt uiCtxInc = 0; uiCtxInc < 4; uiCtxInc++ )
    23562078  {
    2357     pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 0 ] = biari_no_bits( 0, m_cCUQtRootCbfSCModel.get( 0, 0, uiCtxInc ) );
    2358     pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 1 ] = biari_no_bits( 1, m_cCUQtRootCbfSCModel.get( 0, 0, uiCtxInc ) );
     2079    pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
     2080    pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
     2081  }
     2082}
     2083
     2084
     2085/*!
     2086 ****************************************************************************
     2087 * \brief
     2088 *    estimate SAMBAC bit cost for significant coefficient group map
     2089 ****************************************************************************
     2090 */
     2091Void TEncSbac::estSignificantCoeffGroupMapBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
     2092{
     2093  Int firstCtx = 0, numCtx = NUM_SIG_CG_FLAG_CTX;
     2094
     2095  for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
     2096  {
     2097    for( UInt uiBin = 0; uiBin < 2; uiBin++ )
     2098    {
     2099      pcEstBitsSbac->significantCoeffGroupBits[ ctxIdx ][ uiBin ] = m_cCUSigCoeffGroupSCModel.get(  0, eTType, ctxIdx ).getEntropyBits( uiBin );
     2100    }
    23592101  }
    23602102}
     
    23672109 ****************************************************************************
    23682110 */
    2369 Void TEncSbac::estSignificantMapBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
    2370 {
    2371   for ( UInt uiCtx = 0; uiCtx < 16; uiCtx++ )
    2372   {
    2373     for( UInt uiBin = 0; uiBin < 2; uiBin++ )
    2374     {
    2375 #if SIMPLE_CONTEXT_SIG
    2376       if( uiCtx < 4 || eTType )
    2377       {
    2378         pcEstBitsSbac->significantBits[ uiCtx ][ uiBin ] = biari_no_bits ( uiBin, m_cCUSigSCModel.get( uiCTXIdx-2, eTType, uiCtx ) );
    2379       }
    2380       else
    2381       {
    2382         pcEstBitsSbac->significantBits[ uiCtx ][ uiBin ] = biari_no_bits ( uiBin, m_cCUSigSCModel.get( uiCTXIdx-2 ? uiCTXIdx-2 : 1, eTType, uiCtx ) );
    2383       }
    2384 #else
    2385       pcEstBitsSbac->significantBits[ uiCtx ][ uiBin ] = biari_no_bits ( uiBin, m_cCUSigSCModel.get(  uiCTXIdx, eTType, uiCtx ) );
    2386 #endif
    2387 
    2388 #if !PCP_SIGMAP_SIMPLE_LAST   
    2389       pcEstBitsSbac->lastBits[ uiCtx ][ uiBin ]        = biari_no_bits ( uiBin, m_cCULastSCModel.get( uiCTXIdx, eTType, uiCtx ) );
    2390 #endif
    2391     }
    2392   }
    2393 
    2394 #if PCP_SIGMAP_SIMPLE_LAST
     2111Void TEncSbac::estSignificantMapBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType )
     2112{
     2113  Int firstCtx = 0, numCtx = (eTType == TEXT_LUMA) ? 9 : 6;
     2114  if (std::max(width, height) >= 16)
     2115  {
     2116    firstCtx = (eTType == TEXT_LUMA) ? 20 : 17;
     2117    numCtx = (eTType == TEXT_LUMA) ? 7 : 4;   
     2118  }
     2119  else if (width == 8)
     2120  {
     2121    firstCtx = (eTType == TEXT_LUMA) ? 9 : 6;
     2122    numCtx = 11;
     2123  }
     2124 
     2125  if (eTType == TEXT_LUMA )
     2126  {
     2127    for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
     2128    {
     2129      for( UInt uiBin = 0; uiBin < 2; uiBin++ )
     2130      {
     2131        pcEstBitsSbac->significantBits[ ctxIdx ][ uiBin ] = m_cCUSigSCModel.get(  0, 0, ctxIdx ).getEntropyBits( uiBin );
     2132      }
     2133    }
     2134  }
     2135  else
     2136  {
     2137    for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
     2138    {
     2139      for( UInt uiBin = 0; uiBin < 2; uiBin++ )
     2140      {
     2141        pcEstBitsSbac->significantBits[ ctxIdx ][ uiBin ] = m_cCUSigSCModel.get(  0, 0, NUM_SIG_FLAG_CTX_LUMA + ctxIdx ).getEntropyBits( uiBin );
     2142      }
     2143    }
     2144  }
    23952145  Int iBitsX = 0, iBitsY = 0;
    2396   const UInt uiCtxOffset = g_uiCtxXYOffset[uiCTXIdx];
    2397   const UInt uiWidthM1   = (1 << (7-uiCTXIdx)) - 1;
    2398   for ( UInt uiCtx = 0; uiCtx < uiWidthM1; uiCtx++ )
    2399   {
    2400     pcEstBitsSbac->lastXBits[uiCtx] = iBitsX + biari_no_bits (1, m_cCuCtxLastX.get( 0, eTType, uiCtxOffset + g_uiCtxXY[uiCtx] ));
    2401     pcEstBitsSbac->lastYBits[uiCtx] = iBitsY + biari_no_bits (1, m_cCuCtxLastY.get( 0, eTType, uiCtxOffset + g_uiCtxXY[uiCtx] ));
    2402     iBitsX += biari_no_bits (0, m_cCuCtxLastX.get( 0, eTType, uiCtxOffset + g_uiCtxXY[uiCtx] ));
    2403     iBitsY += biari_no_bits (0, m_cCuCtxLastY.get( 0, eTType, uiCtxOffset + g_uiCtxXY[uiCtx] ));
    2404   }
    2405   pcEstBitsSbac->lastXBits[uiWidthM1] = iBitsX;
    2406   pcEstBitsSbac->lastYBits[uiWidthM1] = iBitsY;
    2407 #endif
     2146  const UInt *puiCtxIdx;
     2147  Int ctx;
     2148#if LAST_CTX_REDUCTION
     2149  Int widthCtx = eTType? 4 : width;
     2150  puiCtxIdx = g_uiLastCtx + (g_aucConvertToBit[ widthCtx ]*(g_aucConvertToBit[ widthCtx ]+3));
     2151#else 
     2152  puiCtxIdx = g_uiLastCtx + (g_aucConvertToBit[ width ]*(g_aucConvertToBit[ width ]+3));
     2153#endif
     2154  ContextModel *pCtxX      = m_cCuCtxLastX.get( 0, eTType );
     2155  for (ctx = 0; ctx < g_uiGroupIdx[ width - 1 ]; ctx++)
     2156  {
     2157    Int ctxOffset = puiCtxIdx[ ctx ];
     2158#if LAST_CTX_REDUCTION
     2159    if (eTType)
     2160    {
     2161      Int ctxOffsetC =  ctx>>g_aucConvertToBit[ width ];
     2162      pcEstBitsSbac->lastXBits[ ctx ] = iBitsX + pCtxX[ ctxOffsetC ].getEntropyBits( 0 );
     2163      iBitsX += pCtxX[ ctxOffsetC].getEntropyBits( 1 );
     2164    }
     2165    else
     2166    {
     2167#endif
     2168      pcEstBitsSbac->lastXBits[ ctx ] = iBitsX + pCtxX[ ctxOffset ].getEntropyBits( 0 );
     2169      iBitsX += pCtxX[ ctxOffset ].getEntropyBits( 1 );
     2170#if LAST_CTX_REDUCTION
     2171    }
     2172#endif
     2173    }
     2174  pcEstBitsSbac->lastXBits[ctx] = iBitsX;
     2175
     2176#if LAST_CTX_REDUCTION
     2177  Int heightCtx = eTType? 4 : height;
     2178  puiCtxIdx = g_uiLastCtx + (g_aucConvertToBit[ heightCtx ]*(g_aucConvertToBit[ heightCtx ]+3));
     2179#else
     2180  puiCtxIdx = g_uiLastCtx + (g_aucConvertToBit[ height ]*(g_aucConvertToBit[ height ]+3));
     2181#endif
     2182  ContextModel *pCtxY      = m_cCuCtxLastY.get( 0, eTType );
     2183  for (ctx = 0; ctx < g_uiGroupIdx[ height - 1 ]; ctx++)
     2184  {
     2185    Int ctxOffset = puiCtxIdx[ ctx ];
     2186#if LAST_CTX_REDUCTION
     2187    if (eTType)
     2188    {
     2189      Int ctxOffsetC =  ctx>>g_aucConvertToBit[ height ];
     2190      pcEstBitsSbac->lastYBits[ ctx ] = iBitsY + pCtxY[ ctxOffsetC ].getEntropyBits( 0 );
     2191      iBitsY += pCtxY[ctxOffsetC].getEntropyBits( 1 );
     2192    }
     2193    else
     2194    {
     2195#endif
     2196      pcEstBitsSbac->lastYBits[ ctx ] = iBitsY + pCtxY[ ctxOffset ].getEntropyBits( 0 );
     2197      iBitsY += pCtxY[ ctxOffset ].getEntropyBits( 1 );
     2198#if LAST_CTX_REDUCTION
     2199    }
     2200#endif
     2201    }
     2202  pcEstBitsSbac->lastYBits[ctx] = iBitsY;
    24082203}
    24092204
     
    24162211Void TEncSbac::estSignificantCoefficientsBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
    24172212{
    2418   for( UInt uiSet = 0; uiSet < 6; uiSet++ )
    2419   {
    2420     for( UInt uiCtx = 0; uiCtx < 5; uiCtx++ )
    2421     {
    2422       pcEstBitsSbac->greaterOneBits[ uiSet ][ 0 ][ uiCtx ][ 0 ] = biari_no_bits( 0, m_cCUOneSCModel.get( 0, eTType, ( uiSet << 2 ) + uiSet + uiCtx ) );
    2423       pcEstBitsSbac->greaterOneBits[ uiSet ][ 0 ][ uiCtx ][ 1 ] = biari_no_bits( 1, m_cCUOneSCModel.get( 0, eTType, ( uiSet << 2 ) + uiSet + uiCtx ) );
    2424       pcEstBitsSbac->greaterOneBits[ uiSet ][ 1 ][ uiCtx ][ 0 ] = biari_no_bits( 0, m_cCUAbsSCModel.get( 0, eTType, ( uiSet << 2 ) + uiSet + uiCtx ) );
    2425       pcEstBitsSbac->greaterOneBits[ uiSet ][ 1 ][ uiCtx ][ 1 ] = biari_no_bits( 1, m_cCUAbsSCModel.get( 0, eTType, ( uiSet << 2 ) + uiSet + uiCtx ) );
    2426     }
    2427   }
    2428 }
    2429 
    2430 Int TEncSbac::biari_no_bits( Short symbol, ContextModel& rcSCModel )
    2431 {
    2432   UInt  uiEstBits;
    2433   Short ui16State;
    2434  
    2435   symbol    = (Short)( symbol != 0 );
    2436   ui16State = symbol == rcSCModel.getMps() ? 64 + rcSCModel.getState() : 63 - rcSCModel.getState();
    2437   uiEstBits = entropyBits[ 127 - ui16State ];
    2438   return uiEstBits;
    2439 }
     2213  if (eTType==TEXT_LUMA)
     2214  {
     2215    ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0);
     2216    ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0);
     2217
     2218    for (Int ctxIdx = 0; ctxIdx < NUM_ONE_FLAG_CTX_LUMA; ctxIdx++)
     2219    {
     2220      pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
     2221      pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );   
     2222    }
     2223
     2224    for (Int ctxIdx = 0; ctxIdx < NUM_ABS_FLAG_CTX_LUMA; ctxIdx++)
     2225    {
     2226      pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
     2227      pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );   
     2228    }
     2229  }
     2230  else
     2231  {
     2232    ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0) + NUM_ONE_FLAG_CTX_LUMA;
     2233    ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0) + NUM_ABS_FLAG_CTX_LUMA;
     2234
     2235    for (Int ctxIdx = 0; ctxIdx < NUM_ONE_FLAG_CTX_CHROMA; ctxIdx++)
     2236    {
     2237      pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
     2238      pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );   
     2239    }
     2240
     2241    for (Int ctxIdx = 0; ctxIdx < NUM_ABS_FLAG_CTX_CHROMA; ctxIdx++)
     2242    {
     2243      pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
     2244      pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );   
     2245    }
     2246  }
     2247}
     2248
     2249/**
     2250 - Initialize our context information from the nominated source.
     2251 .
     2252 \param pSrc From where to copy context information.
     2253 */
     2254Void TEncSbac::xCopyContextsFrom( TEncSbac* pSrc )
     2255
     2256  memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
     2257}
     2258
     2259Void  TEncSbac::loadContexts ( TEncSbac* pScr)
     2260{
     2261  this->xCopyContextsFrom(pScr);
     2262}
     2263
     2264#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
     2265Void TEncSbac::xWriteExGolombLevel( UInt uiSymbol, ContextModel& rcSCModel  )
     2266{
     2267  if( uiSymbol )
     2268  {
     2269    m_pcBinIf->encodeBin( 1, rcSCModel );
     2270    UInt uiCount = 0;
     2271    Bool bNoExGo = (uiSymbol < 13);
     2272
     2273    while( --uiSymbol && ++uiCount < 13 )
     2274    {
     2275      m_pcBinIf->encodeBin( 1, rcSCModel );
     2276    }
     2277    if( bNoExGo )
     2278    {
     2279      m_pcBinIf->encodeBin( 0, rcSCModel );
     2280    }
     2281    else
     2282    {
     2283      xWriteEpExGolomb( uiSymbol, 0 );
     2284    }
     2285  }
     2286  else
     2287  {
     2288    m_pcBinIf->encodeBin( 0, rcSCModel );
     2289  }
     2290
     2291  return;
     2292}
     2293#endif
     2294#if HHI_DMM_WEDGE_INTRA
     2295Void TEncSbac::xCodeWedgeFullInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
     2296{
     2297  Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
     2298  Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
     2299
     2300  UInt uiTabIdx = pcCU->getWedgeFullTabIdx( uiAbsPartIdx );
     2301
     2302  for ( Int i = 0; i < iBits; i++ )
     2303  {
     2304    m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmmDataSCModel.get(0, 0, 0) );
     2305  }
     2306}
     2307
     2308Void TEncSbac::xCodeWedgeFullDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
     2309{
     2310  Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
     2311  Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
     2312
     2313  UInt uiTabIdx = pcCU->getWedgeFullTabIdx( uiAbsPartIdx );
     2314
     2315  for ( Int i = 0; i < iBits; i++ )
     2316  {
     2317    m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmmDataSCModel.get(0, 0, 0) );
     2318  }
     2319
     2320  Int iDeltaDC1 = pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx );
     2321  Int iDeltaDC2 = pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx );
     2322
     2323  xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
     2324  if ( iDeltaDC1 != 0 )
     2325  {
     2326    UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
     2327    m_pcBinIf->encodeBinEP( uiSign );
     2328  }
     2329  xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
     2330  if ( iDeltaDC2 != 0 )
     2331  {
     2332    UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
     2333    m_pcBinIf->encodeBinEP( uiSign );
     2334  }
     2335}
     2336
     2337Void TEncSbac::xCodeWedgePredDirInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
     2338{
     2339  if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
     2340  {
     2341    Int iDeltaEnd = pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx );
     2342    m_pcBinIf->encodeBin( (iDeltaEnd!=0), m_cDmmDataSCModel.get(0, 0, 2) );
     2343
     2344    if( iDeltaEnd != 0 )
     2345    {
     2346      UInt uiAbsValMinus1 = abs(iDeltaEnd)-1;
     2347      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01),      m_cDmmDataSCModel.get(0, 0, 2) );
     2348      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cDmmDataSCModel.get(0, 0, 2) );
     2349
     2350      UInt uiSign = iDeltaEnd > 0 ? 0 : 1;
     2351      m_pcBinIf->encodeBinEP( uiSign );
     2352    }
     2353  }
     2354}
     2355
     2356Void TEncSbac::xCodeWedgePredDirDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
     2357{
     2358  if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
     2359  {
     2360    Int iDeltaEnd = pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx );
     2361    m_pcBinIf->encodeBin( (iDeltaEnd!=0), m_cDmmDataSCModel.get(0, 0, 2) );
     2362
     2363    if( iDeltaEnd != 0 )
     2364    {
     2365      UInt uiAbsValMinus1 = abs(iDeltaEnd)-1;
     2366      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01),      m_cDmmDataSCModel.get(0, 0, 2) );
     2367      m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cDmmDataSCModel.get(0, 0, 2) );
     2368
     2369      UInt uiSign = iDeltaEnd > 0 ? 0 : 1;
     2370      m_pcBinIf->encodeBinEP( uiSign );
     2371    }
     2372  }
     2373
     2374  Int iDeltaDC1 = pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx );
     2375  Int iDeltaDC2 = pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx );
     2376
     2377  xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
     2378  if ( iDeltaDC1 != 0 )
     2379  {
     2380    UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
     2381    m_pcBinIf->encodeBinEP( uiSign );
     2382  }
     2383  xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
     2384  if ( iDeltaDC2 != 0 )
     2385  {
     2386    UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
     2387    m_pcBinIf->encodeBinEP( uiSign );
     2388  }
     2389}
     2390#endif
     2391#if HHI_DMM_PRED_TEX
     2392Void TEncSbac::xCodeWedgePredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
     2393{
     2394  Int iDeltaDC1 = pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx );
     2395  Int iDeltaDC2 = pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx );
     2396
     2397  xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
     2398  if ( iDeltaDC1 != 0 )
     2399  {
     2400    UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
     2401    m_pcBinIf->encodeBinEP( uiSign );
     2402  }
     2403  xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
     2404  if ( iDeltaDC2 != 0 )
     2405  {
     2406    UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
     2407    m_pcBinIf->encodeBinEP( uiSign );
     2408  }
     2409}
     2410
     2411Void TEncSbac::xCodeContourPredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
     2412{
     2413  Int iDeltaDC1 = pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx );
     2414  Int iDeltaDC2 = pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx );
     2415
     2416  xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
     2417  if ( iDeltaDC1 != 0 )
     2418  {
     2419    UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
     2420    m_pcBinIf->encodeBinEP( uiSign );
     2421  }
     2422  xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
     2423  if ( iDeltaDC2 != 0 )
     2424  {
     2425    UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
     2426    m_pcBinIf->encodeBinEP( uiSign );
     2427  }
     2428}
     2429#endif
     2430//! \}
Note: See TracChangeset for help on using the changeset viewer.