source: 3DVCSoftware/branches/HTM-6.2-dev2-Samsung/source/Lib/TLibDecoder/TDecCu.cpp

Last change on this file was 399, checked in by samsung-htm, 12 years ago

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