source: SHVCSoftware/branches/SHM-dev/source/Lib/TLibDecoder/TDecSbac.cpp @ 1247

Last change on this file since 1247 was 1246, checked in by seregin, 9 years ago

port rev 4240

  • Property svn:eol-style set to native
File size: 67.6 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2014, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TDecSbac.cpp
35    \brief    Context-adaptive entropy decoder class
36*/
37
38#include "TDecSbac.h"
39#include "TLibCommon/TComTU.h"
40
41#if RExt__DECODER_DEBUG_BIT_STATISTICS
42#include "TLibCommon/TComCodingStatistics.h"
43//
44#define RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(a) , a
45#else
46#define RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(a)
47#endif
48
49//! \ingroup TLibDecoder
50//! \{
51
52#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
53#include "../TLibCommon/Debug.h"
54#endif
55
56
57//////////////////////////////////////////////////////////////////////
58// Construction/Destruction
59//////////////////////////////////////////////////////////////////////
60
61TDecSbac::TDecSbac()
62// new structure here
63: m_pcBitstream                              ( 0 )
64, m_pcTDecBinIf                              ( NULL )
65, m_numContextModels                         ( 0 )
66, m_cCUSplitFlagSCModel                      ( 1,             1,                      NUM_SPLIT_FLAG_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
67, m_cCUSkipFlagSCModel                       ( 1,             1,                      NUM_SKIP_FLAG_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
68, m_cCUMergeFlagExtSCModel                   ( 1,             1,                      NUM_MERGE_FLAG_EXT_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
69, m_cCUMergeIdxExtSCModel                    ( 1,             1,                      NUM_MERGE_IDX_EXT_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
70, m_cCUPartSizeSCModel                       ( 1,             1,                      NUM_PART_SIZE_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
71, m_cCUPredModeSCModel                       ( 1,             1,                      NUM_PRED_MODE_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
72, m_cCUIntraPredSCModel                      ( 1,             1,                      NUM_ADI_CTX                          , m_contextModels + m_numContextModels, m_numContextModels)
73, m_cCUChromaPredSCModel                     ( 1,             1,                      NUM_CHROMA_PRED_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
74, m_cCUDeltaQpSCModel                        ( 1,             1,                      NUM_DELTA_QP_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
75, m_cCUInterDirSCModel                       ( 1,             1,                      NUM_INTER_DIR_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
76, m_cCURefPicSCModel                         ( 1,             1,                      NUM_REF_NO_CTX                       , m_contextModels + m_numContextModels, m_numContextModels)
77, m_cCUMvdSCModel                            ( 1,             1,                      NUM_MV_RES_CTX                       , m_contextModels + m_numContextModels, m_numContextModels)
78, m_cCUQtCbfSCModel                          ( 1,             NUM_QT_CBF_CTX_SETS,    NUM_QT_CBF_CTX_PER_SET               , m_contextModels + m_numContextModels, m_numContextModels)
79, m_cCUTransSubdivFlagSCModel                ( 1,             1,                      NUM_TRANS_SUBDIV_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
80, m_cCUQtRootCbfSCModel                      ( 1,             1,                      NUM_QT_ROOT_CBF_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
81, m_cCUSigCoeffGroupSCModel                  ( 1,             2,                      NUM_SIG_CG_FLAG_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
82, m_cCUSigSCModel                            ( 1,             1,                      NUM_SIG_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
83, m_cCuCtxLastX                              ( 1,             NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY                 , m_contextModels + m_numContextModels, m_numContextModels)
84, m_cCuCtxLastY                              ( 1,             NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY                 , m_contextModels + m_numContextModels, m_numContextModels)
85, m_cCUOneSCModel                            ( 1,             1,                      NUM_ONE_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
86, m_cCUAbsSCModel                            ( 1,             1,                      NUM_ABS_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
87, m_cMVPIdxSCModel                           ( 1,             1,                      NUM_MVP_IDX_CTX                      , m_contextModels + m_numContextModels, m_numContextModels)
88, m_cSaoMergeSCModel                         ( 1,             1,                      NUM_SAO_MERGE_FLAG_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
89, m_cSaoTypeIdxSCModel                       ( 1,             1,                      NUM_SAO_TYPE_IDX_CTX                 , m_contextModels + m_numContextModels, m_numContextModels)
90, m_cTransformSkipSCModel                    ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_TRANSFORMSKIP_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
91, m_CUTransquantBypassFlagSCModel            ( 1,             1,                      NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX    , m_contextModels + m_numContextModels, m_numContextModels)
92, m_explicitRdpcmFlagSCModel                 ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_EXPLICIT_RDPCM_FLAG_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
93, m_explicitRdpcmDirSCModel                  ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_EXPLICIT_RDPCM_DIR_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
94, m_cCrossComponentPredictionSCModel         ( 1,             1,                      NUM_CROSS_COMPONENT_PREDICTION_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
95, m_ChromaQpAdjFlagSCModel                   ( 1,             1,                      NUM_CHROMA_QP_ADJ_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
96, m_ChromaQpAdjIdcSCModel                    ( 1,             1,                      NUM_CHROMA_QP_ADJ_IDC_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
97{
98  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
99}
100
101TDecSbac::~TDecSbac()
102{
103}
104
105// ====================================================================================================================
106// Public member functions
107// ====================================================================================================================
108
109Void TDecSbac::resetEntropy(TComSlice* pSlice)
110{
111  SliceType sliceType  = pSlice->getSliceType();
112  Int       qp         = pSlice->getSliceQp();
113
114  if (pSlice->getPPS()->getCabacInitPresentFlag() && pSlice->getCabacInitFlag())
115  {
116    switch (sliceType)
117    {
118    case P_SLICE:           // change initialization table to B_SLICE initialization
119      sliceType = B_SLICE;
120      break;
121    case B_SLICE:           // change initialization table to P_SLICE initialization
122      sliceType = P_SLICE;
123      break;
124    default     :           // should not occur
125      assert(0);
126      break;
127    }
128  }
129
130  m_cCUSplitFlagSCModel.initBuffer                ( sliceType, qp, (UChar*)INIT_SPLIT_FLAG );
131  m_cCUSkipFlagSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_SKIP_FLAG );
132  m_cCUMergeFlagExtSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT );
133  m_cCUMergeIdxExtSCModel.initBuffer              ( sliceType, qp, (UChar*)INIT_MERGE_IDX_EXT );
134  m_cCUPartSizeSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_PART_SIZE );
135  m_cCUPredModeSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_PRED_MODE );
136  m_cCUIntraPredSCModel.initBuffer                ( sliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
137  m_cCUChromaPredSCModel.initBuffer               ( sliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
138  m_cCUInterDirSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_INTER_DIR );
139  m_cCUMvdSCModel.initBuffer                      ( sliceType, qp, (UChar*)INIT_MVD );
140  m_cCURefPicSCModel.initBuffer                   ( sliceType, qp, (UChar*)INIT_REF_PIC );
141  m_cCUDeltaQpSCModel.initBuffer                  ( sliceType, qp, (UChar*)INIT_DQP );
142  m_cCUQtCbfSCModel.initBuffer                    ( sliceType, qp, (UChar*)INIT_QT_CBF );
143  m_cCUQtRootCbfSCModel.initBuffer                ( sliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
144  m_cCUSigCoeffGroupSCModel.initBuffer            ( sliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
145  m_cCUSigSCModel.initBuffer                      ( sliceType, qp, (UChar*)INIT_SIG_FLAG );
146  m_cCuCtxLastX.initBuffer                        ( sliceType, qp, (UChar*)INIT_LAST );
147  m_cCuCtxLastY.initBuffer                        ( sliceType, qp, (UChar*)INIT_LAST );
148  m_cCUOneSCModel.initBuffer                      ( sliceType, qp, (UChar*)INIT_ONE_FLAG );
149  m_cCUAbsSCModel.initBuffer                      ( sliceType, qp, (UChar*)INIT_ABS_FLAG );
150  m_cMVPIdxSCModel.initBuffer                     ( sliceType, qp, (UChar*)INIT_MVP_IDX );
151  m_cSaoMergeSCModel.initBuffer                   ( sliceType, qp, (UChar*)INIT_SAO_MERGE_FLAG );
152  m_cSaoTypeIdxSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
153  m_cCUTransSubdivFlagSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
154  m_cTransformSkipSCModel.initBuffer              ( sliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
155  m_CUTransquantBypassFlagSCModel.initBuffer      ( sliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
156  m_explicitRdpcmFlagSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_FLAG);
157  m_explicitRdpcmDirSCModel.initBuffer            ( sliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_DIR);
158  m_cCrossComponentPredictionSCModel.initBuffer   ( sliceType, qp, (UChar*)INIT_CROSS_COMPONENT_PREDICTION );
159  m_ChromaQpAdjFlagSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_FLAG );
160  m_ChromaQpAdjIdcSCModel.initBuffer              ( sliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_IDC );
161
162  for (UInt statisticIndex = 0; statisticIndex < RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS ; statisticIndex++)
163  {
164    m_golombRiceAdaptationStatistics[statisticIndex] = 0;
165  }
166
167  m_pcTDecBinIf->start();
168}
169
170Void TDecSbac::parseTerminatingBit( UInt& ruiBit )
171{
172  m_pcTDecBinIf->decodeBinTrm( ruiBit );
173  if ( ruiBit == 1 )
174  {
175    m_pcTDecBinIf->finish();
176
177#if RExt__DECODER_DEBUG_BIT_STATISTICS
178    TComCodingStatistics::IncrementStatisticEP(STATS__TRAILING_BITS, m_pcBitstream->readOutTrailingBits(),0);
179#else
180    m_pcBitstream->readOutTrailingBits();
181#endif
182  }
183}
184
185Void TDecSbac::parseRemainingBytes( Bool noTrailingBytesExpected )
186{
187  if (noTrailingBytesExpected)
188  {
189    const UInt numberOfRemainingSubstreamBytes=m_pcBitstream->getNumBitsLeft();
190    assert (numberOfRemainingSubstreamBytes == 0);
191  }
192  else
193  {
194    while (m_pcBitstream->getNumBitsLeft())
195    {
196      UInt trailingNullByte=m_pcBitstream->readByte();
197      if (trailingNullByte!=0)
198      {
199        printf("Trailing byte should be 0, but has value %02x\n", trailingNullByte);
200        assert(trailingNullByte==0);
201      }
202    }
203  }
204}
205
206#if RExt__DECODER_DEBUG_BIT_STATISTICS
207Void TDecSbac::xReadUnaryMaxSymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol, const class TComCodingStatisticsClassType &whichStat )
208#else
209Void TDecSbac::xReadUnaryMaxSymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
210#endif
211{
212  if (uiMaxSymbol == 0)
213  {
214    ruiSymbol = 0;
215    return;
216  }
217
218  m_pcTDecBinIf->decodeBin( ruiSymbol, pcSCModel[0] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
219
220  if( ruiSymbol == 0 || uiMaxSymbol == 1 )
221  {
222    return;
223  }
224
225  UInt uiSymbol = 0;
226  UInt uiCont;
227
228  do
229  {
230    m_pcTDecBinIf->decodeBin( uiCont, pcSCModel[ iOffset ] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
231    uiSymbol++;
232  } while( uiCont && ( uiSymbol < uiMaxSymbol - 1 ) );
233
234  if( uiCont && ( uiSymbol == uiMaxSymbol - 1 ) )
235  {
236    uiSymbol++;
237  }
238
239  ruiSymbol = uiSymbol;
240}
241
242#if RExt__DECODER_DEBUG_BIT_STATISTICS
243Void TDecSbac::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount, const class TComCodingStatisticsClassType &whichStat )
244#else
245Void TDecSbac::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
246#endif
247{
248  UInt uiSymbol = 0;
249  UInt uiBit = 1;
250
251  while( uiBit )
252  {
253    m_pcTDecBinIf->decodeBinEP( uiBit RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
254    uiSymbol += uiBit << uiCount++;
255  }
256
257  if ( --uiCount )
258  {
259    UInt bins;
260    m_pcTDecBinIf->decodeBinsEP( bins, uiCount RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
261    uiSymbol += bins;
262  }
263
264  ruiSymbol = uiSymbol;
265}
266
267#if RExt__DECODER_DEBUG_BIT_STATISTICS
268Void TDecSbac::xReadUnarySymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset, const class TComCodingStatisticsClassType &whichStat )
269#else
270Void TDecSbac::xReadUnarySymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset )
271#endif
272{
273  m_pcTDecBinIf->decodeBin( ruiSymbol, pcSCModel[0] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
274
275  if( !ruiSymbol )
276  {
277    return;
278  }
279
280  UInt uiSymbol = 0;
281  UInt uiCont;
282
283  do
284  {
285    m_pcTDecBinIf->decodeBin( uiCont, pcSCModel[ iOffset ] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
286    uiSymbol++;
287  } while( uiCont );
288
289  ruiSymbol = uiSymbol;
290}
291
292
293/** Parsing of coeff_abs_level_remaing
294 * \param ruiSymbol reference to coeff_abs_level_remaing
295 * \param ruiParam reference to parameter
296 * \returns Void
297 */
298#if RExt__DECODER_DEBUG_BIT_STATISTICS
299Void TDecSbac::xReadCoefRemainExGolomb ( UInt &rSymbol, UInt &rParam, const Bool useLimitedPrefixLength, const ChannelType channelType, const class TComCodingStatisticsClassType &whichStat )
300#else
301Void TDecSbac::xReadCoefRemainExGolomb ( UInt &rSymbol, UInt &rParam, const Bool useLimitedPrefixLength, const ChannelType channelType )
302#endif
303{
304  UInt prefix   = 0;
305  UInt codeWord = 0;
306
307  if (useLimitedPrefixLength)
308  {
309    const UInt longestPossiblePrefix = (32 - (COEF_REMAIN_BIN_REDUCTION + g_maxTrDynamicRange[channelType])) + COEF_REMAIN_BIN_REDUCTION;
310
311    do
312    {
313      prefix++;
314      m_pcTDecBinIf->decodeBinEP( codeWord RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
315    } while((codeWord != 0) && (prefix < longestPossiblePrefix));
316  }
317  else
318  {
319    do
320    {
321      prefix++;
322      m_pcTDecBinIf->decodeBinEP( codeWord RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
323    } while( codeWord);
324  }
325
326  codeWord  = 1 - codeWord;
327  prefix -= codeWord;
328  codeWord=0;
329
330  if (prefix < COEF_REMAIN_BIN_REDUCTION )
331  {
332    m_pcTDecBinIf->decodeBinsEP(codeWord,rParam RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
333    rSymbol = (prefix<<rParam) + codeWord;
334  }
335  else if (useLimitedPrefixLength)
336  {
337    const UInt maximumPrefixLength = (32 - (COEF_REMAIN_BIN_REDUCTION + g_maxTrDynamicRange[channelType]));
338
339    const UInt prefixLength = prefix - COEF_REMAIN_BIN_REDUCTION;
340    const UInt suffixLength = (prefixLength == maximumPrefixLength) ? (g_maxTrDynamicRange[channelType] - rParam) : prefixLength;
341
342    m_pcTDecBinIf->decodeBinsEP(codeWord, (suffixLength + rParam) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
343
344    rSymbol = codeWord + ((((1 << prefixLength) - 1) + COEF_REMAIN_BIN_REDUCTION) << rParam);
345  }
346  else
347  {
348    m_pcTDecBinIf->decodeBinsEP(codeWord,prefix-COEF_REMAIN_BIN_REDUCTION+rParam RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
349    rSymbol = (((1<<(prefix-COEF_REMAIN_BIN_REDUCTION))+COEF_REMAIN_BIN_REDUCTION-1)<<rParam)+codeWord;
350  }
351}
352
353
354/** Parse I_PCM information.
355 * \param pcCU
356 * \param uiAbsPartIdx
357 * \param uiDepth
358 * \returns Void
359 *
360 * If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
361 */
362Void TDecSbac::parseIPCMInfo ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
363{
364  UInt uiSymbol;
365
366  m_pcTDecBinIf->decodeBinTrm(uiSymbol);
367
368  if (uiSymbol == 1)
369  {
370    Bool bIpcmFlag = true;
371
372    pcCU->setPartSizeSubParts  ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
373    pcCU->setSizeSubParts      ( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
374    pcCU->setTrIdxSubParts     ( 0, uiAbsPartIdx, uiDepth );
375    pcCU->setIPCMFlagSubParts  ( bIpcmFlag, uiAbsPartIdx, uiDepth );
376
377    const UInt minCoeffSizeY = pcCU->getPic()->getMinCUWidth() * pcCU->getPic()->getMinCUHeight();
378    const UInt offsetY       = minCoeffSizeY * uiAbsPartIdx;
379    for (UInt ch=0; ch < pcCU->getPic()->getNumberValidComponents(); ch++)
380    {
381      const ComponentID compID = ComponentID(ch);
382      const UInt offset = offsetY >> (pcCU->getPic()->getComponentScaleX(compID) + pcCU->getPic()->getComponentScaleY(compID));
383      Pel * pPCMSample  = pcCU->getPCMSample(compID) + offset;
384      const UInt width  = pcCU->getWidth (uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleX(compID);
385      const UInt height = pcCU->getHeight(uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleY(compID);
386      const UInt sampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepth(toChannelType(compID));
387      for (UInt y=0; y<height; y++)
388      {
389        for (UInt x=0; x<width; x++)
390        {
391          UInt sample;
392          m_pcTDecBinIf->xReadPCMCode(sampleBits, sample);
393          pPCMSample[x] = sample;
394        }
395        pPCMSample += width;
396      }
397    }
398
399    m_pcTDecBinIf->start();
400  }
401}
402
403Void TDecSbac::parseCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
404{
405  UInt uiSymbol;
406  m_pcTDecBinIf->decodeBin( uiSymbol, m_CUTransquantBypassFlagSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__TQ_BYPASS_FLAG) );
407  pcCU->setCUTransquantBypassSubParts(uiSymbol ? true : false, uiAbsPartIdx, uiDepth);
408}
409
410/** parse skip flag
411 * \param pcCU
412 * \param uiAbsPartIdx
413 * \param uiDepth
414 * \returns Void
415 */
416Void TDecSbac::parseSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
417{
418  if( pcCU->getSlice()->isIntra() )
419  {
420    return;
421  }
422
423  UInt uiSymbol = 0;
424  UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx );
425  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SKIP_FLAG) );
426  DTRACE_CABAC_VL( g_nSymbolCounter++ );
427  DTRACE_CABAC_T( "\tSkipFlag" );
428  DTRACE_CABAC_T( "\tuiCtxSkip: ");
429  DTRACE_CABAC_V( uiCtxSkip );
430  DTRACE_CABAC_T( "\tuiSymbol: ");
431  DTRACE_CABAC_V( uiSymbol );
432  DTRACE_CABAC_T( "\n");
433
434  if( uiSymbol )
435  {
436    pcCU->setSkipFlagSubParts( true,        uiAbsPartIdx, uiDepth );
437    pcCU->setPredModeSubParts( MODE_INTER,  uiAbsPartIdx, uiDepth );
438    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
439    pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
440    pcCU->setMergeFlagSubParts( true , uiAbsPartIdx, 0, uiDepth );
441  }
442}
443
444
445/** parse merge flag
446 * \param pcCU
447 * \param uiAbsPartIdx
448 * \param uiDepth
449 * \param uiPUIdx
450 * \returns Void
451 */
452Void TDecSbac::parseMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx )
453{
454  UInt uiSymbol;
455  m_pcTDecBinIf->decodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MERGE_FLAG) );
456  pcCU->setMergeFlagSubParts( uiSymbol ? true : false, uiAbsPartIdx, uiPUIdx, uiDepth );
457
458  DTRACE_CABAC_VL( g_nSymbolCounter++ );
459  DTRACE_CABAC_T( "\tMergeFlag: " );
460  DTRACE_CABAC_V( uiSymbol );
461  DTRACE_CABAC_T( "\tAddress: " );
462  DTRACE_CABAC_V( pcCU->getCtuRsAddr() );
463  DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
464  DTRACE_CABAC_V( uiAbsPartIdx );
465  DTRACE_CABAC_T( "\n" );
466}
467
468Void TDecSbac::parseMergeIndex ( TComDataCU* pcCU, UInt& ruiMergeIndex )
469{
470  UInt uiUnaryIdx = 0;
471  UInt uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
472  if ( uiNumCand > 1 )
473  {
474    for( ; uiUnaryIdx < uiNumCand - 1; ++uiUnaryIdx )
475    {
476      UInt uiSymbol = 0;
477      if ( uiUnaryIdx==0 )
478      {
479        m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MERGE_INDEX) );
480      }
481      else
482      {
483        m_pcTDecBinIf->decodeBinEP( uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MERGE_INDEX) );
484      }
485      if( uiSymbol == 0 )
486      {
487        break;
488      }
489    }
490  }
491  ruiMergeIndex = uiUnaryIdx;
492
493  DTRACE_CABAC_VL( g_nSymbolCounter++ )
494  DTRACE_CABAC_T( "\tparseMergeIndex()" )
495  DTRACE_CABAC_T( "\tuiMRGIdx= " )
496  DTRACE_CABAC_V( ruiMergeIndex )
497  DTRACE_CABAC_T( "\n" )
498}
499
500Void TDecSbac::parseMVPIdx      ( Int& riMVPIdx )
501{
502  UInt uiSymbol;
503  xReadUnaryMaxSymbol(uiSymbol, m_cMVPIdxSCModel.get(0), 1, AMVP_MAX_NUM_CANDS-1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVP_IDX) );
504  riMVPIdx = uiSymbol;
505}
506
507Void TDecSbac::parseSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
508{
509  if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
510  {
511    pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
512    return;
513  }
514#if RExt__DECODER_DEBUG_BIT_STATISTICS
515  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__SPLIT_FLAG, g_aucConvertToBit[g_uiMaxCUWidth>>uiDepth]+2);
516#endif
517
518  UInt uiSymbol;
519  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSplitFlagSCModel.get( 0, 0, pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth ) ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
520  DTRACE_CABAC_VL( g_nSymbolCounter++ )
521  DTRACE_CABAC_T( "\tSplitFlag\n" )
522  pcCU->setDepthSubParts( uiDepth + uiSymbol, uiAbsPartIdx );
523
524  return;
525}
526
527/** parse partition size
528 * \param pcCU
529 * \param uiAbsPartIdx
530 * \param uiDepth
531 * \returns Void
532 */
533Void TDecSbac::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
534{
535  UInt uiSymbol, uiMode = 0;
536  PartSize eMode;
537
538#if RExt__DECODER_DEBUG_BIT_STATISTICS
539  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__PART_SIZE, g_aucConvertToBit[g_uiMaxCUWidth>>uiDepth]+2);
540#endif
541
542  if ( pcCU->isIntra( uiAbsPartIdx ) )
543  {
544    uiSymbol = 1;
545    if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
546    {
547      m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
548    }
549    eMode = uiSymbol ? SIZE_2Nx2N : SIZE_NxN;
550    UInt uiTrLevel = 0;
551    UInt uiWidthInBit  = g_aucConvertToBit[pcCU->getWidth(uiAbsPartIdx)]+2;
552    UInt uiTrSizeInBit = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxTrSize()]+2;
553    uiTrLevel          = uiWidthInBit >= uiTrSizeInBit ? uiWidthInBit - uiTrSizeInBit : 0;
554    if( eMode == SIZE_NxN )
555    {
556      pcCU->setTrIdxSubParts( 1+uiTrLevel, uiAbsPartIdx, uiDepth );
557    }
558    else
559    {
560      pcCU->setTrIdxSubParts( uiTrLevel, uiAbsPartIdx, uiDepth );
561    }
562  }
563  else
564  {
565    UInt uiMaxNumBits = 2;
566
567    if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( (g_uiMaxCUWidth>>uiDepth) == 8 && (g_uiMaxCUHeight>>uiDepth) == 8 ) )
568    {
569      uiMaxNumBits ++;
570    }
571
572    for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
573    {
574      m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, ui) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
575      if ( uiSymbol )
576      {
577        break;
578      }
579      uiMode++;
580    }
581    eMode = (PartSize) uiMode;
582    if ( pcCU->getSlice()->getSPS()->getUseAMP() && uiDepth < g_uiMaxCUDepth-g_uiAddCUDepth )
583    {
584      if (eMode == SIZE_2NxN)
585      {
586        m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype));
587        if (uiSymbol == 0)
588        {
589          m_pcTDecBinIf->decodeBinEP(uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
590          eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
591        }
592      }
593      else if (eMode == SIZE_Nx2N)
594      {
595        m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
596        if (uiSymbol == 0)
597        {
598          m_pcTDecBinIf->decodeBinEP(uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
599          eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
600        }
601      }
602    }
603  }
604  pcCU->setPartSizeSubParts( eMode, uiAbsPartIdx, uiDepth );
605  pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
606}
607
608
609/** parse prediction mode
610 * \param pcCU
611 * \param uiAbsPartIdx
612 * \param uiDepth
613 * \returns Void
614 */
615Void TDecSbac::parsePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
616{
617  if( pcCU->getSlice()->isIntra() )
618  {
619    pcCU->setPredModeSubParts( MODE_INTRA, uiAbsPartIdx, uiDepth );
620    return;
621  }
622
623  UInt uiSymbol;
624  Int  iPredMode = MODE_INTER;
625  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPredModeSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__PRED_MODE) );
626  iPredMode += uiSymbol;
627  pcCU->setPredModeSubParts( (PredMode)iPredMode, uiAbsPartIdx, uiDepth );
628}
629
630
631Void TDecSbac::parseIntraDirLumaAng  ( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
632{
633  PartSize mode = pcCU->getPartitionSize( absPartIdx );
634  UInt partNum = mode==SIZE_NxN?4:1;
635  UInt partOffset = ( pcCU->getPic()->getNumPartitionsInCtu() >> ( pcCU->getDepth(absPartIdx) << 1 ) ) >> 2;
636  UInt mpmPred[4],symbol;
637  Int j,intraPredMode;
638  if (mode==SIZE_NxN)
639  {
640    depth++;
641  }
642#if RExt__DECODER_DEBUG_BIT_STATISTICS
643  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__INTRA_DIR_ANG, g_aucConvertToBit[g_uiMaxCUWidth>>depth]+2, CHANNEL_TYPE_LUMA);
644#endif
645  for (j=0;j<partNum;j++)
646  {
647    m_pcTDecBinIf->decodeBin( symbol, m_cCUIntraPredSCModel.get( 0, 0, 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
648    mpmPred[j] = symbol;
649  }
650  for (j=0;j<partNum;j++)
651  {
652    Int preds[NUM_MOST_PROBABLE_MODES] = {-1, -1, -1};
653    pcCU->getIntraDirPredictor(absPartIdx+partOffset*j, preds, COMPONENT_Y);
654    if (mpmPred[j])
655    {
656      m_pcTDecBinIf->decodeBinEP( symbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
657      if (symbol)
658      {
659        m_pcTDecBinIf->decodeBinEP( symbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
660        symbol++;
661      }
662      intraPredMode = preds[symbol];
663    }
664    else
665    {
666      m_pcTDecBinIf->decodeBinsEP( symbol, 5 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
667      intraPredMode = symbol;
668
669      //postponed sorting of MPMs (only in remaining branch)
670      if (preds[0] > preds[1])
671      {
672        std::swap(preds[0], preds[1]);
673      }
674      if (preds[0] > preds[2])
675      {
676        std::swap(preds[0], preds[2]);
677      }
678      if (preds[1] > preds[2])
679      {
680        std::swap(preds[1], preds[2]);
681      }
682      for ( UInt i = 0; i < NUM_MOST_PROBABLE_MODES; i++ )
683      {
684        intraPredMode += ( intraPredMode >= preds[i] );
685      }
686    }
687    pcCU->setIntraDirSubParts(CHANNEL_TYPE_LUMA, (UChar)intraPredMode, absPartIdx+partOffset*j, depth );
688  }
689}
690
691
692Void TDecSbac::parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
693{
694  UInt uiSymbol;
695#if RExt__DECODER_DEBUG_BIT_STATISTICS
696  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__INTRA_DIR_ANG, g_aucConvertToBit[g_uiMaxCUWidth>>uiDepth]+2, CHANNEL_TYPE_CHROMA);
697#endif
698
699  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUChromaPredSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
700  if( uiSymbol == 0 )
701  {
702    uiSymbol = DM_CHROMA_IDX;
703  }
704  else
705  {
706    UInt uiIPredMode;
707    m_pcTDecBinIf->decodeBinsEP( uiIPredMode, 2 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
708    UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
709    pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
710    uiSymbol = uiAllowedChromaDir[ uiIPredMode ];
711  }
712
713  pcCU->setIntraDirSubParts( CHANNEL_TYPE_CHROMA, uiSymbol, uiAbsPartIdx, uiDepth );
714}
715
716
717Void TDecSbac::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx )
718{
719  UInt uiSymbol;
720  const UInt uiCtx = pcCU->getCtxInterDir( uiAbsPartIdx );
721  ContextModel *pCtx = m_cCUInterDirSCModel.get( 0 );
722
723  uiSymbol = 0;
724  if (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N || pcCU->getHeight(uiAbsPartIdx) != 8 )
725  {
726    m_pcTDecBinIf->decodeBin( uiSymbol, *( pCtx + uiCtx ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__INTER_DIR) );
727  }
728
729  if( uiSymbol )
730  {
731    uiSymbol = 2;
732  }
733  else
734  {
735    m_pcTDecBinIf->decodeBin( uiSymbol, *( pCtx + 4 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__INTER_DIR) );
736    assert(uiSymbol == 0 || uiSymbol == 1);
737  }
738
739  uiSymbol++;
740  ruiInterDir = uiSymbol;
741  return;
742}
743
744Void TDecSbac::parseRefFrmIdx( TComDataCU* pcCU, Int& riRefFrmIdx, RefPicList eRefList )
745{
746  UInt uiSymbol;
747
748  ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
749  m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__REF_FRM_IDX) );
750
751  if( uiSymbol )
752  {
753    UInt uiRefNum = pcCU->getSlice()->getNumRefIdx( eRefList ) - 2;
754    pCtx++;
755    UInt ui;
756    for( ui = 0; ui < uiRefNum; ++ui )
757    {
758      if( ui == 0 )
759      {
760        m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__REF_FRM_IDX) );
761      }
762      else
763      {
764        m_pcTDecBinIf->decodeBinEP( uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__REF_FRM_IDX) );
765      }
766      if( uiSymbol == 0 )
767      {
768        break;
769      }
770    }
771    uiSymbol = ui + 1;
772  }
773  riRefFrmIdx = uiSymbol;
774
775  return;
776}
777
778Void TDecSbac::parseMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth, RefPicList eRefList )
779{
780  UInt uiSymbol;
781  UInt uiHorAbs;
782  UInt uiVerAbs;
783  UInt uiHorSign = 0;
784  UInt uiVerSign = 0;
785  ContextModel *pCtx = m_cCUMvdSCModel.get( 0 );
786
787  if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
788  {
789    uiHorAbs=0;
790    uiVerAbs=0;
791  }
792  else
793  {
794    m_pcTDecBinIf->decodeBin( uiHorAbs, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD) );
795    m_pcTDecBinIf->decodeBin( uiVerAbs, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD) );
796
797    const Bool bHorAbsGr0 = uiHorAbs != 0;
798    const Bool bVerAbsGr0 = uiVerAbs != 0;
799    pCtx++;
800
801    if( bHorAbsGr0 )
802    {
803      m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD) );
804      uiHorAbs += uiSymbol;
805    }
806
807    if( bVerAbsGr0 )
808    {
809      m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD) );
810      uiVerAbs += uiSymbol;
811    }
812
813    if( bHorAbsGr0 )
814    {
815      if( 2 == uiHorAbs )
816      {
817        xReadEpExGolomb( uiSymbol, 1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD_EP) );
818        uiHorAbs += uiSymbol;
819      }
820
821      m_pcTDecBinIf->decodeBinEP( uiHorSign RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD_EP) );
822    }
823
824    if( bVerAbsGr0 )
825    {
826      if( 2 == uiVerAbs )
827      {
828        xReadEpExGolomb( uiSymbol, 1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD_EP) );
829        uiVerAbs += uiSymbol;
830      }
831
832      m_pcTDecBinIf->decodeBinEP( uiVerSign RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD_EP) );
833    }
834
835  }
836
837  const TComMv cMv( uiHorSign ? -Int( uiHorAbs ): uiHorAbs, uiVerSign ? -Int( uiVerAbs ) : uiVerAbs );
838  pcCU->getCUMvField( eRefList )->setAllMvd( cMv, pcCU->getPartitionSize( uiAbsPartIdx ), uiAbsPartIdx, uiDepth, uiPartIdx );
839  return;
840}
841
842Void TDecSbac::parseCrossComponentPrediction( TComTU &rTu, ComponentID compID )
843{
844  TComDataCU *pcCU = rTu.getCU();
845
846  if( isLuma(compID) || !pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction() )
847  {
848    return;
849  }
850
851  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
852
853  if (!pcCU->isIntra(uiAbsPartIdx) || (pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx ) == DM_CHROMA_IDX))
854  {
855    Char alpha  = 0;
856    UInt symbol = 0;
857
858    DTRACE_CABAC_VL( g_nSymbolCounter++ )
859    DTRACE_CABAC_T("\tparseCrossComponentPrediction()")
860    DTRACE_CABAC_T( "\tAddr=" )
861    DTRACE_CABAC_V( compID )
862    DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
863    DTRACE_CABAC_V( uiAbsPartIdx )
864#if RExt__DECODER_DEBUG_BIT_STATISTICS
865    TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__CROSS_COMPONENT_PREDICTION, (g_aucConvertToBit[rTu.getRect(compID).width] + 2), compID);
866#endif
867    ContextModel *pCtx = m_cCrossComponentPredictionSCModel.get(0, 0) + ((compID == COMPONENT_Cr) ? (NUM_CROSS_COMPONENT_PREDICTION_CTX >> 1) : 0);
868    m_pcTDecBinIf->decodeBin( symbol, pCtx[0] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
869
870    if(symbol != 0)
871    {
872      // Cross-component prediction alpha is non-zero.
873      UInt sign = 0;
874      m_pcTDecBinIf->decodeBin( symbol, pCtx[1] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
875
876      if (symbol != 0)
877      {
878        // alpha is 2 (symbol=1), 4(symbol=2) or 8(symbol=3).
879        // Read up to two more bits
880        xReadUnaryMaxSymbol( symbol, (pCtx + 2), 1, 2 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
881        symbol += 1;
882      }
883      m_pcTDecBinIf->decodeBin( sign, pCtx[4] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
884
885      alpha = (sign != 0) ? -(1 << symbol) : (1 << symbol);
886    }
887    DTRACE_CABAC_T( "\tAlpha=" )
888    DTRACE_CABAC_V( alpha )
889    DTRACE_CABAC_T( "\n" )
890
891    pcCU->setCrossComponentPredictionAlphaPartRange( alpha, compID, uiAbsPartIdx, rTu.GetAbsPartIdxNumParts( compID ) );
892  }
893}
894
895Void TDecSbac::parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize )
896{
897  m_pcTDecBinIf->decodeBin( ruiSubdivFlag, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiLog2TransformBlockSize )
898      RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(TComCodingStatisticsClassType(STATS__CABAC_BITS__TRANSFORM_SUBDIV_FLAG, 5-uiLog2TransformBlockSize))
899                          );
900  DTRACE_CABAC_VL( g_nSymbolCounter++ )
901  DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
902  DTRACE_CABAC_T( "\tsymbol=" )
903  DTRACE_CABAC_V( ruiSubdivFlag )
904  DTRACE_CABAC_T( "\tctx=" )
905  DTRACE_CABAC_V( uiLog2TransformBlockSize )
906  DTRACE_CABAC_T( "\n" )
907}
908
909Void TDecSbac::parseQtRootCbf( UInt uiAbsPartIdx, UInt& uiQtRootCbf )
910{
911  UInt uiSymbol;
912  const UInt uiCtx = 0;
913  m_pcTDecBinIf->decodeBin( uiSymbol , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__QT_ROOT_CBF) );
914  DTRACE_CABAC_VL( g_nSymbolCounter++ )
915  DTRACE_CABAC_T( "\tparseQtRootCbf()" )
916  DTRACE_CABAC_T( "\tsymbol=" )
917  DTRACE_CABAC_V( uiSymbol )
918  DTRACE_CABAC_T( "\tctx=" )
919  DTRACE_CABAC_V( uiCtx )
920  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
921  DTRACE_CABAC_V( uiAbsPartIdx )
922  DTRACE_CABAC_T( "\n" )
923
924  uiQtRootCbf = uiSymbol;
925}
926
927Void TDecSbac::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
928{
929  Int qp;
930  UInt uiDQp;
931  Int  iDQp;
932
933  UInt uiSymbol;
934
935  xReadUnaryMaxSymbol (uiDQp,  &m_cCUDeltaQpSCModel.get( 0, 0, 0 ), 1, CU_DQP_TU_CMAX RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTA_QP_EP) );
936
937  if( uiDQp >= CU_DQP_TU_CMAX)
938  {
939    xReadEpExGolomb( uiSymbol, CU_DQP_EG_k RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTA_QP_EP));
940    uiDQp+=uiSymbol;
941  }
942
943  if ( uiDQp > 0 )
944  {
945    UInt uiSign;
946#if SVC_EXTENSION
947    Int qpBdOffsetY = pcCU->getSlice()->getQpBDOffsetY();
948#else
949    Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
950#endif
951    m_pcTDecBinIf->decodeBinEP(uiSign RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTA_QP_EP));
952    iDQp = uiDQp;
953    if(uiSign)
954    {
955      iDQp = -iDQp;
956    }
957    qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+qpBdOffsetY)) - qpBdOffsetY;
958  }
959  else
960  {
961    qp = pcCU->getRefQP(uiAbsPartIdx);
962  }
963
964  pcCU->setQPSubParts(qp, uiAbsPartIdx, uiDepth);
965  pcCU->setCodedQP(qp);
966}
967
968/** parse chroma qp adjustment, converting to the internal table representation.
969 * \returns Void
970 */
971Void TDecSbac::parseChromaQpAdjustment( TComDataCU* cu, UInt absPartIdx, UInt depth )
972{
973  UInt symbol;
974#if RExt__DECODER_DEBUG_BIT_STATISTICS
975  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__CHROMA_QP_ADJUSTMENT, g_aucConvertToBit[g_uiMaxCUWidth>>depth]+2, CHANNEL_TYPE_CHROMA);
976#endif
977
978  Int tableSize = cu->getSlice()->getPPS()->getChromaQpAdjTableSize();
979
980  /* cu_chroma_qp_adjustment_flag */
981  m_pcTDecBinIf->decodeBin( symbol, m_ChromaQpAdjFlagSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
982
983  if (symbol && tableSize > 1)
984  {
985    /* cu_chroma_qp_adjustment_idc */
986    xReadUnaryMaxSymbol( symbol,  &m_ChromaQpAdjIdcSCModel.get( 0, 0, 0 ), 0, tableSize - 1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
987    symbol++;
988  }
989  /* NB, symbol = 0 if outer flag is not set,
990   *              1 if outer flag is set and there is no inner flag
991   *              1+ otherwise */
992  cu->setChromaQpAdjSubParts( symbol, absPartIdx, depth );
993  cu->setCodedChromaQpAdj(symbol);
994}
995
996Void TDecSbac::parseQtCbf( TComTU &rTu, const ComponentID compID, const Bool lowestLevel )
997{
998  TComDataCU* pcCU = rTu.getCU();
999
1000  const UInt absPartIdx       = rTu.GetAbsPartIdxTU(compID);
1001  const UInt TUDepth          = rTu.GetTransformDepthRel();
1002  const UInt uiCtx            = pcCU->getCtxQtCbf( rTu, toChannelType(compID) );
1003  const UInt contextSet       = toChannelType(compID);
1004
1005  const UInt width            = rTu.getRect(compID).width;
1006  const UInt height           = rTu.getRect(compID).height;
1007  const Bool canQuadSplit     = (width >= (MIN_TU_SIZE * 2)) && (height >= (MIN_TU_SIZE * 2));
1008  const UInt coveredPartIdxes = rTu.GetAbsPartIdxNumParts(compID);
1009
1010  //             Since the CBF for chroma is coded at the highest level possible, if sub-TUs are
1011  //             to be coded for a 4x8 chroma TU, their CBFs must be coded at the highest 4x8 level
1012  //             (i.e. where luma TUs are 8x8 rather than 4x4)
1013  //    ___ ___
1014  //   |   |   | <- 4 x (8x8 luma + 4x8 4:2:2 chroma)
1015  //   |___|___|    each quadrant has its own chroma CBF
1016  //   |   |   | _ _ _ _
1017  //   |___|___|        |
1018  //   <--16--->        V
1019  //                   _ _
1020  //                  |_|_| <- 4 x 4x4 luma + 1 x 4x8 4:2:2 chroma
1021  //                  |_|_|    no chroma CBF is coded - instead the parent CBF is inherited
1022  //                  <-8->    if sub-TUs are present, their CBFs had to be coded at the parent level
1023
1024  const UInt lowestTUDepth = TUDepth + ((!lowestLevel && !canQuadSplit) ? 1 : 0); //unsplittable TUs inherit their parent's CBF
1025        UInt lowestTUCBF   = 0;
1026
1027  if ((width != height) && (lowestLevel || !canQuadSplit)) //if sub-TUs are present
1028  {
1029    const UInt subTUDepth        = lowestTUDepth + 1;
1030    const UInt partIdxesPerSubTU = rTu.GetAbsPartIdxNumParts(compID) >> 1;
1031
1032    UInt combinedSubTUCBF = 0;
1033
1034    for (UInt subTU = 0; subTU < 2; subTU++)
1035    {
1036      UInt uiCbf = MAX_UINT;
1037      m_pcTDecBinIf->decodeBin(uiCbf, m_cCUQtCbfSCModel.get(0, contextSet, uiCtx) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(TComCodingStatisticsClassType(STATS__CABAC_BITS__QT_CBF, g_aucConvertToBit[rTu.getRect(compID).width]+2, compID)));
1038
1039      const UInt subTUAbsPartIdx = absPartIdx + (subTU * partIdxesPerSubTU);
1040      pcCU->setCbfPartRange((uiCbf << subTUDepth), compID, subTUAbsPartIdx, partIdxesPerSubTU);
1041      combinedSubTUCBF |= uiCbf;
1042
1043      DTRACE_CABAC_VL( g_nSymbolCounter++ )
1044      DTRACE_CABAC_T( "\tparseQtCbf()" )
1045      DTRACE_CABAC_T( "\tsub-TU=" )
1046      DTRACE_CABAC_V( subTU )
1047      DTRACE_CABAC_T( "\tsymbol=" )
1048      DTRACE_CABAC_V( uiCbf )
1049      DTRACE_CABAC_T( "\tctx=" )
1050      DTRACE_CABAC_V( uiCtx )
1051      DTRACE_CABAC_T( "\tetype=" )
1052      DTRACE_CABAC_V( compID )
1053      DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1054      DTRACE_CABAC_V( subTUAbsPartIdx )
1055      DTRACE_CABAC_T( "\n" )
1056    }
1057
1058    //propagate the sub-TU CBF up to the lowest TU level
1059    if (combinedSubTUCBF != 0)
1060    {
1061      pcCU->bitwiseOrCbfPartRange((combinedSubTUCBF << lowestTUDepth), compID, absPartIdx, coveredPartIdxes);
1062      lowestTUCBF = combinedSubTUCBF;
1063    }
1064  }
1065  else
1066  {
1067    UInt uiCbf = MAX_UINT;
1068    m_pcTDecBinIf->decodeBin(uiCbf, m_cCUQtCbfSCModel.get(0, contextSet, uiCtx) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(TComCodingStatisticsClassType(STATS__CABAC_BITS__QT_CBF, g_aucConvertToBit[rTu.getRect(compID).width]+2, compID)));
1069
1070    pcCU->setCbfSubParts((uiCbf << lowestTUDepth), compID, absPartIdx, rTu.GetTransformDepthTotalAdj(compID));
1071
1072    DTRACE_CABAC_VL( g_nSymbolCounter++ )
1073    DTRACE_CABAC_T( "\tparseQtCbf()" )
1074    DTRACE_CABAC_T( "\tsymbol=" )
1075    DTRACE_CABAC_V( uiCbf )
1076    DTRACE_CABAC_T( "\tctx=" )
1077    DTRACE_CABAC_V( uiCtx )
1078    DTRACE_CABAC_T( "\tetype=" )
1079    DTRACE_CABAC_V( compID )
1080    DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1081    DTRACE_CABAC_V( rTu.GetAbsPartIdxTU(compID) )
1082    DTRACE_CABAC_T( "\n" )
1083
1084    lowestTUCBF = uiCbf;
1085  }
1086
1087  //propagate the lowest level CBF up to the current level
1088  if (lowestTUCBF != 0)
1089  {
1090    for (UInt depth = TUDepth; depth < lowestTUDepth; depth++)
1091    {
1092      pcCU->bitwiseOrCbfPartRange((lowestTUCBF << depth), compID, absPartIdx, coveredPartIdxes);
1093    }
1094  }
1095}
1096
1097
1098Void TDecSbac::parseTransformSkipFlags (TComTU &rTu, ComponentID component)
1099{
1100  TComDataCU* pcCU=rTu.getCU();
1101  UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU(component);
1102
1103  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1104  {
1105    return;
1106  }
1107
1108  if (!TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(component), pcCU->getSlice()->getPPS()->getTransformSkipLog2MaxSize()))
1109  {
1110    return;
1111  }
1112
1113  UInt useTransformSkip;
1114
1115  m_pcTDecBinIf->decodeBin( useTransformSkip , m_cTransformSkipSCModel.get( 0, toChannelType(component), 0 )
1116      RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(TComCodingStatisticsClassType(STATS__CABAC_BITS__TRANSFORM_SKIP_FLAGS, component))
1117                          );
1118
1119  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1120  DTRACE_CABAC_T("\tparseTransformSkip()");
1121  DTRACE_CABAC_T( "\tsymbol=" )
1122  DTRACE_CABAC_V( useTransformSkip )
1123  DTRACE_CABAC_T( "\tAddr=" )
1124  DTRACE_CABAC_V( pcCU->getCtuRsAddr() )
1125  DTRACE_CABAC_T( "\tetype=" )
1126  DTRACE_CABAC_V( component )
1127  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1128  DTRACE_CABAC_V( rTu.GetAbsPartIdxTU() )
1129  DTRACE_CABAC_T( "\n" )
1130
1131  pcCU->setTransformSkipPartRange( useTransformSkip, component, uiAbsPartIdx, rTu.GetAbsPartIdxNumParts(component));
1132}
1133
1134
1135/** Parse (X,Y) position of the last significant coefficient
1136 * \param uiPosLastX reference to X component of last coefficient
1137 * \param uiPosLastY reference to Y component of last coefficient
1138 * \param width  Block width
1139 * \param height Block height
1140 * \param eTType plane type / luminance or chrominance
1141 * \param uiScanIdx scan type (zig-zag, hor, ver)
1142 *
1143 * This method decodes the X and Y component within a block of the last significant coefficient.
1144 */
1145Void TDecSbac::parseLastSignificantXY( UInt& uiPosLastX, UInt& uiPosLastY, Int width, Int height, ComponentID component, UInt uiScanIdx )
1146{
1147  UInt uiLast;
1148
1149  ContextModel *pCtxX = m_cCuCtxLastX.get( 0, toChannelType(component) );
1150  ContextModel *pCtxY = m_cCuCtxLastY.get( 0, toChannelType(component) );
1151
1152#if RExt__DECODER_DEBUG_BIT_STATISTICS
1153  TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__LAST_SIG_X_Y, g_aucConvertToBit[width]+2, component);
1154#endif
1155
1156
1157  if ( uiScanIdx == SCAN_VER )
1158  {
1159    swap( width, height );
1160  }
1161
1162  Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
1163  getLastSignificantContextParameters(component, width, height, blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY);
1164
1165  //------------------
1166
1167  // posX
1168
1169  for( uiPosLastX = 0; uiPosLastX < g_uiGroupIdx[ width - 1 ]; uiPosLastX++ )
1170  {
1171    m_pcTDecBinIf->decodeBin( uiLast, *( pCtxX + blkSizeOffsetX + (uiPosLastX >>shiftX) ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1172
1173    if( !uiLast )
1174    {
1175      break;
1176    }
1177  }
1178
1179  // posY
1180
1181  for( uiPosLastY = 0; uiPosLastY < g_uiGroupIdx[ height - 1 ]; uiPosLastY++ )
1182  {
1183    m_pcTDecBinIf->decodeBin( uiLast, *( pCtxY + blkSizeOffsetY + (uiPosLastY >>shiftY)) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1184
1185    if( !uiLast )
1186    {
1187      break;
1188    }
1189  }
1190
1191  // EP-coded part
1192
1193  if ( uiPosLastX > 3 )
1194  {
1195    UInt uiTemp  = 0;
1196    UInt uiCount = ( uiPosLastX - 2 ) >> 1;
1197    for ( Int i = uiCount - 1; i >= 0; i-- )
1198    {
1199      m_pcTDecBinIf->decodeBinEP( uiLast RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1200      uiTemp += uiLast << i;
1201    }
1202    uiPosLastX = g_uiMinInGroup[ uiPosLastX ] + uiTemp;
1203  }
1204  if ( uiPosLastY > 3 )
1205  {
1206    UInt uiTemp  = 0;
1207    UInt uiCount = ( uiPosLastY - 2 ) >> 1;
1208    for ( Int i = uiCount - 1; i >= 0; i-- )
1209    {
1210      m_pcTDecBinIf->decodeBinEP( uiLast RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1211      uiTemp += uiLast << i;
1212    }
1213    uiPosLastY = g_uiMinInGroup[ uiPosLastY ] + uiTemp;
1214  }
1215
1216  if( uiScanIdx == SCAN_VER )
1217  {
1218    swap( uiPosLastX, uiPosLastY );
1219  }
1220}
1221
1222Void TDecSbac::parseCoeffNxN(  TComTU &rTu, ComponentID compID )
1223{
1224  TComDataCU* pcCU=rTu.getCU();
1225  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU(compID);
1226  const TComRectangle &rRect=rTu.getRect(compID);
1227  const UInt uiWidth=rRect.width;
1228  const UInt uiHeight=rRect.height;
1229  TCoeff* pcCoef=(pcCU->getCoeff(compID)+rTu.getCoefficientOffset(compID));
1230
1231  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1232  DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
1233  DTRACE_CABAC_V( compID )
1234  DTRACE_CABAC_T( "\twidth=" )
1235  DTRACE_CABAC_V( uiWidth )
1236  DTRACE_CABAC_T( "\theight=" )
1237  DTRACE_CABAC_V( uiHeight )
1238  DTRACE_CABAC_T( "\tdepth=" )
1239//  DTRACE_CABAC_V( rTu.GetTransformDepthTotalAdj(compID) )
1240  DTRACE_CABAC_V( rTu.GetTransformDepthTotal() )
1241  DTRACE_CABAC_T( "\tabspartidx=" )
1242//  DTRACE_CABAC_V( uiAbsPartIdx )
1243  DTRACE_CABAC_V( rTu.GetAbsPartIdxTU(compID) )
1244  DTRACE_CABAC_T( "\ttoCU-X=" )
1245  DTRACE_CABAC_V( pcCU->getCUPelX() )
1246  DTRACE_CABAC_T( "\ttoCU-Y=" )
1247  DTRACE_CABAC_V( pcCU->getCUPelY() )
1248  DTRACE_CABAC_T( "\tCU-addr=" )
1249  DTRACE_CABAC_V(  pcCU->getCtuRsAddr() )
1250  DTRACE_CABAC_T( "\tinCU-X=" )
1251//  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1252  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
1253  DTRACE_CABAC_T( "\tinCU-Y=" )
1254// DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1255  DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
1256  DTRACE_CABAC_T( "\tpredmode=" )
1257  DTRACE_CABAC_V(  pcCU->getPredictionMode( uiAbsPartIdx ) )
1258  DTRACE_CABAC_T( "\n" )
1259
1260  //--------------------------------------------------------------------------------------------------
1261
1262  if( uiWidth > pcCU->getSlice()->getSPS()->getMaxTrSize() )
1263  {
1264    std::cerr << "ERROR: parseCoeffNxN was passed a TU with dimensions larger than the maximum allowed size" << std::endl;
1265    assert(false);
1266    exit(1);
1267  }
1268
1269  //--------------------------------------------------------------------------------------------------
1270
1271  //set parameters
1272
1273  const ChannelType  chType            = toChannelType(compID);
1274  const UInt         uiLog2BlockWidth  = g_aucConvertToBit[ uiWidth  ] + 2;
1275  const UInt         uiLog2BlockHeight = g_aucConvertToBit[ uiHeight ] + 2;
1276  const UInt         uiMaxNumCoeff     = uiWidth * uiHeight;
1277  const UInt         uiMaxNumCoeffM1   = uiMaxNumCoeff - 1;
1278
1279  const ChannelType  channelType       = toChannelType(compID);
1280  const Bool         extendedPrecision = pcCU->getSlice()->getSPS()->getUseExtendedPrecision();
1281
1282  const Bool         alignCABACBeforeBypass = pcCU->getSlice()->getSPS()->getAlignCABACBeforeBypass();
1283
1284#if RExt__DECODER_DEBUG_BIT_STATISTICS
1285  TComCodingStatisticsClassType ctype_group(STATS__CABAC_BITS__SIG_COEFF_GROUP_FLAG, uiLog2BlockWidth, compID);
1286  TComCodingStatisticsClassType ctype_map(STATS__CABAC_BITS__SIG_COEFF_MAP_FLAG, uiLog2BlockWidth, compID);
1287  TComCodingStatisticsClassType ctype_gt1(STATS__CABAC_BITS__GT1_FLAG, uiLog2BlockWidth, compID);
1288  TComCodingStatisticsClassType ctype_gt2(STATS__CABAC_BITS__GT2_FLAG, uiLog2BlockWidth, compID);
1289#endif
1290
1291  Bool beValid;
1292  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1293  {
1294    beValid = false;
1295    if((!pcCU->isIntra(uiAbsPartIdx)) && pcCU->isRDPCMEnabled(uiAbsPartIdx))
1296    {
1297      parseExplicitRdpcmMode(rTu, compID);
1298    }
1299  }
1300  else
1301  {
1302    beValid = pcCU->getSlice()->getPPS()->getSignHideFlag();
1303  }
1304
1305  UInt absSum = 0;
1306
1307  //--------------------------------------------------------------------------------------------------
1308
1309  if(pcCU->getSlice()->getPPS()->getUseTransformSkip())
1310  {
1311    parseTransformSkipFlags(rTu, compID);
1312    //  This TU has coefficients and is transform skipped. Check whether is inter coded and if yes decode the explicit RDPCM mode
1313    if(pcCU->getTransformSkip(uiAbsPartIdx, compID) && (!pcCU->isIntra(uiAbsPartIdx)) && pcCU->isRDPCMEnabled(uiAbsPartIdx) )
1314    {
1315      parseExplicitRdpcmMode(rTu, compID);
1316      if(pcCU->getExplicitRdpcmMode(compID, uiAbsPartIdx) != RDPCM_OFF)
1317      {
1318        //  Sign data hiding is avoided for horizontal and vertical RDPCM modes
1319        beValid = false;
1320      }
1321    }
1322  }
1323
1324  Int uiIntraMode = -1;
1325  const Bool       bIsLuma = isLuma(compID);
1326  Int isIntra = pcCU->isIntra(uiAbsPartIdx) ? 1 : 0;
1327  if ( isIntra && pcCU->isRDPCMEnabled(uiAbsPartIdx) )
1328  {
1329    uiIntraMode = pcCU->getIntraDir( toChannelType(compID), uiAbsPartIdx );
1330    uiIntraMode = (uiIntraMode==DM_CHROMA_IDX && !bIsLuma) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, rTu.GetChromaFormat())) : uiIntraMode;
1331    uiIntraMode = ((rTu.GetChromaFormat() == CHROMA_422) && !bIsLuma) ? g_chroma422IntraAngleMappingTable[uiIntraMode] : uiIntraMode;
1332
1333    Bool transformSkip = pcCU->getTransformSkip( uiAbsPartIdx,compID);
1334    Bool rdpcm_lossy = ( transformSkip /*&& isIntra*/ && ( (uiIntraMode == HOR_IDX) || (uiIntraMode == VER_IDX) ) );
1335    if ( rdpcm_lossy )
1336    {
1337      beValid = false;
1338    }
1339  }
1340
1341  //--------------------------------------------------------------------------------------------------
1342
1343  const Bool  bUseGolombRiceParameterAdaptation = pcCU->getSlice()->getSPS()->getUseGolombRiceParameterAdaptation();
1344        UInt &currentGolombRiceStatistic        = m_golombRiceAdaptationStatistics[rTu.getGolombRiceStatisticsIndex(compID)];
1345
1346  //select scans
1347  TUEntropyCodingParameters codingParameters;
1348  getTUEntropyCodingParameters(codingParameters, rTu, compID);
1349
1350  //===== decode last significant =====
1351  UInt uiPosLastX, uiPosLastY;
1352  parseLastSignificantXY( uiPosLastX, uiPosLastY, uiWidth, uiHeight, compID, codingParameters.scanType );
1353  UInt uiBlkPosLast      = uiPosLastX + (uiPosLastY<<uiLog2BlockWidth);
1354  pcCoef[ uiBlkPosLast ] = 1;
1355
1356  //===== decode significance flags =====
1357  UInt uiScanPosLast;
1358  for( uiScanPosLast = 0; uiScanPosLast < uiMaxNumCoeffM1; uiScanPosLast++ )
1359  {
1360    UInt uiBlkPos = codingParameters.scan[ uiScanPosLast ];
1361    if( uiBlkPosLast == uiBlkPos )
1362    {
1363      break;
1364    }
1365  }
1366
1367  ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, isChroma(chType) );
1368  ContextModel * const baseCtx = m_cCUSigSCModel.get( 0, 0 ) + getSignificanceMapContextOffset(compID);
1369
1370  const Int  iLastScanSet  = uiScanPosLast >> MLS_CG_SIZE;
1371  UInt c1                  = 1;
1372  UInt uiGoRiceParam       = 0;
1373
1374
1375  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
1376  memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
1377
1378  Int  iScanPosSig             = (Int) uiScanPosLast;
1379  for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
1380  {
1381    Int  iSubPos   = iSubSet << MLS_CG_SIZE;
1382    uiGoRiceParam  = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
1383    Bool updateGolombRiceStatistics = bUseGolombRiceParameterAdaptation; //leave the statistics at 0 when not using the adaptation system
1384    Int numNonZero = 0;
1385
1386    Int lastNZPosInCG  = -1;
1387    Int firstNZPosInCG = 1 << MLS_CG_SIZE;
1388
1389    Bool escapeDataPresentInGroup = false;
1390
1391    Int pos[1 << MLS_CG_SIZE];
1392
1393    if( iScanPosSig == (Int) uiScanPosLast )
1394    {
1395      lastNZPosInCG  = iScanPosSig;
1396      firstNZPosInCG = iScanPosSig;
1397      iScanPosSig--;
1398      pos[ numNonZero ] = uiBlkPosLast;
1399      numNonZero = 1;
1400    }
1401
1402    // decode significant_coeffgroup_flag
1403    Int iCGBlkPos = codingParameters.scanCG[ iSubSet ];
1404    Int iCGPosY   = iCGBlkPos / codingParameters.widthInGroups;
1405    Int iCGPosX   = iCGBlkPos - (iCGPosY * codingParameters.widthInGroups);
1406
1407    if( iSubSet == iLastScanSet || iSubSet == 0)
1408    {
1409      uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
1410    }
1411    else
1412    {
1413      UInt uiSigCoeffGroup;
1414      UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups );
1415      m_pcTDecBinIf->decodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_group) );
1416      uiSigCoeffGroupFlag[ iCGBlkPos ] = uiSigCoeffGroup;
1417    }
1418
1419    // decode significant_coeff_flag
1420    const Int patternSigCtx = TComTrQuant::calcPatternSigCtx(uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups);
1421
1422    UInt uiBlkPos, uiSig, uiCtxSig;
1423    for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
1424    {
1425      uiBlkPos  = codingParameters.scan[ iScanPosSig ];
1426      uiSig     = 0;
1427
1428      if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
1429      {
1430        if( iScanPosSig > iSubPos || iSubSet == 0  || numNonZero )
1431        {
1432          uiCtxSig  = TComTrQuant::getSigCtxInc( patternSigCtx, codingParameters, iScanPosSig, uiLog2BlockWidth, uiLog2BlockHeight, chType );
1433          m_pcTDecBinIf->decodeBin( uiSig, baseCtx[ uiCtxSig ] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_map) );
1434        }
1435        else
1436        {
1437          uiSig = 1;
1438        }
1439      }
1440      pcCoef[ uiBlkPos ] = uiSig;
1441      if( uiSig )
1442      {
1443        pos[ numNonZero ] = uiBlkPos;
1444        numNonZero ++;
1445        if( lastNZPosInCG == -1 )
1446        {
1447          lastNZPosInCG = iScanPosSig;
1448        }
1449        firstNZPosInCG = iScanPosSig;
1450      }
1451    }
1452
1453    if( numNonZero > 0 )
1454    {
1455      Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= SBH_THRESHOLD );
1456
1457      absSum = 0;
1458
1459      const UInt uiCtxSet = getContextSetIndex(compID, iSubSet, (c1 == 0));
1460      c1 = 1;
1461      UInt uiBin;
1462
1463      ContextModel *baseCtxMod = m_cCUOneSCModel.get( 0, 0 ) + (NUM_ONE_FLAG_CTX_PER_SET * uiCtxSet);
1464
1465      Int absCoeff[1 << MLS_CG_SIZE];
1466
1467      for ( Int i = 0; i < numNonZero; i++)
1468      {
1469        absCoeff[i] = 1;
1470      }
1471      Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
1472      Int firstC2FlagIdx = -1;
1473
1474      for( Int idx = 0; idx < numC1Flag; idx++ )
1475      {
1476        m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[c1] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_gt1) );
1477        if( uiBin == 1 )
1478        {
1479          c1 = 0;
1480          if (firstC2FlagIdx == -1)
1481          {
1482            firstC2FlagIdx = idx;
1483          }
1484          else //if a greater-than-one has been encountered already this group
1485          {
1486            escapeDataPresentInGroup = true;
1487          }
1488        }
1489        else if( (c1 < 3) && (c1 > 0) )
1490        {
1491          c1++;
1492        }
1493        absCoeff[ idx ] = uiBin + 1;
1494      }
1495
1496      if (c1 == 0)
1497      {
1498        baseCtxMod = m_cCUAbsSCModel.get( 0, 0 ) + (NUM_ABS_FLAG_CTX_PER_SET * uiCtxSet);
1499        if ( firstC2FlagIdx != -1)
1500        {
1501          m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[0] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_gt2) );
1502          absCoeff[ firstC2FlagIdx ] = uiBin + 2;
1503          if (uiBin != 0)
1504          {
1505            escapeDataPresentInGroup = true;
1506          }
1507        }
1508      }
1509
1510      escapeDataPresentInGroup = escapeDataPresentInGroup || (numNonZero > C1FLAG_NUMBER);
1511
1512      const Bool alignGroup = escapeDataPresentInGroup && alignCABACBeforeBypass;
1513
1514#if RExt__DECODER_DEBUG_BIT_STATISTICS
1515      TComCodingStatisticsClassType ctype_signs((alignGroup ? STATS__CABAC_BITS__ALIGNED_SIGN_BIT    : STATS__CABAC_BITS__SIGN_BIT   ), uiLog2BlockWidth, compID);
1516      TComCodingStatisticsClassType ctype_escs ((alignGroup ? STATS__CABAC_BITS__ALIGNED_ESCAPE_BITS : STATS__CABAC_BITS__ESCAPE_BITS), uiLog2BlockWidth, compID);
1517#endif
1518
1519      if (alignGroup)
1520      {
1521        m_pcTDecBinIf->align();
1522      }
1523
1524      UInt coeffSigns;
1525      if ( signHidden && beValid )
1526      {
1527        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero-1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_signs) );
1528        coeffSigns <<= 32 - (numNonZero-1);
1529      }
1530      else
1531      {
1532        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_signs) );
1533        coeffSigns <<= 32 - numNonZero;
1534      }
1535
1536      Int iFirstCoeff2 = 1;
1537      if (escapeDataPresentInGroup)
1538      {
1539        for( Int idx = 0; idx < numNonZero; idx++ )
1540        {
1541          UInt baseLevel  = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2) : 1;
1542
1543          if( absCoeff[ idx ] == baseLevel)
1544          {
1545            UInt uiLevel;
1546            xReadCoefRemainExGolomb( uiLevel, uiGoRiceParam, extendedPrecision, channelType RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_escs) );
1547
1548            absCoeff[ idx ] = uiLevel + baseLevel;
1549
1550            if (absCoeff[idx] > (3 << uiGoRiceParam))
1551            {
1552              uiGoRiceParam = bUseGolombRiceParameterAdaptation ? (uiGoRiceParam + 1) : (std::min<UInt>((uiGoRiceParam + 1), 4));
1553            }
1554
1555            if (updateGolombRiceStatistics)
1556            {
1557              const UInt initialGolombRiceParameter = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
1558
1559              if (uiLevel >= (3 << initialGolombRiceParameter))
1560              {
1561                currentGolombRiceStatistic++;
1562              }
1563              else if (((uiLevel * 2) < (1 << initialGolombRiceParameter)) && (currentGolombRiceStatistic > 0))
1564              {
1565                currentGolombRiceStatistic--;
1566              }
1567
1568              updateGolombRiceStatistics = false;
1569            }
1570          }
1571
1572          if(absCoeff[ idx ] >= 2)
1573          {
1574            iFirstCoeff2 = 0;
1575          }
1576        }
1577      }
1578
1579      for( Int idx = 0; idx < numNonZero; idx++ )
1580      {
1581        Int blkPos = pos[ idx ];
1582        // Signs applied later.
1583        pcCoef[ blkPos ] = absCoeff[ idx ];
1584        absSum += absCoeff[ idx ];
1585
1586        if ( idx == numNonZero-1 && signHidden && beValid )
1587        {
1588          // Infer sign of 1st element.
1589          if (absSum&0x1)
1590          {
1591            pcCoef[ blkPos ] = -pcCoef[ blkPos ];
1592          }
1593        }
1594        else
1595        {
1596          Int sign = static_cast<Int>( coeffSigns ) >> 31;
1597          pcCoef[ blkPos ] = ( pcCoef[ blkPos ] ^ sign ) - sign;
1598          coeffSigns <<= 1;
1599        }
1600      }
1601    }
1602  }
1603
1604#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
1605  printSBACCoeffData(uiPosLastX, uiPosLastY, uiWidth, uiHeight, compID, uiAbsPartIdx, codingParameters.scanType, pcCoef);
1606#endif
1607
1608  return;
1609}
1610
1611Void TDecSbac::parseSaoMaxUvlc ( UInt& val, UInt maxSymbol )
1612{
1613  if (maxSymbol == 0)
1614  {
1615    val = 0;
1616    return;
1617  }
1618
1619  UInt code;
1620  Int  i;
1621  m_pcTDecBinIf->decodeBinEP( code RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
1622  if ( code == 0 )
1623  {
1624    val = 0;
1625    return;
1626  }
1627
1628  i=1;
1629  while (1)
1630  {
1631    m_pcTDecBinIf->decodeBinEP( code RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
1632    if ( code == 0 )
1633    {
1634      break;
1635    }
1636    i++;
1637    if (i == maxSymbol)
1638    {
1639      break;
1640    }
1641  }
1642
1643  val = i;
1644}
1645
1646Void TDecSbac::parseSaoUflc (UInt uiLength, UInt&  riVal)
1647{
1648  m_pcTDecBinIf->decodeBinsEP ( riVal, uiLength RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
1649}
1650
1651Void TDecSbac::parseSaoMerge (UInt&  ruiVal)
1652{
1653  UInt uiCode;
1654  m_pcTDecBinIf->decodeBin( uiCode, m_cSaoMergeSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
1655  ruiVal = (Int)uiCode;
1656}
1657
1658Void TDecSbac::parseSaoTypeIdx (UInt&  ruiVal)
1659{
1660  UInt uiCode;
1661  m_pcTDecBinIf->decodeBin( uiCode, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
1662  if (uiCode == 0)
1663  {
1664    ruiVal = 0;
1665  }
1666  else
1667  {
1668    m_pcTDecBinIf->decodeBinEP( uiCode RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
1669    if (uiCode == 0)
1670    {
1671      ruiVal = 1;
1672    }
1673    else
1674    {
1675      ruiVal = 2;
1676    }
1677  }
1678}
1679
1680Void TDecSbac::parseSaoSign(UInt& val)
1681{
1682  m_pcTDecBinIf->decodeBinEP ( val RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
1683}
1684
1685Void TDecSbac::parseSAOBlkParam (SAOBlkParam& saoBlkParam
1686#if SVC_EXTENSION
1687                                , UInt* saoMaxOffsetQVal
1688#endif
1689                                , Bool* sliceEnabled
1690                                , Bool leftMergeAvail
1691                                , Bool aboveMergeAvail
1692                                )
1693{
1694  UInt uiSymbol;
1695
1696  Bool isLeftMerge = false;
1697  Bool isAboveMerge= false;
1698
1699  if(leftMergeAvail)
1700  {
1701    parseSaoMerge(uiSymbol); //sao_merge_left_flag
1702    isLeftMerge = (uiSymbol?true:false);
1703  }
1704
1705  if( aboveMergeAvail && !isLeftMerge)
1706  {
1707    parseSaoMerge(uiSymbol); //sao_merge_up_flag
1708    isAboveMerge = (uiSymbol?true:false);
1709  }
1710
1711  if(isLeftMerge || isAboveMerge) //merge mode
1712  {
1713    for (UInt componentIndex = 0; componentIndex < MAX_NUM_COMPONENT; componentIndex++)
1714    {
1715      saoBlkParam[componentIndex].modeIdc = (sliceEnabled[componentIndex]) ? SAO_MODE_MERGE : SAO_MODE_OFF;
1716      saoBlkParam[componentIndex].typeIdc = (isLeftMerge)?SAO_MERGE_LEFT:SAO_MERGE_ABOVE;
1717    }
1718  }
1719  else //new or off mode
1720  {
1721    for(Int compId=COMPONENT_Y; compId < MAX_NUM_COMPONENT; compId++)
1722    {
1723      const ComponentID compIdx=ComponentID(compId);
1724      const ComponentID firstCompOfChType = getFirstComponentOfChannel(toChannelType(compIdx));
1725      SAOOffset& ctbParam = saoBlkParam[compIdx];
1726
1727      if(!sliceEnabled[compIdx])
1728      {
1729        //off
1730        ctbParam.modeIdc = SAO_MODE_OFF;
1731        continue;
1732      }
1733
1734      //type
1735      if(compIdx == firstCompOfChType)
1736      {
1737        parseSaoTypeIdx(uiSymbol); //sao_type_idx_luma or sao_type_idx_chroma
1738
1739        assert(uiSymbol ==0 || uiSymbol ==1 || uiSymbol ==2);
1740
1741        if(uiSymbol ==0) //OFF
1742        {
1743          ctbParam.modeIdc = SAO_MODE_OFF;
1744        }
1745        else if(uiSymbol == 1) //BO
1746        {
1747          ctbParam.modeIdc = SAO_MODE_NEW;
1748          ctbParam.typeIdc = SAO_TYPE_START_BO;
1749        }
1750        else //2, EO
1751        {
1752          ctbParam.modeIdc = SAO_MODE_NEW;
1753          ctbParam.typeIdc = SAO_TYPE_START_EO;
1754        }
1755
1756      }
1757      else //Cr, follow Cb SAO type
1758      {
1759        ctbParam.modeIdc = saoBlkParam[COMPONENT_Cb].modeIdc;
1760        ctbParam.typeIdc = saoBlkParam[COMPONENT_Cb].typeIdc;
1761      }
1762
1763      if(ctbParam.modeIdc == SAO_MODE_NEW)
1764      {
1765#if O0043_BEST_EFFORT_DECODING
1766        Int bitDepthOrig = g_bitDepthInStream[toChannelType(compIdx)];
1767        Int forceBitDepthAdjust = bitDepthOrig - g_bitDepth[toChannelType(compIdx)];
1768#endif
1769        Int offset[4];
1770        for(Int i=0; i< 4; i++)
1771        {
1772#if SVC_EXTENSION
1773          parseSaoMaxUvlc(uiSymbol,  saoMaxOffsetQVal[compIdx] ); //sao_offset_abs
1774#else
1775#if O0043_BEST_EFFORT_DECODING
1776          Int saoMaxOffsetQVal = (1<<(min(bitDepthOrig, MAX_SAO_TRUNCATED_BITDEPTH)-5))-1;
1777          parseSaoMaxUvlc(uiSymbol, saoMaxOffsetQVal); //sao_offset_abs
1778#else
1779          parseSaoMaxUvlc(uiSymbol,  g_saoMaxOffsetQVal[compIdx] ); //sao_offset_abs
1780#endif
1781#endif
1782          offset[i] = (Int)uiSymbol;
1783        }
1784
1785        if(ctbParam.typeIdc == SAO_TYPE_START_BO)
1786        {
1787          for(Int i=0; i< 4; i++)
1788          {
1789            if(offset[i] != 0)
1790            {
1791              parseSaoSign(uiSymbol); //sao_offset_sign
1792              if(uiSymbol)
1793              {
1794#if O0043_BEST_EFFORT_DECODING
1795                offset[i] >>= forceBitDepthAdjust;
1796#endif
1797                offset[i] = -offset[i];
1798              }
1799            }
1800          }
1801          parseSaoUflc(NUM_SAO_BO_CLASSES_LOG2, uiSymbol ); //sao_band_position
1802          ctbParam.typeAuxInfo = uiSymbol;
1803
1804          for(Int i=0; i<4; i++)
1805          {
1806            ctbParam.offset[(ctbParam.typeAuxInfo+i)%MAX_NUM_SAO_CLASSES] = offset[i];
1807          }
1808
1809        }
1810        else //EO
1811        {
1812          ctbParam.typeAuxInfo = 0;
1813
1814          if(firstCompOfChType == compIdx)
1815          {
1816            parseSaoUflc(NUM_SAO_EO_TYPES_LOG2, uiSymbol ); //sao_eo_class_luma or sao_eo_class_chroma
1817            ctbParam.typeIdc += uiSymbol;
1818          }
1819          else
1820          {
1821            ctbParam.typeIdc = saoBlkParam[firstCompOfChType].typeIdc;
1822          }
1823          ctbParam.offset[SAO_CLASS_EO_FULL_VALLEY] = offset[0];
1824          ctbParam.offset[SAO_CLASS_EO_HALF_VALLEY] = offset[1];
1825          ctbParam.offset[SAO_CLASS_EO_PLAIN      ] = 0;
1826          ctbParam.offset[SAO_CLASS_EO_HALF_PEAK  ] = -offset[2];
1827          ctbParam.offset[SAO_CLASS_EO_FULL_PEAK  ] = -offset[3];
1828        }
1829      }
1830    }
1831  }
1832}
1833
1834/**
1835 - Initialize our contexts from the nominated source.
1836 .
1837 \param pSrc Contexts to be copied.
1838 */
1839Void TDecSbac::xCopyContextsFrom( const TDecSbac* pSrc )
1840{
1841  memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
1842  memcpy(m_golombRiceAdaptationStatistics, pSrc->m_golombRiceAdaptationStatistics, (sizeof(UInt) * RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS));
1843}
1844
1845Void TDecSbac::xCopyFrom( const TDecSbac* pSrc )
1846{
1847  m_pcTDecBinIf->copyState( pSrc->m_pcTDecBinIf );
1848  xCopyContextsFrom( pSrc );
1849}
1850
1851Void TDecSbac::load ( const TDecSbac* pSrc )
1852{
1853  xCopyFrom(pSrc);
1854}
1855
1856Void TDecSbac::loadContexts ( const TDecSbac* pSrc )
1857{
1858  xCopyContextsFrom(pSrc);
1859}
1860
1861/** Performs CABAC decoding of the explicit RDPCM mode
1862 * \param rTu current TU data structure
1863 * \param compID component identifier
1864 */
1865Void TDecSbac::parseExplicitRdpcmMode( TComTU &rTu, ComponentID compID )
1866{
1867  TComDataCU* cu = rTu.getCU();
1868  const UInt absPartIdx=rTu.GetAbsPartIdxTU(compID);
1869  const TComRectangle &rect = rTu.getRect(compID);
1870  const UInt tuHeight = g_aucConvertToBit[rect.height];
1871  const UInt tuWidth  = g_aucConvertToBit[rect.width];
1872  UInt code = 0;
1873
1874  assert(tuHeight == tuWidth);
1875
1876#if RExt__DECODER_DEBUG_BIT_STATISTICS
1877  const TComCodingStatisticsClassType ctype(STATS__EXPLICIT_RDPCM_BITS, g_aucConvertToBit[g_uiMaxCUWidth>>rTu.GetTransformDepthTotal()]+2);
1878#endif
1879
1880  m_pcTDecBinIf->decodeBin(code, m_explicitRdpcmFlagSCModel.get (0, toChannelType(compID), 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype));
1881
1882  if(code == 0)
1883  {
1884    cu->setExplicitRdpcmModePartRange( RDPCM_OFF, compID, absPartIdx, rTu.GetAbsPartIdxNumParts(compID));
1885  }
1886  else
1887  {
1888    m_pcTDecBinIf->decodeBin(code, m_explicitRdpcmDirSCModel.get (0, toChannelType(compID), 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype));
1889    if(code == 0)
1890    {
1891      cu->setExplicitRdpcmModePartRange( RDPCM_HOR, compID, absPartIdx, rTu.GetAbsPartIdxNumParts(compID));
1892    }
1893    else
1894    {
1895      cu->setExplicitRdpcmModePartRange( RDPCM_VER, compID, absPartIdx, rTu.GetAbsPartIdxNumParts(compID));
1896    }
1897  }
1898}
1899
1900
1901//! \}
Note: See TracBrowser for help on using the repository browser.