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


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

updated trunk (move to HM6.1)

File:
1 edited

Legend:

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

    r42 r56  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license.
     4 * granted under this license. 
    55 *
    6  * Copyright (c) 2010-2011, ISO/IEC
     6 * Copyright (c) 2010-2012, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    1515 *    this list of conditions and the following disclaimer in the documentation
    1616 *    and/or other materials provided with the distribution.
    17  *  * Neither the name of the ISO/IEC nor the names of its contributors may
     17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
    1818 *    be used to endorse or promote products derived from this software without
    1919 *    specific prior written permission.
     
    3232 */
    3333
    34 
    35 
    3634/** \file     TEncCavlc.cpp
    3735    \brief    CAVLC encoder class
    3836*/
    3937
     38#include "../TLibCommon/CommonDef.h"
    4039#include "TEncCavlc.h"
    41 #include "../TLibCommon/SEI.h"
    4240#include "SEIwrite.h"
     41
     42//! \ingroup TLibEncoder
     43//! \{
     44
     45#if ENC_DEC_TRACE
     46
     47#define WRITE_CODE( value, length, name)    xWriteCodeTr ( value, length, name )
     48#define WRITE_UVLC( value,         name)    xWriteUvlcTr ( value,         name )
     49#define WRITE_SVLC( value,         name)    xWriteSvlcTr ( value,         name )
     50#define WRITE_FLAG( value,         name)    xWriteFlagTr ( value,         name )
     51
     52Void  xWriteUvlcTr          ( UInt value,               const Char *pSymbolName);
     53Void  xWriteSvlcTr          ( Int  value,               const Char *pSymbolName);
     54Void  xWriteFlagTr          ( UInt value,               const Char *pSymbolName);
     55
     56Void  xTraceSPSHeader (TComSPS *pSPS)
     57{
     58  fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
     59}
     60
     61Void  xTracePPSHeader (TComPPS *pPPS)
     62{
     63  fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
     64}
     65
     66Void  xTraceAPSHeader (TComAPS *pAPS)
     67{
     68  fprintf( g_hTrace, "=========== Adaptation Parameter Set ===========\n");
     69}
     70
     71Void  xTraceSliceHeader (TComSlice *pSlice)
     72{
     73  fprintf( g_hTrace, "=========== Slice ===========\n");
     74}
     75
     76
     77Void  TEncCavlc::xWriteCodeTr (UInt value, UInt  length, const Char *pSymbolName)
     78{
     79  xWriteCode (value,length);
     80  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
     81  fprintf( g_hTrace, "%-40s u(%d) : %d\n", pSymbolName, length, value );
     82}
     83
     84Void  TEncCavlc::xWriteUvlcTr (UInt value, const Char *pSymbolName)
     85{
     86  xWriteUvlc (value);
     87  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
     88  fprintf( g_hTrace, "%-40s u(v) : %d\n", pSymbolName, value );
     89}
     90
     91Void  TEncCavlc::xWriteSvlcTr (Int value, const Char *pSymbolName)
     92{
     93  xWriteSvlc(value);
     94  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
     95  fprintf( g_hTrace, "%-40s s(v) : %d\n", pSymbolName, value );
     96}
     97
     98Void  TEncCavlc::xWriteFlagTr(UInt value, const Char *pSymbolName)
     99{
     100  xWriteFlag(value);
     101  fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter++ );
     102  fprintf( g_hTrace, "%-40s u(1) : %d\n", pSymbolName, value );
     103}
     104
     105#else
     106
     107#define WRITE_CODE( value, length, name)     xWriteCode ( value, length )
     108#define WRITE_UVLC( value,         name)     xWriteUvlc ( value )
     109#define WRITE_SVLC( value,         name)     xWriteSvlc ( value )
     110#define WRITE_FLAG( value,         name)     xWriteFlag ( value )
     111
     112#endif
     113
     114
    43115
    44116// ====================================================================================================================
     
    49121{
    50122  m_pcBitIf           = NULL;
    51   m_bRunLengthCoding  = false;   //  m_bRunLengthCoding  = !rcSliceHeader.isIntra();
    52123  m_uiCoeffCost       = 0;
    53124  m_bAlfCtrl = false;
    54125  m_uiMaxAlfCtrlDepth = 0;
    55 
    56   m_bAdaptFlag        = true;    // adaptive VLC table
     126 
     127  m_iSliceGranularity = 0;
    57128}
    58129
     
    68139Void TEncCavlc::resetEntropy()
    69140{
    70   m_bRunLengthCoding = ! m_pcSlice->isIntra();
    71   m_uiRun = 0;
    72 #if !CAVLC_COEF_LRG_BLK
    73   ::memcpy(m_uiLPTableE8, g_auiLPTableE8, 10*128*sizeof(UInt));
    74   ::memcpy(m_uiLPTableD8, g_auiLPTableD8, 10*128*sizeof(UInt));
    75 #endif
    76   ::memcpy(m_uiLPTableE4, g_auiLPTableE4, 3*32*sizeof(UInt));
    77   ::memcpy(m_uiLPTableD4, g_auiLPTableD4, 3*32*sizeof(UInt));
    78   ::memcpy(m_uiLastPosVlcIndex, g_auiLastPosVlcIndex, 10*sizeof(UInt));
    79 
    80 #if LCEC_INTRA_MODE
    81 #if MTK_DCM_MPM
    82   ::memcpy(m_uiIntraModeTableD17[0], g_auiIntraModeTableD17[0], 16*sizeof(UInt));
    83   ::memcpy(m_uiIntraModeTableE17[0], g_auiIntraModeTableE17[0], 16*sizeof(UInt));
    84   ::memcpy(m_uiIntraModeTableD17[1], g_auiIntraModeTableD17[1], 16*sizeof(UInt));
    85   ::memcpy(m_uiIntraModeTableE17[1], g_auiIntraModeTableE17[1], 16*sizeof(UInt));
    86 
    87   ::memcpy(m_uiIntraModeTableD34[0], g_auiIntraModeTableD34[0], 33*sizeof(UInt));
    88   ::memcpy(m_uiIntraModeTableE34[0], g_auiIntraModeTableE34[0], 33*sizeof(UInt));
    89   ::memcpy(m_uiIntraModeTableD34[1], g_auiIntraModeTableD34[1], 33*sizeof(UInt));
    90   ::memcpy(m_uiIntraModeTableE34[1], g_auiIntraModeTableE34[1], 33*sizeof(UInt));
    91 #else
    92   ::memcpy(m_uiIntraModeTableD17, g_auiIntraModeTableD17, 16*sizeof(UInt));
    93   ::memcpy(m_uiIntraModeTableE17, g_auiIntraModeTableE17, 16*sizeof(UInt));
    94 
    95   ::memcpy(m_uiIntraModeTableD34, g_auiIntraModeTableD34, 33*sizeof(UInt));
    96   ::memcpy(m_uiIntraModeTableE34, g_auiIntraModeTableE34, 33*sizeof(UInt));
    97 #endif
    98 #endif
    99 
    100 #if CAVLC_RQT_CBP
    101   ::memcpy(m_uiCBP_YUV_TableE, g_auiCBP_YUV_TableE, 4*8*sizeof(UInt));
    102   ::memcpy(m_uiCBP_YUV_TableD, g_auiCBP_YUV_TableD, 4*8*sizeof(UInt));
    103   ::memcpy(m_uiCBP_YS_TableE,  g_auiCBP_YS_TableE,  2*4*sizeof(UInt));
    104   ::memcpy(m_uiCBP_YS_TableD,  g_auiCBP_YS_TableD,  2*4*sizeof(UInt));
    105   ::memcpy(m_uiCBP_YCS_TableE, g_auiCBP_YCS_TableE, 2*8*sizeof(UInt));
    106   ::memcpy(m_uiCBP_YCS_TableD, g_auiCBP_YCS_TableD, 2*8*sizeof(UInt));
    107   ::memcpy(m_uiCBP_4Y_TableE,  g_auiCBP_4Y_TableE,  2*15*sizeof(UInt));
    108   ::memcpy(m_uiCBP_4Y_TableD,  g_auiCBP_4Y_TableD,  2*15*sizeof(UInt));
    109   m_uiCBP_4Y_VlcIdx = 0;
    110 #else
    111   ::memcpy(m_uiCBPTableE, g_auiCBPTableE, 2*8*sizeof(UInt));
    112   ::memcpy(m_uiCBPTableD, g_auiCBPTableD, 2*8*sizeof(UInt));
    113   m_uiCbpVlcIdx[0] = 0;
    114   m_uiCbpVlcIdx[1] = 0;
    115   ::memcpy(m_uiBlkCBPTableE, g_auiBlkCBPTableE, 2*15*sizeof(UInt));
    116   ::memcpy(m_uiBlkCBPTableD, g_auiBlkCBPTableD, 2*15*sizeof(UInt));
    117   m_uiBlkCbpVlcIdx = 0;
    118 #endif
    119 
    120 #if UNIFY_INTER_TABLE
    121   ::memcpy(m_uiMI1TableE, g_auiComMI1TableE, 9*sizeof(UInt));
    122   ::memcpy(m_uiMI1TableD, g_auiComMI1TableD, 9*sizeof(UInt));
    123 #else
    124   ::memcpy(m_uiMI1TableE, g_auiMI1TableE, 8*sizeof(UInt));
    125   ::memcpy(m_uiMI1TableD, g_auiMI1TableD, 8*sizeof(UInt));
    126   ::memcpy(m_uiMI2TableE, g_auiMI2TableE, 15*sizeof(UInt));
    127   ::memcpy(m_uiMI2TableD, g_auiMI2TableD, 15*sizeof(UInt));
    128 
    129 #if DCM_COMB_LIST
    130   if ( m_pcSlice->getNoBackPredFlag() || m_pcSlice->getNumRefIdx(REF_PIC_LIST_C)>0)
    131 #else
    132   if ( m_pcSlice->getNoBackPredFlag() )
    133 #endif
    134   {
    135     ::memcpy(m_uiMI1TableE, g_auiMI1TableENoL1, 8*sizeof(UInt));
    136     ::memcpy(m_uiMI1TableD, g_auiMI1TableDNoL1, 8*sizeof(UInt));
    137     ::memcpy(m_uiMI2TableE, g_auiMI2TableENoL1, 15*sizeof(UInt));
    138     ::memcpy(m_uiMI2TableD, g_auiMI2TableDNoL1, 15*sizeof(UInt));
    139   }
    140 #if MS_LCEC_ONE_FRAME
    141   if ( m_pcSlice->getNumRefIdx(REF_PIC_LIST_0) <= 1 && m_pcSlice->getNumRefIdx(REF_PIC_LIST_1) <= 1 )
    142   {
    143     if ( m_pcSlice->getNoBackPredFlag() || ( m_pcSlice->getNumRefIdx(REF_PIC_LIST_C) > 0 && m_pcSlice->getNumRefIdx(REF_PIC_LIST_C) <= 1 ) )
    144     {
    145       ::memcpy(m_uiMI1TableE, g_auiMI1TableEOnly1RefNoL1, 8*sizeof(UInt));
    146       ::memcpy(m_uiMI1TableD, g_auiMI1TableDOnly1RefNoL1, 8*sizeof(UInt));
    147     }
    148     else
    149     {
    150       ::memcpy(m_uiMI1TableE, g_auiMI1TableEOnly1Ref, 8*sizeof(UInt));
    151       ::memcpy(m_uiMI1TableD, g_auiMI1TableDOnly1Ref, 8*sizeof(UInt));
    152     }
    153   }
    154 #endif
    155 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    156   if (m_pcSlice->getNumRefIdx(REF_PIC_LIST_C)>0)
    157   {
    158     m_uiMI1TableE[8] = 8;
    159     m_uiMI1TableD[8] = 8;
    160   }
    161   else  // GPB case
    162   {
    163     m_uiMI1TableD[8] = m_uiMI1TableD[6];
    164     m_uiMI1TableD[6] = 8;
    165 
    166     m_uiMI1TableE[m_uiMI1TableD[8]] = 8;
    167     m_uiMI1TableE[m_uiMI1TableD[6]] = 6;
    168   }
    169 #endif
    170 #endif
    171 
    172 #if QC_LCEC_INTER_MODE
    173   ::memcpy(m_uiSplitTableE, g_auiInterModeTableE, 4*7*sizeof(UInt));
    174   ::memcpy(m_uiSplitTableD, g_auiInterModeTableD, 4*7*sizeof(UInt));
    175 #endif
    176 
    177   m_uiMITableVlcIdx = 0;
    178 
    179 #if CAVLC_COUNTER_ADAPT
    180 #if CAVLC_RQT_CBP
    181   ::memset(m_ucCBP_YUV_TableCounter,   0,        4*4*sizeof(UChar));
    182   ::memset(m_ucCBP_4Y_TableCounter,    0,        2*2*sizeof(UChar));
    183   ::memset(m_ucCBP_YCS_TableCounter,   0,        2*4*sizeof(UChar));
    184   ::memset(m_ucCBP_YS_TableCounter,    0,        2*3*sizeof(UChar));
    185 #else
    186   ::memset(m_ucCBFTableCounter,        0,        2*4*sizeof(UChar));
    187   ::memset(m_ucBlkCBPTableCounter,     0,        2*2*sizeof(UChar));
    188 #endif
    189 
    190   ::memset(m_ucMI1TableCounter,        0,          4*sizeof(UChar));
    191   ::memset(m_ucSplitTableCounter,      0,        4*4*sizeof(UChar));
    192 
    193 #if CAVLC_RQT_CBP
    194   m_ucCBP_YUV_TableCounterSum[0] = m_ucCBP_YUV_TableCounterSum[1] = m_ucCBP_YUV_TableCounterSum[2] = m_ucCBP_YUV_TableCounterSum[3] = 0;
    195   m_ucCBP_4Y_TableCounterSum[0] = m_ucCBP_4Y_TableCounterSum[1] = 0;
    196   m_ucCBP_YCS_TableCounterSum[0] = m_ucCBP_YCS_TableCounterSum[1] = 0;
    197   m_ucCBP_YS_TableCounterSum[0] = m_ucCBP_YS_TableCounterSum[1] = 0;
    198 #else
    199   m_ucCBFTableCounterSum[0] = m_ucCBFTableCounterSum[1] = 0;
    200   m_ucBlkCBPTableCounterSum[0] = m_ucBlkCBPTableCounterSum[1] = 0;
    201 #endif
    202   m_ucSplitTableCounterSum[0] = m_ucSplitTableCounterSum[1] = m_ucSplitTableCounterSum[2]= m_ucSplitTableCounterSum[3] = 0;
    203   m_ucMI1TableCounterSum = 0;
    204 #endif
    205 }
    206 
    207 #if !CAVLC_COEF_LRG_BLK
    208 UInt* TEncCavlc::GetLP8Table()
    209 {
    210   return &m_uiLPTableE8[0][0];
    211 }
    212 #endif
    213 
    214 UInt* TEncCavlc::GetLP4Table()
    215 {
    216   return &m_uiLPTableE4[0][0];
    217 }
    218 
    219 #if QC_MOD_LCEC
    220 UInt* TEncCavlc::GetLastPosVlcIndexTable()
    221 {
    222   return &m_uiLastPosVlcIndex[0];
    223 }
    224 #endif
     141}
    225142
    226143/**
    227  * marshall the SEI message @sei.
     144 * marshall the SEI message sei.
    228145 */
    229146void TEncCavlc::codeSEI(const SEI& sei)
    230147{
    231 #if BITSTREAM_EXTRACTION
    232   codeNALUnitHeader( NAL_UNIT_SEI, NAL_REF_IDC_PRIORITY_LOWEST, 0, sei.getLayerId() );
     148  writeSEImessage(*m_pcBitIf, sei);
     149}
     150
     151Void  TEncCavlc::codeAPSInitInfo(TComAPS* pcAPS)
     152{
     153
     154#if ENC_DEC_TRACE 
     155  xTraceAPSHeader(pcAPS);
     156#endif
     157  //APS ID
     158  WRITE_UVLC( pcAPS->getAPSID(), "aps_id" );
     159
     160  WRITE_FLAG( pcAPS->getScalingListEnabled()?1:0, "aps_scaling_list_data_present_flag");
     161  //DF flag
     162  WRITE_FLAG(pcAPS->getLoopFilterOffsetInAPS()?1:0, "aps_deblocking_filter_flag");
     163#if !SAO_UNIT_INTERLEAVING
     164  //SAO flag
     165  WRITE_FLAG( pcAPS->getSaoEnabled()?1:0, "aps_sample_adaptive_offset_flag");
     166#endif
     167#if !LCU_SYNTAX_ALF
     168  //ALF flag
     169  WRITE_FLAG( pcAPS->getAlfEnabled()?1:0, "aps_adaptive_loop_filter_flag");
     170#endif
     171}
     172#if LCU_SYNTAX_ALF
     173Void TEncCavlc::codeAPSAlflag(UInt uiCode)
     174{
     175  WRITE_FLAG(uiCode, "aps_adaptive_loop_filter_flag");
     176}
     177#endif
     178
     179Void TEncCavlc::codeDFFlag(UInt uiCode, const Char *pSymbolName)
     180{
     181  WRITE_FLAG(uiCode, pSymbolName);
     182}
     183Void TEncCavlc::codeDFSvlc(Int iCode, const Char *pSymbolName)
     184{
     185  WRITE_SVLC(iCode, pSymbolName);
     186}
     187
     188#if RPS_IN_SPS
     189Void TEncCavlc::codeShortTermRefPicSet( TComSPS* pcSPS, TComReferencePictureSet* rps )
    233190#else
    234   codeNALUnitHeader(NAL_UNIT_SEI, NAL_REF_IDC_PRIORITY_LOWEST);
    235 #endif
    236   writeSEImessage(*m_pcBitIf, sei);
    237 }
     191Void TEncCavlc::codeShortTermRefPicSet( TComPPS* pcPPS, TComReferencePictureSet* rps )
     192#endif
     193{
     194#if PRINT_RPS_INFO
     195  int lastBits = getNumberOfWrittenBits();
     196#endif
     197  WRITE_FLAG( rps->getInterRPSPrediction(), "inter_ref_pic_set_prediction_flag" ); // inter_RPS_prediction_flag
     198  if (rps->getInterRPSPrediction())
     199  {
     200    Int deltaRPS = rps->getDeltaRPS();
     201    WRITE_UVLC( rps->getDeltaRIdxMinus1(), "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
     202    WRITE_CODE( (deltaRPS >=0 ? 0: 1), 1, "delta_rps_sign" ); //delta_rps_sign
     203    WRITE_UVLC( abs(deltaRPS) - 1, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
     204
     205    for(Int j=0; j < rps->getNumRefIdc(); j++)
     206    {
     207      Int refIdc = rps->getRefIdc(j);
     208      WRITE_CODE( (refIdc==1? 1: 0), 1, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
     209      if (refIdc != 1)
     210      {
     211        WRITE_CODE( refIdc>>1, 1, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
     212      }
     213    }
     214  }
     215  else
     216  {
     217    WRITE_UVLC( rps->getNumberOfNegativePictures(), "num_negative_pics" );
     218    WRITE_UVLC( rps->getNumberOfPositivePictures(), "num_positive_pics" );
     219    Int prev = 0;
     220    for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
     221    {
     222      WRITE_UVLC( prev-rps->getDeltaPOC(j)-1, "delta_poc_s0_minus1" );
     223      prev = rps->getDeltaPOC(j);
     224      WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s0_flag");
     225    }
     226    prev = 0;
     227    for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
     228    {
     229      WRITE_UVLC( rps->getDeltaPOC(j)-prev-1, "delta_poc_s1_minus1" );
     230      prev = rps->getDeltaPOC(j);
     231      WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s1_flag" );
     232    }
     233  }
     234
     235#if PRINT_RPS_INFO
     236  printf("irps=%d (%2d bits) ", rps->getInterRPSPrediction(), getNumberOfWrittenBits() - lastBits);
     237  rps->printDeltaPOC();
     238#endif
     239}
     240
    238241
    239242Void TEncCavlc::codePPS( TComPPS* pcPPS )
    240243{
    241   // uiFirstByte
    242 #if BITSTREAM_EXTRACTION
    243   codeNALUnitHeader( NAL_UNIT_PPS, NAL_REF_IDC_PRIORITY_HIGHEST, 0, pcPPS->getLayerId() );
     244#if ENC_DEC_TRACE 
     245  xTracePPSHeader (pcPPS);
     246#endif
     247#if !RPS_IN_SPS
     248  TComRPSList* rpsList = pcPPS->getRPSList();
     249#endif
     250 
     251  WRITE_UVLC( pcPPS->getPPSId(),                             "pic_parameter_set_id" );
     252  WRITE_UVLC( pcPPS->getSPSId(),                             "seq_parameter_set_id" );
     253
     254#if MULTIBITS_DATA_HIDING
     255  WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" );
     256  if( pcPPS->getSignHideFlag() )
     257  {
     258    WRITE_CODE(pcPPS->getTSIG(), 4, "sign_hiding_threshold");
     259  }
     260#endif
     261#if CABAC_INIT_FLAG
     262  WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0,   "cabac_init_present_flag" );
     263#endif
     264#if !RPS_IN_SPS
     265  // RPS is put before entropy_coding_mode_flag
     266  // since entropy_coding_mode_flag will probably be removed from the WD
     267  TComReferencePictureSet*      rps;
     268
     269  WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
     270  for(UInt i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
     271  {
     272    rps = rpsList->getReferencePictureSet(i);
     273    codeShortTermRefPicSet(pcPPS,rps);
     274  }
     275  WRITE_FLAG( pcPPS->getLongTermRefsPresent() ? 1 : 0,         "long_term_ref_pics_present_flag" );
     276#endif
     277  // entropy_coding_mode_flag
     278  // We code the entropy_coding_mode_flag, it's needed for tests.
     279  WRITE_FLAG( pcPPS->getEntropyCodingMode() ? 1 : 0,         "entropy_coding_mode_flag" );
     280  if (pcPPS->getEntropyCodingMode())
     281  {
     282#if !WPP_SIMPLIFICATION
     283    WRITE_UVLC( pcPPS->getEntropyCodingSynchro(),            "entropy_coding_synchro" );
     284    WRITE_FLAG( pcPPS->getCabacIstateReset() ? 1 : 0,        "cabac_istate_reset" );
     285#endif
     286#if !TILES_OR_ENTROPY_SYNC_IDC
     287#if !WPP_SIMPLIFICATION
     288    if ( pcPPS->getEntropyCodingSynchro() )
     289#endif
     290    {
     291      WRITE_UVLC( pcPPS->getNumSubstreams()-1,               "num_substreams_minus1" );
     292    }
     293#endif
     294  }
     295#if !H0566_TLA
     296  WRITE_UVLC( pcPPS->getNumTLayerSwitchingFlags(),           "num_temporal_layer_switching_point_flags" );
     297  for( UInt i = 0; i < pcPPS->getNumTLayerSwitchingFlags(); i++ )
     298  {
     299    WRITE_FLAG( pcPPS->getTLayerSwitchingFlag( i ) ? 1 : 0 , "temporal_layer_switching_point_flag" );
     300  }
     301#endif
     302  //   num_ref_idx_l0_default_active_minus1
     303  //   num_ref_idx_l1_default_active_minus1
     304  WRITE_SVLC( pcPPS->getPicInitQPMinus26(),                  "pic_init_qp_minus26");
     305  WRITE_FLAG( pcPPS->getConstrainedIntraPred() ? 1 : 0,      "constrained_intra_pred_flag" );
     306  WRITE_FLAG( pcPPS->getEnableTMVPFlag() ? 1 : 0,            "enable_temporal_mvp_flag" );
     307  WRITE_CODE( pcPPS->getSliceGranularity(), 2,               "slice_granularity");
     308  WRITE_UVLC( pcPPS->getMaxCuDQPDepth() + pcPPS->getUseDQP(),                   "max_cu_qp_delta_depth" );
     309
     310  WRITE_SVLC( pcPPS->getChromaQpOffset(),                   "chroma_qp_offset"     );
     311  WRITE_SVLC( pcPPS->getChromaQpOffset2nd(),                "chroma_qp_offset_2nd" );
     312
     313  WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0,  "weighted_pred_flag" );   // Use of Weighting Prediction (P_SLICE)
     314  WRITE_CODE( pcPPS->getWPBiPredIdc(), 2, "weighted_bipred_idc" );  // Use of Weighting Bi-Prediction (B_SLICE)
     315#if H0388
     316  WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0,  "output_flag_present_flag" );
     317#endif
     318#if TILES_OR_ENTROPY_SYNC_IDC
     319  if(pcPPS->getSPS()->getTilesOrEntropyCodingSyncIdc()==1)
     320  {
     321#endif
     322    WRITE_FLAG( pcPPS->getColumnRowInfoPresent(),           "tile_info_present_flag" );
     323    WRITE_FLAG( pcPPS->getTileBehaviorControlPresentFlag(),  "tile_control_present_flag");
     324    if( pcPPS->getColumnRowInfoPresent() == 1 )
     325    {
     326      WRITE_UVLC( pcPPS->getNumColumnsMinus1(),                                    "num_tile_columns_minus1" );
     327      WRITE_UVLC( pcPPS->getNumRowsMinus1(),                                       "num_tile_rows_minus1" );
     328      WRITE_FLAG( pcPPS->getUniformSpacingIdr(),                                   "uniform_spacing_flag" );
     329      if( pcPPS->getUniformSpacingIdr() == 0 )
     330      {
     331        for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
     332        {
     333          WRITE_UVLC( pcPPS->getColumnWidth(i),                                    "column_width" );
     334        }
     335        for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
     336        {
     337          WRITE_UVLC( pcPPS->getRowHeight(i),                                      "row_height" );
     338        }
     339      }
     340    }
     341
     342    if(pcPPS->getTileBehaviorControlPresentFlag() == 1)
     343    {
     344      Int iNumColTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumColumnsMinus1());
     345      Int iNumRowTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumRowsMinus1());
     346
     347      if(iNumColTilesMinus1 !=0 || iNumRowTilesMinus1 !=0)
     348      {
     349#if !REMOVE_TILE_DEPENDENCE
     350        WRITE_FLAG( pcPPS->getTileBoundaryIndependenceIdr(),                         "tile_boundary_independence_flag" );
     351        if(pcPPS->getTileBoundaryIndependenceIdr() == 1)
     352        {
     353#endif
     354          WRITE_FLAG( pcPPS->getLFCrossTileBoundaryFlag()?1 : 0,            "loop_filter_across_tile_flag");
     355#if !REMOVE_TILE_DEPENDENCE
     356        }
     357#endif
     358      }
     359    }
     360#if TILES_OR_ENTROPY_SYNC_IDC
     361  }
     362  else if(pcPPS->getSPS()->getTilesOrEntropyCodingSyncIdc()==2)
     363  {
     364    WRITE_UVLC( pcPPS->getNumSubstreams()-1,               "num_substreams_minus1" );
     365  }
     366#endif
     367
     368#if DBL_CONTROL
     369  WRITE_FLAG( pcPPS->getDeblockingFilterControlPresent()?1 : 0, "deblocking_filter_control_present_flag");
     370#endif
     371#if PARALLEL_MERGE
     372  WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
     373#endif
     374  WRITE_FLAG( 0, "pps_extension_flag" );
     375}
     376
     377#if HHI_MPI
     378Void TEncCavlc::codeSPS( TComSPS* pcSPS, Bool bIsDepth )
    244379#else
    245   codeNALUnitHeader( NAL_UNIT_PPS, NAL_REF_IDC_PRIORITY_HIGHEST );
    246 #endif
    247 
    248   xWriteUvlc( pcPPS->getPPSId() );
    249   xWriteUvlc( pcPPS->getSPSId() );
    250 #if CONSTRAINED_INTRA_PRED
    251   xWriteFlag( pcPPS->getConstrainedIntraPred() ? 1 : 0 );
    252 #endif
    253 #ifdef WEIGHT_PRED
    254   xWriteCode( pcPPS->getUseWP(), 1);        // Use of Weighting Prediction (P_SLICE)
    255   xWriteCode( pcPPS->getWPBiPredIdc(), 2);  // Use of Weighting Bi-Prediction (B_SLICE)
    256 #endif
    257   return;
    258 }
    259 
    260 #if BITSTREAM_EXTRACTION
    261 Void TEncCavlc::codeNALUnitHeader( NalUnitType eNalUnitType, NalRefIdc eNalRefIdc, UInt TemporalId, UInt uiLayerId )
    262 {
    263   // uiFirstByte
    264   xWriteCode( 0, 1);                    // forbidden_zero_flag
    265   xWriteCode( eNalRefIdc==0 ? 0:1, 1);  // nal_ref_flag
    266   xWriteCode( eNalUnitType, 6);         // nal_unit_type
    267 
    268   xWriteCode( TemporalId, 3);           // temporal_id
    269   xWriteCode( uiLayerId+1, 5);          // layer_id_plus1
    270 }
     380Void TEncCavlc::codeSPS( TComSPS* pcSPS )
     381#endif
     382{
     383#if ENC_DEC_TRACE 
     384  xTraceSPSHeader (pcSPS);
     385#endif
     386  WRITE_CODE( pcSPS->getProfileIdc (),     8,       "profile_idc" );
     387  WRITE_CODE( 0,                           8,       "reserved_zero_8bits" );
     388  WRITE_CODE( pcSPS->getLevelIdc (),       8,       "level_idc" );
     389  WRITE_UVLC( pcSPS->getSPSId (),                   "seq_parameter_set_id" );
     390  WRITE_UVLC( pcSPS->getChromaFormatIdc (),         "chroma_format_idc" );
     391  WRITE_CODE( pcSPS->getMaxTLayers() - 1,  3,       "max_temporal_layers_minus1" );
     392  WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (),   "pic_width_in_luma_samples" );
     393  WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(),   "pic_height_in_luma_samples" );
     394#if PIC_CROPPING
     395  WRITE_FLAG( pcSPS->getPicCroppingFlag(),          "pic_cropping_flag" );
     396  if (pcSPS->getPicCroppingFlag())
     397  {
     398    WRITE_UVLC( pcSPS->getPicCropLeftOffset(),      "pic_crop_left_offset" );
     399    WRITE_UVLC( pcSPS->getPicCropRightOffset(),     "pic_crop_right_offset" );
     400    WRITE_UVLC( pcSPS->getPicCropTopOffset(),       "pic_crop_top_offset" );
     401    WRITE_UVLC( pcSPS->getPicCropBottomOffset(),    "pic_crop_bottom_offset" );
     402  }
     403#endif
     404
     405#if FULL_NBIT
     406  WRITE_UVLC( pcSPS->getBitDepth() - 8,             "bit_depth_luma_minus8" );
    271407#else
    272 Void TEncCavlc::codeNALUnitHeader( NalUnitType eNalUnitType, NalRefIdc eNalRefIdc, UInt TemporalId, Bool bOutputFlag )
    273 {
    274   // uiFirstByte
    275   xWriteCode( 0, 1);            // forbidden_zero_flag
    276   xWriteCode( eNalRefIdc, 2);   // nal_ref_idc
    277   xWriteCode( eNalUnitType, 5); // nal_unit_type
    278 
    279   if ( (eNalUnitType == NAL_UNIT_CODED_SLICE) || (eNalUnitType == NAL_UNIT_CODED_SLICE_IDR) || (eNalUnitType == NAL_UNIT_CODED_SLICE_CDR) )
    280   {
    281     xWriteCode( TemporalId, 3);   // temporal_id
    282     xWriteFlag( bOutputFlag );    // output_flag
    283     xWriteCode( 1, 4);            // reseved_one_4bits
    284   }
    285 }
    286 #endif
    287 
    288 Void TEncCavlc::codeSPS( TComSPS* pcSPS )
    289 {
    290   // uiFirstByte
    291 #if BITSTREAM_EXTRACTION
    292   codeNALUnitHeader( NAL_UNIT_SPS, NAL_REF_IDC_PRIORITY_HIGHEST, 0, pcSPS->getLayerId() );
     408  WRITE_UVLC( pcSPS->getBitIncrement(),             "bit_depth_luma_minus8" );
     409#endif
     410#if FULL_NBIT
     411  WRITE_UVLC( pcSPS->getBitDepth() - 8,             "bit_depth_chroma_minus8" );
    293412#else
    294   codeNALUnitHeader( NAL_UNIT_SPS, NAL_REF_IDC_PRIORITY_HIGHEST );
    295 #endif
    296 
    297   // Structure
    298   xWriteUvlc  ( pcSPS->getSPSId() );
    299   xWriteUvlc  ( pcSPS->getWidth () );
    300   xWriteUvlc  ( pcSPS->getHeight() );
    301 
     413  WRITE_UVLC( pcSPS->getBitIncrement(),             "bit_depth_chroma_minus8" );
     414#endif
     415
     416  WRITE_FLAG( pcSPS->getUsePCM() ? 1 : 0,                   "pcm_enabled_flag");
     417
     418  if( pcSPS->getUsePCM() )
     419  {
     420  WRITE_CODE( pcSPS->getPCMBitDepthLuma() - 1, 4,   "pcm_bit_depth_luma_minus1" );
     421  WRITE_CODE( pcSPS->getPCMBitDepthChroma() - 1, 4, "pcm_bit_depth_chroma_minus1" );
     422  }
     423
     424#if LOSSLESS_CODING
     425  WRITE_FLAG( (pcSPS->getUseLossless ()) ? 1 : 0,                                    "qpprime_y_zero_transquant_bypass_flag" );
     426#endif
     427
     428  WRITE_UVLC( pcSPS->getBitsForPOC()-4,                 "log2_max_pic_order_cnt_lsb_minus4" );
     429#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
     430  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
     431  {
     432    WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i),           "max_dec_pic_buffering[i]" );
     433    WRITE_UVLC( pcSPS->getNumReorderPics(i),               "num_reorder_pics[i]" );
     434    WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "max_latency_increase[i]" );
     435  }
     436#else
     437  WRITE_UVLC( pcSPS->getMaxNumberOfReferencePictures(), "max_num_ref_pics" );
     438  WRITE_UVLC( pcSPS->getNumReorderFrames(),             "num_reorder_frames" );
     439  WRITE_UVLC(pcSPS->getMaxDecFrameBuffering(),          "max_dec_frame_buffering" );
     440  WRITE_UVLC(pcSPS->getMaxLatencyIncrease(),            "max_latency_increase"    );
     441#endif
     442  assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
     443 
     444  UInt MinCUSize = pcSPS->getMaxCUWidth() >> ( pcSPS->getMaxCUDepth()-g_uiAddCUDepth );
     445  UInt log2MinCUSize = 0;
     446  while(MinCUSize > 1)
     447  {
     448    MinCUSize >>= 1;
     449    log2MinCUSize++;
     450  }
     451
     452#if H0412_REF_PIC_LIST_RESTRICTION
     453  WRITE_FLAG( pcSPS->getRestrictedRefPicListsFlag(),                                 "restricted_ref_pic_lists_flag" );
     454  if( pcSPS->getRestrictedRefPicListsFlag() )
     455  {
     456    WRITE_FLAG( pcSPS->getListsModificationPresentFlag(),                            "lists_modification_present_flag" );
     457  }
     458#endif
     459  WRITE_UVLC( log2MinCUSize - 3,                                                     "log2_min_coding_block_size_minus3" );
     460  WRITE_UVLC( pcSPS->getMaxCUDepth()-g_uiAddCUDepth,                                 "log2_diff_max_min_coding_block_size" );
     461  WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2,                                 "log2_min_transform_block_size_minus2" );
     462  WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_transform_block_size" );
     463
     464  if(log2MinCUSize == 3)
     465  {
     466    xWriteFlag  ( (pcSPS->getDisInter4x4()) ? 1 : 0 );
     467  }
     468
     469  if( pcSPS->getUsePCM() )
     470  {
     471    WRITE_UVLC( pcSPS->getPCMLog2MinSize() - 3,                                      "log2_min_pcm_coding_block_size_minus3" );
     472    WRITE_UVLC( pcSPS->getPCMLog2MaxSize() - pcSPS->getPCMLog2MinSize(),             "log2_diff_max_min_pcm_coding_block_size" );
     473  }
     474  WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthInter() - 1,                               "max_transform_hierarchy_depth_inter" );
     475  WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthIntra() - 1,                               "max_transform_hierarchy_depth_intra" );
     476  WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0,                                   "scaling_list_enabled_flag" );
     477  WRITE_FLAG( pcSPS->getUseLMChroma () ? 1 : 0,                                      "chroma_pred_from_luma_enabled_flag" );
     478  WRITE_FLAG( pcSPS->getUseDF() ? 1 : 0,                                             "deblocking_filter_in_aps_enabled_flag");
     479  WRITE_FLAG( pcSPS->getLFCrossSliceBoundaryFlag()?1 : 0,                            "seq_loop_filter_across_slices_enabled_flag");
     480  WRITE_FLAG( pcSPS->getUseAMP(),                                                    "asymmetric_motion_partitions_enabled_flag" );
     481  WRITE_FLAG( pcSPS->getUseNSQT(),                                                   "non_square_quadtree_enabled_flag" );
     482  WRITE_FLAG( pcSPS->getUseSAO() ? 1 : 0,                                            "sample_adaptive_offset_enabled_flag");
     483  WRITE_FLAG( pcSPS->getUseALF () ? 1 : 0,                                           "adaptive_loop_filter_enabled_flag");
     484#if LCU_SYNTAX_ALF
     485  if(pcSPS->getUseALF())
     486  {
     487    WRITE_FLAG( (pcSPS->getUseALFCoefInSlice()) ? 1 : 0,                             "alf_coef_in_slice_flag");
     488  }
     489#endif
     490
     491  if( pcSPS->getUsePCM() )
     492  {
     493  WRITE_FLAG( pcSPS->getPCMFilterDisableFlag()?1 : 0,                                "pcm_loop_filter_disable_flag");
     494  }
     495
     496  assert( pcSPS->getMaxTLayers() > 0 );         
     497
     498  WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0,                             "temporal_id_nesting_flag" );
     499
     500#if RPS_IN_SPS
     501  TComRPSList* rpsList = pcSPS->getRPSList();
     502  TComReferencePictureSet*      rps;
     503
     504  WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
     505  for(Int i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
     506  {
     507    rps = rpsList->getReferencePictureSet(i);
     508    codeShortTermRefPicSet(pcSPS,rps);
     509  }   
     510  WRITE_FLAG( pcSPS->getLongTermRefsPresent() ? 1 : 0,         "long_term_ref_pics_present_flag" );
     511#endif
     512#if !PIC_CROPPING
     513  //!!!KS: Syntax not in WD !!!
     514 
    302515  xWriteUvlc  ( pcSPS->getPad (0) );
    303516  xWriteUvlc  ( pcSPS->getPad (1) );
    304 
    305   assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
    306   xWriteUvlc  ( pcSPS->getMaxCUWidth()   );
    307   xWriteUvlc  ( pcSPS->getMaxCUDepth()-g_uiAddCUDepth );
    308 
    309   xWriteUvlc( pcSPS->getQuadtreeTULog2MinSize() - 2 );
    310   xWriteUvlc( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize() );
    311   xWriteUvlc( pcSPS->getQuadtreeTUMaxDepthInter() - 1 );
    312   xWriteUvlc( pcSPS->getQuadtreeTUMaxDepthIntra() - 1 );
    313 
    314   xWriteUvlc( pcSPS->getCodedPictureBufferSize() );
    315 
    316   // Tools
    317   xWriteFlag  ( (pcSPS->getUseALF ()) ? 1 : 0 );
    318   xWriteFlag  ( (pcSPS->getUseDQP ()) ? 1 : 0 );
    319 #if !HHI_NO_LowDelayCoding
    320   xWriteFlag  ( (pcSPS->getUseLDC ()) ? 1 : 0 );
    321 #endif
    322   xWriteFlag  ( (pcSPS->getUseMRG ()) ? 1 : 0 ); // SOPH:
    323 
    324 #if LM_CHROMA
    325   xWriteFlag  ( (pcSPS->getUseLMChroma ()) ? 1 : 0 );
    326 #endif
    327 
    328 #if HHI_RMP_SWITCH
    329   xWriteFlag  ( (pcSPS->getUseRMP()) ? 1 : 0 );
    330 #endif
    331 
     517#endif
    332518  // AMVP mode for each depth
    333519  for (Int i = 0; i < pcSPS->getMaxCUDepth(); i++)
     
    336522  }
    337523
    338   // Bit-depth information
    339 #if FULL_NBIT
    340   xWriteUvlc( pcSPS->getBitDepth() - 8 );
     524#if TILES_WPP_ENTRY_POINT_SIGNALLING
     525  Int tilesOrEntropyCodingSyncIdc = 0;
     526  if ( pcSPS->getNumColumnsMinus1() > 0 || pcSPS->getNumRowsMinus1() > 0)
     527  {
     528    tilesOrEntropyCodingSyncIdc = 1;
     529  }
     530  else if ( pcSPS->getNumSubstreams() > 1 )
     531  {
     532    tilesOrEntropyCodingSyncIdc = 2;
     533  }
     534  pcSPS->setTilesOrEntropyCodingSyncIdc( tilesOrEntropyCodingSyncIdc );
     535  WRITE_CODE(tilesOrEntropyCodingSyncIdc, 2, "tiles_or_entropy_coding_sync_idc");
     536#endif
     537
     538#if TILES_OR_ENTROPY_SYNC_IDC
     539  if(tilesOrEntropyCodingSyncIdc == 1)
     540  {
     541#endif
     542    WRITE_UVLC( pcSPS->getNumColumnsMinus1(),                           "num_tile_columns_minus1" );
     543    WRITE_UVLC( pcSPS->getNumRowsMinus1(),                              "num_tile_rows_minus1" );
     544    WRITE_FLAG( pcSPS->getUniformSpacingIdr(),                          "uniform_spacing_flag" );
     545
     546    if( pcSPS->getUniformSpacingIdr()==0 )
     547    {
     548      for(UInt i=0; i<pcSPS->getNumColumnsMinus1(); i++)
     549      {
     550        WRITE_UVLC( pcSPS->getColumnWidth(i),                           "column_width" );
     551      }
     552      for(UInt i=0; i<pcSPS->getNumRowsMinus1(); i++)
     553      {
     554        WRITE_UVLC( pcSPS->getRowHeight(i),                             "row_height" );
     555      }
     556    }
     557
     558    if( pcSPS->getNumColumnsMinus1() !=0 || pcSPS->getNumRowsMinus1() != 0)
     559    {
     560#if !REMOVE_TILE_DEPENDENCE
     561      WRITE_FLAG( pcSPS->getTileBoundaryIndependenceIdr(),                "tile_boundary_independence_flag" );
     562      if(pcSPS->getTileBoundaryIndependenceIdr() == 1)
     563      {
     564#endif
     565        WRITE_FLAG( pcSPS->getLFCrossTileBoundaryFlag()?1 : 0,            "loop_filter_across_tile_flag");
     566#if !REMOVE_TILE_DEPENDENCE
     567      }
     568#endif
     569    }
     570#if TILES_OR_ENTROPY_SYNC_IDC
     571  }
     572#endif
     573  WRITE_FLAG( 1, "sps_extension_flag" );
     574
     575  WRITE_FLAG( (pcSPS->getNumberOfUsableInterViewRefs() > 0) ? 1 : 0, "interview_refs_present_flag" );
     576  if( pcSPS->getNumberOfUsableInterViewRefs() > 0 )
     577  {
     578    WRITE_UVLC( pcSPS->getNumberOfUsableInterViewRefs() - 1,   "num_usable_interview_refs_minus1" );
     579
     580    Int prev = 0;
     581    for( Int j = 0 ; j < pcSPS->getNumberOfUsableInterViewRefs(); j++ )
     582    {
     583      WRITE_UVLC( prev - pcSPS->getUsableInterViewRef( j ) - 1, "delta_usable_interview_ref_minus1" );
     584      prev = pcSPS->getUsableInterViewRef( j );
     585    }
     586  }
     587
     588#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
     589  WRITE_FLAG( pcSPS->getUseDMM(), "enable_dmm_flag" );
     590#endif
     591
     592#if HHI_MPI
     593  if( bIsDepth )
     594  {
     595    WRITE_FLAG( pcSPS->getUseMVI() ? 1 : 0, "use_mvi_flag" );
     596  }
     597#endif
     598
     599  if( pcSPS->getViewId() || pcSPS->isDepth() )
     600  {
     601    WRITE_FLAG( 0, "base_view_flag" );
     602    if( pcSPS->isDepth() )
     603    {
     604      WRITE_FLAG( 1, "depth_flag" );
     605      WRITE_UVLC( pcSPS->getViewId(), "view_id" );
     606      WRITE_SVLC( pcSPS->getViewOrderIdx(), "view_order_idx" );
     607    }
     608    else
     609    {
     610      WRITE_FLAG( 0, "depth_flag" );
     611      WRITE_UVLC( pcSPS->getViewId() - 1, "view_id_minus1" );
     612      WRITE_SVLC( pcSPS->getViewOrderIdx(), "view_order_idx" );
     613      WRITE_UVLC( pcSPS->getCamParPrecision(), "camera_parameter_precision" );
     614      WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "camera_parameter_in_slice_header" );
     615      if( !pcSPS->hasCamParInSliceHeader() )
     616      {
     617        for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ )
     618        {
     619          WRITE_SVLC( pcSPS->getCodedScale    ()[ uiId ], "coded_scale" );
     620          WRITE_SVLC( pcSPS->getCodedOffset   ()[ uiId ], "coded_offset" );
     621          WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiId ] + pcSPS->getCodedScale ()[ uiId ], "inverse_coded_scale_plus_coded_scale" );
     622          WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiId ] + pcSPS->getCodedOffset()[ uiId ], "inverse_coded_offset_plus_coded_offset" );
     623        }
     624      }
     625#if DEPTH_MAP_GENERATION
     626      WRITE_UVLC( pcSPS->getPredDepthMapGeneration(), "Pdm_generation" );
     627      if( pcSPS->getPredDepthMapGeneration() )
     628      {
     629        WRITE_UVLC( pcSPS->getPdmPrecision(), "Pdm_precision" );
     630        for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ )
     631        {
     632          WRITE_SVLC( pcSPS->getPdmScaleNomDelta()[ uiId ], "Pdm_scale_nom_delta" );
     633          WRITE_SVLC( pcSPS->getPdmOffset       ()[ uiId ], "Pdm_offset" );
     634        }
     635#if HHI_INTER_VIEW_MOTION_PRED
     636        WRITE_UVLC( pcSPS->getMultiviewMvPredMode(), "multi_view_mv_pred_mode" );
     637#endif
     638#if HHI_INTER_VIEW_RESIDUAL_PRED
     639        WRITE_FLAG  ( pcSPS->getMultiviewResPredMode(), "multi_view_residual_pred_mode" );
     640#endif
     641      }
     642#endif
     643    }
     644  }
     645  else
     646  {
     647    WRITE_FLAG( 1, "base_view_flag" );   
     648  }
     649  WRITE_FLAG( 0, "sps_extension2_flag" );
     650}
     651
     652Void TEncCavlc::writeTileMarker( UInt uiTileIdx, UInt uiBitsUsed )
     653{
     654  xWriteCode( uiTileIdx, uiBitsUsed );
     655}
     656
     657Void TEncCavlc::codeSliceHeader         ( TComSlice* pcSlice )
     658{
     659#if ENC_DEC_TRACE 
     660  xTraceSliceHeader (pcSlice);
     661#endif
     662
     663  // if( nal_ref_idc != 0 )
     664  //   dec_ref_pic_marking( )
     665  // if( entropy_coding_mode_flag  &&  slice_type  !=  I)
     666  //   cabac_init_idc
     667  // first_slice_in_pic_flag
     668  // if( first_slice_in_pic_flag == 0 )
     669  //    slice_address
     670  //calculate number of bits required for slice address
     671  Int maxAddrOuter = pcSlice->getPic()->getNumCUsInFrame();
     672  Int reqBitsOuter = 0;
     673  while(maxAddrOuter>(1<<reqBitsOuter))
     674  {
     675    reqBitsOuter++;
     676  }
     677  Int maxAddrInner = pcSlice->getPic()->getNumPartInCU()>>(2);
     678  maxAddrInner = (1<<(pcSlice->getPPS()->getSliceGranularity()<<1));
     679  Int reqBitsInner = 0;
     680 
     681  while(maxAddrInner>(1<<reqBitsInner))
     682  {
     683    reqBitsInner++;
     684  }
     685  Int lCUAddress;
     686  Int innerAddress;
     687  if (pcSlice->isNextSlice())
     688  {
     689    // Calculate slice address
     690    lCUAddress = (pcSlice->getSliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
     691    innerAddress = (pcSlice->getSliceCurStartCUAddr()%(pcSlice->getPic()->getNumPartInCU()))>>((pcSlice->getSPS()->getMaxCUDepth()-pcSlice->getPPS()->getSliceGranularity())<<1);
     692  }
     693  else
     694  {
     695    // Calculate slice address
     696    lCUAddress = (pcSlice->getEntropySliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
     697    innerAddress = (pcSlice->getEntropySliceCurStartCUAddr()%(pcSlice->getPic()->getNumPartInCU()))>>((pcSlice->getSPS()->getMaxCUDepth()-pcSlice->getPPS()->getSliceGranularity())<<1);
     698   
     699  }
     700  //write slice address
     701  Int address = (pcSlice->getPic()->getPicSym()->getCUOrderMap(lCUAddress) << reqBitsInner) + innerAddress;
     702  WRITE_FLAG( address==0, "first_slice_in_pic_flag" );
     703  if(address>0)
     704  {
     705    WRITE_CODE( address, reqBitsOuter+reqBitsInner, "slice_address" );
     706  }
     707
     708  WRITE_UVLC( pcSlice->getSliceType(),       "slice_type" );
     709  Bool bEntropySlice = (!pcSlice->isNextSlice());
     710  WRITE_FLAG( bEntropySlice ? 1 : 0, "lightweight_slice_flag" );
     711 
     712  if (!bEntropySlice)
     713  {
     714    WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "pic_parameter_set_id" );
     715#if H0388
     716    if( pcSlice->getPPS()->getOutputFlagPresentFlag() )
     717    {
     718      WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" );
     719    }
     720#endif
     721    if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR)
     722    {
     723      WRITE_UVLC( 0, "idr_pic_id" );
     724      WRITE_FLAG( 0, "no_output_of_prior_pics_flag" );
     725    }
     726    else
     727    {
     728      WRITE_CODE( (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC()))%(1<<pcSlice->getSPS()->getBitsForPOC()), pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb");
     729
     730      if( pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_IDV )
     731      {
     732        TComReferencePictureSet* rps = pcSlice->getRPS();
     733        if(pcSlice->getRPSidx() < 0)
     734        {
     735          WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
     736#if RPS_IN_SPS
     737          codeShortTermRefPicSet(pcSlice->getSPS(), rps);
    341738#else
    342 #if ENABLE_IBDI
    343   xWriteUvlc( pcSPS->getBitDepth() - 8 );
    344 #endif
    345   xWriteUvlc( pcSPS->getBitIncrement() );
    346 #endif
    347 
    348 #if MTK_NONCROSS_INLOOP_FILTER
    349   xWriteFlag( pcSPS->getLFCrossSliceBoundaryFlag()?1 : 0);
    350 #endif
    351 #if MTK_SAO
    352   xWriteFlag( pcSPS->getUseSAO() ? 1 : 0);
    353 #endif
    354 
    355   if( pcSPS->getViewId() || pcSPS->isDepth() )
    356   {
    357     xWriteFlag( 0 ); // inverse of RBSP stop bit (for backwards compatible extension)
    358     if( pcSPS->isDepth() )
    359     {
    360       xWriteFlag( 1 ); // depth
    361       xWriteUvlc( pcSPS->getViewId() );
    362       xWriteSvlc( pcSPS->getViewOrderIdx() );
    363 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    364       xWriteFlag( pcSPS->getUseDMM() ? 1 : 0 );
    365 #endif
    366 #if HHI_MPI
    367       xWriteFlag( pcSPS->getUseMVI() ? 1 : 0 );
    368 #endif
     739          codeShortTermRefPicSet(pcSlice->getPPS(), rps);
     740#endif
     741        }
     742        else
     743        {
     744          WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
     745          WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" );
     746        }
     747#if RPS_IN_SPS
     748        if(pcSlice->getSPS()->getLongTermRefsPresent())
     749#else
     750        if(pcSlice->getPPS()->getLongTermRefsPresent())
     751#endif
     752        {
     753          WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics");
     754          Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC();
     755          Int prev = 0;
     756#if LTRP_MULT
     757          Int prevDeltaPocLt=0;
     758          Int currDeltaPocLt=0;
     759#endif
     760          for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--)
     761          {
     762            WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt");
     763         
     764#if LTRP_MULT
     765            currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt;
     766
     767            Int deltaMsbCycle=0;
     768            if( (i==(rps->getNumberOfPictures()-1)) )
     769            {
     770              deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
     771            }
     772            else if( prevDeltaPocLt!=currDeltaPocLt )
     773            {
     774              deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
     775              if( ((prevDeltaPocLt==maxPocLsb-1) && (currDeltaPocLt==maxPocLsb+1)) ||  ((prevDeltaPocLt==maxPocLsb-2) && (currDeltaPocLt==maxPocLsb)))
     776              {
     777                deltaMsbCycle=deltaMsbCycle-1;
     778              }
     779            }
     780            else
     781            {
     782              deltaMsbCycle=((rps->getDeltaPOC(i+1)-rps->getDeltaPOC(i))/maxPocLsb)-1;
     783            }
     784
     785            if(deltaMsbCycle>=0)
     786            {
     787              WRITE_FLAG( 1, "delta_poc_msb_present_flag");
     788              WRITE_UVLC(deltaMsbCycle, "delta_poc_msb_cycle_lt_minus1");
     789            }
     790            else
     791            {
     792              WRITE_FLAG( 0, "delta_poc_msb_present_flag");
     793            }
     794            prevDeltaPocLt=currDeltaPocLt;
     795#endif
     796            prev = rps->getDeltaPOC(i);
     797            WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
     798          }
     799        }
     800      }
     801    }
     802
     803    if(pcSlice->getSPS()->getUseSAO() || pcSlice->getSPS()->getUseALF()|| pcSlice->getSPS()->getScalingListFlag() || pcSlice->getSPS()->getUseDF())
     804    {
     805      if (pcSlice->getSPS()->getUseALF())
     806      {
     807#if !LCU_SYNTAX_ALF
     808         if (pcSlice->getAlfEnabledFlag())
     809         {
     810           assert (pcSlice->getAPS()->getAlfEnabled());
     811         }
     812#endif
     813         WRITE_FLAG( pcSlice->getAlfEnabledFlag(), "ALF on/off flag in slice header" );
     814      }
     815      if (pcSlice->getSPS()->getUseSAO())
     816      {
     817#if SAO_UNIT_INTERLEAVING
     818        WRITE_FLAG( pcSlice->getSaoInterleavingFlag(), "SAO interleaving flag" );
     819#endif
     820         assert (pcSlice->getSaoEnabledFlag() == pcSlice->getAPS()->getSaoEnabled());
     821         WRITE_FLAG( pcSlice->getSaoEnabledFlag(), "SAO on/off flag in slice header" );
     822#if SAO_UNIT_INTERLEAVING
     823         if (pcSlice->getSaoInterleavingFlag()&&pcSlice->getSaoEnabledFlag() )
     824         {
     825           WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[1], "SAO on/off flag for Cb in slice header" );
     826           WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[2], "SAO on/off flag for Cr in slice header" );
     827         }
     828#endif
     829      }
     830      WRITE_UVLC( pcSlice->getAPS()->getAPSID(), "aps_id");
     831    }
     832
     833    // we always set num_ref_idx_active_override_flag equal to one. this might be done in a more intelligent way
     834    if (!pcSlice->isIntra())
     835    {
     836      WRITE_FLAG( 1 ,                                             "num_ref_idx_active_override_flag");
     837      WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1, 3, "num_ref_idx_l0_active_minus1" );
    369838    }
    370839    else
    371840    {
    372       xWriteFlag( 0 ); // not depth
    373       xWriteUvlc( pcSPS->getViewId() - 1 );
    374       xWriteSvlc( pcSPS->getViewOrderIdx() );
    375       xWriteUvlc( pcSPS->getCamParPrecision() );
    376       xWriteFlag( pcSPS->hasCamParInSliceHeader() ? 1 : 0 );
    377       if( !pcSPS->hasCamParInSliceHeader() )
    378       {
    379         for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ )
    380         {
    381           xWriteSvlc( pcSPS->getCodedScale    ()[ uiId ] );
    382           xWriteSvlc( pcSPS->getCodedOffset   ()[ uiId ] );
    383           xWriteSvlc( pcSPS->getInvCodedScale ()[ uiId ] + pcSPS->getCodedScale ()[ uiId ] );
    384           xWriteSvlc( pcSPS->getInvCodedOffset()[ uiId ] + pcSPS->getCodedOffset()[ uiId ] );
    385         }
    386       }
    387 #if DEPTH_MAP_GENERATION
    388       xWriteUvlc( pcSPS->getPredDepthMapGeneration() );
    389       if( pcSPS->getPredDepthMapGeneration() )
    390       {
    391         xWriteUvlc  ( pcSPS->getPdmPrecision() );
    392         for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ )
    393         {
    394           xWriteSvlc( pcSPS->getPdmScaleNomDelta()[ uiId ] );
    395           xWriteSvlc( pcSPS->getPdmOffset       ()[ uiId ] );
    396         }
    397 #if HHI_INTER_VIEW_MOTION_PRED
    398         xWriteUvlc  ( pcSPS->getMultiviewMvPredMode() );
    399 #endif
    400 #if HHI_INTER_VIEW_RESIDUAL_PRED
    401         xWriteFlag  ( pcSPS->getMultiviewResPredMode() );
    402 #endif
    403       }
    404 #endif
    405     }
    406   }
    407 }
    408 
    409 Void TEncCavlc::codeSliceHeader         ( TComSlice* pcSlice )
    410 {
    411   // here someone can add an appropriated NalRefIdc type
    412 #if DCM_DECODING_REFRESH
    413 #if BITSTREAM_EXTRACTION
    414   codeNALUnitHeader (pcSlice->getNalUnitType(), NAL_REF_IDC_PRIORITY_HIGHEST, 1, pcSlice->getLayerId());
     841      pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
     842    }
     843    if (pcSlice->isInterB())
     844    {
     845      WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1, 3, "num_ref_idx_l1_active_minus1" );
     846    }
     847    else
     848    {
     849      pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
     850    }
     851#if H0412_REF_PIC_LIST_RESTRICTION
     852    if( pcSlice->getSPS()->getListsModificationPresentFlag() )
     853    {
     854#endif
     855    TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
     856#if H0137_0138_LIST_MODIFICATION
     857    if( !pcSlice->isIntra() )
     858    {
     859      WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0,       "ref_pic_list_modification_flag_l0" );
     860      if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
     861      {
     862        Int NumPocTotalCurr = pcSlice->getNumPocTotalCurrMvc();
     863        if (NumPocTotalCurr > 1)
     864        {
     865          Int length = 1;
     866          NumPocTotalCurr --;
     867          while ( NumPocTotalCurr >>= 1)
     868          {
     869            length ++;
     870          }
     871          for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++)
     872          {
     873            WRITE_CODE( refPicListModification->getRefPicSetIdxL0(i), length, "list_entry_l0");
     874          }
     875        }
     876      }
     877    }
     878    if(pcSlice->isInterB())
     879    {   
     880      WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0,       "ref_pic_list_modification_flag_l1" );
     881      if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
     882      {
     883        Int NumPocTotalCurr = pcSlice->getNumPocTotalCurrMvc();
     884        if ( NumPocTotalCurr > 1 )
     885        {
     886          Int length = 1;
     887          NumPocTotalCurr --;
     888          while ( NumPocTotalCurr >>= 1)
     889          {
     890            length ++;
     891          }
     892          for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++)
     893          {
     894            WRITE_CODE( refPicListModification->getRefPicSetIdxL1(i), length, "list_entry_l1");
     895          }
     896        }
     897      }
     898    }
    415899#else
    416   codeNALUnitHeader (pcSlice->getNalUnitType(), NAL_REF_IDC_PRIORITY_HIGHEST, 1, true);
    417 #endif
    418 #else
    419 #if BITSTREAM_EXTRACTION
    420   codeNALUnitHeader (NAL_UNIT_CODED_SLICE, NAL_REF_IDC_PRIORITY_HIGHEST, 0, pcSlice->getLayerId());
    421 #else
    422   codeNALUnitHeader (NAL_UNIT_CODED_SLICE, NAL_REF_IDC_PRIORITY_HIGHEST);
    423 #endif
    424 #endif
    425 
    426   Bool bEntropySlice = false;
    427   if (pcSlice->isNextSlice())
    428   {
    429     xWriteFlag( 0 ); // Entropy slice flag
    430   }
    431   else
    432   {
    433     bEntropySlice = true;
    434     xWriteFlag( 1 ); // Entropy slice flag
    435   }
    436   if (!bEntropySlice)
    437   {
    438     assert( pcSlice->getPPS()->getPPSId() == pcSlice->getPPSId() );
    439     xWriteUvlc  ( pcSlice->getPPSId() );
    440     xWriteCode  (pcSlice->getPOC(), 10 );   //  9 == SPS->Log2MaxFrameNum
    441     xWriteUvlc  (pcSlice->getSliceType() );
    442     xWriteSvlc  (pcSlice->getSliceQp() );
    443   }
    444   if (pcSlice->isNextSlice())
    445   {
    446     xWriteUvlc(pcSlice->getSliceCurStartCUAddr());        // start CU addr for slice
    447   }
    448   else
    449   {
    450     xWriteUvlc(pcSlice->getEntropySliceCurStartCUAddr()); // start CU addr for entropy slice
    451   }
    452   if (!bEntropySlice)
    453   {
    454     xWriteFlag  (pcSlice->getSymbolMode() > 0 ? 1 : 0);
    455 
    456     if (!pcSlice->isIntra())
    457     {
    458       xWriteFlag  (pcSlice->isReferenced() ? 1 : 0);
    459   #if !HIGH_ACCURACY_BI
    460   #ifdef ROUNDING_CONTROL_BIPRED
    461       xWriteFlag  (pcSlice->isRounding() ? 1 : 0);
    462   #endif
    463   #endif
    464     }
    465 
    466     xWriteFlag  (pcSlice->getLoopFilterDisable());
    467 
    468     if (!pcSlice->isIntra())
    469     {
    470       xWriteCode  ((pcSlice->getNumRefIdx( REF_PIC_LIST_0 )), 3 );
    471     }
    472     else
    473     {
    474       pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
    475     }
    476     if (pcSlice->isInterB())
    477     {
    478       xWriteCode  ((pcSlice->getNumRefIdx( REF_PIC_LIST_1 )), 3 );
    479     }
    480     else
    481     {
    482       pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
    483     }
    484 
    485     if (!pcSlice->isIntra())
    486     {
    487 
    488       for(Int i = 0; i<pcSlice->getNumRefIdx(REF_PIC_LIST_0);i++)
    489       {
    490         const bool bInterViewRef = pcSlice->getViewIdx() != pcSlice->getRefPic( REF_PIC_LIST_0,i )->getViewIdx();
    491         xWriteFlag( bInterViewRef );
    492         if( bInterViewRef )
    493         {
    494           xWriteUvlc( pcSlice->getRefPic( REF_PIC_LIST_0,i )->getViewIdx() );
    495         }
    496         else
    497         {
    498           xWriteSvlc(pcSlice->getPOC()-pcSlice->getRefPOC(REF_PIC_LIST_0,i));
    499         }
    500       }
    501 
    502     }
    503     if( pcSlice->isInterB())
    504     {
    505       for(Int i = 0; i<pcSlice->getNumRefIdx(REF_PIC_LIST_1);i++)
    506       {
    507         const bool bInterViewRef = pcSlice->getViewIdx() != pcSlice->getRefPic( REF_PIC_LIST_1,i )->getViewIdx();
    508         xWriteFlag( bInterViewRef );
    509         if( bInterViewRef )
    510         {
    511           xWriteUvlc( pcSlice->getRefPic( REF_PIC_LIST_1,i )->getViewIdx() );
    512         }
    513         else
    514         {
    515           xWriteSvlc(pcSlice->getPOC()-pcSlice->getRefPOC(REF_PIC_LIST_1,i));
    516         }
    517       }
    518     }
    519 
    520 
    521   #if DCM_COMB_LIST
    522     if (pcSlice->isInterB())
    523     {
    524       xWriteFlag  (pcSlice->getRefPicListCombinationFlag() ? 1 : 0 );
    525       if(pcSlice->getRefPicListCombinationFlag())
    526       {
    527         xWriteUvlc( pcSlice->getNumRefIdx(REF_PIC_LIST_C)-1);
    528 
    529         xWriteFlag  (pcSlice->getRefPicListModificationFlagLC() ? 1 : 0 );
     900      if(!pcSlice->isIntra())
     901      {
     902        WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0,       "ref_pic_list_modification_flag" );   
     903        for(Int i = 0; i < refPicListModification->getNumberOfRefPicListModificationsL0(); i++)
     904        {
     905          WRITE_UVLC( refPicListModification->getListIdcL0(i), "ref_pic_list_modification_idc");
     906          WRITE_UVLC( refPicListModification->getRefPicSetIdxL0(i), "ref_pic_set_idx");
     907        }
     908        if(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
     909          WRITE_UVLC( 3, "ref_pic_list_modification_idc");
     910      }
     911      if(pcSlice->isInterB())
     912      {   
     913        WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0,       "ref_pic_list_modification_flag" );
     914        for(Int i = 0; i < refPicListModification->getNumberOfRefPicListModificationsL1(); i++)
     915        {
     916          WRITE_UVLC( refPicListModification->getListIdcL1(i), "ref_pic_list_modification_idc");
     917          WRITE_UVLC( refPicListModification->getRefPicSetIdxL1(i), "ref_pic_set_idx");
     918        }
     919        if(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
     920          WRITE_UVLC( 3, "ref_pic_list_modification_idc");
     921      }
     922#endif
     923    }
     924#if H0412_REF_PIC_LIST_RESTRICTION
     925  }
     926#endif
     927  // ref_pic_list_combination( )
     928  // maybe move to own function?
     929  if (pcSlice->isInterB())
     930  {
     931    WRITE_FLAG(pcSlice->getRefPicListCombinationFlag() ? 1 : 0,       "ref_pic_list_combination_flag" );
     932    if(pcSlice->getRefPicListCombinationFlag())
     933    {
     934      WRITE_UVLC( pcSlice->getNumRefIdx(REF_PIC_LIST_C) - 1,          "num_ref_idx lc_active_minus1");
     935     
     936#if H0412_REF_PIC_LIST_RESTRICTION
     937      if( pcSlice->getSPS()->getListsModificationPresentFlag() )
     938      {
     939#endif
     940        WRITE_FLAG( pcSlice->getRefPicListModificationFlagLC() ? 1 : 0, "ref_pic_list_modification_flag_lc" );
    530941        if(pcSlice->getRefPicListModificationFlagLC())
    531942        {
    532943          for (UInt i=0;i<pcSlice->getNumRefIdx(REF_PIC_LIST_C);i++)
    533944          {
    534             xWriteFlag( pcSlice->getListIdFromIdxOfLC(i));
    535             xWriteUvlc( pcSlice->getRefIdxFromIdxOfLC(i));
     945            WRITE_FLAG( pcSlice->getListIdFromIdxOfLC(i),               "pic_from_list_0_flag" );
     946#if H0137_0138_LIST_MODIFICATION
     947          if (((pcSlice->getListIdFromIdxOfLC(i)==REF_PIC_LIST_0) && pcSlice->getNumRefIdx( REF_PIC_LIST_0 )>1 ) || ((pcSlice->getListIdFromIdxOfLC(i)==REF_PIC_LIST_1) && pcSlice->getNumRefIdx( REF_PIC_LIST_1 )>1 ) )
     948          {
     949            WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i),               "ref_idx_list_curr" );
    536950          }
    537         }
    538       }
    539     }
     951#else
     952            WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i),               "ref_idx_list_curr" );
     953#endif
     954          }
     955        }
     956#if H0412_REF_PIC_LIST_RESTRICTION
     957      }
     958#endif
     959    }
     960  }
     961   
     962#if H0111_MVD_L1_ZERO
     963  if (pcSlice->isInterB())
     964  {
     965    WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0,   "mvd_l1_zero_flag");
     966  }
     967#endif
     968
     969  if(pcSlice->getPPS()->getEntropyCodingMode() && !pcSlice->isIntra())
     970  {
     971#if CABAC_INIT_FLAG
     972    if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag())
     973    {
     974      SliceType sliceType   = pcSlice->getSliceType();
     975      Int  encCABACTableIdx = pcSlice->getPPS()->getEncCABACTableIdx();
     976      Bool encCabacInitFlag = (sliceType!=encCABACTableIdx && encCABACTableIdx!=0) ? true : false;
     977      pcSlice->setCabacInitFlag( encCabacInitFlag );
     978      WRITE_FLAG( encCabacInitFlag?1:0, "cabac_init_flag" );
     979    }
     980#else
     981    WRITE_UVLC(pcSlice->getCABACinitIDC(),  "cabac_init_idc");
     982#endif
     983  }
     984
     985  // if( !lightweight_slice_flag ) {
     986  if (!bEntropySlice)
     987  {
     988    Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 );
     989    WRITE_SVLC( iCode, "slice_qp_delta" );
     990#if DBL_CONTROL
     991    if (pcSlice->getPPS()->getDeblockingFilterControlPresent())
     992    {
     993      if ( pcSlice->getSPS()->getUseDF() )
     994      {
     995        WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag");
     996      }
     997#else
     998    WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag");
     999#endif
     1000      if (!pcSlice->getInheritDblParamFromAPS())
     1001      {
     1002        WRITE_FLAG(pcSlice->getLoopFilterDisable(), "loop_filter_disable");  // should be an IDC
     1003        if(!pcSlice->getLoopFilterDisable())
     1004        {
     1005          WRITE_SVLC (pcSlice->getLoopFilterBetaOffset(), "beta_offset_div2");
     1006          WRITE_SVLC (pcSlice->getLoopFilterTcOffset(), "tc_offset_div2");
     1007        }
     1008      }
     1009#if DBL_CONTROL
     1010    }
     1011#endif
     1012    if ( pcSlice->getSliceType() == B_SLICE )
     1013    {
     1014      WRITE_FLAG( pcSlice->getColDir(), "collocated_from_l0_flag" );
     1015    }
     1016
     1017#if COLLOCATED_REF_IDX
     1018    if ( pcSlice->getSliceType() != I_SLICE &&
     1019      ((pcSlice->getColDir()==0 && pcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)||
     1020      (pcSlice->getColDir()==1  && pcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
     1021    {
     1022      WRITE_UVLC( pcSlice->getColRefIdx(), "collocated_ref_idx" );
     1023    }
     1024#endif
     1025 
     1026    if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) || (pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getSliceType()==B_SLICE) )
     1027    {
     1028      xCodePredWeightTable( pcSlice );
     1029    }
     1030  }
     1031
     1032  // !!!! sytnax elements not in the WD !!!!
     1033  if (!bEntropySlice)
     1034  {
     1035    if( pcSlice->getSPS()->hasCamParInSliceHeader() )
     1036    {
     1037      for( UInt uiId = 0; uiId < pcSlice->getSPS()->getViewId(); uiId++ )
     1038      {
     1039        WRITE_SVLC( pcSlice->getCodedScale    ()[ uiId ], "coded_scale" );
     1040        WRITE_SVLC( pcSlice->getCodedOffset   ()[ uiId ], "coded_offset" );
     1041        WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "inverse_coded_scale_plus_coded_scale" );
     1042        WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "inverse_coded_offset_plus_coded_offset" );
     1043      }
     1044    }
     1045  }
     1046 
     1047#if ( HHI_MPI || HHI_INTER_VIEW_MOTION_PRED )
     1048  #if ( HHI_MPI && HHI_INTER_VIEW_MOTION_PRED )
     1049  const int iExtraMergeCandidates = ( pcSlice->getSPS()->getUseMVI() || pcSlice->getSPS()->getMultiviewMvPredMode() ) ? 1 : 0;
     1050  #elif HHI_MPI
     1051  const int iExtraMergeCandidates = pcSlice->getSPS()->getUseMVI() ? 1 : 0;
     1052  #else
     1053  const int iExtraMergeCandidates = pcSlice->getSPS()->getMultiviewMvPredMode() ? 1 : 0;
    5401054  #endif
    541 
    542   #if 0
    543     xWriteFlag  (pcSlice->getDRBFlag() ? 1 : 0 );
    544     if ( !pcSlice->getDRBFlag() )
    545     {
    546       xWriteCode  (pcSlice->getERBIndex(), 2);
    547     }
    548   #endif
    549 
    550   #if AMVP_NEIGH_COL
    551     if ( pcSlice->getSliceType() == B_SLICE )
    552     {
    553       xWriteFlag( pcSlice->getColDir() );
    554     }
    555   #endif
    556 
    557 #ifdef WEIGHT_PRED
    558     if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) || (pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getSliceType()==B_SLICE) )
    559     {
    560       codeWeightPredTable( pcSlice );
    561     }
    562 #endif
    563     if( pcSlice->getSPS()->hasCamParInSliceHeader() )
    564     {
    565       for( UInt uiId = 0; uiId < pcSlice->getSPS()->getViewId(); uiId++ )
    566       {
    567         xWriteSvlc( pcSlice->getCodedScale    ()[ uiId ] );
    568         xWriteSvlc( pcSlice->getCodedOffset   ()[ uiId ] );
    569         xWriteSvlc( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ] );
    570         xWriteSvlc( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ] );
    571       }
    572     }
    573   }
    574 }
     1055  assert(pcSlice->getMaxNumMergeCand()<=(MRG_MAX_NUM_CANDS_SIGNALED+iExtraMergeCandidates));
     1056  assert(MRG_MAX_NUM_CANDS_SIGNALED<=MRG_MAX_NUM_CANDS);
     1057  WRITE_UVLC(MRG_MAX_NUM_CANDS + iExtraMergeCandidates - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand");
     1058#else
     1059  assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS_SIGNALED);
     1060  assert(MRG_MAX_NUM_CANDS_SIGNALED<=MRG_MAX_NUM_CANDS);
     1061  WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand");
     1062#endif
     1063}
     1064
     1065
     1066Void TEncCavlc::codeTileMarkerFlag(TComSlice* pcSlice)
     1067{
     1068  Bool bEntropySlice = (!pcSlice->isNextSlice());
     1069  if (!bEntropySlice)
     1070  {
     1071    xWriteFlag  (pcSlice->getTileMarkerFlag() ? 1 : 0 );
     1072  }
     1073}
     1074
     1075/**
     1076 - write wavefront substreams sizes for the slice header.
     1077 .
     1078 \param pcSlice Where we find the substream size information.
     1079 */
     1080#if TILES_WPP_ENTRY_POINT_SIGNALLING
     1081Void  TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice )
     1082{
     1083  Int tilesOrEntropyCodingSyncIdc = pSlice->getSPS()->getTilesOrEntropyCodingSyncIdc();
     1084
     1085  if ( tilesOrEntropyCodingSyncIdc == 0 )
     1086  {
     1087    return;
     1088  }
     1089
     1090  UInt numEntryPointOffsets = 0, offsetLenMinus1 = 0, maxOffset = 0;
     1091  UInt *entryPointOffset = NULL;
     1092  if (tilesOrEntropyCodingSyncIdc == 1) // tiles
     1093  {
     1094    numEntryPointOffsets = pSlice->getTileLocationCount();
     1095    entryPointOffset     = new UInt[numEntryPointOffsets];
     1096    for (Int idx=0; idx<pSlice->getTileLocationCount(); idx++)
     1097    {
     1098      if ( idx == 0 )
     1099      {
     1100        entryPointOffset [ idx ] = pSlice->getTileLocation( 0 );
     1101      }
     1102      else
     1103      {
     1104        entryPointOffset [ idx ] = pSlice->getTileLocation( idx ) - pSlice->getTileLocation( idx-1 );
     1105      }
     1106
     1107      if ( entryPointOffset[ idx ] > maxOffset )
     1108      {
     1109        maxOffset = entryPointOffset[ idx ];
     1110      }
     1111    }
     1112  }
     1113  else if (tilesOrEntropyCodingSyncIdc == 2) // wavefront
     1114  {
     1115    Int  numZeroSubstreamsAtEndOfSlice  = 0;
     1116    UInt* pSubstreamSizes               = pSlice->getSubstreamSizes();
     1117    // Find number of zero substreams at the end of slice
     1118    for (Int idx=pSlice->getPPS()->getNumSubstreams()-2; idx>=0; idx--)
     1119    {
     1120      if ( pSubstreamSizes[ idx ] ==  0 )
     1121      {
     1122        numZeroSubstreamsAtEndOfSlice++;
     1123      }
     1124      else
     1125      {
     1126        break;
     1127      }
     1128    }
     1129    numEntryPointOffsets       = pSlice->getPPS()->getNumSubstreams() - 1 - numZeroSubstreamsAtEndOfSlice;
     1130    entryPointOffset           = new UInt[numEntryPointOffsets];
     1131    for (Int idx=0; idx<numEntryPointOffsets; idx++)
     1132    {
     1133      entryPointOffset[ idx ] = ( pSubstreamSizes[ idx ] >> 3 ) ;
     1134      if ( entryPointOffset[ idx ] > maxOffset )
     1135      {
     1136        maxOffset = entryPointOffset[ idx ];
     1137      }
     1138    }
     1139  }
     1140
     1141  maxOffset += ((m_pcBitIf->getNumberOfWrittenBits() + 16) >> 3) + 8 + 2; // allowing for NALU header, slice header, bytes added for "offset_len_minus1" and "num_entry_point_offsets"
     1142
     1143  // Determine number of bits "offsetLenMinus1+1" required for entry point information
     1144  offsetLenMinus1 = 0;
     1145  while (1)
     1146  {
     1147    if (maxOffset >= (1 << offsetLenMinus1) )
     1148    {
     1149      offsetLenMinus1++;
     1150      if ( offsetLenMinus1 > 32 )
     1151      {
     1152        FATAL_ERROR_0("exceeded 32-bits", -1);
     1153      }
     1154    }
     1155    else
     1156    {
     1157      break;
     1158    }
     1159  }
     1160
     1161  WRITE_UVLC(numEntryPointOffsets, "num_entry_point_offsets");
     1162  if (numEntryPointOffsets>0)
     1163  {
     1164    WRITE_UVLC(offsetLenMinus1, "offset_len_minus1");
     1165  }
     1166
     1167  for (UInt idx=0; idx<numEntryPointOffsets; idx++)
     1168  {
     1169    if ( idx == 0 )
     1170    {
     1171      // Adding sizes of NALU header and slice header information to entryPointOffset[ 0 ]
     1172      Int bitDistFromNALUHdrStart    = m_pcBitIf->getNumberOfWrittenBits() + 16;
     1173      entryPointOffset[ idx ] += ( bitDistFromNALUHdrStart + numEntryPointOffsets*(offsetLenMinus1+1) ) >> 3;
     1174    }
     1175    WRITE_CODE(entryPointOffset[ idx ], offsetLenMinus1+1, "entry_point_offset");
     1176  }
     1177
     1178  delete [] entryPointOffset;
     1179}
     1180#else
     1181Void TEncCavlc::codeSliceHeaderSubstreamTable( TComSlice* pcSlice )
     1182{
     1183  UInt uiNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
     1184  UInt*puiSubstreamSizes = pcSlice->getSubstreamSizes();
     1185
     1186  // Write header information for all substreams except the last.
     1187  for (UInt ui = 0; ui+1 < uiNumSubstreams; ui++)
     1188  {
     1189    UInt uiNumbits = puiSubstreamSizes[ui];
     1190
     1191    //the 2 first bits are used to give the size of the header
     1192    if ( uiNumbits < (1<<8) )
     1193    {
     1194      xWriteCode(0,         2  );
     1195      xWriteCode(uiNumbits, 8  );
     1196    }
     1197    else if ( uiNumbits < (1<<16) )
     1198    {
     1199      xWriteCode(1,         2  );
     1200      xWriteCode(uiNumbits, 16 );
     1201    }
     1202    else if ( uiNumbits < (1<<24) )
     1203    {
     1204      xWriteCode(2,         2  );
     1205      xWriteCode(uiNumbits, 24 );
     1206    }
     1207    else if ( uiNumbits < (1<<31) )
     1208    {
     1209      xWriteCode(3,         2  );
     1210      xWriteCode(uiNumbits, 32 );
     1211    }
     1212    else
     1213    {
     1214      printf("Error in codeSliceHeaderTable\n");
     1215      exit(-1);
     1216    }
     1217  }
     1218}
     1219#endif
    5751220
    5761221Void TEncCavlc::codeTerminatingBit      ( UInt uilsLast )
     
    5801225Void TEncCavlc::codeSliceFinish ()
    5811226{
    582   if ( m_bRunLengthCoding && m_uiRun)
    583   {
    584     xWriteUvlc(m_uiRun);
    585   }
    586 }
    587 
     1227}
     1228
     1229#if HHI_INTER_VIEW_MOTION_PRED
     1230Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum )
     1231#else
    5881232Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
    589 {
    590   Int iSymbol = pcCU->getMVPIdx(eRefList, uiAbsPartIdx);
    591   Int iNum    = pcCU->getMVPNum(eRefList, uiAbsPartIdx);
    592 
    593   xWriteUnaryMaxSymbol(iSymbol, iNum-1);
    594 }
    595 #if QC_LCEC_INTER_MODE
     1233#endif
     1234{
     1235  assert(0);
     1236}
     1237
    5961238Void TEncCavlc::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    5971239{
    598   if ( pcCU->getSlice()->isIntra() && pcCU->isIntra( uiAbsPartIdx ) )
    599   {
    600 #if MTK_DISABLE_INTRA_NxN_SPLIT
    601     if( uiDepth == (g_uiMaxCUDepth - g_uiAddCUDepth))
    602 #endif
    603       xWriteFlag( pcCU->getPartitionSize(uiAbsPartIdx ) == SIZE_2Nx2N? 1 : 0 );
     1240  assert(0);
     1241}
     1242
     1243Void TEncCavlc::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1244{
     1245  assert(0);
     1246}
     1247
     1248Void TEncCavlc::codeMergeFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1249{
     1250  assert(0);
     1251}
     1252
     1253Void TEncCavlc::codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1254{
     1255  assert(0);
     1256}
     1257
     1258#if HHI_INTER_VIEW_RESIDUAL_PRED
     1259Void
     1260TEncCavlc::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1261{
     1262  assert(0);
     1263}
     1264#endif
     1265
     1266Void TEncCavlc::codeAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1267
     1268  if (!m_bAlfCtrl)
     1269  {
    6041270    return;
    6051271  }
    606 
    607 
    608 #if MTK_DISABLE_INTRA_NxN_SPLIT && HHI_DISABLE_INTER_NxN_SPLIT
    609   if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    610 #endif
    611   {
    612     if ((pcCU->getPartitionSize(uiAbsPartIdx ) == SIZE_NxN) || pcCU->isIntra( uiAbsPartIdx ))
    613     {
    614       UInt uiIntraFlag = ( pcCU->isIntra(uiAbsPartIdx));
    615       if (pcCU->getPartitionSize(uiAbsPartIdx ) == SIZE_2Nx2N)
    616       {
    617         xWriteFlag(1);
    618       }
    619       else
    620       {
    621         xWriteFlag(0);
    622 #if MTK_DISABLE_INTRA_NxN_SPLIT && !HHI_DISABLE_INTER_NxN_SPLIT
    623         if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    624 #elif !MTK_DISABLE_INTRA_NxN_SPLIT && HHI_DISABLE_INTER_NxN_SPLIT
    625         if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    626 #endif
    627         xWriteFlag( uiIntraFlag? 1 : 0 );
    628       }
    629 
    630       return;
    631     }
    632   }
    633 }
    634 #else
    635 Void TEncCavlc::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    636 {
    637   PartSize eSize         = pcCU->getPartitionSize( uiAbsPartIdx );
    638 
    639   if ( pcCU->getSlice()->isInterB() && pcCU->isIntra( uiAbsPartIdx ) )
    640   {
    641     xWriteFlag( 0 );
    642 #if HHI_RMP_SWITCH
    643     if( pcCU->getSlice()->getSPS()->getUseRMP() )
    644 #endif
    645     {
    646       xWriteFlag( 0 );
    647       xWriteFlag( 0 );
    648     }
    649 #if HHI_DISABLE_INTER_NxN_SPLIT
    650     if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    651     {
    652       xWriteFlag( 0 );
    653     }
    654 #else
    655     xWriteFlag( 0 );
    656 #endif
    657 #if MTK_DISABLE_INTRA_NxN_SPLIT
    658     if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    659 #endif
    660     {
    661       xWriteFlag( (eSize == SIZE_2Nx2N? 0 : 1) );
    662     }
     1272 
     1273  if( pcCU->getDepth(uiAbsPartIdx) > m_uiMaxAlfCtrlDepth && !pcCU->isFirstAbsZorderIdxInDepth(uiAbsPartIdx, m_uiMaxAlfCtrlDepth))
     1274  {
    6631275    return;
    6641276  }
    665 
    666   if ( pcCU->isIntra( uiAbsPartIdx ) )
    667   {
    668 #if MTK_DISABLE_INTRA_NxN_SPLIT
    669     if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    670 #endif
    671     {
    672       xWriteFlag( eSize == SIZE_2Nx2N? 1 : 0 );
    673     }
     1277 
     1278  // get context function is here
     1279  UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0;
     1280 
     1281  xWriteFlag( uiSymbol );
     1282}
     1283
     1284Void TEncCavlc::codeApsExtensionFlag ()
     1285{
     1286  WRITE_FLAG(0, "aps_extension_flag");
     1287}
     1288
     1289Void TEncCavlc::codeAlfCtrlDepth()
     1290
     1291  if (!m_bAlfCtrl)
     1292  {
    6741293    return;
    6751294  }
    676 
    677   switch(eSize)
    678   {
    679     case SIZE_2Nx2N:
    680     {
    681       xWriteFlag( 1 );
    682       break;
    683     }
    684     case SIZE_2NxN:
    685     {
    686       xWriteFlag( 0 );
    687       xWriteFlag( 1 );
    688       break;
    689     }
    690     case SIZE_Nx2N:
    691     {
    692       xWriteFlag( 0 );
    693       xWriteFlag( 0 );
    694       xWriteFlag( 1 );
    695       break;
    696     }
    697     case SIZE_NxN:
    698     {
    699 #if HHI_DISABLE_INTER_NxN_SPLIT
    700       if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    701 #endif
    702       {
    703         xWriteFlag( 0 );
    704 #if HHI_RMP_SWITCH
    705         if( pcCU->getSlice()->getSPS()->getUseRMP())
    706 #endif
    707         {
    708           xWriteFlag( 0 );
    709           xWriteFlag( 0 );
    710         }
    711         if (pcCU->getSlice()->isInterB())
    712         {
    713           xWriteFlag( 1 );
    714         }
    715       }
    716       break;
    717     }
    718     default:
    719     {
    720       assert(0);
    721     }
    722   }
    723 }
    724 #endif
    725 
    726 /** code prediction mode
    727  * \param pcCU
    728  * \param uiAbsPartIdx
     1295 
     1296  UInt uiDepth = m_uiMaxAlfCtrlDepth;
     1297 
     1298  xWriteUvlc(uiDepth);
     1299}
     1300
     1301Void TEncCavlc::codeInterModeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiEncMode )
     1302{
     1303  assert(0);
     1304}
     1305
     1306Void TEncCavlc::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1307{
     1308  assert(0);
     1309}
     1310
     1311Void TEncCavlc::codeSplitFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
     1312{
     1313  assert(0);
     1314}
     1315
     1316Void TEncCavlc::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
     1317{
     1318  assert(0);
     1319}
     1320
     1321Void TEncCavlc::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
     1322{
     1323  assert(0);
     1324}
     1325
     1326Void TEncCavlc::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1327{
     1328  assert(0);
     1329}
     1330
     1331#if BURST_IPCM
     1332/** Code I_PCM information.
     1333 * \param pcCU pointer to CU
     1334 * \param uiAbsPartIdx CU index
     1335 * \param numIPCM the number of succesive IPCM blocks with the same size
     1336 * \param firstIPCMFlag
    7291337 * \returns Void
    7301338 */
    731 Void TEncCavlc::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
    732 {
    733 #if QC_LCEC_INTER_MODE
    734   codeInterModeFlag(pcCU, uiAbsPartIdx,(UInt)pcCU->getDepth(uiAbsPartIdx),2);
    735   return;
     1339Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Int numIPCM, Bool firstIPCMFlag)
     1340{
     1341  assert(0);
     1342}
    7361343#else
    737   // get context function is here
    738   Int iPredMode = pcCU->getPredictionMode( uiAbsPartIdx );
    739   if ( pcCU->getSlice()->isInterB() )
    740   {
    741     return;
    742   }
    743   xWriteFlag( iPredMode == MODE_INTER ? 0 : 1 );
    744 #endif
    745 }
    746 
    747 /** code merge flag
    748  * \param pcCU
    749  * \param uiAbsPartIdx
    750  * \returns Void
    751  */
    752 Void TEncCavlc::codeMergeFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx )
    753 {
    754 #if QC_LCEC_INTER_MODE
    755   if (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N )
    756      return;
    757 #endif
    758   UInt uiSymbol = pcCU->getMergeFlag( uiAbsPartIdx ) ? 1 : 0;
    759   xWriteFlag( uiSymbol );
    760 }
    761 
    762 
    763 #if HHI_INTER_VIEW_MOTION_PRED || HHI_MPI
    764 Void
    765 TEncCavlc::codeMergeIndexMV( TComDataCU* pcCU, UInt uiAbsPartIdx )
    766 {
    767   UInt uiNumCand  = 0;
    768   UInt uiMergeIdx = pcCU->getMergeIndex( uiAbsPartIdx );
    769 #if HHI_MPI
    770   const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
    771   const UInt uiMviMergePos = bMVIAvailable ? HHI_MPI_MERGE_POS : MRG_MAX_NUM_CANDS;
    772   if( bMVIAvailable )
    773   {
    774     uiNumCand++;
    775     const Bool bUseMVI = pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1;
    776     if( bUseMVI )
    777       uiMergeIdx = HHI_MPI_MERGE_POS;
    778     else if( uiMergeIdx >= HHI_MPI_MERGE_POS )
    779       uiMergeIdx++;
    780   }
    781   UInt uiUnaryIdx = uiMergeIdx;
    782   for( UInt uiIdx = 0; uiIdx < MRG_MAX_NUM_CANDS; uiIdx++ )
    783   {
    784     if( uiIdx < uiMviMergePos )
    785     {
    786       if( pcCU->getNeighbourCandIdx( uiIdx, uiAbsPartIdx ) == uiIdx + 1 )
    787       {
    788         uiNumCand++;
    789       }
    790       else if( uiIdx < uiMergeIdx )
    791       {
    792         uiUnaryIdx--;
    793       }
    794     }
    795     else if( uiIdx > uiMviMergePos )
    796     {
    797       if( pcCU->getNeighbourCandIdx( uiIdx - 1, uiAbsPartIdx ) == uiIdx )
    798       {
    799         uiNumCand++;
    800       }
    801       else if( uiIdx < uiMergeIdx )
    802       {
    803         uiUnaryIdx--;
    804       }
    805     }
    806   }
    807 #else
    808   UInt uiUnaryIdx = uiMergeIdx;
    809   for( UInt uiIdx = 0; uiIdx < MRG_MAX_NUM_CANDS; uiIdx++ )
    810   {
    811     if( pcCU->getNeighbourCandIdx( uiIdx, uiAbsPartIdx ) == uiIdx + 1 )
    812     {
    813       uiNumCand++;
    814     }
    815     else if( uiIdx < uiMergeIdx )
    816     {
    817       uiUnaryIdx--;
    818     }
    819   }
    820 #endif
    821   AOF( uiNumCand > 1 );
    822   for( UInt ui = 0; ui < uiNumCand - 1; ui++ )
    823   {
    824     const UInt uiSymbol = ( ui == uiUnaryIdx ? 0 : 1 );
    825     xWriteFlag( uiSymbol );
    826     if( uiSymbol == 0 )
    827     {
    828       break;
    829     }
    830   }
    831 }
    832 #endif
    833 
    834 
    835 /** code merge index
    836  * \param pcCU
    837  * \param uiAbsPartIdx
    838  * \returns Void
    839  */
    840 Void TEncCavlc::codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx )
    841 {
    842 #if HHI_INTER_VIEW_MOTION_PRED || HHI_MPI
    843 #if HHI_INTER_VIEW_MOTION_PRED && HHI_MPI
    844   if( ( pcCU->getSlice()->getSPS()->getViewId() > 0 && ( pcCU->getSlice()->getSPS()->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE ) ||
    845       ( pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) )
    846 #elif HHI_MPI
    847   if( pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
    848 #else
    849   if( pcCU->getSlice()->getSPS()->getViewId() > 0 && ( pcCU->getSlice()->getSPS()->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE )
    850 #endif
    851   {
    852     codeMergeIndexMV( pcCU, uiAbsPartIdx );
    853     return;
    854   }
    855 #endif
    856 
    857   Bool bLeftInvolved = false;
    858   Bool bAboveInvolved = false;
    859   Bool bCollocatedInvolved = false;
    860   Bool bCornerInvolved = false;
    861   UInt uiNumCand = 0;
    862   for( UInt uiIter = 0; uiIter < MRG_MAX_NUM_CANDS; ++uiIter )
    863   {
    864     if( pcCU->getNeighbourCandIdx( uiIter, uiAbsPartIdx ) == uiIter + 1 )
    865     {
    866       uiNumCand++;
    867       if( uiIter == 0 )
    868       {
    869         bLeftInvolved = true;
    870       }
    871       else if( uiIter == 1 )
    872       {
    873         bAboveInvolved = true;
    874       }
    875       else if( uiIter == 2 )
    876       {
    877         bCollocatedInvolved = true;
    878       }
    879       else if( uiIter == 3 )
    880       {
    881         bCornerInvolved = true;
    882       }
    883     }
    884   }
    885   assert( uiNumCand > 1 );
    886   UInt uiUnaryIdx = pcCU->getMergeIndex( uiAbsPartIdx );
    887   if( !bCornerInvolved && uiUnaryIdx > 3 )
    888   {
    889     --uiUnaryIdx;
    890   }
    891   if( !bCollocatedInvolved && uiUnaryIdx > 2 )
    892   {
    893     --uiUnaryIdx;
    894   }
    895   if( !bAboveInvolved && uiUnaryIdx > 1 )
    896   {
    897     --uiUnaryIdx;
    898   }
    899   if( !bLeftInvolved && uiUnaryIdx > 0 )
    900   {
    901     --uiUnaryIdx;
    902   }
    903   for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
    904   {
    905     const UInt uiSymbol = ui == uiUnaryIdx ? 0 : 1;
    906     xWriteFlag( uiSymbol );
    907     if( uiSymbol == 0 )
    908     {
    909       break;
    910     }
    911   }
    912 }
    913 
    914 
    915 #if HHI_INTER_VIEW_RESIDUAL_PRED
    916 Void
    917 TEncCavlc::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
    918 {
    919   UInt uiSymbol = ( pcCU->getResPredFlag( uiAbsPartIdx ) ? 1 : 0 );
    920   xWriteFlag( uiSymbol );
    921 }
    922 #endif
    923 
    924 Void TEncCavlc::codeAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
    925 {
    926   if (!m_bAlfCtrl)
    927     return;
    928 
    929   if( pcCU->getDepth(uiAbsPartIdx) > m_uiMaxAlfCtrlDepth && !pcCU->isFirstAbsZorderIdxInDepth(uiAbsPartIdx, m_uiMaxAlfCtrlDepth))
    930   {
    931     return;
    932   }
    933 
    934   // get context function is here
    935   UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0;
    936 
    937   xWriteFlag( uiSymbol );
    938 }
    939 
    940 Void TEncCavlc::codeAlfCtrlDepth()
    941 {
    942   if (!m_bAlfCtrl)
    943     return;
    944 
    945   UInt uiDepth = m_uiMaxAlfCtrlDepth;
    946 
    947   xWriteUnaryMaxSymbol(uiDepth, g_uiMaxCUDepth-1);
    948 }
    949 #if QC_LCEC_INTER_MODE
    950 Void TEncCavlc::codeInterModeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiEncMode )
    951 {
    952   Bool bHasSplit = ( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )? 0 : 1;
    953   UInt uiSplitFlag = ( pcCU->getDepth( uiAbsPartIdx ) > uiDepth ) ? 1 : 0;
    954   UInt uiMode=0,uiControl=0;
    955   UInt uiTableDepth = uiDepth;
    956   if ( !bHasSplit )
    957   {
    958     uiTableDepth = 3;
    959   }
    960   if(!uiSplitFlag || !bHasSplit)
    961   {
    962     uiMode = 1;
    963     uiControl = 1;
    964     if (!pcCU->isSkipped(uiAbsPartIdx ))
    965     {
    966       uiControl = 2;
    967       uiMode = 6;
    968       if (pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER)
    969       {
    970         if(pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N)
    971           uiMode=pcCU->getMergeFlag(uiAbsPartIdx) ? 2 : 3;
    972         else
    973           uiMode=3+(UInt)pcCU->getPartitionSize(uiAbsPartIdx);
    974       }
    975     }
    976   }
    977   if (uiEncMode != uiControl )
    978     return;
    979   UInt uiEndSym = bHasSplit ? 7 : 6;
    980   uiDepth = uiTableDepth;
    981   UInt uiLength = m_uiSplitTableE[uiDepth][uiMode] + 1;
    982   if (uiLength == uiEndSym)
    983   {
    984     xWriteCode( 0, uiLength - 1);
    985   }
    986   else
    987   {
    988     xWriteCode( 1, uiLength );
    989   }
    990   UInt x = uiMode;
    991   UInt cx = m_uiSplitTableE[uiDepth][x];
    992   /* Adapt table */
    993   if ( m_bAdaptFlag)
    994   {
    995 #if CAVLC_COUNTER_ADAPT
    996     adaptCodeword(cx, m_ucSplitTableCounter[uiDepth],  m_ucSplitTableCounterSum[uiDepth],   m_uiSplitTableD[uiDepth],  m_uiSplitTableE[uiDepth], 4);
    997 #else
    998     if(cx>0)
    999     {
    1000       UInt cy = Max(0,cx-1);
    1001       UInt y = m_uiSplitTableD[uiDepth][cy];
    1002       m_uiSplitTableD[uiDepth][cy] = x;
    1003       m_uiSplitTableD[uiDepth][cx] = y;
    1004       m_uiSplitTableE[uiDepth][x] = cy;
    1005       m_uiSplitTableE[uiDepth][y] = cx;
    1006     }
    1007 #endif
    1008   }
    1009   return;
    1010 }
    1011 #endif
    1012 Void TEncCavlc::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1013 {
    1014 #if QC_LCEC_INTER_MODE
    1015   codeInterModeFlag(pcCU,uiAbsPartIdx,(UInt)pcCU->getDepth(uiAbsPartIdx),1);
    1016   return;
    1017 #else
    1018   // get context function is here
    1019   UInt uiSymbol = pcCU->isSkipped( uiAbsPartIdx ) ? 1 : 0;
    1020   xWriteFlag( uiSymbol );
    1021 #endif
    1022 }
    1023 
    1024 Void TEncCavlc::codeSplitFlag   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    1025 {
    1026   if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    1027     return;
    1028 #if QC_LCEC_INTER_MODE
    1029   if (!pcCU->getSlice()->isIntra())
    1030   {
    1031     codeInterModeFlag(pcCU,uiAbsPartIdx,uiDepth,0);
    1032     return;
    1033   }
    1034 #endif
    1035   UInt uiCurrSplitFlag = ( pcCU->getDepth( uiAbsPartIdx ) > uiDepth ) ? 1 : 0;
    1036 
    1037   xWriteFlag( uiCurrSplitFlag );
    1038   return;
    1039 }
    1040 
    1041 Void TEncCavlc::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
    1042 {
    1043   xWriteFlag( uiSymbol );
    1044 }
    1045 
    1046 Void TEncCavlc::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
    1047 {
    1048   UInt uiCbf = pcCU->getCbf( uiAbsPartIdx, eType, uiTrDepth );
    1049   xWriteFlag( uiCbf );
    1050 }
    1051 
    1052 Void TEncCavlc::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1053 {
    1054   UInt uiCbf = pcCU->getQtRootCbf( uiAbsPartIdx );
    1055   xWriteFlag( uiCbf ? 1 : 0 );
    1056 }
    1057 
    1058 #if LCEC_INTRA_MODE
    1059 #if MTK_DCM_MPM
    1060 Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1061 {
    1062   Int iDir         = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1063   Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
    1064 #if ADD_PLANAR_MODE
    1065   UInt planarFlag    = 0;
    1066   if (iDir == PLANAR_IDX)
    1067   {
    1068     iDir = 2;
    1069     planarFlag = 1;
    1070   }
    1071 #endif
    1072 
    1073   Int uiPreds[2] = {-1, -1};
    1074   Int uiPredNum = pcCU->getIntraDirLumaPredictor(uiAbsPartIdx, uiPreds);
    1075 
    1076   Int uiPredIdx = -1;
    1077 
    1078   for(UInt i = 0; i < uiPredNum; i++)
    1079   {
    1080     if(iDir == uiPreds[i])
    1081     {
    1082       uiPredIdx = i;
    1083     }
    1084   }
    1085 
    1086   if ( g_aucIntraModeBitsAng[iIntraIdx] < 5 )
    1087   {
    1088     if(uiPredIdx != -1)
    1089     {
    1090       xWriteFlag(1);
    1091       if(uiPredNum == 2)
    1092       {
    1093         xWriteFlag((UInt)uiPredIdx);
    1094       }
    1095     }
    1096     else
    1097     {
    1098       xWriteFlag(0);
    1099       for(Int i = (uiPredNum - 1); i >= 0; i--)
    1100       {
    1101         iDir = iDir > uiPreds[i] ? iDir - 1 : iDir;
    1102       }
    1103 
    1104 
    1105       xWriteFlag( iDir & 0x01 ? 1 : 0 );
    1106       if ( g_aucIntraModeBitsAng[iIntraIdx] > 2 ) { xWriteFlag( iDir & 0x02 ? 1 : 0 ); }
    1107       if ( g_aucIntraModeBitsAng[iIntraIdx] > 3 ) { xWriteFlag( iDir & 0x04 ? 1 : 0 ); }
    1108     }
    1109 
    1110   }
    1111   else
    1112   {
    1113      UInt uiCode, uiLength;
    1114      Int iRankIntraMode, iRankIntraModeLarger, iDirLarger;
    1115 
    1116      const UInt *huff;
    1117      const UInt *lengthHuff;
    1118      UInt  *m_uiIntraModeTableD;
    1119      UInt  *m_uiIntraModeTableE;
    1120 
    1121      if ( g_aucIntraModeBitsAng[iIntraIdx] == 5 )
    1122      {
    1123        huff = huff17_2[uiPredNum - 1];
    1124        lengthHuff = lengthHuff17_2[uiPredNum - 1];
    1125        m_uiIntraModeTableD = m_uiIntraModeTableD17[uiPredNum - 1];
    1126        m_uiIntraModeTableE = m_uiIntraModeTableE17[uiPredNum - 1];
    1127      }
    1128      else
    1129      {
    1130        huff = huff34_2[uiPredNum - 1];
    1131        lengthHuff = lengthHuff34_2[uiPredNum - 1];
    1132        m_uiIntraModeTableD = m_uiIntraModeTableD34[uiPredNum - 1];
    1133        m_uiIntraModeTableE = m_uiIntraModeTableE34[uiPredNum - 1];
    1134      }
    1135 
    1136      if(uiPredIdx != -1)
    1137      {
    1138        uiCode=huff[0];
    1139        uiLength=lengthHuff[0];
    1140        xWriteCode(uiCode, uiLength);
    1141 
    1142        if(uiPredNum == 2)
    1143        {
    1144          xWriteFlag((UInt)uiPredIdx);
    1145        }
    1146      }
    1147      else
    1148      {
    1149        for(Int i = (uiPredNum - 1); i >= 0; i--)
    1150        {
    1151          iDir = iDir > uiPreds[i] ? iDir - 1 : iDir;
    1152        }
    1153        iRankIntraMode=m_uiIntraModeTableE[iDir];
    1154 
    1155        uiCode=huff[iRankIntraMode+1];
    1156        uiLength=lengthHuff[iRankIntraMode+1];
    1157 
    1158        xWriteCode(uiCode, uiLength);
    1159 
    1160        if ( m_bAdaptFlag )
    1161        {
    1162          iRankIntraModeLarger = Max(0,iRankIntraMode-1);
    1163          iDirLarger = m_uiIntraModeTableD[iRankIntraModeLarger];
    1164 
    1165          m_uiIntraModeTableD[iRankIntraModeLarger] = iDir;
    1166          m_uiIntraModeTableD[iRankIntraMode] = iDirLarger;
    1167          m_uiIntraModeTableE[iDir] = iRankIntraModeLarger;
    1168          m_uiIntraModeTableE[iDirLarger] = iRankIntraMode;
    1169        }
    1170      }
    1171   }
    1172 #if ADD_PLANAR_MODE
    1173   iDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1174   if ( (iDir == PLANAR_IDX) || (iDir == 2) )
    1175   {
    1176     xWriteFlag( planarFlag );
    1177   }
    1178 #endif
    1179 }
    1180 #else
    1181 Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1182 {
    1183   Int iDir         = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1184   Int iMostProbable = pcCU->getMostProbableIntraDirLuma( uiAbsPartIdx );
    1185   Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
    1186   UInt uiCode, uiLength;
    1187   Int iRankIntraMode, iRankIntraModeLarger, iDirLarger;
    1188 #if ADD_PLANAR_MODE
    1189   UInt planarFlag    = 0;
    1190   if (iDir == PLANAR_IDX)
    1191   {
    1192     iDir = 2;
    1193     planarFlag = 1;
    1194   }
    1195 #endif
    1196 
    1197   UInt ind=(pcCU->getLeftIntraDirLuma( uiAbsPartIdx )==pcCU->getAboveIntraDirLuma( uiAbsPartIdx ))? 0 : 1;
    1198 
    1199   const UInt *huff17=huff17_2[ind];
    1200   const UInt *lengthHuff17=lengthHuff17_2[ind];
    1201   const UInt *huff34=huff34_2[ind];
    1202   const UInt *lengthHuff34=lengthHuff34_2[ind];
    1203 
    1204   if ( g_aucIntraModeBitsAng[iIntraIdx] < 5 )
    1205   {
    1206     if (iDir == iMostProbable)
    1207       xWriteFlag( 1 );
    1208     else{
    1209       if (iDir>iMostProbable)
    1210         iDir--;
    1211       xWriteFlag( 0 );
    1212       xWriteFlag( iDir & 0x01 ? 1 : 0 );
    1213       if ( g_aucIntraModeBitsAng[iIntraIdx] > 2 ) xWriteFlag( iDir & 0x02 ? 1 : 0 );
    1214       if ( g_aucIntraModeBitsAng[iIntraIdx] > 3 ) xWriteFlag( iDir & 0x04 ? 1 : 0 );
    1215     }
    1216   }
    1217   else if ( g_aucIntraModeBitsAng[iIntraIdx] == 5 )
    1218   {
    1219 
    1220     if (iDir==iMostProbable)
    1221     {
    1222       uiCode=huff17[0];
    1223       uiLength=lengthHuff17[0];
    1224     }
    1225     else
    1226     {
    1227       if (iDir>iMostProbable)
    1228       {
    1229         iDir--;
    1230       }
    1231       iRankIntraMode=m_uiIntraModeTableE17[iDir];
    1232 
    1233       uiCode=huff17[iRankIntraMode+1];
    1234       uiLength=lengthHuff17[iRankIntraMode+1];
    1235 
    1236       if ( m_bAdaptFlag )
    1237       {
    1238         iRankIntraModeLarger = Max(0,iRankIntraMode-1);
    1239         iDirLarger = m_uiIntraModeTableD17[iRankIntraModeLarger];
    1240 
    1241         m_uiIntraModeTableD17[iRankIntraModeLarger] = iDir;
    1242         m_uiIntraModeTableD17[iRankIntraMode] = iDirLarger;
    1243         m_uiIntraModeTableE17[iDir] = iRankIntraModeLarger;
    1244         m_uiIntraModeTableE17[iDirLarger] = iRankIntraMode;
    1245       }
    1246     }
    1247     xWriteCode(uiCode, uiLength);
    1248   }
    1249   else{
    1250     if (iDir==iMostProbable)
    1251     {
    1252       uiCode=huff34[0];
    1253       uiLength=lengthHuff34[0];
    1254     }
    1255     else{
    1256       if (iDir>iMostProbable)
    1257       {
    1258         iDir--;
    1259       }
    1260       iRankIntraMode=m_uiIntraModeTableE34[iDir];
    1261 
    1262       uiCode=huff34[iRankIntraMode+1];
    1263       uiLength=lengthHuff34[iRankIntraMode+1];
    1264 
    1265       if ( m_bAdaptFlag )
    1266       {
    1267         iRankIntraModeLarger = Max(0,iRankIntraMode-1);
    1268         iDirLarger = m_uiIntraModeTableD34[iRankIntraModeLarger];
    1269 
    1270         m_uiIntraModeTableD34[iRankIntraModeLarger] = iDir;
    1271         m_uiIntraModeTableD34[iRankIntraMode] = iDirLarger;
    1272         m_uiIntraModeTableE34[iDir] = iRankIntraModeLarger;
    1273         m_uiIntraModeTableE34[iDirLarger] = iRankIntraMode;
    1274       }
    1275     }
    1276 
    1277     xWriteCode(uiCode, uiLength);
    1278   }
    1279 
    1280 #if ADD_PLANAR_MODE
    1281   iDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1282   if ( (iDir == PLANAR_IDX) || (iDir == 2) )
    1283   {
    1284     xWriteFlag( planarFlag );
    1285   }
    1286 #endif
    1287 
    1288 }
    1289 #endif
    1290 #else
    1291 
    1292 Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1293 {
    1294   UInt uiDir         = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1295   Int  iMostProbable = pcCU->getMostProbableIntraDirLuma( uiAbsPartIdx );
    1296 #if ADD_PLANAR_MODE
    1297   UInt planarFlag    = 0;
    1298   if (uiDir == PLANAR_IDX)
    1299   {
    1300     uiDir = 2;
    1301     planarFlag = 1;
    1302   }
    1303 #endif
    1304 
    1305   if (uiDir == iMostProbable)
    1306   {
    1307     xWriteFlag( 1 );
    1308   }
    1309   else
    1310   {
    1311     xWriteFlag( 0 );
    1312     uiDir = uiDir > iMostProbable ? uiDir - 1 : uiDir;
    1313     Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
    1314     if ( g_aucIntraModeBitsAng[iIntraIdx] < 6 )
    1315     {
    1316       xWriteFlag( uiDir & 0x01 ? 1 : 0 );
    1317       if ( g_aucIntraModeBitsAng[iIntraIdx] > 2 ) xWriteFlag( uiDir & 0x02 ? 1 : 0 );
    1318       if ( g_aucIntraModeBitsAng[iIntraIdx] > 3 ) xWriteFlag( uiDir & 0x04 ? 1 : 0 );
    1319       if ( g_aucIntraModeBitsAng[iIntraIdx] > 4 ) xWriteFlag( uiDir & 0x08 ? 1 : 0 );
    1320     }
    1321     else
    1322     {
    1323       if (uiDir < 31)
    1324       { // uiDir is here 0...32, 5 bits for uiDir 0...30, 31 is an escape code for coding one more bit for 31 and 32
    1325         xWriteFlag( uiDir & 0x01 ? 1 : 0 );
    1326         xWriteFlag( uiDir & 0x02 ? 1 : 0 );
    1327         xWriteFlag( uiDir & 0x04 ? 1 : 0 );
    1328         xWriteFlag( uiDir & 0x08 ? 1 : 0 );
    1329         xWriteFlag( uiDir & 0x10 ? 1 : 0 );
    1330       }
    1331       else
    1332       {
    1333         xWriteFlag( 1 );
    1334         xWriteFlag( 1 );
    1335         xWriteFlag( 1 );
    1336         xWriteFlag( 1 );
    1337         xWriteFlag( 1 );
    1338         xWriteFlag( uiDir == 32 ? 1 : 0 );
    1339       }
    1340     }
    1341   }
    1342 
    1343 #if ADD_PLANAR_MODE
    1344   uiDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
    1345   if ( (uiDir == PLANAR_IDX) || (uiDir == 2) )
    1346   {
    1347     xWriteFlag( planarFlag );
    1348   }
    1349 #endif
    1350 
    1351 }
    1352 #endif
    1353 
    1354 Void TEncCavlc::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1355 {
    1356   UInt uiIntraDirChroma = pcCU->getChromaIntraDir   ( uiAbsPartIdx );
    1357 #if ADD_PLANAR_MODE
    1358   UInt planarFlag       = 0;
    1359   if (uiIntraDirChroma == PLANAR_IDX)
    1360   {
    1361     uiIntraDirChroma = 2;
    1362     planarFlag = 1;
    1363   }
    1364 #endif
    1365 
    1366 #if CHROMA_CODEWORD
    1367   UInt uiMode = pcCU->getLumaIntraDir(uiAbsPartIdx);
    1368 #if ADD_PLANAR_MODE
    1369   if ( (uiMode == 2 ) || (uiMode == PLANAR_IDX) )
    1370   {
    1371     uiMode = 4;
    1372   }
    1373 #endif
    1374 #if LM_CHROMA
    1375   Bool bUseLMFlag = pcCU->getSlice()->getSPS()->getUseLMChroma();
    1376 
    1377   Int  iMaxMode = bUseLMFlag ? 3 : 4;
    1378 
    1379   Int  iMax = uiMode < iMaxMode ? 3 : 4;
    1380 
    1381   //switch codeword
    1382   if (uiIntraDirChroma == 4)
    1383   {
    1384     uiIntraDirChroma = 0;
    1385   }
    1386   else if (uiIntraDirChroma == 3 && bUseLMFlag )
    1387   {
    1388     uiIntraDirChroma = 1;
    1389   }
    1390   else
    1391   {
    1392     if (uiIntraDirChroma < uiMode)
    1393       uiIntraDirChroma++;
    1394 
    1395     if (bUseLMFlag)
    1396       uiIntraDirChroma++;
    1397 #if CHROMA_CODEWORD_SWITCH
    1398     uiIntraDirChroma = ChromaMapping[iMax-3][uiIntraDirChroma];
    1399 #endif
    1400   }
    1401 
    1402   xWriteUnaryMaxSymbol( uiIntraDirChroma, iMax);
    1403 
    1404 #else //<--LM_CHROMA
    1405   Int  iMax = uiMode < 4 ? 3 : 4;
    1406 
    1407   //switch codeword
    1408   if (uiIntraDirChroma == 4)
    1409   {
    1410     uiIntraDirChroma = 0;
    1411   }
    1412 #if CHROMA_CODEWORD_SWITCH
    1413   else
    1414   {
    1415     if (uiIntraDirChroma < uiMode)
    1416     {
    1417       uiIntraDirChroma++;
    1418     }
    1419     uiIntraDirChroma = ChromaMapping[iMax-3][uiIntraDirChroma];
    1420   }
    1421 #else
    1422   else if (uiIntraDirChroma < uiMode)
    1423   {
    1424     uiIntraDirChroma++;
    1425   }
    1426 #endif
    1427   xWriteUnaryMaxSymbol( uiIntraDirChroma, iMax);
    1428 #endif //<-- LM_CHROMA
    1429 
    1430 #else // CHROMA_CODEWORD
    1431   if ( 0 == uiIntraDirChroma )
    1432   {
    1433     xWriteFlag( 0 );
    1434   }
    1435   else
    1436   {
    1437     xWriteFlag( 1 );
    1438     xWriteUnaryMaxSymbol( uiIntraDirChroma - 1, 3 );
    1439   }
    1440 #endif
    1441 
    1442 #if ADD_PLANAR_MODE
    1443   uiIntraDirChroma = pcCU->getChromaIntraDir( uiAbsPartIdx );
    1444 #if CHROMA_CODEWORD
    1445   uiMode = pcCU->getLumaIntraDir(uiAbsPartIdx);
    1446   mapPlanartoDC( uiIntraDirChroma );
    1447   mapPlanartoDC( uiMode );
    1448   if ( (uiIntraDirChroma == 2) && (uiMode != 2) )
    1449 #else
    1450   if ( (uiIntraDirChroma == PLANAR_IDX) || (uiIntraDirChroma == 2) )
    1451 #endif
    1452   {
    1453     xWriteFlag( planarFlag );
    1454   }
    1455 #endif
    1456   return;
    1457 }
    1458 
    1459 Void TEncCavlc::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1460 {
    1461   UInt uiInterDir = pcCU->getInterDir   ( uiAbsPartIdx );
    1462   uiInterDir--;
    1463 
    1464 #if UNIFY_INTER_TABLE
    1465 #if DCM_COMB_LIST
    1466   UInt uiNumRefIdxOfLC = pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C);
    1467 #endif
    1468   #define min(a, b) (((a) < (b)) ? (a) : (b))
    1469 #if DCM_COMB_LIST
    1470   UInt uiValNumRefIdxOfLC = min(4,pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C));
    1471 #endif
    1472   UInt uiValNumRefIdxOfL0 = min(2,pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_0));
    1473   UInt uiValNumRefIdxOfL1 = min(2,pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1));
    1474 
    1475   if ( pcCU->getSlice()->getRefIdxCombineCoding() )
    1476   {
    1477 #if CAVLC_COUNTER_ADAPT
    1478     Int x,cx;
    1479 #else
    1480     Int x,cx,y,cy;
    1481 #endif
    1482     Int iRefFrame0,iRefFrame1;
    1483     UInt uiIndex = 0;
    1484 
    1485     UInt *m_uiMITableE;
    1486     UInt *m_uiMITableD;
    1487 
    1488     m_uiMITableE = m_uiMI1TableE;
    1489     m_uiMITableD = m_uiMI1TableD;
    1490 
    1491     UInt uiMaxVal;
    1492 #if DCM_COMB_LIST
    1493     if (uiNumRefIdxOfLC > 0)
    1494     {
    1495       uiMaxVal = uiValNumRefIdxOfLC + uiValNumRefIdxOfL0*uiValNumRefIdxOfL1;
    1496     }
    1497     else
    1498 #endif
    1499     if (m_pcSlice->getNoBackPredFlag())
    1500     {
    1501       uiMaxVal = uiValNumRefIdxOfL0 + uiValNumRefIdxOfL0*uiValNumRefIdxOfL1;
    1502     }
    1503     else
    1504     {
    1505       uiMaxVal = uiValNumRefIdxOfL0 + uiValNumRefIdxOfL1 + uiValNumRefIdxOfL0*uiValNumRefIdxOfL1;
    1506     }
    1507 
    1508     if (uiInterDir==0)
    1509     {
    1510 #if DCM_COMB_LIST
    1511       if(uiNumRefIdxOfLC > 0)
    1512       {
    1513         iRefFrame0 = pcCU->getSlice()->getRefIdxOfLC(REF_PIC_LIST_0, pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx ));
    1514       }
    1515       else
    1516 #endif
    1517       {
    1518         iRefFrame0 = pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx );
    1519       }
    1520       uiIndex = iRefFrame0;
    1521 #if DCM_COMB_LIST
    1522       if(uiNumRefIdxOfLC > 0)
    1523       {
    1524         if ( iRefFrame0 >= 4 )
    1525         {
    1526           uiIndex = uiMaxVal;
    1527         }
    1528       }
    1529       else
    1530 #endif
    1531       {
    1532         if ( iRefFrame0 > 1 )
    1533         {
    1534           uiIndex = uiMaxVal;
    1535         }
    1536       }
    1537     }
    1538     else if (uiInterDir==1)
    1539     {
    1540 #if DCM_COMB_LIST
    1541       if(uiNumRefIdxOfLC > 0)
    1542       {
    1543         iRefFrame1 = pcCU->getSlice()->getRefIdxOfLC(REF_PIC_LIST_1, pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx ));
    1544         uiIndex = iRefFrame1;
    1545       }
    1546       else
    1547 #endif
    1548       {
    1549         iRefFrame1 = pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx );
    1550         uiIndex = uiValNumRefIdxOfL0 + iRefFrame1;
    1551       }
    1552 #if DCM_COMB_LIST
    1553       if(uiNumRefIdxOfLC > 0)
    1554       {
    1555         if ( iRefFrame1 >= 4 )
    1556         {
    1557           uiIndex = uiMaxVal;
    1558         }
    1559       }
    1560       else
    1561 #endif
    1562       {
    1563         if ( iRefFrame1 > 1 )
    1564         {
    1565           uiIndex = uiMaxVal;
    1566         }
    1567       }
    1568     }
    1569     else
    1570     {
    1571       iRefFrame0 = pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx );
    1572       iRefFrame1 = pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx );
    1573       if ( iRefFrame0 >= 2 || iRefFrame1 >= 2 )
    1574       {
    1575         uiIndex = uiMaxVal;
    1576       }
    1577       else
    1578       {
    1579   #if DCM_COMB_LIST
    1580         if(uiNumRefIdxOfLC > 0)
    1581         {
    1582           uiIndex = uiValNumRefIdxOfLC + iRefFrame0*uiValNumRefIdxOfL1 + iRefFrame1;
    1583         }
    1584         else
    1585   #endif
    1586         if (m_pcSlice->getNoBackPredFlag())
    1587         {
    1588           uiMaxVal = uiValNumRefIdxOfL0 + iRefFrame0*uiValNumRefIdxOfL1 + iRefFrame1;
    1589         }
    1590         else
    1591         {
    1592           uiIndex = uiValNumRefIdxOfL0 + uiValNumRefIdxOfL1 + iRefFrame0*uiValNumRefIdxOfL1 + iRefFrame1;
    1593         }
    1594       }
    1595     }
    1596 
    1597     x = uiIndex;
    1598 
    1599     cx = m_uiMITableE[x];
    1600 
    1601     /* Adapt table */
    1602     if ( m_bAdaptFlag )
    1603     {
    1604 #if CAVLC_COUNTER_ADAPT
    1605       adaptCodeword(cx, m_ucMI1TableCounter,  m_ucMI1TableCounterSum,   m_uiMITableD,  m_uiMITableE, 4);
    1606 #else
    1607       cy = Max(0,cx-1);
    1608       y = m_uiMITableD[cy];
    1609       m_uiMITableD[cy] = x;
    1610       m_uiMITableD[cx] = y;
    1611       m_uiMITableE[x] = cy;
    1612       m_uiMITableE[y] = cx;
    1613       m_uiMITableVlcIdx += cx == m_uiMITableVlcIdx ? 0 : (cx < m_uiMITableVlcIdx ? -1 : 1);
    1614 #endif
    1615     }
    1616 
    1617     xWriteUnaryMaxSymbol( cx, uiMaxVal );
    1618 
    1619     if ( x<uiMaxVal )
    1620     {
    1621       return;
    1622     }
    1623   }
    1624 
    1625 #else //UNIFY_INTER_TABLE
    1626 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1627   if ( pcCU->getSlice()->getRefIdxCombineCoding() )
    1628 #else
    1629   if(pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) <= 2 && pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) <= 2)
    1630 #endif
    1631   {
    1632 #if CAVLC_COUNTER_ADAPT
    1633     Int x,cx;
    1634 #else
    1635     Int x,cx,y,cy;
    1636 #endif
    1637     Int iRefFrame0,iRefFrame1;
    1638     UInt uiIndex;
    1639 
    1640     UInt *m_uiMITableE;
    1641     UInt *m_uiMITableD;
    1642     {
    1643       m_uiMITableE = m_uiMI1TableE;
    1644       m_uiMITableD = m_uiMI1TableD;
    1645       if (uiInterDir==0)
    1646       {
    1647 #if DCM_COMB_LIST
    1648         if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0)
    1649         {
    1650           iRefFrame0 = pcCU->getSlice()->getRefIdxOfLC(REF_PIC_LIST_0, pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx ));
    1651         }
    1652         else
    1653         {
    1654           iRefFrame0 = pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx );
    1655         }
    1656 #else
    1657         iRefFrame0 = pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx );
    1658 #endif
    1659         uiIndex = iRefFrame0;
    1660 
    1661 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1662         if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0)
    1663         {
    1664           if ( iRefFrame0 >= 4 )
    1665           {
    1666             uiIndex = 8;
    1667           }
    1668         }
    1669         else
    1670         {
    1671           if ( iRefFrame0 > MS_LCEC_UNI_EXCEPTION_THRES )
    1672           {
    1673             uiIndex = 8;
    1674           }
    1675         }
    1676 #endif
    1677       }
    1678       else if (uiInterDir==1)
    1679       {
    1680 #if DCM_COMB_LIST
    1681         if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0)
    1682         {
    1683           iRefFrame1 = pcCU->getSlice()->getRefIdxOfLC(REF_PIC_LIST_1, pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx ));
    1684           uiIndex = iRefFrame1;
    1685         }
    1686         else
    1687         {
    1688           iRefFrame1 = pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx );
    1689           uiIndex = 2 + iRefFrame1;
    1690         }
    1691 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1692         if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0)
    1693         {
    1694           if ( iRefFrame1 >= 4 )
    1695           {
    1696             uiIndex = 8;
    1697           }
    1698         }
    1699         else
    1700         {
    1701           if ( iRefFrame1 > MS_LCEC_UNI_EXCEPTION_THRES )
    1702           {
    1703             uiIndex = 8;
    1704           }
    1705         }
    1706 #endif
    1707 #else
    1708         iRefFrame1 = pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx );
    1709         uiIndex = 2 + iRefFrame1;
    1710 #endif
    1711       }
    1712       else
    1713       {
    1714         iRefFrame0 = pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx );
    1715         iRefFrame1 = pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx );
    1716         uiIndex = 4 + 2*iRefFrame0 + iRefFrame1;
    1717 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1718         if ( iRefFrame0 >= 2 || iRefFrame1 >= 2 )
    1719         {
    1720           uiIndex = 8;
    1721         }
    1722 #endif
    1723       }
    1724     }
    1725 
    1726     x = uiIndex;
    1727 
    1728     cx = m_uiMITableE[x];
    1729 
    1730     /* Adapt table */
    1731 #if !MS_LCEC_LOOKUP_TABLE_MAX_VALUE
    1732     UInt vlcn = g_auiMITableVlcNum[m_uiMITableVlcIdx];
    1733 #endif
    1734     if ( m_bAdaptFlag )
    1735     {
    1736 #if CAVLC_COUNTER_ADAPT
    1737       adaptCodeword(cx, m_ucMI1TableCounter,  m_ucMI1TableCounterSum,   m_uiMITableD,  m_uiMITableE, 4);
    1738 #else
    1739       cy = Max(0,cx-1);
    1740       y = m_uiMITableD[cy];
    1741       m_uiMITableD[cy] = x;
    1742       m_uiMITableD[cx] = y;
    1743       m_uiMITableE[x] = cy;
    1744       m_uiMITableE[y] = cx;
    1745       m_uiMITableVlcIdx += cx == m_uiMITableVlcIdx ? 0 : (cx < m_uiMITableVlcIdx ? -1 : 1);
    1746 #endif
    1747     }
    1748 
    1749     {
    1750 #if MS_LCEC_LOOKUP_TABLE_MAX_VALUE
    1751       UInt uiMaxVal = 7;
    1752 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1753       uiMaxVal = 8;
    1754 #endif
    1755       if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) <= 1 && pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) <= 1 )
    1756       {
    1757         if ( pcCU->getSlice()->getNoBackPredFlag() || ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 1 ) )
    1758         {
    1759           uiMaxVal = 1;
    1760         }
    1761         else
    1762         {
    1763           uiMaxVal = 2;
    1764         }
    1765       }
    1766       else if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) <= 2 && pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) <= 2 )
    1767       {
    1768         if ( pcCU->getSlice()->getNoBackPredFlag() || ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 2 ) )
    1769         {
    1770           uiMaxVal = 5;
    1771         }
    1772         else
    1773         {
    1774           uiMaxVal = 7;
    1775         }
    1776       }
    1777       else if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 0 ) // GPB case
    1778       {
    1779         uiMaxVal = 4+1+MS_LCEC_UNI_EXCEPTION_THRES;
    1780       }
    1781 
    1782       xWriteUnaryMaxSymbol( cx, uiMaxVal );
    1783 #else
    1784       xWriteVlc( vlcn, cx );
    1785 #endif
    1786     }
    1787 
    1788 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1789     if ( x<8 )
    1790 #endif
    1791     {
    1792       return;
    1793     }
    1794   }
    1795 #endif //UNIFY_INTER_TABLE
    1796 
    1797   xWriteFlag( ( uiInterDir == 2 ? 1 : 0 ));
    1798   if ( pcCU->getSlice()->getNoBackPredFlag() )
    1799   {
    1800     assert( uiInterDir != 1 );
    1801     return;
    1802   }
    1803 #if DCM_COMB_LIST
    1804   if ( uiInterDir < 2 && pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 0)
    1805 #else
    1806   if ( uiInterDir < 2 )
    1807 #endif
    1808   {
    1809     xWriteFlag( uiInterDir );
    1810   }
    1811 
    1812   return;
    1813 }
    1814 
    1815 Void TEncCavlc::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
    1816 {
    1817 #if DCM_COMB_LIST
    1818   Int iRefFrame;
    1819   RefPicList eRefListTemp;
    1820 
    1821   if( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C)>0)
    1822   {
    1823     if ( pcCU->getInterDir( uiAbsPartIdx ) != 3)
    1824     {
    1825       eRefListTemp = REF_PIC_LIST_C;
    1826       iRefFrame = pcCU->getSlice()->getRefIdxOfLC(eRefList, pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx ));
    1827     }
    1828     else
    1829     {
    1830       eRefListTemp = eRefList;
    1831       iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
    1832     }
    1833   }
    1834   else
    1835   {
    1836     eRefListTemp = eRefList;
    1837     iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
    1838   }
    1839 #else
    1840   Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
    1841 #endif
    1842 
    1843   if (pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) <= 2 && pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) <= 2 && pcCU->getSlice()->isInterB())
    1844   {
    1845     return;
    1846   }
    1847 
    1848 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1849   if ( pcCU->getSlice()->getRefIdxCombineCoding() && pcCU->getInterDir(uiAbsPartIdx)==3 &&
    1850       pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx ) < 2 &&
    1851       pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx ) < 2 )
    1852   {
    1853     return;
    1854   }
    1855   else if ( pcCU->getSlice()->getRefIdxCombineCoding() && pcCU->getInterDir(uiAbsPartIdx)==1 &&
    1856            ( ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C)>0  && pcCU->getSlice()->getRefIdxOfLC(REF_PIC_LIST_0, pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx )) < 4 ) ||
    1857             ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C)<=0 && pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx ) <= MS_LCEC_UNI_EXCEPTION_THRES ) ) )
    1858   {
    1859     return;
    1860   }
    1861   else if ( pcCU->getSlice()->getRefIdxCombineCoding() && pcCU->getInterDir(uiAbsPartIdx)==2 && pcCU->getSlice()->getRefIdxOfLC(REF_PIC_LIST_1, pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiAbsPartIdx )) < 4 )
    1862   {
    1863     return;
    1864   }
    1865 
    1866   UInt uiRefFrmIdxMinus = 0;
    1867   if ( pcCU->getSlice()->getRefIdxCombineCoding() )
    1868   {
    1869     if ( pcCU->getInterDir( uiAbsPartIdx ) != 3 )
    1870     {
    1871       if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 )
    1872       {
    1873         uiRefFrmIdxMinus = 4;
    1874         assert( iRefFrame >=4 );
    1875       }
    1876       else
    1877       {
    1878         uiRefFrmIdxMinus = MS_LCEC_UNI_EXCEPTION_THRES+1;
    1879         assert( iRefFrame > MS_LCEC_UNI_EXCEPTION_THRES );
    1880       }
    1881 
    1882     }
    1883     else if ( eRefList == REF_PIC_LIST_1 && pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiAbsPartIdx ) < 2 )
    1884     {
    1885       uiRefFrmIdxMinus = 2;
    1886       assert( iRefFrame >= 2 );
    1887     }
    1888   }
    1889 
    1890   if ( pcCU->getSlice()->getNumRefIdx( eRefListTemp ) - uiRefFrmIdxMinus <= 1 )
    1891   {
    1892     return;
    1893   }
    1894   xWriteFlag( ( iRefFrame - uiRefFrmIdxMinus == 0 ? 0 : 1 ) );
    1895 #else
    1896   xWriteFlag( ( iRefFrame == 0 ? 0 : 1 ) );
    1897 #endif
    1898 
    1899 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1900   if ( iRefFrame - uiRefFrmIdxMinus > 0 )
    1901 #else
    1902   if ( iRefFrame > 0 )
    1903 #endif
    1904   {
    1905     {
    1906 #if DCM_COMB_LIST
    1907 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1908       xWriteUnaryMaxSymbol( iRefFrame - 1 - uiRefFrmIdxMinus, pcCU->getSlice()->getNumRefIdx( eRefListTemp )-2 - uiRefFrmIdxMinus );
    1909 #else
    1910       xWriteUnaryMaxSymbol( iRefFrame - 1, pcCU->getSlice()->getNumRefIdx( eRefListTemp )-2 );
    1911 #endif
    1912 #else
    1913 #if MS_LCEC_LOOKUP_TABLE_EXCEPTION
    1914       xWriteUnaryMaxSymbol( iRefFrame - 1 - uiRefFrmIdxMinus, pcCU->getSlice()->getNumRefIdx( eRefList )-2 - uiRefFrmIdxMinus );
    1915 #else
    1916       xWriteUnaryMaxSymbol( iRefFrame - 1, pcCU->getSlice()->getNumRefIdx( eRefList )-2 );
    1917 #endif
    1918 #endif
    1919     }
    1920   }
    1921   return;
    1922 }
    1923 
    1924 Void TEncCavlc::codeViewIdx(Int iViewIdx)
    1925 {
    1926   xWriteUnaryMaxSymbol(iViewIdx, MAX_NUMBER_VIEWS   );
    1927 }
    1928 
    1929 Void TEncCavlc::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
    1930 {
    1931   TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefList );
    1932   Int iHor = pcCUMvField->getMvd( uiAbsPartIdx ).getHor();
    1933   Int iVer = pcCUMvField->getMvd( uiAbsPartIdx ).getVer();
    1934 
    1935   UInt uiAbsPartIdxL, uiAbsPartIdxA;
    1936   Int iHorPred, iVerPred;
    1937 
    1938   TComDataCU* pcCUL   = pcCU->getPULeft ( uiAbsPartIdxL, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
    1939   TComDataCU* pcCUA   = pcCU->getPUAbove( uiAbsPartIdxA, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
    1940 
    1941   TComCUMvField* pcCUMvFieldL = ( pcCUL == NULL || pcCUL->isIntra( uiAbsPartIdxL ) ) ? NULL : pcCUL->getCUMvField( eRefList );
    1942   TComCUMvField* pcCUMvFieldA = ( pcCUA == NULL || pcCUA->isIntra( uiAbsPartIdxA ) ) ? NULL : pcCUA->getCUMvField( eRefList );
    1943   iHorPred = ( (pcCUMvFieldL == NULL) ? 0 : pcCUMvFieldL->getMvd( uiAbsPartIdxL ).getAbsHor() ) +
    1944   ( (pcCUMvFieldA == NULL) ? 0 : pcCUMvFieldA->getMvd( uiAbsPartIdxA ).getAbsHor() );
    1945   iVerPred = ( (pcCUMvFieldL == NULL) ? 0 : pcCUMvFieldL->getMvd( uiAbsPartIdxL ).getAbsVer() ) +
    1946   ( (pcCUMvFieldA == NULL) ? 0 : pcCUMvFieldA->getMvd( uiAbsPartIdxA ).getAbsVer() );
    1947 
    1948   xWriteSvlc( iHor );
    1949   xWriteSvlc( iVer );
    1950 
    1951   return;
    1952 }
    1953 
    1954 Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
    1955 {
    1956   Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getSlice()->getSliceQp();
    1957 
    1958   if ( iDQp == 0 )
    1959   {
    1960     xWriteFlag( 0 );
    1961   }
    1962   else
    1963   {
    1964     xWriteFlag( 1 );
    1965     xWriteSvlc( iDQp );
    1966   }
    1967 
    1968   return;
    1969 }
    1970 
    1971 #if CAVLC_RQT_CBP
    1972 /** Function for coding cbf and split flag
    1973 * \param pcCU pointer to CU
    1974 * \param uiAbsPartIdx CU index
    1975 * \param uiDepth CU Depth
    1976 * \returns
    1977 * This function performs coding of cbf and split flag
    1978 */
    1979 Void TEncCavlc::codeCbfTrdiv( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    1980 {
    1981   UInt n,cx;
    1982   UInt uiTrDepth = uiDepth - pcCU->getDepth(uiAbsPartIdx);
    1983   UInt uiCBFY = pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA, uiTrDepth);
    1984   UInt uiCBFU = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth);
    1985   UInt uiCBFV = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth);
    1986   UInt uiQPartNumParent  = pcCU->getPic()->getNumPartInCU() >> ((uiDepth-1) << 1);
    1987   UInt uiQPartNumCurr    = pcCU->getPic()->getNumPartInCU() >> ((uiDepth) << 1);
    1988 
    1989   const UInt uiSubdiv = pcCU->getTransformIdx( uiAbsPartIdx ) + pcCU->getDepth( uiAbsPartIdx ) > uiDepth;
    1990   UInt uiFlagPattern = xGetFlagPattern( pcCU, uiAbsPartIdx, uiDepth );
    1991   n = pcCU->isIntra( uiAbsPartIdx ) ? 0 : 1;
    1992 
    1993   if(uiFlagPattern < 8)
    1994   {
    1995     UInt uiFullDepth = pcCU->getDepth(uiAbsPartIdx) + uiTrDepth;
    1996     UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
    1997     if( uiLog2TrSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
    1998     {
    1999       UInt uiCBFU_Parent = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth-1);
    2000       UInt uiCBFV_Parent = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth-1);
    2001       if(uiCBFU_Parent)
    2002       {
    2003         xWriteFlag(uiCBFU);
    2004       }
    2005       if(uiCBFV_Parent)
    2006       {
    2007         xWriteFlag(uiCBFV);
    2008       }
    2009     }
    2010 
    2011     if(uiFlagPattern & 0x01)
    2012     {
    2013       codeTransformSubdivFlag( uiSubdiv, 0);
    2014     }
    2015   }
    2016   else
    2017   {
    2018     if(uiFlagPattern == 8)
    2019     {
    2020       if (uiAbsPartIdx % uiQPartNumParent ==0)
    2021       {
    2022         codeBlockCbf(pcCU, uiAbsPartIdx, TEXT_LUMA, uiTrDepth, uiQPartNumCurr);
    2023       }
    2024     }
    2025     else if(uiFlagPattern == 9)
    2026     {
    2027       bool bNeedToCode = true;
    2028       if ( n==1 && (uiAbsPartIdx%uiQPartNumParent) / uiQPartNumCurr == 3 )
    2029       {
    2030         UInt uiTempAbsPartIdx = uiAbsPartIdx/uiQPartNumParent*uiQPartNumParent;
    2031         if ( pcCU->getCbf( uiTempAbsPartIdx + uiQPartNumCurr*0, TEXT_LUMA, uiTrDepth ) ||
    2032           pcCU->getCbf( uiTempAbsPartIdx + uiQPartNumCurr*1, TEXT_LUMA, uiTrDepth ) ||
    2033           pcCU->getCbf( uiTempAbsPartIdx + uiQPartNumCurr*2, TEXT_LUMA, uiTrDepth ) )
    2034         {
    2035           bNeedToCode = true;
    2036         }
    2037         else
    2038         {
    2039           bNeedToCode = false;
    2040           xWriteFlag( uiSubdiv );
    2041         }
    2042       }
    2043       if ( bNeedToCode )
    2044       {
    2045         cx = m_uiCBP_YS_TableE[n][(uiCBFY<<1)+uiSubdiv];
    2046         xWriteUnaryMaxSymbol(cx,n?2:3);//intra 3; inter 2
    2047 
    2048         if ( m_bAdaptFlag )
    2049         {
    2050           adaptCodeword(cx, m_ucCBP_YS_TableCounter[n],  m_ucCBP_YS_TableCounterSum[n],  m_uiCBP_YS_TableD[n],  m_uiCBP_YS_TableE[n], 3);
    2051         }
    2052       }
    2053     }
    2054     else if( uiFlagPattern == 14)
    2055     {
    2056       UInt  uiIdx = uiTrDepth? (2 + n) : n;
    2057       cx = m_uiCBP_YUV_TableE[uiIdx][(uiCBFV<<0) + (uiCBFU<<1) + (uiCBFY<<2)];
    2058       xWriteUnaryMaxSymbol(cx,7);
    2059 
    2060       if ( m_bAdaptFlag )
    2061       {
    2062         adaptCodeword(cx,  m_ucCBP_YUV_TableCounter[uiIdx],  m_ucCBP_YUV_TableCounterSum[uiIdx],  m_uiCBP_YUV_TableD[uiIdx],  m_uiCBP_YUV_TableE[uiIdx], 4);
    2063       }
    2064     }
    2065     else if ( uiFlagPattern == 11 || uiFlagPattern == 13 || uiFlagPattern == 15 )
    2066     {
    2067       cx = m_uiCBP_YCS_TableE[n][(uiCBFY<<2)+((uiCBFU||uiCBFV?1:0)<<1)+uiSubdiv];
    2068       xWriteCode(g_auiCBP_YCS_Table[n][cx], g_auiCBP_YCS_TableLen[n][cx]);
    2069 
    2070       if ( m_bAdaptFlag )
    2071       {
    2072         adaptCodeword(cx, m_ucCBP_YCS_TableCounter[n],  m_ucCBP_YCS_TableCounterSum[n],  m_uiCBP_YCS_TableD[n],  m_uiCBP_YCS_TableE[n], 4);
    2073       }
    2074 
    2075       //U and V
    2076       if ( uiFlagPattern == 15)
    2077       {
    2078         UInt uiCBFUV = (uiCBFU<<1) + uiCBFV;
    2079         if(uiCBFUV > 0)
    2080         {
    2081           xWriteUnaryMaxSymbol(n? (uiCBFUV - 1) : (3-uiCBFUV), 2);
    2082         }
    2083       }
    2084     }
    2085     else if (uiFlagPattern == 10 || uiFlagPattern == 12)
    2086     {
    2087       xWriteUnaryMaxSymbol(g_auiCBP_YC_TableE[n][(uiCBFY<<1)+(uiCBFU||uiCBFV?1:0)],3);//intra 3; inter 2
    2088     }
    2089   }
    2090   return;
    2091 }
    2092 
    2093 
    2094 /** Function for parsing cbf and split
     1344/** Code I_PCM information.
    20951345 * \param pcCU pointer to CU
    20961346 * \param uiAbsPartIdx CU index
    2097  * \param uiDepth CU Depth
    2098  * \returns flag pattern
    2099  * This function gets flagpattern for cbf and split flag
     1347 * \returns Void
     1348 *
     1349 * If I_PCM flag indicates that the CU is I_PCM, code its PCM alignment bits and codes. 
    21001350 */
    2101 UInt TEncCavlc::xGetFlagPattern( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    2102 {
    2103   const UInt uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()]+2 - uiDepth;
    2104   UInt uiTrDepth =  uiDepth - pcCU->getDepth( uiAbsPartIdx );
    2105   UInt patternYUV, patternDiv;
    2106   UInt bY, bU, bV;
    2107 
    2108   UInt uiFullDepth = uiDepth;
    2109   UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
    2110   if(uiTrDepth == 0)
    2111   {
    2112     patternYUV = 7;
    2113   }
    2114   else if( uiLog2TrSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
    2115   {
    2116     bY = pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA, uiTrDepth - 1)?1:0;
    2117     bU = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth - 1)?1:0;
    2118     bV = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth - 1)?1:0;
    2119     patternYUV = (bY<<2) + (bU<<1) + bV;
    2120   }
    2121   else
    2122   {
    2123     bY = pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA, uiTrDepth - 1)?1:0;
    2124     patternYUV = bY<<2;
    2125   }
    2126 
    2127   if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && uiDepth == pcCU->getDepth(uiAbsPartIdx) )
    2128   {
    2129     patternDiv = 0;
    2130   }
    2131   else if( uiLog2TrafoSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
    2132   {
    2133     patternDiv = 0;
    2134   }
    2135   else if( uiLog2TrafoSize == pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
    2136   {
    2137     patternDiv = 0;
    2138   }
    2139   else if( uiLog2TrafoSize == pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
    2140   {
    2141     patternDiv = 0;
    2142   }
    2143   else
    2144   {
    2145     patternDiv = 1;
    2146   }
    2147   return ((patternYUV<<1)+patternDiv);
    2148 }
    2149 #endif
    2150 
    2151 Void TEncCavlc::codeCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
    2152 {
    2153   if (eType == TEXT_ALL)
    2154   {
    2155 #if CAVLC_COUNTER_ADAPT
    2156     Int n,x,cx;
    2157 #else
    2158     Int n,x,cx,y,cy;
    2159 #endif
    2160 
    2161     UInt uiCBFY = pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA, 0);
    2162     UInt uiCBFU = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U, 0);
    2163     UInt uiCBFV = pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V, 0);
    2164     UInt uiCBP = (uiCBFV<<2) + (uiCBFU<<1) + (uiCBFY<<0);
    2165 
    2166     /* Start adaptation */
    2167     n = pcCU->isIntra( uiAbsPartIdx ) ? 0 : 1;
    2168     x = uiCBP;
    2169 #if CAVLC_RQT_CBP
    2170     cx = m_uiCBP_YUV_TableE[n][x];
    2171     UInt vlcn = 0;
    2172 #else
    2173     cx = m_uiCBPTableE[n][x];
    2174     UInt vlcn = g_auiCbpVlcNum[n][m_uiCbpVlcIdx[n]];
    2175 #endif
    2176 
    2177     if ( m_bAdaptFlag )
    2178     {
    2179 #if CAVLC_COUNTER_ADAPT
    2180 #if CAVLC_RQT_CBP
    2181       adaptCodeword(cx, m_ucCBP_YUV_TableCounter[n], m_ucCBP_YUV_TableCounterSum[n], m_uiCBP_YUV_TableD[n], m_uiCBP_YUV_TableE[n], 4);
    2182 #else
    2183       adaptCodeword(cx, m_ucCBFTableCounter[n],  m_ucCBFTableCounterSum[n],  m_uiCBPTableD[n],  m_uiCBPTableE[n], 4);
    2184 #endif
    2185 #else
    2186       cy = Max(0,cx-1);
    2187       y = m_uiCBPTableD[n][cy];
    2188       m_uiCBPTableD[n][cy] = x;
    2189       m_uiCBPTableD[n][cx] = y;
    2190       m_uiCBPTableE[n][x] = cy;
    2191       m_uiCBPTableE[n][y] = cx;
    2192       m_uiCbpVlcIdx[n] += cx == m_uiCbpVlcIdx[n] ? 0 : (cx < m_uiCbpVlcIdx[n] ? -1 : 1);
    2193 #endif
    2194     }
    2195     xWriteVlc( vlcn, cx );
    2196   }
    2197 }
    2198 
    2199 Void TEncCavlc::codeBlockCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiQPartNum, Bool bRD )
    2200 {
    2201   UInt uiCbf0 = pcCU->getCbf   ( uiAbsPartIdx, eType, uiTrDepth );
    2202   UInt uiCbf1 = pcCU->getCbf   ( uiAbsPartIdx + uiQPartNum, eType, uiTrDepth );
    2203   UInt uiCbf2 = pcCU->getCbf   ( uiAbsPartIdx + uiQPartNum*2, eType, uiTrDepth );
    2204   UInt uiCbf3 = pcCU->getCbf   ( uiAbsPartIdx + uiQPartNum*3, eType, uiTrDepth );
    2205   UInt uiCbf = (uiCbf0<<3) | (uiCbf1<<2) | (uiCbf2<<1) | uiCbf3;
    2206 
    2207   assert(uiTrDepth > 0);
    2208 
    2209   if(bRD && uiCbf==0)
    2210   {
    2211     xWriteCode(0, 4);
     1351Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx)
     1352{
     1353  UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
     1354
     1355  xWriteFlag(uiIPCM);
     1356
     1357  if (uiIPCM)
     1358  {
     1359    xWritePCMAlignZero();
     1360
     1361    UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
     1362    UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
     1363    UInt uiChromaOffset = uiLumaOffset>>2;
     1364
     1365    Pel* piPCMSample;
     1366    UInt uiWidth;
     1367    UInt uiHeight;
     1368    UInt uiSampleBits;
     1369    UInt uiX, uiY;
     1370
     1371    piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
     1372    uiWidth = pcCU->getWidth(uiAbsPartIdx);
     1373    uiHeight = pcCU->getHeight(uiAbsPartIdx);
     1374    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
     1375
     1376    for(uiY = 0; uiY < uiHeight; uiY++)
     1377    {
     1378      for(uiX = 0; uiX < uiWidth; uiX++)
     1379      {
     1380        UInt uiSample = piPCMSample[uiX];
     1381
     1382        xWriteCode(uiSample, uiSampleBits);
     1383      }
     1384      piPCMSample += uiWidth;
     1385    }
     1386
     1387    piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
     1388    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
     1389    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
     1390    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
     1391
     1392    for(uiY = 0; uiY < uiHeight; uiY++)
     1393    {
     1394      for(uiX = 0; uiX < uiWidth; uiX++)
     1395      {
     1396        UInt uiSample = piPCMSample[uiX];
     1397
     1398        xWriteCode(uiSample, uiSampleBits);
     1399      }
     1400      piPCMSample += uiWidth;
     1401    }
     1402
     1403    piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
     1404    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
     1405    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
     1406    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
     1407
     1408    for(uiY = 0; uiY < uiHeight; uiY++)
     1409    {
     1410      for(uiX = 0; uiX < uiWidth; uiX++)
     1411      {
     1412        UInt uiSample = piPCMSample[uiX];
     1413
     1414        xWriteCode(uiSample, uiSampleBits);
     1415      }
     1416      piPCMSample += uiWidth;
     1417    }
     1418  }
     1419}
     1420#endif
     1421
     1422Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1423{
     1424  assert(0);
     1425}
     1426
     1427Void TEncCavlc::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1428{
     1429  assert(0);
     1430}
     1431
     1432Void TEncCavlc::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1433{
     1434  assert(0);
     1435}
     1436
     1437Void TEncCavlc::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
     1438{
     1439  assert(0);
     1440}
     1441
     1442Void TEncCavlc::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
     1443{
     1444  assert(0);
     1445}
     1446
     1447Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
     1448{
     1449  Int iDQp  = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
     1450
     1451#if H0736_AVC_STYLE_QP_RANGE
     1452  Int qpBdOffsetY =  pcCU->getSlice()->getSPS()->getQpBDOffsetY();
     1453  iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
     1454#endif
     1455
     1456  xWriteSvlc( iDQp );
     1457 
     1458  return;
     1459}
     1460
     1461Void TEncCavlc::codeCoeffNxN    ( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
     1462{
     1463  assert(0);
     1464}
     1465
     1466Void TEncCavlc::codeAlfFlag( UInt uiCode )
     1467
     1468  xWriteFlag( uiCode );
     1469}
     1470
     1471Void TEncCavlc::codeAlfCtrlFlag( UInt uiSymbol )
     1472{
     1473  xWriteFlag( uiSymbol );
     1474}
     1475
     1476Void TEncCavlc::codeAlfUvlc( UInt uiCode )
     1477{
     1478  xWriteUvlc( uiCode );
     1479}
     1480
     1481Void TEncCavlc::codeAlfSvlc( Int iCode )
     1482{
     1483  xWriteSvlc( iCode );
     1484}
     1485#if LCU_SYNTAX_ALF
     1486/** Code the fixed length code (smaller than one max value) in OSALF
     1487 * \param idx:  coded value
     1488 * \param maxValue: max value
     1489 */
     1490Void TEncCavlc::codeAlfFixedLengthIdx( UInt idx, UInt maxValue)
     1491{
     1492  UInt length = 0;
     1493  assert(idx<=maxValue);
     1494
     1495  UInt temp = maxValue;
     1496  for(UInt i=0; i<32; i++)
     1497  {
     1498    if(temp&0x1)
     1499    {
     1500      length = i+1;
     1501    }
     1502    temp = (temp >> 1);
     1503  }
     1504
     1505  if(length)
     1506  {
     1507    xWriteCode( idx, length );
     1508  }
     1509}
     1510#endif
     1511
     1512Void TEncCavlc::codeSaoFlag( UInt uiCode )
     1513{
     1514  xWriteFlag( uiCode );
     1515}
     1516
     1517Void TEncCavlc::codeSaoUvlc( UInt uiCode )
     1518{
     1519    xWriteUvlc( uiCode );
     1520}
     1521
     1522Void TEncCavlc::codeSaoSvlc( Int iCode )
     1523{
     1524    xWriteSvlc( iCode );
     1525}
     1526#if SAO_UNIT_INTERLEAVING
     1527/** Code SAO run.
     1528 * \param uiCode
     1529 * \param maxValue
     1530 */
     1531Void TEncCavlc::codeSaoRun( UInt uiCode, UInt maxValue)
     1532{
     1533  UInt uiLength = 0;
     1534  if (!maxValue)
     1535  {
    22121536    return;
    22131537  }
    2214 
    2215   assert(uiCbf > 0);
    2216 
    2217   uiCbf --;
    2218 
    2219 #if CAVLC_COUNTER_ADAPT
    2220   Int x,cx;
    2221 #else
    2222   Int x,cx,y,cy;
    2223 #endif
    2224 
    2225   UInt n = (pcCU->isIntra(uiAbsPartIdx) && eType == TEXT_LUMA)? 0:1;
    2226   x = uiCbf;
    2227 
    2228 #if CAVLC_RQT_CBP
    2229   cx = m_uiCBP_4Y_TableE[n][uiCbf];
    2230   UInt vlcn = (n==0)?g_auiCBP_4Y_VlcNum[m_uiCBP_4Y_VlcIdx]:11;
    2231 #else
    2232   cx = m_uiBlkCBPTableE[n][uiCbf];
    2233   UInt vlcn = (n==0)?g_auiBlkCbpVlcNum[m_uiBlkCbpVlcIdx]:11;
    2234 #endif
    2235 
    2236 
    2237   if ( m_bAdaptFlag )
    2238   {
    2239 
    2240 #if CAVLC_COUNTER_ADAPT
    2241 #if CAVLC_RQT_CBP
    2242     adaptCodeword(cx, m_ucCBP_4Y_TableCounter[n],  m_ucCBP_4Y_TableCounterSum[n],  m_uiCBP_4Y_TableD[n],  m_uiCBP_4Y_TableE[n], 2);
    2243 #else
    2244     adaptCodeword(cx, m_ucBlkCBPTableCounter[n],  m_ucBlkCBPTableCounterSum[n],  m_uiBlkCBPTableD[n],  m_uiBlkCBPTableE[n], 2);
    2245 #endif
    2246 #else
    2247     cy = Max(0,cx-1);
    2248     y = m_uiBlkCBPTableD[n][cy];
    2249     m_uiBlkCBPTableD[n][cy] = x;
    2250     m_uiBlkCBPTableD[n][cx] = y;
    2251     m_uiBlkCBPTableE[n][x] = cy;
    2252     m_uiBlkCBPTableE[n][y] = cx;
    2253 #endif
    2254 
    2255 #if CAVLC_RQT_CBP
    2256     if(n==0)
    2257       m_uiCBP_4Y_VlcIdx += cx == m_uiCBP_4Y_VlcIdx ? 0 : (cx < m_uiCBP_4Y_VlcIdx ? -1 : 1);
    2258 #else
    2259     if(n==0)
    2260       m_uiBlkCbpVlcIdx += cx == m_uiBlkCbpVlcIdx ? 0 : (cx < m_uiBlkCbpVlcIdx ? -1 : 1);
    2261 #endif
    2262   }
    2263 
    2264   xWriteVlc( vlcn, cx );
    2265   return;
    2266 }
    2267 
    2268 Void TEncCavlc::codeCoeffNxN    ( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType, Bool bRD )
    2269 {
    2270   if ( uiWidth > m_pcSlice->getSPS()->getMaxTrSize() )
    2271   {
    2272     uiWidth  = m_pcSlice->getSPS()->getMaxTrSize();
    2273     uiHeight = m_pcSlice->getSPS()->getMaxTrSize();
    2274   }
    2275   UInt uiSize   = uiWidth*uiHeight;
    2276 
    2277   // point to coefficient
    2278   TCoeff* piCoeff = pcCoef;
    2279   UInt uiNumSig = 0;
    2280   UInt uiScanning;
    2281 
    2282   // compute number of significant coefficients
    2283   UInt  uiPart = 0;
    2284   xCheckCoeff(piCoeff, uiWidth, 0, uiNumSig, uiPart );
    2285 
    2286   if ( bRD )
    2287   {
    2288     UInt uiTempDepth = uiDepth - pcCU->getDepth( uiAbsPartIdx );
    2289     pcCU->setCbfSubParts( ( uiNumSig ? 1 : 0 ) << uiTempDepth, eTType, uiAbsPartIdx, uiDepth );
    2290     codeCbf( pcCU, uiAbsPartIdx, eTType, uiTempDepth );
    2291   }
    2292 
    2293   if ( uiNumSig == 0 )
    2294   {
    2295     return;
    2296   }
    2297 
    2298   // initialize scan
    2299   const UInt*  pucScan;
    2300 
    2301 #if CAVLC_COEF_LRG_BLK
    2302   UInt maxBlSize = (eTType==TEXT_LUMA)?32:8;
    2303   UInt uiBlSize = Min(maxBlSize,uiWidth);
    2304   UInt uiConvBit = g_aucConvertToBit[ pcCU->isIntra( uiAbsPartIdx ) ? uiWidth :uiBlSize];
    2305   UInt uiNoCoeff = uiBlSize*uiBlSize;
    2306 #else
    2307   //UInt uiConvBit = g_aucConvertToBit[ Min(8,uiWidth)    ];
    2308   UInt uiConvBit = g_aucConvertToBit[ pcCU->isIntra( uiAbsPartIdx ) ? uiWidth : Min(8,uiWidth)    ];
    2309 #endif
    2310   pucScan        = g_auiFrameScanXY [ uiConvBit + 1 ];
    2311 
    2312 #if QC_MDCS
    2313   UInt uiBlkPos;
    2314 #if CAVLC_COEF_LRG_BLK
    2315   UInt uiLog2BlkSize = g_aucConvertToBit[ pcCU->isIntra( uiAbsPartIdx ) ? uiWidth : uiBlSize] + 2;
    2316 #else
    2317   UInt uiLog2BlkSize = g_aucConvertToBit[ pcCU->isIntra( uiAbsPartIdx ) ? uiWidth : Min(8,uiWidth)    ] + 2;
    2318 #endif
    2319   const UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
    2320 #endif //QC_MDCS
    2321 
    2322 #if CAVLC_COEF_LRG_BLK
    2323   static TCoeff scoeff[1024];
    2324 #else
    2325   TCoeff scoeff[64];
    2326 #endif
    2327   Int iBlockType;
    2328   UInt uiCodeDCCoef = 0;
    2329   TCoeff dcCoeff = 0;
    2330   if (pcCU->isIntra(uiAbsPartIdx))
    2331   {
    2332     UInt uiAbsPartIdxL, uiAbsPartIdxA;
    2333     TComDataCU* pcCUL   = pcCU->getPULeft (uiAbsPartIdxL, pcCU->getZorderIdxInCU() + uiAbsPartIdx);
    2334     TComDataCU* pcCUA   = pcCU->getPUAbove(uiAbsPartIdxA, pcCU->getZorderIdxInCU() + uiAbsPartIdx);
    2335     if (pcCUL == NULL && pcCUA == NULL)
    2336     {
    2337       uiCodeDCCoef = 1;
    2338       xWriteVlc((eTType == TEXT_LUMA ? 3 : 1) , abs(piCoeff[0]));
    2339       if (piCoeff[0] != 0)
    2340       {
    2341         UInt sign = (piCoeff[0] < 0) ? 1 : 0;
    2342         xWriteFlag(sign);
    2343       }
    2344       dcCoeff = piCoeff[0];
    2345       piCoeff[0] = 1;
    2346     }
    2347   }
    2348 
    2349   if( uiSize == 2*2 )
    2350   {
    2351     // hack: re-use 4x4 coding
    2352     ::memset( scoeff, 0, 16*sizeof(TCoeff) );
    2353     for (uiScanning=0; uiScanning<4; uiScanning++)
    2354     {
    2355 #if QC_MDCS
    2356       uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
    2357       scoeff[15-uiScanning] = piCoeff[ uiBlkPos ];
    2358 #else
    2359       scoeff[15-uiScanning] = piCoeff[ pucScan[ uiScanning ] ];
    2360 #endif //QC_MDCS
    2361     }
    2362 #if QC_MOD_LCEC
    2363     if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
    2364       iBlockType = eTType-2;
    2365     else
    2366       iBlockType = 2 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
    2367 #else
    2368     iBlockType = pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType();
    2369 #endif
    2370 
    2371 #if CAVLC_COEF_LRG_BLK
    2372     xCodeCoeff( scoeff, iBlockType, 4 );
    2373 #else
    2374     xCodeCoeff4x4( scoeff, iBlockType );
    2375 #endif
    2376   }
    2377   else if ( uiSize == 4*4 )
    2378   {
    2379     for (uiScanning=0; uiScanning<16; uiScanning++)
    2380     {
    2381 #if QC_MDCS
    2382       uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
    2383       scoeff[15-uiScanning] = piCoeff[ uiBlkPos ];
    2384 #else
    2385       scoeff[15-uiScanning] = piCoeff[ pucScan[ uiScanning ] ];
    2386 #endif //QC_MDCS
    2387     }
    2388 #if QC_MOD_LCEC
    2389     if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
    2390       iBlockType = eTType-2;
    2391     else
    2392       iBlockType = 2 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
    2393 #else
    2394     iBlockType = pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType();
    2395 #endif
    2396 
    2397 #if CAVLC_COEF_LRG_BLK
    2398     xCodeCoeff( scoeff, iBlockType, 4 );
    2399 #else
    2400     xCodeCoeff4x4( scoeff, iBlockType );
    2401 #endif
    2402   }
    2403   else if ( uiSize == 8*8 )
    2404   {
    2405     for (uiScanning=0; uiScanning<64; uiScanning++)
    2406     {
    2407 #if QC_MDCS
    2408       uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
    2409       scoeff[63-uiScanning] = piCoeff[ uiBlkPos ];
    2410 #else
    2411       scoeff[63-uiScanning] = piCoeff[ pucScan[ uiScanning ] ];
    2412 #endif //QC_MDCS
    2413     }
    2414     if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
    2415       iBlockType = eTType-2;
    2416     else
    2417       iBlockType = 2 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
    2418 
    2419 #if CAVLC_COEF_LRG_BLK
    2420     xCodeCoeff( scoeff, iBlockType, 8 );
    2421 #else
    2422     xCodeCoeff8x8( scoeff, iBlockType );
    2423 #endif
    2424   }
    2425   else
    2426   {
    2427     if(!pcCU->isIntra( uiAbsPartIdx ))
    2428     {
    2429 #if CAVLC_COEF_LRG_BLK
    2430       UInt uiBlSizeInBit = g_aucConvertToBit[uiBlSize] + 2;
    2431       UInt uiWidthInBit = g_aucConvertToBit[uiWidth] + 2;
    2432       for (uiScanning=0; uiScanning<uiNoCoeff; uiScanning++)
    2433       {
    2434 #if QC_MDCS
    2435         uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
    2436         uiBlkPos = ((uiBlkPos>>uiBlSizeInBit) <<uiWidthInBit) + (uiBlkPos&(uiBlSize-1));
    2437         scoeff[uiNoCoeff-uiScanning-1] = piCoeff[ uiBlkPos ];
    2438 #else
    2439         scoeff[uiNoCoeff-uiScanning-1] = piCoeff[((pucScan[uiScanning]>>uiBlSizeInBit)<<uiWidthInBit) + (pucScan[uiScanning]&(uiBlSize-1))];
    2440 #endif
    2441       }
    2442 #else
    2443       for (uiScanning=0; uiScanning<64; uiScanning++)
    2444       {
    2445 #if QC_MDCS
    2446       uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
    2447       uiBlkPos = (uiBlkPos/8) * uiWidth + uiBlkPos%8;
    2448       scoeff[63-uiScanning] = piCoeff[ uiBlkPos ];
    2449 #else
    2450         scoeff[63-uiScanning] = piCoeff[(pucScan[uiScanning]/8)*uiWidth + (pucScan[uiScanning]%8)];
    2451 #endif //QC_MDCS
    2452       }
    2453       if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
    2454         iBlockType = eTType-2;
    2455       else
    2456         iBlockType = 5 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
    2457       xCodeCoeff8x8( scoeff, iBlockType );
    2458       return;
    2459 #endif
    2460     }
    2461 
    2462     if(pcCU->isIntra( uiAbsPartIdx ))
    2463     {
    2464 #if CAVLC_COEF_LRG_BLK
    2465       for (uiScanning=0; uiScanning<uiNoCoeff; uiScanning++)
    2466       {
    2467 #if QC_MDCS
    2468         uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
    2469         scoeff[uiNoCoeff-uiScanning-1] = piCoeff[ uiBlkPos ];
    2470 #else
    2471         scoeff[uiNoCoeff-uiScanning-1] = piCoeff[ pucScan[ uiScanning ] ];
    2472 #endif
    2473       }
    2474 #else
    2475       for (uiScanning=0; uiScanning<64; uiScanning++)
    2476       {
    2477 #if QC_MDCS
    2478       uiBlkPos = g_auiSigLastScan[uiScanIdx][uiLog2BlkSize-1][uiScanning];
    2479       scoeff[63-uiScanning] = piCoeff[ uiBlkPos ];
    2480 #else
    2481         scoeff[63-uiScanning] = piCoeff[ pucScan[ uiScanning ] ];
    2482 #endif //QC_MDCS
    2483       }
    2484 
    2485       if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
    2486         iBlockType = eTType-2;
    2487       else
    2488         iBlockType = 5 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
    2489       xCodeCoeff8x8( scoeff, iBlockType );
    2490 #endif
    2491     }
    2492 
    2493 #if CAVLC_COEF_LRG_BLK
    2494     if (eTType==TEXT_CHROMA_U || eTType==TEXT_CHROMA_V)
    2495     {
    2496       iBlockType = eTType-2;
    2497     }
    2498     else
    2499     {
    2500       iBlockType = 5 + ( pcCU->isIntra(uiAbsPartIdx) ? 0 : pcCU->getSlice()->getSliceType() );
    2501     }
    2502     xCodeCoeff( scoeff, iBlockType, uiBlSize);
    2503 #endif
    2504 
    2505     //#endif
    2506   }
    2507 
    2508   if (uiCodeDCCoef == 1)
    2509   {
    2510     piCoeff[0] = dcCoeff;
    2511   }
    2512 }
    2513 
    2514 Void TEncCavlc::codeAlfFlag( UInt uiCode )
    2515 {
    2516 
    2517   xWriteFlag( uiCode );
    2518 }
    2519 
    2520 #if TSB_ALF_HEADER
    2521 Void TEncCavlc::codeAlfFlagNum( UInt uiCode, UInt minValue )
    2522 {
    2523   UInt uiLength = 0;
    2524   UInt maxValue = (minValue << (this->getMaxAlfCtrlDepth()*2));
    2525   assert((uiCode>=minValue)&&(uiCode<=maxValue));
    2526   UInt temp = maxValue - minValue;
    2527   for(UInt i=0; i<32; i++)
    2528   {
    2529     if(temp&0x1)
    2530     {
    2531       uiLength = i+1;
    2532     }
    2533     temp = (temp >> 1);
    2534   }
    2535   if(uiLength)
    2536   {
    2537     xWriteCode( uiCode - minValue, uiLength );
    2538   }
    2539 }
    2540 
    2541 Void TEncCavlc::codeAlfCtrlFlag( UInt uiSymbol )
    2542 {
    2543   xWriteFlag( uiSymbol );
    2544 }
    2545 #endif
    2546 
    2547 Void TEncCavlc::codeAlfUvlc( UInt uiCode )
    2548 {
    2549   xWriteUvlc( uiCode );
    2550 }
    2551 
    2552 Void TEncCavlc::codeAlfSvlc( Int iCode )
    2553 {
    2554   xWriteSvlc( iCode );
    2555 }
    2556 #if MTK_SAO
    2557 Void TEncCavlc::codeAoFlag( UInt uiCode )
    2558 {
    2559 
    2560   xWriteFlag( uiCode );
    2561 #if LCEC_STAT
    2562   if (m_bAdaptFlag)
    2563     m_uiBitAlfFlag += 1;
    2564 #endif
    2565 }
    2566 
    2567 Void TEncCavlc::codeAoUvlc( UInt uiCode )
    2568 {
    2569 #if LCEC_STAT
    2570   if (m_bAdaptFlag)
    2571     m_uiBitAlfUvlc += xWriteUvlc( uiCode );
    2572   else
    2573 #endif
    2574     xWriteUvlc( uiCode );
    2575 }
    2576 
    2577 Void TEncCavlc::codeAoSvlc( Int iCode )
    2578 {
    2579 #if LCEC_STAT
    2580   if (m_bAdaptFlag)
    2581     m_uiBitAlfSvlc += xWriteSvlc( iCode );
    2582   else
    2583 #endif
    2584     xWriteSvlc( iCode );
    2585 }
    2586 
    2587 #endif
    2588 
    2589 Void TEncCavlc::estBit( estBitsSbacStruct* pcEstBitsCabac, UInt uiCTXIdx, TextType eTType )
     1538  assert(uiCode<=maxValue);             
     1539
     1540  for(UInt i=0; i<32; i++)                                     
     1541  {                                                           
     1542    if(maxValue&0x1)                                               
     1543    {                                                         
     1544      uiLength = i+1;                                         
     1545    }                                                         
     1546    maxValue = (maxValue >> 1);                                       
     1547  }
     1548  WRITE_CODE( uiCode, uiLength, "sao_run_diff");
     1549}
     1550#endif
     1551
     1552Void TEncCavlc::estBit( estBitsSbacStruct* pcEstBitsCabac, Int width, Int height, TextType eTType )
    25901553{
    25911554  // printf("error : no VLC mode support in this version\n");
     
    26071570  UInt uiLength = 1;
    26081571  UInt uiTemp = ++uiCode;
    2609 
     1572 
    26101573  assert ( uiTemp );
    2611 
     1574 
    26121575  while( 1 != uiTemp )
    26131576  {
     
    26151578    uiLength += 2;
    26161579  }
    2617 
    2618   m_pcBitIf->write( uiCode, uiLength );
     1580 
     1581  //m_pcBitIf->write( uiCode, uiLength );
     1582  // Take care of cases where uiLength > 32
     1583  m_pcBitIf->write( 0, uiLength >> 1);
     1584  m_pcBitIf->write( uiCode, (uiLength+1) >> 1);
    26191585}
    26201586
     
    26221588{
    26231589  UInt uiCode;
    2624 
     1590 
    26251591  uiCode = xConvertToUInt( iCode );
    26261592  xWriteUvlc( uiCode );
     
    26321598}
    26331599
    2634 Void TEncCavlc::xCheckCoeff( TCoeff* pcCoef, UInt uiSize, UInt uiDepth, UInt& uiNumofCoeff, UInt& uiPart )
    2635 {
    2636   UInt ui = uiSize>>uiDepth;
    2637   if( uiPart == 0 )
    2638   {
    2639     if( ui <= 4 )
    2640     {
    2641       UInt x, y;
    2642       TCoeff* pCeoff = pcCoef;
    2643       for( y=0 ; y<ui ; y++ )
    2644       {
    2645         for( x=0 ; x<ui ; x++ )
    2646         {
    2647           if( pCeoff[x] != 0 )
    2648           {
    2649             uiNumofCoeff++;
    2650           }
    2651         }
    2652         pCeoff += uiSize;
    2653       }
    2654     }
    2655     else
    2656     {
    2657       xCheckCoeff( pcCoef,                            uiSize, uiDepth+1, uiNumofCoeff, uiPart ); uiPart++; //1st Part
    2658       xCheckCoeff( pcCoef             + (ui>>1),      uiSize, uiDepth+1, uiNumofCoeff, uiPart ); uiPart++; //2nd Part
    2659       xCheckCoeff( pcCoef + (ui>>1)*uiSize,           uiSize, uiDepth+1, uiNumofCoeff, uiPart ); uiPart++; //3rd Part
    2660       xCheckCoeff( pcCoef + (ui>>1)*uiSize + (ui>>1), uiSize, uiDepth+1, uiNumofCoeff, uiPart );           //4th Part
    2661     }
    2662   }
    2663   else
    2664   {
    2665     UInt x, y;
    2666     TCoeff* pCeoff = pcCoef;
    2667     for( y=0 ; y<ui ; y++ )
    2668     {
    2669       for( x=0 ; x<ui ; x++ )
    2670       {
    2671         if( pCeoff[x] != 0 )
    2672         {
    2673           uiNumofCoeff++;
    2674         }
    2675       }
    2676       pCeoff += uiSize;
    2677     }
    2678   }
     1600/** Write PCM alignment bits.
     1601 * \returns Void
     1602 */
     1603Void  TEncCavlc::xWritePCMAlignZero    ()
     1604{
     1605  m_pcBitIf->writeAlignZero();
    26791606}
    26801607
     
    26901617    return;
    26911618  }
    2692 
     1619 
    26931620  Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
    2694 
     1621 
    26951622  while( --uiSymbol )
    26961623  {
     
    27111638    UInt uiCount = 0;
    27121639    Bool bNoExGo = (uiSymbol < 13);
    2713 
     1640   
    27141641    while( --uiSymbol && ++uiCount < 13 )
    27151642    {
     
    27481675}
    27491676
    2750 #if !QC_MOD_LCEC_RDOQ
    2751 UInt TEncCavlc::xLeadingZeros(UInt uiCode)
    2752 {
    2753   UInt uiCount = 0;
    2754   Int iDone = 0;
    2755 
    2756   if (uiCode)
    2757   {
    2758     while (!iDone)
    2759     {
    2760       uiCode >>= 1;
    2761       if (!uiCode) iDone = 1;
    2762       else uiCount++;
    2763     }
    2764   }
    2765   return uiCount;
    2766 }
    2767 #endif
    2768 
    2769 Void TEncCavlc::xWriteVlc(UInt uiTableNumber, UInt uiCodeNumber)
    2770 {
    2771 #if CAVLC_COEF_LRG_BLK
    2772   assert( uiTableNumber<=13 );
    2773 #else
    2774   assert( uiTableNumber<=11 );
    2775 #endif
    2776 
    2777   UInt uiTemp;
    2778   UInt uiLength = 0;
    2779   UInt uiCode = 0;
    2780 
    2781   if ( uiTableNumber < 5 )
    2782   {
    2783     if ((Int)uiCodeNumber < (6 * (1 << uiTableNumber)))
    2784     {
    2785       uiTemp = 1<<uiTableNumber;
    2786       uiCode = uiTemp+uiCodeNumber%uiTemp;
    2787       uiLength = 1+uiTableNumber+(uiCodeNumber>>uiTableNumber);
    2788     }
    2789     else
    2790     {
    2791       uiCode = uiCodeNumber - (6 * (1 << uiTableNumber)) + (1 << uiTableNumber);
    2792       uiLength = (6-uiTableNumber)+1+2*xLeadingZeros(uiCode);
    2793     }
    2794   }
    2795   else if (uiTableNumber < 8)
    2796   {
    2797     uiTemp = 1<<(uiTableNumber-4);
    2798     uiCode = uiTemp+uiCodeNumber%uiTemp;
    2799     uiLength = 1+(uiTableNumber-4)+(uiCodeNumber>>(uiTableNumber-4));
    2800   }
    2801   else if (uiTableNumber == 8)
    2802   {
    2803     assert( uiCodeNumber<=2 );
    2804     if (uiCodeNumber == 0)
    2805     {
    2806       uiCode = 1;
    2807       uiLength = 1;
    2808     }
    2809     else if (uiCodeNumber == 1)
    2810     {
    2811       uiCode = 1;
    2812       uiLength = 2;
    2813     }
    2814     else if (uiCodeNumber == 2)
    2815     {
    2816       uiCode = 0;
    2817       uiLength = 2;
    2818     }
    2819   }
    2820   else if (uiTableNumber == 9)
    2821   {
    2822     if (uiCodeNumber == 0)
    2823     {
    2824       uiCode = 4;
    2825       uiLength = 3;
    2826     }
    2827     else if (uiCodeNumber == 1)
    2828     {
    2829       uiCode = 10;
    2830       uiLength = 4;
    2831     }
    2832     else if (uiCodeNumber == 2)
    2833     {
    2834       uiCode = 11;
    2835       uiLength = 4;
    2836     }
    2837     else if (uiCodeNumber < 11)
    2838     {
    2839       uiCode = uiCodeNumber+21;
    2840       uiLength = 5;
    2841     }
    2842     else
    2843     {
    2844       uiTemp = 1<<4;
    2845       uiCode = uiTemp+(uiCodeNumber+5)%uiTemp;
    2846       uiLength = 5+((uiCodeNumber+5)>>4);
    2847     }
    2848   }
    2849   else if (uiTableNumber == 10)
    2850   {
    2851     uiCode = uiCodeNumber+1;
    2852     uiLength = 1+2*xLeadingZeros(uiCode);
    2853   }
    2854   else if (uiTableNumber == 11)
    2855   {
    2856     if (uiCodeNumber == 0)
    2857     {
    2858       uiCode = 0;
    2859       uiLength = 3;
    2860     }
    2861     else
    2862     {
    2863       uiCode = uiCodeNumber + 1;
    2864       uiLength = 4;
    2865     }
    2866   }
    2867 #if CAVLC_COEF_LRG_BLK
    2868   else if (uiTableNumber == 12)
    2869   {
    2870     uiCode = 64+(uiCodeNumber&0x3f);
    2871     uiLength = 7+(uiCodeNumber>>6);
    2872     if (uiLength>32)
    2873     {
    2874       xWriteCode(0, uiLength-32);
    2875       uiLength  = 32;
    2876     }
    2877   }
    2878   else if (uiTableNumber == 13)
    2879   {
    2880     uiTemp = 1<<4;
    2881     uiCode = uiTemp+(uiCodeNumber&0x0f);
    2882     uiLength = 5+(uiCodeNumber>>4);
    2883   }
    2884 #endif
    2885 
    2886   xWriteCode(uiCode, uiLength);
    2887 }
    2888 
    2889 #if CAVLC_COEF_LRG_BLK
    2890 /** Function for encoding a block of transform coeffcients in CAVLC.
    2891  * \param scoeff pointer to transform coefficient buffer
    2892  * \param n block type information, e.g. luma, chroma, intra, inter, etc.
    2893  * \param blSize block size
    2894  * \returns
    2895  * This function performs encoding for a block of transform coefficient in CAVLC.
     1677/** code explicit wp tables
     1678 * \param TComSlice* pcSlice
     1679 * \returns Void
    28961680 */
    2897 Void TEncCavlc::xCodeCoeff( TCoeff* scoeff, Int n, Int blSize)
    2898 {
    2899   static const int switch_thr[10] = {49,49,0,49,49,0,49,49,49,49};
    2900   int i, noCoeff = blSize*blSize;
    2901   unsigned int cn;
    2902   int level,vlc,sign,done,last_pos,start;
    2903   int run_done,maxrun,run,lev;
    2904   int tmprun,vlc_adaptive=0;
    2905   static const int atable[5] = {4,6,14,28,0xfffffff};
    2906   int sum_big_coef = 0;
    2907   Int tr1;
    2908 
    2909   /* Do the last coefficient first */
    2910   i = 0;
    2911   done = 0;
    2912   while (!done && i < noCoeff)
    2913   {
    2914     if (scoeff[i])
    2915     {
    2916       done = 1;
    2917     }
    2918     else
    2919     {
    2920       i++;
    2921     }
    2922   }
    2923   if (i == noCoeff)
    2924   {
    2925     return;
    2926   }
    2927 
    2928   last_pos = noCoeff-i-1;
    2929   level = abs(scoeff[i]);
    2930   lev = (level == 1) ? 0 : 1;
    2931 
    2932   if(blSize >= 8)
    2933   {
    2934     cn = xLastLevelInd(lev, last_pos, blSize);
    2935     // ADAPT_VLC_NUM
    2936     vlc = g_auiLastPosVlcNum[n][Min(16,m_uiLastPosVlcIndex[n])];
    2937     xWriteVlc( vlc, cn );
    2938 
    2939     if ( m_bAdaptFlag ){
    2940       // ADAPT_VLC_NUM
    2941       cn = (blSize==8)? cn:(cn>>2);
    2942       m_uiLastPosVlcIndex[n] += cn == m_uiLastPosVlcIndex[n] ? 0 : (cn < m_uiLastPosVlcIndex[n] ? -1 : 1);
    2943     }
    2944   }
    2945   else
    2946   {
    2947     int x,y,cx,cy;
    2948     int nTab = max(0,n-2);
    2949 
    2950     x = (lev<<4) + last_pos;
    2951     cx = m_uiLPTableE4[nTab][x];
    2952     xWriteVlc( 2, cx );
    2953 
    2954     if ( m_bAdaptFlag )
    2955     {
    2956       cy = Max( 0, cx-1 );
    2957       y = m_uiLPTableD4[nTab][cy];
    2958       m_uiLPTableD4[nTab][cy] = x;
    2959       m_uiLPTableD4[nTab][cx] = y;
    2960       m_uiLPTableE4[nTab][x] = cy;
    2961       m_uiLPTableE4[nTab][y] = cx;
    2962     }
    2963   }
    2964 
    2965   sign = (scoeff[i++] < 0) ? 1 : 0;
    2966   if (level > 1)
    2967   {
    2968     xWriteVlc( 0, ((level-2)<<1)+sign );
    2969     tr1=0;
    2970   }
    2971   else
    2972   {
    2973     xWriteFlag( sign );
    2974     tr1=1;
    2975   }
    2976 
    2977   if (i < noCoeff)
    2978   {
    2979     /* Go into run mode */
    2980     run_done = 0;
    2981     const UInt *vlcTable = (n==2||n==5)? ((blSize<=8)? g_auiVlcTable8x8Intra:g_auiVlcTable16x16Intra):
    2982       ((blSize<=8)? g_auiVlcTable8x8Inter:g_auiVlcTable16x16Inter);
    2983     const UInt **pLumaRunTr1 = (blSize==4)? g_pLumaRunTr14x4:g_pLumaRunTr18x8;
    2984     while ( !run_done )
    2985     {
    2986       maxrun = noCoeff-i-1;
    2987       tmprun = Min(maxrun, 28);
    2988 
    2989       vlc = vlcTable[tmprun];
    2990       run = 0;
    2991       done = 0;
    2992       while (!done)
    2993       {
    2994         if (!scoeff[i])
    2995         {
    2996           run++;
    2997         }
    2998         else
    2999         {
    3000           level = abs(scoeff[i]);
    3001           lev = (level == 1) ? 0 : 1;
    3002 
    3003           if(n == 2 || n == 5)
     1681Void TEncCavlc::xCodePredWeightTable( TComSlice* pcSlice )
     1682{
     1683  wpScalingParam  *wp;
     1684  Bool            bChroma     = true; // color always present in HEVC ?
     1685  Int             iNbRef       = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1);
     1686  Bool            bDenomCoded  = false;
     1687
     1688  UInt            uiMode = 0;
     1689  if ( (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) || (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag()==0 ) )
     1690    uiMode = 1; // explicit
     1691  else if ( pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==2 )
     1692    uiMode = 2; // implicit (does not use this mode in this syntax)
     1693  if (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag())
     1694    uiMode = 3; // combined explicit
     1695  if(uiMode == 1)
     1696  {
     1697    for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
     1698    {
     1699      RefPicList  eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
     1700      for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
     1701      {
     1702        pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
     1703        if ( !bDenomCoded )
     1704        {
     1705          Int iDeltaDenom;
     1706          WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" );     // ue(v): luma_log2_weight_denom
     1707
     1708          if( bChroma )
    30041709          {
    3005             cn = xRunLevelInd(lev, run, maxrun, pLumaRunTr1[tr1][tmprun]);
     1710            iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom);
     1711            WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );       // se(v): delta_chroma_log2_weight_denom
    30061712          }
    3007           else
     1713          bDenomCoded = true;
     1714        }
     1715
     1716        WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lX_flag" );               // u(1): luma_weight_lX_flag
     1717
     1718        if ( wp[0].bPresentFlag )
     1719        {
     1720          Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom));
     1721          WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lX" );                  // se(v): delta_luma_weight_lX
     1722          WRITE_SVLC( wp[0].iOffset, "luma_offset_lX" );                       // se(v): luma_offset_lX
     1723        }
     1724
     1725        if ( bChroma )
     1726        {
     1727          WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lX_flag" );           // u(1): chroma_weight_lX_flag
     1728
     1729          if ( wp[1].bPresentFlag )
    30081730          {
    3009             cn = xRunLevelIndInter(lev, run, maxrun);
    3010           }
    3011 
    3012           xWriteVlc( vlc, cn );
    3013 
    3014           if (tr1==0 || level>=2)
    3015           {
    3016             tr1=0;
    3017           }
    3018           else if (tr1 < MAX_TR1)
    3019           {
    3020             tr1++;
    3021           }
    3022 
    3023           sign = (scoeff[i] < 0) ? 1 : 0;
    3024           if (level > 1)
    3025           {
    3026             xWriteVlc( 0, ((level-2)<<1)+sign );
    3027 
    3028             sum_big_coef += level;
    3029             if (blSize == 4 || i > switch_thr[n] || sum_big_coef > 2)
     1731            for ( Int j=1 ; j<3 ; j++ )
    30301732            {
    3031               run_done = 1;
     1733              Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom));
     1734              WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lX" );            // se(v): delta_chroma_weight_lX
     1735
     1736              Int iDeltaChroma = (wp[j].iOffset + ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) - (g_uiIBDI_MAX>>1));
     1737              WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lX" );            // se(v): delta_chroma_offset_lX
    30321738            }
    30331739          }
    3034           else
     1740        }
     1741      }
     1742    }
     1743  }
     1744  else if (uiMode == 3)
     1745  {
     1746    for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx++ )
     1747    {
     1748      RefPicList  eRefPicList = (RefPicList)pcSlice->getListIdFromIdxOfLC(iRefIdx);
     1749      Int iCombRefIdx = pcSlice->getRefIdxFromIdxOfLC(iRefIdx);
     1750
     1751      pcSlice->getWpScaling(eRefPicList, iCombRefIdx, wp);
     1752      if ( !bDenomCoded )
     1753      {
     1754        Int iDeltaDenom;
     1755        WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" );       // ue(v): luma_log2_weight_denom
     1756
     1757        if( bChroma )
     1758        {
     1759          iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom);
     1760          WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );         // se(v): delta_chroma_log2_weight_denom
     1761        }
     1762        bDenomCoded = true;
     1763      }
     1764
     1765      WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lc_flag" );                 // u(1): luma_weight_lc_flag
     1766
     1767      if ( wp[0].bPresentFlag )
     1768      {
     1769        Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom));
     1770        WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lc" );                    // se(v): delta_luma_weight_lc
     1771        WRITE_SVLC( wp[0].iOffset, "luma_offset_lc" );                         // se(v): luma_offset_lc
     1772      }
     1773      if ( bChroma )
     1774      {
     1775        WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lc_flag" );             // u(1): luma_weight_lc_flag
     1776
     1777        if ( wp[1].bPresentFlag )
     1778        {
     1779          for ( Int j=1 ; j<3 ; j++ )
    30351780          {
    3036             xWriteFlag( sign );
     1781            Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom));
     1782            WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lc" );              // se(v): delta_chroma_weight_lc
     1783
     1784            Int iDeltaChroma = (wp[j].iOffset + ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) - (g_uiIBDI_MAX>>1));
     1785            WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lc" );              // se(v): delta_chroma_offset_lc
    30371786          }
    3038           run = 0;
    3039           done = 1;
    3040         }
    3041         if (i == (noCoeff-1))
    3042         {
    3043           done = 1;
    3044           run_done = 1;
    3045           if (run)
    3046           {
    3047             if(n == 2 || n == 5)
    3048             {
    3049               cn = xRunLevelInd(0, run, maxrun, pLumaRunTr1[tr1][tmprun]);
    3050             }
    3051             else
    3052             {
    3053               cn = xRunLevelIndInter(0, run, maxrun);
    3054             }
    3055 
    3056             xWriteVlc( vlc, cn );
    3057           }
    3058         }
    3059         i++;
    3060       }
    3061     }
    3062   }
    3063 
    3064   /* Code the rest in level mode */
    3065   start = i;
    3066   for ( i=start; i<noCoeff; i++ )
    3067   {
    3068     int tmp = abs(scoeff[i]);
    3069 
    3070     xWriteVlc( vlc_adaptive, tmp );
    3071     if (scoeff[i])
    3072     {
    3073       xWriteFlag( (scoeff[i] < 0) ? 1 : 0 );
    3074       if (tmp > atable[vlc_adaptive])
    3075       {
    3076         vlc_adaptive++;
    3077       }
    3078     }
    3079   }
    3080 
     1787        }
     1788      }
     1789    }
     1790  }
     1791}
     1792
     1793/** code quantization matrix
     1794 *  \param scalingList quantization matrix information
     1795 */
     1796Void TEncCavlc::codeScalingList( TComScalingList* scalingList )
     1797{
     1798  UInt listId,sizeId;
     1799  Bool scalingListPredModeFlag;
     1800
     1801#if SCALING_LIST_OUTPUT_RESULT
     1802  Int startBit;
     1803  Int startTotalBit;
     1804  startBit = m_pcBitIf->getNumberOfWrittenBits();
     1805  startTotalBit = m_pcBitIf->getNumberOfWrittenBits();
     1806#endif
     1807
     1808  WRITE_FLAG( scalingList->getScalingListPresentFlag (), "scaling_list_present_flag" );
     1809
     1810  if(scalingList->getScalingListPresentFlag () == false)
     1811  {
     1812#if SCALING_LIST_OUTPUT_RESULT
     1813    printf("Header Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startBit);
     1814#endif
     1815    //for each size
     1816    for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
     1817    {
     1818      for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
     1819      {
     1820#if SCALING_LIST_OUTPUT_RESULT
     1821        startBit = m_pcBitIf->getNumberOfWrittenBits();
     1822#endif
     1823        scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
     1824        WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
     1825        if(!scalingListPredModeFlag)// Copy Mode
     1826        {
     1827          WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId) - 1, "scaling_list_pred_matrix_id_delta");
     1828        }
     1829        else// DPCM Mode
     1830        {
     1831          xCodeScalingList(scalingList, sizeId, listId);
     1832        }
     1833#if SCALING_LIST_OUTPUT_RESULT
     1834        printf("Matrix [%d][%d] Bit %d\n",sizeId,listId,m_pcBitIf->getNumberOfWrittenBits() - startBit);
     1835#endif
     1836      }
     1837    }
     1838  }
     1839#if SCALING_LIST_OUTPUT_RESULT
     1840  else
     1841  {
     1842    printf("Header Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit);
     1843  }
     1844  printf("Total Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit);
     1845#endif
    30811846  return;
    30821847}
    3083 
     1848/** code DPCM
     1849 * \param scalingList quantization matrix information
     1850 * \param sizeIdc size index
     1851 * \param listIdc list index
     1852 */
     1853Void TEncCavlc::xCodeScalingList(TComScalingList* scalingList, UInt sizeId, UInt listId)
     1854{
     1855#if SCALING_LIST
     1856  Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
     1857  UInt* scan    = g_auiFrameScanXY [ (sizeId == 0)? 1 : 2];
    30841858#else
    3085 Void TEncCavlc::xCodeCoeff4x4(TCoeff* scoeff, Int n )
    3086 {
    3087   Int i;
    3088   UInt cn;
    3089   Int level,vlc,sign,done,last_pos,start;
    3090   Int run_done,maxrun,run,lev;
    3091 #if QC_MOD_LCEC
    3092   Int vlc_adaptive=0;
     1859  Int coefNum = (Int)g_scalingListSize[sizeId];
     1860  UInt* scan    = g_auiFrameScanXY [ sizeId + 1];
     1861#endif
     1862  Int nextCoef = SCALING_LIST_START_VALUE;
     1863  Int data;
     1864  Int *src = scalingList->getScalingListAddress(sizeId, listId);
     1865#if SCALING_LIST
     1866  if(sizeId > SCALING_LIST_8x8 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
     1867  {
     1868    WRITE_SVLC( -8, "scaling_list_dc_coef_minus8");
     1869  }
     1870  else if(sizeId < SCALING_LIST_16x16 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
     1871  {
     1872    WRITE_SVLC( -8, "scaling_list_delta_coef");
     1873  }
     1874  else
     1875  {
     1876    if( sizeId > SCALING_LIST_8x8 )
     1877    {
     1878      WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
     1879    }
     1880    for(Int i=0;i<coefNum;i++)
     1881    {
     1882      data = src[scan[i]] - nextCoef;
     1883      nextCoef = src[scan[i]];
     1884      if(data > 127)
     1885      {
     1886        data = data - 256;
     1887      }
     1888      if(data < -128)
     1889      {
     1890        data = data + 256;
     1891      }
     1892
     1893      WRITE_SVLC( data,  "scaling_list_delta_coef");
     1894    }
     1895  }
    30931896#else
    3094   Int tmprun, vlc_adaptive=0;
    3095 #endif
    3096   static const int atable[5] = {4,6,14,28,0xfffffff};
    3097   Int tmp;
    3098 #if QC_MOD_LCEC
    3099   Int nTab = max(0,n-2);
    3100   Int tr1;
    3101 #endif
    3102 
    3103   /* Do the last coefficient first */
    3104   i = 0;
    3105   done = 0;
    3106 
    3107   while (!done && i < 16)
    3108   {
    3109     if (scoeff[i])
    3110     {
    3111       done = 1;
    3112     }
    3113     else
    3114     {
    3115       i++;
    3116     }
    3117   }
    3118   if (i == 16)
    3119   {
    3120     return;
    3121   }
    3122 
    3123   last_pos = 15-i;
    3124   level = abs(scoeff[i]);
    3125   lev = (level == 1) ? 0 : 1;
    3126 
    3127 #if QC_MOD_LCEC
    3128   if (level>1)
    3129   {
    3130     tr1=0;
    3131   }
    3132   else
    3133   {
    3134     tr1=1;
    3135   }
    3136 #endif
    3137 
    3138   {
    3139     int x,y,cx,cy,vlcNum;
    3140     int vlcTable[3] = {2,2,2};
    3141 
    3142     x = 16*lev + last_pos;
    3143 
    3144 #if QC_MOD_LCEC
    3145     cx = m_uiLPTableE4[nTab][x];
    3146     vlcNum = vlcTable[nTab];
     1897  for(Int i=0;i<coefNum;i++)
     1898  {
     1899    data = src[scan[i]] - nextCoef;
     1900    nextCoef = src[scan[i]];
     1901    if(data > 127)
     1902    {
     1903      data = data - 256;
     1904    }
     1905    if(data < -128)
     1906    {
     1907      data = data + 256;
     1908    }
     1909
     1910    WRITE_SVLC( data,  "delta_coef");
     1911  }
     1912#endif
     1913}
     1914Bool TComScalingList::checkPredMode(UInt sizeId, UInt listId)
     1915{
     1916  for(Int predListIdx = (Int)listId -1 ; predListIdx >= 0; predListIdx--)
     1917  {
     1918#if SCALING_LIST
     1919    if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
     1920     && ((sizeId < SCALING_LIST_16x16) || (getScalingListDC(sizeId,listId) == getScalingListDC(sizeId,predListIdx)))) // check DC value
    31471921#else
    3148     cx = m_uiLPTableE4[n][x];
    3149     vlcNum = vlcTable[n];
    3150 #endif
    3151 
    3152     xWriteVlc( vlcNum, cx );
    3153 
    3154     if ( m_bAdaptFlag )
    3155     {
    3156       cy = Max( 0, cx-1 );
    3157 #if QC_MOD_LCEC
    3158       y = m_uiLPTableD4[nTab][cy];
    3159       m_uiLPTableD4[nTab][cy] = x;
    3160       m_uiLPTableD4[nTab][cx] = y;
    3161       m_uiLPTableE4[nTab][x] = cy;
    3162       m_uiLPTableE4[nTab][y] = cx;
    3163 #else
    3164       y = m_uiLPTableD4[n][cy];
    3165       m_uiLPTableD4[n][cy] = x;
    3166       m_uiLPTableD4[n][cx] = y;
    3167       m_uiLPTableE4[n][x] = cy;
    3168       m_uiLPTableE4[n][y] = cx;
    3169 #endif
    3170     }
    3171   }
    3172 
    3173   sign = (scoeff[i] < 0) ? 1 : 0;
    3174   if (level > 1)
    3175   {
    3176     xWriteVlc( 0, 2*(level-2)+sign );
    3177   }
    3178   else
    3179   {
    3180     xWriteFlag( sign );
    3181   }
    3182   i++;
    3183 
    3184   if (i < 16)
    3185   {
    3186     /* Go into run mode */
    3187     run_done = 0;
    3188     while (!run_done)
    3189     {
    3190       maxrun = 15-i;
    3191 #if QC_MOD_LCEC
    3192       if ( n == 2 )
    3193         vlc = g_auiVlcTable8x8Intra[maxrun];
    3194       else
    3195         vlc = g_auiVlcTable8x8Inter[maxrun];
    3196 #else
    3197       tmprun = maxrun;
    3198       if (maxrun > 27)
    3199       {
    3200         vlc = 3;
    3201         tmprun = 28;
    3202       }
    3203       else
    3204       {
    3205         vlc = g_auiVlcTable8x8[maxrun];
    3206       }
    3207 #endif
    3208 
    3209       run = 0;
    3210       done = 0;
    3211       while (!done)
    3212       {
    3213         if (!scoeff[i])
    3214         {
    3215           run++;
    3216         }
    3217         else
    3218         {
    3219           level = abs(scoeff[i]);
    3220           lev = (level == 1) ? 0 : 1;
    3221 #if QC_MOD_LCEC
    3222           if ( n == 2 ){
    3223             cn = xRunLevelInd(lev, run, maxrun, g_auiLumaRunTr14x4[tr1][maxrun]);
    3224           }
    3225           else{
    3226 #if RUNLEVEL_TABLE_CUT
    3227             cn = xRunLevelIndInter(lev, run, maxrun);
    3228 #else
    3229             cn = g_auiLumaRun8x8[maxrun][lev][run];
    3230 #endif
    3231           }
    3232 #else
    3233           if (maxrun > 27)
    3234           {
    3235             cn = g_auiLumaRun8x8[28][lev][run];
    3236           }
    3237           else
    3238           {
    3239             cn = g_auiLumaRun8x8[maxrun][lev][run];
    3240           }
    3241 #endif
    3242             xWriteVlc( vlc, cn );
    3243 
    3244 #if QC_MOD_LCEC
    3245           if (tr1>0 && tr1 < MAX_TR1)
    3246           {
    3247             tr1++;
    3248           }
    3249 #endif
    3250           sign = (scoeff[i] < 0) ? 1 : 0;
    3251           if (level > 1)
    3252           {
    3253             xWriteVlc( 0, 2*(level-2)+sign );
    3254             run_done = 1;
    3255           }
    3256           else
    3257           {
    3258             xWriteFlag( sign );
    3259           }
    3260 
    3261           run = 0;
    3262           done = 1;
    3263         }
    3264         if (i == 15)
    3265         {
    3266           done = 1;
    3267           run_done = 1;
    3268           if (run)
    3269           {
    3270 #if QC_MOD_LCEC
    3271             if (n==2){
    3272               cn=xRunLevelInd(0, run, maxrun, g_auiLumaRunTr14x4[tr1][maxrun]);
    3273             }
    3274             else{
    3275 #if RUNLEVEL_TABLE_CUT
    3276               cn = xRunLevelIndInter(0, run, maxrun);
    3277 #else
    3278               cn = g_auiLumaRun8x8[maxrun][0][run];
    3279 #endif
    3280             }
    3281 #else
    3282             if (maxrun > 27)
    3283             {
    3284               cn = g_auiLumaRun8x8[28][0][run];
    3285             }
    3286             else
    3287             {
    3288               cn = g_auiLumaRun8x8[maxrun][0][run];
    3289             }
    3290 #endif
    3291             xWriteVlc( vlc, cn );
    3292           }
    3293         }
    3294         i++;
    3295       }
    3296     }
    3297   }
    3298 
    3299   /* Code the rest in level mode */
    3300   start = i;
    3301   for ( i=start; i<16; i++ )
    3302   {
    3303     tmp = abs(scoeff[i]);
    3304     xWriteVlc( vlc_adaptive, tmp );
    3305     if (scoeff[i])
    3306     {
    3307       sign = (scoeff[i] < 0) ? 1 : 0;
    3308       xWriteFlag( sign );
    3309     }
    3310     if ( tmp > atable[vlc_adaptive] )
    3311     {
    3312       vlc_adaptive++;
    3313     }
    3314   }
    3315   return;
    3316 }
    3317 
    3318 Void TEncCavlc::xCodeCoeff8x8( TCoeff* scoeff, Int n )
    3319 {
    3320   int i;
    3321   unsigned int cn;
    3322   int level,vlc,sign,done,last_pos,start;
    3323   int run_done,maxrun,run,lev;
    3324 #if QC_MOD_LCEC
    3325   int vlc_adaptive=0;
    3326 #else
    3327   int tmprun,vlc_adaptive=0;
    3328 #endif
    3329   static const int atable[5] = {4,6,14,28,0xfffffff};
    3330   int tmp;
    3331 #if QC_MOD_LCEC
    3332   Int tr1;
    3333 #endif
    3334 
    3335   static const int switch_thr[10] = {49,49,0,49,49,0,49,49,49,49};
    3336   int sum_big_coef = 0;
    3337 
    3338 
    3339   /* Do the last coefficient first */
    3340   i = 0;
    3341   done = 0;
    3342   while (!done && i < 64)
    3343   {
    3344     if (scoeff[i])
    3345     {
    3346       done = 1;
    3347     }
    3348     else
    3349     {
    3350       i++;
    3351     }
    3352   }
    3353   if (i == 64)
    3354   {
    3355     return;
    3356   }
    3357 
    3358   last_pos = 63-i;
    3359   level = abs(scoeff[i]);
    3360   lev = (level == 1) ? 0 : 1;
    3361 
    3362   {
    3363     int x,y,cx,cy,vlcNum;
    3364     x = 64*lev + last_pos;
    3365 
    3366     cx = m_uiLPTableE8[n][x];
    3367     // ADAPT_VLC_NUM
    3368     vlcNum = g_auiLastPosVlcNum[n][Min(16,m_uiLastPosVlcIndex[n])];
    3369     xWriteVlc( vlcNum, cx );
    3370 
    3371     if ( m_bAdaptFlag )
    3372     {
    3373       // ADAPT_VLC_NUM
    3374       m_uiLastPosVlcIndex[n] += cx == m_uiLastPosVlcIndex[n] ? 0 : (cx < m_uiLastPosVlcIndex[n] ? -1 : 1);
    3375       cy = Max(0,cx-1);
    3376       y = m_uiLPTableD8[n][cy];
    3377       m_uiLPTableD8[n][cy] = x;
    3378       m_uiLPTableD8[n][cx] = y;
    3379       m_uiLPTableE8[n][x] = cy;
    3380       m_uiLPTableE8[n][y] = cx;
    3381     }
    3382   }
    3383 
    3384   sign = (scoeff[i] < 0) ? 1 : 0;
    3385   if (level > 1)
    3386   {
    3387     xWriteVlc( 0, 2*(level-2)+sign );
    3388   }
    3389   else
    3390   {
    3391     xWriteFlag( sign );
    3392   }
    3393   i++;
    3394 #if QC_MOD_LCEC
    3395   if (level>1){
    3396     tr1=0;
    3397   }
    3398   else
    3399   {
    3400     tr1=1;
    3401   }
    3402 #endif
    3403 
    3404   if (i < 64)
    3405   {
    3406     /* Go into run mode */
    3407     run_done = 0;
    3408     while ( !run_done )
    3409     {
    3410       maxrun = 63-i;
    3411 #if QC_MOD_LCEC
    3412       if(n == 2 || n == 5)
    3413         vlc = g_auiVlcTable8x8Intra[Min(maxrun,28)];
    3414       else
    3415         vlc = g_auiVlcTable8x8Inter[Min(maxrun,28)];
    3416 #else
    3417       tmprun = maxrun;
    3418       if (maxrun > 27)
    3419       {
    3420         vlc = 3;
    3421         tmprun = 28;
    3422       }
    3423       else
    3424       {
    3425         vlc = g_auiVlcTable8x8[maxrun];
    3426       }
    3427 #endif
    3428 
    3429       run = 0;
    3430       done = 0;
    3431       while (!done)
    3432       {
    3433         if (!scoeff[i])
    3434         {
    3435           run++;
    3436         }
    3437         else
    3438         {
    3439           level = abs(scoeff[i]);
    3440           lev = (level == 1) ? 0 : 1;
    3441 #if QC_MOD_LCEC
    3442           if(n == 2 || n == 5)
    3443             cn = xRunLevelInd(lev, run, maxrun, g_auiLumaRunTr18x8[tr1][min(maxrun,28)]);
    3444           else
    3445 #if RUNLEVEL_TABLE_CUT
    3446             cn = xRunLevelIndInter(lev, run, maxrun);
    3447 #else
    3448             cn = g_auiLumaRun8x8[min(maxrun,28)][lev][run];
    3449 #endif
    3450 #else
    3451           if (maxrun > 27)
    3452           {
    3453             cn = g_auiLumaRun8x8[28][lev][run];
    3454           }
    3455           else
    3456           {
    3457             cn = g_auiLumaRun8x8[maxrun][lev][run];
    3458           }
    3459 #endif
    3460           xWriteVlc( vlc, cn );
    3461 
    3462 #if QC_MOD_LCEC
    3463           if (tr1==0 || level >=2)
    3464           {
    3465             tr1=0;
    3466           }
    3467           else if (tr1 < MAX_TR1)
    3468           {
    3469             tr1++;
    3470           }
    3471 #endif
    3472           sign = (scoeff[i] < 0) ? 1 : 0;
    3473           if (level > 1)
    3474           {
    3475             xWriteVlc( 0, 2*(level-2)+sign );
    3476 
    3477             sum_big_coef += level;
    3478             if (i > switch_thr[n] || sum_big_coef > 2)
    3479             {
    3480               run_done = 1;
    3481             }
    3482           }
    3483           else
    3484           {
    3485             xWriteFlag( sign );
    3486           }
    3487           run = 0;
    3488           done = 1;
    3489         }
    3490         if (i == 63)
    3491         {
    3492           done = 1;
    3493           run_done = 1;
    3494           if (run)
    3495           {
    3496 #if QC_MOD_LCEC
    3497             if(n == 2 || n == 5)
    3498               cn=xRunLevelInd(0, run, maxrun, g_auiLumaRunTr18x8[tr1][min(maxrun,28)]);
    3499             else
    3500 #if RUNLEVEL_TABLE_CUT
    3501               cn = xRunLevelIndInter(0, run, maxrun);
    3502 #else
    3503               cn = g_auiLumaRun8x8[min(maxrun,28)][0][run];
    3504 #endif
    3505 #else
    3506             if (maxrun > 27)
    3507             {
    3508               cn = g_auiLumaRun8x8[28][0][run];
    3509             }
    3510             else
    3511             {
    3512               cn = g_auiLumaRun8x8[maxrun][0][run];
    3513             }
    3514 #endif
    3515             xWriteVlc( vlc, cn );
    3516           }
    3517         }
    3518         i++;
    3519       }
    3520     }
    3521   }
    3522 
    3523   /* Code the rest in level mode */
    3524   start = i;
    3525   for ( i=start; i<64; i++ )
    3526   {
    3527     tmp = abs(scoeff[i]);
    3528     xWriteVlc( vlc_adaptive, tmp );
    3529     if (scoeff[i])
    3530     {
    3531       sign = (scoeff[i] < 0) ? 1 : 0;
    3532       xWriteFlag( sign );
    3533     }
    3534     if (tmp>atable[vlc_adaptive])
    3535     {
    3536       vlc_adaptive++;
    3537     }
    3538   }
    3539 
    3540   return;
    3541 }
    3542 #endif
    3543 
    3544 #ifdef WEIGHT_PRED
    3545 Void TEncCavlc::codeWeightPredTable( TComSlice* pcSlice )
    3546 {
    3547   wpScalingParam  *wp;
    3548   Bool            bChroma     = true; // color always present in HEVC ?
    3549   Int             nbRef       = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1);
    3550   Bool            denomCoded  = false;
    3551 
    3552   for ( Int numRef=0 ; numRef<nbRef ; numRef++ ) {
    3553     RefPicList  eRefPicList = ( numRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
    3554     for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) {
    3555       pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
    3556       if ( !denomCoded ) {
    3557         // code luma_log2_weight_denom :
    3558         xWriteUvlc( wp[0].uiLog2WeightDenom );    // ue(v): luma_log2_weight_denom
    3559         if( bChroma )
    3560           xWriteUvlc( wp[1].uiLog2WeightDenom );  // ue(v): chroma_log2_weight_denom
    3561         denomCoded = true;
    3562       }
    3563 
    3564       xWriteFlag( wp[0].bPresentFlag );           // u(1): luma_weight_l0_flag
    3565       if ( wp[0].bPresentFlag ) {
    3566         xWriteSvlc( wp[0].iWeight );  // se(v): luma_weight_l0[i]
    3567         xWriteSvlc( wp[0].iOffset );  // se(v): luma_offset_l0[i]
    3568       }
    3569       if ( bChroma ) {
    3570         xWriteFlag( wp[1].bPresentFlag );           // u(1): chroma_weight_l0_flag
    3571         if ( wp[1].bPresentFlag ) {
    3572           for ( Int j=1 ; j<3 ; j++ ) {
    3573             xWriteSvlc( wp[j].iWeight );  // se(v): chroma_weight_l0[i][j]
    3574             xWriteSvlc( wp[j].iOffset );  // se(v): chroma_offset_l0[i][j]
    3575           }
    3576         }
    3577       }
    3578     }
    3579   }
    3580 
    3581 }
    3582 #endif
     1922    if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*(Int)g_scalingListSize[sizeId])) // check value of matrix
     1923#endif
     1924    {
     1925      setRefMatrixId(sizeId, listId, predListIdx);
     1926      return false;
     1927    }
     1928  }
     1929  return true;
     1930}
     1931//! \}
Note: See TracChangeset for help on using the changeset viewer.