source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibDecoder/TDecCu.cpp

Last change on this file was 213, checked in by mitsubishi-htm, 12 years ago

A final release, as planned

  • Migrate to HTM 5.1
  • For VC project files, only VC9 file is updated
  • To be used as an additional anchor for CE1.h for 3rd JCTVC meeting at Geneva
  • Property svn:eol-style set to native
File size: 54.5 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2012, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TDecCu.cpp
35    \brief    CU decoder class
36*/
37
38#include "TDecCu.h"
39
40#if RWTH_SDC_DLT_B0036
41#define GetDepthValue2Idx(val)     (pcCU->getSlice()->getSPS()->depthValue2idx(val))
42#define GetIdx2DepthValue(val)     (pcCU->getSlice()->getSPS()->idx2DepthValue(val))
43#endif
44
45//! \ingroup TLibDecoder
46//! \{
47
48// ====================================================================================================================
49// Constructor / destructor / create / destroy
50// ====================================================================================================================
51
52TDecCu::TDecCu()
53{
54  m_ppcYuvResi = NULL;
55  m_ppcYuvReco = NULL;
56#if HHI_INTER_VIEW_RESIDUAL_PRED
57  m_ppcYuvResPred = NULL;
58#endif
59#if FORCE_REF_VSP
60  m_ppcYuvAvail   = NULL;
61  m_ppcYuvSynth   = NULL;
62#endif
63  m_ppcCU      = NULL;
64}
65
66TDecCu::~TDecCu()
67{
68}
69
70Void TDecCu::init( TDecEntropy* pcEntropyDecoder, TComTrQuant* pcTrQuant, TComPrediction* pcPrediction)
71{
72  m_pcEntropyDecoder  = pcEntropyDecoder;
73  m_pcTrQuant         = pcTrQuant;
74  m_pcPrediction      = pcPrediction;
75}
76
77/**
78 \param    uiMaxDepth    total number of allowable depth
79 \param    uiMaxWidth    largest CU width
80 \param    uiMaxHeight   largest CU height
81 */
82Void TDecCu::create( UInt uiMaxDepth, UInt uiMaxWidth, UInt uiMaxHeight )
83{
84  m_uiMaxDepth = uiMaxDepth+1;
85 
86  m_ppcYuvResi = new TComYuv*[m_uiMaxDepth-1];
87  m_ppcYuvReco = new TComYuv*[m_uiMaxDepth-1];
88#if HHI_INTER_VIEW_RESIDUAL_PRED
89  m_ppcYuvResPred = new TComYuv*   [m_uiMaxDepth-1];
90#endif
91#if FORCE_REF_VSP
92  m_ppcYuvAvail   = new TComYuv*    [m_uiMaxDepth-1];
93  m_ppcYuvSynth   = new TComYuv*    [m_uiMaxDepth-1];
94#endif
95  m_ppcCU      = new TComDataCU*[m_uiMaxDepth-1];
96 
97  UInt uiNumPartitions;
98  for ( UInt ui = 0; ui < m_uiMaxDepth-1; ui++ )
99  {
100    uiNumPartitions = 1<<( ( m_uiMaxDepth - ui - 1 )<<1 );
101    UInt uiWidth  = uiMaxWidth  >> ui;
102    UInt uiHeight = uiMaxHeight >> ui;
103   
104    m_ppcYuvResi[ui] = new TComYuv;    m_ppcYuvResi[ui]->create( uiWidth, uiHeight );
105    m_ppcYuvReco[ui] = new TComYuv;    m_ppcYuvReco[ui]->create( uiWidth, uiHeight );
106#if HHI_INTER_VIEW_RESIDUAL_PRED
107    m_ppcYuvResPred[ui] = new TComYuv;    m_ppcYuvResPred[ui]->create( uiWidth, uiHeight );
108#endif
109#if FORCE_REF_VSP
110    m_ppcYuvAvail  [ui] = new TComYuv;    m_ppcYuvAvail  [ui]->create( uiWidth, uiHeight );
111    m_ppcYuvSynth  [ui] = new TComYuv;    m_ppcYuvSynth  [ui]->create( uiWidth, uiHeight );
112#endif
113    m_ppcCU     [ui] = new TComDataCU; m_ppcCU     [ui]->create( uiNumPartitions, uiWidth, uiHeight, true, uiMaxWidth >> (m_uiMaxDepth - 1) );
114  }
115 
116  m_bDecodeDQP = false;
117
118  // initialize partition order.
119  UInt* piTmp = &g_auiZscanToRaster[0];
120  initZscanToRaster(m_uiMaxDepth, 1, 0, piTmp);
121  initRasterToZscan( uiMaxWidth, uiMaxHeight, m_uiMaxDepth );
122 
123  // initialize conversion matrix from partition index to pel
124  initRasterToPelXY( uiMaxWidth, uiMaxHeight, m_uiMaxDepth );
125  initMotionReferIdx ( uiMaxWidth, uiMaxHeight, m_uiMaxDepth );
126}
127
128Void TDecCu::destroy()
129{
130  for ( UInt ui = 0; ui < m_uiMaxDepth-1; ui++ )
131  {
132    m_ppcYuvResi[ui]->destroy(); delete m_ppcYuvResi[ui]; m_ppcYuvResi[ui] = NULL;
133    m_ppcYuvReco[ui]->destroy(); delete m_ppcYuvReco[ui]; m_ppcYuvReco[ui] = NULL;
134#if HHI_INTER_VIEW_RESIDUAL_PRED
135    m_ppcYuvResPred[ui]->destroy(); delete m_ppcYuvResPred[ui]; m_ppcYuvResPred[ui] = NULL;
136#endif
137#if FORCE_REF_VSP
138    m_ppcYuvAvail  [ui]->destroy(); delete m_ppcYuvAvail  [ui]; m_ppcYuvAvail  [ui] = NULL;
139    m_ppcYuvSynth  [ui]->destroy(); delete m_ppcYuvSynth  [ui]; m_ppcYuvSynth  [ui] = NULL;
140#endif
141    m_ppcCU     [ui]->destroy(); delete m_ppcCU     [ui]; m_ppcCU     [ui] = NULL;
142  }
143 
144  delete [] m_ppcYuvResi; m_ppcYuvResi = NULL;
145  delete [] m_ppcYuvReco; m_ppcYuvReco = NULL;
146#if HHI_INTER_VIEW_RESIDUAL_PRED
147  delete [] m_ppcYuvResPred; m_ppcYuvResPred = NULL;
148#endif
149#if FORCE_REF_VSP
150  delete [] m_ppcYuvAvail;   m_ppcYuvAvail   = NULL;
151  delete [] m_ppcYuvSynth;   m_ppcYuvSynth   = NULL;
152#endif
153  delete [] m_ppcCU     ; m_ppcCU      = NULL;
154}
155
156// ====================================================================================================================
157// Public member functions
158// ====================================================================================================================
159
160/** \param    pcCU        pointer of CU data
161 \param    ruiIsLast   last data?
162 */
163Void TDecCu::decodeCU( TComDataCU* pcCU, UInt& ruiIsLast )
164{
165  if ( pcCU->getSlice()->getPPS()->getUseDQP() )
166  {
167    setdQPFlag(true);
168  }
169
170#if BURST_IPCM
171  pcCU->setNumSucIPCM(0);
172#endif
173
174  // start from the top level CU
175  xDecodeCU( pcCU, 0, 0, ruiIsLast);
176}
177
178/** \param    pcCU        pointer of CU data
179 */
180Void TDecCu::decompressCU( TComDataCU* pcCU )
181{
182  xDecompressCU( pcCU, pcCU, 0,  0 );
183}
184
185// ====================================================================================================================
186// Protected member functions
187// ====================================================================================================================
188
189/**decode end-of-slice flag
190 * \param pcCU
191 * \param uiAbsPartIdx
192 * \param uiDepth
193 * \returns Bool
194 */
195Bool TDecCu::xDecodeSliceEnd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth) {
196  UInt uiIsLast;
197  TComPic* pcPic = pcCU->getPic();
198  TComSlice * pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
199  UInt uiCurNumParts    = pcPic->getNumPartInCU() >> (uiDepth<<1);
200  UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
201  UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
202  UInt uiGranularityWidth = g_uiMaxCUWidth>>(pcSlice->getPPS()->getSliceGranularity());
203  UInt uiPosX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
204  UInt uiPosY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
205
206#if HHI_MPI
207  const UInt uiCUWidth  = pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1 ? g_uiMaxCUWidth>>uiDepth  : pcCU->getWidth (uiAbsPartIdx);
208  const UInt uiCUHeight = pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1 ? g_uiMaxCUHeight>>uiDepth : pcCU->getHeight(uiAbsPartIdx);
209  if(((uiPosX+uiCUWidth)%uiGranularityWidth==0||(uiPosX+uiCUWidth==uiWidth))
210    &&((uiPosY+uiCUHeight)%uiGranularityWidth==0||(uiPosY+uiCUHeight==uiHeight)))
211#else
212  if(((uiPosX+pcCU->getWidth(uiAbsPartIdx))%uiGranularityWidth==0||(uiPosX+pcCU->getWidth(uiAbsPartIdx)==uiWidth))
213    &&((uiPosY+pcCU->getHeight(uiAbsPartIdx))%uiGranularityWidth==0||(uiPosY+pcCU->getHeight(uiAbsPartIdx)==uiHeight)))
214#endif
215  {
216    m_pcEntropyDecoder->decodeTerminatingBit( uiIsLast );
217  }
218  else
219  {
220    uiIsLast=0;
221  }
222 
223  if(uiIsLast) 
224  {
225    if(pcSlice->isNextEntropySlice()&&!pcSlice->isNextSlice()) 
226    {
227      pcSlice->setEntropySliceCurEndCUAddr(pcCU->getSCUAddr()+uiAbsPartIdx+uiCurNumParts);
228    }
229    else 
230    {
231      pcSlice->setSliceCurEndCUAddr(pcCU->getSCUAddr()+uiAbsPartIdx+uiCurNumParts);
232      pcSlice->setEntropySliceCurEndCUAddr(pcCU->getSCUAddr()+uiAbsPartIdx+uiCurNumParts);
233    }
234  }
235
236  return uiIsLast>0;
237}
238
239/** decode CU block recursively
240 * \param pcCU
241 * \param uiAbsPartIdx
242 * \param uiDepth
243 * \returns Void
244 */
245
246Void TDecCu::xDecodeCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt& ruiIsLast)
247{
248  TComPic* pcPic = pcCU->getPic();
249  UInt uiCurNumParts    = pcPic->getNumPartInCU() >> (uiDepth<<1);
250  UInt uiQNumParts      = uiCurNumParts>>2;
251 
252  Bool bBoundary = false;
253  UInt uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
254  UInt uiRPelX   = uiLPelX + (g_uiMaxCUWidth>>uiDepth)  - 1;
255  UInt uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
256  UInt uiBPelY   = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
257
258  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
259  Bool bStartInCU = pcCU->getSCUAddr()+uiAbsPartIdx+uiCurNumParts>pcSlice->getEntropySliceCurStartCUAddr()&&pcCU->getSCUAddr()+uiAbsPartIdx<pcSlice->getEntropySliceCurStartCUAddr();
260  if((!bStartInCU) && ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
261  {
262#if BURST_IPCM
263    if(pcCU->getNumSucIPCM() == 0)
264    {
265#if HHI_MPI
266      if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 || uiDepth < pcCU->getTextureModeDepth( uiAbsPartIdx ) )
267#endif
268      m_pcEntropyDecoder->decodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
269    }
270    else
271    {
272      pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
273    }
274#else
275#if HHI_MPI
276    if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 || uiDepth < pcCU->getTextureModeDepth( uiAbsPartIdx ) )
277#endif
278    m_pcEntropyDecoder->decodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
279#endif
280  }
281  else
282  {
283    bBoundary = true;
284  }
285 
286  if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth ) ) || bBoundary )
287  {
288    UInt uiIdx = uiAbsPartIdx;
289    if( (g_uiMaxCUWidth>>uiDepth) == pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
290    {
291      setdQPFlag(true);
292      pcCU->setQPSubParts( pcCU->getRefQP(uiAbsPartIdx), uiAbsPartIdx, uiDepth ); // set QP to default QP
293    }
294
295    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
296    {
297      uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiIdx] ];
298      uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiIdx] ];
299     
300      Bool bSubInSlice = pcCU->getSCUAddr()+uiIdx+uiQNumParts>pcSlice->getEntropySliceCurStartCUAddr();
301      if ( bSubInSlice )
302      {
303        if ( ( uiLPelX < pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() ) )
304        {
305          xDecodeCU( pcCU, uiIdx, uiDepth+1, ruiIsLast );
306        }
307        else
308        {
309          pcCU->setOutsideCUPart( uiIdx, uiDepth+1 );
310        }
311      }
312      if(ruiIsLast)
313      {
314        break;
315      }
316     
317      uiIdx += uiQNumParts;
318    }
319    if( (g_uiMaxCUWidth>>uiDepth) == pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
320    {
321      if ( getdQPFlag() )
322      {
323        UInt uiQPSrcPartIdx;
324        if ( pcPic->getCU( pcCU->getAddr() )->getEntropySliceStartCU(uiAbsPartIdx) != pcSlice->getEntropySliceCurStartCUAddr() )
325        {
326          uiQPSrcPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU();
327        }
328        else
329        {
330          uiQPSrcPartIdx = uiAbsPartIdx;
331        }
332        pcCU->setQPSubParts( pcCU->getRefQP( uiQPSrcPartIdx ), uiAbsPartIdx, uiDepth ); // set QP to default QP
333      }
334    }
335    return;
336  }
337 
338  if( (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
339  {
340    setdQPFlag(true);
341    pcCU->setQPSubParts( pcCU->getRefQP(uiAbsPartIdx), uiAbsPartIdx, uiDepth ); // set QP to default QP
342  }
343
344  // decode CU mode and the partition size
345#if BURST_IPCM
346  if( !pcCU->getSlice()->isIntra() && pcCU->getNumSucIPCM() == 0 )
347#else
348  if( !pcCU->getSlice()->isIntra() )
349#endif
350#if HHI_MPI
351  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
352#endif
353  {
354    m_pcEntropyDecoder->decodeSkipFlag( pcCU, uiAbsPartIdx, uiDepth );
355
356#if FORCE_REF_VSP==1
357    if( pcCU->isSkipped(uiAbsPartIdx) && pcCU->getSlice()->getViewId() != 0 )
358#if VSP_CFG
359    if( pcCU->getSlice()->getSPS()->getVspDepthPresentFlag() || !pcCU->getSlice()->getSPS()->isDepth() )
360#else
361    if( !pcCU->getSlice()->getVspDepthDisableFlag() || !pcCU->getSlice()->getSPS()->isDepth() )
362#endif
363    {
364      m_pcEntropyDecoder->decodeVspFlag( pcCU, uiAbsPartIdx, uiDepth );
365    }
366#endif
367  }
368 
369  if( pcCU->isSkipped(uiAbsPartIdx) )
370#if FORCE_REF_VSP==1
371  if( !pcCU->isVspMode(uiAbsPartIdx) )
372#endif
373  {
374    m_ppcCU[uiDepth]->copyInterPredInfoFrom( pcCU, uiAbsPartIdx, REF_PIC_LIST_0 );
375    m_ppcCU[uiDepth]->copyInterPredInfoFrom( pcCU, uiAbsPartIdx, REF_PIC_LIST_1 );
376#if HHI_INTER_VIEW_MOTION_PRED
377    TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
378    UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
379    Int numValidMergeCand = 0;
380    for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS_MEM; ++ui )
381#else
382    TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS << 1]; // double length for mv of both lists
383    UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
384    Int numValidMergeCand = 0;
385    for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ++ui )
386#endif
387    {
388      uhInterDirNeighbours[ui] = 0;
389    }
390    m_pcEntropyDecoder->decodeMergeIndex( pcCU, 0, uiAbsPartIdx, SIZE_2Nx2N, uhInterDirNeighbours, cMvFieldNeighbours, uiDepth );
391#if HHI_MPI
392    if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == uiDepth )
393    {
394      TComDataCU *pcTextureCU = pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() );
395      pcCU->copyTextureMotionDataFrom( pcTextureCU, uiDepth, pcCU->getZorderIdxInCU() + uiAbsPartIdx, uiAbsPartIdx );
396
397      UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
398      for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
399      {
400        const UChar uhNewDepth = max<UInt>( uiDepth, pcTextureCU->getDepth( uiAbsPartIdx + ui ) );
401        pcCU->setPredictionMode( uiAbsPartIdx + ui, MODE_SKIP );
402        pcCU->setPartitionSize( uiAbsPartIdx + ui, SIZE_2Nx2N );
403        pcCU->setDepth( uiAbsPartIdx + ui, uhNewDepth );
404        pcCU->setWidth( uiAbsPartIdx + ui, g_uiMaxCUWidth>>uhNewDepth );
405        pcCU->setHeight( uiAbsPartIdx + ui, g_uiMaxCUHeight>>uhNewDepth );
406      }
407    }
408    else
409    {
410#endif
411#if SIMP_MRG_PRUN     
412    UInt uiMergeIndex = pcCU->getMergeIndex(uiAbsPartIdx);
413    m_ppcCU[uiDepth]->getInterMergeCandidates( 0, 0, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
414#else
415    m_ppcCU[uiDepth]->getInterMergeCandidates( 0, 0, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
416    UInt uiMergeIndex = pcCU->getMergeIndex(uiAbsPartIdx);
417#endif
418    pcCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeIndex], uiAbsPartIdx, 0, uiDepth );
419
420    TComMv cTmpMv( 0, 0 );
421    for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
422    {       
423      if ( pcCU->getSlice()->getNumRefIdx( RefPicList( uiRefListIdx ) ) > 0 )
424      {
425        pcCU->setMVPIdxSubParts( 0, RefPicList( uiRefListIdx ), uiAbsPartIdx, 0, uiDepth);
426        pcCU->setMVPNumSubParts( 0, RefPicList( uiRefListIdx ), uiAbsPartIdx, 0, uiDepth);
427        pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->setAllMvd( cTmpMv, SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
428        pcCU->getCUMvField( RefPicList( uiRefListIdx ) )->setAllMvField( cMvFieldNeighbours[ 2*uiMergeIndex + uiRefListIdx ], SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
429      }
430    }
431#if LGE_ILLUCOMP_B0045
432    m_pcEntropyDecoder->decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
433#endif
434#if HHI_MPI
435    }
436#endif
437#if HHI_INTER_VIEW_RESIDUAL_PRED
438    m_pcEntropyDecoder->decodeResPredFlag( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth], 0 );
439#endif
440    xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
441    return;
442  }
443
444#if FORCE_REF_VSP==1
445  if( pcCU->isVspMode( uiAbsPartIdx ) )
446  {
447    TComMv cMvZero;
448
449    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
450    pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
451
452    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( TComMvField(), SIZE_2Nx2N, uiAbsPartIdx, uiDepth, 0 );
453    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( TComMvField(), SIZE_2Nx2N, uiAbsPartIdx, uiDepth, 0 );
454    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( cMvZero,       SIZE_2Nx2N, uiAbsPartIdx, uiDepth, 0 );
455    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( cMvZero,       SIZE_2Nx2N, uiAbsPartIdx, uiDepth, 0 );
456
457    //pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx ( pcCU->getSlice()->getRefIdxVsp(REF_PIC_LIST_0), SIZE_2Nx2N, 0, pcCU->getDepth(0), 0 );
458    //pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx ( pcCU->getSlice()->getRefIdxVsp(REF_PIC_LIST_1), SIZE_2Nx2N, 0, pcCU->getDepth(0), 0 );
459
460    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, uiAbsPartIdx, 0, uiDepth );
461    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, uiAbsPartIdx, 0, uiDepth );
462    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, uiAbsPartIdx, 0, uiDepth );
463    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, uiAbsPartIdx, 0, uiDepth );
464
465    pcCU->setCbfSubParts( 0, 0, 0, uiAbsPartIdx, uiDepth );
466    pcCU->setTrIdxSubParts( 0 , uiAbsPartIdx, uiDepth );
467    pcCU->setNSQTIdxSubParts( uiAbsPartIdx, uiDepth );
468
469    xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
470    return;
471  }
472#endif
473
474#if HHI_MPI
475  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
476  {
477#endif
478#if BURST_IPCM
479  if( pcCU->getNumSucIPCM() == 0 ) 
480  {
481    m_pcEntropyDecoder->decodePredMode( pcCU, uiAbsPartIdx, uiDepth );
482    m_pcEntropyDecoder->decodePartSize( pcCU, uiAbsPartIdx, uiDepth );
483  }
484  else
485  {
486    pcCU->setPredModeSubParts( MODE_INTRA, uiAbsPartIdx, uiDepth );
487    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
488    pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth ); 
489    pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
490  }
491#else
492  m_pcEntropyDecoder->decodePredMode( pcCU, uiAbsPartIdx, uiDepth );
493  m_pcEntropyDecoder->decodePartSize( pcCU, uiAbsPartIdx, uiDepth );
494#endif
495
496  if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
497  {
498    m_pcEntropyDecoder->decodeIPCMInfo( pcCU, uiAbsPartIdx, uiDepth );
499
500    if(pcCU->getIPCMFlag(uiAbsPartIdx))
501    {
502      xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
503      return;
504    }
505  }
506
507#if ! HHI_MPI
508  UInt uiCurrWidth      = pcCU->getWidth ( uiAbsPartIdx );
509  UInt uiCurrHeight     = pcCU->getHeight( uiAbsPartIdx );
510#endif
511 
512  // prediction mode ( Intra : direction mode, Inter : Mv, reference idx )
513  m_pcEntropyDecoder->decodePredInfo( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth]);
514 
515#if LGE_ILLUCOMP_B0045
516  m_pcEntropyDecoder->decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
517#endif
518
519#if HHI_INTER_VIEW_RESIDUAL_PRED
520  if( !pcCU->isIntra( uiAbsPartIdx ) )
521  {
522    m_pcEntropyDecoder->decodeResPredFlag    ( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth], 0 );
523  }
524#endif
525
526#if HHI_MPI
527    if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == uiDepth )
528    {
529      assert( pcCU->getZorderIdxInCU() == 0 );
530      TComDataCU *pcTextureCU = pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() );
531      pcCU->copyTextureMotionDataFrom( pcTextureCU, uiDepth, pcCU->getZorderIdxInCU() + uiAbsPartIdx, uiAbsPartIdx );
532
533      UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
534      for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
535      {
536        const UChar uhNewDepth = max<UInt>( uiDepth, pcTextureCU->getDepth( uiAbsPartIdx + ui ) );
537        pcCU->setPredictionMode( uiAbsPartIdx + ui, MODE_INTER );
538        pcCU->setPartitionSize( uiAbsPartIdx + ui, SIZE_2Nx2N );
539        pcCU->setDepth( uiAbsPartIdx + ui, uhNewDepth );
540        pcCU->setWidth( uiAbsPartIdx + ui, g_uiMaxCUWidth>>uhNewDepth );
541        pcCU->setHeight( uiAbsPartIdx + ui, g_uiMaxCUHeight>>uhNewDepth );
542      }
543
544      if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth ) ) || bBoundary )
545      {
546        UInt uiIdx = uiAbsPartIdx;
547        if( (g_uiMaxCUWidth>>uiDepth) == pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
548        {
549          setdQPFlag(true);
550          pcCU->setQPSubParts( pcCU->getRefQP(uiAbsPartIdx), uiAbsPartIdx, uiDepth ); // set QP to default QP
551        }
552
553        for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
554        {
555          uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiIdx] ];
556          uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiIdx] ];
557
558          Bool bSubInSlice = pcCU->getSCUAddr()+uiIdx+uiQNumParts>pcSlice->getEntropySliceCurStartCUAddr();
559          if ( bSubInSlice )
560          {
561            if ( ( uiLPelX < pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() ) )
562            {
563              xDecodeCU( pcCU, uiIdx, uiDepth+1, ruiIsLast );
564            }
565            else
566            {
567              pcCU->setOutsideCUPart( uiIdx, uiDepth+1 );
568            }
569          }
570          if(ruiIsLast)
571          {
572            break;
573          }
574          uiIdx += uiQNumParts;
575        }
576        if( (g_uiMaxCUWidth>>uiDepth) == pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
577        {
578          if ( getdQPFlag() )
579          {
580            UInt uiQPSrcPartIdx;
581            if ( pcPic->getCU( pcCU->getAddr() )->getEntropySliceStartCU(uiAbsPartIdx) != pcSlice->getEntropySliceCurStartCUAddr() )
582            {
583              uiQPSrcPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU();
584            }
585            else
586            {
587              uiQPSrcPartIdx = uiAbsPartIdx;
588            }
589            pcCU->setQPSubParts( pcCU->getRefQP( uiQPSrcPartIdx ), uiAbsPartIdx, uiDepth ); // set QP to default QP
590          }
591        }
592        return;
593      }
594    }
595  }
596
597  UInt uiCurrWidth      = pcCU->getWidth ( uiAbsPartIdx );
598  UInt uiCurrHeight     = pcCU->getHeight( uiAbsPartIdx );
599#endif
600
601  // Coefficient decoding
602  Bool bCodeDQP = getdQPFlag();
603  m_pcEntropyDecoder->decodeCoeff( pcCU, uiAbsPartIdx, uiDepth, uiCurrWidth, uiCurrHeight, bCodeDQP );
604  setdQPFlag( bCodeDQP );
605  xFinishDecodeCU( pcCU, uiAbsPartIdx, uiDepth, ruiIsLast );
606}
607
608Void TDecCu::xFinishDecodeCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt& ruiIsLast)
609{
610  if( (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
611  {
612    if( getdQPFlag() )
613    {
614      pcCU->setQPSubParts( pcCU->getRefQP(uiAbsPartIdx), uiAbsPartIdx, uiDepth ); // set QP to default QP
615    }
616  }
617
618#if BURST_IPCM
619  if( pcCU->getNumSucIPCM() > 0 )
620  {
621    ruiIsLast = 0;
622    return;
623  }
624#endif
625
626  ruiIsLast = xDecodeSliceEnd( pcCU, uiAbsPartIdx, uiDepth);
627}
628
629Void TDecCu::xDecompressCU( TComDataCU* pcCU, TComDataCU* pcCUCur, UInt uiAbsPartIdx,  UInt uiDepth )
630{
631  TComPic* pcPic = pcCU->getPic();
632#if FORCE_REF_VSP
633  if(pcPic->getPicYuvSynth())  m_ppcYuvSynth[uiDepth]->copyFromPicYuv( pcPic->getPicYuvSynth(), pcCU->getAddr(), uiAbsPartIdx );
634  if(pcPic->getPicYuvAvail())  m_ppcYuvAvail[uiDepth]->copyFromPicYuv( pcPic->getPicYuvAvail(), pcCU->getAddr(), uiAbsPartIdx );
635#endif
636 
637  Bool bBoundary = false;
638  UInt uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
639  UInt uiRPelX   = uiLPelX + (g_uiMaxCUWidth>>uiDepth)  - 1;
640  UInt uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
641  UInt uiBPelY   = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
642 
643  UInt uiCurNumParts    = pcPic->getNumPartInCU() >> (uiDepth<<1);
644  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
645  Bool bStartInCU = pcCU->getSCUAddr()+uiAbsPartIdx+uiCurNumParts>pcSlice->getEntropySliceCurStartCUAddr()&&pcCU->getSCUAddr()+uiAbsPartIdx<pcSlice->getEntropySliceCurStartCUAddr();
646  if(bStartInCU||( uiRPelX >= pcSlice->getSPS()->getPicWidthInLumaSamples() ) || ( uiBPelY >= pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
647  {
648    bBoundary = true;
649  }
650 
651  if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth ) ) || bBoundary )
652  {
653    UInt uiNextDepth = uiDepth + 1;
654    UInt uiQNumParts = pcCU->getTotalNumPart() >> (uiNextDepth<<1);
655    UInt uiIdx = uiAbsPartIdx;
656    for ( UInt uiPartIdx = 0; uiPartIdx < 4; uiPartIdx++ )
657    {
658      uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiIdx] ];
659      uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiIdx] ];
660     
661      Bool binSlice = (pcCU->getSCUAddr()+uiIdx+uiQNumParts>pcSlice->getEntropySliceCurStartCUAddr())&&(pcCU->getSCUAddr()+uiIdx<pcSlice->getEntropySliceCurEndCUAddr());
662      if(binSlice&&( uiLPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
663      {
664        xDecompressCU(pcCU, m_ppcCU[uiNextDepth], uiIdx, uiNextDepth );
665      }
666     
667      uiIdx += uiQNumParts;
668    }
669    return;
670  }
671 
672  // Residual reconstruction
673  m_ppcYuvResi[uiDepth]->clear();
674 
675  m_ppcCU[uiDepth]->copySubCU( pcCU, uiAbsPartIdx, uiDepth );
676 
677  switch( m_ppcCU[uiDepth]->getPredictionMode(0) )
678  {
679    case MODE_SKIP:
680    case MODE_INTER:
681      xReconInter( m_ppcCU[uiDepth], uiAbsPartIdx, uiDepth );
682      break;
683    case MODE_INTRA:
684#if RWTH_SDC_DLT_B0036
685      if( m_ppcCU[uiDepth]->getSDCFlag(0) )
686        xReconIntraSDC( m_ppcCU[uiDepth], 0, uiDepth );
687      else
688#endif
689      xReconIntraQT( m_ppcCU[uiDepth], uiAbsPartIdx, uiDepth );
690      break;
691#if FORCE_REF_VSP==1
692    case MODE_SYNTH:
693      m_ppcYuvReco[uiDepth]->copyFromPicYuv(pcPic->getPicYuvSynth(), pcCU->getAddr(), uiAbsPartIdx);
694      break;
695#endif
696    default:
697      assert(0);
698      break;
699  }
700#if LOSSLESS_CODING
701  if ( m_ppcCU[uiDepth]->isLosslessCoded(0) && (m_ppcCU[uiDepth]->getIPCMFlag(0) == false))
702  {
703    xFillPCMBuffer(m_ppcCU[uiDepth], uiAbsPartIdx, uiDepth);   
704  }
705#endif
706 
707  xCopyToPic( m_ppcCU[uiDepth], pcPic, uiAbsPartIdx, uiDepth );
708}
709
710Void TDecCu::xReconInter( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
711{
712#if HHI_MPI
713#if FIX_MPI_B0065
714  if( pcCU->getTextureModeDepth( 0 ) != -1 )
715  {
716    TComDataCU *pcTextureCU = pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() );
717    if( uiDepth == pcTextureCU->getDepth(uiAbsPartIdx))
718    {
719      PartSize partSize = pcTextureCU->getPartitionSize(uiAbsPartIdx);
720      pcCU->setPartSizeSubParts( partSize, 0, uiDepth );
721    }
722    else
723    {
724      pcCU->setPartSizeSubParts( SIZE_NxN, 0, uiDepth );
725    }
726  }
727#else
728  if( pcCU->getTextureModeDepth( 0 ) != -1 )
729    pcCU->setPartSizeSubParts( SIZE_NxN, 0, uiDepth );
730#endif
731#endif
732 
733  // inter prediction
734  m_pcPrediction->motionCompensation( pcCU, m_ppcYuvReco[uiDepth] );
735 
736#if HHI_MPI
737  if( pcCU->getTextureModeDepth( 0 ) != -1 )
738    pcCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
739#endif
740
741#if HHI_INTER_VIEW_RESIDUAL_PRED
742  if( pcCU->getResPredFlag( 0 ) )
743  {
744    AOF( pcCU->getResPredAvail( 0 ) );
745    Bool bOK = pcCU->getResidualSamples( 0, 
746#if QC_SIMPLIFIEDIVRP_M24938
747      true,
748#endif
749      m_ppcYuvResPred[uiDepth] );
750    AOF( bOK );
751#if LG_RESTRICTEDRESPRED_M24766
752    Int iPUResiPredShift[4];
753    pcCU->getPUResiPredShift(iPUResiPredShift, 0);
754    m_ppcYuvReco[uiDepth]->add(iPUResiPredShift, pcCU->getPartitionSize(0), m_ppcYuvResPred[uiDepth], pcCU->getWidth( 0 ), pcCU->getHeight( 0 ) );
755#else
756    m_ppcYuvReco[uiDepth]->add( m_ppcYuvResPred[uiDepth], pcCU->getWidth( 0 ), pcCU->getHeight( 0 ) );
757#endif
758  }
759#endif
760
761  // inter recon
762  xDecodeInterTexture( pcCU, 0, uiDepth );
763 
764  // clip for only non-zero cbp case
765  if  ( ( pcCU->getCbf( 0, TEXT_LUMA ) ) || ( pcCU->getCbf( 0, TEXT_CHROMA_U ) ) || ( pcCU->getCbf(0, TEXT_CHROMA_V ) ) )
766  {
767    m_ppcYuvReco[uiDepth]->addClip( m_ppcYuvReco[uiDepth], m_ppcYuvResi[uiDepth], 0, pcCU->getWidth( 0 ) );
768  }
769  else
770  {
771#if HHI_INTER_VIEW_RESIDUAL_PRED
772    if( pcCU->getResPredFlag( 0 ) )
773    {
774      m_ppcYuvReco[uiDepth]->clip( pcCU->getWidth( 0 ), pcCU->getHeight( 0 ) );
775    }
776#endif
777    m_ppcYuvReco[uiDepth]->copyPartToPartYuv( m_ppcYuvReco[uiDepth],0, pcCU->getWidth( 0 ),pcCU->getHeight( 0 ));
778  }
779}
780
781Void
782TDecCu::xIntraRecLumaBlk( TComDataCU* pcCU,
783                         UInt        uiTrDepth,
784                         UInt        uiAbsPartIdx,
785                         TComYuv*    pcRecoYuv,
786                         TComYuv*    pcPredYuv, 
787                         TComYuv*    pcResiYuv )
788{
789  UInt    uiWidth           = pcCU     ->getWidth   ( 0 ) >> uiTrDepth;
790  UInt    uiHeight          = pcCU     ->getHeight  ( 0 ) >> uiTrDepth;
791  UInt    uiStride          = pcRecoYuv->getStride  ();
792  Pel*    piReco            = pcRecoYuv->getLumaAddr( uiAbsPartIdx );
793  Pel*    piPred            = pcPredYuv->getLumaAddr( uiAbsPartIdx );
794  Pel*    piResi            = pcResiYuv->getLumaAddr( uiAbsPartIdx );
795 
796  UInt    uiNumCoeffInc     = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
797  TCoeff* pcCoeff           = pcCU->getCoeffY() + ( uiNumCoeffInc * uiAbsPartIdx );
798 
799  UInt    uiLumaPredMode    = pcCU->getLumaIntraDir     ( uiAbsPartIdx );
800 
801  UInt    uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
802  Pel*    piRecIPred        = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
803  UInt    uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getStride  ();
804 
805  //===== init availability pattern =====
806  Bool  bAboveAvail = false;
807  Bool  bLeftAvail  = false;
808  pcCU->getPattern()->initPattern   ( pcCU, uiTrDepth, uiAbsPartIdx );
809  pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, uiTrDepth, 
810                                     m_pcPrediction->getPredicBuf       (),
811                                     m_pcPrediction->getPredicBufWidth  (),
812                                     m_pcPrediction->getPredicBufHeight (),
813                                     bAboveAvail, bLeftAvail );
814#if LGE_EDGE_INTRA_A0070
815  if( uiLumaPredMode >= EDGE_INTRA_IDX )
816  {
817    m_pcPrediction->predIntraLumaEdge( pcCU, pcCU->getPattern(), uiAbsPartIdx, uiWidth, uiHeight, piPred, uiStride
818#if LGE_EDGE_INTRA_DELTA_DC
819      , uiLumaPredMode == EDGE_INTRA_DELTA_IDX
820#endif
821      );
822  } 
823  else
824#endif
825 
826  //===== get prediction signal =====
827#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
828  if( uiLumaPredMode >= NUM_INTRA_MODE )
829  {
830    m_pcPrediction->predIntraLumaDMM( pcCU, uiAbsPartIdx, uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail, false );
831  } 
832  else
833  {
834#endif
835  m_pcPrediction->predIntraLumaAng( pcCU->getPattern(), uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, pcCU, bAboveAvail, bLeftAvail );
836#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
837  }
838#endif
839 
840  //===== inverse transform =====
841#if H0736_AVC_STYLE_QP_RANGE
842  m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
843#else
844  m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, 0 );
845#endif
846
847  Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)TEXT_LUMA];
848  assert(scalingListType < 6);
849#if LOSSLESS_CODING
850  m_pcTrQuant->invtransformNxN( pcCU, TEXT_LUMA, pcCU->getLumaIntraDir( uiAbsPartIdx ), piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType );
851#else 
852  m_pcTrQuant->invtransformNxN(       TEXT_LUMA, pcCU->getLumaIntraDir( uiAbsPartIdx ), piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType );
853#endif
854
855 
856  //===== reconstruction =====
857  Pel* pPred      = piPred;
858  Pel* pResi      = piResi;
859  Pel* pReco      = piReco;
860  Pel* pRecIPred  = piRecIPred;
861  for( UInt uiY = 0; uiY < uiHeight; uiY++ )
862  {
863    for( UInt uiX = 0; uiX < uiWidth; uiX++ )
864    {
865      pReco    [ uiX ] = Clip( pPred[ uiX ] + pResi[ uiX ] );
866      pRecIPred[ uiX ] = pReco[ uiX ];
867    }
868    pPred     += uiStride;
869    pResi     += uiStride;
870    pReco     += uiStride;
871    pRecIPred += uiRecIPredStride;
872  }
873}
874
875
876Void
877TDecCu::xIntraRecChromaBlk( TComDataCU* pcCU,
878                           UInt        uiTrDepth,
879                           UInt        uiAbsPartIdx,
880                           TComYuv*    pcRecoYuv,
881                           TComYuv*    pcPredYuv, 
882                           TComYuv*    pcResiYuv,
883                           UInt        uiChromaId )
884{
885  UInt uiFullDepth  = pcCU->getDepth( 0 ) + uiTrDepth;
886  UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
887
888  if( uiLog2TrSize == 2 )
889  {
890    assert( uiTrDepth > 0 );
891    uiTrDepth--;
892    UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth ) << 1 );
893    Bool bFirstQ = ( ( uiAbsPartIdx % uiQPDiv ) == 0 );
894    if( !bFirstQ )
895    {
896      return;
897    }
898  }
899 
900  TextType  eText             = ( uiChromaId > 0 ? TEXT_CHROMA_V : TEXT_CHROMA_U );
901  UInt      uiWidth           = pcCU     ->getWidth   ( 0 ) >> ( uiTrDepth + 1 );
902  UInt      uiHeight          = pcCU     ->getHeight  ( 0 ) >> ( uiTrDepth + 1 );
903  UInt      uiStride          = pcRecoYuv->getCStride ();
904  Pel*      piReco            = ( uiChromaId > 0 ? pcRecoYuv->getCrAddr( uiAbsPartIdx ) : pcRecoYuv->getCbAddr( uiAbsPartIdx ) );
905  Pel*      piPred            = ( uiChromaId > 0 ? pcPredYuv->getCrAddr( uiAbsPartIdx ) : pcPredYuv->getCbAddr( uiAbsPartIdx ) );
906  Pel*      piResi            = ( uiChromaId > 0 ? pcResiYuv->getCrAddr( uiAbsPartIdx ) : pcResiYuv->getCbAddr( uiAbsPartIdx ) );
907 
908  UInt      uiNumCoeffInc     = ( ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 ) ) >> 2;
909  TCoeff*   pcCoeff           = ( uiChromaId > 0 ? pcCU->getCoeffCr() : pcCU->getCoeffCb() ) + ( uiNumCoeffInc * uiAbsPartIdx );
910 
911  UInt      uiChromaPredMode  = pcCU->getChromaIntraDir( 0 );
912 
913  UInt      uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
914  Pel*      piRecIPred        = ( uiChromaId > 0 ? pcCU->getPic()->getPicYuvRec()->getCrAddr( pcCU->getAddr(), uiZOrder ) : pcCU->getPic()->getPicYuvRec()->getCbAddr( pcCU->getAddr(), uiZOrder ) );
915  UInt      uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getCStride();
916 
917  //===== init availability pattern =====
918  Bool  bAboveAvail = false;
919  Bool  bLeftAvail  = false;
920  pcCU->getPattern()->initPattern         ( pcCU, uiTrDepth, uiAbsPartIdx );
921
922  if( uiChromaPredMode == LM_CHROMA_IDX && uiChromaId == 0 )
923  {
924    pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, uiTrDepth, 
925                                     m_pcPrediction->getPredicBuf       (),
926                                     m_pcPrediction->getPredicBufWidth  (),
927                                     m_pcPrediction->getPredicBufHeight (),
928                                     bAboveAvail, bLeftAvail, 
929                                     true );
930
931    m_pcPrediction->getLumaRecPixels( pcCU->getPattern(), uiWidth, uiHeight );
932  }
933 
934  pcCU->getPattern()->initAdiPatternChroma( pcCU, uiAbsPartIdx, uiTrDepth, 
935                                           m_pcPrediction->getPredicBuf       (),
936                                           m_pcPrediction->getPredicBufWidth  (),
937                                           m_pcPrediction->getPredicBufHeight (),
938                                           bAboveAvail, bLeftAvail );
939  Int* pPatChroma   = ( uiChromaId > 0 ? pcCU->getPattern()->getAdiCrBuf( uiWidth, uiHeight, m_pcPrediction->getPredicBuf() ) : pcCU->getPattern()->getAdiCbBuf( uiWidth, uiHeight, m_pcPrediction->getPredicBuf() ) );
940 
941  //===== get prediction signal =====
942  if( uiChromaPredMode == LM_CHROMA_IDX )
943  {
944    m_pcPrediction->predLMIntraChroma( pcCU->getPattern(), pPatChroma, piPred, uiStride, uiWidth, uiHeight, uiChromaId );
945  }
946  else
947  {
948    if( uiChromaPredMode == DM_CHROMA_IDX )
949    {
950      uiChromaPredMode = pcCU->getLumaIntraDir( 0 );
951#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
952      mapDMMtoIntraMode( uiChromaPredMode );
953#endif
954    }
955    m_pcPrediction->predIntraChromaAng( pcCU->getPattern(), pPatChroma, uiChromaPredMode, piPred, uiStride, uiWidth, uiHeight, pcCU, bAboveAvail, bLeftAvail ); 
956  }
957
958  //===== inverse transform =====
959  if(eText == TEXT_CHROMA_U)
960  {
961#if H0736_AVC_STYLE_QP_RANGE
962    m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset() );
963#else
964    m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getPPS()->getChromaQpOffset() );
965#endif
966  }
967  else
968  {
969#if H0736_AVC_STYLE_QP_RANGE
970    m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
971#else
972    m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
973#endif
974  }
975
976  Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)eText];
977  assert(scalingListType < 6);
978#if LOSSLESS_CODING
979  m_pcTrQuant->invtransformNxN( pcCU, eText, REG_DCT, piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType );
980#else 
981  m_pcTrQuant->invtransformNxN(       eText, REG_DCT, piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType );
982#endif
983
984  //===== reconstruction =====
985  Pel* pPred      = piPred;
986  Pel* pResi      = piResi;
987  Pel* pReco      = piReco;
988  Pel* pRecIPred  = piRecIPred;
989  for( UInt uiY = 0; uiY < uiHeight; uiY++ )
990  {
991    for( UInt uiX = 0; uiX < uiWidth; uiX++ )
992    {
993      pReco    [ uiX ] = Clip( pPred[ uiX ] + pResi[ uiX ] );
994      pRecIPred[ uiX ] = pReco[ uiX ];
995    }
996    pPred     += uiStride;
997    pResi     += uiStride;
998    pReco     += uiStride;
999    pRecIPred += uiRecIPredStride;
1000  }
1001}
1002
1003Void
1004TDecCu::xIntraRecQT( TComDataCU* pcCU,
1005                    UInt        uiTrDepth,
1006                    UInt        uiAbsPartIdx,
1007                    TComYuv*    pcRecoYuv,
1008                    TComYuv*    pcPredYuv, 
1009                    TComYuv*    pcResiYuv )
1010{
1011  UInt uiFullDepth  = pcCU->getDepth(0) + uiTrDepth;
1012  UInt uiTrMode     = pcCU->getTransformIdx( uiAbsPartIdx );
1013  if( uiTrMode == uiTrDepth )
1014  {
1015    xIntraRecLumaBlk  ( pcCU, uiTrDepth, uiAbsPartIdx, pcRecoYuv, pcPredYuv, pcResiYuv );
1016    xIntraRecChromaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcRecoYuv, pcPredYuv, pcResiYuv, 0 );
1017    xIntraRecChromaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcRecoYuv, pcPredYuv, pcResiYuv, 1 );
1018  }
1019  else
1020  {
1021    UInt uiNumQPart  = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
1022    for( UInt uiPart = 0; uiPart < 4; uiPart++ )
1023    {
1024      xIntraRecQT( pcCU, uiTrDepth + 1, uiAbsPartIdx + uiPart * uiNumQPart, pcRecoYuv, pcPredYuv, pcResiYuv );
1025    }
1026  }
1027}
1028
1029Void
1030TDecCu::xReconIntraQT( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1031{
1032  UInt  uiInitTrDepth = ( pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1 );
1033  UInt  uiNumPart     = pcCU->getNumPartInter();
1034  UInt  uiNumQParts   = pcCU->getTotalNumPart() >> 2;
1035 
1036  if (pcCU->getIPCMFlag(0))
1037  {
1038    xReconPCM( pcCU, uiAbsPartIdx, uiDepth );
1039    return;
1040  }
1041
1042  for( UInt uiPU = 0; uiPU < uiNumPart; uiPU++ )
1043  {
1044    xIntraLumaRecQT( pcCU, uiInitTrDepth, uiPU * uiNumQParts, m_ppcYuvReco[uiDepth], m_ppcYuvReco[uiDepth], m_ppcYuvResi[uiDepth] );
1045  } 
1046
1047  for( UInt uiPU = 0; uiPU < uiNumPart; uiPU++ )
1048  {
1049    xIntraChromaRecQT( pcCU, uiInitTrDepth, uiPU * uiNumQParts, m_ppcYuvReco[uiDepth], m_ppcYuvReco[uiDepth], m_ppcYuvResi[uiDepth] );
1050  }
1051
1052}
1053
1054#if RWTH_SDC_DLT_B0036
1055Void TDecCu::xReconIntraSDC( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1056{
1057  UInt uiWidth        = pcCU->getWidth  ( 0 );
1058  UInt uiHeight       = pcCU->getHeight ( 0 );
1059 
1060  TComYuv* pcRecoYuv  = m_ppcYuvReco[uiDepth];
1061  TComYuv* pcPredYuv  = m_ppcYuvReco[uiDepth];
1062  TComYuv* pcResiYuv  = m_ppcYuvResi[uiDepth];
1063 
1064  UInt    uiStride    = pcRecoYuv->getStride  ();
1065  Pel*    piReco      = pcRecoYuv->getLumaAddr( uiAbsPartIdx );
1066  Pel*    piPred      = pcPredYuv->getLumaAddr( uiAbsPartIdx );
1067  Pel*    piResi      = pcResiYuv->getLumaAddr( uiAbsPartIdx );
1068 
1069  UInt    uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1070  Pel*    piRecIPred        = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
1071  UInt    uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getStride  ();
1072 
1073  UInt    uiLumaPredMode    = pcCU->getLumaIntraDir     ( uiAbsPartIdx );
1074 
1075  AOF( uiWidth == uiHeight );
1076  AOF( uiAbsPartIdx == 0 );
1077  AOF( pcCU->getSDCAvailable(uiAbsPartIdx) );
1078  AOF( pcCU->getSDCFlag(uiAbsPartIdx) );
1079 
1080  //===== init availability pattern =====
1081  Bool  bAboveAvail = false;
1082  Bool  bLeftAvail  = false;
1083  pcCU->getPattern()->initPattern   ( pcCU, 0, uiAbsPartIdx );
1084  pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, 0, m_pcPrediction->getPredicBuf(), m_pcPrediction->getPredicBufWidth(), m_pcPrediction->getPredicBufHeight(), bAboveAvail, bLeftAvail );
1085 
1086  //===== get prediction signal =====
1087#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1088  if( uiLumaPredMode >= NUM_INTRA_MODE )
1089  {
1090    m_pcPrediction->predIntraLumaDMM( pcCU, uiAbsPartIdx, uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail, false );
1091  }
1092  else
1093  {
1094#endif
1095    m_pcPrediction->predIntraLumaAng( pcCU->getPattern(), uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, pcCU, bAboveAvail, bLeftAvail );
1096#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
1097  }
1098#endif
1099 
1100  // number of segments depends on prediction mode
1101  UInt uiNumSegments = 1; 
1102  Bool* pbMask = NULL;
1103  UInt uiMaskStride = 0;
1104 
1105  if( uiLumaPredMode == DMM_WEDGE_FULL_IDX || uiLumaPredMode == DMM_WEDGE_PREDDIR_IDX )
1106  {
1107    Int uiTabIdx = (uiLumaPredMode == DMM_WEDGE_FULL_IDX)?pcCU->getWedgeFullTabIdx(uiAbsPartIdx):pcCU->getWedgePredDirTabIdx(uiAbsPartIdx);
1108   
1109    WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiWidth])];
1110    TComWedgelet* pcWedgelet = &(pacWedgeList->at( uiTabIdx ));
1111   
1112    uiNumSegments = 2;
1113    pbMask = pcWedgelet->getPattern();
1114    uiMaskStride = pcWedgelet->getStride();
1115  }
1116 
1117  // get DC prediction for each segment
1118  Pel apDCPredValues[2];
1119  xAnalyzeSegmentsSDC(piPred, uiStride, uiWidth, apDCPredValues, uiNumSegments, pbMask, uiMaskStride);
1120 
1121  // reconstruct residual based on mask + DC residuals
1122  Pel apDCResiValues[2];
1123  //Pel apDCRecoValues[2];
1124  for( UInt ui = 0; ui < uiNumSegments; ui++ )
1125  {
1126    Pel   pPredIdx    = GetDepthValue2Idx( apDCPredValues[ui] );
1127    Pel   pResiIdx    = pcCU->getSDCSegmentDCOffset(ui, uiAbsPartIdx);
1128    Pel   pRecoValue  = GetIdx2DepthValue( pPredIdx + pResiIdx );
1129   
1130    //apDCRecoValues[ui]  = pRecoValue;
1131    apDCResiValues[ui]  = pRecoValue - apDCPredValues[ui];
1132  }
1133 
1134  //===== reconstruction =====
1135  Bool*pMask      = pbMask;
1136  Pel* pPred      = piPred;
1137  Pel* pResi      = piResi;
1138  Pel* pReco      = piReco;
1139  Pel* pRecIPred  = piRecIPred;
1140 
1141  for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1142  {
1143    for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1144    {
1145      UChar ucSegment = pMask?(UChar)pMask[uiX]:0;
1146      assert( ucSegment < uiNumSegments );
1147     
1148      Pel pPredVal= apDCPredValues[ucSegment];
1149      Pel pResiDC = apDCResiValues[ucSegment];
1150     
1151      pReco    [ uiX ] = Clip( pPredVal + pResiDC );
1152      pRecIPred[ uiX ] = pReco[ uiX ];
1153    }
1154    pPred     += uiStride;
1155    pResi     += uiStride;
1156    pReco     += uiStride;
1157    pRecIPred += uiRecIPredStride;
1158    pMask     += uiMaskStride;
1159  }
1160 
1161  // clear UV
1162  UInt  uiStrideC     = pcPredYuv->getCStride();
1163  Pel   *pRecCb       = pcPredYuv->getCbAddr();
1164  Pel   *pRecCr       = pcPredYuv->getCrAddr();
1165 
1166  for (Int y=0; y<uiHeight/2; y++)
1167  {
1168    for (Int x=0; x<uiWidth/2; x++)
1169    {
1170      pRecCb[x] = (Pel)(128<<g_uiBitIncrement);
1171      pRecCr[x] = (Pel)(128<<g_uiBitIncrement);
1172    }
1173   
1174    pRecCb += uiStrideC;
1175    pRecCr += uiStrideC;
1176  }
1177}
1178#endif
1179
1180/** Function for deriving recontructed PU/CU Luma sample with QTree structure
1181 * \param pcCU pointer of current CU
1182 * \param uiTrDepth current tranform split depth
1183 * \param uiAbsPartIdx  part index
1184 * \param pcRecoYuv pointer to reconstructed sample arrays
1185 * \param pcPredYuv pointer to prediction sample arrays
1186 * \param pcResiYuv pointer to residue sample arrays
1187 *
1188 \ This function dervies recontructed PU/CU Luma sample with recursive QTree structure
1189 */
1190Void
1191TDecCu::xIntraLumaRecQT( TComDataCU* pcCU,
1192                     UInt        uiTrDepth,
1193                     UInt        uiAbsPartIdx,
1194                     TComYuv*    pcRecoYuv,
1195                     TComYuv*    pcPredYuv, 
1196                     TComYuv*    pcResiYuv )
1197{
1198  UInt uiFullDepth  = pcCU->getDepth(0) + uiTrDepth;
1199  UInt uiTrMode     = pcCU->getTransformIdx( uiAbsPartIdx );
1200  if( uiTrMode == uiTrDepth )
1201  {
1202    xIntraRecLumaBlk  ( pcCU, uiTrDepth, uiAbsPartIdx, pcRecoYuv, pcPredYuv, pcResiYuv );
1203  }
1204  else
1205  {
1206    UInt uiNumQPart  = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
1207    for( UInt uiPart = 0; uiPart < 4; uiPart++ )
1208    {
1209      xIntraLumaRecQT( pcCU, uiTrDepth + 1, uiAbsPartIdx + uiPart * uiNumQPart, pcRecoYuv, pcPredYuv, pcResiYuv );
1210    }
1211  }
1212}
1213
1214/** Function for deriving recontructed PU/CU chroma samples with QTree structure
1215 * \param pcCU pointer of current CU
1216 * \param uiTrDepth current tranform split depth
1217 * \param uiAbsPartIdx  part index
1218 * \param pcRecoYuv pointer to reconstructed sample arrays
1219 * \param pcPredYuv pointer to prediction sample arrays
1220 * \param pcResiYuv pointer to residue sample arrays
1221 *
1222 \ This function dervies recontructed PU/CU chroma samples with QTree recursive structure
1223 */
1224Void
1225TDecCu::xIntraChromaRecQT( TComDataCU* pcCU,
1226                     UInt        uiTrDepth,
1227                     UInt        uiAbsPartIdx,
1228                     TComYuv*    pcRecoYuv,
1229                     TComYuv*    pcPredYuv, 
1230                     TComYuv*    pcResiYuv )
1231{
1232  UInt uiFullDepth  = pcCU->getDepth(0) + uiTrDepth;
1233  UInt uiTrMode     = pcCU->getTransformIdx( uiAbsPartIdx );
1234  if( uiTrMode == uiTrDepth )
1235  {
1236    xIntraRecChromaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcRecoYuv, pcPredYuv, pcResiYuv, 0 );
1237    xIntraRecChromaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcRecoYuv, pcPredYuv, pcResiYuv, 1 );
1238  }
1239  else
1240  {
1241    UInt uiNumQPart  = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
1242    for( UInt uiPart = 0; uiPart < 4; uiPart++ )
1243    {
1244      xIntraChromaRecQT( pcCU, uiTrDepth + 1, uiAbsPartIdx + uiPart * uiNumQPart, pcRecoYuv, pcPredYuv, pcResiYuv );
1245    }
1246  }
1247}
1248
1249Void TDecCu::xCopyToPic( TComDataCU* pcCU, TComPic* pcPic, UInt uiZorderIdx, UInt uiDepth )
1250{
1251  UInt uiCUAddr = pcCU->getAddr();
1252 
1253  m_ppcYuvReco[uiDepth]->copyToPicYuv  ( pcPic->getPicYuvRec (), uiCUAddr, uiZorderIdx );
1254 
1255  return;
1256}
1257
1258Void TDecCu::xDecodeInterTexture ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1259{
1260  UInt    uiWidth    = pcCU->getWidth ( uiAbsPartIdx );
1261  UInt    uiHeight   = pcCU->getHeight( uiAbsPartIdx );
1262  TCoeff* piCoeff;
1263 
1264  Pel*    pResi;
1265  UInt    uiLumaTrMode, uiChromaTrMode;
1266 
1267  pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx( uiAbsPartIdx ), uiLumaTrMode, uiChromaTrMode );
1268 
1269  // Y
1270  piCoeff = pcCU->getCoeffY();
1271  pResi = m_ppcYuvResi[uiDepth]->getLumaAddr();
1272
1273#if H0736_AVC_STYLE_QP_RANGE
1274  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
1275#else
1276  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, 0 );
1277#endif
1278
1279  m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_LUMA, pResi, 0, m_ppcYuvResi[uiDepth]->getStride(), uiWidth, uiHeight, uiLumaTrMode, 0, piCoeff );
1280 
1281  // Cb and Cr
1282#if H0736_AVC_STYLE_QP_RANGE
1283  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset() );
1284#else
1285  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getPPS()->getChromaQpOffset() );
1286#endif
1287
1288  uiWidth  >>= 1;
1289  uiHeight >>= 1;
1290  piCoeff = pcCU->getCoeffCb(); pResi = m_ppcYuvResi[uiDepth]->getCbAddr();
1291  m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_CHROMA_U, pResi, 0, m_ppcYuvResi[uiDepth]->getCStride(), uiWidth, uiHeight, uiChromaTrMode, 0, piCoeff );
1292
1293#if H0736_AVC_STYLE_QP_RANGE
1294  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
1295#else
1296  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
1297#endif
1298
1299  piCoeff = pcCU->getCoeffCr(); pResi = m_ppcYuvResi[uiDepth]->getCrAddr();
1300  m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_CHROMA_V, pResi, 0, m_ppcYuvResi[uiDepth]->getCStride(), uiWidth, uiHeight, uiChromaTrMode, 0, piCoeff );
1301}
1302
1303/** Function for deriving reconstructed luma/chroma samples of a PCM mode CU.
1304 * \param pcCU pointer to current CU
1305 * \param uiPartIdx part index
1306 * \param piPCM pointer to PCM code arrays
1307 * \param piReco pointer to reconstructed sample arrays
1308 * \param uiStride stride of reconstructed sample arrays
1309 * \param uiWidth CU width
1310 * \param uiHeight CU height
1311 * \param ttText texture component type
1312 * \returns Void
1313 */
1314Void TDecCu::xDecodePCMTexture( TComDataCU* pcCU, UInt uiPartIdx, Pel *piPCM, Pel* piReco, UInt uiStride, UInt uiWidth, UInt uiHeight, TextType ttText)
1315{
1316  UInt uiX, uiY;
1317  Pel* piPicReco;
1318  UInt uiPicStride;
1319  UInt uiPcmLeftShiftBit; 
1320
1321  if( ttText == TEXT_LUMA )
1322  {
1323    uiPicStride   = pcCU->getPic()->getPicYuvRec()->getStride();
1324    piPicReco = pcCU->getPic()->getPicYuvRec()->getLumaAddr(pcCU->getAddr(), pcCU->getZorderIdxInCU()+uiPartIdx);
1325    uiPcmLeftShiftBit = g_uiBitDepth + g_uiBitIncrement - pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
1326  }
1327  else
1328  {
1329    uiPicStride = pcCU->getPic()->getPicYuvRec()->getCStride();
1330
1331    if( ttText == TEXT_CHROMA_U )
1332    {
1333      piPicReco = pcCU->getPic()->getPicYuvRec()->getCbAddr(pcCU->getAddr(), pcCU->getZorderIdxInCU()+uiPartIdx);
1334    }
1335    else
1336    {
1337      piPicReco = pcCU->getPic()->getPicYuvRec()->getCrAddr(pcCU->getAddr(), pcCU->getZorderIdxInCU()+uiPartIdx);
1338    }
1339    uiPcmLeftShiftBit = g_uiBitDepth + g_uiBitIncrement - pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1340  }
1341
1342  for( uiY = 0; uiY < uiHeight; uiY++ )
1343  {
1344    for( uiX = 0; uiX < uiWidth; uiX++ )
1345    {
1346      piReco[uiX] = (piPCM[uiX] << uiPcmLeftShiftBit);
1347      piPicReco[uiX] = piReco[uiX];
1348    }
1349    piPCM += uiWidth;
1350    piReco += uiStride;
1351    piPicReco += uiPicStride;
1352  }
1353}
1354
1355/** Function for reconstructing a PCM mode CU.
1356 * \param pcCU pointer to current CU
1357 * \param uiAbsPartIdx CU index
1358 * \param uiDepth CU Depth
1359 * \returns Void
1360 */
1361Void TDecCu::xReconPCM( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1362{
1363  // Luma
1364  UInt uiWidth  = (g_uiMaxCUWidth >> uiDepth);
1365  UInt uiHeight = (g_uiMaxCUHeight >> uiDepth);
1366
1367  Pel* piPcmY = pcCU->getPCMSampleY();
1368  Pel* piRecoY = m_ppcYuvReco[uiDepth]->getLumaAddr(0, uiWidth);
1369
1370  UInt uiStride = m_ppcYuvResi[uiDepth]->getStride();
1371
1372  xDecodePCMTexture( pcCU, 0, piPcmY, piRecoY, uiStride, uiWidth, uiHeight, TEXT_LUMA);
1373
1374  // Cb and Cr
1375  UInt uiCWidth  = (uiWidth>>1);
1376  UInt uiCHeight = (uiHeight>>1);
1377
1378  Pel* piPcmCb = pcCU->getPCMSampleCb();
1379  Pel* piPcmCr = pcCU->getPCMSampleCr();
1380  Pel* pRecoCb = m_ppcYuvReco[uiDepth]->getCbAddr();
1381  Pel* pRecoCr = m_ppcYuvReco[uiDepth]->getCrAddr();
1382
1383  UInt uiCStride = m_ppcYuvReco[uiDepth]->getCStride();
1384
1385  xDecodePCMTexture( pcCU, 0, piPcmCb, pRecoCb, uiCStride, uiCWidth, uiCHeight, TEXT_CHROMA_U);
1386  xDecodePCMTexture( pcCU, 0, piPcmCr, pRecoCr, uiCStride, uiCWidth, uiCHeight, TEXT_CHROMA_V);
1387}
1388
1389#if LOSSLESS_CODING
1390/** Function for filling the PCM buffer of a CU using its reconstructed sample array
1391 * \param pcCU pointer to current CU
1392 * \param uiAbsPartIdx CU index
1393 * \param uiDepth CU Depth
1394 * \returns Void
1395 */
1396Void TDecCu::xFillPCMBuffer(TComDataCU* pCU, UInt absPartIdx, UInt depth)
1397{
1398  // Luma
1399  UInt width  = (g_uiMaxCUWidth >> depth);
1400  UInt height = (g_uiMaxCUHeight >> depth);
1401
1402  Pel* pPcmY = pCU->getPCMSampleY();
1403  Pel* pRecoY = m_ppcYuvReco[depth]->getLumaAddr(0, width);
1404
1405  UInt stride = m_ppcYuvReco[depth]->getStride();
1406
1407  for(Int y = 0; y < height; y++ )
1408  {
1409    for(Int x = 0; x < width; x++ )
1410    {
1411      pPcmY[x] = pRecoY[x];
1412    }
1413    pPcmY += width;
1414    pRecoY += stride;
1415  }
1416
1417  // Cb and Cr
1418  UInt widthC  = (width>>1);
1419  UInt heightC = (height>>1);
1420
1421  Pel* pPcmCb = pCU->getPCMSampleCb();
1422  Pel* pPcmCr = pCU->getPCMSampleCr();
1423  Pel* pRecoCb = m_ppcYuvReco[depth]->getCbAddr();
1424  Pel* pRecoCr = m_ppcYuvReco[depth]->getCrAddr();
1425
1426  UInt strideC = m_ppcYuvReco[depth]->getCStride();
1427
1428  for(Int y = 0; y < heightC; y++ )
1429  {
1430    for(Int x = 0; x < widthC; x++ )
1431    {
1432      pPcmCb[x] = pRecoCb[x];
1433      pPcmCr[x] = pRecoCr[x];
1434    }
1435    pPcmCr += widthC;
1436    pPcmCb += widthC;
1437    pRecoCb += strideC;
1438    pRecoCr += strideC;
1439  }
1440
1441}
1442#endif
1443
1444#if RWTH_SDC_DLT_B0036
1445Void TDecCu::xAnalyzeSegmentsSDC( Pel* pOrig, UInt uiStride, UInt uiSize, Pel* rpSegMeans, UInt uiNumSegments, Bool* pMask, UInt uiMaskStride )
1446{
1447  Int iSumDepth[2];
1448  memset(iSumDepth, 0, sizeof(Int)*2);
1449  Int iSumPix[2];
1450  memset(iSumPix, 0, sizeof(Int)*2);
1451 
1452  for (Int y=0; y<uiSize; y++)
1453  {
1454    for (Int x=0; x<uiSize; x++)
1455    {
1456      UChar ucSegment = pMask?(UChar)pMask[x]:0;
1457      assert( ucSegment < uiNumSegments );
1458     
1459      iSumDepth[ucSegment] += pOrig[x];
1460      iSumPix[ucSegment]   += 1;
1461    }
1462   
1463    pOrig  += uiStride;
1464    pMask  += uiMaskStride;
1465  }
1466 
1467  // compute mean for each segment
1468  for( UChar ucSeg = 0; ucSeg < uiNumSegments; ucSeg++ )
1469  {
1470    if( iSumPix[ucSeg] > 0 )
1471      rpSegMeans[ucSeg] = iSumDepth[ucSeg] / iSumPix[ucSeg];
1472    else
1473      rpSegMeans[ucSeg] = 0;  // this happens for zero-segments
1474  }
1475}
1476#endif
1477
1478//! \}
Note: See TracBrowser for help on using the repository browser.