Ignore:
Timestamp:
26 Feb 2015, 00:21:54 (10 years ago)
Author:
seregin
Message:

merge with SHM-upgrade branch

Location:
branches/SHM-dev
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-dev

  • branches/SHM-dev/source

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncSbac.cpp

    r713 r1029  
    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 *
    66 * Copyright (c) 2010-2014, ITU/ISO/IEC
    … …  
    3838#include "TEncTop.h"
    3939#include "TEncSbac.h"
     40#include "TLibCommon/TComTU.h"
    4041
    4142#include <map>
    4243#include <algorithm>
     44
     45#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
     46#include "../TLibCommon/Debug.h"
     47#endif
     48
    4349
    4450//! \ingroup TLibEncoder
    … …  
    5157TEncSbac::TEncSbac()
    5258// new structure here
    53 : m_pcBitIf                   ( NULL )
    54 , m_pcSlice                   ( NULL )
    55 , m_pcBinIf                   ( NULL )
    56 , m_uiCoeffCost               ( 0 )
    57 , m_numContextModels          ( 0 )
    58 , m_cCUSplitFlagSCModel       ( 1,             1,               NUM_SPLIT_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels )
    59 , m_cCUSkipFlagSCModel        ( 1,             1,               NUM_SKIP_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    60 , m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        , m_contextModels + m_numContextModels, m_numContextModels)
    61 , m_cCUMergeIdxExtSCModel     ( 1,             1,               NUM_MERGE_IDX_EXT_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
    62 , m_cCUPartSizeSCModel        ( 1,             1,               NUM_PART_SIZE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    63 , m_cCUPredModeSCModel        ( 1,             1,               NUM_PRED_MODE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    64 , m_cCUIntraPredSCModel       ( 1,             1,               NUM_ADI_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
    65 , m_cCUChromaPredSCModel      ( 1,             1,               NUM_CHROMA_PRED_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
    66 , m_cCUDeltaQpSCModel         ( 1,             1,               NUM_DELTA_QP_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    67 , m_cCUInterDirSCModel        ( 1,             1,               NUM_INTER_DIR_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
    68 , m_cCURefPicSCModel          ( 1,             1,               NUM_REF_NO_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
    69 , m_cCUMvdSCModel             ( 1,             1,               NUM_MV_RES_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
    70 , m_cCUQtCbfSCModel           ( 1,             2,               NUM_QT_CBF_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
    71 , m_cCUTransSubdivFlagSCModel ( 1,             1,               NUM_TRANS_SUBDIV_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
    72 , m_cCUQtRootCbfSCModel       ( 1,             1,               NUM_QT_ROOT_CBF_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
    73 , m_cCUSigCoeffGroupSCModel   ( 1,             2,               NUM_SIG_CG_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
    74 , m_cCUSigSCModel             ( 1,             1,               NUM_SIG_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    75 , m_cCuCtxLastX               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          , m_contextModels + m_numContextModels, m_numContextModels)
    76 , m_cCuCtxLastY               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          , m_contextModels + m_numContextModels, m_numContextModels)
    77 , m_cCUOneSCModel             ( 1,             1,               NUM_ONE_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    78 , m_cCUAbsSCModel             ( 1,             1,               NUM_ABS_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    79 , m_cMVPIdxSCModel            ( 1,             1,               NUM_MVP_IDX_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
    80 , m_cSaoMergeSCModel          ( 1,             1,               NUM_SAO_MERGE_FLAG_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
    81 , m_cSaoTypeIdxSCModel        ( 1,             1,               NUM_SAO_TYPE_IDX_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
    82 , m_cTransformSkipSCModel     ( 1,             2,               NUM_TRANSFORMSKIP_FLAG_CTX    , m_contextModels + m_numContextModels, m_numContextModels)
    83 , m_CUTransquantBypassFlagSCModel( 1,          1,               NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX, m_contextModels + m_numContextModels, m_numContextModels)
     59: m_pcBitIf                            ( NULL )
     60, m_pcSlice                            ( NULL )
     61, m_pcBinIf                            ( NULL )
     62, m_numContextModels                   ( 0 )
     63, m_cCUSplitFlagSCModel                ( 1,             1,                      NUM_SPLIT_FLAG_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
     64, m_cCUSkipFlagSCModel                 ( 1,             1,                      NUM_SKIP_FLAG_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
     65, m_cCUMergeFlagExtSCModel             ( 1,             1,                      NUM_MERGE_FLAG_EXT_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
     66, m_cCUMergeIdxExtSCModel              ( 1,             1,                      NUM_MERGE_IDX_EXT_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
     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_cCUIntraPredSCModel                ( 1,             1,                      NUM_ADI_CTX                          , m_contextModels + m_numContextModels, m_numContextModels)
     70, m_cCUChromaPredSCModel               ( 1,             1,                      NUM_CHROMA_PRED_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
     71, m_cCUDeltaQpSCModel                  ( 1,             1,                      NUM_DELTA_QP_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
     72, m_cCUInterDirSCModel                 ( 1,             1,                      NUM_INTER_DIR_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
     73, m_cCURefPicSCModel                   ( 1,             1,                      NUM_REF_NO_CTX                       , m_contextModels + m_numContextModels, m_numContextModels)
     74, m_cCUMvdSCModel                      ( 1,             1,                      NUM_MV_RES_CTX                       , m_contextModels + m_numContextModels, m_numContextModels)
     75, m_cCUQtCbfSCModel                    ( 1,             NUM_QT_CBF_CTX_SETS,    NUM_QT_CBF_CTX_PER_SET               , m_contextModels + m_numContextModels, m_numContextModels)
     76, m_cCUTransSubdivFlagSCModel          ( 1,             1,                      NUM_TRANS_SUBDIV_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
     77, m_cCUQtRootCbfSCModel                ( 1,             1,                      NUM_QT_ROOT_CBF_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
     78, m_cCUSigCoeffGroupSCModel            ( 1,             2,                      NUM_SIG_CG_FLAG_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
     79, m_cCUSigSCModel                      ( 1,             1,                      NUM_SIG_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
     80, m_cCuCtxLastX                        ( 1,             NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY                 , m_contextModels + m_numContextModels, m_numContextModels)
     81, m_cCuCtxLastY                        ( 1,             NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY                 , m_contextModels + m_numContextModels, m_numContextModels)
     82, m_cCUOneSCModel                      ( 1,             1,                      NUM_ONE_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
     83, m_cCUAbsSCModel                      ( 1,             1,                      NUM_ABS_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
     84, m_cMVPIdxSCModel                     ( 1,             1,                      NUM_MVP_IDX_CTX                      , m_contextModels + m_numContextModels, m_numContextModels)
     85, m_cSaoMergeSCModel                   ( 1,             1,                      NUM_SAO_MERGE_FLAG_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
     86, m_cSaoTypeIdxSCModel                 ( 1,             1,                      NUM_SAO_TYPE_IDX_CTX                 , m_contextModels + m_numContextModels, m_numContextModels)
     87, m_cTransformSkipSCModel              ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_TRANSFORMSKIP_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
     88, m_CUTransquantBypassFlagSCModel      ( 1,             1,                      NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX    , m_contextModels + m_numContextModels, m_numContextModels)
     89, m_explicitRdpcmFlagSCModel           ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_EXPLICIT_RDPCM_FLAG_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
     90, m_explicitRdpcmDirSCModel            ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_EXPLICIT_RDPCM_DIR_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
     91, m_cCrossComponentPredictionSCModel   ( 1,             1,                      NUM_CROSS_COMPONENT_PREDICTION_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
     92, m_ChromaQpAdjFlagSCModel             ( 1,             1,                      NUM_CHROMA_QP_ADJ_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
     93, m_ChromaQpAdjIdcSCModel              ( 1,             1,                      NUM_CHROMA_QP_ADJ_IDC_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
    8494{
    8595  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
    … …  
    98108  Int  iQp              = m_pcSlice->getSliceQp();
    99109  SliceType eSliceType  = m_pcSlice->getSliceType();
    100  
     110
    101111  Int  encCABACTableIdx = m_pcSlice->getPPS()->getEncCABACTableIdx();
    102112  if (!m_pcSlice->isIntra() && (encCABACTableIdx==B_SLICE || encCABACTableIdx==P_SLICE) && m_pcSlice->getPPS()->getCabacInitPresentFlag())
    … …  
    105115  }
    106116
    107   m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
    108  
    109   m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
    110   m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
    111   m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
    112   m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
    113   m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
    114   m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
    115   m_cCUChromaPredSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
    116   m_cCUInterDirSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
    117   m_cCUMvdSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MVD );
    118   m_cCURefPicSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
    119   m_cCUDeltaQpSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DQP );
    120   m_cCUQtCbfSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
    121   m_cCUQtRootCbfSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
    122   m_cCUSigCoeffGroupSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
    123   m_cCUSigSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
    124   m_cCuCtxLastX.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
    125   m_cCuCtxLastY.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
    126   m_cCUOneSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
    127   m_cCUAbsSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
    128   m_cMVPIdxSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
    129   m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
    130   m_cSaoMergeSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_FLAG );
    131   m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
    132   m_cTransformSkipSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    133   m_CUTransquantBypassFlagSCModel.initBuffer( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
    134   // new structure
    135   m_uiLastQp = iQp;
    136  
     117  m_cCUSplitFlagSCModel.initBuffer                ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
     118  m_cCUSkipFlagSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
     119  m_cCUMergeFlagExtSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
     120  m_cCUMergeIdxExtSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
     121  m_cCUPartSizeSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
     122  m_cCUPredModeSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
     123  m_cCUIntraPredSCModel.initBuffer                ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
     124  m_cCUChromaPredSCModel.initBuffer               ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
     125  m_cCUInterDirSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
     126  m_cCUMvdSCModel.initBuffer                      ( eSliceType, iQp, (UChar*)INIT_MVD );
     127  m_cCURefPicSCModel.initBuffer                   ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
     128  m_cCUDeltaQpSCModel.initBuffer                  ( eSliceType, iQp, (UChar*)INIT_DQP );
     129  m_cCUQtCbfSCModel.initBuffer                    ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
     130  m_cCUQtRootCbfSCModel.initBuffer                ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
     131  m_cCUSigCoeffGroupSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
     132  m_cCUSigSCModel.initBuffer                      ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
     133  m_cCuCtxLastX.initBuffer                        ( eSliceType, iQp, (UChar*)INIT_LAST );
     134  m_cCuCtxLastY.initBuffer                        ( eSliceType, iQp, (UChar*)INIT_LAST );
     135  m_cCUOneSCModel.initBuffer                      ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
     136  m_cCUAbsSCModel.initBuffer                      ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
     137  m_cMVPIdxSCModel.initBuffer                     ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
     138  m_cCUTransSubdivFlagSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
     139  m_cSaoMergeSCModel.initBuffer                   ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_FLAG );
     140  m_cSaoTypeIdxSCModel.initBuffer                 ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
     141  m_cTransformSkipSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
     142  m_CUTransquantBypassFlagSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
     143  m_explicitRdpcmFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_EXPLICIT_RDPCM_FLAG);
     144  m_explicitRdpcmDirSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_EXPLICIT_RDPCM_DIR);
     145  m_cCrossComponentPredictionSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_CROSS_COMPONENT_PREDICTION  );
     146  m_ChromaQpAdjFlagSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CHROMA_QP_ADJ_FLAG );
     147  m_ChromaQpAdjIdcSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_CHROMA_QP_ADJ_IDC );
     148
     149  for (UInt statisticIndex = 0; statisticIndex < RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS ; statisticIndex++)
     150  {
     151    m_golombRiceAdaptationStatistics[statisticIndex] = 0;
     152  }
     153
    137154  m_pcBinIf->start();
    138  
     155
    139156  return;
    140157}
    141158
    142 /** The function does the following: 
    143  * If current slice type is P/B then it determines the distance of initialisation type 1 and 2 from the current CABAC states and 
     159/** The function does the following:
     160 * If current slice type is P/B then it determines the distance of initialisation type 1 and 2 from the current CABAC states and
    144161 * stores the index of the closest table.  This index is used for the next P/B slice when cabac_init_present_flag is true.
    145162 */
    … …  
    159176      SliceType curSliceType  = aSliceTypeChoices[idx];
    160177
    161       curCost  = m_cCUSplitFlagSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_SPLIT_FLAG );
    162       curCost += m_cCUSkipFlagSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SKIP_FLAG );
    163       curCost += m_cCUMergeFlagExtSCModel.calcCost    ( curSliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT);
    164       curCost += m_cCUMergeIdxExtSCModel.calcCost     ( curSliceType, qp, (UChar*)INIT_MERGE_IDX_EXT);
    165       curCost += m_cCUPartSizeSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_PART_SIZE );
    166       curCost += m_cCUPredModeSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_PRED_MODE );
    167       curCost += m_cCUIntraPredSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
    168       curCost += m_cCUChromaPredSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
    169       curCost += m_cCUInterDirSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_INTER_DIR );
    170       curCost += m_cCUMvdSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_MVD );
    171       curCost += m_cCURefPicSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_REF_PIC );
    172       curCost += m_cCUDeltaQpSCModel.calcCost         ( curSliceType, qp, (UChar*)INIT_DQP );
    173       curCost += m_cCUQtCbfSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_QT_CBF );
    174       curCost += m_cCUQtRootCbfSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
    175       curCost += m_cCUSigCoeffGroupSCModel.calcCost   ( curSliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
    176       curCost += m_cCUSigSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_SIG_FLAG );
    177       curCost += m_cCuCtxLastX.calcCost               ( curSliceType, qp, (UChar*)INIT_LAST );
    178       curCost += m_cCuCtxLastY.calcCost               ( curSliceType, qp, (UChar*)INIT_LAST );
    179       curCost += m_cCUOneSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_ONE_FLAG );
    180       curCost += m_cCUAbsSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_ABS_FLAG );
    181       curCost += m_cMVPIdxSCModel.calcCost            ( curSliceType, qp, (UChar*)INIT_MVP_IDX );
    182       curCost += m_cCUTransSubdivFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
    183       curCost += m_cSaoMergeSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_FLAG );
    184       curCost += m_cSaoTypeIdxSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
    185       curCost += m_cTransformSkipSCModel.calcCost     ( curSliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    186       curCost += m_CUTransquantBypassFlagSCModel.calcCost( curSliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
     178      curCost  = m_cCUSplitFlagSCModel.calcCost                ( curSliceType, qp, (UChar*)INIT_SPLIT_FLAG );
     179      curCost += m_cCUSkipFlagSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_SKIP_FLAG );
     180      curCost += m_cCUMergeFlagExtSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT);
     181      curCost += m_cCUMergeIdxExtSCModel.calcCost              ( curSliceType, qp, (UChar*)INIT_MERGE_IDX_EXT);
     182      curCost += m_cCUPartSizeSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_PART_SIZE );
     183      curCost += m_cCUPredModeSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_PRED_MODE );
     184      curCost += m_cCUIntraPredSCModel.calcCost                ( curSliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
     185      curCost += m_cCUChromaPredSCModel.calcCost               ( curSliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
     186      curCost += m_cCUInterDirSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_INTER_DIR );
     187      curCost += m_cCUMvdSCModel.calcCost                      ( curSliceType, qp, (UChar*)INIT_MVD );
     188      curCost += m_cCURefPicSCModel.calcCost                   ( curSliceType, qp, (UChar*)INIT_REF_PIC );
     189      curCost += m_cCUDeltaQpSCModel.calcCost                  ( curSliceType, qp, (UChar*)INIT_DQP );
     190      curCost += m_cCUQtCbfSCModel.calcCost                    ( curSliceType, qp, (UChar*)INIT_QT_CBF );
     191      curCost += m_cCUQtRootCbfSCModel.calcCost                ( curSliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
     192      curCost += m_cCUSigCoeffGroupSCModel.calcCost            ( curSliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
     193      curCost += m_cCUSigSCModel.calcCost                      ( curSliceType, qp, (UChar*)INIT_SIG_FLAG );
     194      curCost += m_cCuCtxLastX.calcCost                        ( curSliceType, qp, (UChar*)INIT_LAST );
     195      curCost += m_cCuCtxLastY.calcCost                        ( curSliceType, qp, (UChar*)INIT_LAST );
     196      curCost += m_cCUOneSCModel.calcCost                      ( curSliceType, qp, (UChar*)INIT_ONE_FLAG );
     197      curCost += m_cCUAbsSCModel.calcCost                      ( curSliceType, qp, (UChar*)INIT_ABS_FLAG );
     198      curCost += m_cMVPIdxSCModel.calcCost                     ( curSliceType, qp, (UChar*)INIT_MVP_IDX );
     199      curCost += m_cCUTransSubdivFlagSCModel.calcCost          ( curSliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
     200      curCost += m_cSaoMergeSCModel.calcCost                   ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_FLAG );
     201      curCost += m_cSaoTypeIdxSCModel.calcCost                 ( curSliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
     202      curCost += m_cTransformSkipSCModel.calcCost              ( curSliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
     203      curCost += m_CUTransquantBypassFlagSCModel.calcCost      ( curSliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
     204      curCost += m_explicitRdpcmFlagSCModel.calcCost           ( curSliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_FLAG);
     205      curCost += m_explicitRdpcmDirSCModel.calcCost            ( curSliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_DIR);
     206      curCost += m_cCrossComponentPredictionSCModel.calcCost   ( curSliceType, qp, (UChar*)INIT_CROSS_COMPONENT_PREDICTION );
     207      curCost += m_ChromaQpAdjFlagSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_FLAG );
     208      curCost += m_ChromaQpAdjIdcSCModel.calcCost              ( curSliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_IDC );
     209
    187210      if (curCost < bestCost)
    188211      {
    … …  
    196219  {
    197220    m_pcSlice->getPPS()->setEncCABACTableIdx( I_SLICE );
    198   } 
    199 }
    200 
    201 
    202 /** The function does the followng: Write out terminate bit. Flush CABAC. Intialize CABAC states. Start CABAC.
    203  */
    204 Void TEncSbac::updateContextTables( SliceType eSliceType, Int iQp, Bool bExecuteFinish )
    205 {
    206   m_pcBinIf->encodeBinTrm(1);
    207   if (bExecuteFinish) m_pcBinIf->finish();
    208   m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
    209  
    210   m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
    211   m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
    212   m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
    213   m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
    214   m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
    215   m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
    216   m_cCUChromaPredSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
    217   m_cCUInterDirSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
    218   m_cCUMvdSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MVD );
    219   m_cCURefPicSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
    220   m_cCUDeltaQpSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DQP );
    221   m_cCUQtCbfSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
    222   m_cCUQtRootCbfSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
    223   m_cCUSigCoeffGroupSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
    224   m_cCUSigSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
    225   m_cCuCtxLastX.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
    226   m_cCuCtxLastY.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
    227   m_cCUOneSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
    228   m_cCUAbsSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
    229   m_cMVPIdxSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
    230   m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
    231   m_cSaoMergeSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_FLAG );
    232   m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
    233   m_cTransformSkipSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    234   m_CUTransquantBypassFlagSCModel.initBuffer( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
    235   m_pcBinIf->start();
     221  }
    236222}
    237223
    … …  
    270256}
    271257
    272 #if POC_RESET_IDC_SIGNALLING
    273 Void  TEncSbac::codeSliceHeaderExtn( TComSlice* pSlice, Int shBitsWrittenTillNow )
    274 {
    275   assert (0);
     258Void TEncSbac::codeTerminatingBit( UInt uilsLast )
     259{
     260  m_pcBinIf->encodeBinTrm( uilsLast );
     261}
     262
     263Void TEncSbac::codeSliceFinish()
     264{
     265  m_pcBinIf->finish();
     266}
     267
     268Void TEncSbac::xWriteUnarySymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset )
     269{
     270  m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[0] );
     271
     272  if( 0 == uiSymbol)
     273  {
     274    return;
     275  }
     276
     277  while( uiSymbol-- )
     278  {
     279    m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ iOffset ] );
     280  }
     281
    276282  return;
    277283}
    278 #endif
    279 Void TEncSbac::codeTerminatingBit( UInt uilsLast )
    280 {
    281   m_pcBinIf->encodeBinTrm( uilsLast );
    282 }
    283 
    284 Void TEncSbac::codeSliceFinish()
    285 {
    286   m_pcBinIf->finish();
    287 }
    288 
    289 Void TEncSbac::xWriteUnarySymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset )
    290 {
    291   m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[0] );
    292  
    293   if( 0 == uiSymbol)
     284
     285Void TEncSbac::xWriteUnaryMaxSymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
     286{
     287  if (uiMaxSymbol == 0)
    294288  {
    295289    return;
    296290  }
    297  
    298   while( uiSymbol-- )
    299   {
    300     m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ iOffset ] );
    301   }
    302  
    303   return;
    304 }
    305 
    306 Void TEncSbac::xWriteUnaryMaxSymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
    307 {
    308   if (uiMaxSymbol == 0)
     291
     292  m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ 0 ] );
     293
     294  if ( uiSymbol == 0 )
    309295  {
    310296    return;
    311297  }
    312  
    313   m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ 0 ] );
    314  
    315   if ( uiSymbol == 0 )
    316   {
    317     return;
    318   }
    319  
     298
    320299  Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
    321  
     300
    322301  while( --uiSymbol )
    323302  {
    … …  
    328307    m_pcBinIf->encodeBin( 0, pcSCModel[ iOffset ] );
    329308  }
    330  
     309
    331310  return;
    332311}
    … …  
    336315  UInt bins = 0;
    337316  Int numBins = 0;
    338  
     317
    339318  while( uiSymbol >= (UInt)(1<<uiCount) )
    340319  {
    … …  
    346325  bins = 2 * bins + 0;
    347326  numBins++;
    348  
     327
    349328  bins = (bins << uiCount) | uiSymbol;
    350329  numBins += uiCount;
    351  
     330
    352331  assert( numBins <= 32 );
    353332  m_pcBinIf->encodeBinsEP( bins, numBins );
    354333}
     334
    355335
    356336/** Coding of coeff_abs_level_minus3
    … …  
    359339 * \returns Void
    360340 */
    361 Void TEncSbac::xWriteCoefRemainExGolomb ( UInt symbol, UInt &rParam )
     341Void TEncSbac::xWriteCoefRemainExGolomb ( UInt symbol, UInt &rParam, const Bool useLimitedPrefixLength, const ChannelType channelType )
    362342{
    363343  Int codeNumber  = (Int)symbol;
    364344  UInt length;
     345
    365346  if (codeNumber < (COEF_REMAIN_BIN_REDUCTION << rParam))
    366347  {
    … …  
    369350    m_pcBinIf->encodeBinsEP((codeNumber%(1<<rParam)),rParam);
    370351  }
     352  else if (useLimitedPrefixLength)
     353  {
     354    const UInt maximumPrefixLength = (32 - (COEF_REMAIN_BIN_REDUCTION + g_maxTrDynamicRange[channelType]));
     355
     356    UInt prefixLength = 0;
     357    UInt suffixLength = MAX_UINT;
     358    UInt codeValue    = (symbol >> rParam) - COEF_REMAIN_BIN_REDUCTION;
     359
     360    if (codeValue >= ((1 << maximumPrefixLength) - 1))
     361    {
     362      prefixLength = maximumPrefixLength;
     363      suffixLength = g_maxTrDynamicRange[channelType] - rParam;
     364    }
     365    else
     366    {
     367      while (codeValue > ((2 << prefixLength) - 2))
     368      {
     369        prefixLength++;
     370      }
     371
     372      suffixLength = prefixLength + 1; //+1 for the separator bit
     373    }
     374
     375    const UInt suffix = codeValue - ((1 << prefixLength) - 1);
     376
     377    const UInt totalPrefixLength = prefixLength + COEF_REMAIN_BIN_REDUCTION;
     378    const UInt prefix            = (1 << totalPrefixLength) - 1;
     379    const UInt rParamBitMask     = (1 << rParam) - 1;
     380
     381    m_pcBinIf->encodeBinsEP(  prefix,                                        totalPrefixLength      ); //prefix
     382    m_pcBinIf->encodeBinsEP(((suffix << rParam) | (symbol & rParamBitMask)), (suffixLength + rParam)); //separator, suffix, and rParam bits
     383  }
    371384  else
    372385  {
    373386    length = rParam;
    374387    codeNumber  = codeNumber - ( COEF_REMAIN_BIN_REDUCTION << rParam);
     388
    375389    while (codeNumber >= (1<<length))
    376390    {
    377       codeNumber -=  (1<<(length++));   
    378     }
     391      codeNumber -=  (1<<(length++));
     392    }
     393
    379394    m_pcBinIf->encodeBinsEP((1<<(COEF_REMAIN_BIN_REDUCTION+length+1-rParam))-2,COEF_REMAIN_BIN_REDUCTION+length+1-rParam);
    380395    m_pcBinIf->encodeBinsEP(codeNumber,length);
    … …  
    383398
    384399// SBAC RD
    385 Void  TEncSbac::load ( TEncSbac* pSrc)
     400Void  TEncSbac::load ( const TEncSbac* pSrc)
    386401{
    387402  this->xCopyFrom(pSrc);
    388403}
    389404
    390 Void  TEncSbac::loadIntraDirModeLuma( TEncSbac* pSrc)
     405Void  TEncSbac::loadIntraDirMode( const TEncSbac* pSrc, const ChannelType chType )
    391406{
    392407  m_pcBinIf->copyState( pSrc->m_pcBinIf );
    393  
    394   this->m_cCUIntraPredSCModel      .copyFrom( &pSrc->m_cCUIntraPredSCModel       );
    395 }
    396 
    397 
    398 Void  TEncSbac::store( TEncSbac* pDest)
     408  if (isLuma(chType))
     409    this->m_cCUIntraPredSCModel      .copyFrom( &pSrc->m_cCUIntraPredSCModel       );
     410  else
     411    this->m_cCUChromaPredSCModel     .copyFrom( &pSrc->m_cCUChromaPredSCModel      );
     412}
     413
     414
     415Void  TEncSbac::store( TEncSbac* pDest) const
    399416{
    400417  pDest->xCopyFrom( this );
    … …  
    402419
    403420
    404 Void TEncSbac::xCopyFrom( TEncSbac* pSrc )
     421Void TEncSbac::xCopyFrom( const TEncSbac* pSrc )
    405422{
    406423  m_pcBinIf->copyState( pSrc->m_pcBinIf );
    407  
    408   this->m_uiCoeffCost = pSrc->m_uiCoeffCost;
    409   this->m_uiLastQp    = pSrc->m_uiLastQp;
    410  
    411   memcpy( m_contextModels, pSrc->m_contextModels, m_numContextModels * sizeof( ContextModel ) );
     424  xCopyContextsFrom(pSrc);
    412425}
    413426
    … …  
    423436{
    424437  PartSize eSize         = pcCU->getPartitionSize( uiAbsPartIdx );
     438
    425439  if ( pcCU->isIntra( uiAbsPartIdx ) )
    426440  {
    … …  
    431445    return;
    432446  }
    433  
     447
    434448  switch(eSize)
    435449  {
    … …  
    465479      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
    466480      m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
     481
    467482      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
    468483      {
    469484        m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
    470485      }
     486
    471487      if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
    472488      {
    … …  
    496512    {
    497513      assert(0);
    498     }
    499   }
    500 }
     514      break;
     515    }
     516  }
     517}
     518
    501519
    502520/** code prediction mode
    503521 * \param pcCU
    504  * \param uiAbsPartIdx 
     522 * \param uiAbsPartIdx
    505523 * \returns Void
    506524 */
    … …  
    508526{
    509527  // get context function is here
    510   Int iPredMode = pcCU->getPredictionMode( uiAbsPartIdx );
    511   m_pcBinIf->encodeBin( iPredMode == MODE_INTER ? 0 : 1, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
     528  m_pcBinIf->encodeBin( pcCU->isIntra( uiAbsPartIdx ) ? 1 : 0, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
    512529}
    513530
    … …  
    520537/** code skip flag
    521538 * \param pcCU
    522  * \param uiAbsPartIdx 
     539 * \param uiAbsPartIdx
    523540 * \returns Void
    524541 */
    … …  
    540557/** code merge flag
    541558 * \param pcCU
    542  * \param uiAbsPartIdx 
     559 * \param uiAbsPartIdx
    543560 * \returns Void
    544561 */
    … …  
    552569  DTRACE_CABAC_V( uiSymbol );
    553570  DTRACE_CABAC_T( "\tAddress: " );
    554   DTRACE_CABAC_V( pcCU->getAddr() );
     571  DTRACE_CABAC_V( pcCU->getCtuRsAddr() );
    555572  DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
    556573  DTRACE_CABAC_V( uiAbsPartIdx );
    … …  
    560577/** code merge index
    561578 * \param pcCU
    562  * \param uiAbsPartIdx 
     579 * \param uiAbsPartIdx
    563580 * \returns Void
    564581 */
    … …  
    597614  if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    598615    return;
    599  
     616
    600617  UInt uiCtx           = pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth );
    601618  UInt uiCurrSplitFlag = ( pcCU->getDepth( uiAbsPartIdx ) > uiDepth ) ? 1 : 0;
    602  
     619
    603620  assert( uiCtx < 3 );
    604621  m_pcBinIf->encodeBin( uiCurrSplitFlag, m_cCUSplitFlagSCModel.get( 0, 0, uiCtx ) );
    … …  
    620637}
    621638
     639
    622640Void TEncSbac::codeIntraDirLumaAng( TComDataCU* pcCU, UInt absPartIdx, Bool isMultiple)
    623641{
    624642  UInt dir[4],j;
    625   Int preds[4][3] = {{-1, -1, -1},{-1, -1, -1},{-1, -1, -1},{-1, -1, -1}};
     643  Int preds[4][NUM_MOST_PROBABLE_MODES] = {{-1, -1, -1},{-1, -1, -1},{-1, -1, -1},{-1, -1, -1}};
    626644  Int predNum[4], predIdx[4] ={ -1,-1,-1,-1};
    627645  PartSize mode = pcCU->getPartitionSize( absPartIdx );
    628646  UInt partNum = isMultiple?(mode==SIZE_NxN?4:1):1;
    629   UInt partOffset = ( pcCU->getPic()->getNumPartInCU() >> ( pcCU->getDepth(absPartIdx) << 1 ) ) >> 2;
     647  UInt partOffset = ( pcCU->getPic()->getNumPartitionsInCtu() >> ( pcCU->getDepth(absPartIdx) << 1 ) ) >> 2;
    630648  for (j=0;j<partNum;j++)
    631649  {
    632     dir[j] = pcCU->getLumaIntraDir( absPartIdx+partOffset*j );
    633     predNum[j] = pcCU->getIntraDirLumaPredictor(absPartIdx+partOffset*j, preds[j]); 
     650    dir[j] = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j );
     651    predNum[j] = pcCU->getIntraDirPredictor(absPartIdx+partOffset*j, preds[j], COMPONENT_Y);
    634652    for(UInt i = 0; i < predNum[j]; i++)
    635653    {
    … …  
    640658    }
    641659    m_pcBinIf->encodeBin((predIdx[j] != -1)? 1 : 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
    642   } 
     660  }
    643661  for (j=0;j<partNum;j++)
    644662  {
    … …  
    653671    else
    654672    {
     673      assert(predNum[j]>=3); // It is currently always 3!
    655674      if (preds[j][0] > preds[j][1])
    656       { 
    657         std::swap(preds[j][0], preds[j][1]); 
     675      {
     676        std::swap(preds[j][0], preds[j][1]);
    658677      }
    659678      if (preds[j][0] > preds[j][2])
    … …  
    677696Void TEncSbac::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
    678697{
    679   UInt uiIntraDirChroma = pcCU->getChromaIntraDir( uiAbsPartIdx );
    680 
    681   if( uiIntraDirChroma == DM_CHROMA_IDX ) 
     698  UInt uiIntraDirChroma = pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx );
     699
     700  if( uiIntraDirChroma == DM_CHROMA_IDX )
    682701  {
    683702    m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
    684703  }
    685704  else
    686   {
     705  {
     706    m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
     707
    687708    UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
    688709    pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
    … …  
    696717      }
    697718    }
    698     m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
    699719
    700720    m_pcBinIf->encodeBinsEP( uiIntraDirChroma, 2 );
    701721  }
     722
    702723  return;
    703724}
     725
    704726
    705727Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
    … …  
    708730  const UInt uiCtx      = pcCU->getCtxInterDir( uiAbsPartIdx );
    709731  ContextModel *pCtx    = m_cCUInterDirSCModel.get( 0 );
     732
    710733  if (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N || pcCU->getHeight(uiAbsPartIdx) != 8 )
    711734  {
    712735    m_pcBinIf->encodeBin( uiInterDir == 2 ? 1 : 0, *( pCtx + uiCtx ) );
    713736  }
     737
    714738  if (uiInterDir < 2)
    715739  {
    716740    m_pcBinIf->encodeBin( uiInterDir, *( pCtx + 4 ) );
    717741  }
     742
    718743  return;
    719744}
    … …  
    721746Void TEncSbac::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
    722747{
    723   {
    724     Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
    725     ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
    726     m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
    727    
    728     if( iRefFrame > 0 )
    729     {
    730       UInt uiRefNum = pcCU->getSlice()->getNumRefIdx( eRefList ) - 2;
    731       pCtx++;
    732       iRefFrame--;
    733       for( UInt ui = 0; ui < uiRefNum; ++ui )
    734       {
    735         const UInt uiSymbol = ui == iRefFrame ? 0 : 1;
    736         if( ui == 0 )
    737         {
    738           m_pcBinIf->encodeBin( uiSymbol, *pCtx );       
    739         }
    740         else
    741         {
    742           m_pcBinIf->encodeBinEP( uiSymbol );
    743         }
    744         if( uiSymbol == 0 )
    745         {
    746           break;
    747         }
     748  Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
     749  ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
     750  m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
     751
     752  if( iRefFrame > 0 )
     753  {
     754    UInt uiRefNum = pcCU->getSlice()->getNumRefIdx( eRefList ) - 2;
     755    pCtx++;
     756    iRefFrame--;
     757    for( UInt ui = 0; ui < uiRefNum; ++ui )
     758    {
     759      const UInt uiSymbol = ui == iRefFrame ? 0 : 1;
     760      if( ui == 0 )
     761      {
     762        m_pcBinIf->encodeBin( uiSymbol, *pCtx );
     763      }
     764      else
     765      {
     766        m_pcBinIf->encodeBinEP( uiSymbol );
     767      }
     768      if( uiSymbol == 0 )
     769      {
     770        break;
    748771      }
    749772    }
    … …  
    802825    m_pcBinIf->encodeBinEP( 0 > iVer ? 1 : 0 );
    803826  }
    804  
     827
    805828  return;
     829}
     830
     831Void TEncSbac::codeCrossComponentPrediction( TComTU &rTu, ComponentID compID )
     832{
     833  TComDataCU *pcCU = rTu.getCU();
     834
     835  if( isLuma(compID) || !pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction() ) return;
     836
     837  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
     838
     839  if (!pcCU->isIntra(uiAbsPartIdx) || (pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx ) == DM_CHROMA_IDX))
     840  {
     841    DTRACE_CABAC_VL( g_nSymbolCounter++ )
     842    DTRACE_CABAC_T("\tparseCrossComponentPrediction()")
     843    DTRACE_CABAC_T( "\tAddr=" )
     844    DTRACE_CABAC_V( compID )
     845    DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
     846    DTRACE_CABAC_V( uiAbsPartIdx )
     847
     848    Int alpha = pcCU->getCrossComponentPredictionAlpha( uiAbsPartIdx, compID );
     849    ContextModel *pCtx = m_cCrossComponentPredictionSCModel.get(0, 0) + ((compID == COMPONENT_Cr) ? (NUM_CROSS_COMPONENT_PREDICTION_CTX >> 1) : 0);
     850    m_pcBinIf->encodeBin(((alpha != 0) ? 1 : 0), pCtx[0]);
     851
     852    if (alpha != 0)
     853    {
     854      static const Int log2AbsAlphaMinus1Table[8] = { 0, 1, 1, 2, 2, 2, 3, 3 };
     855      assert(abs(alpha) <= 8);
     856
     857      if (abs(alpha)>1)
     858      {
     859        m_pcBinIf->encodeBin(1, pCtx[1]);
     860        xWriteUnaryMaxSymbol( log2AbsAlphaMinus1Table[abs(alpha) - 1] - 1, (pCtx + 2), 1, 2 );
     861      }
     862      else
     863      {
     864        m_pcBinIf->encodeBin(0, pCtx[1]);
     865      }
     866      m_pcBinIf->encodeBin( ((alpha < 0) ? 1 : 0), pCtx[4] );
     867    }
     868    DTRACE_CABAC_T( "\tAlpha=" )
     869    DTRACE_CABAC_V( pcCU->getCrossComponentPredictionAlpha( uiAbsPartIdx, compID ) )
     870    DTRACE_CABAC_T( "\n" )
     871  }
    806872}
    807873
    … …  
    810876  Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
    811877 
    812 #if REPN_FORMAT_IN_VPS
     878#if REPN_FORMAT_IN_VPS 
    813879  Int qpBdOffsetY =  pcCU->getSlice()->getQpBDOffsetY();
    814880#else
    815   Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffsetY();
     881  Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
    816882#endif
    817883  iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
    … …  
    834900}
    835901
    836 Void TEncSbac::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
    837 {
    838   UInt uiCbf = pcCU->getCbf     ( uiAbsPartIdx, eType, uiTrDepth );
    839   UInt uiCtx = pcCU->getCtxQtCbf( eType, uiTrDepth );
    840   m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, eType ? TEXT_CHROMA : eType, uiCtx ) );
    841   DTRACE_CABAC_VL( g_nSymbolCounter++ )
    842   DTRACE_CABAC_T( "\tparseQtCbf()" )
    843   DTRACE_CABAC_T( "\tsymbol=" )
    844   DTRACE_CABAC_V( uiCbf )
    845   DTRACE_CABAC_T( "\tctx=" )
    846   DTRACE_CABAC_V( uiCtx )
    847   DTRACE_CABAC_T( "\tetype=" )
    848   DTRACE_CABAC_V( eType )
    849   DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
    850   DTRACE_CABAC_V( uiAbsPartIdx )
    851   DTRACE_CABAC_T( "\n" )
    852 }
    853 
    854 void TEncSbac::codeTransformSkipFlags (TComDataCU* pcCU, UInt uiAbsPartIdx, UInt width, UInt height, TextType eTType )
    855 {
     902/** code chroma qp adjustment, converting from the internal table representation
     903 * \returns Void
     904 */
     905Void TEncSbac::codeChromaQpAdjustment( TComDataCU* cu, UInt absPartIdx )
     906{
     907  Int internalIdc = cu->getChromaQpAdj( absPartIdx );
     908  Int tableSize = cu->getSlice()->getPPS()->getChromaQpAdjTableSize();
     909  /* internal_idc == 0 => flag = 0
     910   * internal_idc > 1 => code idc value (if table size warrents) */
     911  m_pcBinIf->encodeBin( internalIdc > 0, m_ChromaQpAdjFlagSCModel.get( 0, 0, 0 ) );
     912
     913  if (internalIdc > 0 && tableSize > 1)
     914  {
     915    xWriteUnaryMaxSymbol( internalIdc - 1, &m_ChromaQpAdjIdcSCModel.get( 0, 0, 0 ), 0, tableSize - 1 );
     916  }
     917}
     918
     919Void TEncSbac::codeQtCbf( TComTU &rTu, const ComponentID compID, const Bool lowestLevel )
     920{
     921  TComDataCU* pcCU = rTu.getCU();
     922
     923  const UInt absPartIdx   = rTu.GetAbsPartIdxTU(compID);
     924  const UInt TUDepth      = rTu.GetTransformDepthRel();
     925        UInt uiCtx        = pcCU->getCtxQtCbf( rTu, toChannelType(compID) );
     926  const UInt contextSet   = toChannelType(compID);
     927
     928  const UInt width        = rTu.getRect(compID).width;
     929  const UInt height       = rTu.getRect(compID).height;
     930  const Bool canQuadSplit = (width >= (MIN_TU_SIZE * 2)) && (height >= (MIN_TU_SIZE * 2));
     931
     932  //             Since the CBF for chroma is coded at the highest level possible, if sub-TUs are
     933  //             to be coded for a 4x8 chroma TU, their CBFs must be coded at the highest 4x8 level
     934  //             (i.e. where luma TUs are 8x8 rather than 4x4)
     935  //    ___ ___
     936  //   |   |   | <- 4 x (8x8 luma + 4x8 4:2:2 chroma)
     937  //   |___|___|    each quadrant has its own chroma CBF
     938  //   |   |   | _ _ _ _
     939  //   |___|___|        |
     940  //   <--16--->        V
     941  //                   _ _
     942  //                  |_|_| <- 4 x 4x4 luma + 1 x 4x8 4:2:2 chroma
     943  //                  |_|_|    no chroma CBF is coded - instead the parent CBF is inherited
     944  //                  <-8->    if sub-TUs are present, their CBFs had to be coded at the parent level
     945
     946  const UInt lowestTUDepth = TUDepth + ((!lowestLevel && !canQuadSplit) ? 1 : 0); //unsplittable TUs inherit their parent's CBF
     947
     948  if ((width != height) && (lowestLevel || !canQuadSplit)) //if sub-TUs are present
     949  {
     950    const UInt subTUDepth        = lowestTUDepth + 1;                      //if this is the lowest level of the TU-tree, the sub-TUs are directly below. Otherwise, this must be the level above the lowest level (as specified above)
     951    const UInt partIdxesPerSubTU = rTu.GetAbsPartIdxNumParts(compID) >> 1;
     952
     953    for (UInt subTU = 0; subTU < 2; subTU++)
     954    {
     955      const UInt subTUAbsPartIdx = absPartIdx + (subTU * partIdxesPerSubTU);
     956      const UInt uiCbf           = pcCU->getCbf(subTUAbsPartIdx, compID, subTUDepth);
     957
     958      m_pcBinIf->encodeBin(uiCbf, m_cCUQtCbfSCModel.get(0, contextSet, uiCtx));
     959
     960      DTRACE_CABAC_VL( g_nSymbolCounter++ )
     961      DTRACE_CABAC_T( "\tparseQtCbf()" )
     962      DTRACE_CABAC_T( "\tsub-TU=" )
     963      DTRACE_CABAC_V( subTU )
     964      DTRACE_CABAC_T( "\tsymbol=" )
     965      DTRACE_CABAC_V( uiCbf )
     966      DTRACE_CABAC_T( "\tctx=" )
     967      DTRACE_CABAC_V( uiCtx )
     968      DTRACE_CABAC_T( "\tetype=" )
     969      DTRACE_CABAC_V( compID )
     970      DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
     971      DTRACE_CABAC_V( subTUAbsPartIdx )
     972      DTRACE_CABAC_T( "\n" )
     973    }
     974  }
     975  else
     976  {
     977    const UInt uiCbf = pcCU->getCbf( absPartIdx, compID, lowestTUDepth );
     978    m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, contextSet, uiCtx ) );
     979
     980
     981    DTRACE_CABAC_VL( g_nSymbolCounter++ )
     982    DTRACE_CABAC_T( "\tparseQtCbf()" )
     983    DTRACE_CABAC_T( "\tsymbol=" )
     984    DTRACE_CABAC_V( uiCbf )
     985    DTRACE_CABAC_T( "\tctx=" )
     986    DTRACE_CABAC_V( uiCtx )
     987    DTRACE_CABAC_T( "\tetype=" )
     988    DTRACE_CABAC_V( compID )
     989    DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
     990    DTRACE_CABAC_V( rTu.GetAbsPartIdxTU(compID) )
     991    DTRACE_CABAC_T( "\n" )
     992  }
     993}
     994
     995
     996Void TEncSbac::codeTransformSkipFlags (TComTU &rTu, ComponentID component )
     997{
     998  TComDataCU* pcCU=rTu.getCU();
     999  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
     1000
    8561001  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
    8571002  {
    8581003    return;
    8591004  }
    860   if(width != 4 || height != 4)
     1005
     1006  if (!TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(component), pcCU->getSlice()->getPPS()->getTransformSkipLog2MaxSize()))
    8611007  {
    8621008    return;
    8631009  }
    8641010
    865   UInt useTransformSkip = pcCU->getTransformSkip( uiAbsPartIdx,eTType);
    866   m_pcBinIf->encodeBin( useTransformSkip, m_cTransformSkipSCModel.get( 0, eTType? TEXT_CHROMA: TEXT_LUMA, 0 ) );
     1011  UInt useTransformSkip = pcCU->getTransformSkip( uiAbsPartIdx,component);
     1012  m_pcBinIf->encodeBin( useTransformSkip, m_cTransformSkipSCModel.get( 0, toChannelType(component), 0 ) );
     1013
    8671014  DTRACE_CABAC_VL( g_nSymbolCounter++ )
    8681015  DTRACE_CABAC_T("\tparseTransformSkip()");
    … …  
    8701017  DTRACE_CABAC_V( useTransformSkip )
    8711018  DTRACE_CABAC_T( "\tAddr=" )
    872   DTRACE_CABAC_V( pcCU->getAddr() )
     1019  DTRACE_CABAC_V( pcCU->getCtuRsAddr() )
    8731020  DTRACE_CABAC_T( "\tetype=" )
    874   DTRACE_CABAC_V( eTType )
     1021  DTRACE_CABAC_V( component )
    8751022  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
    876   DTRACE_CABAC_V( uiAbsPartIdx )
     1023  DTRACE_CABAC_V( rTu.GetAbsPartIdxTU() )
    8771024  DTRACE_CABAC_T( "\n" )
    8781025}
     1026
    8791027
    8801028/** Code I_PCM information.
    … …  
    8951043    m_pcBinIf->encodePCMAlignBits();
    8961044
    897     UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
    898     UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
    899     UInt uiChromaOffset = uiLumaOffset>>2;
    900     Pel* piPCMSample;
    901     UInt uiWidth;
    902     UInt uiHeight;
    903     UInt uiSampleBits;
    904     UInt uiX, uiY;
    905 
    906     piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
    907     uiWidth = pcCU->getWidth(uiAbsPartIdx);
    908     uiHeight = pcCU->getHeight(uiAbsPartIdx);
    909     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
    910 
    911     for(uiY = 0; uiY < uiHeight; uiY++)
    912     {
    913       for(uiX = 0; uiX < uiWidth; uiX++)
    914       {
    915         UInt uiSample = piPCMSample[uiX];
    916 
    917         m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
    918       }
    919       piPCMSample += uiWidth;
    920     }
    921 
    922 #if AUXILIARY_PICTURES
    923     if (pcCU->getSlice()->getChromaFormatIdc() != CHROMA_400)
    924     {
    925 #endif
    926     piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
    927     uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
    928     uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
    929     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
    930 
    931     for(uiY = 0; uiY < uiHeight; uiY++)
    932     {
    933       for(uiX = 0; uiX < uiWidth; uiX++)
    934       {
    935         UInt uiSample = piPCMSample[uiX];
    936 
    937         m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
    938       }
    939       piPCMSample += uiWidth;
    940     }
    941 
    942     piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
    943     uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
    944     uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
    945     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
    946 
    947     for(uiY = 0; uiY < uiHeight; uiY++)
    948     {
    949       for(uiX = 0; uiX < uiWidth; uiX++)
    950       {
    951         UInt uiSample = piPCMSample[uiX];
    952 
    953         m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
    954       }
    955       piPCMSample += uiWidth;
    956     }
    957 #if AUXILIARY_PICTURES
    958     }
    959 #endif
     1045    const UInt minCoeffSizeY = pcCU->getPic()->getMinCUWidth() * pcCU->getPic()->getMinCUHeight();
     1046    const UInt offsetY       = minCoeffSizeY * uiAbsPartIdx;
     1047    for (UInt ch=0; ch < pcCU->getPic()->getNumberValidComponents(); ch++)
     1048    {
     1049      const ComponentID compID = ComponentID(ch);
     1050      const UInt offset = offsetY >> (pcCU->getPic()->getComponentScaleX(compID) + pcCU->getPic()->getComponentScaleY(compID));
     1051      Pel * pPCMSample  = pcCU->getPCMSample(compID) + offset;
     1052      const UInt width  = pcCU->getWidth (uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleX(compID);
     1053      const UInt height = pcCU->getHeight(uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleY(compID);
     1054      const UInt sampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepth(toChannelType(compID));
     1055      for (UInt y=0; y<height; y++)
     1056      {
     1057        for (UInt x=0; x<width; x++)
     1058        {
     1059          UInt sample = pPCMSample[x];
     1060          m_pcBinIf->xWritePCMCode(sample, sampleBits);
     1061        }
     1062        pPCMSample += width;
     1063      }
     1064    }
     1065
    9601066    m_pcBinIf->resetBac();
    9611067  }
    … …  
    9781084}
    9791085
    980 Void TEncSbac::codeQtCbfZero( TComDataCU* pcCU, TextType eType, UInt uiTrDepth )
     1086Void TEncSbac::codeQtCbfZero( TComTU & rTu, const ChannelType chType )
    9811087{
    9821088  // this function is only used to estimate the bits when cbf is 0
    9831089  // and will never be called when writing the bistream. do not need to write log
    9841090  UInt uiCbf = 0;
    985   UInt uiCtx = pcCU->getCtxQtCbf( eType, uiTrDepth );
    986   m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, eType ? TEXT_CHROMA : eType, uiCtx ) );
     1091  UInt uiCtx = rTu.getCU()->getCtxQtCbf( rTu, chType );
     1092
     1093  m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, chType, uiCtx ) );
    9871094}
    9881095
    … …  
    10051112 * This method encodes the X and Y component within a block of the last significant coefficient.
    10061113 */
    1007 Void TEncSbac::codeLastSignificantXY( UInt uiPosX, UInt uiPosY, Int width, Int height, TextType eTType, UInt uiScanIdx )
    1008 { 
     1114Void TEncSbac::codeLastSignificantXY( UInt uiPosX, UInt uiPosY, Int width, Int height, ComponentID component, UInt uiScanIdx )
     1115{
    10091116  // swap
    10101117  if( uiScanIdx == SCAN_VER )
    10111118  {
    10121119    swap( uiPosX, uiPosY );
     1120    swap( width,  height );
    10131121  }
    10141122
    10151123  UInt uiCtxLast;
    1016   ContextModel *pCtxX = m_cCuCtxLastX.get( 0, eTType );
    1017   ContextModel *pCtxY = m_cCuCtxLastY.get( 0, eTType );
    10181124  UInt uiGroupIdxX    = g_uiGroupIdx[ uiPosX ];
    10191125  UInt uiGroupIdxY    = g_uiGroupIdx[ uiPosY ];
    10201126
     1127  ContextModel *pCtxX = m_cCuCtxLastX.get( 0, toChannelType(component) );
     1128  ContextModel *pCtxY = m_cCuCtxLastY.get( 0, toChannelType(component) );
    10211129
    10221130  Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
    1023   blkSizeOffsetX = eTType ? 0: (g_aucConvertToBit[ width ] *3 + ((g_aucConvertToBit[ width ] +1)>>2));
    1024   blkSizeOffsetY = eTType ? 0: (g_aucConvertToBit[ height ]*3 + ((g_aucConvertToBit[ height ]+1)>>2));
    1025   shiftX= eTType ? g_aucConvertToBit[ width  ] :((g_aucConvertToBit[ width  ]+3)>>2);
    1026   shiftY= eTType ? g_aucConvertToBit[ height ] :((g_aucConvertToBit[ height ]+3)>>2);
     1131  getLastSignificantContextParameters(component, width, height, blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY);
     1132
     1133  //------------------
     1134
    10271135  // posX
     1136
    10281137  for( uiCtxLast = 0; uiCtxLast < uiGroupIdxX; uiCtxLast++ )
    10291138  {
    1030       m_pcBinIf->encodeBin( 1, *( pCtxX + blkSizeOffsetX + (uiCtxLast >>shiftX) ) );
     1139    m_pcBinIf->encodeBin( 1, *( pCtxX + blkSizeOffsetX + (uiCtxLast >>shiftX) ) );
    10311140  }
    10321141  if( uiGroupIdxX < g_uiGroupIdx[ width - 1 ])
    10331142  {
    1034       m_pcBinIf->encodeBin( 0, *( pCtxX + blkSizeOffsetX + (uiCtxLast >>shiftX) ) );
     1143    m_pcBinIf->encodeBin( 0, *( pCtxX + blkSizeOffsetX + (uiCtxLast >>shiftX) ) );
    10351144  }
    10361145
    10371146  // posY
     1147
    10381148  for( uiCtxLast = 0; uiCtxLast < uiGroupIdxY; uiCtxLast++ )
    10391149  {
    … …  
    10441154    m_pcBinIf->encodeBin( 0, *( pCtxY + blkSizeOffsetY + (uiCtxLast >>shiftY) ) );
    10451155  }
     1156
     1157  // EP-coded part
     1158
    10461159  if ( uiGroupIdxX > 3 )
    1047   {     
     1160  {
    10481161    UInt uiCount = ( uiGroupIdxX - 2 ) >> 1;
    10491162    uiPosX       = uiPosX - g_uiMinInGroup[ uiGroupIdxX ];
    … …  
    10541167  }
    10551168  if ( uiGroupIdxY > 3 )
    1056   {     
     1169  {
    10571170    UInt uiCount = ( uiGroupIdxY - 2 ) >> 1;
    10581171    uiPosY       = uiPosY - g_uiMinInGroup[ uiGroupIdxY ];
    … …  
    10641177}
    10651178
    1066 Void TEncSbac::codeCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
    1067 {
     1179
     1180Void TEncSbac::codeCoeffNxN( TComTU &rTu, TCoeff* pcCoef, const ComponentID compID )
     1181{
     1182  TComDataCU* pcCU=rTu.getCU();
     1183  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU(compID);
     1184  const TComRectangle &tuRect=rTu.getRect(compID);
     1185  const UInt uiWidth=tuRect.width;
     1186  const UInt uiHeight=tuRect.height;
     1187
    10681188  DTRACE_CABAC_VL( g_nSymbolCounter++ )
    10691189  DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
    1070   DTRACE_CABAC_V( eTType )
     1190  DTRACE_CABAC_V( compID )
    10711191  DTRACE_CABAC_T( "\twidth=" )
    10721192  DTRACE_CABAC_V( uiWidth )
    … …  
    10741194  DTRACE_CABAC_V( uiHeight )
    10751195  DTRACE_CABAC_T( "\tdepth=" )
    1076   DTRACE_CABAC_V( uiDepth )
     1196//  DTRACE_CABAC_V( rTu.GetTransformDepthTotalAdj(compID) )
     1197  DTRACE_CABAC_V( rTu.GetTransformDepthTotal() )
    10771198  DTRACE_CABAC_T( "\tabspartidx=" )
    10781199  DTRACE_CABAC_V( uiAbsPartIdx )
    … …  
    10821203  DTRACE_CABAC_V( pcCU->getCUPelY() )
    10831204  DTRACE_CABAC_T( "\tCU-addr=" )
    1084   DTRACE_CABAC_V(  pcCU->getAddr() )
     1205  DTRACE_CABAC_V(  pcCU->getCtuRsAddr() )
    10851206  DTRACE_CABAC_T( "\tinCU-X=" )
    1086   DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
     1207//  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
     1208  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
    10871209  DTRACE_CABAC_T( "\tinCU-Y=" )
    1088   DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
     1210// DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
     1211  DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
    10891212  DTRACE_CABAC_T( "\tpredmode=" )
    10901213  DTRACE_CABAC_V(  pcCU->getPredictionMode( uiAbsPartIdx ) )
    10911214  DTRACE_CABAC_T( "\n" )
    10921215
     1216  //--------------------------------------------------------------------------------------------------
     1217
    10931218  if( uiWidth > m_pcSlice->getSPS()->getMaxTrSize() )
    10941219  {
    1095     uiWidth  = m_pcSlice->getSPS()->getMaxTrSize();
    1096     uiHeight = m_pcSlice->getSPS()->getMaxTrSize();
    1097   }
    1098  
    1099   UInt uiNumSig = 0;
    1100  
     1220    std::cerr << "ERROR: codeCoeffNxN was passed a TU with dimensions larger than the maximum allowed size" << std::endl;
     1221    assert(false);
     1222    exit(1);
     1223  }
     1224
    11011225  // compute number of significant coefficients
    1102   uiNumSig = TEncEntropy::countNonZeroCoeffs(pcCoef, uiWidth * uiHeight);
    1103  
     1226  UInt uiNumSig = TEncEntropy::countNonZeroCoeffs(pcCoef, uiWidth * uiHeight);
     1227
    11041228  if ( uiNumSig == 0 )
    1105     return;
     1229  {
     1230    std::cerr << "ERROR: codeCoeffNxN called for empty TU!" << std::endl;
     1231    assert(false);
     1232    exit(1);
     1233  }
     1234
     1235  //--------------------------------------------------------------------------------------------------
     1236
     1237  //set parameters
     1238
     1239  const ChannelType  chType            = toChannelType(compID);
     1240  const UInt         uiLog2BlockWidth  = g_aucConvertToBit[ uiWidth  ] + 2;
     1241  const UInt         uiLog2BlockHeight = g_aucConvertToBit[ uiHeight ] + 2;
     1242
     1243  const ChannelType  channelType       = toChannelType(compID);
     1244  const Bool         extendedPrecision = pcCU->getSlice()->getSPS()->getUseExtendedPrecision();
     1245
     1246  const Bool         alignCABACBeforeBypass = pcCU->getSlice()->getSPS()->getAlignCABACBeforeBypass();
     1247
     1248  Bool beValid;
     1249
     1250  {
     1251    Int uiIntraMode = -1;
     1252    const Bool       bIsLuma = isLuma(compID);
     1253    Int isIntra = pcCU->isIntra(uiAbsPartIdx) ? 1 : 0;
     1254    if ( isIntra )
     1255    {
     1256      uiIntraMode = pcCU->getIntraDir( toChannelType(compID), uiAbsPartIdx );
     1257
     1258      uiIntraMode = (uiIntraMode==DM_CHROMA_IDX && !bIsLuma) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, rTu.GetChromaFormat())) : uiIntraMode;
     1259      uiIntraMode = ((rTu.GetChromaFormat() == CHROMA_422) && !bIsLuma) ? g_chroma422IntraAngleMappingTable[uiIntraMode] : uiIntraMode;
     1260    }
     1261
     1262    Int transformSkip = pcCU->getTransformSkip( uiAbsPartIdx,compID) ? 1 : 0;
     1263    Bool rdpcm_lossy = ( transformSkip && isIntra && ( (uiIntraMode == HOR_IDX) || (uiIntraMode == VER_IDX) ) ) && pcCU->isRDPCMEnabled(uiAbsPartIdx);
     1264
     1265    if ( (pcCU->getCUTransquantBypass(uiAbsPartIdx)) || rdpcm_lossy )
     1266    {
     1267      beValid = false;
     1268      if ( (!pcCU->isIntra(uiAbsPartIdx)) && pcCU->isRDPCMEnabled(uiAbsPartIdx))
     1269        codeExplicitRdpcmMode( rTu, compID);
     1270    }
     1271    else
     1272    {
     1273      beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
     1274    }
     1275  }
     1276
     1277  //--------------------------------------------------------------------------------------------------
     1278
    11061279  if(pcCU->getSlice()->getPPS()->getUseTransformSkip())
    11071280  {
    1108     codeTransformSkipFlags( pcCU,uiAbsPartIdx, uiWidth, uiHeight, eTType );
    1109   }
    1110   eTType = eTType == TEXT_LUMA ? TEXT_LUMA : ( eTType == TEXT_NONE ? TEXT_NONE : TEXT_CHROMA );
    1111  
     1281    codeTransformSkipFlags(rTu, compID);
     1282    if(pcCU->getTransformSkip(uiAbsPartIdx, compID) && !pcCU->isIntra(uiAbsPartIdx) && pcCU->isRDPCMEnabled(uiAbsPartIdx))
     1283    {
     1284      //  This TU has coefficients and is transform skipped. Check whether is inter coded and if yes encode the explicit RDPCM mode
     1285      codeExplicitRdpcmMode( rTu, compID);
     1286
     1287      if(pcCU->getExplicitRdpcmMode(compID, uiAbsPartIdx) != RDPCM_OFF)
     1288      {
     1289        //  Sign data hiding is avoided for horizontal and vertical explicit RDPCM modes
     1290        beValid = false;
     1291      }
     1292    }
     1293  }
     1294
     1295  //--------------------------------------------------------------------------------------------------
     1296
     1297  const Bool  bUseGolombRiceParameterAdaptation = pcCU->getSlice()->getSPS()->getUseGolombRiceParameterAdaptation();
     1298        UInt &currentGolombRiceStatistic        = m_golombRiceAdaptationStatistics[rTu.getGolombRiceStatisticsIndex(compID)];
     1299
     1300  //select scans
     1301  TUEntropyCodingParameters codingParameters;
     1302  getTUEntropyCodingParameters(codingParameters, rTu, compID);
     1303
    11121304  //----- encode significance map -----
    1113   const UInt   uiLog2BlockSize = g_aucConvertToBit[ uiWidth ] + 2;
    1114   UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
    1115   const UInt *scan = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize - 1 ];
    1116  
    1117   Bool beValid;
    1118   if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
    1119   {
    1120     beValid = false;
    1121   }
    1122   else
    1123   {
    1124     beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
    1125   }
    11261305
    11271306  // Find position of last coefficient
    … …  
    11291308  Int posLast;
    11301309
    1131   const UInt * scanCG;
    1132   {
    1133     scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize > 3 ? uiLog2BlockSize-2-1 : 0 ];
    1134     if( uiLog2BlockSize == 3 )
    1135     {
    1136       scanCG = g_sigLastScan8x8[ uiScanIdx ];
    1137     }
    1138     else if( uiLog2BlockSize == 5 )
    1139     {
    1140       scanCG = g_sigLastScanCG32x32;
    1141     }
    1142   }
     1310
    11431311  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
    1144   static const UInt uiShift = MLS_CG_SIZE >> 1;
    1145   const UInt uiNumBlkSide = uiWidth >> uiShift;
    1146 
    1147     ::memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
    1148 
    1149     do
    1150     {
    1151       posLast = scan[ ++scanPosLast ];
    1152 
     1312
     1313  memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
     1314  do
     1315  {
     1316    posLast = codingParameters.scan[ ++scanPosLast ];
     1317
     1318    if( pcCoef[ posLast ] != 0 )
     1319    {
    11531320      // get L1 sig map
    1154       UInt uiPosY    = posLast >> uiLog2BlockSize;
    1155       UInt uiPosX    = posLast - ( uiPosY << uiLog2BlockSize );
    1156       UInt uiBlkIdx  = uiNumBlkSide * (uiPosY >> uiShift) + (uiPosX >> uiShift);
    1157       if( pcCoef[ posLast ] )
    1158       {
    1159         uiSigCoeffGroupFlag[ uiBlkIdx ] = 1;
    1160       }
    1161 
    1162       uiNumSig -= ( pcCoef[ posLast ] != 0 );
    1163     }
    1164     while ( uiNumSig > 0 );
     1321      UInt uiPosY   = posLast >> uiLog2BlockWidth;
     1322      UInt uiPosX   = posLast - ( uiPosY << uiLog2BlockWidth );
     1323
     1324      UInt uiBlkIdx = (codingParameters.widthInGroups * (uiPosY >> MLS_CG_LOG2_HEIGHT)) + (uiPosX >> MLS_CG_LOG2_WIDTH);
     1325      uiSigCoeffGroupFlag[ uiBlkIdx ] = 1;
     1326
     1327      uiNumSig--;
     1328    }
     1329  }
     1330  while ( uiNumSig > 0 );
    11651331
    11661332  // Code position of last coefficient
    1167   Int posLastY = posLast >> uiLog2BlockSize;
    1168   Int posLastX = posLast - ( posLastY << uiLog2BlockSize );
    1169   codeLastSignificantXY(posLastX, posLastY, uiWidth, uiHeight, eTType, uiScanIdx);
    1170  
     1333  Int posLastY = posLast >> uiLog2BlockWidth;
     1334  Int posLastX = posLast - ( posLastY << uiLog2BlockWidth );
     1335  codeLastSignificantXY(posLastX, posLastY, uiWidth, uiHeight, compID, codingParameters.scanType);
     1336
    11711337  //===== code significance flag =====
    1172   ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, eTType );
    1173   ContextModel * const baseCtx = (eTType==TEXT_LUMA) ? m_cCUSigSCModel.get( 0, 0 ) : m_cCUSigSCModel.get( 0, 0 ) + NUM_SIG_FLAG_CTX_LUMA;
    1174 
    1175 
    1176   const Int  iLastScanSet      = scanPosLast >> LOG2_SCAN_SET_SIZE;
    1177   UInt c1 = 1;
    1178   UInt uiGoRiceParam           = 0;
    1179   Int  iScanPosSig             = scanPosLast;
     1338  ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, chType );
     1339  ContextModel * const baseCtx = m_cCUSigSCModel.get( 0, 0 ) + getSignificanceMapContextOffset(compID);
     1340
     1341  const Int  iLastScanSet  = scanPosLast >> MLS_CG_SIZE;
     1342
     1343  UInt c1                  = 1;
     1344  UInt uiGoRiceParam       = 0;
     1345  Int  iScanPosSig         = scanPosLast;
    11801346
    11811347  for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
    11821348  {
    11831349    Int numNonZero = 0;
    1184     Int  iSubPos     = iSubSet << LOG2_SCAN_SET_SIZE;
    1185     uiGoRiceParam    = 0;
    1186     Int absCoeff[16];
     1350    Int  iSubPos   = iSubSet << MLS_CG_SIZE;
     1351    uiGoRiceParam  = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
     1352    Bool updateGolombRiceStatistics = bUseGolombRiceParameterAdaptation; //leave the statistics at 0 when not using the adaptation system
    11871353    UInt coeffSigns = 0;
    11881354
    1189     Int lastNZPosInCG = -1, firstNZPosInCG = SCAN_SET_SIZE;
     1355    Int absCoeff[1 << MLS_CG_SIZE];
     1356
     1357    Int lastNZPosInCG  = -1;
     1358    Int firstNZPosInCG = 1 << MLS_CG_SIZE;
     1359
     1360    Bool escapeDataPresentInGroup = false;
    11901361
    11911362    if( iScanPosSig == scanPosLast )
    11921363    {
    1193       absCoeff[ 0 ] = abs( pcCoef[ posLast ] );
     1364      absCoeff[ 0 ] = Int(abs( pcCoef[ posLast ] ));
    11941365      coeffSigns    = ( pcCoef[ posLast ] < 0 );
    11951366      numNonZero    = 1;
    … …  
    11991370    }
    12001371
    1201       // encode significant_coeffgroup_flag
    1202       Int iCGBlkPos = scanCG[ iSubSet ];
    1203       Int iCGPosY   = iCGBlkPos / uiNumBlkSide;
    1204       Int iCGPosX   = iCGBlkPos - (iCGPosY * uiNumBlkSide);
    1205       if( iSubSet == iLastScanSet || iSubSet == 0)
    1206       {
    1207         uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
    1208       }
    1209       else
    1210       {
    1211           UInt uiSigCoeffGroup   = (uiSigCoeffGroupFlag[ iCGBlkPos ] != 0);
    1212           UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight );
    1213           m_pcBinIf->encodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
    1214       }
    1215      
    1216       // encode significant_coeff_flag
    1217       if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
    1218       {
    1219         Int patternSigCtx = TComTrQuant::calcPatternSigCtx( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight );
    1220         UInt uiBlkPos, uiPosY, uiPosX, uiSig, uiCtxSig;
    1221         for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
     1372    // encode significant_coeffgroup_flag
     1373    Int iCGBlkPos = codingParameters.scanCG[ iSubSet ];
     1374    Int iCGPosY   = iCGBlkPos / codingParameters.widthInGroups;
     1375    Int iCGPosX   = iCGBlkPos - (iCGPosY * codingParameters.widthInGroups);
     1376
     1377    if( iSubSet == iLastScanSet || iSubSet == 0)
     1378    {
     1379      uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
     1380    }
     1381    else
     1382    {
     1383      UInt uiSigCoeffGroup   = (uiSigCoeffGroupFlag[ iCGBlkPos ] != 0);
     1384      UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups );
     1385      m_pcBinIf->encodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
     1386    }
     1387
     1388    // encode significant_coeff_flag
     1389    if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
     1390    {
     1391      const Int patternSigCtx = TComTrQuant::calcPatternSigCtx(uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups);
     1392
     1393      UInt uiBlkPos, uiSig, uiCtxSig;
     1394      for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
     1395      {
     1396        uiBlkPos  = codingParameters.scan[ iScanPosSig ];
     1397        uiSig     = (pcCoef[ uiBlkPos ] != 0);
     1398        if( iScanPosSig > iSubPos || iSubSet == 0 || numNonZero )
    12221399        {
    1223           uiBlkPos  = scan[ iScanPosSig ];
    1224           uiPosY    = uiBlkPos >> uiLog2BlockSize;
    1225           uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
    1226           uiSig     = (pcCoef[ uiBlkPos ] != 0);
    1227           if( iScanPosSig > iSubPos || iSubSet == 0 || numNonZero )
     1400          uiCtxSig  = TComTrQuant::getSigCtxInc( patternSigCtx, codingParameters, iScanPosSig, uiLog2BlockWidth, uiLog2BlockHeight, chType );
     1401          m_pcBinIf->encodeBin( uiSig, baseCtx[ uiCtxSig ] );
     1402        }
     1403        if( uiSig )
     1404        {
     1405          absCoeff[ numNonZero ] = Int(abs( pcCoef[ uiBlkPos ] ));
     1406          coeffSigns = 2 * coeffSigns + ( pcCoef[ uiBlkPos ] < 0 );
     1407          numNonZero++;
     1408          if( lastNZPosInCG == -1 )
    12281409          {
    1229             uiCtxSig  = TComTrQuant::getSigCtxInc( patternSigCtx, uiScanIdx, uiPosX, uiPosY, uiLog2BlockSize, eTType );
    1230             m_pcBinIf->encodeBin( uiSig, baseCtx[ uiCtxSig ] );
     1410            lastNZPosInCG = iScanPosSig;
    12311411          }
    1232           if( uiSig )
    1233           {
    1234             absCoeff[ numNonZero ] = abs( pcCoef[ uiBlkPos ] );
    1235             coeffSigns = 2 * coeffSigns + ( pcCoef[ uiBlkPos ] < 0 );
    1236             numNonZero++;
    1237             if( lastNZPosInCG == -1 )
    1238             {
    1239               lastNZPosInCG = iScanPosSig;
    1240             }
    1241             firstNZPosInCG = iScanPosSig;
    1242           }
     1412          firstNZPosInCG = iScanPosSig;
    12431413        }
    12441414      }
    1245       else
    1246       {
    1247         iScanPosSig = iSubPos - 1;
    1248       }
     1415    }
     1416    else
     1417    {
     1418      iScanPosSig = iSubPos - 1;
     1419    }
    12491420
    12501421    if( numNonZero > 0 )
    12511422    {
    12521423      Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= SBH_THRESHOLD );
    1253       UInt uiCtxSet = (iSubSet > 0 && eTType==TEXT_LUMA) ? 2 : 0;
    1254      
    1255       if( c1 == 0 )
    1256       {
    1257         uiCtxSet++;
    1258       }
     1424
     1425      const UInt uiCtxSet = getContextSetIndex(compID, iSubSet, (c1 == 0));
    12591426      c1 = 1;
    1260       ContextModel *baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUOneSCModel.get( 0, 0 ) + 4 * uiCtxSet : m_cCUOneSCModel.get( 0, 0 ) + NUM_ONE_FLAG_CTX_LUMA + 4 * uiCtxSet;
    1261      
     1427
     1428      ContextModel *baseCtxMod = m_cCUOneSCModel.get( 0, 0 ) + (NUM_ONE_FLAG_CTX_PER_SET * uiCtxSet);
     1429
    12621430      Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
    12631431      Int firstC2FlagIdx = -1;
    … …  
    12731441          {
    12741442            firstC2FlagIdx = idx;
     1443          }
     1444          else //if a greater-than-one has been encountered already this group
     1445          {
     1446            escapeDataPresentInGroup = true;
    12751447          }
    12761448        }
    … …  
    12801452        }
    12811453      }
    1282      
     1454
    12831455      if (c1 == 0)
    12841456      {
    1285 
    1286         baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + uiCtxSet;
     1457        baseCtxMod = m_cCUAbsSCModel.get( 0, 0 ) + (NUM_ABS_FLAG_CTX_PER_SET * uiCtxSet);
    12871458        if ( firstC2FlagIdx != -1)
    12881459        {
    12891460          UInt symbol = absCoeff[ firstC2FlagIdx ] > 2;
    12901461          m_pcBinIf->encodeBin( symbol, baseCtxMod[0] );
     1462          if (symbol != 0)
     1463          {
     1464            escapeDataPresentInGroup = true;
     1465          }
    12911466        }
    12921467      }
    1293      
     1468
     1469      escapeDataPresentInGroup = escapeDataPresentInGroup || (numNonZero > C1FLAG_NUMBER);
     1470
     1471      if (escapeDataPresentInGroup && alignCABACBeforeBypass)
     1472      {
     1473        m_pcBinIf->align();
     1474      }
     1475
    12941476      if( beValid && signHidden )
    12951477      {
    … …  
    13001482        m_pcBinIf->encodeBinsEP( coeffSigns, numNonZero );
    13011483      }
    1302      
    1303       Int iFirstCoeff2 = 1;   
    1304       if (c1 == 0 || numNonZero > C1FLAG_NUMBER)
     1484
     1485      Int iFirstCoeff2 = 1;
     1486      if (escapeDataPresentInGroup)
    13051487      {
    13061488        for ( Int idx = 0; idx < numNonZero; idx++ )
    … …  
    13101492          if( absCoeff[ idx ] >= baseLevel)
    13111493          {
    1312             xWriteCoefRemainExGolomb( absCoeff[ idx ] - baseLevel, uiGoRiceParam );
    1313             if(absCoeff[idx] > 3*(1<<uiGoRiceParam))
     1494            const UInt escapeCodeValue = absCoeff[idx] - baseLevel;
     1495
     1496            xWriteCoefRemainExGolomb( escapeCodeValue, uiGoRiceParam, extendedPrecision, channelType );
     1497
     1498            if (absCoeff[idx] > (3 << uiGoRiceParam))
    13141499            {
    1315                uiGoRiceParam = min<UInt>(uiGoRiceParam+ 1, 4);
     1500              uiGoRiceParam = bUseGolombRiceParameterAdaptation ? (uiGoRiceParam + 1) : (std::min<UInt>((uiGoRiceParam + 1), 4));
     1501            }
     1502
     1503            if (updateGolombRiceStatistics)
     1504            {
     1505              const UInt initialGolombRiceParameter = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
     1506
     1507              if (escapeCodeValue >= (3 << initialGolombRiceParameter))
     1508              {
     1509                currentGolombRiceStatistic++;
     1510              }
     1511              else if (((escapeCodeValue * 2) < (1 << initialGolombRiceParameter)) && (currentGolombRiceStatistic > 0))
     1512              {
     1513                currentGolombRiceStatistic--;
     1514              }
     1515
     1516              updateGolombRiceStatistics = false;
    13161517            }
    13171518          }
    1318           if(absCoeff[ idx ] >= 2) 
     1519
     1520          if(absCoeff[ idx ] >= 2)
    13191521          {
    13201522            iFirstCoeff2 = 0;
    13211523          }
    1322         }       
    1323       }
    1324     }
    1325   }
     1524        }
     1525      }
     1526    }
     1527  }
     1528#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
     1529  printSBACCoeffData(posLastX, posLastY, uiWidth, uiHeight, compID, uiAbsPartIdx, codingParameters.scanType, pcCoef, g_bFinalEncode);
     1530#endif
    13261531
    13271532  return;
    … …  
    13641569}
    13651570
    1366 
    1367 /** Code SAO EO class or BO band position
     1571/** Code SAO EO class or BO band position
    13681572 * \param uiLength
    13691573 * \param uiCode
    … …  
    13711575Void TEncSbac::codeSaoUflc       ( UInt uiLength, UInt uiCode )
    13721576{
    1373    m_pcBinIf->encodeBinsEP ( uiCode, uiLength );
    1374 }
     1577  m_pcBinIf->encodeBinsEP ( uiCode, uiLength );
     1578}
     1579
    13751580/** Code SAO merge flags
    13761581 * \param uiCode
    … …  
    13791584Void TEncSbac::codeSaoMerge       ( UInt uiCode )
    13801585{
    1381   if (uiCode == 0)
    1382   {
    1383     m_pcBinIf->encodeBin(0,  m_cSaoMergeSCModel.get( 0, 0, 0 ));
    1384   }
    1385   else
    1386   {
    1387     m_pcBinIf->encodeBin(1,  m_cSaoMergeSCModel.get( 0, 0, 0 ));
    1388   }
    1389 }
    1390 /** Code SAO type index
     1586  m_pcBinIf->encodeBin(((uiCode == 0) ? 0 : 1),  m_cSaoMergeSCModel.get( 0, 0, 0 ));
     1587}
     1588
     1589/** Code SAO type index
    13911590 * \param uiCode
    13921591 */
    … …  
    14031602  }
    14041603}
    1405 /*!
    1406  ****************************************************************************
    1407  * \brief
    1408  *   estimate bit cost for CBP, significant map and significant coefficients
    1409  ****************************************************************************
    1410  */
    1411 Void TEncSbac::estBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType )
    1412 {
    1413   estCBFBit( pcEstBitsSbac );
    1414 
    1415   estSignificantCoeffGroupMapBit( pcEstBitsSbac, eTType );
    1416  
    1417   // encode significance map
    1418   estSignificantMapBit( pcEstBitsSbac, width, height, eTType );
    1419  
    1420   // encode significant coefficients
    1421   estSignificantCoefficientsBit( pcEstBitsSbac, eTType );
    1422 }
    1423 
    1424 /*!
    1425  ****************************************************************************
    1426  * \brief
    1427  *    estimate bit cost for each CBP bit
    1428  ****************************************************************************
    1429  */
    1430 Void TEncSbac::estCBFBit( estBitsSbacStruct* pcEstBitsSbac )
    1431 {
    1432   ContextModel *pCtx = m_cCUQtCbfSCModel.get( 0 );
    1433 
    1434   for( UInt uiCtxInc = 0; uiCtxInc < 3*NUM_QT_CBF_CTX; uiCtxInc++ )
    1435   {
    1436     pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
    1437     pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
    1438   }
    1439 
    1440   pCtx = m_cCUQtRootCbfSCModel.get( 0 );
    1441  
    1442   for( UInt uiCtxInc = 0; uiCtxInc < 4; uiCtxInc++ )
    1443   {
    1444     pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
    1445     pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
    1446   }
    1447 }
    1448 
    1449 
    1450 /*!
    1451  ****************************************************************************
    1452  * \brief
    1453  *    estimate SAMBAC bit cost for significant coefficient group map
    1454  ****************************************************************************
    1455  */
    1456 Void TEncSbac::estSignificantCoeffGroupMapBit( estBitsSbacStruct* pcEstBitsSbac, TextType eTType )
    1457 {
    1458   Int firstCtx = 0, numCtx = NUM_SIG_CG_FLAG_CTX;
    1459 
    1460   for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
    1461   {
    1462     for( UInt uiBin = 0; uiBin < 2; uiBin++ )
    1463     {
    1464       pcEstBitsSbac->significantCoeffGroupBits[ ctxIdx ][ uiBin ] = m_cCUSigCoeffGroupSCModel.get(  0, eTType, ctxIdx ).getEntropyBits( uiBin );
    1465     }
    1466   }
    1467 }
    1468 
    1469 
    1470 /*!
    1471  ****************************************************************************
    1472  * \brief
    1473  *    estimate SAMBAC bit cost for significant coefficient map
    1474  ****************************************************************************
    1475  */
    1476 Void TEncSbac::estSignificantMapBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType )
    1477 {
    1478   Int firstCtx = 1, numCtx = 8;
    1479   if (max(width, height) >= 16)
    1480   {
    1481     firstCtx = (eTType == TEXT_LUMA) ? 21 : 12;
    1482     numCtx = (eTType == TEXT_LUMA) ? 6 : 3;
    1483   }
    1484   else if (width == 8)
    1485   {
    1486     firstCtx = 9;
    1487     numCtx = (eTType == TEXT_LUMA) ? 12 : 3;
    1488   }
    1489  
    1490   if (eTType == TEXT_LUMA )
    1491   {
    1492     for( UInt bin = 0; bin < 2; bin++ )
    1493     {
    1494       pcEstBitsSbac->significantBits[ 0 ][ bin ] = m_cCUSigSCModel.get(  0, 0, 0 ).getEntropyBits( bin );
    1495     }
    1496 
    1497     for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
    1498     {
    1499       for( UInt uiBin = 0; uiBin < 2; uiBin++ )
    1500       {
    1501         pcEstBitsSbac->significantBits[ ctxIdx ][ uiBin ] = m_cCUSigSCModel.get(  0, 0, ctxIdx ).getEntropyBits( uiBin );
    1502       }
    1503     }
    1504   }
    1505   else
    1506   {
    1507     for( UInt bin = 0; bin < 2; bin++ )
    1508     {
    1509       pcEstBitsSbac->significantBits[ 0 ][ bin ] = m_cCUSigSCModel.get(  0, 0, NUM_SIG_FLAG_CTX_LUMA + 0 ).getEntropyBits( bin );
    1510     }
    1511     for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
    1512     {
    1513       for( UInt uiBin = 0; uiBin < 2; uiBin++ )
    1514       {
    1515         pcEstBitsSbac->significantBits[ ctxIdx ][ uiBin ] = m_cCUSigSCModel.get(  0, 0, NUM_SIG_FLAG_CTX_LUMA + ctxIdx ).getEntropyBits( uiBin );
    1516       }
    1517     }
    1518   }
    1519   Int iBitsX = 0, iBitsY = 0;
    1520   Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
    1521 
    1522   blkSizeOffsetX = eTType ? 0: (g_aucConvertToBit[ width ] *3 + ((g_aucConvertToBit[ width ] +1)>>2));
    1523   blkSizeOffsetY = eTType ? 0: (g_aucConvertToBit[ height ]*3 + ((g_aucConvertToBit[ height ]+1)>>2));
    1524   shiftX = eTType ? g_aucConvertToBit[ width  ] :((g_aucConvertToBit[ width  ]+3)>>2);
    1525   shiftY = eTType ? g_aucConvertToBit[ height ] :((g_aucConvertToBit[ height ]+3)>>2);
    1526 
    1527   Int ctx;
    1528   ContextModel *pCtxX      = m_cCuCtxLastX.get( 0, eTType );
    1529   for (ctx = 0; ctx < g_uiGroupIdx[ width - 1 ]; ctx++)
    1530   {
    1531     Int ctxOffset = blkSizeOffsetX + (ctx >>shiftX);
    1532     pcEstBitsSbac->lastXBits[ ctx ] = iBitsX + pCtxX[ ctxOffset ].getEntropyBits( 0 );
    1533     iBitsX += pCtxX[ ctxOffset ].getEntropyBits( 1 );
    1534   }
    1535   pcEstBitsSbac->lastXBits[ctx] = iBitsX;
    1536   ContextModel *pCtxY      = m_cCuCtxLastY.get( 0, eTType );
    1537   for (ctx = 0; ctx < g_uiGroupIdx[ height - 1 ]; ctx++)
    1538   {
    1539     Int ctxOffset = blkSizeOffsetY + (ctx >>shiftY);
    1540     pcEstBitsSbac->lastYBits[ ctx ] = iBitsY + pCtxY[ ctxOffset ].getEntropyBits( 0 );
    1541     iBitsY += pCtxY[ ctxOffset ].getEntropyBits( 1 );
    1542   }
    1543   pcEstBitsSbac->lastYBits[ctx] = iBitsY;
    1544 }
    1545 
    1546 /*!
    1547  ****************************************************************************
    1548  * \brief
    1549  *    estimate bit cost of significant coefficient
    1550  ****************************************************************************
    1551  */
    1552 Void TEncSbac::estSignificantCoefficientsBit( estBitsSbacStruct* pcEstBitsSbac, TextType eTType )
    1553 {
    1554   if (eTType==TEXT_LUMA)
    1555   {
    1556     ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0);
    1557     ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0);
    1558 
    1559     for (Int ctxIdx = 0; ctxIdx < NUM_ONE_FLAG_CTX_LUMA; ctxIdx++)
    1560     {
    1561       pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
    1562       pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );   
    1563     }
    1564 
    1565     for (Int ctxIdx = 0; ctxIdx < NUM_ABS_FLAG_CTX_LUMA; ctxIdx++)
    1566     {
    1567       pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
    1568       pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );   
    1569     }
    1570   }
    1571   else
    1572   {
    1573     ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0) + NUM_ONE_FLAG_CTX_LUMA;
    1574     ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0) + NUM_ABS_FLAG_CTX_LUMA;
    1575 
    1576     for (Int ctxIdx = 0; ctxIdx < NUM_ONE_FLAG_CTX_CHROMA; ctxIdx++)
    1577     {
    1578       pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
    1579       pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );   
    1580     }
    1581 
    1582     for (Int ctxIdx = 0; ctxIdx < NUM_ABS_FLAG_CTX_CHROMA; ctxIdx++)
    1583     {
    1584       pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
    1585       pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );   
    1586     }
    1587   }
    1588 }
    1589 
    1590 /**
    1591  - Initialize our context information from the nominated source.
    1592  .
    1593  \param pSrc From where to copy context information.
    1594  */
    1595 Void TEncSbac::xCopyContextsFrom( TEncSbac* pSrc )
    1596 { 
    1597   memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
    1598 }
    1599 
    1600 Void  TEncSbac::loadContexts ( TEncSbac* pScr)
    1601 {
    1602   this->xCopyContextsFrom(pScr);
    1603 }
    1604 
    16051604#if SVC_EXTENSION
    1606 Void TEncSbac::codeSAOOffsetParam(Int compIdx, SAOOffset& ctbParam, Bool sliceEnabled, UInt* saoMaxOffsetQVal)
     1605Void TEncSbac::codeSAOOffsetParam(ComponentID compIdx, SAOOffset& ctbParam, Bool sliceEnabled, UInt* saoMaxOffsetQVal)
    16071606#else
    1608 Void TEncSbac::codeSAOOffsetParam(Int compIdx, SAOOffset& ctbParam, Bool sliceEnabled)
     1607Void TEncSbac::codeSAOOffsetParam(ComponentID compIdx, SAOOffset& ctbParam, Bool sliceEnabled)
    16091608#endif
    16101609{
    … …  
    16151614    return;
    16161615  }
     1616  const Bool bIsFirstCompOfChType = (getFirstComponentOfChannel(toChannelType(compIdx)) == compIdx);
    16171617
    16181618  //type
    1619   if(compIdx == SAO_Y || compIdx == SAO_Cb)
     1619  if(bIsFirstCompOfChType)
    16201620  {
    16211621    //sao_type_idx_luma or sao_type_idx_chroma
    … …  
    16331633      uiSymbol = 2;
    16341634    }
    1635     codeSaoTypeIdx(uiSymbol); 
     1635    codeSaoTypeIdx(uiSymbol);
    16361636  }
    16371637
    16381638  if(ctbParam.modeIdc == SAO_MODE_NEW)
    16391639  {
    1640     Int numClasses = (ctbParam.typeIdc == SAO_TYPE_BO)?4:NUM_SAO_EO_CLASSES; 
     1640    Int numClasses = (ctbParam.typeIdc == SAO_TYPE_BO)?4:NUM_SAO_EO_CLASSES;
    16411641    Int offset[4];
    16421642    Int k=0;
    … …  
    16761676    else //EO
    16771677    {
    1678       if(compIdx == SAO_Y || compIdx == SAO_Cb)
     1678      if(bIsFirstCompOfChType)
    16791679      {
    16801680        assert(ctbParam.typeIdc - SAO_TYPE_START_EO >=0);
    … …  
    17031703  if(leftMergeAvail)
    17041704  {
    1705     isLeftMerge = ((saoBlkParam[SAO_Y].modeIdc == SAO_MODE_MERGE) && (saoBlkParam[SAO_Y].typeIdc == SAO_MERGE_LEFT));
     1705    isLeftMerge = ((saoBlkParam[COMPONENT_Y].modeIdc == SAO_MODE_MERGE) && (saoBlkParam[COMPONENT_Y].typeIdc == SAO_MERGE_LEFT));
    17061706    codeSaoMerge( isLeftMerge?1:0  ); //sao_merge_left_flag
    17071707  }
    … …  
    17091709  if( aboveMergeAvail && !isLeftMerge)
    17101710  {
    1711     isAboveMerge = ((saoBlkParam[SAO_Y].modeIdc == SAO_MODE_MERGE) && (saoBlkParam[SAO_Y].typeIdc == SAO_MERGE_ABOVE));
     1711    isAboveMerge = ((saoBlkParam[COMPONENT_Y].modeIdc == SAO_MODE_MERGE) && (saoBlkParam[COMPONENT_Y].typeIdc == SAO_MERGE_ABOVE));
    17121712    codeSaoMerge( isAboveMerge?1:0  ); //sao_merge_left_flag
    17131713  }
    … …  
    17201720  if(!isLeftMerge && !isAboveMerge) //not merge mode
    17211721  {
    1722     for(Int compIdx=0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
     1722    for(Int compIdx=0; compIdx < MAX_NUM_COMPONENT; compIdx++)
    17231723    {
    17241724#if SVC_EXTENSION
    1725       codeSAOOffsetParam(compIdx, saoBlkParam[compIdx], sliceEnabled[compIdx], saoMaxOffsetQVal);
     1725      codeSAOOffsetParam(ComponentID(compIdx), saoBlkParam[compIdx], sliceEnabled[compIdx], saoMaxOffsetQVal);
    17261726#else
    1727       codeSAOOffsetParam(compIdx, saoBlkParam[compIdx], sliceEnabled[compIdx]);
     1727      codeSAOOffsetParam(ComponentID(compIdx), saoBlkParam[compIdx], sliceEnabled[compIdx]);
    17281728#endif
    17291729    }
    … …  
    17311731}
    17321732
     1733/*!
     1734 ****************************************************************************
     1735 * \brief
     1736 *   estimate bit cost for CBP, significant map and significant coefficients
     1737 ****************************************************************************
     1738 */
     1739Void TEncSbac::estBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
     1740{
     1741  estCBFBit( pcEstBitsSbac );
     1742
     1743  estSignificantCoeffGroupMapBit( pcEstBitsSbac, chType );
     1744
     1745  // encode significance map
     1746  estSignificantMapBit( pcEstBitsSbac, width, height, chType );
     1747
     1748  // encode last significant position
     1749  estLastSignificantPositionBit( pcEstBitsSbac, width, height, chType );
     1750
     1751  // encode significant coefficients
     1752  estSignificantCoefficientsBit( pcEstBitsSbac, chType );
     1753
     1754  memcpy(pcEstBitsSbac->golombRiceAdaptationStatistics, m_golombRiceAdaptationStatistics, (sizeof(UInt) * RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS));
     1755}
     1756
     1757/*!
     1758 ****************************************************************************
     1759 * \brief
     1760 *    estimate bit cost for each CBP bit
     1761 ****************************************************************************
     1762 */
     1763Void TEncSbac::estCBFBit( estBitsSbacStruct* pcEstBitsSbac )
     1764{
     1765  ContextModel *pCtx = m_cCUQtCbfSCModel.get( 0 );
     1766
     1767  for( UInt uiCtxInc = 0; uiCtxInc < (NUM_QT_CBF_CTX_SETS * NUM_QT_CBF_CTX_PER_SET); uiCtxInc++ )
     1768  {
     1769    pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
     1770    pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
     1771  }
     1772
     1773  pCtx = m_cCUQtRootCbfSCModel.get( 0 );
     1774
     1775  for( UInt uiCtxInc = 0; uiCtxInc < 4; uiCtxInc++ )
     1776  {
     1777    pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
     1778    pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
     1779  }
     1780}
     1781
     1782
     1783/*!
     1784 ****************************************************************************
     1785 * \brief
     1786 *    estimate SAMBAC bit cost for significant coefficient group map
     1787 ****************************************************************************
     1788 */
     1789Void TEncSbac::estSignificantCoeffGroupMapBit( estBitsSbacStruct* pcEstBitsSbac, ChannelType chType )
     1790{
     1791  Int firstCtx = 0, numCtx = NUM_SIG_CG_FLAG_CTX;
     1792
     1793  for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
     1794  {
     1795    for( UInt uiBin = 0; uiBin < 2; uiBin++ )
     1796    {
     1797      pcEstBitsSbac->significantCoeffGroupBits[ ctxIdx ][ uiBin ] = m_cCUSigCoeffGroupSCModel.get(  0, chType, ctxIdx ).getEntropyBits( uiBin );
     1798    }
     1799  }
     1800}
     1801
     1802
     1803/*!
     1804 ****************************************************************************
     1805 * \brief
     1806 *    estimate SAMBAC bit cost for significant coefficient map
     1807 ****************************************************************************
     1808 */
     1809Void TEncSbac::estSignificantMapBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
     1810{
     1811  //--------------------------------------------------------------------------------------------------
     1812
     1813  //set up the number of channels and context variables
     1814
     1815  const UInt firstComponent = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
     1816  const UInt lastComponent  = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
     1817
     1818  //----------------------------------------------------------
     1819
     1820  Int firstCtx = MAX_INT;
     1821  Int numCtx   = MAX_INT;
     1822
     1823  if      ((width == 4) && (height == 4))
     1824  {
     1825    firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_4x4];
     1826    numCtx   = significanceMapContextSetSize [chType][CONTEXT_TYPE_4x4];
     1827  }
     1828  else if ((width == 8) && (height == 8))
     1829  {
     1830    firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_8x8];
     1831    numCtx   = significanceMapContextSetSize [chType][CONTEXT_TYPE_8x8];
     1832  }
     1833  else
     1834  {
     1835    firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_NxN];
     1836    numCtx   = significanceMapContextSetSize [chType][CONTEXT_TYPE_NxN];
     1837  }
     1838
     1839  //--------------------------------------------------------------------------------------------------
     1840
     1841  //fill the data for the significace map
     1842
     1843  for (UInt component = firstComponent; component <= lastComponent; component++)
     1844  {
     1845    const UInt contextOffset = getSignificanceMapContextOffset(ComponentID(component));
     1846
     1847    if (firstCtx > 0)
     1848    {
     1849      for( UInt bin = 0; bin < 2; bin++ ) //always get the DC
     1850      {
     1851        pcEstBitsSbac->significantBits[ contextOffset ][ bin ] = m_cCUSigSCModel.get( 0, 0, contextOffset ).getEntropyBits( bin );
     1852      }
     1853    }
     1854
     1855    // This could be made optional, but would require this function to have knowledge of whether the
     1856    // TU is transform-skipped or transquant-bypassed and whether the SPS flag is set
     1857    for( UInt bin = 0; bin < 2; bin++ )
     1858    {
     1859      const Int ctxIdx = significanceMapContextSetStart[chType][CONTEXT_TYPE_SINGLE];
     1860      pcEstBitsSbac->significantBits[ contextOffset + ctxIdx ][ bin ] = m_cCUSigSCModel.get( 0, 0, (contextOffset + ctxIdx) ).getEntropyBits( bin );
     1861    }
     1862
     1863    for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
     1864    {
     1865      for( UInt uiBin = 0; uiBin < 2; uiBin++ )
     1866      {
     1867        pcEstBitsSbac->significantBits[ contextOffset + ctxIdx ][ uiBin ] = m_cCUSigSCModel.get(  0, 0, (contextOffset + ctxIdx) ).getEntropyBits( uiBin );
     1868      }
     1869    }
     1870  }
     1871
     1872  //--------------------------------------------------------------------------------------------------
     1873}
     1874
     1875
     1876/*!
     1877 ****************************************************************************
     1878 * \brief
     1879 *    estimate bit cost of significant coefficient
     1880 ****************************************************************************
     1881 */
     1882
     1883Void TEncSbac::estLastSignificantPositionBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
     1884{
     1885  //--------------------------------------------------------------------------------------------------.
     1886
     1887  //set up the number of channels
     1888
     1889  const UInt firstComponent = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
     1890  const UInt lastComponent  = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
     1891
     1892  //--------------------------------------------------------------------------------------------------
     1893
     1894  //fill the data for the last-significant-coefficient position
     1895
     1896  for (UInt componentIndex = firstComponent; componentIndex <= lastComponent; componentIndex++)
     1897  {
     1898    const ComponentID component = ComponentID(componentIndex);
     1899
     1900    Int iBitsX = 0, iBitsY = 0;
     1901
     1902    Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
     1903    getLastSignificantContextParameters(ComponentID(component), width, height, blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY);
     1904
     1905    Int ctx;
     1906
     1907    const ChannelType channelType = toChannelType(ComponentID(component));
     1908
     1909    ContextModel *const pCtxX = m_cCuCtxLastX.get( 0, channelType );
     1910    ContextModel *const pCtxY = m_cCuCtxLastY.get( 0, channelType );
     1911    Int          *const lastXBitsArray = pcEstBitsSbac->lastXBits[channelType];
     1912    Int          *const lastYBitsArray = pcEstBitsSbac->lastYBits[channelType];
     1913
     1914    //------------------------------------------------
     1915
     1916    //X-coordinate
     1917
     1918    for (ctx = 0; ctx < g_uiGroupIdx[ width - 1 ]; ctx++)
     1919    {
     1920      Int ctxOffset = blkSizeOffsetX + (ctx >>shiftX);
     1921      lastXBitsArray[ ctx ] = iBitsX + pCtxX[ ctxOffset ].getEntropyBits( 0 );
     1922      iBitsX += pCtxX[ ctxOffset ].getEntropyBits( 1 );
     1923    }
     1924
     1925    lastXBitsArray[ctx] = iBitsX;
     1926
     1927    //------------------------------------------------
     1928
     1929    //Y-coordinate
     1930
     1931    for (ctx = 0; ctx < g_uiGroupIdx[ height - 1 ]; ctx++)
     1932    {
     1933      Int ctxOffset = blkSizeOffsetY + (ctx >>shiftY);
     1934      lastYBitsArray[ ctx ] = iBitsY + pCtxY[ ctxOffset ].getEntropyBits( 0 );
     1935      iBitsY += pCtxY[ ctxOffset ].getEntropyBits( 1 );
     1936    }
     1937
     1938    lastYBitsArray[ctx] = iBitsY;
     1939
     1940  } //end of component loop
     1941
     1942  //--------------------------------------------------------------------------------------------------
     1943}
     1944
     1945
     1946/*!
     1947 ****************************************************************************
     1948 * \brief
     1949 *    estimate bit cost of significant coefficient
     1950 ****************************************************************************
     1951 */
     1952Void TEncSbac::estSignificantCoefficientsBit( estBitsSbacStruct* pcEstBitsSbac, ChannelType chType )
     1953{
     1954  ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0);
     1955  ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0);
     1956
     1957  const UInt oneStartIndex = ((isLuma(chType)) ? (0)                     : (NUM_ONE_FLAG_CTX_LUMA));
     1958  const UInt oneStopIndex  = ((isLuma(chType)) ? (NUM_ONE_FLAG_CTX_LUMA) : (NUM_ONE_FLAG_CTX));
     1959  const UInt absStartIndex = ((isLuma(chType)) ? (0)                     : (NUM_ABS_FLAG_CTX_LUMA));
     1960  const UInt absStopIndex  = ((isLuma(chType)) ? (NUM_ABS_FLAG_CTX_LUMA) : (NUM_ABS_FLAG_CTX));
     1961
     1962  for (Int ctxIdx = oneStartIndex; ctxIdx < oneStopIndex; ctxIdx++)
     1963  {
     1964    pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
     1965    pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );
     1966  }
     1967
     1968  for (Int ctxIdx = absStartIndex; ctxIdx < absStopIndex; ctxIdx++)
     1969  {
     1970    pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
     1971    pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );
     1972  }
     1973}
     1974
     1975/**
     1976 - Initialize our context information from the nominated source.
     1977 .
     1978 \param pSrc From where to copy context information.
     1979 */
     1980Void TEncSbac::xCopyContextsFrom( const TEncSbac* pSrc )
     1981{
     1982  memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
     1983  memcpy(m_golombRiceAdaptationStatistics, pSrc->m_golombRiceAdaptationStatistics, (sizeof(UInt) * RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS));
     1984}
     1985
     1986Void  TEncSbac::loadContexts ( const TEncSbac* pSrc)
     1987{
     1988  xCopyContextsFrom(pSrc);
     1989}
     1990
     1991/** Performs CABAC encoding of the explicit RDPCM mode
     1992 * \param rTu current TU data structure
     1993 * \param compID component identifier
     1994 */
     1995Void TEncSbac::codeExplicitRdpcmMode( TComTU &rTu, const ComponentID compID )
     1996{
     1997  TComDataCU *cu = rTu.getCU();
     1998  const TComRectangle &rect = rTu.getRect(compID);
     1999  const UInt absPartIdx   = rTu.GetAbsPartIdxTU(compID);
     2000  const UInt tuHeight = g_aucConvertToBit[rect.height];
     2001  const UInt tuWidth  = g_aucConvertToBit[rect.width];
     2002
     2003  assert(tuHeight == tuWidth);
     2004  assert(tuHeight < 4);
     2005
     2006  UInt explicitRdpcmMode = cu->getExplicitRdpcmMode(compID, absPartIdx);
     2007
     2008  if( explicitRdpcmMode == RDPCM_OFF )
     2009  {
     2010    m_pcBinIf->encodeBin (0, m_explicitRdpcmFlagSCModel.get (0, toChannelType(compID), 0));
     2011  }
     2012  else if( explicitRdpcmMode == RDPCM_HOR || explicitRdpcmMode == RDPCM_VER )
     2013  {
     2014    m_pcBinIf->encodeBin (1, m_explicitRdpcmFlagSCModel.get (0, toChannelType(compID), 0));
     2015    if(explicitRdpcmMode == RDPCM_HOR)
     2016    {
     2017      m_pcBinIf->encodeBin ( 0, m_explicitRdpcmDirSCModel.get(0, toChannelType(compID), 0));
     2018    }
     2019    else
     2020    {
     2021      m_pcBinIf->encodeBin ( 1, m_explicitRdpcmDirSCModel.get(0, toChannelType(compID), 0));
     2022    }
     2023  }
     2024  else
     2025  {
     2026    assert(0);
     2027  }
     2028}
     2029
     2030#if POC_RESET_IDC_SIGNALLING
     2031Void  TEncSbac::codeSliceHeaderExtn( TComSlice* pSlice, Int shBitsWrittenTillNow )
     2032{
     2033  assert (0);
     2034  return;
     2035}
     2036#endif
     2037
    17332038//! \}
Note: See TracChangeset for help on using the changeset viewer.