source: 3DVCSoftware/tags/HTM-DEV-0.1/source/Lib/TLibEncoder/TEncSearch.cpp @ 324

Last change on this file since 324 was 324, checked in by tech, 13 years ago

Initial development version for update to latest HM version.
Includes MV-HEVC and basic extensions for 3D-HEVC.

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