source: SHVCSoftware/branches/SHM-5.1-dev/source/Lib/TLibEncoder/TEncSearch.cpp @ 1398

Last change on this file since 1398 was 595, checked in by seregin, 11 years ago

merge with SHM-5.0-dev branch
  • Property svn:eol-style set to native
File size: 237.8 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2014, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TEncSearch.cpp
35 \brief    encoder search class
36 */
37
38#include "TLibCommon/TypeDef.h"
39#include "TLibCommon/TComRom.h"
40#include "TLibCommon/TComMotionInfo.h"
41#include "TEncSearch.h"
42#include <math.h>
43
44//! \ingroup TLibEncoder
45//! \{
46
47static const TComMv s_acMvRefineH[9] =
48{
49  TComMv(  0,  0 ), // 0
50  TComMv(  0, -1 ), // 1
51  TComMv(  0,  1 ), // 2
52  TComMv( -1,  0 ), // 3
53  TComMv(  1,  0 ), // 4
54  TComMv( -1, -1 ), // 5
55  TComMv(  1, -1 ), // 6
56  TComMv( -1,  1 ), // 7
57  TComMv(  1,  1 )  // 8
58};
59
60static const TComMv s_acMvRefineQ[9] =
61{
62  TComMv(  0,  0 ), // 0
63  TComMv(  0, -1 ), // 1
64  TComMv(  0,  1 ), // 2
65  TComMv( -1, -1 ), // 5
66  TComMv(  1, -1 ), // 6
67  TComMv( -1,  0 ), // 3
68  TComMv(  1,  0 ), // 4
69  TComMv( -1,  1 ), // 7
70  TComMv(  1,  1 )  // 8
71};
72
73static const UInt s_auiDFilter[9] =
74{
75  0, 1, 0,
76  2, 3, 2,
77  0, 1, 0
78};
79
80TEncSearch::TEncSearch()
81{
82  m_ppcQTTempCoeffY  = NULL;
83  m_ppcQTTempCoeffCb = NULL;
84  m_ppcQTTempCoeffCr = NULL;
85  m_pcQTTempCoeffY   = NULL;
86  m_pcQTTempCoeffCb  = NULL;
87  m_pcQTTempCoeffCr  = NULL;
88#if ADAPTIVE_QP_SELECTION
89  m_ppcQTTempArlCoeffY  = NULL;
90  m_ppcQTTempArlCoeffCb = NULL;
91  m_ppcQTTempArlCoeffCr = NULL;
92  m_pcQTTempArlCoeffY   = NULL;
93  m_pcQTTempArlCoeffCb  = NULL;
94  m_pcQTTempArlCoeffCr  = NULL;
95#endif
96  m_puhQTTempTrIdx   = NULL;
97  m_puhQTTempCbf[0] = m_puhQTTempCbf[1] = m_puhQTTempCbf[2] = NULL;
98  m_pcQTTempTComYuv  = NULL;
99  m_pcEncCfg = NULL;
100  m_pcEntropyCoder = NULL;
101  m_pTempPel = NULL;
102  m_pSharedPredTransformSkip[0] = m_pSharedPredTransformSkip[1] = m_pSharedPredTransformSkip[2] = NULL;
103  m_pcQTTempTUCoeffY   = NULL;
104  m_pcQTTempTUCoeffCb  = NULL;
105  m_pcQTTempTUCoeffCr  = NULL;
106#if ADAPTIVE_QP_SELECTION
107  m_ppcQTTempTUArlCoeffY  = NULL;
108  m_ppcQTTempTUArlCoeffCb = NULL;
109  m_ppcQTTempTUArlCoeffCr = NULL;
110#endif
111  m_puhQTTempTransformSkipFlag[0] = NULL;
112  m_puhQTTempTransformSkipFlag[1] = NULL;
113  m_puhQTTempTransformSkipFlag[2] = NULL;
114  setWpScalingDistParam( NULL, -1, REF_PIC_LIST_X );
115}
116
117TEncSearch::~TEncSearch()
118{
119  if ( m_pTempPel )
120  {
121    delete [] m_pTempPel;
122    m_pTempPel = NULL;
123  }
124 
125  if ( m_pcEncCfg )
126  {
127    const UInt uiNumLayersAllocated = m_pcEncCfg->getQuadtreeTULog2MaxSize()-m_pcEncCfg->getQuadtreeTULog2MinSize()+1;
128    for( UInt ui = 0; ui < uiNumLayersAllocated; ++ui )
129    {
130      delete[] m_ppcQTTempCoeffY[ui];
131      delete[] m_ppcQTTempCoeffCb[ui];
132      delete[] m_ppcQTTempCoeffCr[ui];
133#if ADAPTIVE_QP_SELECTION
134      delete[] m_ppcQTTempArlCoeffY[ui];
135      delete[] m_ppcQTTempArlCoeffCb[ui];
136      delete[] m_ppcQTTempArlCoeffCr[ui];
137#endif
138      m_pcQTTempTComYuv[ui].destroy();
139    }
140  }
141  delete[] m_ppcQTTempCoeffY;
142  delete[] m_ppcQTTempCoeffCb;
143  delete[] m_ppcQTTempCoeffCr;
144  delete[] m_pcQTTempCoeffY;
145  delete[] m_pcQTTempCoeffCb;
146  delete[] m_pcQTTempCoeffCr;
147#if ADAPTIVE_QP_SELECTION
148  delete[] m_ppcQTTempArlCoeffY;
149  delete[] m_ppcQTTempArlCoeffCb;
150  delete[] m_ppcQTTempArlCoeffCr;
151  delete[] m_pcQTTempArlCoeffY;
152  delete[] m_pcQTTempArlCoeffCb;
153  delete[] m_pcQTTempArlCoeffCr;
154#endif
155  delete[] m_puhQTTempTrIdx;
156  delete[] m_puhQTTempCbf[0];
157  delete[] m_puhQTTempCbf[1];
158  delete[] m_puhQTTempCbf[2];
159  delete[] m_pcQTTempTComYuv;
160  delete[] m_pSharedPredTransformSkip[0];
161  delete[] m_pSharedPredTransformSkip[1];
162  delete[] m_pSharedPredTransformSkip[2];
163  delete[] m_pcQTTempTUCoeffY;
164  delete[] m_pcQTTempTUCoeffCb;
165  delete[] m_pcQTTempTUCoeffCr;
166#if ADAPTIVE_QP_SELECTION
167  delete[] m_ppcQTTempTUArlCoeffY;
168  delete[] m_ppcQTTempTUArlCoeffCb;
169  delete[] m_ppcQTTempTUArlCoeffCr;
170#endif
171  delete[] m_puhQTTempTransformSkipFlag[0];
172  delete[] m_puhQTTempTransformSkipFlag[1];
173  delete[] m_puhQTTempTransformSkipFlag[2];
174  m_pcQTTempTransformSkipTComYuv.destroy();
175  m_tmpYuvPred.destroy();
176}
177
178void TEncSearch::init(TEncCfg*      pcEncCfg,
179                      TComTrQuant*  pcTrQuant,
180                      Int           iSearchRange,
181                      Int           bipredSearchRange,
182                      Int           iFastSearch,
183                      Int           iMaxDeltaQP,
184                      TEncEntropy*  pcEntropyCoder,
185                      TComRdCost*   pcRdCost,
186                      TEncSbac*** pppcRDSbacCoder,
187                      TEncSbac*   pcRDGoOnSbacCoder
188                      )
189{
190  m_pcEncCfg             = pcEncCfg;
191  m_pcTrQuant            = pcTrQuant;
192  m_iSearchRange         = iSearchRange;
193  m_bipredSearchRange    = bipredSearchRange;
194  m_iFastSearch          = iFastSearch;
195  m_iMaxDeltaQP          = iMaxDeltaQP;
196  m_pcEntropyCoder       = pcEntropyCoder;
197  m_pcRdCost             = pcRdCost;
198 
199  m_pppcRDSbacCoder     = pppcRDSbacCoder;
200  m_pcRDGoOnSbacCoder   = pcRDGoOnSbacCoder;
201 
202  for (Int iDir = 0; iDir < 2; iDir++)
203  {
204    for (Int iRefIdx = 0; iRefIdx < 33; iRefIdx++)
205    {
206      m_aaiAdaptSR[iDir][iRefIdx] = iSearchRange;
207    }
208  }
209 
210  m_puiDFilter = s_auiDFilter + 4;
211 
212  // initialize motion cost
213#if !FIX203
214  m_pcRdCost->initRateDistortionModel( m_iSearchRange << 2 );
215#endif
216 
217  for( Int iNum = 0; iNum < AMVP_MAX_NUM_CANDS+1; iNum++)
218  {
219    for( Int iIdx = 0; iIdx < AMVP_MAX_NUM_CANDS; iIdx++)
220    {
221      if (iIdx < iNum)
222        m_auiMVPIdxCost[iIdx][iNum] = xGetMvpIdxBits(iIdx, iNum);
223      else
224        m_auiMVPIdxCost[iIdx][iNum] = MAX_INT;
225    }
226  }
227 
228  initTempBuff();
229 
230  m_pTempPel = new Pel[g_uiMaxCUWidth*g_uiMaxCUHeight];
231 
232  const UInt uiNumLayersToAllocate = pcEncCfg->getQuadtreeTULog2MaxSize()-pcEncCfg->getQuadtreeTULog2MinSize()+1;
233  m_ppcQTTempCoeffY  = new TCoeff*[uiNumLayersToAllocate];
234  m_ppcQTTempCoeffCb = new TCoeff*[uiNumLayersToAllocate];
235  m_ppcQTTempCoeffCr = new TCoeff*[uiNumLayersToAllocate];
236  m_pcQTTempCoeffY   = new TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight   ];
237  m_pcQTTempCoeffCb  = new TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
238  m_pcQTTempCoeffCr  = new TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
239#if ADAPTIVE_QP_SELECTION
240  m_ppcQTTempArlCoeffY  = new Int*[uiNumLayersToAllocate];
241  m_ppcQTTempArlCoeffCb = new Int*[uiNumLayersToAllocate];
242  m_ppcQTTempArlCoeffCr = new Int*[uiNumLayersToAllocate];
243  m_pcQTTempArlCoeffY   = new Int [g_uiMaxCUWidth*g_uiMaxCUHeight   ];
244  m_pcQTTempArlCoeffCb  = new Int [g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
245  m_pcQTTempArlCoeffCr  = new Int [g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
246#endif
247 
248  const UInt uiNumPartitions = 1<<(g_uiMaxCUDepth<<1);
249  m_puhQTTempTrIdx   = new UChar  [uiNumPartitions];
250  m_puhQTTempCbf[0]  = new UChar  [uiNumPartitions];
251  m_puhQTTempCbf[1]  = new UChar  [uiNumPartitions];
252  m_puhQTTempCbf[2]  = new UChar  [uiNumPartitions];
253  m_pcQTTempTComYuv  = new TComYuv[uiNumLayersToAllocate];
254  for( UInt ui = 0; ui < uiNumLayersToAllocate; ++ui )
255  {
256    m_ppcQTTempCoeffY[ui]  = new TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight   ];
257    m_ppcQTTempCoeffCb[ui] = new TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
258    m_ppcQTTempCoeffCr[ui] = new TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
259#if ADAPTIVE_QP_SELECTION
260    m_ppcQTTempArlCoeffY[ui]  = new Int[g_uiMaxCUWidth*g_uiMaxCUHeight   ];
261    m_ppcQTTempArlCoeffCb[ui] = new Int[g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
262    m_ppcQTTempArlCoeffCr[ui] = new Int[g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
263#endif
264    m_pcQTTempTComYuv[ui].create( g_uiMaxCUWidth, g_uiMaxCUHeight );
265  }
266  m_pSharedPredTransformSkip[0] = new Pel[MAX_TS_WIDTH*MAX_TS_HEIGHT];
267  m_pSharedPredTransformSkip[1] = new Pel[MAX_TS_WIDTH*MAX_TS_HEIGHT];
268  m_pSharedPredTransformSkip[2] = new Pel[MAX_TS_WIDTH*MAX_TS_HEIGHT];
269  m_pcQTTempTUCoeffY  = new TCoeff[MAX_TS_WIDTH*MAX_TS_HEIGHT];
270  m_pcQTTempTUCoeffCb = new TCoeff[MAX_TS_WIDTH*MAX_TS_HEIGHT];
271  m_pcQTTempTUCoeffCr = new TCoeff[MAX_TS_WIDTH*MAX_TS_HEIGHT];
272#if ADAPTIVE_QP_SELECTION
273  m_ppcQTTempTUArlCoeffY  = new Int[MAX_TS_WIDTH*MAX_TS_HEIGHT];
274  m_ppcQTTempTUArlCoeffCb = new Int[MAX_TS_WIDTH*MAX_TS_HEIGHT];
275  m_ppcQTTempTUArlCoeffCr = new Int[MAX_TS_WIDTH*MAX_TS_HEIGHT];
276#endif
277  m_pcQTTempTransformSkipTComYuv.create( g_uiMaxCUWidth, g_uiMaxCUHeight );
278
279  m_puhQTTempTransformSkipFlag[0] = new UChar  [uiNumPartitions];
280  m_puhQTTempTransformSkipFlag[1] = new UChar  [uiNumPartitions];
281  m_puhQTTempTransformSkipFlag[2] = new UChar  [uiNumPartitions];
282  m_tmpYuvPred.create(MAX_CU_SIZE, MAX_CU_SIZE);
283}
284
285#if FASTME_SMOOTHER_MV
286#define FIRSTSEARCHSTOP     1
287#else
288#define FIRSTSEARCHSTOP     0
289#endif
290
291#define TZ_SEARCH_CONFIGURATION                                                                                 \
292const Int  iRaster                  = 5;  /* TZ soll von aussen ?ergeben werden */                            \
293const Bool bTestOtherPredictedMV    = 0;                                                                      \
294const Bool bTestZeroVector          = 1;                                                                      \
295const Bool bTestZeroVectorStart     = 0;                                                                      \
296const Bool bTestZeroVectorStop      = 0;                                                                      \
297const Bool bFirstSearchDiamond      = 1;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
298const Bool bFirstSearchStop         = FIRSTSEARCHSTOP;                                                        \
299const UInt uiFirstSearchRounds      = 3;  /* first search stop X rounds after best match (must be >=1) */     \
300const Bool bEnableRasterSearch      = 1;                                                                      \
301const Bool bAlwaysRasterSearch      = 0;  /* ===== 1: BETTER but factor 2 slower ===== */                     \
302const Bool bRasterRefinementEnable  = 0;  /* enable either raster refinement or star refinement */            \
303const Bool bRasterRefinementDiamond = 0;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
304const Bool bStarRefinementEnable    = 1;  /* enable either star refinement or raster refinement */            \
305const Bool bStarRefinementDiamond   = 1;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
306const Bool bStarRefinementStop      = 0;                                                                      \
307const UInt uiStarRefinementRounds   = 2;  /* star refinement stop X rounds after best match (must be >=1) */  \
308
309
310__inline Void TEncSearch::xTZSearchHelp( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, const Int iSearchX, const Int iSearchY, const UChar ucPointNr, const UInt uiDistance )
311{
312  UInt  uiSad;
313 
314  Pel*  piRefSrch;
315 
316  piRefSrch = rcStruct.piRefY + iSearchY * rcStruct.iYStride + iSearchX;
317 
318  //-- jclee for using the SAD function pointer
319  m_pcRdCost->setDistParam( pcPatternKey, piRefSrch, rcStruct.iYStride,  m_cDistParam );
320 
321  // fast encoder decision: use subsampled SAD when rows > 8 for integer ME
322  if ( m_pcEncCfg->getUseFastEnc() )
323  {
324    if ( m_cDistParam.iRows > 8 )
325    {
326      m_cDistParam.iSubShift = 1;
327    }
328  }
329
330  setDistParamComp(0);  // Y component
331
332  // distortion
333  m_cDistParam.bitDepth = g_bitDepthY;
334  uiSad = m_cDistParam.DistFunc( &m_cDistParam );
335 
336  // motion cost
337  uiSad += m_pcRdCost->getCost( iSearchX, iSearchY );
338 
339  if( uiSad < rcStruct.uiBestSad )
340  {
341    rcStruct.uiBestSad      = uiSad;
342    rcStruct.iBestX         = iSearchX;
343    rcStruct.iBestY         = iSearchY;
344    rcStruct.uiBestDistance = uiDistance;
345    rcStruct.uiBestRound    = 0;
346    rcStruct.ucPointNr      = ucPointNr;
347  }
348}
349
350__inline Void TEncSearch::xTZ2PointSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB )
351{
352  Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
353  Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
354  Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
355  Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
356 
357  // 2 point search,                   //   1 2 3
358  // check only the 2 untested points  //   4 0 5
359  // around the start point            //   6 7 8
360  Int iStartX = rcStruct.iBestX;
361  Int iStartY = rcStruct.iBestY;
362  switch( rcStruct.ucPointNr )
363  {
364    case 1:
365    {
366      if ( (iStartX - 1) >= iSrchRngHorLeft )
367      {
368        xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY, 0, 2 );
369      }
370      if ( (iStartY - 1) >= iSrchRngVerTop )
371      {
372        xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iStartY - 1, 0, 2 );
373      }
374    }
375      break;
376    case 2:
377    {
378      if ( (iStartY - 1) >= iSrchRngVerTop )
379      {
380        if ( (iStartX - 1) >= iSrchRngHorLeft )
381        {
382          xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY - 1, 0, 2 );
383        }
384        if ( (iStartX + 1) <= iSrchRngHorRight )
385        {
386          xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY - 1, 0, 2 );
387        }
388      }
389    }
390      break;
391    case 3:
392    {
393      if ( (iStartY - 1) >= iSrchRngVerTop )
394      {
395        xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iStartY - 1, 0, 2 );
396      }
397      if ( (iStartX + 1) <= iSrchRngHorRight )
398      {
399        xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY, 0, 2 );
400      }
401    }
402      break;
403    case 4:
404    {
405      if ( (iStartX - 1) >= iSrchRngHorLeft )
406      {
407        if ( (iStartY + 1) <= iSrchRngVerBottom )
408        {
409          xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY + 1, 0, 2 );
410        }
411        if ( (iStartY - 1) >= iSrchRngVerTop )
412        {
413          xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY - 1, 0, 2 );
414        }
415      }
416    }
417      break;
418    case 5:
419    {
420      if ( (iStartX + 1) <= iSrchRngHorRight )
421      {
422        if ( (iStartY - 1) >= iSrchRngVerTop )
423        {
424          xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY - 1, 0, 2 );
425        }
426        if ( (iStartY + 1) <= iSrchRngVerBottom )
427        {
428          xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY + 1, 0, 2 );
429        }
430      }
431    }
432      break;
433    case 6:
434    {
435      if ( (iStartX - 1) >= iSrchRngHorLeft )
436      {
437        xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY , 0, 2 );
438      }
439      if ( (iStartY + 1) <= iSrchRngVerBottom )
440      {
441        xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iStartY + 1, 0, 2 );
442      }
443    }
444      break;
445    case 7:
446    {
447      if ( (iStartY + 1) <= iSrchRngVerBottom )
448      {
449        if ( (iStartX - 1) >= iSrchRngHorLeft )
450        {
451          xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY + 1, 0, 2 );
452        }
453        if ( (iStartX + 1) <= iSrchRngHorRight )
454        {
455          xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY + 1, 0, 2 );
456        }
457      }
458    }
459      break;
460    case 8:
461    {
462      if ( (iStartX + 1) <= iSrchRngHorRight )
463      {
464        xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY, 0, 2 );
465      }
466      if ( (iStartY + 1) <= iSrchRngVerBottom )
467      {
468        xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iStartY + 1, 0, 2 );
469      }
470    }
471      break;
472    default:
473    {
474      assert( false );
475    }
476      break;
477  } // switch( rcStruct.ucPointNr )
478}
479
480__inline Void TEncSearch::xTZ8PointSquareSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist )
481{
482  Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
483  Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
484  Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
485  Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
486 
487  // 8 point search,                   //   1 2 3
488  // search around the start point     //   4 0 5
489  // with the required  distance       //   6 7 8
490  assert( iDist != 0 );
491  const Int iTop        = iStartY - iDist;
492  const Int iBottom     = iStartY + iDist;
493  const Int iLeft       = iStartX - iDist;
494  const Int iRight      = iStartX + iDist;
495  rcStruct.uiBestRound += 1;
496 
497  if ( iTop >= iSrchRngVerTop ) // check top
498  {
499    if ( iLeft >= iSrchRngHorLeft ) // check top left
500    {
501      xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iTop, 1, iDist );
502    }
503    // top middle
504    xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
505   
506    if ( iRight <= iSrchRngHorRight ) // check top right
507    {
508      xTZSearchHelp( pcPatternKey, rcStruct, iRight, iTop, 3, iDist );
509    }
510  } // check top
511  if ( iLeft >= iSrchRngHorLeft ) // check middle left
512  {
513    xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 4, iDist );
514  }
515  if ( iRight <= iSrchRngHorRight ) // check middle right
516  {
517    xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 5, iDist );
518  }
519  if ( iBottom <= iSrchRngVerBottom ) // check bottom
520  {
521    if ( iLeft >= iSrchRngHorLeft ) // check bottom left
522    {
523      xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iBottom, 6, iDist );
524    }
525    // check bottom middle
526    xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
527   
528    if ( iRight <= iSrchRngHorRight ) // check bottom right
529    {
530      xTZSearchHelp( pcPatternKey, rcStruct, iRight, iBottom, 8, iDist );
531    }
532  } // check bottom
533}
534
535__inline Void TEncSearch::xTZ8PointDiamondSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist )
536{
537  Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
538  Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
539  Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
540  Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
541 
542  // 8 point search,                   //   1 2 3
543  // search around the start point     //   4 0 5
544  // with the required  distance       //   6 7 8
545  assert ( iDist != 0 );
546  const Int iTop        = iStartY - iDist;
547  const Int iBottom     = iStartY + iDist;
548  const Int iLeft       = iStartX - iDist;
549  const Int iRight      = iStartX + iDist;
550  rcStruct.uiBestRound += 1;
551 
552  if ( iDist == 1 ) // iDist == 1
553  {
554    if ( iTop >= iSrchRngVerTop ) // check top
555    {
556      xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
557    }
558    if ( iLeft >= iSrchRngHorLeft ) // check middle left
559    {
560      xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 4, iDist );
561    }
562    if ( iRight <= iSrchRngHorRight ) // check middle right
563    {
564      xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 5, iDist );
565    }
566    if ( iBottom <= iSrchRngVerBottom ) // check bottom
567    {
568      xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
569    }
570  }
571  else // if (iDist != 1)
572  {
573    if ( iDist <= 8 )
574    {
575      const Int iTop_2      = iStartY - (iDist>>1);
576      const Int iBottom_2   = iStartY + (iDist>>1);
577      const Int iLeft_2     = iStartX - (iDist>>1);
578      const Int iRight_2    = iStartX + (iDist>>1);
579     
580      if (  iTop >= iSrchRngVerTop && iLeft >= iSrchRngHorLeft &&
581          iRight <= iSrchRngHorRight && iBottom <= iSrchRngVerBottom ) // check border
582      {
583        xTZSearchHelp( pcPatternKey, rcStruct, iStartX,  iTop,      2, iDist    );
584        xTZSearchHelp( pcPatternKey, rcStruct, iLeft_2,  iTop_2,    1, iDist>>1 );
585        xTZSearchHelp( pcPatternKey, rcStruct, iRight_2, iTop_2,    3, iDist>>1 );
586        xTZSearchHelp( pcPatternKey, rcStruct, iLeft,    iStartY,   4, iDist    );
587        xTZSearchHelp( pcPatternKey, rcStruct, iRight,   iStartY,   5, iDist    );
588        xTZSearchHelp( pcPatternKey, rcStruct, iLeft_2,  iBottom_2, 6, iDist>>1 );
589        xTZSearchHelp( pcPatternKey, rcStruct, iRight_2, iBottom_2, 8, iDist>>1 );
590        xTZSearchHelp( pcPatternKey, rcStruct, iStartX,  iBottom,   7, iDist    );
591      }
592      else // check border
593      {
594        if ( iTop >= iSrchRngVerTop ) // check top
595        {
596          xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
597        }
598        if ( iTop_2 >= iSrchRngVerTop ) // check half top
599        {
600          if ( iLeft_2 >= iSrchRngHorLeft ) // check half left
601          {
602            xTZSearchHelp( pcPatternKey, rcStruct, iLeft_2, iTop_2, 1, (iDist>>1) );
603          }
604          if ( iRight_2 <= iSrchRngHorRight ) // check half right
605          {
606            xTZSearchHelp( pcPatternKey, rcStruct, iRight_2, iTop_2, 3, (iDist>>1) );
607          }
608        } // check half top
609        if ( iLeft >= iSrchRngHorLeft ) // check left
610        {
611          xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 4, iDist );
612        }
613        if ( iRight <= iSrchRngHorRight ) // check right
614        {
615          xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 5, iDist );
616        }
617        if ( iBottom_2 <= iSrchRngVerBottom ) // check half bottom
618        {
619          if ( iLeft_2 >= iSrchRngHorLeft ) // check half left
620          {
621            xTZSearchHelp( pcPatternKey, rcStruct, iLeft_2, iBottom_2, 6, (iDist>>1) );
622          }
623          if ( iRight_2 <= iSrchRngHorRight ) // check half right
624          {
625            xTZSearchHelp( pcPatternKey, rcStruct, iRight_2, iBottom_2, 8, (iDist>>1) );
626          }
627        } // check half bottom
628        if ( iBottom <= iSrchRngVerBottom ) // check bottom
629        {
630          xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
631        }
632      } // check border
633    }
634    else // iDist > 8
635    {
636      if ( iTop >= iSrchRngVerTop && iLeft >= iSrchRngHorLeft &&
637          iRight <= iSrchRngHorRight && iBottom <= iSrchRngVerBottom ) // check border
638      {
639        xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop,    0, iDist );
640        xTZSearchHelp( pcPatternKey, rcStruct, iLeft,   iStartY, 0, iDist );
641        xTZSearchHelp( pcPatternKey, rcStruct, iRight,  iStartY, 0, iDist );
642        xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 0, iDist );
643        for ( Int index = 1; index < 4; index++ )
644        {
645          Int iPosYT = iTop    + ((iDist>>2) * index);
646          Int iPosYB = iBottom - ((iDist>>2) * index);
647          Int iPosXL = iStartX - ((iDist>>2) * index);
648          Int iPosXR = iStartX + ((iDist>>2) * index);
649          xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYT, 0, iDist );
650          xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYT, 0, iDist );
651          xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYB, 0, iDist );
652          xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYB, 0, iDist );
653        }
654      }
655      else // check border
656      {
657        if ( iTop >= iSrchRngVerTop ) // check top
658        {
659          xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 0, iDist );
660        }
661        if ( iLeft >= iSrchRngHorLeft ) // check left
662        {
663          xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 0, iDist );
664        }
665        if ( iRight <= iSrchRngHorRight ) // check right
666        {
667          xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 0, iDist );
668        }
669        if ( iBottom <= iSrchRngVerBottom ) // check bottom
670        {
671          xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 0, iDist );
672        }
673        for ( Int index = 1; index < 4; index++ )
674        {
675          Int iPosYT = iTop    + ((iDist>>2) * index);
676          Int iPosYB = iBottom - ((iDist>>2) * index);
677          Int iPosXL = iStartX - ((iDist>>2) * index);
678          Int iPosXR = iStartX + ((iDist>>2) * index);
679         
680          if ( iPosYT >= iSrchRngVerTop ) // check top
681          {
682            if ( iPosXL >= iSrchRngHorLeft ) // check left
683            {
684              xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYT, 0, iDist );
685            }
686            if ( iPosXR <= iSrchRngHorRight ) // check right
687            {
688              xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYT, 0, iDist );
689            }
690          } // check top
691          if ( iPosYB <= iSrchRngVerBottom ) // check bottom
692          {
693            if ( iPosXL >= iSrchRngHorLeft ) // check left
694            {
695              xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYB, 0, iDist );
696            }
697            if ( iPosXR <= iSrchRngHorRight ) // check right
698            {
699              xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYB, 0, iDist );
700            }
701          } // check bottom
702        } // for ...
703      } // check border
704    } // iDist <= 8
705  } // iDist == 1
706}
707
708//<--
709
710UInt TEncSearch::xPatternRefinement( TComPattern* pcPatternKey,
711                                    TComMv baseRefMv,
712                                    Int iFrac, TComMv& rcMvFrac )
713{
714  UInt  uiDist;
715  UInt  uiDistBest  = MAX_UINT;
716  UInt  uiDirecBest = 0;
717 
718  Pel*  piRefPos;
719  Int iRefStride = m_filteredBlock[0][0].getStride();
720  m_pcRdCost->setDistParam( pcPatternKey, m_filteredBlock[0][0].getLumaAddr(), iRefStride, 1, m_cDistParam, m_pcEncCfg->getUseHADME() );
721 
722  const TComMv* pcMvRefine = (iFrac == 2 ? s_acMvRefineH : s_acMvRefineQ);
723 
724  for (UInt i = 0; i < 9; i++)
725  {
726    TComMv cMvTest = pcMvRefine[i];
727    cMvTest += baseRefMv;
728   
729    Int horVal = cMvTest.getHor() * iFrac;
730    Int verVal = cMvTest.getVer() * iFrac;
731    piRefPos = m_filteredBlock[ verVal & 3 ][ horVal & 3 ].getLumaAddr();
732    if ( horVal == 2 && ( verVal & 1 ) == 0 )
733    {
734      piRefPos += 1;
735    }
736    if ( ( horVal & 1 ) == 0 && verVal == 2 )
737    {
738      piRefPos += iRefStride;
739    }
740    cMvTest = pcMvRefine[i];
741    cMvTest += rcMvFrac;
742
743    setDistParamComp(0);  // Y component
744
745    m_cDistParam.pCur = piRefPos;
746    m_cDistParam.bitDepth = g_bitDepthY;
747    uiDist = m_cDistParam.DistFunc( &m_cDistParam );
748    uiDist += m_pcRdCost->getCost( cMvTest.getHor(), cMvTest.getVer() );
749   
750    if ( uiDist < uiDistBest )
751    {
752      uiDistBest  = uiDist;
753      uiDirecBest = i;
754    }
755  }
756 
757  rcMvFrac = pcMvRefine[uiDirecBest];
758 
759  return uiDistBest;
760}
761
762Void
763TEncSearch::xEncSubdivCbfQT( TComDataCU*  pcCU,
764                            UInt         uiTrDepth,
765                            UInt         uiAbsPartIdx,
766                            Bool         bLuma,
767                            Bool         bChroma )
768{
769  UInt  uiFullDepth     = pcCU->getDepth(0) + uiTrDepth;
770  UInt  uiTrMode        = pcCU->getTransformIdx( uiAbsPartIdx );
771  UInt  uiSubdiv        = ( uiTrMode > uiTrDepth ? 1 : 0 );
772  UInt  uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()] + 2 - uiFullDepth;
773
774  if( pcCU->getPredictionMode(0) == MODE_INTRA && pcCU->getPartitionSize(0) == SIZE_NxN && uiTrDepth == 0 )
775  {
776    assert( uiSubdiv );
777  }
778  else if( uiLog2TrafoSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
779  {
780    assert( uiSubdiv );
781  }
782  else if( uiLog2TrafoSize == pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
783  {
784    assert( !uiSubdiv );
785  }
786  else if( uiLog2TrafoSize == pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
787  {
788    assert( !uiSubdiv );
789  }
790  else
791  {
792    assert( uiLog2TrafoSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
793    if( bLuma )
794    {
795      m_pcEntropyCoder->encodeTransformSubdivFlag( uiSubdiv, 5 - uiLog2TrafoSize );
796    }
797  }
798 
799  if ( bChroma )
800  {
801    if( uiLog2TrafoSize > 2 )
802    {
803      if( uiTrDepth==0 || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth-1 ) )
804      {
805        m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth );
806      }
807      if( uiTrDepth==0 || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth-1 ) )
808      {
809        m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth );
810      }
811    }
812  }
813
814  if( uiSubdiv )
815  {
816    UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
817    for( UInt uiPart = 0; uiPart < 4; uiPart++ )
818    {
819      xEncSubdivCbfQT( pcCU, uiTrDepth + 1, uiAbsPartIdx + uiPart * uiQPartNum, bLuma, bChroma );
820    }
821    return;
822  }
823 
824  //===== Cbfs =====
825  if( bLuma )
826  {
827    m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA,     uiTrMode );
828  }
829}
830
831Void
832TEncSearch::xEncCoeffQT( TComDataCU*  pcCU,
833                        UInt         uiTrDepth,
834                        UInt         uiAbsPartIdx,
835                        TextType     eTextType,
836                        Bool         bRealCoeff )
837{
838  UInt  uiFullDepth     = pcCU->getDepth(0) + uiTrDepth;
839  UInt  uiTrMode        = pcCU->getTransformIdx( uiAbsPartIdx );
840  UInt  uiSubdiv        = ( uiTrMode > uiTrDepth ? 1 : 0 );
841  UInt  uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()] + 2 - uiFullDepth;
842  UInt  uiChroma        = ( eTextType != TEXT_LUMA ? 1 : 0 );
843 
844  if( uiSubdiv )
845  {
846    UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
847      for( UInt uiPart = 0; uiPart < 4; uiPart++ )
848      {
849        xEncCoeffQT( pcCU, uiTrDepth + 1, uiAbsPartIdx + uiPart * uiQPartNum, eTextType, bRealCoeff );
850      }
851    return;
852  }
853 
854  if( eTextType != TEXT_LUMA && uiLog2TrafoSize == 2 )
855  {
856    assert( uiTrDepth > 0 );
857    uiTrDepth--;
858    UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth ) << 1 );
859    Bool bFirstQ = ( ( uiAbsPartIdx % uiQPDiv ) == 0 );
860    if( !bFirstQ )
861    {
862      return;
863    }
864  }
865 
866  //===== coefficients =====
867  UInt    uiWidth         = pcCU->getWidth  ( 0 ) >> ( uiTrDepth + uiChroma );
868  UInt    uiHeight        = pcCU->getHeight ( 0 ) >> ( uiTrDepth + uiChroma );
869  UInt    uiCoeffOffset   = ( pcCU->getPic()->getMinCUWidth() * pcCU->getPic()->getMinCUHeight() * uiAbsPartIdx ) >> ( uiChroma << 1 );
870  UInt    uiQTLayer       = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrafoSize;
871  TCoeff* pcCoeff         = 0;
872  switch( eTextType )
873  {
874    case TEXT_LUMA:     pcCoeff = ( bRealCoeff ? pcCU->getCoeffY () : m_ppcQTTempCoeffY [uiQTLayer] );  break;
875    case TEXT_CHROMA_U: pcCoeff = ( bRealCoeff ? pcCU->getCoeffCb() : m_ppcQTTempCoeffCb[uiQTLayer] );  break;
876    case TEXT_CHROMA_V: pcCoeff = ( bRealCoeff ? pcCU->getCoeffCr() : m_ppcQTTempCoeffCr[uiQTLayer] );  break;
877    default:            assert(0);
878  }
879  pcCoeff += uiCoeffOffset;
880 
881  m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeff, uiAbsPartIdx, uiWidth, uiHeight, uiFullDepth, eTextType );
882}
883
884
885Void
886TEncSearch::xEncIntraHeader( TComDataCU*  pcCU,
887                            UInt         uiTrDepth,
888                            UInt         uiAbsPartIdx,
889                            Bool         bLuma,
890                            Bool         bChroma )
891{
892  if( bLuma )
893  {
894    // CU header
895    if( uiAbsPartIdx == 0 )
896    {
897      if( !pcCU->getSlice()->isIntra() )
898      {
899        if (pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
900        {
901          m_pcEntropyCoder->encodeCUTransquantBypassFlag( pcCU, 0, true );
902        }
903        m_pcEntropyCoder->encodeSkipFlag( pcCU, 0, true );
904        m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
905      }
906   
907      m_pcEntropyCoder  ->encodePartSize( pcCU, 0, pcCU->getDepth(0), true );
908
909      if (pcCU->isIntra(0) && pcCU->getPartitionSize(0) == SIZE_2Nx2N )
910      {
911        m_pcEntropyCoder->encodeIPCMInfo( pcCU, 0, true );
912
913        if ( pcCU->getIPCMFlag (0))
914        {
915          return;
916        }
917      }
918    }
919    // luma prediction mode
920    if( pcCU->getPartitionSize(0) == SIZE_2Nx2N )
921    {
922      if( uiAbsPartIdx == 0 )
923      {
924        m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, 0 );
925      }
926    }
927    else
928    {
929      UInt uiQNumParts = pcCU->getTotalNumPart() >> 2;
930      if( uiTrDepth == 0 )
931      {
932        assert( uiAbsPartIdx == 0 );
933        for( UInt uiPart = 0; uiPart < 4; uiPart++ )
934        {
935          m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiPart * uiQNumParts );
936        }
937      }
938      else if( ( uiAbsPartIdx % uiQNumParts ) == 0 )
939      {
940        m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiAbsPartIdx );
941      }
942    }
943  }
944  if( bChroma )
945  {
946    // chroma prediction mode
947    if( uiAbsPartIdx == 0 )
948    {
949      m_pcEntropyCoder->encodeIntraDirModeChroma( pcCU, 0, true );
950    }
951  }
952}
953
954
955UInt
956TEncSearch::xGetIntraBitsQT( TComDataCU*  pcCU,
957                            UInt         uiTrDepth,
958                            UInt         uiAbsPartIdx,
959                            Bool         bLuma,
960                            Bool         bChroma,
961                            Bool         bRealCoeff /* just for test */ )
962{
963  m_pcEntropyCoder->resetBits();
964  xEncIntraHeader ( pcCU, uiTrDepth, uiAbsPartIdx, bLuma, bChroma );
965  xEncSubdivCbfQT ( pcCU, uiTrDepth, uiAbsPartIdx, bLuma, bChroma );
966 
967  if( bLuma )
968  {
969    xEncCoeffQT   ( pcCU, uiTrDepth, uiAbsPartIdx, TEXT_LUMA,      bRealCoeff );
970  }
971  if( bChroma )
972  {
973    xEncCoeffQT   ( pcCU, uiTrDepth, uiAbsPartIdx, TEXT_CHROMA_U,  bRealCoeff );
974    xEncCoeffQT   ( pcCU, uiTrDepth, uiAbsPartIdx, TEXT_CHROMA_V,  bRealCoeff );
975  }
976  UInt   uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
977  return uiBits;
978}
979
980UInt
981TEncSearch::xGetIntraBitsQTChroma( TComDataCU*  pcCU,
982                                  UInt         uiTrDepth,
983                                  UInt         uiAbsPartIdx,
984                                  UInt         uiChromaId,
985                                  Bool         bRealCoeff /* just for test */ )
986{
987  m_pcEntropyCoder->resetBits();
988  if( uiChromaId == TEXT_CHROMA_U)
989  {
990    xEncCoeffQT   ( pcCU, uiTrDepth, uiAbsPartIdx, TEXT_CHROMA_U,  bRealCoeff );
991  }
992  else if(uiChromaId == TEXT_CHROMA_V)
993  {
994    xEncCoeffQT   ( pcCU, uiTrDepth, uiAbsPartIdx, TEXT_CHROMA_V,  bRealCoeff );
995  }
996
997  UInt   uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
998  return uiBits;
999}
1000
1001Void
1002TEncSearch::xIntraCodingLumaBlk( TComDataCU* pcCU,
1003                                UInt        uiTrDepth,
1004                                UInt        uiAbsPartIdx,
1005                                TComYuv*    pcOrgYuv, 
1006                                TComYuv*    pcPredYuv, 
1007                                TComYuv*    pcResiYuv, 
1008                                UInt&       ruiDist,
1009                                Int        default0Save1Load2 )
1010{
1011  UInt    uiLumaPredMode    = pcCU     ->getLumaIntraDir     ( uiAbsPartIdx );
1012  UInt    uiFullDepth       = pcCU     ->getDepth   ( 0 )  + uiTrDepth;
1013  UInt    uiWidth           = pcCU     ->getWidth   ( 0 ) >> uiTrDepth;
1014  UInt    uiHeight          = pcCU     ->getHeight  ( 0 ) >> uiTrDepth;
1015  UInt    uiStride          = pcOrgYuv ->getStride  ();
1016  Pel*    piOrg             = pcOrgYuv ->getLumaAddr( uiAbsPartIdx );
1017  Pel*    piPred            = pcPredYuv->getLumaAddr( uiAbsPartIdx );
1018  Pel*    piResi            = pcResiYuv->getLumaAddr( uiAbsPartIdx );
1019  Pel*    piReco            = pcPredYuv->getLumaAddr( uiAbsPartIdx );
1020 
1021  UInt    uiLog2TrSize      = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
1022  UInt    uiQTLayer         = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
1023  UInt    uiNumCoeffPerInc  = pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
1024  TCoeff* pcCoeff           = m_ppcQTTempCoeffY[ uiQTLayer ] + uiNumCoeffPerInc * uiAbsPartIdx;
1025#if ADAPTIVE_QP_SELECTION
1026  Int*    pcArlCoeff        = m_ppcQTTempArlCoeffY[ uiQTLayer ] + uiNumCoeffPerInc * uiAbsPartIdx;
1027#endif
1028  Pel*    piRecQt           = m_pcQTTempTComYuv[ uiQTLayer ].getLumaAddr( uiAbsPartIdx );
1029  UInt    uiRecQtStride     = m_pcQTTempTComYuv[ uiQTLayer ].getStride  ();
1030 
1031  UInt    uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1032  Pel*    piRecIPred        = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
1033  UInt    uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getStride  ();
1034  Bool    useTransformSkip  = pcCU->getTransformSkip(uiAbsPartIdx, TEXT_LUMA);
1035  //===== init availability pattern =====
1036  Bool  bAboveAvail = false;
1037  Bool  bLeftAvail  = false;
1038  if(default0Save1Load2 != 2)
1039  {
1040    pcCU->getPattern()->initPattern   ( pcCU, uiTrDepth, uiAbsPartIdx );
1041    pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, uiTrDepth, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );
1042    //===== get prediction signal =====
1043    predIntraLumaAng( pcCU->getPattern(), uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
1044    // save prediction
1045    if(default0Save1Load2 == 1)
1046    {
1047      Pel*  pPred   = piPred;
1048      Pel*  pPredBuf = m_pSharedPredTransformSkip[0];
1049      Int k = 0;
1050      for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1051      {
1052        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1053        {
1054          pPredBuf[ k ++ ] = pPred[ uiX ];
1055        }
1056        pPred += uiStride;
1057      }
1058    }
1059  }
1060  else 
1061  {
1062    // load prediction
1063    Pel*  pPred   = piPred;
1064    Pel*  pPredBuf = m_pSharedPredTransformSkip[0];
1065    Int k = 0;
1066    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1067    {
1068      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1069      {
1070        pPred[ uiX ] = pPredBuf[ k ++ ];
1071      }
1072      pPred += uiStride;
1073    }
1074  }
1075  //===== get residual signal =====
1076  {
1077    // get residual
1078    Pel*  pOrg    = piOrg;
1079    Pel*  pPred   = piPred;
1080    Pel*  pResi   = piResi;
1081    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1082    {
1083      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1084      {
1085        pResi[ uiX ] = pOrg[ uiX ] - pPred[ uiX ];
1086      }
1087      pOrg  += uiStride;
1088      pResi += uiStride;
1089      pPred += uiStride;
1090    }
1091  }
1092 
1093  //===== transform and quantization =====
1094  //--- init rate estimation arrays for RDOQ ---
1095  if( useTransformSkip? m_pcEncCfg->getUseRDOQTS():m_pcEncCfg->getUseRDOQ())
1096  {
1097    m_pcEntropyCoder->estimateBit( m_pcTrQuant->m_pcEstBitsSbac, uiWidth, uiWidth, TEXT_LUMA );
1098  }
1099  //--- transform and quantization ---
1100  UInt uiAbsSum = 0;
1101  pcCU       ->setTrIdxSubParts ( uiTrDepth, uiAbsPartIdx, uiFullDepth );
1102
1103#if REPN_FORMAT_IN_VPS
1104  m_pcTrQuant->setQPforQuant    ( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getQpBDOffsetY(), 0 );
1105#else
1106  m_pcTrQuant->setQPforQuant    ( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
1107#endif
1108
1109#if RDOQ_CHROMA_LAMBDA
1110  m_pcTrQuant->selectLambda     (TEXT_LUMA); 
1111#endif
1112
1113  m_pcTrQuant->transformNxN     ( pcCU, piResi, uiStride, pcCoeff, 
1114#if ADAPTIVE_QP_SELECTION
1115    pcArlCoeff, 
1116#endif
1117    uiWidth, uiHeight, uiAbsSum, TEXT_LUMA, uiAbsPartIdx,useTransformSkip );
1118 
1119  //--- set coded block flag ---
1120  pcCU->setCbfSubParts          ( ( uiAbsSum ? 1 : 0 ) << uiTrDepth, TEXT_LUMA, uiAbsPartIdx, uiFullDepth );
1121  //--- inverse transform ---
1122  if( uiAbsSum )
1123  {
1124    Int scalingListType = 0 + g_eTTable[(Int)TEXT_LUMA];
1125    assert(scalingListType < SCALING_LIST_NUM);
1126    m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,pcCU->getLumaIntraDir( uiAbsPartIdx ), piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType, useTransformSkip );
1127  }
1128  else
1129  {
1130    Pel* pResi = piResi;
1131    memset( pcCoeff, 0, sizeof( TCoeff ) * uiWidth * uiHeight );
1132    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1133    {
1134      memset( pResi, 0, sizeof( Pel ) * uiWidth );
1135      pResi += uiStride;
1136    }
1137  }
1138 
1139  //===== reconstruction =====
1140  {
1141    Pel* pPred      = piPred;
1142    Pel* pResi      = piResi;
1143    Pel* pReco      = piReco;
1144    Pel* pRecQt     = piRecQt;
1145    Pel* pRecIPred  = piRecIPred;
1146    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1147    {
1148      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1149      {
1150        pReco    [ uiX ] = ClipY( pPred[ uiX ] + pResi[ uiX ] );
1151        pRecQt   [ uiX ] = pReco[ uiX ];
1152        pRecIPred[ uiX ] = pReco[ uiX ];
1153      }
1154      pPred     += uiStride;
1155      pResi     += uiStride;
1156      pReco     += uiStride;
1157      pRecQt    += uiRecQtStride;
1158      pRecIPred += uiRecIPredStride;
1159    }
1160  }
1161 
1162  //===== update distortion =====
1163  ruiDist += m_pcRdCost->getDistPart(g_bitDepthY, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight );
1164}
1165
1166Void
1167TEncSearch::xIntraCodingChromaBlk( TComDataCU* pcCU,
1168                                  UInt        uiTrDepth,
1169                                  UInt        uiAbsPartIdx,
1170                                  TComYuv*    pcOrgYuv, 
1171                                  TComYuv*    pcPredYuv, 
1172                                  TComYuv*    pcResiYuv, 
1173                                  UInt&       ruiDist,
1174                                  UInt        uiChromaId,
1175                                  Int        default0Save1Load2 )
1176{
1177  UInt uiOrgTrDepth = uiTrDepth;
1178  UInt uiFullDepth  = pcCU->getDepth( 0 ) + uiTrDepth;
1179  UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
1180  if( uiLog2TrSize == 2 )
1181  {
1182    assert( uiTrDepth > 0 );
1183    uiTrDepth--;
1184    UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth ) << 1 );
1185    Bool bFirstQ = ( ( uiAbsPartIdx % uiQPDiv ) == 0 );
1186    if( !bFirstQ )
1187    {
1188      return;
1189    }
1190  }
1191 
1192  TextType  eText             = ( uiChromaId > 0 ? TEXT_CHROMA_V : TEXT_CHROMA_U );
1193  UInt      uiChromaPredMode  = pcCU     ->getChromaIntraDir( uiAbsPartIdx );
1194  UInt      uiWidth           = pcCU     ->getWidth   ( 0 ) >> ( uiTrDepth + 1 );
1195  UInt      uiHeight          = pcCU     ->getHeight  ( 0 ) >> ( uiTrDepth + 1 );
1196  UInt      uiStride          = pcOrgYuv ->getCStride ();
1197  Pel*      piOrg             = ( uiChromaId > 0 ? pcOrgYuv ->getCrAddr( uiAbsPartIdx ) : pcOrgYuv ->getCbAddr( uiAbsPartIdx ) );
1198  Pel*      piPred            = ( uiChromaId > 0 ? pcPredYuv->getCrAddr( uiAbsPartIdx ) : pcPredYuv->getCbAddr( uiAbsPartIdx ) );
1199  Pel*      piResi            = ( uiChromaId > 0 ? pcResiYuv->getCrAddr( uiAbsPartIdx ) : pcResiYuv->getCbAddr( uiAbsPartIdx ) );
1200  Pel*      piReco            = ( uiChromaId > 0 ? pcPredYuv->getCrAddr( uiAbsPartIdx ) : pcPredYuv->getCbAddr( uiAbsPartIdx ) );
1201 
1202  UInt      uiQTLayer         = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
1203  UInt      uiNumCoeffPerInc  = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 ) ) >> 2;
1204  TCoeff*   pcCoeff           = ( uiChromaId > 0 ? m_ppcQTTempCoeffCr[ uiQTLayer ] : m_ppcQTTempCoeffCb[ uiQTLayer ] ) + uiNumCoeffPerInc * uiAbsPartIdx;
1205#if ADAPTIVE_QP_SELECTION
1206  Int*      pcArlCoeff        = ( uiChromaId > 0 ? m_ppcQTTempArlCoeffCr[ uiQTLayer ] : m_ppcQTTempArlCoeffCb[ uiQTLayer ] ) + uiNumCoeffPerInc * uiAbsPartIdx;
1207#endif
1208  Pel*      piRecQt           = ( uiChromaId > 0 ? m_pcQTTempTComYuv[ uiQTLayer ].getCrAddr( uiAbsPartIdx ) : m_pcQTTempTComYuv[ uiQTLayer ].getCbAddr( uiAbsPartIdx ) );
1209  UInt      uiRecQtStride     = m_pcQTTempTComYuv[ uiQTLayer ].getCStride();
1210 
1211  UInt      uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1212  Pel*      piRecIPred        = ( uiChromaId > 0 ? pcCU->getPic()->getPicYuvRec()->getCrAddr( pcCU->getAddr(), uiZOrder ) : pcCU->getPic()->getPicYuvRec()->getCbAddr( pcCU->getAddr(), uiZOrder ) );
1213  UInt      uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getCStride();
1214  Bool      useTransformSkipChroma       = pcCU->getTransformSkip(uiAbsPartIdx, eText);
1215  //===== update chroma mode =====
1216  if( uiChromaPredMode == DM_CHROMA_IDX )
1217  {
1218    uiChromaPredMode          = pcCU->getLumaIntraDir( 0 );
1219  }
1220 
1221  //===== init availability pattern =====
1222  Bool  bAboveAvail = false;
1223  Bool  bLeftAvail  = false;
1224  if( default0Save1Load2 != 2 )
1225  {
1226    pcCU->getPattern()->initPattern         ( pcCU, uiTrDepth, uiAbsPartIdx );
1227
1228    pcCU->getPattern()->initAdiPatternChroma( pcCU, uiAbsPartIdx, uiTrDepth, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );
1229    Int*  pPatChroma  = ( uiChromaId > 0 ? pcCU->getPattern()->getAdiCrBuf( uiWidth, uiHeight, m_piYuvExt ) : pcCU->getPattern()->getAdiCbBuf( uiWidth, uiHeight, m_piYuvExt ) );
1230
1231    //===== get prediction signal =====
1232    predIntraChromaAng( pPatChroma, uiChromaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
1233
1234    // save prediction
1235    if( default0Save1Load2 == 1 )
1236    {
1237      Pel*  pPred   = piPred;
1238      Pel*  pPredBuf = m_pSharedPredTransformSkip[1 + uiChromaId];
1239      Int k = 0;
1240      for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1241      {
1242        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1243        {
1244          pPredBuf[ k ++ ] = pPred[ uiX ];
1245        }
1246        pPred += uiStride;
1247      }
1248    }
1249  }
1250  else
1251  {
1252    // load prediction
1253    Pel*  pPred   = piPred;
1254    Pel*  pPredBuf = m_pSharedPredTransformSkip[1 + uiChromaId];
1255    Int k = 0;
1256    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1257    {
1258      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1259      {
1260        pPred[ uiX ] = pPredBuf[ k ++ ];
1261      }
1262      pPred += uiStride;
1263    }
1264  }
1265  //===== get residual signal =====
1266  {
1267    // get residual
1268    Pel*  pOrg    = piOrg;
1269    Pel*  pPred   = piPred;
1270    Pel*  pResi   = piResi;
1271    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1272    {
1273      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1274      {
1275        pResi[ uiX ] = pOrg[ uiX ] - pPred[ uiX ];
1276      }
1277      pOrg  += uiStride;
1278      pResi += uiStride;
1279      pPred += uiStride;
1280    }
1281  }
1282 
1283  //===== transform and quantization =====
1284  {
1285    //--- init rate estimation arrays for RDOQ ---
1286    if( useTransformSkipChroma? m_pcEncCfg->getUseRDOQTS():m_pcEncCfg->getUseRDOQ())
1287    {
1288      m_pcEntropyCoder->estimateBit( m_pcTrQuant->m_pcEstBitsSbac, uiWidth, uiWidth, eText );
1289    }
1290    //--- transform and quantization ---
1291    UInt uiAbsSum = 0;
1292
1293    Int curChromaQpOffset;
1294    if(eText == TEXT_CHROMA_U)
1295    {
1296      curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCbQpOffset() + pcCU->getSlice()->getSliceQpDeltaCb();
1297    }
1298    else
1299    {
1300      curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();
1301    }
1302    m_pcTrQuant->setQPforQuant     ( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
1303
1304#if RDOQ_CHROMA_LAMBDA
1305    m_pcTrQuant->selectLambda(eText);
1306#endif
1307    m_pcTrQuant->transformNxN      ( pcCU, piResi, uiStride, pcCoeff, 
1308#if ADAPTIVE_QP_SELECTION
1309                                     pcArlCoeff, 
1310#endif
1311                                     uiWidth, uiHeight, uiAbsSum, eText, uiAbsPartIdx, useTransformSkipChroma );
1312    //--- set coded block flag ---
1313    pcCU->setCbfSubParts           ( ( uiAbsSum ? 1 : 0 ) << uiOrgTrDepth, eText, uiAbsPartIdx, pcCU->getDepth(0) + uiTrDepth );
1314    //--- inverse transform ---
1315    if( uiAbsSum )
1316    {
1317      Int scalingListType = 0 + g_eTTable[(Int)eText];
1318      assert(scalingListType < SCALING_LIST_NUM);
1319      m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA, REG_DCT, piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType, useTransformSkipChroma );
1320    }
1321    else
1322    {
1323      Pel* pResi = piResi;
1324      memset( pcCoeff, 0, sizeof( TCoeff ) * uiWidth * uiHeight );
1325      for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1326      {
1327        memset( pResi, 0, sizeof( Pel ) * uiWidth );
1328        pResi += uiStride;
1329      }
1330    }
1331  }
1332 
1333  //===== reconstruction =====
1334  {
1335    Pel* pPred      = piPred;
1336    Pel* pResi      = piResi;
1337    Pel* pReco      = piReco;
1338    Pel* pRecQt     = piRecQt;
1339    Pel* pRecIPred  = piRecIPred;
1340    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1341    {
1342      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1343      {
1344        pReco    [ uiX ] = ClipC( pPred[ uiX ] + pResi[ uiX ] );
1345        pRecQt   [ uiX ] = pReco[ uiX ];
1346        pRecIPred[ uiX ] = pReco[ uiX ];
1347      }
1348      pPred     += uiStride;
1349      pResi     += uiStride;
1350      pReco     += uiStride;
1351      pRecQt    += uiRecQtStride;
1352      pRecIPred += uiRecIPredStride;
1353    }
1354  }
1355 
1356  //===== update distortion =====
1357  ruiDist += m_pcRdCost->getDistPart(g_bitDepthC, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight, eText );
1358}
1359
1360
1361
1362Void
1363TEncSearch::xRecurIntraCodingQT( TComDataCU*  pcCU, 
1364                                UInt         uiTrDepth,
1365                                UInt         uiAbsPartIdx, 
1366                                Bool         bLumaOnly,
1367                                TComYuv*     pcOrgYuv, 
1368                                TComYuv*     pcPredYuv, 
1369                                TComYuv*     pcResiYuv, 
1370                                UInt&        ruiDistY,
1371                                UInt&        ruiDistC,
1372#if HHI_RQT_INTRA_SPEEDUP
1373                                Bool         bCheckFirst,
1374#endif
1375                                Double&      dRDCost )
1376{
1377  UInt    uiFullDepth   = pcCU->getDepth( 0 ) +  uiTrDepth;
1378  UInt    uiLog2TrSize  = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
1379  Bool    bCheckFull    = ( uiLog2TrSize  <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() );
1380  Bool    bCheckSplit   = ( uiLog2TrSize  >  pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
1381 
1382#if HHI_RQT_INTRA_SPEEDUP
1383  Int maxTuSize = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize();
1384  Int isIntraSlice = (pcCU->getSlice()->getSliceType() == I_SLICE);
1385  // don't check split if TU size is less or equal to max TU size
1386  Bool noSplitIntraMaxTuSize = bCheckFull;
1387  if(m_pcEncCfg->getRDpenalty() && ! isIntraSlice)
1388  {
1389    // in addition don't check split if TU size is less or equal to 16x16 TU size for non-intra slice
1390    noSplitIntraMaxTuSize = ( uiLog2TrSize  <= min(maxTuSize,4) );
1391
1392    // if maximum RD-penalty don't check TU size 32x32
1393    if(m_pcEncCfg->getRDpenalty()==2)
1394    {
1395      bCheckFull    = ( uiLog2TrSize  <= min(maxTuSize,4));
1396    }
1397  }
1398  if( bCheckFirst && noSplitIntraMaxTuSize )
1399  {
1400    bCheckSplit = false;
1401  }
1402#else
1403  Int maxTuSize = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize();
1404  Int isIntraSlice = (pcCU->getSlice()->getSliceType() == I_SLICE);
1405  // if maximum RD-penalty don't check TU size 32x32
1406  if((m_pcEncCfg->getRDpenalty()==2)  && !isIntraSlice)
1407  {
1408    bCheckFull    = ( uiLog2TrSize  <= min(maxTuSize,4));
1409  }
1410#endif
1411  Double  dSingleCost   = MAX_DOUBLE;
1412  UInt    uiSingleDistY = 0;
1413  UInt    uiSingleDistC = 0;
1414  UInt    uiSingleCbfY  = 0;
1415  UInt    uiSingleCbfU  = 0;
1416  UInt    uiSingleCbfV  = 0;
1417  Bool    checkTransformSkip  = pcCU->getSlice()->getPPS()->getUseTransformSkip();
1418  UInt    widthTransformSkip  = pcCU->getWidth ( 0 ) >> uiTrDepth;
1419  UInt    heightTransformSkip = pcCU->getHeight( 0 ) >> uiTrDepth;
1420  Int     bestModeId    = 0;
1421  Int     bestModeIdUV[2] = {0, 0};
1422  checkTransformSkip         &= (widthTransformSkip == 4 && heightTransformSkip == 4);
1423  checkTransformSkip         &= (!pcCU->getCUTransquantBypass(0));
1424  if ( m_pcEncCfg->getUseTransformSkipFast() )
1425  {
1426    checkTransformSkip       &= (pcCU->getPartitionSize(uiAbsPartIdx)==SIZE_NxN);
1427  }
1428  if( bCheckFull )
1429  {
1430    if(checkTransformSkip == true)
1431    {
1432      //----- store original entropy coding status -----
1433      m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
1434
1435      UInt   singleDistYTmp     = 0;
1436      UInt   singleDistCTmp     = 0;
1437      UInt   singleCbfYTmp      = 0;
1438      UInt   singleCbfUTmp      = 0;
1439      UInt   singleCbfVTmp      = 0;
1440      Double singleCostTmp      = 0;
1441      Int    default0Save1Load2 = 0;
1442      Int    firstCheckId       = 0;
1443
1444      UInt   uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + (uiTrDepth - 1) ) << 1 );
1445      Bool   bFirstQ = ( ( uiAbsPartIdx % uiQPDiv ) == 0 );
1446
1447      for(Int modeId = firstCheckId; modeId < 2; modeId ++)
1448      {
1449        singleDistYTmp = 0;
1450        singleDistCTmp = 0;
1451        pcCU ->setTransformSkipSubParts ( modeId, TEXT_LUMA, uiAbsPartIdx, uiFullDepth ); 
1452        if(modeId == firstCheckId)
1453        {
1454          default0Save1Load2 = 1;
1455        }
1456        else
1457        {
1458          default0Save1Load2 = 2;
1459        }
1460        //----- code luma block with given intra prediction mode and store Cbf-----
1461        xIntraCodingLumaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, singleDistYTmp,default0Save1Load2); 
1462        singleCbfYTmp = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrDepth );
1463        //----- code chroma blocks with given intra prediction mode and store Cbf-----
1464        if( !bLumaOnly )
1465        {
1466          if(bFirstQ)
1467          {
1468            pcCU ->setTransformSkipSubParts ( modeId, TEXT_CHROMA_U, uiAbsPartIdx, uiFullDepth); 
1469            pcCU ->setTransformSkipSubParts ( modeId, TEXT_CHROMA_V, uiAbsPartIdx, uiFullDepth); 
1470          }
1471          xIntraCodingChromaBlk ( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, singleDistCTmp, 0, default0Save1Load2); 
1472          xIntraCodingChromaBlk ( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, singleDistCTmp, 1, default0Save1Load2); 
1473          singleCbfUTmp = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth );
1474          singleCbfVTmp = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth );
1475        }
1476        //----- determine rate and r-d cost -----
1477        if(modeId == 1 && singleCbfYTmp == 0)
1478        {
1479          //In order not to code TS flag when cbf is zero, the case for TS with cbf being zero is forbidden.
1480          singleCostTmp = MAX_DOUBLE; 
1481        }
1482        else
1483        {
1484          UInt uiSingleBits = xGetIntraBitsQT( pcCU, uiTrDepth, uiAbsPartIdx, true, !bLumaOnly, false );
1485          singleCostTmp     = m_pcRdCost->calcRdCost( uiSingleBits, singleDistYTmp + singleDistCTmp );
1486        }
1487
1488        if(singleCostTmp < dSingleCost)
1489        {
1490          dSingleCost   = singleCostTmp;
1491          uiSingleDistY = singleDistYTmp;
1492          uiSingleDistC = singleDistCTmp;
1493          uiSingleCbfY  = singleCbfYTmp;
1494          uiSingleCbfU  = singleCbfUTmp;
1495          uiSingleCbfV  = singleCbfVTmp;
1496          bestModeId    = modeId;
1497          if(bestModeId == firstCheckId)
1498          {
1499            xStoreIntraResultQT(pcCU, uiTrDepth, uiAbsPartIdx,bLumaOnly );
1500            m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
1501          }
1502        }
1503        if(modeId == firstCheckId)
1504        {
1505          m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
1506        }
1507      }
1508
1509      pcCU ->setTransformSkipSubParts ( bestModeId, TEXT_LUMA, uiAbsPartIdx, uiFullDepth ); 
1510
1511      if(bestModeId == firstCheckId)
1512      {
1513        xLoadIntraResultQT(pcCU, uiTrDepth, uiAbsPartIdx,bLumaOnly );
1514        pcCU->setCbfSubParts  ( uiSingleCbfY << uiTrDepth, TEXT_LUMA, uiAbsPartIdx, uiFullDepth );
1515        if( !bLumaOnly )
1516        {
1517          if(bFirstQ)
1518          {
1519            pcCU->setCbfSubParts( uiSingleCbfU << uiTrDepth, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth( 0 ) + uiTrDepth - 1 );
1520            pcCU->setCbfSubParts( uiSingleCbfV << uiTrDepth, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth( 0 ) + uiTrDepth - 1 );
1521          }
1522        }
1523        m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
1524      } 
1525
1526      if( !bLumaOnly )
1527      {
1528        bestModeIdUV[0] = bestModeIdUV[1] = bestModeId;
1529        if(bFirstQ && bestModeId == 1)
1530        {
1531          //In order not to code TS flag when cbf is zero, the case for TS with cbf being zero is forbidden.
1532          if(uiSingleCbfU == 0)
1533          {
1534            pcCU ->setTransformSkipSubParts ( 0, TEXT_CHROMA_U, uiAbsPartIdx, uiFullDepth); 
1535            bestModeIdUV[0] = 0;
1536          }
1537          if(uiSingleCbfV == 0)
1538          {
1539            pcCU ->setTransformSkipSubParts ( 0, TEXT_CHROMA_V, uiAbsPartIdx, uiFullDepth); 
1540            bestModeIdUV[1] = 0;
1541          }
1542        }
1543      }
1544    }
1545    else
1546    {
1547      pcCU ->setTransformSkipSubParts ( 0, TEXT_LUMA, uiAbsPartIdx, uiFullDepth ); 
1548      //----- store original entropy coding status -----
1549      if( bCheckSplit )
1550      {
1551        m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
1552      }
1553      //----- code luma block with given intra prediction mode and store Cbf-----
1554      dSingleCost   = 0.0;
1555      xIntraCodingLumaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, uiSingleDistY ); 
1556      if( bCheckSplit )
1557      {
1558        uiSingleCbfY = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrDepth );
1559      }
1560      //----- code chroma blocks with given intra prediction mode and store Cbf-----
1561      if( !bLumaOnly )
1562      {
1563        pcCU ->setTransformSkipSubParts ( 0, TEXT_CHROMA_U, uiAbsPartIdx, uiFullDepth ); 
1564        pcCU ->setTransformSkipSubParts ( 0, TEXT_CHROMA_V, uiAbsPartIdx, uiFullDepth ); 
1565        xIntraCodingChromaBlk ( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, uiSingleDistC, 0 ); 
1566        xIntraCodingChromaBlk ( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, uiSingleDistC, 1 ); 
1567        if( bCheckSplit )
1568        {
1569          uiSingleCbfU = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth );
1570          uiSingleCbfV = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth );
1571        }
1572      }
1573      //----- determine rate and r-d cost -----
1574      UInt uiSingleBits = xGetIntraBitsQT( pcCU, uiTrDepth, uiAbsPartIdx, true, !bLumaOnly, false );
1575      if(m_pcEncCfg->getRDpenalty() && (uiLog2TrSize==5) && !isIntraSlice)
1576      {
1577        uiSingleBits=uiSingleBits*4; 
1578      }
1579      dSingleCost       = m_pcRdCost->calcRdCost( uiSingleBits, uiSingleDistY + uiSingleDistC );
1580    }
1581  }
1582 
1583  if( bCheckSplit )
1584  {
1585    //----- store full entropy coding status, load original entropy coding status -----
1586    if( bCheckFull )
1587    {
1588      m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_TEST ] );
1589      m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
1590    }
1591    else
1592    {
1593      m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
1594    }
1595
1596    //----- code splitted block -----
1597    Double  dSplitCost      = 0.0;
1598    UInt    uiSplitDistY    = 0;
1599    UInt    uiSplitDistC    = 0;
1600    UInt    uiQPartsDiv     = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
1601    UInt    uiAbsPartIdxSub = uiAbsPartIdx;
1602
1603    UInt    uiSplitCbfY = 0;
1604    UInt    uiSplitCbfU = 0;
1605    UInt    uiSplitCbfV = 0;
1606
1607    for( UInt uiPart = 0; uiPart < 4; uiPart++, uiAbsPartIdxSub += uiQPartsDiv )
1608    {
1609#if HHI_RQT_INTRA_SPEEDUP
1610      xRecurIntraCodingQT( pcCU, uiTrDepth + 1, uiAbsPartIdxSub, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiSplitDistY, uiSplitDistC, bCheckFirst, dSplitCost );
1611#else
1612      xRecurIntraCodingQT( pcCU, uiTrDepth + 1, uiAbsPartIdxSub, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiSplitDistY, uiSplitDistC, dSplitCost );
1613#endif
1614
1615      uiSplitCbfY |= pcCU->getCbf( uiAbsPartIdxSub, TEXT_LUMA, uiTrDepth + 1 );
1616      if(!bLumaOnly)
1617      {
1618        uiSplitCbfU |= pcCU->getCbf( uiAbsPartIdxSub, TEXT_CHROMA_U, uiTrDepth + 1 );
1619        uiSplitCbfV |= pcCU->getCbf( uiAbsPartIdxSub, TEXT_CHROMA_V, uiTrDepth + 1 );
1620      }
1621    }
1622
1623    for( UInt uiOffs = 0; uiOffs < 4 * uiQPartsDiv; uiOffs++ )
1624    {
1625      pcCU->getCbf( TEXT_LUMA )[ uiAbsPartIdx + uiOffs ] |= ( uiSplitCbfY << uiTrDepth );
1626    }
1627    if( !bLumaOnly )
1628    {
1629      for( UInt uiOffs = 0; uiOffs < 4 * uiQPartsDiv; uiOffs++ )
1630      {
1631        pcCU->getCbf( TEXT_CHROMA_U )[ uiAbsPartIdx + uiOffs ] |= ( uiSplitCbfU << uiTrDepth );
1632        pcCU->getCbf( TEXT_CHROMA_V )[ uiAbsPartIdx + uiOffs ] |= ( uiSplitCbfV << uiTrDepth );
1633      }
1634    }
1635    //----- restore context states -----
1636    m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
1637
1638    //----- determine rate and r-d cost -----
1639    UInt uiSplitBits = xGetIntraBitsQT( pcCU, uiTrDepth, uiAbsPartIdx, true, !bLumaOnly, false );
1640    dSplitCost       = m_pcRdCost->calcRdCost( uiSplitBits, uiSplitDistY + uiSplitDistC );
1641   
1642    //===== compare and set best =====
1643    if( dSplitCost < dSingleCost )
1644    {
1645      //--- update cost ---
1646      ruiDistY += uiSplitDistY;
1647      ruiDistC += uiSplitDistC;
1648      dRDCost  += dSplitCost;
1649      return;
1650    }
1651    //----- set entropy coding status -----
1652    m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_TEST ] );
1653
1654    //--- set transform index and Cbf values ---
1655    pcCU->setTrIdxSubParts( uiTrDepth, uiAbsPartIdx, uiFullDepth );
1656    pcCU->setCbfSubParts  ( uiSingleCbfY << uiTrDepth, TEXT_LUMA, uiAbsPartIdx, uiFullDepth );
1657    pcCU ->setTransformSkipSubParts  ( bestModeId, TEXT_LUMA, uiAbsPartIdx, uiFullDepth ); 
1658    if( !bLumaOnly )
1659    {
1660      pcCU->setCbfSubParts( uiSingleCbfU << uiTrDepth, TEXT_CHROMA_U, uiAbsPartIdx, uiFullDepth );
1661      pcCU->setCbfSubParts( uiSingleCbfV << uiTrDepth, TEXT_CHROMA_V, uiAbsPartIdx, uiFullDepth );
1662      pcCU->setTransformSkipSubParts ( bestModeIdUV[0], TEXT_CHROMA_U, uiAbsPartIdx, uiFullDepth); 
1663      pcCU->setTransformSkipSubParts ( bestModeIdUV[1], TEXT_CHROMA_V, uiAbsPartIdx, uiFullDepth); 
1664    }
1665   
1666    //--- set reconstruction for next intra prediction blocks ---
1667    UInt  uiWidth     = pcCU->getWidth ( 0 ) >> uiTrDepth;
1668    UInt  uiHeight    = pcCU->getHeight( 0 ) >> uiTrDepth;
1669    UInt  uiQTLayer   = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
1670    UInt  uiZOrder    = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1671    Pel*  piSrc       = m_pcQTTempTComYuv[ uiQTLayer ].getLumaAddr( uiAbsPartIdx );
1672    UInt  uiSrcStride = m_pcQTTempTComYuv[ uiQTLayer ].getStride  ();
1673    Pel*  piDes       = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
1674    UInt  uiDesStride = pcCU->getPic()->getPicYuvRec()->getStride  ();
1675    for( UInt uiY = 0; uiY < uiHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
1676    {
1677      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1678      {
1679        piDes[ uiX ] = piSrc[ uiX ];
1680      }
1681    }
1682    if( !bLumaOnly )
1683    {
1684      uiWidth   >>= 1;
1685      uiHeight  >>= 1;
1686      piSrc       = m_pcQTTempTComYuv[ uiQTLayer ].getCbAddr  ( uiAbsPartIdx );
1687      uiSrcStride = m_pcQTTempTComYuv[ uiQTLayer ].getCStride ();
1688      piDes       = pcCU->getPic()->getPicYuvRec()->getCbAddr ( pcCU->getAddr(), uiZOrder );
1689      uiDesStride = pcCU->getPic()->getPicYuvRec()->getCStride();
1690      for( UInt uiY = 0; uiY < uiHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
1691      {
1692        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1693        {
1694          piDes[ uiX ] = piSrc[ uiX ];
1695        }
1696      }
1697      piSrc       = m_pcQTTempTComYuv[ uiQTLayer ].getCrAddr  ( uiAbsPartIdx );
1698      piDes       = pcCU->getPic()->getPicYuvRec()->getCrAddr ( pcCU->getAddr(), uiZOrder );
1699      for( UInt uiY = 0; uiY < uiHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
1700      {
1701        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1702        {
1703          piDes[ uiX ] = piSrc[ uiX ];
1704        }
1705      }
1706    }
1707  }
1708  ruiDistY += uiSingleDistY;
1709  ruiDistC += uiSingleDistC;
1710  dRDCost  += dSingleCost;
1711}
1712
1713
1714Void
1715TEncSearch::xSetIntraResultQT( TComDataCU* pcCU,
1716                              UInt        uiTrDepth,
1717                              UInt        uiAbsPartIdx,
1718                              Bool        bLumaOnly,
1719                              TComYuv*    pcRecoYuv )
1720{
1721  UInt uiFullDepth  = pcCU->getDepth(0) + uiTrDepth;
1722  UInt uiTrMode     = pcCU->getTransformIdx( uiAbsPartIdx );
1723  if(  uiTrMode == uiTrDepth )
1724  {
1725    UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
1726    UInt uiQTLayer    = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
1727   
1728    Bool bSkipChroma  = false;
1729    Bool bChromaSame  = false;
1730    if( !bLumaOnly && uiLog2TrSize == 2 )
1731    {
1732      assert( uiTrDepth > 0 );
1733      UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth - 1 ) << 1 );
1734      bSkipChroma  = ( ( uiAbsPartIdx % uiQPDiv ) != 0 );
1735      bChromaSame  = true;
1736    }
1737   
1738    //===== copy transform coefficients =====
1739    UInt uiNumCoeffY    = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( uiFullDepth << 1 );
1740    UInt uiNumCoeffIncY = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
1741    TCoeff* pcCoeffSrcY = m_ppcQTTempCoeffY [ uiQTLayer ] + ( uiNumCoeffIncY * uiAbsPartIdx );
1742    TCoeff* pcCoeffDstY = pcCU->getCoeffY ()              + ( uiNumCoeffIncY * uiAbsPartIdx );
1743    ::memcpy( pcCoeffDstY, pcCoeffSrcY, sizeof( TCoeff ) * uiNumCoeffY );
1744#if ADAPTIVE_QP_SELECTION
1745    Int* pcArlCoeffSrcY = m_ppcQTTempArlCoeffY [ uiQTLayer ] + ( uiNumCoeffIncY * uiAbsPartIdx );
1746    Int* pcArlCoeffDstY = pcCU->getArlCoeffY ()              + ( uiNumCoeffIncY * uiAbsPartIdx );
1747    ::memcpy( pcArlCoeffDstY, pcArlCoeffSrcY, sizeof( Int ) * uiNumCoeffY );
1748#endif
1749    if( !bLumaOnly && !bSkipChroma )
1750    {
1751      UInt uiNumCoeffC    = ( bChromaSame ? uiNumCoeffY    : uiNumCoeffY    >> 2 );
1752      UInt uiNumCoeffIncC = uiNumCoeffIncY >> 2;
1753      TCoeff* pcCoeffSrcU = m_ppcQTTempCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1754      TCoeff* pcCoeffSrcV = m_ppcQTTempCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1755      TCoeff* pcCoeffDstU = pcCU->getCoeffCb()              + ( uiNumCoeffIncC * uiAbsPartIdx );
1756      TCoeff* pcCoeffDstV = pcCU->getCoeffCr()              + ( uiNumCoeffIncC * uiAbsPartIdx );
1757      ::memcpy( pcCoeffDstU, pcCoeffSrcU, sizeof( TCoeff ) * uiNumCoeffC );
1758      ::memcpy( pcCoeffDstV, pcCoeffSrcV, sizeof( TCoeff ) * uiNumCoeffC );
1759#if ADAPTIVE_QP_SELECTION
1760      Int* pcArlCoeffSrcU = m_ppcQTTempArlCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1761      Int* pcArlCoeffSrcV = m_ppcQTTempArlCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1762      Int* pcArlCoeffDstU = pcCU->getArlCoeffCb()              + ( uiNumCoeffIncC * uiAbsPartIdx );
1763      Int* pcArlCoeffDstV = pcCU->getArlCoeffCr()              + ( uiNumCoeffIncC * uiAbsPartIdx );
1764      ::memcpy( pcArlCoeffDstU, pcArlCoeffSrcU, sizeof( Int ) * uiNumCoeffC );
1765      ::memcpy( pcArlCoeffDstV, pcArlCoeffSrcV, sizeof( Int ) * uiNumCoeffC );
1766#endif
1767    }
1768   
1769    //===== copy reconstruction =====
1770    m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartLuma( pcRecoYuv, uiAbsPartIdx, 1 << uiLog2TrSize, 1 << uiLog2TrSize );
1771    if( !bLumaOnly && !bSkipChroma )
1772    {
1773      UInt uiLog2TrSizeChroma = ( bChromaSame ? uiLog2TrSize : uiLog2TrSize - 1 );
1774      m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartChroma( pcRecoYuv, uiAbsPartIdx, 1 << uiLog2TrSizeChroma, 1 << uiLog2TrSizeChroma );
1775    }
1776  }
1777  else
1778  {
1779    UInt uiNumQPart  = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
1780    for( UInt uiPart = 0; uiPart < 4; uiPart++ )
1781    {
1782      xSetIntraResultQT( pcCU, uiTrDepth + 1, uiAbsPartIdx + uiPart * uiNumQPart, bLumaOnly, pcRecoYuv );
1783    }
1784  }
1785}
1786
1787Void
1788TEncSearch::xStoreIntraResultQT( TComDataCU* pcCU,
1789                                UInt        uiTrDepth,
1790                                UInt        uiAbsPartIdx,
1791                                Bool        bLumaOnly )
1792{
1793  UInt uiFullDepth  = pcCU->getDepth(0) + uiTrDepth;
1794  UInt uiTrMode     = pcCU->getTransformIdx( uiAbsPartIdx );
1795  assert(  uiTrMode == uiTrDepth );
1796  UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
1797  UInt uiQTLayer    = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
1798
1799  Bool bSkipChroma  = false;
1800  Bool bChromaSame  = false;
1801  if( !bLumaOnly && uiLog2TrSize == 2 )
1802  {
1803    assert( uiTrDepth > 0 );
1804    UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth - 1 ) << 1 );
1805    bSkipChroma  = ( ( uiAbsPartIdx % uiQPDiv ) != 0 );
1806    bChromaSame  = true;
1807  }
1808
1809  //===== copy transform coefficients =====
1810  UInt uiNumCoeffY    = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( uiFullDepth << 1 );
1811  UInt uiNumCoeffIncY = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
1812  TCoeff* pcCoeffSrcY = m_ppcQTTempCoeffY [ uiQTLayer ] + ( uiNumCoeffIncY * uiAbsPartIdx );
1813  TCoeff* pcCoeffDstY = m_pcQTTempTUCoeffY;
1814
1815  ::memcpy( pcCoeffDstY, pcCoeffSrcY, sizeof( TCoeff ) * uiNumCoeffY );
1816#if ADAPTIVE_QP_SELECTION
1817  Int* pcArlCoeffSrcY = m_ppcQTTempArlCoeffY [ uiQTLayer ] + ( uiNumCoeffIncY * uiAbsPartIdx );
1818  Int* pcArlCoeffDstY = m_ppcQTTempTUArlCoeffY;
1819  ::memcpy( pcArlCoeffDstY, pcArlCoeffSrcY, sizeof( Int ) * uiNumCoeffY );
1820#endif
1821  if( !bLumaOnly && !bSkipChroma )
1822  {
1823    UInt uiNumCoeffC    = ( bChromaSame ? uiNumCoeffY    : uiNumCoeffY    >> 2 );
1824    UInt uiNumCoeffIncC = uiNumCoeffIncY >> 2;
1825    TCoeff* pcCoeffSrcU = m_ppcQTTempCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1826    TCoeff* pcCoeffSrcV = m_ppcQTTempCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1827    TCoeff* pcCoeffDstU = m_pcQTTempTUCoeffCb;
1828    TCoeff* pcCoeffDstV = m_pcQTTempTUCoeffCr;
1829    ::memcpy( pcCoeffDstU, pcCoeffSrcU, sizeof( TCoeff ) * uiNumCoeffC );
1830    ::memcpy( pcCoeffDstV, pcCoeffSrcV, sizeof( TCoeff ) * uiNumCoeffC );
1831#if ADAPTIVE_QP_SELECTION
1832    Int* pcArlCoeffSrcU = m_ppcQTTempArlCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1833    Int* pcArlCoeffSrcV = m_ppcQTTempArlCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1834    Int* pcArlCoeffDstU = m_ppcQTTempTUArlCoeffCb;
1835    Int* pcArlCoeffDstV = m_ppcQTTempTUArlCoeffCr;
1836    ::memcpy( pcArlCoeffDstU, pcArlCoeffSrcU, sizeof( Int ) * uiNumCoeffC );
1837    ::memcpy( pcArlCoeffDstV, pcArlCoeffSrcV, sizeof( Int ) * uiNumCoeffC );
1838#endif
1839  }
1840
1841  //===== copy reconstruction =====
1842  m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartLuma( &m_pcQTTempTransformSkipTComYuv, uiAbsPartIdx, 1 << uiLog2TrSize, 1 << uiLog2TrSize );
1843
1844  if( !bLumaOnly && !bSkipChroma )
1845  {
1846    UInt uiLog2TrSizeChroma = ( bChromaSame ? uiLog2TrSize : uiLog2TrSize - 1 );
1847    m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartChroma( &m_pcQTTempTransformSkipTComYuv, uiAbsPartIdx, 1 << uiLog2TrSizeChroma, 1 << uiLog2TrSizeChroma );
1848  }
1849}
1850
1851Void
1852TEncSearch::xLoadIntraResultQT( TComDataCU* pcCU,
1853                               UInt        uiTrDepth,
1854                               UInt        uiAbsPartIdx,
1855                               Bool        bLumaOnly )
1856{
1857  UInt uiFullDepth  = pcCU->getDepth(0) + uiTrDepth;
1858  UInt uiTrMode     = pcCU->getTransformIdx( uiAbsPartIdx );
1859  assert(  uiTrMode == uiTrDepth );
1860  UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
1861  UInt uiQTLayer    = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
1862
1863  Bool bSkipChroma  = false;
1864  Bool bChromaSame  = false;
1865  if( !bLumaOnly && uiLog2TrSize == 2 )
1866  {
1867    assert( uiTrDepth > 0 );
1868    UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth - 1 ) << 1 );
1869    bSkipChroma  = ( ( uiAbsPartIdx % uiQPDiv ) != 0 );
1870    bChromaSame  = true;
1871  }
1872
1873  //===== copy transform coefficients =====
1874  UInt uiNumCoeffY    = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( uiFullDepth << 1 );
1875  UInt uiNumCoeffIncY = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
1876  TCoeff* pcCoeffDstY = m_ppcQTTempCoeffY [ uiQTLayer ] + ( uiNumCoeffIncY * uiAbsPartIdx );
1877  TCoeff* pcCoeffSrcY = m_pcQTTempTUCoeffY;
1878
1879  ::memcpy( pcCoeffDstY, pcCoeffSrcY, sizeof( TCoeff ) * uiNumCoeffY );
1880#if ADAPTIVE_QP_SELECTION
1881  Int* pcArlCoeffDstY = m_ppcQTTempArlCoeffY [ uiQTLayer ] + ( uiNumCoeffIncY * uiAbsPartIdx );
1882  Int* pcArlCoeffSrcY = m_ppcQTTempTUArlCoeffY;
1883  ::memcpy( pcArlCoeffDstY, pcArlCoeffSrcY, sizeof( Int ) * uiNumCoeffY );
1884#endif
1885  if( !bLumaOnly && !bSkipChroma )
1886  {
1887    UInt uiNumCoeffC    = ( bChromaSame ? uiNumCoeffY    : uiNumCoeffY    >> 2 );
1888    UInt uiNumCoeffIncC = uiNumCoeffIncY >> 2;
1889    TCoeff* pcCoeffDstU = m_ppcQTTempCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1890    TCoeff* pcCoeffDstV = m_ppcQTTempCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1891    TCoeff* pcCoeffSrcU = m_pcQTTempTUCoeffCb;
1892    TCoeff* pcCoeffSrcV = m_pcQTTempTUCoeffCr;
1893    ::memcpy( pcCoeffDstU, pcCoeffSrcU, sizeof( TCoeff ) * uiNumCoeffC );
1894    ::memcpy( pcCoeffDstV, pcCoeffSrcV, sizeof( TCoeff ) * uiNumCoeffC );
1895#if ADAPTIVE_QP_SELECTION
1896    Int* pcArlCoeffDstU = m_ppcQTTempArlCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1897    Int* pcArlCoeffDstV = m_ppcQTTempArlCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
1898    Int* pcArlCoeffSrcU = m_ppcQTTempTUArlCoeffCb;
1899    Int* pcArlCoeffSrcV = m_ppcQTTempTUArlCoeffCr;
1900    ::memcpy( pcArlCoeffDstU, pcArlCoeffSrcU, sizeof( Int ) * uiNumCoeffC );
1901    ::memcpy( pcArlCoeffDstV, pcArlCoeffSrcV, sizeof( Int ) * uiNumCoeffC );
1902#endif
1903  }
1904
1905  //===== copy reconstruction =====
1906  m_pcQTTempTransformSkipTComYuv.copyPartToPartLuma( &m_pcQTTempTComYuv[ uiQTLayer ] , uiAbsPartIdx, 1 << uiLog2TrSize, 1 << uiLog2TrSize );
1907
1908  if( !bLumaOnly && !bSkipChroma )
1909  {
1910    UInt uiLog2TrSizeChroma = ( bChromaSame ? uiLog2TrSize : uiLog2TrSize - 1 );
1911    m_pcQTTempTransformSkipTComYuv.copyPartToPartChroma( &m_pcQTTempTComYuv[ uiQTLayer ], uiAbsPartIdx, 1 << uiLog2TrSizeChroma, 1 << uiLog2TrSizeChroma );
1912  }
1913
1914  UInt    uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1915  Pel*    piRecIPred        = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
1916  UInt    uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getStride  ();
1917  Pel*    piRecQt           = m_pcQTTempTComYuv[ uiQTLayer ].getLumaAddr( uiAbsPartIdx );
1918  UInt    uiRecQtStride     = m_pcQTTempTComYuv[ uiQTLayer ].getStride  ();
1919  UInt    uiWidth           = pcCU     ->getWidth   ( 0 ) >> uiTrDepth;
1920  UInt    uiHeight          = pcCU     ->getHeight  ( 0 ) >> uiTrDepth;
1921  Pel* pRecQt     = piRecQt;
1922  Pel* pRecIPred  = piRecIPred;
1923  for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1924  {
1925    for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1926    {
1927      pRecIPred[ uiX ] = pRecQt   [ uiX ];
1928    }
1929    pRecQt    += uiRecQtStride;
1930    pRecIPred += uiRecIPredStride;
1931  }
1932
1933  if( !bLumaOnly && !bSkipChroma )
1934  {
1935    piRecIPred = pcCU->getPic()->getPicYuvRec()->getCbAddr( pcCU->getAddr(), uiZOrder );
1936    piRecQt    = m_pcQTTempTComYuv[ uiQTLayer ].getCbAddr( uiAbsPartIdx );
1937    pRecQt     = piRecQt;
1938    pRecIPred  = piRecIPred;
1939    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1940    {
1941      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1942      {
1943        pRecIPred[ uiX ] = pRecQt[ uiX ];
1944      }
1945      pRecQt    += uiRecQtStride;
1946      pRecIPred += uiRecIPredStride;
1947    }
1948
1949    piRecIPred = pcCU->getPic()->getPicYuvRec()->getCrAddr( pcCU->getAddr(), uiZOrder );
1950    piRecQt    = m_pcQTTempTComYuv[ uiQTLayer ].getCrAddr( uiAbsPartIdx );
1951    pRecQt     = piRecQt;
1952    pRecIPred  = piRecIPred;
1953    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1954    {
1955      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1956      {
1957        pRecIPred[ uiX ] = pRecQt[ uiX ];
1958      }
1959      pRecQt    += uiRecQtStride;
1960      pRecIPred += uiRecIPredStride;
1961    }
1962  }
1963}
1964
1965Void
1966TEncSearch::xStoreIntraResultChromaQT( TComDataCU* pcCU,
1967                                      UInt        uiTrDepth,
1968                                      UInt        uiAbsPartIdx,
1969                                      UInt        stateU0V1Both2 )
1970{
1971  UInt uiFullDepth = pcCU->getDepth(0) + uiTrDepth;
1972  UInt uiTrMode    = pcCU->getTransformIdx( uiAbsPartIdx );
1973  if(  uiTrMode == uiTrDepth )
1974  {
1975    UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
1976    UInt uiQTLayer    = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
1977
1978    Bool bChromaSame = false;
1979    if( uiLog2TrSize == 2 )
1980    {
1981      assert( uiTrDepth > 0 );
1982      uiTrDepth --;
1983      UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth) << 1 );
1984      if( ( uiAbsPartIdx % uiQPDiv ) != 0 )
1985      {
1986        return;
1987      }
1988      bChromaSame = true;
1989    }
1990
1991    //===== copy transform coefficients =====
1992    UInt uiNumCoeffC    = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( uiFullDepth << 1 );
1993    if( !bChromaSame )
1994    {
1995      uiNumCoeffC     >>= 2;
1996    }
1997    UInt uiNumCoeffIncC = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 ) + 2 );
1998    if(stateU0V1Both2 == 0 || stateU0V1Both2 == 2)
1999    {
2000      TCoeff* pcCoeffSrcU = m_ppcQTTempCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2001      TCoeff* pcCoeffDstU = m_pcQTTempTUCoeffCb;
2002      ::memcpy( pcCoeffDstU, pcCoeffSrcU, sizeof( TCoeff ) * uiNumCoeffC );
2003
2004#if ADAPTIVE_QP_SELECTION   
2005      Int* pcArlCoeffSrcU = m_ppcQTTempArlCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2006      Int* pcArlCoeffDstU = m_ppcQTTempTUArlCoeffCb;
2007      ::memcpy( pcArlCoeffDstU, pcArlCoeffSrcU, sizeof( Int ) * uiNumCoeffC );
2008#endif
2009    }
2010    if(stateU0V1Both2 == 1 || stateU0V1Both2 == 2)
2011    {
2012      TCoeff* pcCoeffSrcV = m_ppcQTTempCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2013      TCoeff* pcCoeffDstV = m_pcQTTempTUCoeffCr;
2014      ::memcpy( pcCoeffDstV, pcCoeffSrcV, sizeof( TCoeff ) * uiNumCoeffC );
2015#if ADAPTIVE_QP_SELECTION   
2016      Int* pcArlCoeffSrcV = m_ppcQTTempArlCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2017      Int* pcArlCoeffDstV = m_ppcQTTempTUArlCoeffCr;
2018      ::memcpy( pcArlCoeffDstV, pcArlCoeffSrcV, sizeof( Int ) * uiNumCoeffC );
2019#endif
2020    }
2021
2022    //===== copy reconstruction =====
2023    UInt uiLog2TrSizeChroma = ( bChromaSame ? uiLog2TrSize : uiLog2TrSize - 1 );
2024    m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartChroma(&m_pcQTTempTransformSkipTComYuv, uiAbsPartIdx, 1 << uiLog2TrSizeChroma, 1 << uiLog2TrSizeChroma, stateU0V1Both2 );
2025  }
2026}
2027
2028
2029Void
2030TEncSearch::xLoadIntraResultChromaQT( TComDataCU* pcCU,
2031                                     UInt        uiTrDepth,
2032                                     UInt        uiAbsPartIdx,
2033                                     UInt        stateU0V1Both2 )
2034{
2035  UInt uiFullDepth = pcCU->getDepth(0) + uiTrDepth;
2036  UInt uiTrMode    = pcCU->getTransformIdx( uiAbsPartIdx );
2037  if(  uiTrMode == uiTrDepth )
2038  {
2039    UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
2040    UInt uiQTLayer    = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
2041
2042    Bool bChromaSame = false;
2043    if( uiLog2TrSize == 2 )
2044    {
2045      assert( uiTrDepth > 0 );
2046      uiTrDepth --;
2047      UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth ) << 1 );
2048      if( ( uiAbsPartIdx % uiQPDiv ) != 0 )
2049      {
2050        return;
2051      }
2052      bChromaSame = true;
2053    }
2054
2055    //===== copy transform coefficients =====
2056    UInt uiNumCoeffC = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( uiFullDepth << 1 );
2057    if( !bChromaSame )
2058    {
2059      uiNumCoeffC >>= 2;
2060    }
2061    UInt uiNumCoeffIncC = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 ) + 2 );
2062
2063    if(stateU0V1Both2 ==0 || stateU0V1Both2 == 2)
2064    {
2065      TCoeff* pcCoeffDstU = m_ppcQTTempCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2066      TCoeff* pcCoeffSrcU = m_pcQTTempTUCoeffCb;
2067      ::memcpy( pcCoeffDstU, pcCoeffSrcU, sizeof( TCoeff ) * uiNumCoeffC );
2068#if ADAPTIVE_QP_SELECTION   
2069      Int* pcArlCoeffDstU = m_ppcQTTempArlCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2070      Int* pcArlCoeffSrcU = m_ppcQTTempTUArlCoeffCb;
2071      ::memcpy( pcArlCoeffDstU, pcArlCoeffSrcU, sizeof( Int ) * uiNumCoeffC );
2072#endif
2073    }
2074    if(stateU0V1Both2 ==1 || stateU0V1Both2 == 2)
2075    {
2076      TCoeff* pcCoeffDstV = m_ppcQTTempCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2077      TCoeff* pcCoeffSrcV = m_pcQTTempTUCoeffCr;
2078      ::memcpy( pcCoeffDstV, pcCoeffSrcV, sizeof( TCoeff ) * uiNumCoeffC );
2079#if ADAPTIVE_QP_SELECTION   
2080      Int* pcArlCoeffDstV = m_ppcQTTempArlCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2081      Int* pcArlCoeffSrcV = m_ppcQTTempTUArlCoeffCr;       
2082      ::memcpy( pcArlCoeffDstV, pcArlCoeffSrcV, sizeof( Int ) * uiNumCoeffC );
2083#endif
2084    }
2085
2086    //===== copy reconstruction =====
2087    UInt uiLog2TrSizeChroma = ( bChromaSame ? uiLog2TrSize : uiLog2TrSize - 1 );
2088    m_pcQTTempTransformSkipTComYuv.copyPartToPartChroma( &m_pcQTTempTComYuv[ uiQTLayer ], uiAbsPartIdx, 1 << uiLog2TrSizeChroma, 1 << uiLog2TrSizeChroma, stateU0V1Both2);
2089
2090    UInt    uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
2091    UInt    uiWidth           = pcCU->getWidth   ( 0 ) >> (uiTrDepth + 1);
2092    UInt    uiHeight          = pcCU->getHeight  ( 0 ) >> (uiTrDepth + 1);
2093    UInt    uiRecQtStride     = m_pcQTTempTComYuv[ uiQTLayer ].getCStride  ();
2094    UInt    uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getCStride  ();
2095
2096    if(stateU0V1Both2 ==0 || stateU0V1Both2 == 2)
2097    {
2098      Pel* piRecIPred = pcCU->getPic()->getPicYuvRec()->getCbAddr( pcCU->getAddr(), uiZOrder );
2099      Pel* piRecQt    = m_pcQTTempTComYuv[ uiQTLayer ].getCbAddr( uiAbsPartIdx );
2100      Pel* pRecQt     = piRecQt;
2101      Pel* pRecIPred  = piRecIPred;
2102      for( UInt uiY = 0; uiY < uiHeight; uiY++ )
2103      {
2104        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
2105        {
2106          pRecIPred[ uiX ] = pRecQt[ uiX ];
2107        }
2108        pRecQt    += uiRecQtStride;
2109        pRecIPred += uiRecIPredStride;
2110      }
2111    }
2112    if(stateU0V1Both2 == 1 || stateU0V1Both2 == 2)
2113    {
2114      Pel* piRecIPred = pcCU->getPic()->getPicYuvRec()->getCrAddr( pcCU->getAddr(), uiZOrder );
2115      Pel* piRecQt    = m_pcQTTempTComYuv[ uiQTLayer ].getCrAddr( uiAbsPartIdx );
2116      Pel* pRecQt     = piRecQt;
2117      Pel* pRecIPred  = piRecIPred;
2118      for( UInt uiY = 0; uiY < uiHeight; uiY++ )
2119      {
2120        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
2121        {
2122          pRecIPred[ uiX ] = pRecQt[ uiX ];
2123        }
2124        pRecQt    += uiRecQtStride;
2125        pRecIPred += uiRecIPredStride;
2126      }
2127    }
2128  }
2129}
2130
2131Void
2132TEncSearch::xRecurIntraChromaCodingQT( TComDataCU*  pcCU, 
2133                                      UInt         uiTrDepth,
2134                                      UInt         uiAbsPartIdx, 
2135                                      TComYuv*     pcOrgYuv, 
2136                                      TComYuv*     pcPredYuv, 
2137                                      TComYuv*     pcResiYuv, 
2138                                      UInt&        ruiDist )
2139{
2140  UInt uiFullDepth = pcCU->getDepth( 0 ) +  uiTrDepth;
2141  UInt uiTrMode    = pcCU->getTransformIdx( uiAbsPartIdx );
2142  if(  uiTrMode == uiTrDepth )
2143  {
2144    Bool checkTransformSkip = pcCU->getSlice()->getPPS()->getUseTransformSkip();
2145    UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
2146
2147    UInt actualTrDepth = uiTrDepth;
2148    if( uiLog2TrSize == 2 )
2149    {
2150      assert( uiTrDepth > 0 );
2151      actualTrDepth--;
2152      UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + actualTrDepth) << 1 );
2153      Bool bFirstQ = ( ( uiAbsPartIdx % uiQPDiv ) == 0 );
2154      if( !bFirstQ )
2155      {
2156        return;
2157      }
2158    }
2159
2160    checkTransformSkip &= (uiLog2TrSize <= 3);
2161    if ( m_pcEncCfg->getUseTransformSkipFast() )
2162    {
2163      checkTransformSkip &= (uiLog2TrSize < 3);
2164      if (checkTransformSkip)
2165      {
2166        Int nbLumaSkip = 0;
2167        for(UInt absPartIdxSub = uiAbsPartIdx; absPartIdxSub < uiAbsPartIdx + 4; absPartIdxSub ++)
2168        {
2169          nbLumaSkip += pcCU->getTransformSkip(absPartIdxSub, TEXT_LUMA);
2170        }
2171        checkTransformSkip &= (nbLumaSkip > 0);
2172      }
2173    }
2174
2175    if(checkTransformSkip)
2176    {
2177        //use RDO to decide whether Cr/Cb takes TS
2178        m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[uiFullDepth][CI_QT_TRAFO_ROOT] );
2179
2180        for(Int chromaId = 0; chromaId < 2; chromaId ++)
2181        {
2182          Double  dSingleCost    = MAX_DOUBLE;
2183          Int     bestModeId     = 0;
2184          UInt    singleDistC    = 0;
2185          UInt    singleCbfC     = 0;
2186          UInt    singleDistCTmp = 0;
2187          Double  singleCostTmp  = 0;
2188          UInt    singleCbfCTmp  = 0;
2189
2190          Int     default0Save1Load2 = 0;
2191          Int     firstCheckId       = 0;
2192
2193          for(Int chromaModeId = firstCheckId; chromaModeId < 2; chromaModeId ++)
2194          {
2195            pcCU->setTransformSkipSubParts ( chromaModeId, (TextType)(chromaId + 2), uiAbsPartIdx, pcCU->getDepth( 0 ) +  actualTrDepth); 
2196            if(chromaModeId == firstCheckId)
2197            {
2198              default0Save1Load2 = 1;
2199            }
2200            else
2201            {
2202              default0Save1Load2 = 2;
2203            }
2204            singleDistCTmp = 0;
2205            xIntraCodingChromaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, singleDistCTmp, chromaId ,default0Save1Load2);
2206            singleCbfCTmp = pcCU->getCbf( uiAbsPartIdx, (TextType)(chromaId + 2), uiTrDepth);
2207           
2208            if(chromaModeId == 1 && singleCbfCTmp == 0)
2209            {
2210              //In order not to code TS flag when cbf is zero, the case for TS with cbf being zero is forbidden.
2211              singleCostTmp = MAX_DOUBLE;
2212            }
2213            else
2214            {
2215              UInt bitsTmp = xGetIntraBitsQTChroma( pcCU,uiTrDepth, uiAbsPartIdx,chromaId + 2, false );
2216              singleCostTmp  = m_pcRdCost->calcRdCost( bitsTmp, singleDistCTmp);
2217            }
2218
2219            if(singleCostTmp < dSingleCost)
2220          {
2221            dSingleCost = singleCostTmp;
2222            singleDistC = singleDistCTmp;
2223            bestModeId  = chromaModeId;
2224            singleCbfC  = singleCbfCTmp;
2225           
2226            if(bestModeId == firstCheckId)
2227            {
2228              xStoreIntraResultChromaQT(pcCU, uiTrDepth, uiAbsPartIdx,chromaId);
2229              m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
2230            }
2231          }
2232          if(chromaModeId == firstCheckId)
2233          {
2234            m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
2235          }
2236        }
2237       
2238        if(bestModeId == firstCheckId)
2239        {
2240          xLoadIntraResultChromaQT(pcCU, uiTrDepth, uiAbsPartIdx,chromaId);
2241          pcCU->setCbfSubParts ( singleCbfC << uiTrDepth, (TextType)(chromaId + 2), uiAbsPartIdx, pcCU->getDepth(0) + actualTrDepth );
2242          m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
2243        }
2244        pcCU ->setTransformSkipSubParts( bestModeId, (TextType)(chromaId + 2), uiAbsPartIdx, pcCU->getDepth( 0 ) +  actualTrDepth );
2245        ruiDist += singleDistC;
2246       
2247        if(chromaId == 0)
2248        {
2249          m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[uiFullDepth][CI_QT_TRAFO_ROOT] );
2250        }
2251      }
2252    }
2253    else
2254    {
2255      pcCU ->setTransformSkipSubParts( 0, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth( 0 ) +  actualTrDepth ); 
2256      pcCU ->setTransformSkipSubParts( 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth( 0 ) +  actualTrDepth ); 
2257      xIntraCodingChromaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, ruiDist, 0 ); 
2258      xIntraCodingChromaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, ruiDist, 1 ); 
2259    }
2260  }
2261  else
2262  {
2263    UInt uiSplitCbfU     = 0;
2264    UInt uiSplitCbfV     = 0;
2265    UInt uiQPartsDiv     = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
2266    UInt uiAbsPartIdxSub = uiAbsPartIdx;
2267    for( UInt uiPart = 0; uiPart < 4; uiPart++, uiAbsPartIdxSub += uiQPartsDiv )
2268    {
2269      xRecurIntraChromaCodingQT( pcCU, uiTrDepth + 1, uiAbsPartIdxSub, pcOrgYuv, pcPredYuv, pcResiYuv, ruiDist );
2270      uiSplitCbfU |= pcCU->getCbf( uiAbsPartIdxSub, TEXT_CHROMA_U, uiTrDepth + 1 );
2271      uiSplitCbfV |= pcCU->getCbf( uiAbsPartIdxSub, TEXT_CHROMA_V, uiTrDepth + 1 );
2272    }
2273    for( UInt uiOffs = 0; uiOffs < 4 * uiQPartsDiv; uiOffs++ )
2274    {
2275      pcCU->getCbf( TEXT_CHROMA_U )[ uiAbsPartIdx + uiOffs ] |= ( uiSplitCbfU << uiTrDepth );
2276      pcCU->getCbf( TEXT_CHROMA_V )[ uiAbsPartIdx + uiOffs ] |= ( uiSplitCbfV << uiTrDepth );
2277    }
2278  }
2279}
2280
2281Void
2282TEncSearch::xSetIntraResultChromaQT( TComDataCU* pcCU,
2283                                    UInt        uiTrDepth,
2284                                    UInt        uiAbsPartIdx,
2285                                    TComYuv*    pcRecoYuv )
2286{
2287  UInt uiFullDepth  = pcCU->getDepth(0) + uiTrDepth;
2288  UInt uiTrMode     = pcCU->getTransformIdx( uiAbsPartIdx );
2289  if(  uiTrMode == uiTrDepth )
2290  {
2291    UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
2292    UInt uiQTLayer    = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
2293   
2294    Bool bChromaSame  = false;
2295    if( uiLog2TrSize == 2 )
2296    {
2297      assert( uiTrDepth > 0 );
2298      UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrDepth - 1 ) << 1 );
2299      if( ( uiAbsPartIdx % uiQPDiv ) != 0 )
2300      {
2301        return;
2302      }
2303      bChromaSame     = true;
2304    }
2305   
2306    //===== copy transform coefficients =====
2307    UInt uiNumCoeffC    = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( uiFullDepth << 1 );
2308    if( !bChromaSame )
2309    {
2310      uiNumCoeffC     >>= 2;
2311    }
2312    UInt uiNumCoeffIncC = ( pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 ) + 2 );
2313    TCoeff* pcCoeffSrcU = m_ppcQTTempCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2314    TCoeff* pcCoeffSrcV = m_ppcQTTempCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2315    TCoeff* pcCoeffDstU = pcCU->getCoeffCb()              + ( uiNumCoeffIncC * uiAbsPartIdx );
2316    TCoeff* pcCoeffDstV = pcCU->getCoeffCr()              + ( uiNumCoeffIncC * uiAbsPartIdx );
2317    ::memcpy( pcCoeffDstU, pcCoeffSrcU, sizeof( TCoeff ) * uiNumCoeffC );
2318    ::memcpy( pcCoeffDstV, pcCoeffSrcV, sizeof( TCoeff ) * uiNumCoeffC );
2319#if ADAPTIVE_QP_SELECTION   
2320    Int* pcArlCoeffSrcU = m_ppcQTTempArlCoeffCb[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2321    Int* pcArlCoeffSrcV = m_ppcQTTempArlCoeffCr[ uiQTLayer ] + ( uiNumCoeffIncC * uiAbsPartIdx );
2322    Int* pcArlCoeffDstU = pcCU->getArlCoeffCb()              + ( uiNumCoeffIncC * uiAbsPartIdx );
2323    Int* pcArlCoeffDstV = pcCU->getArlCoeffCr()              + ( uiNumCoeffIncC * uiAbsPartIdx );
2324    ::memcpy( pcArlCoeffDstU, pcArlCoeffSrcU, sizeof( Int ) * uiNumCoeffC );
2325    ::memcpy( pcArlCoeffDstV, pcArlCoeffSrcV, sizeof( Int ) * uiNumCoeffC );
2326#endif
2327   
2328    //===== copy reconstruction =====
2329    UInt uiLog2TrSizeChroma = ( bChromaSame ? uiLog2TrSize : uiLog2TrSize - 1 );
2330    m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartChroma( pcRecoYuv, uiAbsPartIdx, 1 << uiLog2TrSizeChroma, 1 << uiLog2TrSizeChroma );
2331  }
2332  else
2333  {
2334    UInt uiNumQPart  = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
2335    for( UInt uiPart = 0; uiPart < 4; uiPart++ )
2336    {
2337      xSetIntraResultChromaQT( pcCU, uiTrDepth + 1, uiAbsPartIdx + uiPart * uiNumQPart, pcRecoYuv );
2338    }
2339  }
2340}
2341
2342
2343Void
2344TEncSearch::preestChromaPredMode( TComDataCU* pcCU, 
2345                                 TComYuv*    pcOrgYuv, 
2346                                 TComYuv*    pcPredYuv )
2347{
2348  UInt  uiWidth     = pcCU->getWidth ( 0 ) >> 1;
2349  UInt  uiHeight    = pcCU->getHeight( 0 ) >> 1;
2350  UInt  uiStride    = pcOrgYuv ->getCStride();
2351  Pel*  piOrgU      = pcOrgYuv ->getCbAddr ( 0 );
2352  Pel*  piOrgV      = pcOrgYuv ->getCrAddr ( 0 );
2353  Pel*  piPredU     = pcPredYuv->getCbAddr ( 0 );
2354  Pel*  piPredV     = pcPredYuv->getCrAddr ( 0 );
2355 
2356  //===== init pattern =====
2357  Bool  bAboveAvail = false;
2358  Bool  bLeftAvail  = false;
2359  pcCU->getPattern()->initPattern         ( pcCU, 0, 0 );
2360  pcCU->getPattern()->initAdiPatternChroma( pcCU, 0, 0, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );
2361  Int*  pPatChromaU = pcCU->getPattern()->getAdiCbBuf( uiWidth, uiHeight, m_piYuvExt );
2362  Int*  pPatChromaV = pcCU->getPattern()->getAdiCrBuf( uiWidth, uiHeight, m_piYuvExt );
2363 
2364  //===== get best prediction modes (using SAD) =====
2365  UInt  uiMinMode   = 0;
2366  UInt  uiMaxMode   = 4;
2367  UInt  uiBestMode  = MAX_UINT;
2368  UInt  uiMinSAD    = MAX_UINT;
2369  for( UInt uiMode  = uiMinMode; uiMode < uiMaxMode; uiMode++ )
2370  {
2371    //--- get prediction ---
2372    predIntraChromaAng( pPatChromaU, uiMode, piPredU, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
2373    predIntraChromaAng( pPatChromaV, uiMode, piPredV, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
2374   
2375    //--- get SAD ---
2376    UInt  uiSAD  = m_pcRdCost->calcHAD(g_bitDepthC, piOrgU, uiStride, piPredU, uiStride, uiWidth, uiHeight );
2377    uiSAD       += m_pcRdCost->calcHAD(g_bitDepthC, piOrgV, uiStride, piPredV, uiStride, uiWidth, uiHeight );
2378    //--- check ---
2379    if( uiSAD < uiMinSAD )
2380    {
2381      uiMinSAD   = uiSAD;
2382      uiBestMode = uiMode;
2383    }
2384  }
2385 
2386  //===== set chroma pred mode =====
2387  pcCU->setChromIntraDirSubParts( uiBestMode, 0, pcCU->getDepth( 0 ) );
2388}
2389
2390Void
2391TEncSearch::estIntraPredQT( TComDataCU* pcCU, 
2392                           TComYuv*    pcOrgYuv, 
2393                           TComYuv*    pcPredYuv, 
2394                           TComYuv*    pcResiYuv, 
2395                           TComYuv*    pcRecoYuv,
2396                           UInt&       ruiDistC,
2397                           Bool        bLumaOnly )
2398{
2399  UInt    uiDepth        = pcCU->getDepth(0);
2400  UInt    uiNumPU        = pcCU->getNumPartInter();
2401  UInt    uiInitTrDepth  = pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1;
2402  UInt    uiWidth        = pcCU->getWidth (0) >> uiInitTrDepth;
2403  UInt    uiHeight       = pcCU->getHeight(0) >> uiInitTrDepth;
2404  UInt    uiQNumParts    = pcCU->getTotalNumPart() >> 2;
2405  UInt    uiWidthBit     = pcCU->getIntraSizeIdx(0);
2406  UInt    uiOverallDistY = 0;
2407  UInt    uiOverallDistC = 0;
2408  UInt    CandNum;
2409  Double  CandCostList[ FAST_UDI_MAX_RDMODE_NUM ];
2410 
2411  //===== set QP and clear Cbf =====
2412  if ( pcCU->getSlice()->getPPS()->getUseDQP() == true)
2413  {
2414    pcCU->setQPSubParts( pcCU->getQP(0), 0, uiDepth );
2415  }
2416  else
2417  {
2418    pcCU->setQPSubParts( pcCU->getSlice()->getSliceQp(), 0, uiDepth );
2419  }
2420 
2421  //===== loop over partitions =====
2422  UInt uiPartOffset = 0;
2423  for( UInt uiPU = 0; uiPU < uiNumPU; uiPU++, uiPartOffset += uiQNumParts )
2424  {
2425    //===== init pattern for luma prediction =====
2426    Bool bAboveAvail = false;
2427    Bool bLeftAvail  = false;
2428    pcCU->getPattern()->initPattern   ( pcCU, uiInitTrDepth, uiPartOffset );
2429    pcCU->getPattern()->initAdiPattern( pcCU, uiPartOffset, uiInitTrDepth, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );
2430   
2431    //===== determine set of modes to be tested (using prediction signal only) =====
2432    Int numModesAvailable     = 35; //total number of Intra modes
2433    Pel* piOrg         = pcOrgYuv ->getLumaAddr( uiPU, uiWidth );
2434    Pel* piPred        = pcPredYuv->getLumaAddr( uiPU, uiWidth );
2435    UInt uiStride      = pcPredYuv->getStride();
2436    UInt uiRdModeList[FAST_UDI_MAX_RDMODE_NUM];
2437    Int numModesForFullRD = g_aucIntraModeNumFast[ uiWidthBit ];
2438   
2439    Bool doFastSearch = (numModesForFullRD != numModesAvailable);
2440    if (doFastSearch)
2441    {
2442      assert(numModesForFullRD < numModesAvailable);
2443#if FAST_INTRA_SHVC
2444      Int   uiPreds[3] = {-1, -1, -1};
2445      Int   iMode = -1;
2446      Bool  skipFastHAD = false;
2447      Int numCand = pcCU->getIntraDirLumaPredictor( uiPartOffset, uiPreds, &iMode );
2448
2449      if ( m_pcEncCfg->getUseFastIntraScalable() )
2450      {
2451        if( pcCU->getLayerId() > 0 )
2452        {
2453          numModesAvailable = pcCU->reduceSetOfIntraModes(uiPartOffset, uiPreds, iMode );
2454          if( numModesForFullRD > numModesAvailable ) //fast HAD can be skipped
2455          {
2456            skipFastHAD = true;
2457            numModesForFullRD = numModesAvailable;
2458            for( Int i=0; i < numModesForFullRD; i++ ) 
2459              uiRdModeList[ i ] = g_reducedSetIntraModes[ i ];
2460          }
2461        }
2462      }
2463#endif
2464
2465      for( Int i=0; i < numModesForFullRD; i++ ) 
2466      {
2467        CandCostList[ i ] = MAX_DOUBLE;
2468      }
2469      CandNum = 0;
2470     
2471      for( Int modeIdx = 0; modeIdx < numModesAvailable; modeIdx++ )
2472      {
2473        UInt uiMode = modeIdx;
2474#if FAST_INTRA_SHVC
2475        if ( m_pcEncCfg->getUseFastIntraScalable() )
2476        {
2477          if( skipFastHAD )//indicates that fast HAD can be skipped
2478            break;
2479          uiMode = ( iMode==0 ) ? g_reducedSetIntraModes[modeIdx] : uiMode; //(iMode=0) indicates reduced set of modes
2480        }
2481#endif
2482
2483        predIntraLumaAng( pcCU->getPattern(), uiMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
2484       
2485        // use hadamard transform here
2486        UInt uiSad = m_pcRdCost->calcHAD(g_bitDepthY, piOrg, uiStride, piPred, uiStride, uiWidth, uiHeight );
2487       
2488        UInt   iModeBits = xModeBitsIntra( pcCU, uiMode, uiPU, uiPartOffset, uiDepth, uiInitTrDepth );
2489        Double cost      = (Double)uiSad + (Double)iModeBits * m_pcRdCost->getSqrtLambda();
2490       
2491        CandNum += xUpdateCandList( uiMode, cost, numModesForFullRD, uiRdModeList, CandCostList );
2492      }
2493   
2494#if FAST_UDI_USE_MPM
2495#if FAST_INTRA_SHVC == 0
2496      Int uiPreds[3] = {-1, -1, -1};
2497      Int iMode = -1;
2498      Int numCand = pcCU->getIntraDirLumaPredictor( uiPartOffset, uiPreds, &iMode );
2499#endif
2500      if( iMode >= 0 )
2501      {
2502        numCand = iMode;
2503      }
2504     
2505      for( Int j=0; j < numCand; j++)
2506      {
2507        Bool mostProbableModeIncluded = false;
2508        Int mostProbableMode = uiPreds[j];
2509       
2510        for( Int i=0; i < numModesForFullRD; i++)
2511        {
2512          mostProbableModeIncluded |= (mostProbableMode == uiRdModeList[i]);
2513        }
2514        if (!mostProbableModeIncluded)
2515        {
2516          uiRdModeList[numModesForFullRD++] = mostProbableMode;
2517        }
2518      }
2519#endif // FAST_UDI_USE_MPM
2520    }
2521    else
2522    {
2523      for( Int i=0; i < numModesForFullRD; i++)
2524      {
2525        uiRdModeList[i] = i;
2526      }
2527    }
2528   
2529    //===== check modes (using r-d costs) =====
2530#if HHI_RQT_INTRA_SPEEDUP_MOD
2531    UInt   uiSecondBestMode  = MAX_UINT;
2532    Double dSecondBestPUCost = MAX_DOUBLE;
2533#endif
2534   
2535    UInt    uiBestPUMode  = 0;
2536    UInt    uiBestPUDistY = 0;
2537    UInt    uiBestPUDistC = 0;
2538    Double  dBestPUCost   = MAX_DOUBLE;
2539    for( UInt uiMode = 0; uiMode < numModesForFullRD; uiMode++ )
2540    {
2541      // set luma prediction mode
2542      UInt uiOrgMode = uiRdModeList[uiMode];
2543     
2544      pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
2545     
2546      // set context models
2547      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
2548     
2549      // determine residual for partition
2550      UInt   uiPUDistY = 0;
2551      UInt   uiPUDistC = 0;
2552      Double dPUCost   = 0.0;
2553#if HHI_RQT_INTRA_SPEEDUP
2554      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost );
2555#else
2556      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost );
2557#endif
2558     
2559      // check r-d cost
2560      if( dPUCost < dBestPUCost )
2561      {
2562#if HHI_RQT_INTRA_SPEEDUP_MOD
2563        uiSecondBestMode  = uiBestPUMode;
2564        dSecondBestPUCost = dBestPUCost;
2565#endif
2566        uiBestPUMode  = uiOrgMode;
2567        uiBestPUDistY = uiPUDistY;
2568        uiBestPUDistC = uiPUDistC;
2569        dBestPUCost   = dPUCost;
2570       
2571        xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
2572       
2573        UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
2574        ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2575        ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2576        ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2577        ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2578        ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2579        ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2580        ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2581      }
2582#if HHI_RQT_INTRA_SPEEDUP_MOD
2583      else if( dPUCost < dSecondBestPUCost )
2584      {
2585        uiSecondBestMode  = uiOrgMode;
2586        dSecondBestPUCost = dPUCost;
2587      }
2588#endif
2589    } // Mode loop
2590   
2591#if HHI_RQT_INTRA_SPEEDUP
2592#if HHI_RQT_INTRA_SPEEDUP_MOD
2593    for( UInt ui =0; ui < 2; ++ui )
2594#endif
2595    {
2596#if HHI_RQT_INTRA_SPEEDUP_MOD
2597      UInt uiOrgMode   = ui ? uiSecondBestMode  : uiBestPUMode;
2598      if( uiOrgMode == MAX_UINT )
2599      {
2600        break;
2601      }
2602#else
2603      UInt uiOrgMode = uiBestPUMode;
2604#endif
2605     
2606      pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
2607     
2608      // set context models
2609      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
2610     
2611      // determine residual for partition
2612      UInt   uiPUDistY = 0;
2613      UInt   uiPUDistC = 0;
2614      Double dPUCost   = 0.0;
2615      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, false, dPUCost );
2616     
2617      // check r-d cost
2618      if( dPUCost < dBestPUCost )
2619      {
2620        uiBestPUMode  = uiOrgMode;
2621        uiBestPUDistY = uiPUDistY;
2622        uiBestPUDistC = uiPUDistC;
2623        dBestPUCost   = dPUCost;
2624       
2625        xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
2626       
2627        UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
2628        ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2629        ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2630        ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2631        ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2632        ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2633        ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2634        ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
2635      }
2636    } // Mode loop
2637#endif
2638   
2639    //--- update overall distortion ---
2640    uiOverallDistY += uiBestPUDistY;
2641    uiOverallDistC += uiBestPUDistC;
2642   
2643    //--- update transform index and cbf ---
2644    UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
2645    ::memcpy( pcCU->getTransformIdx()       + uiPartOffset, m_puhQTTempTrIdx,  uiQPartNum * sizeof( UChar ) );
2646    ::memcpy( pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, m_puhQTTempCbf[0], uiQPartNum * sizeof( UChar ) );
2647    ::memcpy( pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, m_puhQTTempCbf[1], uiQPartNum * sizeof( UChar ) );
2648    ::memcpy( pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, m_puhQTTempCbf[2], uiQPartNum * sizeof( UChar ) );
2649    ::memcpy( pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, m_puhQTTempTransformSkipFlag[0], uiQPartNum * sizeof( UChar ) );
2650    ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, m_puhQTTempTransformSkipFlag[1], uiQPartNum * sizeof( UChar ) );
2651    ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, m_puhQTTempTransformSkipFlag[2], uiQPartNum * sizeof( UChar ) );
2652    //--- set reconstruction for next intra prediction blocks ---
2653    if( uiPU != uiNumPU - 1 )
2654    {
2655      Bool bSkipChroma  = false;
2656      Bool bChromaSame  = false;
2657      UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> ( pcCU->getDepth(0) + uiInitTrDepth ) ] + 2;
2658      if( !bLumaOnly && uiLog2TrSize == 2 )
2659      {
2660        assert( uiInitTrDepth  > 0 );
2661        bSkipChroma  = ( uiPU != 0 );
2662        bChromaSame  = true;
2663      }
2664     
2665      UInt    uiCompWidth   = pcCU->getWidth ( 0 ) >> uiInitTrDepth;
2666      UInt    uiCompHeight  = pcCU->getHeight( 0 ) >> uiInitTrDepth;
2667      UInt    uiZOrder      = pcCU->getZorderIdxInCU() + uiPartOffset;
2668      Pel*    piDes         = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
2669      UInt    uiDesStride   = pcCU->getPic()->getPicYuvRec()->getStride();
2670      Pel*    piSrc         = pcRecoYuv->getLumaAddr( uiPartOffset );
2671      UInt    uiSrcStride   = pcRecoYuv->getStride();
2672      for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
2673      {
2674        for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
2675        {
2676          piDes[ uiX ] = piSrc[ uiX ];
2677        }
2678      }
2679      if( !bLumaOnly && !bSkipChroma )
2680      {
2681        if( !bChromaSame )
2682        {
2683          uiCompWidth   >>= 1;
2684          uiCompHeight  >>= 1;
2685        }
2686        piDes         = pcCU->getPic()->getPicYuvRec()->getCbAddr( pcCU->getAddr(), uiZOrder );
2687        uiDesStride   = pcCU->getPic()->getPicYuvRec()->getCStride();
2688        piSrc         = pcRecoYuv->getCbAddr( uiPartOffset );
2689        uiSrcStride   = pcRecoYuv->getCStride();
2690        for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
2691        {
2692          for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
2693          {
2694            piDes[ uiX ] = piSrc[ uiX ];
2695          }
2696        }
2697        piDes         = pcCU->getPic()->getPicYuvRec()->getCrAddr( pcCU->getAddr(), uiZOrder );
2698        piSrc         = pcRecoYuv->getCrAddr( uiPartOffset );
2699        for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
2700        {
2701          for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
2702          {
2703            piDes[ uiX ] = piSrc[ uiX ];
2704          }
2705        }
2706      }
2707    }
2708   
2709    //=== update PU data ====
2710    pcCU->setLumaIntraDirSubParts     ( uiBestPUMode, uiPartOffset, uiDepth + uiInitTrDepth );
2711    pcCU->copyToPic                   ( uiDepth, uiPU, uiInitTrDepth );
2712  } // PU loop
2713 
2714 
2715  if( uiNumPU > 1 )
2716  { // set Cbf for all blocks
2717    UInt uiCombCbfY = 0;
2718    UInt uiCombCbfU = 0;
2719    UInt uiCombCbfV = 0;
2720    UInt uiPartIdx  = 0;
2721    for( UInt uiPart = 0; uiPart < 4; uiPart++, uiPartIdx += uiQNumParts )
2722    {
2723      uiCombCbfY |= pcCU->getCbf( uiPartIdx, TEXT_LUMA,     1 );
2724      uiCombCbfU |= pcCU->getCbf( uiPartIdx, TEXT_CHROMA_U, 1 );
2725      uiCombCbfV |= pcCU->getCbf( uiPartIdx, TEXT_CHROMA_V, 1 );
2726    }
2727    for( UInt uiOffs = 0; uiOffs < 4 * uiQNumParts; uiOffs++ )
2728    {
2729      pcCU->getCbf( TEXT_LUMA     )[ uiOffs ] |= uiCombCbfY;
2730      pcCU->getCbf( TEXT_CHROMA_U )[ uiOffs ] |= uiCombCbfU;
2731      pcCU->getCbf( TEXT_CHROMA_V )[ uiOffs ] |= uiCombCbfV;
2732    }
2733  }
2734 
2735  //===== reset context models =====
2736  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
2737 
2738  //===== set distortion (rate and r-d costs are determined later) =====
2739  ruiDistC                   = uiOverallDistC;
2740  pcCU->getTotalDistortion() = uiOverallDistY + uiOverallDistC;
2741}
2742
2743
2744
2745Void
2746TEncSearch::estIntraPredChromaQT( TComDataCU* pcCU, 
2747                                 TComYuv*    pcOrgYuv, 
2748                                 TComYuv*    pcPredYuv, 
2749                                 TComYuv*    pcResiYuv, 
2750                                 TComYuv*    pcRecoYuv,
2751                                 UInt        uiPreCalcDistC )
2752{
2753  UInt    uiDepth     = pcCU->getDepth(0);
2754  UInt    uiBestMode  = 0;
2755  UInt    uiBestDist  = 0;
2756  Double  dBestCost   = MAX_DOUBLE;
2757 
2758  //----- init mode list -----
2759  UInt  uiMinMode = 0;
2760  UInt  uiModeList[ NUM_CHROMA_MODE ];
2761  pcCU->getAllowedChromaDir( 0, uiModeList );
2762  UInt  uiMaxMode = NUM_CHROMA_MODE;
2763
2764  //----- check chroma modes -----
2765  for( UInt uiMode = uiMinMode; uiMode < uiMaxMode; uiMode++ )
2766  {
2767    //----- restore context models -----
2768    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
2769   
2770    //----- chroma coding -----
2771    UInt    uiDist = 0;
2772    pcCU->setChromIntraDirSubParts  ( uiModeList[uiMode], 0, uiDepth );
2773    xRecurIntraChromaCodingQT       ( pcCU,   0, 0, pcOrgYuv, pcPredYuv, pcResiYuv, uiDist );
2774    if( pcCU->getSlice()->getPPS()->getUseTransformSkip() )
2775    {
2776      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
2777    }
2778    UInt    uiBits = xGetIntraBitsQT( pcCU,   0, 0, false, true, false );
2779    Double  dCost  = m_pcRdCost->calcRdCost( uiBits, uiDist );
2780   
2781    //----- compare -----
2782    if( dCost < dBestCost )
2783    {
2784      dBestCost   = dCost;
2785      uiBestDist  = uiDist;
2786      uiBestMode  = uiModeList[uiMode];
2787      UInt  uiQPN = pcCU->getPic()->getNumPartInCU() >> ( uiDepth << 1 );
2788      xSetIntraResultChromaQT( pcCU, 0, 0, pcRecoYuv );
2789      ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ), uiQPN * sizeof( UChar ) );
2790      ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ), uiQPN * sizeof( UChar ) );
2791      ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip( TEXT_CHROMA_U ), uiQPN * sizeof( UChar ) );
2792      ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip( TEXT_CHROMA_V ), uiQPN * sizeof( UChar ) );
2793    }
2794  }
2795 
2796  //----- set data -----
2797  UInt  uiQPN = pcCU->getPic()->getNumPartInCU() >> ( uiDepth << 1 );
2798  ::memcpy( pcCU->getCbf( TEXT_CHROMA_U ), m_puhQTTempCbf[1], uiQPN * sizeof( UChar ) );
2799  ::memcpy( pcCU->getCbf( TEXT_CHROMA_V ), m_puhQTTempCbf[2], uiQPN * sizeof( UChar ) );
2800  ::memcpy( pcCU->getTransformSkip( TEXT_CHROMA_U ), m_puhQTTempTransformSkipFlag[1], uiQPN * sizeof( UChar ) );
2801  ::memcpy( pcCU->getTransformSkip( TEXT_CHROMA_V ), m_puhQTTempTransformSkipFlag[2], uiQPN * sizeof( UChar ) );
2802  pcCU->setChromIntraDirSubParts( uiBestMode, 0, uiDepth );
2803  pcCU->getTotalDistortion      () += uiBestDist - uiPreCalcDistC;
2804 
2805  //----- restore context models -----
2806  m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
2807}
2808
2809/** Function for encoding and reconstructing luma/chroma samples of a PCM mode CU.
2810 * \param pcCU pointer to current CU
2811 * \param uiAbsPartIdx part index
2812 * \param piOrg pointer to original sample arrays
2813 * \param piPCM pointer to PCM code arrays
2814 * \param piPred pointer to prediction signal arrays
2815 * \param piResi pointer to residual signal arrays
2816 * \param piReco pointer to reconstructed sample arrays
2817 * \param uiStride stride of the original/prediction/residual sample arrays
2818 * \param uiWidth block width
2819 * \param uiHeight block height
2820 * \param ttText texture component type
2821 * \returns Void
2822 */
2823Void TEncSearch::xEncPCM (TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piOrg, Pel* piPCM, Pel* piPred, Pel* piResi, Pel* piReco, UInt uiStride, UInt uiWidth, UInt uiHeight, TextType eText )
2824{
2825  UInt uiX, uiY;
2826  UInt uiReconStride;
2827  Pel* pOrg  = piOrg;
2828  Pel* pPCM  = piPCM;
2829  Pel* pPred = piPred;
2830  Pel* pResi = piResi;
2831  Pel* pReco = piReco;
2832  Pel* pRecoPic;
2833  Int shiftPcm;
2834
2835  if( eText == TEXT_LUMA)
2836  {
2837    uiReconStride = pcCU->getPic()->getPicYuvRec()->getStride();
2838    pRecoPic      = pcCU->getPic()->getPicYuvRec()->getLumaAddr(pcCU->getAddr(), pcCU->getZorderIdxInCU()+uiAbsPartIdx);
2839    shiftPcm = g_bitDepthY - pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
2840  }
2841  else
2842  {
2843    uiReconStride = pcCU->getPic()->getPicYuvRec()->getCStride();
2844
2845    if( eText == TEXT_CHROMA_U )
2846    {
2847      pRecoPic = pcCU->getPic()->getPicYuvRec()->getCbAddr(pcCU->getAddr(), pcCU->getZorderIdxInCU()+uiAbsPartIdx);
2848    }
2849    else
2850    {
2851      pRecoPic = pcCU->getPic()->getPicYuvRec()->getCrAddr(pcCU->getAddr(), pcCU->getZorderIdxInCU()+uiAbsPartIdx);
2852    }
2853    shiftPcm = g_bitDepthC - pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
2854  }
2855
2856  // Reset pred and residual
2857  for( uiY = 0; uiY < uiHeight; uiY++ )
2858  {
2859    for( uiX = 0; uiX < uiWidth; uiX++ )
2860    {
2861      pPred[uiX] = 0;
2862      pResi[uiX] = 0;
2863    }
2864    pPred += uiStride;
2865    pResi += uiStride;
2866  }
2867
2868  // Encode
2869  for( uiY = 0; uiY < uiHeight; uiY++ )
2870  {
2871    for( uiX = 0; uiX < uiWidth; uiX++ )
2872    {
2873      pPCM[uiX] = pOrg[uiX]>> shiftPcm;
2874    }
2875    pPCM += uiWidth;
2876    pOrg += uiStride;
2877  }
2878
2879  pPCM  = piPCM;
2880
2881  // Reconstruction
2882  for( uiY = 0; uiY < uiHeight; uiY++ )
2883  {
2884    for( uiX = 0; uiX < uiWidth; uiX++ )
2885    {
2886      pReco   [uiX] = pPCM[uiX]<< shiftPcm;
2887      pRecoPic[uiX] = pReco[uiX];
2888    }
2889    pPCM += uiWidth;
2890    pReco += uiStride;
2891    pRecoPic += uiReconStride;
2892  }
2893}
2894
2895/**  Function for PCM mode estimation.
2896 * \param pcCU
2897 * \param pcOrgYuv
2898 * \param rpcPredYuv
2899 * \param rpcResiYuv
2900 * \param rpcRecoYuv
2901 * \returns Void
2902 */
2903Void TEncSearch::IPCMSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv*& rpcPredYuv, TComYuv*& rpcResiYuv, TComYuv*& rpcRecoYuv )
2904{
2905  UInt   uiDepth        = pcCU->getDepth(0);
2906  UInt   uiWidth        = pcCU->getWidth(0);
2907  UInt   uiHeight       = pcCU->getHeight(0);
2908  UInt   uiStride       = rpcPredYuv->getStride();
2909  UInt   uiStrideC      = rpcPredYuv->getCStride();
2910  UInt   uiWidthC       = uiWidth  >> 1;
2911  UInt   uiHeightC      = uiHeight >> 1;
2912  UInt   uiDistortion = 0;
2913  UInt   uiBits;
2914
2915  Double dCost;
2916
2917  Pel*    pOrig;
2918  Pel*    pResi;
2919  Pel*    pReco;
2920  Pel*    pPred;
2921  Pel*    pPCM;
2922
2923  UInt uiAbsPartIdx = 0;
2924
2925  UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
2926  UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
2927  UInt uiChromaOffset = uiLumaOffset>>2;
2928
2929  // Luminance
2930  pOrig    = pcOrgYuv->getLumaAddr(0, uiWidth);
2931  pResi    = rpcResiYuv->getLumaAddr(0, uiWidth);
2932  pPred    = rpcPredYuv->getLumaAddr(0, uiWidth);
2933  pReco    = rpcRecoYuv->getLumaAddr(0, uiWidth);
2934  pPCM     = pcCU->getPCMSampleY() + uiLumaOffset;
2935
2936  xEncPCM ( pcCU, 0, pOrig, pPCM, pPred, pResi, pReco, uiStride, uiWidth, uiHeight, TEXT_LUMA );
2937
2938  // Chroma U
2939  pOrig    = pcOrgYuv->getCbAddr();
2940  pResi    = rpcResiYuv->getCbAddr();
2941  pPred    = rpcPredYuv->getCbAddr();
2942  pReco    = rpcRecoYuv->getCbAddr();
2943  pPCM     = pcCU->getPCMSampleCb() + uiChromaOffset;
2944
2945  xEncPCM ( pcCU, 0, pOrig, pPCM, pPred, pResi, pReco, uiStrideC, uiWidthC, uiHeightC, TEXT_CHROMA_U );
2946
2947  // Chroma V
2948  pOrig    = pcOrgYuv->getCrAddr();
2949  pResi    = rpcResiYuv->getCrAddr();
2950  pPred    = rpcPredYuv->getCrAddr();
2951  pReco    = rpcRecoYuv->getCrAddr();
2952  pPCM     = pcCU->getPCMSampleCr() + uiChromaOffset;
2953
2954  xEncPCM ( pcCU, 0, pOrig, pPCM, pPred, pResi, pReco, uiStrideC, uiWidthC, uiHeightC, TEXT_CHROMA_V );
2955
2956  m_pcEntropyCoder->resetBits();
2957  xEncIntraHeader ( pcCU, uiDepth, uiAbsPartIdx, true, false);
2958  uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
2959
2960  dCost = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
2961
2962  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
2963
2964  pcCU->getTotalBits()       = uiBits;
2965  pcCU->getTotalCost()       = dCost;
2966  pcCU->getTotalDistortion() = uiDistortion;
2967
2968  pcCU->copyToPic(uiDepth, 0, 0);
2969}
2970
2971Void TEncSearch::xGetInterPredictionError( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPartIdx, UInt& ruiErr, Bool bHadamard )
2972{
2973  motionCompensation( pcCU, &m_tmpYuvPred, REF_PIC_LIST_X, iPartIdx );
2974
2975  UInt uiAbsPartIdx = 0;
2976  Int iWidth = 0;
2977  Int iHeight = 0;
2978  pcCU->getPartIndexAndSize( iPartIdx, uiAbsPartIdx, iWidth, iHeight );
2979
2980  DistParam cDistParam;
2981
2982  cDistParam.bApplyWeight = false;
2983
2984  m_pcRdCost->setDistParam( cDistParam, g_bitDepthY,
2985                            pcYuvOrg->getLumaAddr( uiAbsPartIdx ), pcYuvOrg->getStride(), 
2986                            m_tmpYuvPred .getLumaAddr( uiAbsPartIdx ), m_tmpYuvPred .getStride(), 
2987                            iWidth, iHeight, m_pcEncCfg->getUseHADME() );
2988  ruiErr = cDistParam.DistFunc( &cDistParam );
2989}
2990
2991/** estimation of best merge coding
2992 * \param pcCU
2993 * \param pcYuvOrg
2994 * \param iPUIdx
2995 * \param uiInterDir
2996 * \param pacMvField
2997 * \param uiMergeIndex
2998 * \param ruiCost
2999 * \param ruiBits
3000 * \param puhNeighCands
3001 * \param bValid
3002 * \returns Void
3003 */
3004Void TEncSearch::xMergeEstimation( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPUIdx, UInt& uiInterDir, TComMvField* pacMvField, UInt& uiMergeIndex, UInt& ruiCost, TComMvField* cMvFieldNeighbours, UChar* uhInterDirNeighbours, Int& numValidMergeCand )
3005{
3006  UInt uiAbsPartIdx = 0;
3007  Int iWidth = 0;
3008  Int iHeight = 0; 
3009
3010  pcCU->getPartIndexAndSize( iPUIdx, uiAbsPartIdx, iWidth, iHeight );
3011  UInt uiDepth = pcCU->getDepth( uiAbsPartIdx );
3012  PartSize partSize = pcCU->getPartitionSize( 0 );
3013  if ( pcCU->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() && partSize != SIZE_2Nx2N && pcCU->getWidth( 0 ) <= 8 )
3014  {
3015    pcCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
3016    if ( iPUIdx == 0 )
3017    {
3018      pcCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours, numValidMergeCand );
3019    }
3020    pcCU->setPartSizeSubParts( partSize, 0, uiDepth );
3021  }
3022  else
3023  {
3024    pcCU->getInterMergeCandidates( uiAbsPartIdx, iPUIdx, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
3025  }
3026  xRestrictBipredMergeCand( pcCU, iPUIdx, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
3027
3028  ruiCost = MAX_UINT;
3029  for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
3030  {
3031#if REF_IDX_ME_ZEROMV
3032    Bool bZeroMVILR = pcCU->xCheckZeroMVILRMerge(uhInterDirNeighbours[uiMergeCand], cMvFieldNeighbours[0 + 2*uiMergeCand], cMvFieldNeighbours[1 + 2*uiMergeCand]);
3033    if(bZeroMVILR)
3034    {
3035#endif
3036#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
3037    if (!(pcCU->isInterLayerReference(uhInterDirNeighbours[uiMergeCand], cMvFieldNeighbours[0 + 2*uiMergeCand], cMvFieldNeighbours[1 + 2*uiMergeCand]) && m_disableILP))
3038    {
3039#endif
3040      UInt uiCostCand = MAX_UINT;
3041      UInt uiBitsCand = 0;
3042     
3043      PartSize ePartSize = pcCU->getPartitionSize( 0 );
3044
3045      pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], ePartSize, uiAbsPartIdx, 0, iPUIdx );
3046      pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], ePartSize, uiAbsPartIdx, 0, iPUIdx );
3047
3048      xGetInterPredictionError( pcCU, pcYuvOrg, iPUIdx, uiCostCand, m_pcEncCfg->getUseHADME() );
3049      uiBitsCand = uiMergeCand + 1;
3050      if (uiMergeCand == m_pcEncCfg->getMaxNumMergeCand() -1)
3051      {
3052         uiBitsCand--;
3053      }
3054      uiCostCand = uiCostCand + m_pcRdCost->getCost( uiBitsCand );
3055      if ( uiCostCand < ruiCost )
3056      {
3057        ruiCost = uiCostCand;
3058        pacMvField[0] = cMvFieldNeighbours[0 + 2*uiMergeCand];
3059        pacMvField[1] = cMvFieldNeighbours[1 + 2*uiMergeCand];
3060        uiInterDir = uhInterDirNeighbours[uiMergeCand];
3061        uiMergeIndex = uiMergeCand;
3062      }
3063#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
3064    }
3065#endif
3066#if REF_IDX_ME_ZEROMV
3067    }
3068#endif
3069  }
3070}
3071
3072/** convert bi-pred merge candidates to uni-pred
3073 * \param pcCU
3074 * \param puIdx
3075 * \param mvFieldNeighbours
3076 * \param interDirNeighbours
3077 * \param numValidMergeCand
3078 * \returns Void
3079 */
3080Void TEncSearch::xRestrictBipredMergeCand( TComDataCU* pcCU, UInt puIdx, TComMvField* mvFieldNeighbours, UChar* interDirNeighbours, Int numValidMergeCand )
3081{
3082  if ( pcCU->isBipredRestriction(puIdx) )
3083  {
3084    for( UInt mergeCand = 0; mergeCand < numValidMergeCand; ++mergeCand )
3085    {
3086      if ( interDirNeighbours[mergeCand] == 3 )
3087      {
3088        interDirNeighbours[mergeCand] = 1;
3089        mvFieldNeighbours[(mergeCand << 1) + 1].setMvField(TComMv(0,0), -1);
3090      }
3091    }
3092  }
3093}
3094
3095/** search of the best candidate for inter prediction
3096 * \param pcCU
3097 * \param pcOrgYuv
3098 * \param rpcPredYuv
3099 * \param rpcResiYuv
3100 * \param rpcRecoYuv
3101 * \param bUseRes
3102 * \returns Void
3103 */
3104#if AMP_MRG
3105Void TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv*& rpcPredYuv, TComYuv*& rpcResiYuv, TComYuv*& rpcRecoYuv, Bool bUseRes, Bool bUseMRG )
3106#else
3107Void TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv*& rpcPredYuv, TComYuv*& rpcResiYuv, TComYuv*& rpcRecoYuv, Bool bUseRes )
3108#endif
3109{
3110  m_acYuvPred[0].clear();
3111  m_acYuvPred[1].clear();
3112  m_cYuvPredTemp.clear();
3113  rpcPredYuv->clear();
3114 
3115  if ( !bUseRes )
3116  {
3117    rpcResiYuv->clear();
3118  }
3119 
3120  rpcRecoYuv->clear();
3121 
3122  TComMv        cMvSrchRngLT;
3123  TComMv        cMvSrchRngRB;
3124 
3125  TComMv        cMvZero;
3126  TComMv        TempMv; //kolya
3127 
3128  TComMv        cMv[2];
3129  TComMv        cMvBi[2];
3130  TComMv        cMvTemp[2][33];
3131 
3132  Int           iNumPart    = pcCU->getNumPartInter();
3133  Int           iNumPredDir = pcCU->getSlice()->isInterP() ? 1 : 2;
3134 
3135  TComMv        cMvPred[2][33];
3136 
3137  TComMv        cMvPredBi[2][33];
3138  Int           aaiMvpIdxBi[2][33];
3139 
3140  Int           aaiMvpIdx[2][33];
3141  Int           aaiMvpNum[2][33];
3142 
3143  AMVPInfo aacAMVPInfo[2][33];
3144 
3145  Int           iRefIdx[2]={0,0}; //If un-initialized, may cause SEGV in bi-directional prediction iterative stage.
3146  Int           iRefIdxBi[2];
3147 
3148  UInt          uiPartAddr;
3149  Int           iRoiWidth, iRoiHeight;
3150 
3151  UInt          uiMbBits[3] = {1, 1, 0};
3152 
3153  UInt          uiLastMode = 0;
3154  Int           iRefStart, iRefEnd;
3155 
3156  PartSize      ePartSize = pcCU->getPartitionSize( 0 );
3157
3158  Int           bestBiPRefIdxL1 = 0;
3159  Int           bestBiPMvpL1 = 0;
3160  UInt          biPDistTemp = MAX_INT;
3161
3162#if ZERO_MVD_EST
3163  Int           aiZeroMvdMvpIdx[2] = {-1, -1};
3164  Int           aiZeroMvdRefIdx[2] = {0, 0};
3165  Int           iZeroMvdDir = -1;
3166#endif
3167
3168  TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS << 1]; // double length for mv of both lists
3169  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
3170  Int numValidMergeCand = 0 ;
3171
3172  for ( Int iPartIdx = 0; iPartIdx < iNumPart; iPartIdx++ )
3173  {
3174    UInt          uiCost[2] = { MAX_UINT, MAX_UINT };
3175    UInt          uiCostBi  =   MAX_UINT;
3176    UInt          uiCostTemp;
3177   
3178    UInt          uiBits[3];
3179    UInt          uiBitsTemp;
3180#if ZERO_MVD_EST
3181    UInt          uiZeroMvdCost = MAX_UINT;
3182    UInt          uiZeroMvdCostTemp;
3183    UInt          uiZeroMvdBitsTemp;
3184    UInt          uiZeroMvdDistTemp = MAX_UINT;
3185    UInt          auiZeroMvdBits[3];
3186#endif
3187    UInt          bestBiPDist = MAX_INT;
3188
3189    UInt          uiCostTempL0[MAX_NUM_REF];
3190    for (Int iNumRef=0; iNumRef < MAX_NUM_REF; iNumRef++)
3191    {
3192      uiCostTempL0[iNumRef] = MAX_UINT;
3193    }
3194    UInt          uiBitsTempL0[MAX_NUM_REF];
3195
3196    TComMv        mvValidList1;
3197    Int           refIdxValidList1 = 0;
3198    UInt          bitsValidList1 = MAX_UINT;
3199    UInt          costValidList1 = MAX_UINT;
3200
3201    xGetBlkBits( ePartSize, pcCU->getSlice()->isInterP(), iPartIdx, uiLastMode, uiMbBits);
3202   
3203    pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iRoiWidth, iRoiHeight );
3204   
3205#if AMP_MRG
3206    Bool bTestNormalMC = true;
3207   
3208    if ( bUseMRG && pcCU->getWidth( 0 ) > 8 && iNumPart == 2 )
3209    {
3210      bTestNormalMC = false;
3211    }
3212   
3213    if (bTestNormalMC)
3214    {
3215#endif
3216
3217    //  Uni-directional prediction
3218    for ( Int iRefList = 0; iRefList < iNumPredDir; iRefList++ )
3219    {
3220      RefPicList  eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
3221     
3222      for ( Int iRefIdxTemp = 0; iRefIdxTemp < pcCU->getSlice()->getNumRefIdx(eRefPicList); iRefIdxTemp++ )
3223      {
3224#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
3225        if (pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxTemp )->isILR(pcCU->getLayerId()) && m_disableILP)
3226        {
3227          continue;
3228        }
3229#endif
3230#if (ENCODER_FAST_MODE)
3231        TComPic* pcPic    = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxTemp );
3232        if( pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N) ) 
3233        {
3234          continue;
3235        }
3236#endif
3237
3238        uiBitsTemp = uiMbBits[iRefList];
3239        if ( pcCU->getSlice()->getNumRefIdx(eRefPicList) > 1 )
3240        {
3241          uiBitsTemp += iRefIdxTemp+1;
3242          if ( iRefIdxTemp == pcCU->getSlice()->getNumRefIdx(eRefPicList)-1 ) uiBitsTemp--;
3243        }
3244#if ZERO_MVD_EST
3245        xEstimateMvPredAMVP( pcCU, pcOrgYuv, iPartIdx, eRefPicList, iRefIdxTemp, cMvPred[iRefList][iRefIdxTemp], false, &biPDistTemp, &uiZeroMvdDistTemp);
3246#else
3247        xEstimateMvPredAMVP( pcCU, pcOrgYuv, iPartIdx, eRefPicList, iRefIdxTemp, cMvPred[iRefList][iRefIdxTemp], false, &biPDistTemp);
3248#endif
3249        aaiMvpIdx[iRefList][iRefIdxTemp] = pcCU->getMVPIdx(eRefPicList, uiPartAddr);
3250        aaiMvpNum[iRefList][iRefIdxTemp] = pcCU->getMVPNum(eRefPicList, uiPartAddr);
3251       
3252        if(pcCU->getSlice()->getMvdL1ZeroFlag() && iRefList==1 && biPDistTemp < bestBiPDist)
3253        {
3254#if REF_IDX_ME_ZEROMV
3255          Bool bZeroMVILR = pcCU->xCheckZeroMVILRMvdL1Zero(iRefList, iRefIdxTemp, aaiMvpIdx[iRefList][iRefIdxTemp]);
3256          if(bZeroMVILR)
3257          {
3258#endif
3259          bestBiPDist = biPDistTemp;
3260          bestBiPMvpL1 = aaiMvpIdx[iRefList][iRefIdxTemp];
3261          bestBiPRefIdxL1 = iRefIdxTemp;
3262#if REF_IDX_ME_ZEROMV
3263          }
3264#endif
3265        }
3266
3267        uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
3268#if ZERO_MVD_EST
3269        if ( iRefList == 0 || pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 )
3270        {
3271          uiZeroMvdBitsTemp = uiBitsTemp;
3272          uiZeroMvdBitsTemp += 2; //zero mvd bits
3273
3274          m_pcRdCost->getMotionCost( 1, 0 );
3275          uiZeroMvdCostTemp = uiZeroMvdDistTemp + m_pcRdCost->getCost(uiZeroMvdBitsTemp);
3276
3277          if (uiZeroMvdCostTemp < uiZeroMvdCost)
3278          {
3279            uiZeroMvdCost = uiZeroMvdCostTemp;
3280            iZeroMvdDir = iRefList + 1;
3281            aiZeroMvdRefIdx[iRefList] = iRefIdxTemp;
3282            aiZeroMvdMvpIdx[iRefList] = aaiMvpIdx[iRefList][iRefIdxTemp];
3283            auiZeroMvdBits[iRefList] = uiZeroMvdBitsTemp;
3284          }         
3285        }
3286#endif
3287       
3288#if GPB_SIMPLE_UNI
3289        if ( iRefList == 1 )    // list 1
3290        {
3291          if ( pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) >= 0 )
3292          {
3293            cMvTemp[1][iRefIdxTemp] = cMvTemp[0][pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )];
3294            uiCostTemp = uiCostTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )];
3295            /*first subtract the bit-rate part of the cost of the other list*/
3296            uiCostTemp -= m_pcRdCost->getCost( uiBitsTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )] );
3297            /*correct the bit-rate part of the current ref*/
3298            m_pcRdCost->setPredictor  ( cMvPred[iRefList][iRefIdxTemp] );
3299            uiBitsTemp += m_pcRdCost->getBits( cMvTemp[1][iRefIdxTemp].getHor(), cMvTemp[1][iRefIdxTemp].getVer() );
3300            /*calculate the correct cost*/
3301            uiCostTemp += m_pcRdCost->getCost( uiBitsTemp );
3302          }
3303          else
3304          {
3305            xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
3306          }
3307        }
3308        else
3309        {
3310          xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
3311        }
3312#else
3313        xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
3314#endif
3315        xCopyAMVPInfo(pcCU->getCUMvField(eRefPicList)->getAMVPInfo(), &aacAMVPInfo[iRefList][iRefIdxTemp]); // must always be done ( also when AMVP_MODE = AM_NONE )
3316        xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
3317
3318        if ( iRefList == 0 )
3319        {
3320          uiCostTempL0[iRefIdxTemp] = uiCostTemp;
3321          uiBitsTempL0[iRefIdxTemp] = uiBitsTemp;
3322        }
3323        if ( uiCostTemp < uiCost[iRefList] )
3324        {
3325          uiCost[iRefList] = uiCostTemp;
3326          uiBits[iRefList] = uiBitsTemp; // storing for bi-prediction
3327
3328          // set motion
3329          cMv[iRefList]     = cMvTemp[iRefList][iRefIdxTemp];
3330          iRefIdx[iRefList] = iRefIdxTemp;
3331        }
3332
3333        if ( iRefList == 1 && uiCostTemp < costValidList1 && pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 )
3334        {
3335          costValidList1 = uiCostTemp;
3336          bitsValidList1 = uiBitsTemp;
3337
3338          // set motion
3339          mvValidList1     = cMvTemp[iRefList][iRefIdxTemp];
3340          refIdxValidList1 = iRefIdxTemp;
3341        }
3342      }
3343    }
3344    //  Bi-directional prediction
3345#if REF_IDX_ME_ZEROMV
3346    if ( (pcCU->getSlice()->isInterB()) && (pcCU->isBipredRestriction(iPartIdx) == false) && !(pcCU->getSlice()->getMvdL1ZeroFlag() && bestBiPDist == MAX_INT) )
3347#else
3348    if ( (pcCU->getSlice()->isInterB()) && (pcCU->isBipredRestriction(iPartIdx) == false) )
3349#endif
3350    {
3351     
3352      cMvBi[0] = cMv[0];            cMvBi[1] = cMv[1];
3353      iRefIdxBi[0] = iRefIdx[0];    iRefIdxBi[1] = iRefIdx[1];
3354     
3355      ::memcpy(cMvPredBi, cMvPred, sizeof(cMvPred));
3356      ::memcpy(aaiMvpIdxBi, aaiMvpIdx, sizeof(aaiMvpIdx));
3357     
3358      UInt uiMotBits[2];
3359
3360      if(pcCU->getSlice()->getMvdL1ZeroFlag())
3361      {
3362        xCopyAMVPInfo(&aacAMVPInfo[1][bestBiPRefIdxL1], pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo());
3363        pcCU->setMVPIdxSubParts( bestBiPMvpL1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3364        aaiMvpIdxBi[1][bestBiPRefIdxL1] = bestBiPMvpL1;
3365        cMvPredBi[1][bestBiPRefIdxL1]   = pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo()->m_acMvCand[bestBiPMvpL1];
3366
3367        cMvBi[1] = cMvPredBi[1][bestBiPRefIdxL1];
3368        iRefIdxBi[1] = bestBiPRefIdxL1;
3369        pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMv( cMvBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
3370        pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllRefIdx( iRefIdxBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
3371        TComYuv* pcYuvPred = &m_acYuvPred[1];
3372        motionCompensation( pcCU, pcYuvPred, REF_PIC_LIST_1, iPartIdx );
3373
3374        uiMotBits[0] = uiBits[0] - uiMbBits[0];
3375        uiMotBits[1] = uiMbBits[1];
3376
3377        if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1) > 1 )
3378        {
3379          uiMotBits[1] += bestBiPRefIdxL1+1;
3380          if ( bestBiPRefIdxL1 == pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1)-1 ) uiMotBits[1]--;
3381        }
3382
3383        uiMotBits[1] += m_auiMVPIdxCost[aaiMvpIdxBi[1][bestBiPRefIdxL1]][AMVP_MAX_NUM_CANDS];
3384
3385        uiBits[2] = uiMbBits[2] + uiMotBits[0] + uiMotBits[1];
3386
3387        cMvTemp[1][bestBiPRefIdxL1] = cMvBi[1];
3388      }
3389      else
3390      {
3391        uiMotBits[0] = uiBits[0] - uiMbBits[0];
3392        uiMotBits[1] = uiBits[1] - uiMbBits[1];
3393        uiBits[2] = uiMbBits[2] + uiMotBits[0] + uiMotBits[1];
3394      }
3395
3396      // 4-times iteration (default)
3397      Int iNumIter = 4;
3398     
3399      // fast encoder setting: only one iteration
3400      if ( m_pcEncCfg->getUseFastEnc() || pcCU->getSlice()->getMvdL1ZeroFlag())
3401      {
3402        iNumIter = 1;
3403      }
3404     
3405      for ( Int iIter = 0; iIter < iNumIter; iIter++ )
3406      {
3407       
3408        Int         iRefList    = iIter % 2;
3409        if ( m_pcEncCfg->getUseFastEnc() )
3410        {
3411          if( uiCost[0] <= uiCost[1] )
3412          {
3413            iRefList = 1;
3414          }
3415          else
3416          {
3417            iRefList = 0;
3418          }
3419        }
3420        else if ( iIter == 0 )
3421        {
3422          iRefList = 0;
3423        }
3424        if ( iIter == 0 && !pcCU->getSlice()->getMvdL1ZeroFlag())
3425        {
3426          pcCU->getCUMvField(RefPicList(1-iRefList))->setAllMv( cMv[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
3427          pcCU->getCUMvField(RefPicList(1-iRefList))->setAllRefIdx( iRefIdx[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
3428          TComYuv*  pcYuvPred = &m_acYuvPred[1-iRefList];
3429          motionCompensation ( pcCU, pcYuvPred, RefPicList(1-iRefList), iPartIdx );
3430        }
3431        RefPicList  eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
3432
3433        if(pcCU->getSlice()->getMvdL1ZeroFlag())
3434        {
3435          iRefList = 0;
3436          eRefPicList = REF_PIC_LIST_0;
3437        }
3438
3439        Bool bChanged = false;
3440       
3441#if (ENCODER_FAST_MODE)
3442        Bool     testIter = true;
3443        TComPic* pcPic    = pcCU->getSlice()->getRefPic( RefPicList(1 - iRefList), iRefIdxBi[1 - iRefList] );
3444        if(pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N))
3445        {
3446          testIter = false;  //the fixed part is ILR, skip this iteration       
3447        }
3448#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
3449        if (pcPic->isILR(pcCU->getLayerId()) && m_disableILP)
3450        {
3451          testIter = false;
3452        }
3453#endif
3454        if(testIter)
3455        {
3456#endif
3457        iRefStart = 0;
3458        iRefEnd   = pcCU->getSlice()->getNumRefIdx(eRefPicList)-1;
3459       
3460        for ( Int iRefIdxTemp = iRefStart; iRefIdxTemp <= iRefEnd; iRefIdxTemp++ )
3461        {
3462#if (ENCODER_FAST_MODE)
3463          Bool testRefIdx = true;
3464          pcPic           = pcCU->getSlice()->getRefPic( RefPicList(iRefList) , iRefIdxTemp );
3465          if(pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N))
3466          {
3467            testRefIdx = false;  //the refined part is ILR, skip this reference pic           
3468          }
3469#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
3470          if (pcPic->isILR(pcCU->getLayerId()) && m_disableILP)
3471          {
3472            testRefIdx = false;
3473          }
3474#endif
3475          if(testRefIdx)
3476          {
3477#endif
3478          uiBitsTemp = uiMbBits[2] + uiMotBits[1-iRefList];
3479          if ( pcCU->getSlice()->getNumRefIdx(eRefPicList) > 1 )
3480          {
3481            uiBitsTemp += iRefIdxTemp+1;
3482            if ( iRefIdxTemp == pcCU->getSlice()->getNumRefIdx(eRefPicList)-1 ) uiBitsTemp--;
3483          }
3484          uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdxBi[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
3485          // call ME
3486          xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPredBi[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp, true );
3487          xCopyAMVPInfo(&aacAMVPInfo[iRefList][iRefIdxTemp], pcCU->getCUMvField(eRefPicList)->getAMVPInfo());
3488          xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPredBi[iRefList][iRefIdxTemp], aaiMvpIdxBi[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
3489
3490          if ( uiCostTemp < uiCostBi )
3491          {
3492            bChanged = true;
3493           
3494            cMvBi[iRefList]     = cMvTemp[iRefList][iRefIdxTemp];
3495            iRefIdxBi[iRefList] = iRefIdxTemp;
3496           
3497            uiCostBi            = uiCostTemp;
3498            uiMotBits[iRefList] = uiBitsTemp - uiMbBits[2] - uiMotBits[1-iRefList];
3499            uiBits[2]           = uiBitsTemp;
3500           
3501            if(iNumIter!=1)
3502            {
3503              //  Set motion
3504              pcCU->getCUMvField( eRefPicList )->setAllMv( cMvBi[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
3505              pcCU->getCUMvField( eRefPicList )->setAllRefIdx( iRefIdxBi[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
3506
3507              TComYuv* pcYuvPred = &m_acYuvPred[iRefList];
3508              motionCompensation( pcCU, pcYuvPred, eRefPicList, iPartIdx );
3509            }
3510          }
3511#if (ENCODER_FAST_MODE)
3512          }
3513#endif
3514        }
3515#if (ENCODER_FAST_MODE)
3516        } // for loop-iRefIdxTemp
3517#endif
3518       
3519        if ( !bChanged )
3520        {
3521          if ( uiCostBi <= uiCost[0] && uiCostBi <= uiCost[1] )
3522          {
3523            xCopyAMVPInfo(&aacAMVPInfo[0][iRefIdxBi[0]], pcCU->getCUMvField(REF_PIC_LIST_0)->getAMVPInfo());
3524            xCheckBestMVP(pcCU, REF_PIC_LIST_0, cMvBi[0], cMvPredBi[0][iRefIdxBi[0]], aaiMvpIdxBi[0][iRefIdxBi[0]], uiBits[2], uiCostBi);
3525            if(!pcCU->getSlice()->getMvdL1ZeroFlag())
3526            {
3527              xCopyAMVPInfo(&aacAMVPInfo[1][iRefIdxBi[1]], pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo());
3528              xCheckBestMVP(pcCU, REF_PIC_LIST_1, cMvBi[1], cMvPredBi[1][iRefIdxBi[1]], aaiMvpIdxBi[1][iRefIdxBi[1]], uiBits[2], uiCostBi);
3529            }
3530          }
3531          break;
3532        }
3533      } // for loop-iter
3534    } // if (B_SLICE)
3535#if ZERO_MVD_EST
3536    if ( (pcCU->getSlice()->isInterB()) && (pcCU->isBipredRestriction(iPartIdx) == false) )
3537    {
3538      m_pcRdCost->getMotionCost( 1, 0 );
3539
3540      for ( Int iL0RefIdxTemp = 0; iL0RefIdxTemp <= pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_0)-1; iL0RefIdxTemp++ )
3541      for ( Int iL1RefIdxTemp = 0; iL1RefIdxTemp <= pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1)-1; iL1RefIdxTemp++ )
3542      {
3543        UInt uiRefIdxBitsTemp = 0;
3544        if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_0) > 1 )
3545        {
3546          uiRefIdxBitsTemp += iL0RefIdxTemp+1;
3547          if ( iL0RefIdxTemp == pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_0)-1 ) uiRefIdxBitsTemp--;
3548        }
3549        if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1) > 1 )
3550        {
3551          uiRefIdxBitsTemp += iL1RefIdxTemp+1;
3552          if ( iL1RefIdxTemp == pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1)-1 ) uiRefIdxBitsTemp--;
3553        }
3554
3555        Int iL0MVPIdx = 0;
3556        Int iL1MVPIdx = 0;
3557
3558        for (iL0MVPIdx = 0; iL0MVPIdx < aaiMvpNum[0][iL0RefIdxTemp]; iL0MVPIdx++)
3559        {
3560          for (iL1MVPIdx = 0; iL1MVPIdx < aaiMvpNum[1][iL1RefIdxTemp]; iL1MVPIdx++)
3561          {
3562            uiZeroMvdBitsTemp = uiRefIdxBitsTemp;
3563            uiZeroMvdBitsTemp += uiMbBits[2];
3564            uiZeroMvdBitsTemp += m_auiMVPIdxCost[iL0MVPIdx][aaiMvpNum[0][iL0RefIdxTemp]] + m_auiMVPIdxCost[iL1MVPIdx][aaiMvpNum[1][iL1RefIdxTemp]];
3565            uiZeroMvdBitsTemp += 4; //zero mvd for both directions
3566            pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( aacAMVPInfo[0][iL0RefIdxTemp].m_acMvCand[iL0MVPIdx], iL0RefIdxTemp, ePartSize, uiPartAddr, iPartIdx, 0 );
3567            pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( aacAMVPInfo[1][iL1RefIdxTemp].m_acMvCand[iL1MVPIdx], iL1RefIdxTemp, ePartSize, uiPartAddr, iPartIdx, 0 );
3568 
3569            xGetInterPredictionError( pcCU, pcOrgYuv, iPartIdx, uiZeroMvdDistTemp, m_pcEncCfg->getUseHADME() );
3570            uiZeroMvdCostTemp = uiZeroMvdDistTemp + m_pcRdCost->getCost( uiZeroMvdBitsTemp );
3571            if (uiZeroMvdCostTemp < uiZeroMvdCost)
3572            {
3573              uiZeroMvdCost = uiZeroMvdCostTemp;
3574              iZeroMvdDir = 3;
3575              aiZeroMvdMvpIdx[0] = iL0MVPIdx;
3576              aiZeroMvdMvpIdx[1] = iL1MVPIdx;
3577              aiZeroMvdRefIdx[0] = iL0RefIdxTemp;
3578              aiZeroMvdRefIdx[1] = iL1RefIdxTemp;
3579              auiZeroMvdBits[2] = uiZeroMvdBitsTemp;
3580            }
3581          }
3582        }
3583      }
3584    }
3585#endif
3586
3587#if AMP_MRG
3588    } //end if bTestNormalMC
3589#endif
3590    //  Clear Motion Field
3591    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( TComMvField(), ePartSize, uiPartAddr, 0, iPartIdx );
3592    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( TComMvField(), ePartSize, uiPartAddr, 0, iPartIdx );
3593    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( cMvZero,       ePartSize, uiPartAddr, 0, iPartIdx );
3594    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( cMvZero,       ePartSize, uiPartAddr, 0, iPartIdx );
3595
3596    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3597    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3598    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3599    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3600   
3601    UInt uiMEBits = 0;
3602    // Set Motion Field_
3603    cMv[1] = mvValidList1;
3604    iRefIdx[1] = refIdxValidList1;
3605    uiBits[1] = bitsValidList1;
3606    uiCost[1] = costValidList1;
3607#if AMP_MRG
3608    if (bTestNormalMC)
3609    {
3610#endif
3611#if ZERO_MVD_EST
3612    if (uiZeroMvdCost <= uiCostBi && uiZeroMvdCost <= uiCost[0] && uiZeroMvdCost <= uiCost[1])
3613    {
3614      if (iZeroMvdDir == 3)
3615      {
3616        uiLastMode = 2;
3617
3618        pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( aacAMVPInfo[0][aiZeroMvdRefIdx[0]].m_acMvCand[aiZeroMvdMvpIdx[0]], aiZeroMvdRefIdx[0], ePartSize, uiPartAddr, iPartIdx, 0 );
3619        pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( aacAMVPInfo[1][aiZeroMvdRefIdx[1]].m_acMvCand[aiZeroMvdMvpIdx[1]], aiZeroMvdRefIdx[1], ePartSize, uiPartAddr, iPartIdx, 0 );
3620 
3621        pcCU->setInterDirSubParts( 3, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
3622       
3623        pcCU->setMVPIdxSubParts( aiZeroMvdMvpIdx[0], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3624        pcCU->setMVPNumSubParts( aaiMvpNum[0][aiZeroMvdRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3625        pcCU->setMVPIdxSubParts( aiZeroMvdMvpIdx[1], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3626        pcCU->setMVPNumSubParts( aaiMvpNum[1][aiZeroMvdRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3627        uiMEBits = auiZeroMvdBits[2];
3628      }
3629      else if (iZeroMvdDir == 1)
3630      {       
3631        uiLastMode = 0;
3632
3633        pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( aacAMVPInfo[0][aiZeroMvdRefIdx[0]].m_acMvCand[aiZeroMvdMvpIdx[0]], aiZeroMvdRefIdx[0], ePartSize, uiPartAddr, iPartIdx, 0 );
3634
3635        pcCU->setInterDirSubParts( 1, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
3636       
3637        pcCU->setMVPIdxSubParts( aiZeroMvdMvpIdx[0], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3638        pcCU->setMVPNumSubParts( aaiMvpNum[0][aiZeroMvdRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3639        uiMEBits = auiZeroMvdBits[0];
3640      }
3641      else if (iZeroMvdDir == 2)
3642      {
3643        uiLastMode = 1;
3644
3645        pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( aacAMVPInfo[1][aiZeroMvdRefIdx[1]].m_acMvCand[aiZeroMvdMvpIdx[1]], aiZeroMvdRefIdx[1], ePartSize, uiPartAddr, iPartIdx, 0 );
3646
3647        pcCU->setInterDirSubParts( 2, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
3648       
3649        pcCU->setMVPIdxSubParts( aiZeroMvdMvpIdx[1], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3650        pcCU->setMVPNumSubParts( aaiMvpNum[1][aiZeroMvdRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3651        uiMEBits = auiZeroMvdBits[1];
3652      }
3653      else
3654      {
3655        assert(0);
3656      }
3657    }
3658    else
3659#endif
3660    if ( uiCostBi <= uiCost[0] && uiCostBi <= uiCost[1])
3661    {
3662      uiLastMode = 2;
3663      pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMv( cMvBi[0], ePartSize, uiPartAddr, 0, iPartIdx );
3664      pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx( iRefIdxBi[0], ePartSize, uiPartAddr, 0, iPartIdx );
3665      pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMv( cMvBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
3666      pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx( iRefIdxBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
3667     
3668      TempMv = cMvBi[0] - cMvPredBi[0][iRefIdxBi[0]];
3669      pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( TempMv,                 ePartSize, uiPartAddr, 0, iPartIdx );
3670     
3671      TempMv = cMvBi[1] - cMvPredBi[1][iRefIdxBi[1]];
3672      pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( TempMv,                 ePartSize, uiPartAddr, 0, iPartIdx );
3673     
3674      pcCU->setInterDirSubParts( 3, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
3675     
3676      pcCU->setMVPIdxSubParts( aaiMvpIdxBi[0][iRefIdxBi[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3677      pcCU->setMVPNumSubParts( aaiMvpNum[0][iRefIdxBi[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3678      pcCU->setMVPIdxSubParts( aaiMvpIdxBi[1][iRefIdxBi[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3679      pcCU->setMVPNumSubParts( aaiMvpNum[1][iRefIdxBi[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3680
3681      uiMEBits = uiBits[2];
3682    }
3683    else if ( uiCost[0] <= uiCost[1] )
3684    {
3685      uiLastMode = 0;
3686      pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMv( cMv[0], ePartSize, uiPartAddr, 0, iPartIdx );
3687      pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx( iRefIdx[0], ePartSize, uiPartAddr, 0, iPartIdx );
3688      TempMv = cMv[0] - cMvPred[0][iRefIdx[0]];
3689      pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( TempMv,                 ePartSize, uiPartAddr, 0, iPartIdx );
3690      pcCU->setInterDirSubParts( 1, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
3691     
3692      pcCU->setMVPIdxSubParts( aaiMvpIdx[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3693      pcCU->setMVPNumSubParts( aaiMvpNum[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3694
3695      uiMEBits = uiBits[0];
3696    }
3697    else
3698    {
3699      uiLastMode = 1;
3700      pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMv( cMv[1], ePartSize, uiPartAddr, 0, iPartIdx );
3701      pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx( iRefIdx[1], ePartSize, uiPartAddr, 0, iPartIdx );
3702      TempMv = cMv[1] - cMvPred[1][iRefIdx[1]];
3703      pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( TempMv,                 ePartSize, uiPartAddr, 0, iPartIdx );
3704      pcCU->setInterDirSubParts( 2, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
3705     
3706      pcCU->setMVPIdxSubParts( aaiMvpIdx[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3707      pcCU->setMVPNumSubParts( aaiMvpNum[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3708
3709      uiMEBits = uiBits[1];
3710    }
3711#if AMP_MRG
3712    } // end if bTestNormalMC
3713#endif
3714
3715    if ( pcCU->getPartitionSize( uiPartAddr ) != SIZE_2Nx2N )
3716    {
3717      UInt uiMRGInterDir = 0;     
3718      TComMvField cMRGMvField[2];
3719      UInt uiMRGIndex = 0;
3720
3721      UInt uiMEInterDir = 0;
3722      TComMvField cMEMvField[2];
3723
3724      m_pcRdCost->getMotionCost( 1, 0 );
3725#if AMP_MRG
3726      // calculate ME cost
3727      UInt uiMEError = MAX_UINT;
3728      UInt uiMECost = MAX_UINT;
3729
3730      if (bTestNormalMC)
3731      {
3732        xGetInterPredictionError( pcCU, pcOrgYuv, iPartIdx, uiMEError, m_pcEncCfg->getUseHADME() );
3733        uiMECost = uiMEError + m_pcRdCost->getCost( uiMEBits );
3734      }
3735#else
3736      // calculate ME cost
3737      UInt uiMEError = MAX_UINT;
3738      xGetInterPredictionError( pcCU, pcOrgYuv, iPartIdx, uiMEError, m_pcEncCfg->getUseHADME() );
3739      UInt uiMECost = uiMEError + m_pcRdCost->getCost( uiMEBits );
3740#endif
3741      // save ME result.
3742      uiMEInterDir = pcCU->getInterDir( uiPartAddr );
3743      pcCU->getMvField( pcCU, uiPartAddr, REF_PIC_LIST_0, cMEMvField[0] );
3744      pcCU->getMvField( pcCU, uiPartAddr, REF_PIC_LIST_1, cMEMvField[1] );
3745
3746      // find Merge result
3747      UInt uiMRGCost = MAX_UINT;
3748      xMergeEstimation( pcCU, pcOrgYuv, iPartIdx, uiMRGInterDir, cMRGMvField, uiMRGIndex, uiMRGCost, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand);
3749      if ( uiMRGCost < uiMECost )
3750      {
3751        // set Merge result
3752        pcCU->setMergeFlagSubParts ( true,          uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
3753        pcCU->setMergeIndexSubParts( uiMRGIndex,    uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
3754        pcCU->setInterDirSubParts  ( uiMRGInterDir, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
3755        pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMRGMvField[0], ePartSize, uiPartAddr, 0, iPartIdx );
3756        pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMRGMvField[1], ePartSize, uiPartAddr, 0, iPartIdx );
3757
3758        pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( cMvZero,            ePartSize, uiPartAddr, 0, iPartIdx );
3759        pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( cMvZero,            ePartSize, uiPartAddr, 0, iPartIdx );
3760
3761        pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3762        pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3763        pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3764        pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
3765      }
3766      else
3767      {
3768        // set ME result
3769        pcCU->setMergeFlagSubParts( false,        uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
3770        pcCU->setInterDirSubParts ( uiMEInterDir, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
3771        pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMEMvField[0], ePartSize, uiPartAddr, 0, iPartIdx );
3772        pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMEMvField[1], ePartSize, uiPartAddr, 0, iPartIdx );
3773      }
3774    }
3775
3776    //  MC
3777    motionCompensation ( pcCU, rpcPredYuv, REF_PIC_LIST_X, iPartIdx );
3778   
3779  } //  end of for ( Int iPartIdx = 0; iPartIdx < iNumPart; iPartIdx++ )
3780
3781  setWpScalingDistParam( pcCU, -1, REF_PIC_LIST_X );
3782
3783  return;
3784}
3785
3786// AMVP
3787#if ZERO_MVD_EST
3788Void TEncSearch::xEstimateMvPredAMVP( TComDataCU* pcCU, TComYuv* pcOrgYuv, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMvPred, Bool bFilled, UInt* puiDistBiP, UInt* puiDist  )
3789#else
3790Void TEncSearch::xEstimateMvPredAMVP( TComDataCU* pcCU, TComYuv* pcOrgYuv, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMvPred, Bool bFilled, UInt* puiDistBiP )
3791#endif
3792{
3793  AMVPInfo* pcAMVPInfo = pcCU->getCUMvField(eRefPicList)->getAMVPInfo();
3794 
3795  TComMv  cBestMv;
3796  Int     iBestIdx = 0;
3797  TComMv  cZeroMv;
3798  TComMv  cMvPred;
3799  UInt    uiBestCost = MAX_INT;
3800  UInt    uiPartAddr = 0;
3801  Int     iRoiWidth, iRoiHeight;
3802  Int     i;
3803 
3804  pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iRoiWidth, iRoiHeight );
3805  // Fill the MV Candidates
3806  if (!bFilled)
3807  {
3808    pcCU->fillMvpCand( uiPartIdx, uiPartAddr, eRefPicList, iRefIdx, pcAMVPInfo );
3809  }
3810 
3811  // initialize Mvp index & Mvp
3812  iBestIdx = 0;
3813  cBestMv  = pcAMVPInfo->m_acMvCand[0];
3814#if !ZERO_MVD_EST
3815  if (pcAMVPInfo->iN <= 1)
3816  {
3817    rcMvPred = cBestMv;
3818   
3819    pcCU->setMVPIdxSubParts( iBestIdx, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
3820    pcCU->setMVPNumSubParts( pcAMVPInfo->iN, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
3821
3822    if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefPicList==REF_PIC_LIST_1)
3823    {
3824#if ZERO_MVD_EST
3825      (*puiDistBiP) = xGetTemplateCost( pcCU, uiPartIdx, uiPartAddr, pcOrgYuv, &m_cYuvPredTemp, rcMvPred, 0, AMVP_MAX_NUM_CANDS, eRefPicList, iRefIdx, iRoiWidth, iRoiHeight, uiDist );
3826#else
3827      (*puiDistBiP) = xGetTemplateCost( pcCU, uiPartIdx, uiPartAddr, pcOrgYuv, &m_cYuvPredTemp, rcMvPred, 0, AMVP_MAX_NUM_CANDS, eRefPicList, iRefIdx, iRoiWidth, iRoiHeight);
3828#endif
3829    }
3830    return;
3831  }
3832#endif 
3833  if (bFilled)
3834  {
3835    assert(pcCU->getMVPIdx(eRefPicList,uiPartAddr) >= 0);
3836    rcMvPred = pcAMVPInfo->m_acMvCand[pcCU->getMVPIdx(eRefPicList,uiPartAddr)];
3837    return;
3838  }
3839 
3840  m_cYuvPredTemp.clear();
3841#if ZERO_MVD_EST
3842  UInt uiDist;
3843#endif
3844  //-- Check Minimum Cost.
3845  for ( i = 0 ; i < pcAMVPInfo->iN; i++)
3846  {
3847    UInt uiTmpCost;
3848#if ZERO_MVD_EST
3849    uiTmpCost = xGetTemplateCost( pcCU, uiPartIdx, uiPartAddr, pcOrgYuv, &m_cYuvPredTemp, pcAMVPInfo->m_acMvCand[i], i, AMVP_MAX_NUM_CANDS, eRefPicList, iRefIdx, iRoiWidth, iRoiHeight, uiDist );
3850#else
3851    uiTmpCost = xGetTemplateCost( pcCU, uiPartIdx, uiPartAddr, pcOrgYuv, &m_cYuvPredTemp, pcAMVPInfo->m_acMvCand[i], i, AMVP_MAX_NUM_CANDS, eRefPicList, iRefIdx, iRoiWidth, iRoiHeight);
3852#endif     
3853    if ( uiBestCost > uiTmpCost )
3854    {
3855      uiBestCost = uiTmpCost;
3856      cBestMv   = pcAMVPInfo->m_acMvCand[i];
3857      iBestIdx  = i;
3858      (*puiDistBiP) = uiTmpCost;
3859#if ZERO_MVD_EST
3860      (*puiDist) = uiDist;
3861#endif
3862    }
3863  }
3864
3865  m_cYuvPredTemp.clear();
3866 
3867  // Setting Best MVP
3868  rcMvPred = cBestMv;
3869  pcCU->setMVPIdxSubParts( iBestIdx, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
3870  pcCU->setMVPNumSubParts( pcAMVPInfo->iN, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
3871  return;
3872}
3873
3874UInt TEncSearch::xGetMvpIdxBits(Int iIdx, Int iNum)
3875{
3876  assert(iIdx >= 0 && iNum >= 0 && iIdx < iNum);
3877 
3878  if (iNum == 1)
3879  {
3880    return 0;
3881  }
3882 
3883  UInt uiLength = 1;
3884  Int iTemp = iIdx;
3885  if ( iTemp == 0 )
3886  {
3887    return uiLength;
3888  }
3889 
3890  Bool bCodeLast = ( iNum-1 > iTemp );
3891 
3892  uiLength += (iTemp-1);
3893 
3894  if( bCodeLast )
3895  {
3896    uiLength++;
3897  }
3898 
3899  return uiLength;
3900}
3901
3902Void TEncSearch::xGetBlkBits( PartSize eCUMode, Bool bPSlice, Int iPartIdx, UInt uiLastMode, UInt uiBlkBit[3])
3903{
3904  if ( eCUMode == SIZE_2Nx2N )
3905  {
3906    uiBlkBit[0] = (! bPSlice) ? 3 : 1;
3907    uiBlkBit[1] = 3;
3908    uiBlkBit[2] = 5;
3909  }
3910  else if ( (eCUMode == SIZE_2NxN || eCUMode == SIZE_2NxnU) || eCUMode == SIZE_2NxnD )
3911  {
3912    UInt aauiMbBits[2][3][3] = { { {0,0,3}, {0,0,0}, {0,0,0} } , { {5,7,7}, {7,5,7}, {9-3,9-3,9-3} } };
3913    if ( bPSlice )
3914    {
3915      uiBlkBit[0] = 3;
3916      uiBlkBit[1] = 0;
3917      uiBlkBit[2] = 0;
3918    }
3919    else
3920    {
3921      ::memcpy( uiBlkBit, aauiMbBits[iPartIdx][uiLastMode], 3*sizeof(UInt) );
3922    }
3923  }
3924  else if ( (eCUMode == SIZE_Nx2N || eCUMode == SIZE_nLx2N) || eCUMode == SIZE_nRx2N )
3925  {
3926    UInt aauiMbBits[2][3][3] = { { {0,2,3}, {0,0,0}, {0,0,0} } , { {5,7,7}, {7-2,7-2,9-2}, {9-3,9-3,9-3} } };
3927    if ( bPSlice )
3928    {
3929      uiBlkBit[0] = 3;
3930      uiBlkBit[1] = 0;
3931      uiBlkBit[2] = 0;
3932    }
3933    else
3934    {
3935      ::memcpy( uiBlkBit, aauiMbBits[iPartIdx][uiLastMode], 3*sizeof(UInt) );
3936    }
3937  }
3938  else if ( eCUMode == SIZE_NxN )
3939  {
3940    uiBlkBit[0] = (! bPSlice) ? 3 : 1;
3941    uiBlkBit[1] = 3;
3942    uiBlkBit[2] = 5;
3943  }
3944  else
3945  {
3946    printf("Wrong!\n");
3947    assert( 0 );
3948  }
3949}
3950
3951Void TEncSearch::xCopyAMVPInfo (AMVPInfo* pSrc, AMVPInfo* pDst)
3952{
3953  pDst->iN = pSrc->iN;
3954  for (Int i = 0; i < pSrc->iN; i++)
3955  {
3956    pDst->m_acMvCand[i] = pSrc->m_acMvCand[i];
3957  }
3958}
3959
3960Void TEncSearch::xCheckBestMVP ( TComDataCU* pcCU, RefPicList eRefPicList, TComMv cMv, TComMv& rcMvPred, Int& riMVPIdx, UInt& ruiBits, UInt& ruiCost )
3961{
3962  AMVPInfo* pcAMVPInfo = pcCU->getCUMvField(eRefPicList)->getAMVPInfo();
3963 
3964  assert(pcAMVPInfo->m_acMvCand[riMVPIdx] == rcMvPred);
3965 
3966  if (pcAMVPInfo->iN < 2) return;
3967 
3968  m_pcRdCost->getMotionCost( 1, 0 );
3969  m_pcRdCost->setCostScale ( 0    );
3970 
3971  Int iBestMVPIdx = riMVPIdx;
3972 
3973  m_pcRdCost->setPredictor( rcMvPred );
3974  Int iOrgMvBits  = m_pcRdCost->getBits(cMv.getHor(), cMv.getVer());
3975  iOrgMvBits += m_auiMVPIdxCost[riMVPIdx][AMVP_MAX_NUM_CANDS];
3976  Int iBestMvBits = iOrgMvBits;
3977 
3978  for (Int iMVPIdx = 0; iMVPIdx < pcAMVPInfo->iN; iMVPIdx++)
3979  {
3980    if (iMVPIdx == riMVPIdx) continue;
3981   
3982    m_pcRdCost->setPredictor( pcAMVPInfo->m_acMvCand[iMVPIdx] );
3983   
3984    Int iMvBits = m_pcRdCost->getBits(cMv.getHor(), cMv.getVer());
3985    iMvBits += m_auiMVPIdxCost[iMVPIdx][AMVP_MAX_NUM_CANDS];
3986   
3987    if (iMvBits < iBestMvBits)
3988    {
3989      iBestMvBits = iMvBits;
3990      iBestMVPIdx = iMVPIdx;
3991    }
3992  }
3993 
3994  if (iBestMVPIdx != riMVPIdx)  //if changed
3995  {
3996    rcMvPred = pcAMVPInfo->m_acMvCand[iBestMVPIdx];
3997   
3998    riMVPIdx = iBestMVPIdx;
3999    UInt uiOrgBits = ruiBits;
4000    ruiBits = uiOrgBits - iOrgMvBits + iBestMvBits;
4001    ruiCost = (ruiCost - m_pcRdCost->getCost( uiOrgBits ))  + m_pcRdCost->getCost( ruiBits );
4002  }
4003}
4004
4005UInt TEncSearch::xGetTemplateCost( TComDataCU* pcCU,
4006                                  UInt        uiPartIdx,
4007                                  UInt      uiPartAddr,
4008                                  TComYuv*    pcOrgYuv,
4009                                  TComYuv*    pcTemplateCand,
4010                                  TComMv      cMvCand,
4011                                  Int         iMVPIdx,
4012                                  Int     iMVPNum,
4013                                  RefPicList  eRefPicList,
4014                                  Int         iRefIdx,
4015                                  Int         iSizeX,
4016                                  Int         iSizeY
4017                               #if ZERO_MVD_EST
4018                                , UInt&       ruiDist
4019                               #endif
4020                                  )
4021{
4022  UInt uiCost  = MAX_INT;
4023 
4024  TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec();
4025 
4026  pcCU->clipMv( cMvCand );
4027
4028  // prediction pattern
4029#if O0194_WEIGHTED_PREDICTION_CGS
4030  // Bug Fix (It did not check WP for BSlices)
4031  if ( pcCU->getSlice()->getPPS()->getUseWP())
4032#else
4033  if ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType()==P_SLICE )
4034#endif
4035  {
4036    xPredInterLumaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMvCand, iSizeX, iSizeY, pcTemplateCand, true );
4037  }
4038  else
4039  {
4040    xPredInterLumaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMvCand, iSizeX, iSizeY, pcTemplateCand, false );
4041  }
4042
4043#if O0194_WEIGHTED_PREDICTION_CGS
4044  if ( pcCU->getSlice()->getPPS()->getUseWP())
4045  ///< Bug Fix (It did not check WP for BSlices)
4046#else
4047  if ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType()==P_SLICE )
4048#endif
4049  {
4050    xWeightedPredictionUni( pcCU, pcTemplateCand, uiPartAddr, iSizeX, iSizeY, eRefPicList, pcTemplateCand, iRefIdx );
4051  }
4052
4053  // calc distortion
4054#if ZERO_MVD_EST
4055  m_pcRdCost->getMotionCost( 1, 0 );
4056  DistParam cDistParam;
4057  m_pcRdCost->setDistParam( cDistParam, g_bitDepthY,
4058                            pcOrgYuv->getLumaAddr(uiPartAddr), pcOrgYuv->getStride(), 
4059                            pcTemplateCand->getLumaAddr(uiPartAddr), pcTemplateCand->getStride(), 
4060                            iSizeX, iSizeY, m_pcEncCfg->getUseHADME() );
4061  ruiDist = cDistParam.DistFunc( &cDistParam );
4062  uiCost = ruiDist + m_pcRdCost->getCost( m_auiMVPIdxCost[iMVPIdx][iMVPNum] );
4063#else
4064  uiCost = m_pcRdCost->getDistPart(g_bitDepthY, pcTemplateCand->getLumaAddr(uiPartAddr), pcTemplateCand->getStride(), pcOrgYuv->getLumaAddr(uiPartAddr), pcOrgYuv->getStride(), iSizeX, iSizeY, TEXT_LUMA, DF_SAD );
4065  uiCost = (UInt) m_pcRdCost->calcRdCost( m_auiMVPIdxCost[iMVPIdx][iMVPNum], uiCost, false, DF_SAD );
4066#endif
4067  return uiCost;
4068}
4069
4070Void TEncSearch::xMotionEstimation( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPartIdx, RefPicList eRefPicList, TComMv* pcMvPred, Int iRefIdxPred, TComMv& rcMv, UInt& ruiBits, UInt& ruiCost, Bool bBi  )
4071{
4072  UInt          uiPartAddr;
4073  Int           iRoiWidth;
4074  Int           iRoiHeight;
4075 
4076  TComMv        cMvHalf, cMvQter;
4077  TComMv        cMvSrchRngLT;
4078  TComMv        cMvSrchRngRB;
4079 
4080  TComYuv*      pcYuv = pcYuvOrg;
4081  m_iSearchRange = m_aaiAdaptSR[eRefPicList][iRefIdxPred];
4082 
4083  Int           iSrchRng      = ( bBi ? m_bipredSearchRange : m_iSearchRange );
4084  TComPattern*  pcPatternKey  = pcCU->getPattern        ();
4085 
4086  Double        fWeight       = 1.0;
4087 
4088  pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iRoiWidth, iRoiHeight );
4089 
4090  if ( bBi )
4091  {
4092    TComYuv*  pcYuvOther = &m_acYuvPred[1-(Int)eRefPicList];
4093    pcYuv                = &m_cYuvPredTemp;
4094   
4095    pcYuvOrg->copyPartToPartYuv( pcYuv, uiPartAddr, iRoiWidth, iRoiHeight );
4096   
4097    pcYuv->removeHighFreq( pcYuvOther, uiPartAddr, iRoiWidth, iRoiHeight );
4098   
4099    fWeight = 0.5;
4100  }
4101 
4102  //  Search key pattern initialization
4103  pcPatternKey->initPattern( pcYuv->getLumaAddr( uiPartAddr ),
4104                            pcYuv->getCbAddr  ( uiPartAddr ),
4105                            pcYuv->getCrAddr  ( uiPartAddr ),
4106                            iRoiWidth,
4107                            iRoiHeight,
4108                            pcYuv->getStride(),
4109                            0, 0 );
4110 
4111  Pel*        piRefY      = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr );
4112  Int         iRefStride  = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->getPicYuvRec()->getStride();
4113 
4114  TComMv      cMvPred = *pcMvPred;
4115 
4116  if ( bBi )  xSetSearchRange   ( pcCU, rcMv   , iSrchRng, cMvSrchRngLT, cMvSrchRngRB );
4117  else        xSetSearchRange   ( pcCU, cMvPred, iSrchRng, cMvSrchRngLT, cMvSrchRngRB );
4118 
4119  m_pcRdCost->getMotionCost ( 1, 0 );
4120 
4121  m_pcRdCost->setPredictor  ( *pcMvPred );
4122  m_pcRdCost->setCostScale  ( 2 );
4123
4124  setWpScalingDistParam( pcCU, iRefIdxPred, eRefPicList );
4125  //  Do integer search
4126#if REF_IDX_ME_ZEROMV
4127  if( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->isILR(pcCU->getLayerId()))  //ILR reference pic
4128  {
4129    rcMv.setZero();  //use Mv(0, 0) for integer ME
4130  }
4131  else  //non ILR reference pic
4132  {
4133    if ( !m_iFastSearch || bBi ) 
4134    { 
4135      xPatternSearch      ( pcPatternKey, piRefY, iRefStride, &cMvSrchRngLT, &cMvSrchRngRB, rcMv, ruiCost ); 
4136    } 
4137    else 
4138    { 
4139      rcMv = *pcMvPred; 
4140      xPatternSearchFast  ( pcCU, pcPatternKey, piRefY, iRefStride, &cMvSrchRngLT, &cMvSrchRngRB, rcMv, ruiCost ); 
4141    }
4142  }
4143#else
4144  if ( !m_iFastSearch || bBi )
4145  {
4146    xPatternSearch      ( pcPatternKey, piRefY, iRefStride, &cMvSrchRngLT, &cMvSrchRngRB, rcMv, ruiCost );
4147  }
4148  else
4149  {
4150    rcMv = *pcMvPred;
4151    xPatternSearchFast  ( pcCU, pcPatternKey, piRefY, iRefStride, &cMvSrchRngLT, &cMvSrchRngRB, rcMv, ruiCost );
4152  }
4153#endif
4154 
4155  m_pcRdCost->getMotionCost( 1, 0 );
4156  m_pcRdCost->setCostScale ( 1 );
4157
4158#if REF_IDX_ME_ZEROMV
4159  if( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->isILR(pcCU->getLayerId()))  //ILR reference pic
4160  {
4161    xPatternSearchFracDIFMv0( pcCU, pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost, bBi );
4162  }
4163  else    //non ILR reference pic
4164  {
4165    xPatternSearchFracDIF( pcCU, pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost, bBi );
4166  }
4167#else
4168  xPatternSearchFracDIF( pcCU, pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost,bBi );
4169#endif
4170
4171  m_pcRdCost->setCostScale( 0 );
4172  rcMv <<= 2;
4173  rcMv += (cMvHalf <<= 1);
4174  rcMv +=  cMvQter;
4175 
4176  UInt uiMvBits = m_pcRdCost->getBits( rcMv.getHor(), rcMv.getVer() );
4177 
4178  ruiBits      += uiMvBits;
4179  ruiCost       = (UInt)( floor( fWeight * ( (Double)ruiCost - (Double)m_pcRdCost->getCost( uiMvBits ) ) ) + (Double)m_pcRdCost->getCost( ruiBits ) );
4180}
4181
4182
4183Void TEncSearch::xSetSearchRange ( TComDataCU* pcCU, TComMv& cMvPred, Int iSrchRng, TComMv& rcMvSrchRngLT, TComMv& rcMvSrchRngRB )
4184{
4185  Int  iMvShift = 2;
4186  TComMv cTmpMvPred = cMvPred;
4187  pcCU->clipMv( cTmpMvPred );
4188
4189  rcMvSrchRngLT.setHor( cTmpMvPred.getHor() - (iSrchRng << iMvShift) );
4190  rcMvSrchRngLT.setVer( cTmpMvPred.getVer() - (iSrchRng << iMvShift) );
4191 
4192  rcMvSrchRngRB.setHor( cTmpMvPred.getHor() + (iSrchRng << iMvShift) );
4193  rcMvSrchRngRB.setVer( cTmpMvPred.getVer() + (iSrchRng << iMvShift) );
4194  pcCU->clipMv        ( rcMvSrchRngLT );
4195  pcCU->clipMv        ( rcMvSrchRngRB );
4196 
4197  rcMvSrchRngLT >>= iMvShift;
4198  rcMvSrchRngRB >>= iMvShift;
4199}
4200
4201Void TEncSearch::xPatternSearch( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, TComMv& rcMv, UInt& ruiSAD )
4202{
4203  Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
4204  Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
4205  Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
4206  Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
4207 
4208  UInt  uiSad;
4209  UInt  uiSadBest         = MAX_UINT;
4210  Int   iBestX = 0;
4211  Int   iBestY = 0;
4212 
4213  Pel*  piRefSrch;
4214 
4215  //-- jclee for using the SAD function pointer
4216  m_pcRdCost->setDistParam( pcPatternKey, piRefY, iRefStride,  m_cDistParam );
4217 
4218  // fast encoder decision: use subsampled SAD for integer ME
4219  if ( m_pcEncCfg->getUseFastEnc() )
4220  {
4221    if ( m_cDistParam.iRows > 8 )
4222    {
4223      m_cDistParam.iSubShift = 1;
4224    }
4225  }
4226 
4227  piRefY += (iSrchRngVerTop * iRefStride);
4228  for ( Int y = iSrchRngVerTop; y <= iSrchRngVerBottom; y++ )
4229  {
4230    for ( Int x = iSrchRngHorLeft; x <= iSrchRngHorRight; x++ )
4231    {
4232      //  find min. distortion position
4233      piRefSrch = piRefY + x;
4234      m_cDistParam.pCur = piRefSrch;
4235
4236      setDistParamComp(0);
4237
4238      m_cDistParam.bitDepth = g_bitDepthY;
4239      uiSad = m_cDistParam.DistFunc( &m_cDistParam );
4240     
4241      // motion cost
4242      uiSad += m_pcRdCost->getCost( x, y );
4243     
4244      if ( uiSad < uiSadBest )
4245      {
4246        uiSadBest = uiSad;
4247        iBestX    = x;
4248        iBestY    = y;
4249      }
4250    }
4251    piRefY += iRefStride;
4252  }
4253 
4254  rcMv.set( iBestX, iBestY );
4255 
4256  ruiSAD = uiSadBest - m_pcRdCost->getCost( iBestX, iBestY );
4257  return;
4258}
4259
4260Void TEncSearch::xPatternSearchFast( TComDataCU* pcCU, TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, TComMv& rcMv, UInt& ruiSAD )
4261{
4262  pcCU->getMvPredLeft       ( m_acMvPredictors[0] );
4263  pcCU->getMvPredAbove      ( m_acMvPredictors[1] );
4264  pcCU->getMvPredAboveRight ( m_acMvPredictors[2] );
4265 
4266  switch ( m_iFastSearch )
4267  {
4268    case 1:
4269      xTZSearch( pcCU, pcPatternKey, piRefY, iRefStride, pcMvSrchRngLT, pcMvSrchRngRB, rcMv, ruiSAD );
4270      break;
4271     
4272    default:
4273      break;
4274  }
4275}
4276
4277Void TEncSearch::xTZSearch( TComDataCU* pcCU, TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, TComMv& rcMv, UInt& ruiSAD )
4278{
4279  Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
4280  Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
4281  Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
4282  Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
4283 
4284  TZ_SEARCH_CONFIGURATION
4285 
4286  UInt uiSearchRange = m_iSearchRange;
4287  pcCU->clipMv( rcMv );
4288  rcMv >>= 2;
4289  // init TZSearchStruct
4290  IntTZSearchStruct cStruct;
4291  cStruct.iYStride    = iRefStride;
4292  cStruct.piRefY      = piRefY;
4293  cStruct.uiBestSad   = MAX_UINT;
4294 
4295  // set rcMv (Median predictor) as start point and as best point
4296  xTZSearchHelp( pcPatternKey, cStruct, rcMv.getHor(), rcMv.getVer(), 0, 0 );
4297 
4298  // test whether one of PRED_A, PRED_B, PRED_C MV is better start point than Median predictor
4299  if ( bTestOtherPredictedMV )
4300  {
4301    for ( UInt index = 0; index < 3; index++ )
4302    {
4303      TComMv cMv = m_acMvPredictors[index];
4304      pcCU->clipMv( cMv );
4305      cMv >>= 2;
4306      xTZSearchHelp( pcPatternKey, cStruct, cMv.getHor(), cMv.getVer(), 0, 0 );
4307    }
4308  }
4309 
4310  // test whether zero Mv is better start point than Median predictor
4311  if ( bTestZeroVector )
4312  {
4313    xTZSearchHelp( pcPatternKey, cStruct, 0, 0, 0, 0 );
4314  }
4315 
4316  // start search
4317  Int  iDist = 0;
4318  Int  iStartX = cStruct.iBestX;
4319  Int  iStartY = cStruct.iBestY;
4320 
4321  // first search
4322  for ( iDist = 1; iDist <= (Int)uiSearchRange; iDist*=2 )
4323  {
4324    if ( bFirstSearchDiamond == 1 )
4325    {
4326      xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
4327    }
4328    else
4329    {
4330      xTZ8PointSquareSearch  ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
4331    }
4332   
4333    if ( bFirstSearchStop && ( cStruct.uiBestRound >= uiFirstSearchRounds ) ) // stop criterion
4334    {
4335      break;
4336    }
4337  }
4338 
4339  // test whether zero Mv is a better start point than Median predictor
4340  if ( bTestZeroVectorStart && ((cStruct.iBestX != 0) || (cStruct.iBestY != 0)) )
4341  {
4342    xTZSearchHelp( pcPatternKey, cStruct, 0, 0, 0, 0 );
4343    if ( (cStruct.iBestX == 0) && (cStruct.iBestY == 0) )
4344    {
4345      // test its neighborhood
4346      for ( iDist = 1; iDist <= (Int)uiSearchRange; iDist*=2 )
4347      {
4348        xTZ8PointDiamondSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, 0, 0, iDist );
4349        if ( bTestZeroVectorStop && (cStruct.uiBestRound > 0) ) // stop criterion
4350        {
4351          break;
4352        }
4353      }
4354    }
4355  }
4356 
4357  // calculate only 2 missing points instead 8 points if cStruct.uiBestDistance == 1
4358  if ( cStruct.uiBestDistance == 1 )
4359  {
4360    cStruct.uiBestDistance = 0;
4361    xTZ2PointSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB );
4362  }
4363 
4364  // raster search if distance is too big
4365  if ( bEnableRasterSearch && ( ((Int)(cStruct.uiBestDistance) > iRaster) || bAlwaysRasterSearch ) )
4366  {
4367    cStruct.uiBestDistance = iRaster;
4368    for ( iStartY = iSrchRngVerTop; iStartY <= iSrchRngVerBottom; iStartY += iRaster )
4369    {
4370      for ( iStartX = iSrchRngHorLeft; iStartX <= iSrchRngHorRight; iStartX += iRaster )
4371      {
4372        xTZSearchHelp( pcPatternKey, cStruct, iStartX, iStartY, 0, iRaster );
4373      }
4374    }
4375  }
4376 
4377  // raster refinement
4378  if ( bRasterRefinementEnable && cStruct.uiBestDistance > 0 )
4379  {
4380    while ( cStruct.uiBestDistance > 0 )
4381    {
4382      iStartX = cStruct.iBestX;
4383      iStartY = cStruct.iBestY;
4384      if ( cStruct.uiBestDistance > 1 )
4385      {
4386        iDist = cStruct.uiBestDistance >>= 1;
4387        if ( bRasterRefinementDiamond == 1 )
4388        {
4389          xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
4390        }
4391        else
4392        {
4393          xTZ8PointSquareSearch  ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
4394        }
4395      }
4396     
4397      // calculate only 2 missing points instead 8 points if cStruct.uiBestDistance == 1
4398      if ( cStruct.uiBestDistance == 1 )
4399      {
4400        cStruct.uiBestDistance = 0;
4401        if ( cStruct.ucPointNr != 0 )
4402        {
4403          xTZ2PointSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB );
4404        }
4405      }
4406    }
4407  }
4408 
4409  // start refinement
4410  if ( bStarRefinementEnable && cStruct.uiBestDistance > 0 )
4411  {
4412    while ( cStruct.uiBestDistance > 0 )
4413    {
4414      iStartX = cStruct.iBestX;
4415      iStartY = cStruct.iBestY;
4416      cStruct.uiBestDistance = 0;
4417      cStruct.ucPointNr = 0;
4418      for ( iDist = 1; iDist < (Int)uiSearchRange + 1; iDist*=2 )
4419      {
4420        if ( bStarRefinementDiamond == 1 )
4421        {
4422          xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
4423        }
4424        else
4425        {
4426          xTZ8PointSquareSearch  ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
4427        }
4428        if ( bStarRefinementStop && (cStruct.uiBestRound >= uiStarRefinementRounds) ) // stop criterion
4429        {
4430          break;
4431        }
4432      }
4433     
4434      // calculate only 2 missing points instead 8 points if cStrukt.uiBestDistance == 1
4435      if ( cStruct.uiBestDistance == 1 )
4436      {
4437        cStruct.uiBestDistance = 0;
4438        if ( cStruct.ucPointNr != 0 )
4439        {
4440          xTZ2PointSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB );
4441        }
4442      }
4443    }
4444  }
4445 
4446  // write out best match
4447  rcMv.set( cStruct.iBestX, cStruct.iBestY );
4448  ruiSAD = cStruct.uiBestSad - m_pcRdCost->getCost( cStruct.iBestX, cStruct.iBestY );
4449}
4450
4451Void TEncSearch::xPatternSearchFracDIF(TComDataCU* pcCU,
4452                                       TComPattern* pcPatternKey,
4453                                       Pel* piRefY,
4454                                       Int iRefStride,
4455                                       TComMv* pcMvInt,
4456                                       TComMv& rcMvHalf,
4457                                       TComMv& rcMvQter,
4458                                       UInt& ruiCost
4459                                       ,Bool biPred
4460                                       )
4461{
4462  //  Reference pattern initialization (integer scale)
4463  TComPattern cPatternRoi;
4464  Int         iOffset    = pcMvInt->getHor() + pcMvInt->getVer() * iRefStride;
4465  cPatternRoi.initPattern( piRefY +  iOffset,
4466                          NULL,
4467                          NULL,
4468                          pcPatternKey->getROIYWidth(),
4469                          pcPatternKey->getROIYHeight(),
4470                          iRefStride,
4471                          0, 0 );
4472 
4473  //  Half-pel refinement
4474  xExtDIFUpSamplingH ( &cPatternRoi, biPred );
4475 
4476  rcMvHalf = *pcMvInt;   rcMvHalf <<= 1;    // for mv-cost
4477  TComMv baseRefMv(0, 0);
4478  ruiCost = xPatternRefinement( pcPatternKey, baseRefMv, 2, rcMvHalf   );
4479 
4480  m_pcRdCost->setCostScale( 0 );
4481 
4482  xExtDIFUpSamplingQ ( &cPatternRoi, rcMvHalf, biPred );
4483  baseRefMv = rcMvHalf;
4484  baseRefMv <<= 1;
4485 
4486  rcMvQter = *pcMvInt;   rcMvQter <<= 1;    // for mv-cost
4487  rcMvQter += rcMvHalf;  rcMvQter <<= 1;
4488  ruiCost = xPatternRefinement( pcPatternKey, baseRefMv, 1, rcMvQter );
4489}
4490
4491/** encode residual and calculate rate-distortion for a CU block
4492 * \param pcCU
4493 * \param pcYuvOrg
4494 * \param pcYuvPred
4495 * \param rpcYuvResi
4496 * \param rpcYuvResiBest
4497 * \param rpcYuvRec
4498 * \param bSkipRes
4499 * \returns Void
4500 */
4501Void TEncSearch::encodeResAndCalcRdInterCU( TComDataCU* pcCU, TComYuv* pcYuvOrg, TComYuv* pcYuvPred, TComYuv*& rpcYuvResi, TComYuv*& rpcYuvResiBest, TComYuv*& rpcYuvRec, Bool bSkipRes )
4502{
4503  if ( pcCU->isIntra(0) )
4504  {
4505    return;
4506  }
4507 
4508  Bool      bHighPass    = pcCU->getSlice()->getDepth() ? true : false;
4509  UInt      uiBits       = 0, uiBitsBest = 0;
4510  UInt      uiDistortion = 0, uiDistortionBest = 0;
4511 
4512  UInt      uiWidth      = pcCU->getWidth ( 0 );
4513  UInt      uiHeight     = pcCU->getHeight( 0 );
4514 
4515  //  No residual coding : SKIP mode
4516  if ( bSkipRes )
4517  {
4518    pcCU->setSkipFlagSubParts( true, 0, pcCU->getDepth(0) );
4519
4520    rpcYuvResi->clear();
4521   
4522    pcYuvPred->copyToPartYuv( rpcYuvRec, 0 );
4523   
4524    uiDistortion = m_pcRdCost->getDistPart(g_bitDepthY, rpcYuvRec->getLumaAddr(), rpcYuvRec->getStride(),  pcYuvOrg->getLumaAddr(), pcYuvOrg->getStride(),  uiWidth,      uiHeight      )
4525    + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCbAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCbAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1, TEXT_CHROMA_U )
4526    + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCrAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCrAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1, TEXT_CHROMA_V );
4527
4528    m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST]);
4529   
4530    m_pcEntropyCoder->resetBits();
4531    if (pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
4532    {
4533      m_pcEntropyCoder->encodeCUTransquantBypassFlag(pcCU, 0, true);
4534    }
4535    m_pcEntropyCoder->encodeSkipFlag(pcCU, 0, true);
4536    m_pcEntropyCoder->encodeMergeIndex( pcCU, 0, true );
4537   
4538    uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
4539    pcCU->getTotalBits()       = uiBits;
4540    pcCU->getTotalDistortion() = uiDistortion;
4541    pcCU->getTotalCost()       = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
4542   
4543    m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_TEMP_BEST]);
4544   
4545    pcCU->setCbfSubParts( 0, 0, 0, 0, pcCU->getDepth( 0 ) );
4546    pcCU->setTrIdxSubParts( 0, 0, pcCU->getDepth(0) );
4547   
4548    return;
4549  }
4550 
4551  //  Residual coding.
4552  Int    qp, qpBest = 0, qpMin, qpMax;
4553  Double  dCost, dCostBest = MAX_DOUBLE;
4554 
4555  UInt uiTrLevel = 0;
4556  if( (pcCU->getWidth(0) > pcCU->getSlice()->getSPS()->getMaxTrSize()) )
4557  {
4558    while( pcCU->getWidth(0) > (pcCU->getSlice()->getSPS()->getMaxTrSize()<<uiTrLevel) ) uiTrLevel++;
4559  }
4560  UInt uiMaxTrMode = 1 + uiTrLevel;
4561 
4562  while((uiWidth>>uiMaxTrMode) < (g_uiMaxCUWidth>>g_uiMaxCUDepth)) uiMaxTrMode--;
4563 
4564#if REPN_FORMAT_IN_VPS
4565  qpMin =  bHighPass ? Clip3( -pcCU->getSlice()->getQpBDOffsetY(), MAX_QP, pcCU->getQP(0) - m_iMaxDeltaQP ) : pcCU->getQP( 0 );
4566  qpMax =  bHighPass ? Clip3( -pcCU->getSlice()->getQpBDOffsetY(), MAX_QP, pcCU->getQP(0) + m_iMaxDeltaQP ) : pcCU->getQP( 0 );
4567#else
4568  qpMin =  bHighPass ? Clip3( -pcCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, pcCU->getQP(0) - m_iMaxDeltaQP ) : pcCU->getQP( 0 );
4569  qpMax =  bHighPass ? Clip3( -pcCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, pcCU->getQP(0) + m_iMaxDeltaQP ) : pcCU->getQP( 0 );
4570#endif
4571
4572  rpcYuvResi->subtract( pcYuvOrg, pcYuvPred, 0, uiWidth );
4573
4574  for ( qp = qpMin; qp <= qpMax; qp++ )
4575  {
4576    dCost = 0.;
4577    uiBits = 0;
4578    uiDistortion = 0;
4579    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_CURR_BEST ] );
4580   
4581    UInt uiZeroDistortion = 0;
4582    xEstimateResidualQT( pcCU, 0, 0, 0, rpcYuvResi,  pcCU->getDepth(0), dCost, uiBits, uiDistortion, &uiZeroDistortion );
4583   
4584    m_pcEntropyCoder->resetBits();
4585    m_pcEntropyCoder->encodeQtRootCbfZero( pcCU );
4586    UInt zeroResiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
4587    Double dZeroCost = m_pcRdCost->calcRdCost( zeroResiBits, uiZeroDistortion );
4588    if(pcCU->isLosslessCoded( 0 ))
4589    { 
4590      dZeroCost = dCost + 1;
4591    }
4592    if ( dZeroCost < dCost )
4593    {
4594      dCost        = dZeroCost;
4595      uiBits       = 0;
4596      uiDistortion = uiZeroDistortion;
4597     
4598      const UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> (pcCU->getDepth(0) << 1);
4599      ::memset( pcCU->getTransformIdx()      , 0, uiQPartNum * sizeof(UChar) );
4600      ::memset( pcCU->getCbf( TEXT_LUMA )    , 0, uiQPartNum * sizeof(UChar) );
4601      ::memset( pcCU->getCbf( TEXT_CHROMA_U ), 0, uiQPartNum * sizeof(UChar) );
4602      ::memset( pcCU->getCbf( TEXT_CHROMA_V ), 0, uiQPartNum * sizeof(UChar) );
4603      ::memset( pcCU->getCoeffY()            , 0, uiWidth * uiHeight * sizeof( TCoeff )      );
4604      ::memset( pcCU->getCoeffCb()           , 0, uiWidth * uiHeight * sizeof( TCoeff ) >> 2 );
4605      ::memset( pcCU->getCoeffCr()           , 0, uiWidth * uiHeight * sizeof( TCoeff ) >> 2 );
4606      pcCU->setTransformSkipSubParts ( 0, 0, 0, 0, pcCU->getDepth(0) );
4607    }
4608    else
4609    {
4610      xSetResidualQTData( pcCU, 0, 0, 0, NULL, pcCU->getDepth(0), false );
4611    }
4612   
4613    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST] );
4614#if 0 // check
4615    {
4616      m_pcEntropyCoder->resetBits();
4617      m_pcEntropyCoder->encodeCoeff( pcCU, 0, pcCU->getDepth(0), pcCU->getWidth(0), pcCU->getHeight(0) );
4618      const UInt uiBitsForCoeff = m_pcEntropyCoder->getNumberOfWrittenBits();
4619      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST] );
4620      if( uiBitsForCoeff != uiBits )
4621        assert( 0 );
4622    }
4623#endif
4624    uiBits = 0;
4625    {
4626      TComYuv *pDummy = NULL;
4627      xAddSymbolBitsInter( pcCU, 0, 0, uiBits, pDummy, NULL, pDummy );
4628    }
4629   
4630   
4631    Double dExactCost = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
4632    dCost = dExactCost;
4633   
4634    if ( dCost < dCostBest )
4635    {
4636      if ( !pcCU->getQtRootCbf( 0 ) )
4637      {
4638        rpcYuvResiBest->clear();
4639      }
4640      else
4641      {
4642        xSetResidualQTData( pcCU, 0, 0, 0, rpcYuvResiBest, pcCU->getDepth(0), true );
4643      }
4644     
4645      if( qpMin != qpMax && qp != qpMax )
4646      {
4647        const UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> (pcCU->getDepth(0) << 1);
4648        ::memcpy( m_puhQTTempTrIdx, pcCU->getTransformIdx(),        uiQPartNum * sizeof(UChar) );
4649        ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA ),     uiQPartNum * sizeof(UChar) );
4650        ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ), uiQPartNum * sizeof(UChar) );
4651        ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ), uiQPartNum * sizeof(UChar) );
4652        ::memcpy( m_pcQTTempCoeffY,  pcCU->getCoeffY(),  uiWidth * uiHeight * sizeof( TCoeff )      );
4653        ::memcpy( m_pcQTTempCoeffCb, pcCU->getCoeffCb(), uiWidth * uiHeight * sizeof( TCoeff ) >> 2 );
4654        ::memcpy( m_pcQTTempCoeffCr, pcCU->getCoeffCr(), uiWidth * uiHeight * sizeof( TCoeff ) >> 2 );
4655#if ADAPTIVE_QP_SELECTION
4656        ::memcpy( m_pcQTTempArlCoeffY,  pcCU->getArlCoeffY(),  uiWidth * uiHeight * sizeof( Int )      );
4657        ::memcpy( m_pcQTTempArlCoeffCb, pcCU->getArlCoeffCb(), uiWidth * uiHeight * sizeof( Int ) >> 2 );
4658        ::memcpy( m_pcQTTempArlCoeffCr, pcCU->getArlCoeffCr(), uiWidth * uiHeight * sizeof( Int ) >> 2 );
4659#endif
4660        ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA),     uiQPartNum * sizeof( UChar ) );
4661        ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U), uiQPartNum * sizeof( UChar ) );
4662        ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V), uiQPartNum * sizeof( UChar ) );
4663      }
4664      uiBitsBest       = uiBits;
4665      uiDistortionBest = uiDistortion;
4666      dCostBest        = dCost;
4667      qpBest           = qp;
4668      m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_TEMP_BEST ] );
4669    }
4670  }
4671 
4672  assert ( dCostBest != MAX_DOUBLE );
4673 
4674  if( qpMin != qpMax && qpBest != qpMax )
4675  {
4676    assert( 0 ); // check
4677    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_TEMP_BEST ] );
4678
4679    // copy best cbf and trIdx to pcCU
4680    const UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> (pcCU->getDepth(0) << 1);
4681    ::memcpy( pcCU->getTransformIdx(),       m_puhQTTempTrIdx,  uiQPartNum * sizeof(UChar) );
4682    ::memcpy( pcCU->getCbf( TEXT_LUMA ),     m_puhQTTempCbf[0], uiQPartNum * sizeof(UChar) );
4683    ::memcpy( pcCU->getCbf( TEXT_CHROMA_U ), m_puhQTTempCbf[1], uiQPartNum * sizeof(UChar) );
4684    ::memcpy( pcCU->getCbf( TEXT_CHROMA_V ), m_puhQTTempCbf[2], uiQPartNum * sizeof(UChar) );
4685    ::memcpy( pcCU->getCoeffY(),  m_pcQTTempCoeffY,  uiWidth * uiHeight * sizeof( TCoeff )      );
4686    ::memcpy( pcCU->getCoeffCb(), m_pcQTTempCoeffCb, uiWidth * uiHeight * sizeof( TCoeff ) >> 2 );
4687    ::memcpy( pcCU->getCoeffCr(), m_pcQTTempCoeffCr, uiWidth * uiHeight * sizeof( TCoeff ) >> 2 );
4688#if ADAPTIVE_QP_SELECTION
4689    ::memcpy( pcCU->getArlCoeffY(),  m_pcQTTempArlCoeffY,  uiWidth * uiHeight * sizeof( Int )      );
4690    ::memcpy( pcCU->getArlCoeffCb(), m_pcQTTempArlCoeffCb, uiWidth * uiHeight * sizeof( Int ) >> 2 );
4691    ::memcpy( pcCU->getArlCoeffCr(), m_pcQTTempArlCoeffCr, uiWidth * uiHeight * sizeof( Int ) >> 2 );
4692#endif
4693    ::memcpy( pcCU->getTransformSkip(TEXT_LUMA),     m_puhQTTempTransformSkipFlag[0], uiQPartNum * sizeof( UChar ) );
4694    ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_U), m_puhQTTempTransformSkipFlag[1], uiQPartNum * sizeof( UChar ) );
4695    ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_V), m_puhQTTempTransformSkipFlag[2], uiQPartNum * sizeof( UChar ) );
4696  }
4697  rpcYuvRec->addClip ( pcYuvPred, rpcYuvResiBest, 0, uiWidth );
4698 
4699  // update with clipped distortion and cost (qp estimation loop uses unclipped values)
4700    uiDistortionBest = m_pcRdCost->getDistPart(g_bitDepthY, rpcYuvRec->getLumaAddr(), rpcYuvRec->getStride(),  pcYuvOrg->getLumaAddr(), pcYuvOrg->getStride(),  uiWidth,      uiHeight      )
4701    + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCbAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCbAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1, TEXT_CHROMA_U )
4702    + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCrAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCrAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1, TEXT_CHROMA_V );
4703  dCostBest = m_pcRdCost->calcRdCost( uiBitsBest, uiDistortionBest );
4704 
4705  pcCU->getTotalBits()       = uiBitsBest;
4706  pcCU->getTotalDistortion() = uiDistortionBest;
4707  pcCU->getTotalCost()       = dCostBest;
4708 
4709  if ( pcCU->isSkipped(0) )
4710  {
4711    pcCU->setCbfSubParts( 0, 0, 0, 0, pcCU->getDepth( 0 ) );
4712  }
4713 
4714  pcCU->setQPSubParts( qpBest, 0, pcCU->getDepth(0) );
4715}
4716
4717Void TEncSearch::xEstimateResidualQT( TComDataCU* pcCU, UInt uiQuadrant, UInt uiAbsPartIdx, UInt absTUPartIdx, TComYuv* pcResi, const UInt uiDepth, Double &rdCost, UInt &ruiBits, UInt &ruiDist, UInt *puiZeroDist )
4718{
4719  const UInt uiTrMode = uiDepth - pcCU->getDepth( 0 );
4720 
4721  assert( pcCU->getDepth( 0 ) == pcCU->getDepth( uiAbsPartIdx ) );
4722  const UInt uiLog2TrSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiDepth]+2;
4723 
4724  UInt SplitFlag = ((pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) && pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER && ( pcCU->getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N ));
4725  Bool bCheckFull;
4726  if ( SplitFlag && uiDepth == pcCU->getDepth(uiAbsPartIdx) && ( uiLog2TrSize >  pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) ) )
4727  {
4728     bCheckFull = false;
4729  }
4730  else
4731  {
4732     bCheckFull =  ( uiLog2TrSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() );
4733  }
4734
4735  const Bool bCheckSplit  = ( uiLog2TrSize >  pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
4736 
4737  assert( bCheckFull || bCheckSplit );
4738 
4739  Bool  bCodeChroma   = true;
4740  UInt  uiTrModeC     = uiTrMode;
4741  UInt  uiLog2TrSizeC = uiLog2TrSize-1;
4742  if( uiLog2TrSize == 2 )
4743  {
4744    uiLog2TrSizeC++;
4745    uiTrModeC    --;
4746    UInt  uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrModeC ) << 1 );
4747    bCodeChroma   = ( ( uiAbsPartIdx % uiQPDiv ) == 0 );
4748  }
4749 
4750  const UInt uiSetCbf = 1 << uiTrMode;
4751  // code full block
4752  Double dSingleCost = MAX_DOUBLE;
4753  UInt uiSingleBits = 0;
4754  UInt uiSingleDist = 0;
4755  UInt uiAbsSumY = 0, uiAbsSumU = 0, uiAbsSumV = 0;
4756  UInt uiBestTransformMode[3] = {0};
4757
4758  m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
4759 
4760  if( bCheckFull )
4761  {
4762    const UInt uiNumCoeffPerAbsPartIdxIncrement = pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
4763    const UInt uiQTTempAccessLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
4764    TCoeff *pcCoeffCurrY = m_ppcQTTempCoeffY [uiQTTempAccessLayer] +  uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx;
4765    TCoeff *pcCoeffCurrU = m_ppcQTTempCoeffCb[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
4766    TCoeff *pcCoeffCurrV = m_ppcQTTempCoeffCr[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
4767#if ADAPTIVE_QP_SELECTION   
4768    Int *pcArlCoeffCurrY = m_ppcQTTempArlCoeffY [uiQTTempAccessLayer] +  uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx;
4769    Int *pcArlCoeffCurrU = m_ppcQTTempArlCoeffCb[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
4770    Int *pcArlCoeffCurrV = m_ppcQTTempArlCoeffCr[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);   
4771#endif
4772   
4773    Int trWidth = 0, trHeight = 0, trWidthC = 0, trHeightC = 0;
4774    UInt absTUPartIdxC = uiAbsPartIdx;
4775
4776    trWidth  = trHeight  = 1 << uiLog2TrSize;
4777    trWidthC = trHeightC = 1 <<uiLog2TrSizeC;
4778    pcCU->setTrIdxSubParts( uiDepth - pcCU->getDepth( 0 ), uiAbsPartIdx, uiDepth );
4779    Double minCostY = MAX_DOUBLE;
4780    Double minCostU = MAX_DOUBLE;
4781    Double minCostV = MAX_DOUBLE;
4782    Bool checkTransformSkipY  = pcCU->getSlice()->getPPS()->getUseTransformSkip() && trWidth == 4 && trHeight == 4;
4783    Bool checkTransformSkipUV = pcCU->getSlice()->getPPS()->getUseTransformSkip() && trWidthC == 4 && trHeightC == 4;
4784
4785    checkTransformSkipY         &= (!pcCU->isLosslessCoded(0));
4786    checkTransformSkipUV        &= (!pcCU->isLosslessCoded(0));
4787
4788    pcCU->setTransformSkipSubParts ( 0, TEXT_LUMA, uiAbsPartIdx, uiDepth ); 
4789    if( bCodeChroma )
4790    {
4791      pcCU->setTransformSkipSubParts ( 0, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC ); 
4792      pcCU->setTransformSkipSubParts ( 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC ); 
4793    }
4794
4795    if (m_pcEncCfg->getUseRDOQ())
4796    {
4797      m_pcEntropyCoder->estimateBit(m_pcTrQuant->m_pcEstBitsSbac, trWidth, trHeight, TEXT_LUMA );       
4798    }
4799
4800#if REPN_FORMAT_IN_VPS
4801    m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getQpBDOffsetY(), 0 );
4802#else
4803    m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
4804#endif
4805
4806#if RDOQ_CHROMA_LAMBDA
4807    m_pcTrQuant->selectLambda(TEXT_LUMA); 
4808#endif
4809    m_pcTrQuant->transformNxN( pcCU, pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride (), pcCoeffCurrY, 
4810#if ADAPTIVE_QP_SELECTION
4811                                 pcArlCoeffCurrY, 
4812#endif     
4813                                 trWidth,   trHeight,    uiAbsSumY, TEXT_LUMA,     uiAbsPartIdx );
4814   
4815    pcCU->setCbfSubParts( uiAbsSumY ? uiSetCbf : 0, TEXT_LUMA, uiAbsPartIdx, uiDepth );
4816   
4817    if( bCodeChroma )
4818    {
4819      if (m_pcEncCfg->getUseRDOQ())
4820      {
4821        m_pcEntropyCoder->estimateBit(m_pcTrQuant->m_pcEstBitsSbac, trWidthC, trHeightC, TEXT_CHROMA );         
4822      }
4823
4824      Int curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCbQpOffset() + pcCU->getSlice()->getSliceQpDeltaCb();
4825      m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
4826
4827#if RDOQ_CHROMA_LAMBDA
4828      m_pcTrQuant->selectLambda(TEXT_CHROMA_U);
4829#endif
4830
4831      m_pcTrQuant->transformNxN( pcCU, pcResi->getCbAddr(absTUPartIdxC), pcResi->getCStride(), pcCoeffCurrU, 
4832#if ADAPTIVE_QP_SELECTION
4833                                 pcArlCoeffCurrU, 
4834#endif       
4835                                 trWidthC, trHeightC, uiAbsSumU, TEXT_CHROMA_U, uiAbsPartIdx );
4836
4837      curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();
4838      m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
4839     
4840#if RDOQ_CHROMA_LAMBDA
4841      m_pcTrQuant->selectLambda(TEXT_CHROMA_V);
4842#endif
4843
4844      m_pcTrQuant->transformNxN( pcCU, pcResi->getCrAddr(absTUPartIdxC), pcResi->getCStride(), pcCoeffCurrV, 
4845#if ADAPTIVE_QP_SELECTION
4846                                 pcArlCoeffCurrV, 
4847#endif       
4848                                 trWidthC, trHeightC, uiAbsSumV, TEXT_CHROMA_V, uiAbsPartIdx );
4849
4850      pcCU->setCbfSubParts( uiAbsSumU ? uiSetCbf : 0, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
4851      pcCU->setCbfSubParts( uiAbsSumV ? uiSetCbf : 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
4852    }
4853   
4854    m_pcEntropyCoder->resetBits();
4855   
4856    m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA,     uiTrMode );
4857
4858    m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrY, uiAbsPartIdx,  trWidth,  trHeight,    uiDepth, TEXT_LUMA );
4859    const UInt uiSingleBitsY = m_pcEntropyCoder->getNumberOfWrittenBits();
4860   
4861    UInt uiSingleBitsU = 0;
4862    UInt uiSingleBitsV = 0;
4863    if( bCodeChroma )
4864    {
4865      m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrMode );
4866      m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrU, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_U );
4867      uiSingleBitsU = m_pcEntropyCoder->getNumberOfWrittenBits() - uiSingleBitsY;
4868     
4869      m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrMode );
4870      m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrV, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_V );
4871      uiSingleBitsV = m_pcEntropyCoder->getNumberOfWrittenBits() - ( uiSingleBitsY + uiSingleBitsU );
4872    }
4873   
4874    const UInt uiNumSamplesLuma = 1 << (uiLog2TrSize<<1);
4875    const UInt uiNumSamplesChro = 1 << (uiLog2TrSizeC<<1);
4876   
4877    ::memset( m_pTempPel, 0, sizeof( Pel ) * uiNumSamplesLuma ); // not necessary needed for inside of recursion (only at the beginning)
4878   
4879    UInt uiDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pTempPel, trWidth, pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth, trHeight ); // initialized with zero residual destortion
4880
4881    if ( puiZeroDist )
4882    {
4883      *puiZeroDist += uiDistY;
4884    }
4885    if( uiAbsSumY )
4886    {
4887      Pel *pcResiCurrY = m_pcQTTempTComYuv[ uiQTTempAccessLayer ].getLumaAddr( absTUPartIdx );
4888
4889#if REPN_FORMAT_IN_VPS
4890      m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
4891#else
4892      m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
4893#endif
4894
4895      Int scalingListType = 3 + g_eTTable[(Int)TEXT_LUMA];
4896      assert(scalingListType < SCALING_LIST_NUM);
4897      m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,REG_DCT, pcResiCurrY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),  pcCoeffCurrY, trWidth, trHeight, scalingListType );//this is for inter mode only
4898     
4899      const UInt uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),
4900      pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth,trHeight );
4901      if (pcCU->isLosslessCoded(0)) 
4902      {
4903        uiDistY = uiNonzeroDistY;
4904      }
4905      else
4906      {
4907        const Double singleCostY = m_pcRdCost->calcRdCost( uiSingleBitsY, uiNonzeroDistY );
4908        m_pcEntropyCoder->resetBits();
4909        m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_LUMA,     uiTrMode );
4910        const UInt uiNullBitsY   = m_pcEntropyCoder->getNumberOfWrittenBits();
4911        const Double nullCostY   = m_pcRdCost->calcRdCost( uiNullBitsY, uiDistY );
4912        if( nullCostY < singleCostY ) 
4913        {   
4914          uiAbsSumY = 0;
4915          ::memset( pcCoeffCurrY, 0, sizeof( TCoeff ) * uiNumSamplesLuma );
4916          if( checkTransformSkipY )
4917          {
4918            minCostY = nullCostY;
4919          }
4920        }
4921        else
4922        {
4923          uiDistY = uiNonzeroDistY;
4924          if( checkTransformSkipY )
4925          {
4926            minCostY = singleCostY;
4927          }
4928        }
4929      }
4930    }
4931    else if( checkTransformSkipY )
4932    {
4933      m_pcEntropyCoder->resetBits();
4934      m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_LUMA, uiTrMode );
4935      const UInt uiNullBitsY = m_pcEntropyCoder->getNumberOfWrittenBits();
4936      minCostY = m_pcRdCost->calcRdCost( uiNullBitsY, uiDistY );
4937    }
4938
4939    if( !uiAbsSumY )
4940    {
4941      Pel *pcPtr =  m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx );
4942      const UInt uiStride = m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride();
4943      for( UInt uiY = 0; uiY < trHeight; ++uiY )
4944      {
4945        ::memset( pcPtr, 0, sizeof( Pel ) * trWidth );
4946        pcPtr += uiStride;
4947      } 
4948    }
4949   
4950    UInt uiDistU = 0;
4951    UInt uiDistV = 0;
4952    if( bCodeChroma )
4953    {
4954      uiDistU = m_pcRdCost->getDistPart(g_bitDepthC, m_pTempPel, trWidthC, pcResi->getCbAddr( absTUPartIdxC ), pcResi->getCStride(), trWidthC, trHeightC
4955                                        , TEXT_CHROMA_U
4956                                        ); // initialized with zero residual destortion
4957      if ( puiZeroDist )
4958      {
4959        *puiZeroDist += uiDistU;
4960      }
4961      if( uiAbsSumU )
4962      {
4963        Pel *pcResiCurrU = m_pcQTTempTComYuv[uiQTTempAccessLayer].getCbAddr( absTUPartIdxC );
4964
4965        Int curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCbQpOffset() + pcCU->getSlice()->getSliceQpDeltaCb();
4966        m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
4967
4968        Int scalingListType = 3 + g_eTTable[(Int)TEXT_CHROMA_U];
4969        assert(scalingListType < SCALING_LIST_NUM);
4970        m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA,REG_DCT, pcResiCurrU, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(), pcCoeffCurrU, trWidthC, trHeightC, scalingListType  );
4971       
4972        const UInt uiNonzeroDistU = m_pcRdCost->getDistPart(g_bitDepthC, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCbAddr( absTUPartIdxC), m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(),
4973                                                            pcResi->getCbAddr( absTUPartIdxC), pcResi->getCStride(), trWidthC, trHeightC
4974                                                            , TEXT_CHROMA_U
4975                                                            );
4976
4977        if(pcCU->isLosslessCoded(0)) 
4978        {
4979          uiDistU = uiNonzeroDistU;
4980        }
4981        else
4982        {
4983          const Double dSingleCostU = m_pcRdCost->calcRdCost( uiSingleBitsU, uiNonzeroDistU );
4984          m_pcEntropyCoder->resetBits();
4985          m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_U,     uiTrMode );
4986          const UInt uiNullBitsU    = m_pcEntropyCoder->getNumberOfWrittenBits();
4987          const Double dNullCostU   = m_pcRdCost->calcRdCost( uiNullBitsU, uiDistU );
4988          if( dNullCostU < dSingleCostU )
4989          {
4990            uiAbsSumU = 0;
4991            ::memset( pcCoeffCurrU, 0, sizeof( TCoeff ) * uiNumSamplesChro );
4992            if( checkTransformSkipUV )
4993            {
4994              minCostU = dNullCostU;
4995            }
4996          }
4997          else
4998          {
4999            uiDistU = uiNonzeroDistU;
5000            if( checkTransformSkipUV )
5001            {
5002              minCostU = dSingleCostU;
5003            }
5004          }
5005        }
5006      }
5007      else if( checkTransformSkipUV )
5008      {
5009        m_pcEntropyCoder->resetBits();
5010        m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_U, uiTrMode );
5011        const UInt uiNullBitsU = m_pcEntropyCoder->getNumberOfWrittenBits();
5012        minCostU = m_pcRdCost->calcRdCost( uiNullBitsU, uiDistU );
5013      }
5014      if( !uiAbsSumU )
5015      {
5016        Pel *pcPtr =  m_pcQTTempTComYuv[uiQTTempAccessLayer].getCbAddr( absTUPartIdxC );
5017          const UInt uiStride = m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride();
5018        for( UInt uiY = 0; uiY < trHeightC; ++uiY )
5019        {
5020          ::memset( pcPtr, 0, sizeof(Pel) * trWidthC );
5021          pcPtr += uiStride;
5022        }
5023      }
5024     
5025      uiDistV = m_pcRdCost->getDistPart(g_bitDepthC, m_pTempPel, trWidthC, pcResi->getCrAddr( absTUPartIdxC), pcResi->getCStride(), trWidthC, trHeightC
5026                                        , TEXT_CHROMA_V
5027                                        ); // initialized with zero residual destortion
5028      if ( puiZeroDist )
5029      {
5030        *puiZeroDist += uiDistV;
5031      }
5032      if( uiAbsSumV )
5033      {
5034        Pel *pcResiCurrV = m_pcQTTempTComYuv[uiQTTempAccessLayer].getCrAddr( absTUPartIdxC );
5035        Int curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();
5036        m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
5037
5038        Int scalingListType = 3 + g_eTTable[(Int)TEXT_CHROMA_V];
5039        assert(scalingListType < SCALING_LIST_NUM);
5040        m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA,REG_DCT, pcResiCurrV, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(), pcCoeffCurrV, trWidthC, trHeightC, scalingListType );
5041       
5042        const UInt uiNonzeroDistV = m_pcRdCost->getDistPart(g_bitDepthC, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCrAddr( absTUPartIdxC ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(),
5043                                                            pcResi->getCrAddr( absTUPartIdxC ), pcResi->getCStride(), trWidthC, trHeightC
5044                                                            , TEXT_CHROMA_V
5045                                                            );
5046        if (pcCU->isLosslessCoded(0)) 
5047        {
5048          uiDistV = uiNonzeroDistV;
5049        }
5050        else
5051        {
5052          const Double dSingleCostV = m_pcRdCost->calcRdCost( uiSingleBitsV, uiNonzeroDistV );
5053          m_pcEntropyCoder->resetBits();
5054          m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_V,     uiTrMode );
5055          const UInt uiNullBitsV    = m_pcEntropyCoder->getNumberOfWrittenBits();
5056          const Double dNullCostV   = m_pcRdCost->calcRdCost( uiNullBitsV, uiDistV );
5057          if( dNullCostV < dSingleCostV )
5058          {
5059            uiAbsSumV = 0;
5060            ::memset( pcCoeffCurrV, 0, sizeof( TCoeff ) * uiNumSamplesChro );
5061            if( checkTransformSkipUV )
5062            {
5063              minCostV = dNullCostV;
5064            }
5065          }
5066          else
5067          {
5068            uiDistV = uiNonzeroDistV;
5069            if( checkTransformSkipUV )
5070            {
5071              minCostV = dSingleCostV;
5072            }
5073          }
5074        }
5075      }
5076      else if( checkTransformSkipUV )
5077      {
5078        m_pcEntropyCoder->resetBits();
5079        m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_V, uiTrMode );
5080        const UInt uiNullBitsV = m_pcEntropyCoder->getNumberOfWrittenBits();
5081        minCostV = m_pcRdCost->calcRdCost( uiNullBitsV, uiDistV );
5082      }
5083      if( !uiAbsSumV )
5084      {
5085        Pel *pcPtr =  m_pcQTTempTComYuv[uiQTTempAccessLayer].getCrAddr( absTUPartIdxC );
5086        const UInt uiStride = m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride();
5087        for( UInt uiY = 0; uiY < trHeightC; ++uiY )
5088        {   
5089          ::memset( pcPtr, 0, sizeof(Pel) * trWidthC );
5090          pcPtr += uiStride;
5091        }
5092      }
5093    }
5094    pcCU->setCbfSubParts( uiAbsSumY ? uiSetCbf : 0, TEXT_LUMA, uiAbsPartIdx, uiDepth );
5095    if( bCodeChroma )
5096    {
5097      pcCU->setCbfSubParts( uiAbsSumU ? uiSetCbf : 0, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5098      pcCU->setCbfSubParts( uiAbsSumV ? uiSetCbf : 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5099    }
5100
5101    if( checkTransformSkipY )
5102    {
5103      UInt uiNonzeroDistY, uiAbsSumTransformSkipY;
5104      Double dSingleCostY;
5105
5106      Pel *pcResiCurrY = m_pcQTTempTComYuv[ uiQTTempAccessLayer ].getLumaAddr( absTUPartIdx );
5107      UInt resiYStride = m_pcQTTempTComYuv[ uiQTTempAccessLayer ].getStride();
5108
5109      TCoeff bestCoeffY[32*32];
5110      memcpy( bestCoeffY, pcCoeffCurrY, sizeof(TCoeff) * uiNumSamplesLuma );
5111     
5112#if ADAPTIVE_QP_SELECTION
5113      TCoeff bestArlCoeffY[32*32];
5114      memcpy( bestArlCoeffY, pcArlCoeffCurrY, sizeof(TCoeff) * uiNumSamplesLuma );
5115#endif
5116
5117      Pel bestResiY[32*32];
5118      for ( Int i = 0; i < trHeight; ++i )
5119      {
5120        memcpy( &bestResiY[i*trWidth], pcResiCurrY+i*resiYStride, sizeof(Pel) * trWidth );
5121      }
5122
5123      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
5124
5125      pcCU->setTransformSkipSubParts ( 1, TEXT_LUMA, uiAbsPartIdx, uiDepth );
5126
5127      if (m_pcEncCfg->getUseRDOQTS())
5128      {
5129        m_pcEntropyCoder->estimateBit( m_pcTrQuant->m_pcEstBitsSbac, trWidth, trHeight, TEXT_LUMA );       
5130      }
5131
5132#if REPN_FORMAT_IN_VPS
5133      m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getQpBDOffsetY(), 0 );
5134#else
5135      m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
5136#endif
5137
5138#if RDOQ_CHROMA_LAMBDA
5139      m_pcTrQuant->selectLambda(TEXT_LUMA);
5140#endif
5141      m_pcTrQuant->transformNxN( pcCU, pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride (), pcCoeffCurrY, 
5142#if ADAPTIVE_QP_SELECTION
5143        pcArlCoeffCurrY, 
5144#endif     
5145        trWidth,   trHeight,    uiAbsSumTransformSkipY, TEXT_LUMA, uiAbsPartIdx, true );
5146      pcCU->setCbfSubParts( uiAbsSumTransformSkipY ? uiSetCbf : 0, TEXT_LUMA, uiAbsPartIdx, uiDepth );
5147
5148      if( uiAbsSumTransformSkipY != 0 )
5149      {
5150        m_pcEntropyCoder->resetBits();
5151        m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA, uiTrMode );
5152        m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrY, uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_LUMA );
5153        const UInt uiTsSingleBitsY = m_pcEntropyCoder->getNumberOfWrittenBits();
5154
5155#if REPN_FORMAT_IN_VPS
5156        m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getQpBDOffsetY(), 0 );
5157#else
5158        m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
5159#endif
5160
5161        Int scalingListType = 3 + g_eTTable[(Int)TEXT_LUMA];
5162        assert(scalingListType < SCALING_LIST_NUM);
5163
5164        m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,REG_DCT, pcResiCurrY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),  pcCoeffCurrY, trWidth, trHeight, scalingListType, true );
5165
5166        uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),
5167          pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth, trHeight );
5168
5169        dSingleCostY = m_pcRdCost->calcRdCost( uiTsSingleBitsY, uiNonzeroDistY );
5170      }
5171
5172      if( !uiAbsSumTransformSkipY || minCostY < dSingleCostY )
5173      {
5174        pcCU->setTransformSkipSubParts ( 0, TEXT_LUMA, uiAbsPartIdx, uiDepth );
5175        memcpy( pcCoeffCurrY, bestCoeffY, sizeof(TCoeff) * uiNumSamplesLuma );
5176#if ADAPTIVE_QP_SELECTION
5177        memcpy( pcArlCoeffCurrY, bestArlCoeffY, sizeof(TCoeff) * uiNumSamplesLuma );
5178#endif
5179        for( Int i = 0; i < trHeight; ++i )
5180        {
5181          memcpy( pcResiCurrY+i*resiYStride, &bestResiY[i*trWidth], sizeof(Pel) * trWidth );
5182        }
5183      }
5184      else
5185      {
5186        uiDistY = uiNonzeroDistY;
5187        uiAbsSumY = uiAbsSumTransformSkipY;
5188        uiBestTransformMode[0] = 1;
5189      }
5190
5191      pcCU->setCbfSubParts( uiAbsSumY ? uiSetCbf : 0, TEXT_LUMA, uiAbsPartIdx, uiDepth );
5192    }
5193
5194    if( bCodeChroma && checkTransformSkipUV  )
5195    {
5196      UInt uiNonzeroDistU, uiNonzeroDistV, uiAbsSumTransformSkipU, uiAbsSumTransformSkipV;
5197      Double dSingleCostU, dSingleCostV;
5198
5199      Pel *pcResiCurrU = m_pcQTTempTComYuv[uiQTTempAccessLayer].getCbAddr( absTUPartIdxC );
5200      Pel *pcResiCurrV = m_pcQTTempTComYuv[uiQTTempAccessLayer].getCrAddr( absTUPartIdxC );
5201      UInt resiCStride = m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride();
5202
5203      TCoeff bestCoeffU[32*32], bestCoeffV[32*32];
5204      memcpy( bestCoeffU, pcCoeffCurrU, sizeof(TCoeff) * uiNumSamplesChro );
5205      memcpy( bestCoeffV, pcCoeffCurrV, sizeof(TCoeff) * uiNumSamplesChro );
5206
5207#if ADAPTIVE_QP_SELECTION
5208      TCoeff bestArlCoeffU[32*32], bestArlCoeffV[32*32];
5209      memcpy( bestArlCoeffU, pcArlCoeffCurrU, sizeof(TCoeff) * uiNumSamplesChro );
5210      memcpy( bestArlCoeffV, pcArlCoeffCurrV, sizeof(TCoeff) * uiNumSamplesChro );
5211#endif
5212
5213      Pel bestResiU[32*32], bestResiV[32*32];
5214      for (Int i = 0; i < trHeightC; ++i )
5215      {
5216        memcpy( &bestResiU[i*trWidthC], pcResiCurrU+i*resiCStride, sizeof(Pel) * trWidthC );
5217        memcpy( &bestResiV[i*trWidthC], pcResiCurrV+i*resiCStride, sizeof(Pel) * trWidthC );
5218      }
5219
5220      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
5221
5222      pcCU->setTransformSkipSubParts ( 1, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC ); 
5223      pcCU->setTransformSkipSubParts ( 1, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5224
5225      if (m_pcEncCfg->getUseRDOQTS())
5226      {
5227        m_pcEntropyCoder->estimateBit(m_pcTrQuant->m_pcEstBitsSbac, trWidthC, trHeightC, TEXT_CHROMA );         
5228      }
5229
5230      Int curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCbQpOffset() + pcCU->getSlice()->getSliceQpDeltaCb();
5231      m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
5232
5233#if RDOQ_CHROMA_LAMBDA
5234      m_pcTrQuant->selectLambda(TEXT_CHROMA_U);
5235#endif
5236
5237      m_pcTrQuant->transformNxN( pcCU, pcResi->getCbAddr(absTUPartIdxC), pcResi->getCStride(), pcCoeffCurrU, 
5238#if ADAPTIVE_QP_SELECTION
5239        pcArlCoeffCurrU, 
5240#endif       
5241        trWidthC, trHeightC, uiAbsSumTransformSkipU, TEXT_CHROMA_U, uiAbsPartIdx, true );
5242      curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();
5243      m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
5244#if RDOQ_CHROMA_LAMBDA
5245      m_pcTrQuant->selectLambda(TEXT_CHROMA_V);
5246#endif
5247      m_pcTrQuant->transformNxN( pcCU, pcResi->getCrAddr(absTUPartIdxC), pcResi->getCStride(), pcCoeffCurrV, 
5248#if ADAPTIVE_QP_SELECTION
5249        pcArlCoeffCurrV, 
5250#endif       
5251        trWidthC, trHeightC, uiAbsSumTransformSkipV, TEXT_CHROMA_V, uiAbsPartIdx, true );
5252
5253      pcCU->setCbfSubParts( uiAbsSumTransformSkipU ? uiSetCbf : 0, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5254      pcCU->setCbfSubParts( uiAbsSumTransformSkipV ? uiSetCbf : 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5255
5256      m_pcEntropyCoder->resetBits();
5257      uiSingleBitsU = 0;
5258      uiSingleBitsV = 0;
5259
5260      if( uiAbsSumTransformSkipU )
5261      {
5262        m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrMode );
5263        m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrU, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_U );
5264        uiSingleBitsU = m_pcEntropyCoder->getNumberOfWrittenBits();   
5265
5266        curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCbQpOffset() + pcCU->getSlice()->getSliceQpDeltaCb();
5267        m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
5268
5269        Int scalingListType = 3 + g_eTTable[(Int)TEXT_CHROMA_U];
5270        assert(scalingListType < SCALING_LIST_NUM);
5271
5272        m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA,REG_DCT, pcResiCurrU, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(), pcCoeffCurrU, trWidthC, trHeightC, scalingListType, true  );
5273
5274        uiNonzeroDistU = m_pcRdCost->getDistPart(g_bitDepthC, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCbAddr( absTUPartIdxC), m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(),
5275                                                 pcResi->getCbAddr( absTUPartIdxC), pcResi->getCStride(), trWidthC, trHeightC
5276                                                 , TEXT_CHROMA_U
5277                                                 );
5278
5279        dSingleCostU = m_pcRdCost->calcRdCost( uiSingleBitsU, uiNonzeroDistU );
5280      }
5281
5282      if( !uiAbsSumTransformSkipU || minCostU < dSingleCostU )
5283      {
5284        pcCU->setTransformSkipSubParts ( 0, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC ); 
5285
5286        memcpy( pcCoeffCurrU, bestCoeffU, sizeof (TCoeff) * uiNumSamplesChro );
5287#if ADAPTIVE_QP_SELECTION
5288        memcpy( pcArlCoeffCurrU, bestArlCoeffU, sizeof (TCoeff) * uiNumSamplesChro );
5289#endif
5290        for( Int i = 0; i < trHeightC; ++i )
5291        {
5292          memcpy( pcResiCurrU+i*resiCStride, &bestResiU[i*trWidthC], sizeof(Pel) * trWidthC );
5293        }
5294      }
5295      else
5296      {
5297        uiDistU = uiNonzeroDistU;
5298        uiAbsSumU = uiAbsSumTransformSkipU;
5299        uiBestTransformMode[1] = 1;
5300      }
5301
5302      if( uiAbsSumTransformSkipV )
5303      {
5304        m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrMode );
5305        m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrV, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_V );
5306        uiSingleBitsV = m_pcEntropyCoder->getNumberOfWrittenBits() - uiSingleBitsU;
5307
5308        curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();
5309        m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
5310
5311        Int scalingListType = 3 + g_eTTable[(Int)TEXT_CHROMA_V];
5312        assert(scalingListType < SCALING_LIST_NUM);
5313
5314        m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA,REG_DCT, pcResiCurrV, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(), pcCoeffCurrV, trWidthC, trHeightC, scalingListType, true );
5315
5316        uiNonzeroDistV = m_pcRdCost->getDistPart(g_bitDepthC, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCrAddr( absTUPartIdxC ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(),
5317                                                 pcResi->getCrAddr( absTUPartIdxC ), pcResi->getCStride(), trWidthC, trHeightC
5318                                                 , TEXT_CHROMA_V
5319                                                 );
5320
5321        dSingleCostV = m_pcRdCost->calcRdCost( uiSingleBitsV, uiNonzeroDistV );
5322      }
5323
5324      if( !uiAbsSumTransformSkipV || minCostV < dSingleCostV )
5325      {
5326        pcCU->setTransformSkipSubParts ( 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC ); 
5327
5328        memcpy( pcCoeffCurrV, bestCoeffV, sizeof(TCoeff) * uiNumSamplesChro );
5329#if ADAPTIVE_QP_SELECTION
5330        memcpy( pcArlCoeffCurrV, bestArlCoeffV, sizeof(TCoeff) * uiNumSamplesChro );
5331#endif
5332        for( Int i = 0; i < trHeightC; ++i )
5333        {
5334          memcpy( pcResiCurrV+i*resiCStride, &bestResiV[i*trWidthC], sizeof(Pel) * trWidthC );
5335        }
5336      }
5337      else
5338      {
5339        uiDistV = uiNonzeroDistV;
5340        uiAbsSumV = uiAbsSumTransformSkipV;
5341        uiBestTransformMode[2] = 1;
5342      }
5343
5344      pcCU->setCbfSubParts( uiAbsSumU ? uiSetCbf : 0, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5345      pcCU->setCbfSubParts( uiAbsSumV ? uiSetCbf : 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5346    }
5347
5348    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
5349    m_pcEntropyCoder->resetBits();
5350
5351    if( uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
5352    {
5353      m_pcEntropyCoder->encodeTransformSubdivFlag( 0, 5 - uiLog2TrSize );
5354    }
5355
5356    if( bCodeChroma )
5357    {
5358      m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrMode );
5359      m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrMode );
5360    }
5361
5362    m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA,     uiTrMode );
5363
5364    m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrY, uiAbsPartIdx, trWidth, trHeight,    uiDepth, TEXT_LUMA );
5365
5366    if( bCodeChroma )
5367    {
5368      m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrU, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_U );
5369      m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrV, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_V );
5370    }
5371
5372    uiSingleBits = m_pcEntropyCoder->getNumberOfWrittenBits();
5373
5374    uiSingleDist = uiDistY + uiDistU + uiDistV;
5375    dSingleCost = m_pcRdCost->calcRdCost( uiSingleBits, uiSingleDist );
5376  } 
5377 
5378  // code sub-blocks
5379  if( bCheckSplit )
5380  {
5381    if( bCheckFull )
5382    {
5383      m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_TEST ] );
5384      m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
5385    }
5386    UInt uiSubdivDist = 0;
5387    UInt uiSubdivBits = 0;
5388    Double dSubdivCost = 0.0;
5389   
5390    const UInt uiQPartNumSubdiv = pcCU->getPic()->getNumPartInCU() >> ((uiDepth + 1 ) << 1);
5391    for( UInt ui = 0; ui < 4; ++ui )
5392    {
5393      UInt nsAddr = uiAbsPartIdx + ui * uiQPartNumSubdiv;
5394      xEstimateResidualQT( pcCU, ui, uiAbsPartIdx + ui * uiQPartNumSubdiv, nsAddr, pcResi, uiDepth + 1, dSubdivCost, uiSubdivBits, uiSubdivDist, bCheckFull ? NULL : puiZeroDist );
5395    }
5396   
5397    UInt uiYCbf = 0;
5398    UInt uiUCbf = 0;
5399    UInt uiVCbf = 0;
5400    for( UInt ui = 0; ui < 4; ++ui )
5401    {
5402      uiYCbf |= pcCU->getCbf( uiAbsPartIdx + ui * uiQPartNumSubdiv, TEXT_LUMA,     uiTrMode + 1 );
5403      uiUCbf |= pcCU->getCbf( uiAbsPartIdx + ui * uiQPartNumSubdiv, TEXT_CHROMA_U, uiTrMode + 1 );
5404      uiVCbf |= pcCU->getCbf( uiAbsPartIdx + ui * uiQPartNumSubdiv, TEXT_CHROMA_V, uiTrMode + 1 );
5405    }
5406    for( UInt ui = 0; ui < 4 * uiQPartNumSubdiv; ++ui )
5407    {
5408      pcCU->getCbf( TEXT_LUMA     )[uiAbsPartIdx + ui] |= uiYCbf << uiTrMode;
5409      pcCU->getCbf( TEXT_CHROMA_U )[uiAbsPartIdx + ui] |= uiUCbf << uiTrMode;
5410      pcCU->getCbf( TEXT_CHROMA_V )[uiAbsPartIdx + ui] |= uiVCbf << uiTrMode;
5411    }
5412   
5413    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
5414    m_pcEntropyCoder->resetBits();
5415   
5416    xEncodeResidualQT( pcCU, uiAbsPartIdx, uiDepth, true,  TEXT_LUMA );
5417    xEncodeResidualQT( pcCU, uiAbsPartIdx, uiDepth, false, TEXT_LUMA );
5418    xEncodeResidualQT( pcCU, uiAbsPartIdx, uiDepth, false, TEXT_CHROMA_U );
5419    xEncodeResidualQT( pcCU, uiAbsPartIdx, uiDepth, false, TEXT_CHROMA_V );
5420
5421    uiSubdivBits = m_pcEntropyCoder->getNumberOfWrittenBits();
5422    dSubdivCost  = m_pcRdCost->calcRdCost( uiSubdivBits, uiSubdivDist );
5423   
5424    if( uiYCbf || uiUCbf || uiVCbf || !bCheckFull )
5425    {
5426      if( dSubdivCost < dSingleCost )
5427      {
5428        rdCost += dSubdivCost;
5429        ruiBits += uiSubdivBits;
5430        ruiDist += uiSubdivDist;
5431        return;
5432      }
5433    }
5434    pcCU->setTransformSkipSubParts ( uiBestTransformMode[0], TEXT_LUMA, uiAbsPartIdx, uiDepth ); 
5435    if(bCodeChroma)
5436    {
5437      pcCU->setTransformSkipSubParts ( uiBestTransformMode[1], TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC ); 
5438      pcCU->setTransformSkipSubParts ( uiBestTransformMode[2], TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC ); 
5439    }
5440    assert( bCheckFull );
5441
5442    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_TEST ] );
5443  }
5444  rdCost += dSingleCost;
5445  ruiBits += uiSingleBits;
5446  ruiDist += uiSingleDist;
5447 
5448  pcCU->setTrIdxSubParts( uiTrMode, uiAbsPartIdx, uiDepth );
5449 
5450  pcCU->setCbfSubParts( uiAbsSumY ? uiSetCbf : 0, TEXT_LUMA, uiAbsPartIdx, uiDepth );
5451  if( bCodeChroma )
5452  {
5453    pcCU->setCbfSubParts( uiAbsSumU ? uiSetCbf : 0, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5454    pcCU->setCbfSubParts( uiAbsSumV ? uiSetCbf : 0, TEXT_CHROMA_V, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
5455  }
5456}
5457
5458Void TEncSearch::xEncodeResidualQT( TComDataCU* pcCU, UInt uiAbsPartIdx, const UInt uiDepth, Bool bSubdivAndCbf, TextType eType )
5459{
5460  assert( pcCU->getDepth( 0 ) == pcCU->getDepth( uiAbsPartIdx ) );
5461  const UInt uiCurrTrMode = uiDepth - pcCU->getDepth( 0 );
5462  const UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
5463 
5464  const Bool bSubdiv = uiCurrTrMode != uiTrMode;
5465 
5466  const UInt uiLog2TrSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiDepth]+2;
5467
5468  if( bSubdivAndCbf && uiLog2TrSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() && uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
5469  {
5470    m_pcEntropyCoder->encodeTransformSubdivFlag( bSubdiv, 5 - uiLog2TrSize );
5471  }
5472
5473  assert( pcCU->getPredictionMode(uiAbsPartIdx) != MODE_INTRA );
5474    if( bSubdivAndCbf )
5475    {
5476      const Bool bFirstCbfOfCU = uiCurrTrMode == 0;
5477      if( bFirstCbfOfCU || uiLog2TrSize > 2 )
5478      {
5479        if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiCurrTrMode - 1 ) )
5480        {
5481          m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiCurrTrMode );
5482        }
5483        if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiCurrTrMode - 1 ) )
5484        {
5485          m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiCurrTrMode );
5486        }
5487      }
5488      else if( uiLog2TrSize == 2 )
5489      {
5490        assert( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiCurrTrMode ) == pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiCurrTrMode - 1 ) );
5491        assert( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiCurrTrMode ) == pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiCurrTrMode - 1 ) );
5492      }
5493    }
5494 
5495  if( !bSubdiv )
5496  {
5497    const UInt uiNumCoeffPerAbsPartIdxIncrement = pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
5498    //assert( 16 == uiNumCoeffPerAbsPartIdxIncrement ); // check
5499    const UInt uiQTTempAccessLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
5500    TCoeff *pcCoeffCurrY = m_ppcQTTempCoeffY [uiQTTempAccessLayer] +  uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx;
5501    TCoeff *pcCoeffCurrU = m_ppcQTTempCoeffCb[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5502    TCoeff *pcCoeffCurrV = m_ppcQTTempCoeffCr[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5503   
5504    Bool  bCodeChroma   = true;
5505    UInt  uiTrModeC     = uiTrMode;
5506    UInt  uiLog2TrSizeC = uiLog2TrSize-1;
5507    if( uiLog2TrSize == 2 )
5508    {
5509      uiLog2TrSizeC++;
5510      uiTrModeC    --;
5511      UInt  uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrModeC ) << 1 );
5512      bCodeChroma   = ( ( uiAbsPartIdx % uiQPDiv ) == 0 );
5513    }
5514   
5515    if( bSubdivAndCbf )
5516    {
5517      m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA,     uiTrMode );
5518    }
5519    else
5520    {
5521      if( eType == TEXT_LUMA     && pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA,     uiTrMode ) )
5522      {
5523        Int trWidth  = 1 << uiLog2TrSize;
5524        Int trHeight = 1 << uiLog2TrSize;
5525        m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrY, uiAbsPartIdx, trWidth, trHeight,    uiDepth, TEXT_LUMA );
5526      }
5527      if( bCodeChroma )
5528      {
5529        Int trWidth  = 1 << uiLog2TrSizeC;
5530        Int trHeight = 1 << uiLog2TrSizeC;
5531        if( eType == TEXT_CHROMA_U && pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrMode ) )
5532        {
5533          m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrU, uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
5534        }
5535        if( eType == TEXT_CHROMA_V && pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrMode ) )
5536        {
5537          m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrV, uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
5538        }
5539      }
5540    }
5541  }
5542  else
5543  {
5544    if( bSubdivAndCbf || pcCU->getCbf( uiAbsPartIdx, eType, uiCurrTrMode ) )
5545    {
5546      const UInt uiQPartNumSubdiv = pcCU->getPic()->getNumPartInCU() >> ((uiDepth + 1 ) << 1);
5547      for( UInt ui = 0; ui < 4; ++ui )
5548      {
5549        xEncodeResidualQT( pcCU, uiAbsPartIdx + ui * uiQPartNumSubdiv, uiDepth + 1, bSubdivAndCbf, eType );
5550      }
5551    }
5552  }
5553}
5554
5555Void TEncSearch::xSetResidualQTData( TComDataCU* pcCU, UInt uiQuadrant, UInt uiAbsPartIdx, UInt absTUPartIdx, TComYuv* pcResi, UInt uiDepth, Bool bSpatial )
5556{
5557  assert( pcCU->getDepth( 0 ) == pcCU->getDepth( uiAbsPartIdx ) );
5558  const UInt uiCurrTrMode = uiDepth - pcCU->getDepth( 0 );
5559  const UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
5560
5561  if( uiCurrTrMode == uiTrMode )
5562  {
5563    const UInt uiLog2TrSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiDepth]+2;
5564    const UInt uiQTTempAccessLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
5565
5566    Bool  bCodeChroma   = true;
5567    UInt  uiTrModeC     = uiTrMode;
5568    UInt  uiLog2TrSizeC = uiLog2TrSize-1;
5569    if( uiLog2TrSize == 2 )
5570    {
5571      uiLog2TrSizeC++;
5572      uiTrModeC    --;
5573      UInt  uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth( 0 ) + uiTrModeC ) << 1 );
5574      bCodeChroma   = ( ( uiAbsPartIdx % uiQPDiv ) == 0 );
5575    }
5576
5577    if( bSpatial )
5578    {     
5579      Int trWidth  = 1 << uiLog2TrSize;
5580      Int trHeight = 1 << uiLog2TrSize;
5581      m_pcQTTempTComYuv[uiQTTempAccessLayer].copyPartToPartLuma    ( pcResi, absTUPartIdx, trWidth , trHeight );
5582
5583      if( bCodeChroma )
5584      {
5585        m_pcQTTempTComYuv[uiQTTempAccessLayer].copyPartToPartChroma( pcResi, uiAbsPartIdx, 1 << uiLog2TrSizeC, 1 << uiLog2TrSizeC );
5586      }
5587    }
5588    else
5589    {
5590      UInt    uiNumCoeffPerAbsPartIdxIncrement = pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
5591      UInt    uiNumCoeffY = ( 1 << ( uiLog2TrSize << 1 ) );
5592      TCoeff* pcCoeffSrcY = m_ppcQTTempCoeffY [uiQTTempAccessLayer] +  uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx;
5593      TCoeff* pcCoeffDstY = pcCU->getCoeffY() + uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx;
5594      ::memcpy( pcCoeffDstY, pcCoeffSrcY, sizeof( TCoeff ) * uiNumCoeffY );
5595#if ADAPTIVE_QP_SELECTION
5596      Int* pcArlCoeffSrcY = m_ppcQTTempArlCoeffY [uiQTTempAccessLayer] +  uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx;
5597      Int* pcArlCoeffDstY = pcCU->getArlCoeffY() + uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx;
5598      ::memcpy( pcArlCoeffDstY, pcArlCoeffSrcY, sizeof( Int ) * uiNumCoeffY );
5599#endif
5600      if( bCodeChroma )
5601      {
5602        UInt    uiNumCoeffC = ( 1 << ( uiLog2TrSizeC << 1 ) );
5603        TCoeff* pcCoeffSrcU = m_ppcQTTempCoeffCb[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5604        TCoeff* pcCoeffSrcV = m_ppcQTTempCoeffCr[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5605        TCoeff* pcCoeffDstU = pcCU->getCoeffCb() + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5606        TCoeff* pcCoeffDstV = pcCU->getCoeffCr() + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5607        ::memcpy( pcCoeffDstU, pcCoeffSrcU, sizeof( TCoeff ) * uiNumCoeffC );
5608        ::memcpy( pcCoeffDstV, pcCoeffSrcV, sizeof( TCoeff ) * uiNumCoeffC );
5609#if ADAPTIVE_QP_SELECTION
5610        Int* pcArlCoeffSrcU = m_ppcQTTempArlCoeffCb[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5611        Int* pcArlCoeffSrcV = m_ppcQTTempArlCoeffCr[uiQTTempAccessLayer] + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5612        Int* pcArlCoeffDstU = pcCU->getArlCoeffCb() + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5613        Int* pcArlCoeffDstV = pcCU->getArlCoeffCr() + (uiNumCoeffPerAbsPartIdxIncrement * uiAbsPartIdx>>2);
5614        ::memcpy( pcArlCoeffDstU, pcArlCoeffSrcU, sizeof( Int ) * uiNumCoeffC );
5615        ::memcpy( pcArlCoeffDstV, pcArlCoeffSrcV, sizeof( Int ) * uiNumCoeffC );
5616#endif
5617      }
5618    }
5619  }
5620  else
5621  {
5622    const UInt uiQPartNumSubdiv = pcCU->getPic()->getNumPartInCU() >> ((uiDepth + 1 ) << 1);
5623    for( UInt ui = 0; ui < 4; ++ui )
5624    {
5625      UInt nsAddr = uiAbsPartIdx + ui * uiQPartNumSubdiv;
5626      xSetResidualQTData( pcCU, ui, uiAbsPartIdx + ui * uiQPartNumSubdiv, nsAddr, pcResi, uiDepth + 1, bSpatial );
5627    }
5628  }
5629}
5630
5631UInt TEncSearch::xModeBitsIntra( TComDataCU* pcCU, UInt uiMode, UInt uiPU, UInt uiPartOffset, UInt uiDepth, UInt uiInitTrDepth )
5632{
5633  // Reload only contexts required for coding intra mode information
5634  m_pcRDGoOnSbacCoder->loadIntraDirModeLuma( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
5635 
5636  pcCU->setLumaIntraDirSubParts ( uiMode, uiPartOffset, uiDepth + uiInitTrDepth );
5637 
5638  m_pcEntropyCoder->resetBits();
5639  m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiPartOffset);
5640 
5641  return m_pcEntropyCoder->getNumberOfWrittenBits();
5642}
5643
5644UInt TEncSearch::xUpdateCandList( UInt uiMode, Double uiCost, UInt uiFastCandNum, UInt * CandModeList, Double * CandCostList )
5645{
5646  UInt i;
5647  UInt shift=0;
5648 
5649  while ( shift<uiFastCandNum && uiCost<CandCostList[ uiFastCandNum-1-shift ] ) shift++;
5650 
5651  if( shift!=0 )
5652  {
5653    for(i=1; i<shift; i++)
5654    {
5655      CandModeList[ uiFastCandNum-i ] = CandModeList[ uiFastCandNum-1-i ];
5656      CandCostList[ uiFastCandNum-i ] = CandCostList[ uiFastCandNum-1-i ];
5657    }
5658    CandModeList[ uiFastCandNum-shift ] = uiMode;
5659    CandCostList[ uiFastCandNum-shift ] = uiCost;
5660    return 1;
5661  }
5662 
5663  return 0;
5664}
5665
5666/** add inter-prediction syntax elements for a CU block
5667 * \param pcCU
5668 * \param uiQp
5669 * \param uiTrMode
5670 * \param ruiBits
5671 * \param rpcYuvRec
5672 * \param pcYuvPred
5673 * \param rpcYuvResi
5674 * \returns Void
5675 */
5676Void  TEncSearch::xAddSymbolBitsInter( TComDataCU* pcCU, UInt uiQp, UInt uiTrMode, UInt& ruiBits, TComYuv*& rpcYuvRec, TComYuv*pcYuvPred, TComYuv*& rpcYuvResi )
5677{
5678  if(pcCU->getMergeFlag( 0 ) && pcCU->getPartitionSize( 0 ) == SIZE_2Nx2N && !pcCU->getQtRootCbf( 0 ))
5679  {
5680    pcCU->setSkipFlagSubParts( true, 0, pcCU->getDepth(0) );
5681
5682    m_pcEntropyCoder->resetBits();
5683    if(pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
5684    {
5685      m_pcEntropyCoder->encodeCUTransquantBypassFlag(pcCU, 0, true);
5686    }
5687    m_pcEntropyCoder->encodeSkipFlag(pcCU, 0, true);
5688    m_pcEntropyCoder->encodeMergeIndex(pcCU, 0, true);
5689    ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
5690  }
5691  else
5692  {
5693    m_pcEntropyCoder->resetBits();
5694    if(pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
5695    {
5696      m_pcEntropyCoder->encodeCUTransquantBypassFlag(pcCU, 0, true);
5697    }
5698    m_pcEntropyCoder->encodeSkipFlag ( pcCU, 0, true );
5699    m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
5700    m_pcEntropyCoder->encodePartSize( pcCU, 0, pcCU->getDepth(0), true );
5701    m_pcEntropyCoder->encodePredInfo( pcCU, 0, true );
5702    Bool bDummy = false;
5703    m_pcEntropyCoder->encodeCoeff   ( pcCU, 0, pcCU->getDepth(0), pcCU->getWidth(0), pcCU->getHeight(0), bDummy );
5704   
5705    ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
5706  }
5707}
5708
5709/**
5710 * \brief Generate half-sample interpolated block
5711 *
5712 * \param pattern Reference picture ROI
5713 * \param biPred    Flag indicating whether block is for biprediction
5714 */
5715Void TEncSearch::xExtDIFUpSamplingH( TComPattern* pattern, Bool biPred )
5716{
5717  Int width      = pattern->getROIYWidth();
5718  Int height     = pattern->getROIYHeight();
5719  Int srcStride  = pattern->getPatternLStride();
5720 
5721  Int intStride = m_filteredBlockTmp[0].getStride();
5722  Int dstStride = m_filteredBlock[0][0].getStride();
5723  Short *intPtr;
5724  Short *dstPtr;
5725  Int filterSize = NTAPS_LUMA;
5726  Int halfFilterSize = (filterSize>>1);
5727  Pel *srcPtr = pattern->getROIY() - halfFilterSize*srcStride - 1;
5728 
5729  m_if.filterHorLuma(srcPtr, srcStride, m_filteredBlockTmp[0].getLumaAddr(), intStride, width+1, height+filterSize, 0, false);
5730  m_if.filterHorLuma(srcPtr, srcStride, m_filteredBlockTmp[2].getLumaAddr(), intStride, width+1, height+filterSize, 2, false);
5731 
5732  intPtr = m_filteredBlockTmp[0].getLumaAddr() + halfFilterSize * intStride + 1; 
5733  dstPtr = m_filteredBlock[0][0].getLumaAddr();
5734  m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width+0, height+0, 0, false, true);
5735 
5736  intPtr = m_filteredBlockTmp[0].getLumaAddr() + (halfFilterSize-1) * intStride + 1; 
5737  dstPtr = m_filteredBlock[2][0].getLumaAddr();
5738  m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width+0, height+1, 2, false, true);
5739 
5740  intPtr = m_filteredBlockTmp[2].getLumaAddr() + halfFilterSize * intStride;
5741  dstPtr = m_filteredBlock[0][2].getLumaAddr();
5742  m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width+1, height+0, 0, false, true);
5743 
5744  intPtr = m_filteredBlockTmp[2].getLumaAddr() + (halfFilterSize-1) * intStride;
5745  dstPtr = m_filteredBlock[2][2].getLumaAddr();
5746  m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width+1, height+1, 2, false, true);
5747}
5748
5749/**
5750 * \brief Generate quarter-sample interpolated blocks
5751 *
5752 * \param pattern    Reference picture ROI
5753 * \param halfPelRef Half-pel mv
5754 * \param biPred     Flag indicating whether block is for biprediction
5755 */
5756Void TEncSearch::xExtDIFUpSamplingQ( TComPattern* pattern, TComMv halfPelRef, Bool biPred )
5757{
5758  Int width      = pattern->getROIYWidth();
5759  Int height     = pattern->getROIYHeight();
5760  Int srcStride  = pattern->getPatternLStride();
5761 
5762  Pel *srcPtr;
5763  Int intStride = m_filteredBlockTmp[0].getStride();
5764  Int dstStride = m_filteredBlock[0][0].getStride();
5765  Short *intPtr;
5766  Short *dstPtr;
5767  Int filterSize = NTAPS_LUMA;
5768 
5769  Int halfFilterSize = (filterSize>>1);
5770
5771  Int extHeight = (halfPelRef.getVer() == 0) ? height + filterSize : height + filterSize-1;
5772 
5773  // Horizontal filter 1/4
5774  srcPtr = pattern->getROIY() - halfFilterSize * srcStride - 1;
5775  intPtr = m_filteredBlockTmp[1].getLumaAddr();
5776  if (halfPelRef.getVer() > 0)
5777  {
5778    srcPtr += srcStride;
5779  }
5780  if (halfPelRef.getHor() >= 0)
5781  {
5782    srcPtr += 1;
5783  }
5784  m_if.filterHorLuma(srcPtr, srcStride, intPtr, intStride, width, extHeight, 1, false);
5785 
5786  // Horizontal filter 3/4
5787  srcPtr = pattern->getROIY() - halfFilterSize*srcStride - 1;
5788  intPtr = m_filteredBlockTmp[3].getLumaAddr();
5789  if (halfPelRef.getVer() > 0)
5790  {
5791    srcPtr += srcStride;
5792  }
5793  if (halfPelRef.getHor() > 0)
5794  {
5795    srcPtr += 1;
5796  }
5797  m_if.filterHorLuma(srcPtr, srcStride, intPtr, intStride, width, extHeight, 3, false);       
5798 
5799  // Generate @ 1,1
5800  intPtr = m_filteredBlockTmp[1].getLumaAddr() + (halfFilterSize-1) * intStride;
5801  dstPtr = m_filteredBlock[1][1].getLumaAddr();
5802  if (halfPelRef.getVer() == 0)
5803  {
5804    intPtr += intStride;
5805  }
5806  m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 1, false, true);
5807 
5808  // Generate @ 3,1
5809  intPtr = m_filteredBlockTmp[1].getLumaAddr() + (halfFilterSize-1) * intStride;
5810  dstPtr = m_filteredBlock[3][1].getLumaAddr();
5811  m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 3, false, true);
5812 
5813  if (halfPelRef.getVer() != 0)
5814  {
5815    // Generate @ 2,1
5816    intPtr = m_filteredBlockTmp[1].getLumaAddr() + (halfFilterSize-1) * intStride;
5817    dstPtr = m_filteredBlock[2][1].getLumaAddr();
5818    if (halfPelRef.getVer() == 0)
5819    {
5820      intPtr += intStride;
5821    }
5822    m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 2, false, true);
5823   
5824    // Generate @ 2,3
5825    intPtr = m_filteredBlockTmp[3].getLumaAddr() + (halfFilterSize-1) * intStride;
5826    dstPtr = m_filteredBlock[2][3].getLumaAddr();
5827    if (halfPelRef.getVer() == 0)
5828    {
5829      intPtr += intStride;
5830    }
5831    m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 2, false, true);
5832  }
5833  else
5834  {
5835    // Generate @ 0,1
5836    intPtr = m_filteredBlockTmp[1].getLumaAddr() + halfFilterSize * intStride;
5837    dstPtr = m_filteredBlock[0][1].getLumaAddr();
5838    m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 0, false, true);
5839   
5840    // Generate @ 0,3
5841    intPtr = m_filteredBlockTmp[3].getLumaAddr() + halfFilterSize * intStride;
5842    dstPtr = m_filteredBlock[0][3].getLumaAddr();
5843    m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 0, false, true);
5844  }
5845 
5846  if (halfPelRef.getHor() != 0)
5847  {
5848    // Generate @ 1,2
5849    intPtr = m_filteredBlockTmp[2].getLumaAddr() + (halfFilterSize-1) * intStride;
5850    dstPtr = m_filteredBlock[1][2].getLumaAddr();
5851    if (halfPelRef.getHor() > 0)
5852    {
5853      intPtr += 1;
5854    }
5855    if (halfPelRef.getVer() >= 0)
5856    {
5857      intPtr += intStride;
5858    }
5859    m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 1, false, true);
5860   
5861    // Generate @ 3,2
5862    intPtr = m_filteredBlockTmp[2].getLumaAddr() + (halfFilterSize-1) * intStride;
5863    dstPtr = m_filteredBlock[3][2].getLumaAddr();
5864    if (halfPelRef.getHor() > 0)
5865    {
5866      intPtr += 1;
5867    }
5868    if (halfPelRef.getVer() > 0)
5869    {
5870      intPtr += intStride;
5871    }
5872    m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 3, false, true); 
5873  }
5874  else
5875  {
5876    // Generate @ 1,0
5877    intPtr = m_filteredBlockTmp[0].getLumaAddr() + (halfFilterSize-1) * intStride + 1;
5878    dstPtr = m_filteredBlock[1][0].getLumaAddr();
5879    if (halfPelRef.getVer() >= 0)
5880    {
5881      intPtr += intStride;
5882    }
5883    m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 1, false, true);
5884   
5885    // Generate @ 3,0
5886    intPtr = m_filteredBlockTmp[0].getLumaAddr() + (halfFilterSize-1) * intStride + 1;
5887    dstPtr = m_filteredBlock[3][0].getLumaAddr();
5888    if (halfPelRef.getVer() > 0)
5889    {
5890      intPtr += intStride;
5891    }
5892    m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 3, false, true);
5893  }
5894 
5895  // Generate @ 1,3
5896  intPtr = m_filteredBlockTmp[3].getLumaAddr() + (halfFilterSize-1) * intStride;
5897  dstPtr = m_filteredBlock[1][3].getLumaAddr();
5898  if (halfPelRef.getVer() == 0)
5899  {
5900    intPtr += intStride;
5901  }
5902  m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 1, false, true);
5903 
5904  // Generate @ 3,3
5905  intPtr = m_filteredBlockTmp[3].getLumaAddr() + (halfFilterSize-1) * intStride;
5906  dstPtr = m_filteredBlock[3][3].getLumaAddr();
5907  m_if.filterVerLuma(intPtr, intStride, dstPtr, dstStride, width, height, 3, false, true);
5908}
5909
5910/** set wp tables
5911 * \param TComDataCU* pcCU
5912 * \param iRefIdx
5913 * \param eRefPicListCur
5914 * \returns Void
5915 */
5916Void  TEncSearch::setWpScalingDistParam( TComDataCU* pcCU, Int iRefIdx, RefPicList eRefPicListCur )
5917{
5918  if ( iRefIdx<0 )
5919  {
5920    m_cDistParam.bApplyWeight = false;
5921    return;
5922  }
5923
5924  TComSlice       *pcSlice  = pcCU->getSlice();
5925  TComPPS         *pps      = pcCU->getSlice()->getPPS();
5926  wpScalingParam  *wp0 , *wp1;
5927  m_cDistParam.bApplyWeight = ( pcSlice->getSliceType()==P_SLICE && pps->getUseWP() ) || ( pcSlice->getSliceType()==B_SLICE && pps->getWPBiPred() ) ;
5928  if ( !m_cDistParam.bApplyWeight ) return;
5929
5930  Int iRefIdx0 = ( eRefPicListCur == REF_PIC_LIST_0 ) ? iRefIdx : (-1);
5931  Int iRefIdx1 = ( eRefPicListCur == REF_PIC_LIST_1 ) ? iRefIdx : (-1);
5932
5933  getWpScaling( pcCU, iRefIdx0, iRefIdx1, wp0 , wp1 );
5934
5935  if ( iRefIdx0 < 0 ) wp0 = NULL;
5936  if ( iRefIdx1 < 0 ) wp1 = NULL;
5937
5938  m_cDistParam.wpCur  = NULL;
5939
5940  if ( eRefPicListCur == REF_PIC_LIST_0 )
5941  {
5942    m_cDistParam.wpCur = wp0;
5943  }
5944  else
5945  {
5946    m_cDistParam.wpCur = wp1;
5947  }
5948}
5949
5950#if SVC_EXTENSION
5951#if REF_IDX_ME_ZEROMV
5952Void TEncSearch::xPatternSearchFracDIFMv0(TComDataCU* pcCU,
5953                                          TComPattern* pcPatternKey,
5954                                          Pel* piRefY,
5955                                          Int iRefStride,
5956                                          TComMv* pcMvInt,
5957                                          TComMv& rcMvHalf,
5958                                          TComMv& rcMvQter,
5959                                          UInt& ruiCost,
5960                                          Bool biPred
5961                                          )
5962{
5963  assert(pcMvInt->getHor() == 0 && pcMvInt->getVer() == 0);
5964  Int         iOffset    = pcMvInt->getHor() + pcMvInt->getVer() * iRefStride;
5965  m_pcRdCost->setDistParam( pcPatternKey, piRefY + iOffset, iRefStride, 1, m_cDistParam, m_pcEncCfg->getUseHADME() );
5966  m_pcRdCost->setCostScale ( 2 );
5967  setDistParamComp(0);
5968  ruiCost = m_cDistParam.DistFunc( &m_cDistParam );  //SATD
5969  ruiCost += m_pcRdCost->getCost( pcMvInt->getHor(), pcMvInt->getVer() );  //SATD rdCost
5970  rcMvHalf.setZero();
5971  rcMvQter.setZero();
5972}
5973#endif
5974
5975#if ENCODER_FAST_MODE
5976Bool TEncSearch::predInterSearchILRUni( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv*& rpcPredYuv, TComYuv*& rpcResiYuv, TComYuv*& rpcRecoYuv, UInt refLayerId )
5977{
5978    rpcPredYuv->clear();
5979    rpcRecoYuv->clear();
5980
5981    Int           iNumPredDir = pcCU->getSlice()->isInterP() ? 1 : 2;
5982
5983    TComMv        cMv[2];
5984    TComMv        cMvPred[2][33];
5985    TComMv        cMvTemp[2][33];
5986    TComMv        TempMv;
5987
5988    Int           iRefIdx[2]={0,0};
5989
5990    Int           aaiMvpIdx[2][33];
5991    Int           aaiMvpNum[2][33];
5992
5993    UInt          uiMbBits[3] = {1, 1, 0};
5994    UInt          uiLastMode = 0;
5995
5996    UInt          uiCost[2]   = { MAX_UINT, MAX_UINT };     //uni, rdCost
5997    UInt          uiCostTemp;
5998    UInt          biPDistTemp = MAX_INT;
5999    UInt          uiBitsTemp;
6000
6001    PartSize      ePartSize = pcCU->getPartitionSize( 0 );  //2Nx2N
6002    Int           iPartIdx  = 0;                            //one PU in CU
6003    UInt          uiPartAddr;
6004    Int           iRoiWidth, iRoiHeight;
6005    Bool          bILRSearched = false;
6006
6007    xGetBlkBits( ePartSize, pcCU->getSlice()->isInterP(), iPartIdx, uiLastMode, uiMbBits);
6008    pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iRoiWidth, iRoiHeight );
6009
6010    for( Int iRefList = 0; iRefList < iNumPredDir; iRefList++)  //list
6011    {
6012        if(bILRSearched)
6013           continue;
6014
6015        RefPicList  eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
6016
6017        Int  iRefIdxTemp = -1;
6018        Bool foundILR    = false;
6019
6020        for( Int refIdx = 0; refIdx < pcCU->getSlice()->getNumRefIdx(eRefPicList); refIdx++ )
6021        {
6022            if( pcCU->getSlice()->getRefPic(eRefPicList, refIdx)->isILR(pcCU->getLayerId()) && pcCU->getSlice()->getRefPic(eRefPicList, refIdx)->getLayerId() == refLayerId )
6023            {
6024                iRefIdxTemp = refIdx;
6025                foundILR    = true;
6026                bILRSearched = true;
6027                break;
6028            }
6029        }
6030
6031        if(!foundILR)  //no ILR in eRefPiclist
6032        {
6033            continue; 
6034        }
6035
6036        uiBitsTemp = uiMbBits[iRefList];
6037        if ( pcCU->getSlice()->getNumRefIdx(eRefPicList) > 1 ) 
6038        { 
6039            uiBitsTemp += iRefIdxTemp+1; 
6040            if ( iRefIdxTemp == pcCU->getSlice()->getNumRefIdx(eRefPicList)-1 ) uiBitsTemp--; 
6041        }
6042
6043        xEstimateMvPredAMVP( pcCU, pcOrgYuv, iPartIdx, eRefPicList, iRefIdxTemp, cMvPred[iRefList][iRefIdxTemp], false, &biPDistTemp);
6044        aaiMvpIdx[iRefList][iRefIdxTemp] = pcCU->getMVPIdx(eRefPicList, uiPartAddr);
6045        aaiMvpNum[iRefList][iRefIdxTemp] = pcCU->getMVPNum(eRefPicList, uiPartAddr);
6046
6047        uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
6048
6049        xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
6050        xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
6051
6052        if( uiCostTemp < uiCost[iRefList] )
6053        {
6054            uiCost[iRefList] = uiCostTemp;
6055
6056            cMv[iRefList]     = cMvTemp[iRefList][iRefIdxTemp];
6057            iRefIdx[iRefList] = iRefIdxTemp;
6058
6059            pcCU->getCUMvField(eRefPicList)->setAllMv( cMv[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
6060            pcCU->getCUMvField(eRefPicList)->setAllRefIdx( iRefIdx[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
6061        }
6062    }
6063
6064    if( uiCost[0] == MAX_UINT && uiCost[1] == MAX_UINT )  //no ILR in both list0 and list1
6065    {
6066        return false;
6067    }
6068
6069    //  Clear Motion Field
6070    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( TComMvField(), ePartSize, uiPartAddr, 0, iPartIdx ); 
6071    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( TComMvField(), ePartSize, uiPartAddr, 0, iPartIdx ); 
6072    pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( TComMv(),      ePartSize, uiPartAddr, 0, iPartIdx ); 
6073    pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( TComMv(),      ePartSize, uiPartAddr, 0, iPartIdx );
6074
6075    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr)); 
6076    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr)); 
6077    pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr)); 
6078    pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
6079
6080    if( uiCost[0] <= uiCost[1] )  //list0 ILR
6081    {
6082        pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMv    ( cMv[0], ePartSize, uiPartAddr, 0, iPartIdx );
6083        pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx( iRefIdx[0], ePartSize, uiPartAddr, 0, iPartIdx );
6084
6085        TempMv = cMv[0] - cMvPred[0][iRefIdx[0]]; 
6086        pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd( TempMv, ePartSize, uiPartAddr, 0, iPartIdx );
6087
6088        pcCU->setInterDirSubParts( 1, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
6089
6090        pcCU->setMVPIdxSubParts( aaiMvpIdx[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr)); 
6091        pcCU->setMVPNumSubParts( aaiMvpNum[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
6092    }
6093    else if( uiCost[1] < uiCost[0] )  //list1 ILR
6094    {
6095        pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMv    ( cMv[1], ePartSize, uiPartAddr, 0, iPartIdx );
6096        pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx( iRefIdx[1], ePartSize, uiPartAddr, 0, iPartIdx );
6097
6098        TempMv = cMv[1] - cMvPred[1][iRefIdx[1]]; 
6099        pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd( TempMv, ePartSize, uiPartAddr, 0, iPartIdx );
6100
6101        pcCU->setInterDirSubParts( 2, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
6102
6103        pcCU->setMVPIdxSubParts( aaiMvpIdx[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr)); 
6104        pcCU->setMVPNumSubParts( aaiMvpNum[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
6105    }
6106    else
6107    {
6108        assert(0);
6109    }
6110
6111    pcCU->setMergeFlagSubParts( false, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
6112
6113    motionCompensation ( pcCU, rpcPredYuv, REF_PIC_LIST_X, iPartIdx );
6114    setWpScalingDistParam( pcCU, -1, REF_PIC_LIST_X );
6115
6116    return true;
6117}
6118#endif
6119#endif //SVC_EXTENSION
6120
6121//! \}
Note: See TracBrowser for help on using the repository browser.