source: SHVCSoftware/branches/SHM-4.1-dev/source/Lib/TLibCommon/TComTrQuant.cpp @ 501

Last change on this file since 501 was 442, checked in by seregin, 11 years ago

reintegrate SHM-3.1-dev branch
  • Property svn:eol-style set to native
File size: 84.3 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     TComTrQuant.cpp
35    \brief    transform and quantization class
36*/
37
38#include <stdlib.h>
39#include <math.h>
40#include <memory.h>
41#include "TComTrQuant.h"
42#include "TComPic.h"
43#include "ContextTables.h"
44#define MAYBE_BUGFIX 1
45typedef struct
46{
47  Int    iNNZbeforePos0;
48  Double d64CodedLevelandDist; // distortion and level cost only
49  Double d64UncodedDist;    // all zero coded block distortion
50  Double d64SigCost;
51  Double d64SigCost_0;
52#if MAYBE_BUGFIX
53  Void init()
54  {
55    iNNZbeforePos0 = 0;
56  d64CodedLevelandDist = 0;
57  d64UncodedDist = 0;
58  d64SigCost = 0;
59  d64SigCost_0 = 0;
60  }
61#endif
62} coeffGroupRDStats;
63
64//! \ingroup TLibCommon
65//! \{
66
67// ====================================================================================================================
68// Constants
69// ====================================================================================================================
70
71#define RDOQ_CHROMA                 1           ///< use of RDOQ in chroma
72
73// ====================================================================================================================
74// Tables
75// ====================================================================================================================
76
77// RDOQ parameter
78
79// ====================================================================================================================
80// Qp class member functions
81// ====================================================================================================================
82
83QpParam::QpParam()
84{
85}
86
87// ====================================================================================================================
88// TComTrQuant class member functions
89// ====================================================================================================================
90
91TComTrQuant::TComTrQuant()
92{
93  m_cQP.clear();
94 
95  // allocate temporary buffers
96  m_plTempCoeff  = new Int[ MAX_CU_SIZE*MAX_CU_SIZE ];
97 
98  // allocate bit estimation class  (for RDOQ)
99  m_pcEstBitsSbac = new estBitsSbacStruct;
100  initScalingList();
101}
102
103TComTrQuant::~TComTrQuant()
104{
105  // delete temporary buffers
106  if ( m_plTempCoeff )
107  {
108    delete [] m_plTempCoeff;
109    m_plTempCoeff = NULL;
110  }
111 
112  // delete bit estimation class
113  if ( m_pcEstBitsSbac )
114  {
115    delete m_pcEstBitsSbac;
116  }
117  destroyScalingList();
118}
119
120#if ADAPTIVE_QP_SELECTION
121Void TComTrQuant::storeSliceQpNext(TComSlice* pcSlice)
122{
123  Int qpBase = pcSlice->getSliceQpBase();
124  Int sliceQpused = pcSlice->getSliceQp();
125  Int sliceQpnext;
126  Double alpha = qpBase < 17 ? 0.5 : 1;
127 
128  Int cnt=0;
129  for(Int u=1; u<=LEVEL_RANGE; u++)
130  { 
131    cnt += m_sliceNsamples[u] ;
132  }
133
134  if( !m_useRDOQ )
135  {
136    sliceQpused = qpBase;
137    alpha = 0.5;
138  }
139
140  if( cnt > 120 )
141  {
142    Double sum = 0;
143    Int k = 0;
144    for(Int u=1; u<LEVEL_RANGE; u++)
145    {
146      sum += u*m_sliceSumC[u];
147      k += u*u*m_sliceNsamples[u];
148    }
149
150    Int v;
151    Double q[MAX_QP+1] ;
152    for(v=0; v<=MAX_QP; v++)
153    {
154      q[v] = (Double)(g_invQuantScales[v%6] * (1<<(v/6)))/64 ;
155    }
156
157    Double qnext = sum/k * q[sliceQpused] / (1<<ARL_C_PRECISION);
158
159    for(v=0; v<MAX_QP; v++)
160    {
161      if(qnext < alpha * q[v] + (1 - alpha) * q[v+1] )
162      {
163        break;
164      }
165    }
166    sliceQpnext = Clip3(sliceQpused - 3, sliceQpused + 3, v);
167  }
168  else
169  {
170    sliceQpnext = sliceQpused;
171  }
172
173  m_qpDelta[qpBase] = sliceQpnext - qpBase; 
174}
175
176Void TComTrQuant::initSliceQpDelta()
177{
178  for(Int qp=0; qp<=MAX_QP; qp++)
179  {
180    m_qpDelta[qp] = qp < 17 ? 0 : 1;
181  }
182}
183
184Void TComTrQuant::clearSliceARLCnt()
185{ 
186  memset(m_sliceSumC, 0, sizeof(Double)*(LEVEL_RANGE+1));
187  memset(m_sliceNsamples, 0, sizeof(Int)*(LEVEL_RANGE+1));
188}
189#endif
190
191
192/** Set qP for Quantization.
193 * \param qpy QPy
194 * \param bLowpass
195 * \param eSliceType
196 * \param eTxtType
197 * \param qpBdOffset
198 * \param chromaQPOffset
199 *
200 * return void 
201 */
202Void TComTrQuant::setQPforQuant( Int qpy, TextType eTxtType, Int qpBdOffset, Int chromaQPOffset)
203{
204  Int qpScaled;
205
206  if(eTxtType == TEXT_LUMA)
207  {
208    qpScaled = qpy + qpBdOffset;
209  }
210  else
211  {
212    qpScaled = Clip3( -qpBdOffset, 57, qpy + chromaQPOffset );
213
214    if(qpScaled < 0)
215    {
216      qpScaled = qpScaled + qpBdOffset;
217    }
218    else
219    {
220      qpScaled = g_aucChromaScale[ qpScaled ] + qpBdOffset;
221    }
222  }
223  m_cQP.setQpParam( qpScaled );
224}
225
226#if MATRIX_MULT
227/** NxN forward transform (2D) using brute force matrix multiplication (3 nested loops)
228 *  \param block pointer to input data (residual)
229 *  \param coeff pointer to output data (transform coefficients)
230 *  \param uiStride stride of input data
231 *  \param uiTrSize transform size (uiTrSize x uiTrSize)
232 *  \param uiMode is Intra Prediction mode used in Mode-Dependent DCT/DST only
233 */
234void xTr(Int bitDepth, Pel *block, Int *coeff, UInt uiStride, UInt uiTrSize, UInt uiMode)
235{
236  Int i,j,k,iSum;
237  Int tmp[32*32];
238  const Short *iT;
239  UInt uiLog2TrSize = g_aucConvertToBit[ uiTrSize ] + 2;
240
241  if (uiTrSize==4)
242  {
243    iT  = g_aiT4[0];
244  }
245  else if (uiTrSize==8)
246  {
247    iT = g_aiT8[0];
248  }
249  else if (uiTrSize==16)
250  {
251    iT = g_aiT16[0];
252  }
253  else if (uiTrSize==32)
254  {
255    iT = g_aiT32[0];
256  }
257  else
258  {
259    assert(0);
260  }
261
262  Int shift_1st = uiLog2TrSize - 1 + bitDepth-8; // log2(N) - 1 + g_bitDepth-8
263  Int add_1st = 1<<(shift_1st-1);
264  Int shift_2nd = uiLog2TrSize + 6;
265  Int add_2nd = 1<<(shift_2nd-1);
266
267  /* Horizontal transform */
268
269  if (uiTrSize==4)
270  {
271    if (uiMode != REG_DCT && g_aucDCTDSTMode_Hor[uiMode])
272    {
273      iT  =  g_as_DST_MAT_4[0];
274    }
275  }
276  for (i=0; i<uiTrSize; i++)
277  {
278    for (j=0; j<uiTrSize; j++)
279    {
280      iSum = 0;
281      for (k=0; k<uiTrSize; k++)
282      {
283        iSum += iT[i*uiTrSize+k]*block[j*uiStride+k];
284      }
285      tmp[i*uiTrSize+j] = (iSum + add_1st)>>shift_1st;
286    }
287  }
288 
289  /* Vertical transform */
290  if (uiTrSize==4)
291  {
292    if (uiMode != REG_DCT && g_aucDCTDSTMode_Vert[uiMode])
293    {
294      iT  =  g_as_DST_MAT_4[0];
295    }
296    else
297    {
298      iT  = g_aiT4[0];
299    }
300  }
301  for (i=0; i<uiTrSize; i++)
302  {                 
303    for (j=0; j<uiTrSize; j++)
304    {
305      iSum = 0;
306      for (k=0; k<uiTrSize; k++)
307      {
308        iSum += iT[i*uiTrSize+k]*tmp[j*uiTrSize+k];       
309      }
310      coeff[i*uiTrSize+j] = (iSum + add_2nd)>>shift_2nd; 
311    }
312  }
313}
314
315/** NxN inverse transform (2D) using brute force matrix multiplication (3 nested loops)
316 *  \param coeff pointer to input data (transform coefficients)
317 *  \param block pointer to output data (residual)
318 *  \param uiStride stride of output data
319 *  \param uiTrSize transform size (uiTrSize x uiTrSize)
320 *  \param uiMode is Intra Prediction mode used in Mode-Dependent DCT/DST only
321 */
322void xITr(Int *coeff, Pel *block, UInt uiStride, UInt uiTrSize, UInt uiMode)
323{
324  Int i,j,k,iSum;
325  Int tmp[32*32];
326  const Short *iT;
327 
328  if (uiTrSize==4)
329  {
330    iT  = g_aiT4[0];
331  }
332  else if (uiTrSize==8)
333  {
334    iT = g_aiT8[0];
335  }
336  else if (uiTrSize==16)
337  {
338    iT = g_aiT16[0];
339  }
340  else if (uiTrSize==32)
341  {
342    iT = g_aiT32[0];
343  }
344  else
345  {
346    assert(0);
347  }
348 
349  Int shift_1st = SHIFT_INV_1ST;
350  Int add_1st = 1<<(shift_1st-1);
351  Int shift_2nd = SHIFT_INV_2ND - g_bitDepth-8;
352  Int add_2nd = 1<<(shift_2nd-1);
353  if (uiTrSize==4)
354  {
355    if (uiMode != REG_DCT && g_aucDCTDSTMode_Vert[uiMode] ) // Check for DCT or DST
356    {
357      iT  =  g_as_DST_MAT_4[0];
358    }
359  }
360 
361  /* Horizontal transform */
362  for (i=0; i<uiTrSize; i++)
363  {   
364    for (j=0; j<uiTrSize; j++)
365    {
366      iSum = 0;
367      for (k=0; k<uiTrSize; k++)
368      {       
369        iSum += iT[k*uiTrSize+i]*coeff[k*uiTrSize+j]; 
370      }
371      tmp[i*uiTrSize+j] = Clip3(-32768, 32767, (iSum + add_1st)>>shift_1st); // Clipping is normative
372    }
373  }   
374 
375  if (uiTrSize==4)
376  {
377    if (uiMode != REG_DCT && g_aucDCTDSTMode_Hor[uiMode] )   // Check for DCT or DST
378    {
379      iT  =  g_as_DST_MAT_4[0];
380    }
381    else 
382    {
383      iT  = g_aiT4[0];
384    }
385  }
386 
387  /* Vertical transform */
388  for (i=0; i<uiTrSize; i++)
389  {   
390    for (j=0; j<uiTrSize; j++)
391    {
392      iSum = 0;
393      for (k=0; k<uiTrSize; k++)
394      {       
395        iSum += iT[k*uiTrSize+j]*tmp[i*uiTrSize+k];
396      }
397      block[i*uiStride+j] = Clip3(-32768, 32767, (iSum + add_2nd)>>shift_2nd); // Clipping is non-normative
398    }
399  }
400}
401
402#else //MATRIX_MULT
403
404/** 4x4 forward transform implemented using partial butterfly structure (1D)
405 *  \param src   input data (residual)
406 *  \param dst   output data (transform coefficients)
407 *  \param shift specifies right shift after 1D transform
408 */
409
410void partialButterfly4(Short *src,Short *dst,Int shift, Int line)
411{
412  Int j;
413  Int E[2],O[2];
414  Int add = 1<<(shift-1);
415
416  for (j=0; j<line; j++)
417  {   
418    /* E and O */
419    E[0] = src[0] + src[3];
420    O[0] = src[0] - src[3];
421    E[1] = src[1] + src[2];
422    O[1] = src[1] - src[2];
423
424    dst[0] = (g_aiT4[0][0]*E[0] + g_aiT4[0][1]*E[1] + add)>>shift;
425    dst[2*line] = (g_aiT4[2][0]*E[0] + g_aiT4[2][1]*E[1] + add)>>shift;
426    dst[line] = (g_aiT4[1][0]*O[0] + g_aiT4[1][1]*O[1] + add)>>shift;
427    dst[3*line] = (g_aiT4[3][0]*O[0] + g_aiT4[3][1]*O[1] + add)>>shift;
428
429    src += 4;
430    dst ++;
431  }
432}
433
434// Fast DST Algorithm. Full matrix multiplication for DST and Fast DST algorithm
435// give identical results
436void fastForwardDst(Short *block,Short *coeff,Int shift)  // input block, output coeff
437{
438  Int i, c[4];
439  Int rnd_factor = 1<<(shift-1);
440  for (i=0; i<4; i++)
441  {
442    // Intermediate Variables
443    c[0] = block[4*i+0] + block[4*i+3];
444    c[1] = block[4*i+1] + block[4*i+3];
445    c[2] = block[4*i+0] - block[4*i+1];
446    c[3] = 74* block[4*i+2];
447
448    coeff[   i] =  ( 29 * c[0] + 55 * c[1]         + c[3]               + rnd_factor ) >> shift;
449    coeff[ 4+i] =  ( 74 * (block[4*i+0]+ block[4*i+1] - block[4*i+3])   + rnd_factor ) >> shift;
450    coeff[ 8+i] =  ( 29 * c[2] + 55 * c[0]         - c[3]               + rnd_factor ) >> shift;
451    coeff[12+i] =  ( 55 * c[2] - 29 * c[1]         + c[3]               + rnd_factor ) >> shift;
452  }
453}
454
455void fastInverseDst(Short *tmp,Short *block,Int shift)  // input tmp, output block
456{
457  Int i, c[4];
458  Int rnd_factor = 1<<(shift-1);
459  for (i=0; i<4; i++)
460  { 
461    // Intermediate Variables
462    c[0] = tmp[  i] + tmp[ 8+i];
463    c[1] = tmp[8+i] + tmp[12+i];
464    c[2] = tmp[  i] - tmp[12+i];
465    c[3] = 74* tmp[4+i];
466
467    block[4*i+0] = Clip3( -32768, 32767, ( 29 * c[0] + 55 * c[1]     + c[3]               + rnd_factor ) >> shift );
468    block[4*i+1] = Clip3( -32768, 32767, ( 55 * c[2] - 29 * c[1]     + c[3]               + rnd_factor ) >> shift );
469    block[4*i+2] = Clip3( -32768, 32767, ( 74 * (tmp[i] - tmp[8+i]  + tmp[12+i])      + rnd_factor ) >> shift );
470    block[4*i+3] = Clip3( -32768, 32767, ( 55 * c[0] + 29 * c[2]     - c[3]               + rnd_factor ) >> shift );
471  }
472}
473
474void partialButterflyInverse4(Short *src,Short *dst,Int shift, Int line)
475{
476  Int j;
477  Int E[2],O[2];
478  Int add = 1<<(shift-1);
479
480  for (j=0; j<line; j++)
481  {   
482    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */   
483    O[0] = g_aiT4[1][0]*src[line] + g_aiT4[3][0]*src[3*line];
484    O[1] = g_aiT4[1][1]*src[line] + g_aiT4[3][1]*src[3*line];
485    E[0] = g_aiT4[0][0]*src[0] + g_aiT4[2][0]*src[2*line];
486    E[1] = g_aiT4[0][1]*src[0] + g_aiT4[2][1]*src[2*line];
487
488    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
489    dst[0] = Clip3( -32768, 32767, (E[0] + O[0] + add)>>shift );
490    dst[1] = Clip3( -32768, 32767, (E[1] + O[1] + add)>>shift );
491    dst[2] = Clip3( -32768, 32767, (E[1] - O[1] + add)>>shift );
492    dst[3] = Clip3( -32768, 32767, (E[0] - O[0] + add)>>shift );
493           
494    src   ++;
495    dst += 4;
496  }
497}
498
499
500void partialButterfly8(Short *src,Short *dst,Int shift, Int line)
501{
502  Int j,k;
503  Int E[4],O[4];
504  Int EE[2],EO[2];
505  Int add = 1<<(shift-1);
506
507  for (j=0; j<line; j++)
508  { 
509    /* E and O*/
510    for (k=0;k<4;k++)
511    {
512      E[k] = src[k] + src[7-k];
513      O[k] = src[k] - src[7-k];
514    }   
515    /* EE and EO */
516    EE[0] = E[0] + E[3];   
517    EO[0] = E[0] - E[3];
518    EE[1] = E[1] + E[2];
519    EO[1] = E[1] - E[2];
520
521    dst[0] = (g_aiT8[0][0]*EE[0] + g_aiT8[0][1]*EE[1] + add)>>shift;
522    dst[4*line] = (g_aiT8[4][0]*EE[0] + g_aiT8[4][1]*EE[1] + add)>>shift; 
523    dst[2*line] = (g_aiT8[2][0]*EO[0] + g_aiT8[2][1]*EO[1] + add)>>shift;
524    dst[6*line] = (g_aiT8[6][0]*EO[0] + g_aiT8[6][1]*EO[1] + add)>>shift; 
525
526    dst[line] = (g_aiT8[1][0]*O[0] + g_aiT8[1][1]*O[1] + g_aiT8[1][2]*O[2] + g_aiT8[1][3]*O[3] + add)>>shift;
527    dst[3*line] = (g_aiT8[3][0]*O[0] + g_aiT8[3][1]*O[1] + g_aiT8[3][2]*O[2] + g_aiT8[3][3]*O[3] + add)>>shift;
528    dst[5*line] = (g_aiT8[5][0]*O[0] + g_aiT8[5][1]*O[1] + g_aiT8[5][2]*O[2] + g_aiT8[5][3]*O[3] + add)>>shift;
529    dst[7*line] = (g_aiT8[7][0]*O[0] + g_aiT8[7][1]*O[1] + g_aiT8[7][2]*O[2] + g_aiT8[7][3]*O[3] + add)>>shift;
530
531    src += 8;
532    dst ++;
533  }
534}
535
536
537void partialButterflyInverse8(Short *src,Short *dst,Int shift, Int line)
538{
539  Int j,k;
540  Int E[4],O[4];
541  Int EE[2],EO[2];
542  Int add = 1<<(shift-1);
543
544  for (j=0; j<line; j++) 
545  {   
546    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
547    for (k=0;k<4;k++)
548    {
549      O[k] = g_aiT8[ 1][k]*src[line] + g_aiT8[ 3][k]*src[3*line] + g_aiT8[ 5][k]*src[5*line] + g_aiT8[ 7][k]*src[7*line];
550    }
551
552    EO[0] = g_aiT8[2][0]*src[ 2*line ] + g_aiT8[6][0]*src[ 6*line ];
553    EO[1] = g_aiT8[2][1]*src[ 2*line ] + g_aiT8[6][1]*src[ 6*line ];
554    EE[0] = g_aiT8[0][0]*src[ 0      ] + g_aiT8[4][0]*src[ 4*line ];
555    EE[1] = g_aiT8[0][1]*src[ 0      ] + g_aiT8[4][1]*src[ 4*line ];
556
557    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */ 
558    E[0] = EE[0] + EO[0];
559    E[3] = EE[0] - EO[0];
560    E[1] = EE[1] + EO[1];
561    E[2] = EE[1] - EO[1];
562    for (k=0;k<4;k++)
563    {
564      dst[ k   ] = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
565      dst[ k+4 ] = Clip3( -32768, 32767, (E[3-k] - O[3-k] + add)>>shift );
566    }   
567    src ++;
568    dst += 8;
569  }
570}
571
572
573void partialButterfly16(Short *src,Short *dst,Int shift, Int line)
574{
575  Int j,k;
576  Int E[8],O[8];
577  Int EE[4],EO[4];
578  Int EEE[2],EEO[2];
579  Int add = 1<<(shift-1);
580
581  for (j=0; j<line; j++) 
582  {   
583    /* E and O*/
584    for (k=0;k<8;k++)
585    {
586      E[k] = src[k] + src[15-k];
587      O[k] = src[k] - src[15-k];
588    } 
589    /* EE and EO */
590    for (k=0;k<4;k++)
591    {
592      EE[k] = E[k] + E[7-k];
593      EO[k] = E[k] - E[7-k];
594    }
595    /* EEE and EEO */
596    EEE[0] = EE[0] + EE[3];   
597    EEO[0] = EE[0] - EE[3];
598    EEE[1] = EE[1] + EE[2];
599    EEO[1] = EE[1] - EE[2];
600
601    dst[ 0      ] = (g_aiT16[ 0][0]*EEE[0] + g_aiT16[ 0][1]*EEE[1] + add)>>shift;       
602    dst[ 8*line ] = (g_aiT16[ 8][0]*EEE[0] + g_aiT16[ 8][1]*EEE[1] + add)>>shift;   
603    dst[ 4*line ] = (g_aiT16[ 4][0]*EEO[0] + g_aiT16[ 4][1]*EEO[1] + add)>>shift;       
604    dst[ 12*line] = (g_aiT16[12][0]*EEO[0] + g_aiT16[12][1]*EEO[1] + add)>>shift;
605
606    for (k=2;k<16;k+=4)
607    {
608      dst[ k*line ] = (g_aiT16[k][0]*EO[0] + g_aiT16[k][1]*EO[1] + g_aiT16[k][2]*EO[2] + g_aiT16[k][3]*EO[3] + add)>>shift;     
609    }
610
611    for (k=1;k<16;k+=2)
612    {
613      dst[ k*line ] = (g_aiT16[k][0]*O[0] + g_aiT16[k][1]*O[1] + g_aiT16[k][2]*O[2] + g_aiT16[k][3]*O[3] + 
614        g_aiT16[k][4]*O[4] + g_aiT16[k][5]*O[5] + g_aiT16[k][6]*O[6] + g_aiT16[k][7]*O[7] + add)>>shift;
615    }
616
617    src += 16;
618    dst ++; 
619
620  }
621}
622
623
624void partialButterflyInverse16(Short *src,Short *dst,Int shift, Int line)
625{
626  Int j,k;
627  Int E[8],O[8];
628  Int EE[4],EO[4];
629  Int EEE[2],EEO[2];
630  Int add = 1<<(shift-1);
631
632  for (j=0; j<line; j++)
633  {   
634    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
635    for (k=0;k<8;k++)
636    {
637      O[k] = g_aiT16[ 1][k]*src[ line] + g_aiT16[ 3][k]*src[ 3*line] + g_aiT16[ 5][k]*src[ 5*line] + g_aiT16[ 7][k]*src[ 7*line] + 
638        g_aiT16[ 9][k]*src[ 9*line] + g_aiT16[11][k]*src[11*line] + g_aiT16[13][k]*src[13*line] + g_aiT16[15][k]*src[15*line];
639    }
640    for (k=0;k<4;k++)
641    {
642      EO[k] = g_aiT16[ 2][k]*src[ 2*line] + g_aiT16[ 6][k]*src[ 6*line] + g_aiT16[10][k]*src[10*line] + g_aiT16[14][k]*src[14*line];
643    }
644    EEO[0] = g_aiT16[4][0]*src[ 4*line ] + g_aiT16[12][0]*src[ 12*line ];
645    EEE[0] = g_aiT16[0][0]*src[ 0      ] + g_aiT16[ 8][0]*src[ 8*line  ];
646    EEO[1] = g_aiT16[4][1]*src[ 4*line ] + g_aiT16[12][1]*src[ 12*line ];
647    EEE[1] = g_aiT16[0][1]*src[ 0      ] + g_aiT16[ 8][1]*src[ 8*line  ];
648
649    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */ 
650    for (k=0;k<2;k++)
651    {
652      EE[k] = EEE[k] + EEO[k];
653      EE[k+2] = EEE[1-k] - EEO[1-k];
654    }   
655    for (k=0;k<4;k++)
656    {
657      E[k] = EE[k] + EO[k];
658      E[k+4] = EE[3-k] - EO[3-k];
659    }   
660    for (k=0;k<8;k++)
661    {
662      dst[k]   = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
663      dst[k+8] = Clip3( -32768, 32767, (E[7-k] - O[7-k] + add)>>shift );
664    }   
665    src ++; 
666    dst += 16;
667  }
668}
669
670
671void partialButterfly32(Short *src,Short *dst,Int shift, Int line)
672{
673  Int j,k;
674  Int E[16],O[16];
675  Int EE[8],EO[8];
676  Int EEE[4],EEO[4];
677  Int EEEE[2],EEEO[2];
678  Int add = 1<<(shift-1);
679
680  for (j=0; j<line; j++)
681  {   
682    /* E and O*/
683    for (k=0;k<16;k++)
684    {
685      E[k] = src[k] + src[31-k];
686      O[k] = src[k] - src[31-k];
687    } 
688    /* EE and EO */
689    for (k=0;k<8;k++)
690    {
691      EE[k] = E[k] + E[15-k];
692      EO[k] = E[k] - E[15-k];
693    }
694    /* EEE and EEO */
695    for (k=0;k<4;k++)
696    {
697      EEE[k] = EE[k] + EE[7-k];
698      EEO[k] = EE[k] - EE[7-k];
699    }
700    /* EEEE and EEEO */
701    EEEE[0] = EEE[0] + EEE[3];   
702    EEEO[0] = EEE[0] - EEE[3];
703    EEEE[1] = EEE[1] + EEE[2];
704    EEEO[1] = EEE[1] - EEE[2];
705
706    dst[ 0       ] = (g_aiT32[ 0][0]*EEEE[0] + g_aiT32[ 0][1]*EEEE[1] + add)>>shift;
707    dst[ 16*line ] = (g_aiT32[16][0]*EEEE[0] + g_aiT32[16][1]*EEEE[1] + add)>>shift;
708    dst[ 8*line  ] = (g_aiT32[ 8][0]*EEEO[0] + g_aiT32[ 8][1]*EEEO[1] + add)>>shift; 
709    dst[ 24*line ] = (g_aiT32[24][0]*EEEO[0] + g_aiT32[24][1]*EEEO[1] + add)>>shift;
710    for (k=4;k<32;k+=8)
711    {
712      dst[ k*line ] = (g_aiT32[k][0]*EEO[0] + g_aiT32[k][1]*EEO[1] + g_aiT32[k][2]*EEO[2] + g_aiT32[k][3]*EEO[3] + add)>>shift;
713    }       
714    for (k=2;k<32;k+=4)
715    {
716      dst[ k*line ] = (g_aiT32[k][0]*EO[0] + g_aiT32[k][1]*EO[1] + g_aiT32[k][2]*EO[2] + g_aiT32[k][3]*EO[3] + 
717        g_aiT32[k][4]*EO[4] + g_aiT32[k][5]*EO[5] + g_aiT32[k][6]*EO[6] + g_aiT32[k][7]*EO[7] + add)>>shift;
718    }       
719    for (k=1;k<32;k+=2)
720    {
721      dst[ k*line ] = (g_aiT32[k][ 0]*O[ 0] + g_aiT32[k][ 1]*O[ 1] + g_aiT32[k][ 2]*O[ 2] + g_aiT32[k][ 3]*O[ 3] + 
722        g_aiT32[k][ 4]*O[ 4] + g_aiT32[k][ 5]*O[ 5] + g_aiT32[k][ 6]*O[ 6] + g_aiT32[k][ 7]*O[ 7] +
723        g_aiT32[k][ 8]*O[ 8] + g_aiT32[k][ 9]*O[ 9] + g_aiT32[k][10]*O[10] + g_aiT32[k][11]*O[11] + 
724        g_aiT32[k][12]*O[12] + g_aiT32[k][13]*O[13] + g_aiT32[k][14]*O[14] + g_aiT32[k][15]*O[15] + add)>>shift;
725    }
726    src += 32;
727    dst ++;
728  }
729}
730
731
732void partialButterflyInverse32(Short *src,Short *dst,Int shift, Int line)
733{
734  Int j,k;
735  Int E[16],O[16];
736  Int EE[8],EO[8];
737  Int EEE[4],EEO[4];
738  Int EEEE[2],EEEO[2];
739  Int add = 1<<(shift-1);
740
741  for (j=0; j<line; j++)
742  {   
743    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
744    for (k=0;k<16;k++)
745    {
746      O[k] = g_aiT32[ 1][k]*src[ line  ] + g_aiT32[ 3][k]*src[ 3*line  ] + g_aiT32[ 5][k]*src[ 5*line  ] + g_aiT32[ 7][k]*src[ 7*line  ] + 
747        g_aiT32[ 9][k]*src[ 9*line  ] + g_aiT32[11][k]*src[ 11*line ] + g_aiT32[13][k]*src[ 13*line ] + g_aiT32[15][k]*src[ 15*line ] + 
748        g_aiT32[17][k]*src[ 17*line ] + g_aiT32[19][k]*src[ 19*line ] + g_aiT32[21][k]*src[ 21*line ] + g_aiT32[23][k]*src[ 23*line ] + 
749        g_aiT32[25][k]*src[ 25*line ] + g_aiT32[27][k]*src[ 27*line ] + g_aiT32[29][k]*src[ 29*line ] + g_aiT32[31][k]*src[ 31*line ];
750    }
751    for (k=0;k<8;k++)
752    {
753      EO[k] = g_aiT32[ 2][k]*src[ 2*line  ] + g_aiT32[ 6][k]*src[ 6*line  ] + g_aiT32[10][k]*src[ 10*line ] + g_aiT32[14][k]*src[ 14*line ] + 
754        g_aiT32[18][k]*src[ 18*line ] + g_aiT32[22][k]*src[ 22*line ] + g_aiT32[26][k]*src[ 26*line ] + g_aiT32[30][k]*src[ 30*line ];
755    }
756    for (k=0;k<4;k++)
757    {
758      EEO[k] = g_aiT32[4][k]*src[ 4*line ] + g_aiT32[12][k]*src[ 12*line ] + g_aiT32[20][k]*src[ 20*line ] + g_aiT32[28][k]*src[ 28*line ];
759    }
760    EEEO[0] = g_aiT32[8][0]*src[ 8*line ] + g_aiT32[24][0]*src[ 24*line ];
761    EEEO[1] = g_aiT32[8][1]*src[ 8*line ] + g_aiT32[24][1]*src[ 24*line ];
762    EEEE[0] = g_aiT32[0][0]*src[ 0      ] + g_aiT32[16][0]*src[ 16*line ];   
763    EEEE[1] = g_aiT32[0][1]*src[ 0      ] + g_aiT32[16][1]*src[ 16*line ];
764
765    /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
766    EEE[0] = EEEE[0] + EEEO[0];
767    EEE[3] = EEEE[0] - EEEO[0];
768    EEE[1] = EEEE[1] + EEEO[1];
769    EEE[2] = EEEE[1] - EEEO[1];   
770    for (k=0;k<4;k++)
771    {
772      EE[k] = EEE[k] + EEO[k];
773      EE[k+4] = EEE[3-k] - EEO[3-k];
774    }   
775    for (k=0;k<8;k++)
776    {
777      E[k] = EE[k] + EO[k];
778      E[k+8] = EE[7-k] - EO[7-k];
779    }   
780    for (k=0;k<16;k++)
781    {
782      dst[k]    = Clip3( -32768, 32767, (E[k] + O[k] + add)>>shift );
783      dst[k+16] = Clip3( -32768, 32767, (E[15-k] - O[15-k] + add)>>shift );
784    }
785    src ++;
786    dst += 32;
787  }
788}
789
790/** MxN forward transform (2D)
791*  \param block input data (residual)
792*  \param coeff output data (transform coefficients)
793*  \param iWidth input data (width of transform)
794*  \param iHeight input data (height of transform)
795*/
796void xTrMxN(Int bitDepth, Short *block,Short *coeff, Int iWidth, Int iHeight, UInt uiMode)
797{
798  Int shift_1st = g_aucConvertToBit[iWidth]  + 1 + bitDepth-8; // log2(iWidth) - 1 + g_bitDepth - 8
799  Int shift_2nd = g_aucConvertToBit[iHeight]  + 8;                   // log2(iHeight) + 6
800
801  Short tmp[ 64 * 64 ];
802
803  if( iWidth == 4 && iHeight == 4)
804  {
805    if (uiMode != REG_DCT)
806    {
807      fastForwardDst(block,tmp,shift_1st); // Forward DST BY FAST ALGORITHM, block input, tmp output
808      fastForwardDst(tmp,coeff,shift_2nd); // Forward DST BY FAST ALGORITHM, tmp input, coeff output
809    }
810    else
811    {
812      partialButterfly4(block, tmp, shift_1st, iHeight);
813      partialButterfly4(tmp, coeff, shift_2nd, iWidth);
814    }
815
816  }
817  else if( iWidth == 8 && iHeight == 8)
818  {
819    partialButterfly8( block, tmp, shift_1st, iHeight );
820    partialButterfly8( tmp, coeff, shift_2nd, iWidth );
821  }
822  else if( iWidth == 16 && iHeight == 16)
823  {
824    partialButterfly16( block, tmp, shift_1st, iHeight );
825    partialButterfly16( tmp, coeff, shift_2nd, iWidth );
826  }
827  else if( iWidth == 32 && iHeight == 32)
828  {
829    partialButterfly32( block, tmp, shift_1st, iHeight );
830    partialButterfly32( tmp, coeff, shift_2nd, iWidth );
831  }
832}
833/** MxN inverse transform (2D)
834*  \param coeff input data (transform coefficients)
835*  \param block output data (residual)
836*  \param iWidth input data (width of transform)
837*  \param iHeight input data (height of transform)
838*/
839void xITrMxN(Int bitDepth, Short *coeff,Short *block, Int iWidth, Int iHeight, UInt uiMode)
840{
841  Int shift_1st = SHIFT_INV_1ST;
842  Int shift_2nd = SHIFT_INV_2ND - (bitDepth-8);
843
844  Short tmp[ 64*64];
845  if( iWidth == 4 && iHeight == 4)
846  {
847    if (uiMode != REG_DCT)
848    {
849      fastInverseDst(coeff,tmp,shift_1st);    // Inverse DST by FAST Algorithm, coeff input, tmp output
850      fastInverseDst(tmp,block,shift_2nd); // Inverse DST by FAST Algorithm, tmp input, coeff output
851    }
852    else
853    {
854      partialButterflyInverse4(coeff,tmp,shift_1st,iWidth);
855      partialButterflyInverse4(tmp,block,shift_2nd,iHeight);
856    }
857  }
858  else if( iWidth == 8 && iHeight == 8)
859  {
860    partialButterflyInverse8(coeff,tmp,shift_1st,iWidth);
861    partialButterflyInverse8(tmp,block,shift_2nd,iHeight);
862  }
863  else if( iWidth == 16 && iHeight == 16)
864  {
865    partialButterflyInverse16(coeff,tmp,shift_1st,iWidth);
866    partialButterflyInverse16(tmp,block,shift_2nd,iHeight);
867  }
868  else if( iWidth == 32 && iHeight == 32)
869  {
870    partialButterflyInverse32(coeff,tmp,shift_1st,iWidth);
871    partialButterflyInverse32(tmp,block,shift_2nd,iHeight);
872  }
873}
874
875#endif //MATRIX_MULT
876
877// To minimize the distortion only. No rate is considered.
878Void TComTrQuant::signBitHidingHDQ( TCoeff* pQCoef, TCoeff* pCoef, UInt const *scan, Int* deltaU, Int width, Int height )
879{
880  Int lastCG = -1;
881  Int absSum = 0 ;
882  Int n ;
883
884  for( Int subSet = (width*height-1) >> LOG2_SCAN_SET_SIZE; subSet >= 0; subSet-- )
885  {
886    Int  subPos     = subSet << LOG2_SCAN_SET_SIZE;
887    Int  firstNZPosInCG=SCAN_SET_SIZE , lastNZPosInCG=-1 ;
888    absSum = 0 ;
889
890    for(n = SCAN_SET_SIZE-1; n >= 0; --n )
891    {
892      if( pQCoef[ scan[ n + subPos ]] )
893      {
894        lastNZPosInCG = n;
895        break;
896      }
897    }
898
899    for(n = 0; n <SCAN_SET_SIZE; n++ )
900    {
901      if( pQCoef[ scan[ n + subPos ]] )
902      {
903        firstNZPosInCG = n;
904        break;
905      }
906    }
907
908    for(n = firstNZPosInCG; n <=lastNZPosInCG; n++ )
909    {
910      absSum += pQCoef[ scan[ n + subPos ]];
911    }
912
913    if(lastNZPosInCG>=0 && lastCG==-1) 
914    {
915      lastCG = 1 ; 
916    }
917
918    if( lastNZPosInCG-firstNZPosInCG>=SBH_THRESHOLD )
919    {
920      UInt signbit = (pQCoef[scan[subPos+firstNZPosInCG]]>0?0:1) ;
921      if( signbit!=(absSum&0x1) )  //compare signbit with sum_parity
922      {
923        Int minCostInc = MAX_INT,  minPos =-1, finalChange=0, curCost=MAX_INT, curChange=0;
924       
925        for( n = (lastCG==1?lastNZPosInCG:SCAN_SET_SIZE-1) ; n >= 0; --n )
926        {
927          UInt blkPos   = scan[ n+subPos ];
928          if(pQCoef[ blkPos ] != 0 )
929          {
930            if(deltaU[blkPos]>0)
931            {
932              curCost = - deltaU[blkPos]; 
933              curChange=1 ;
934            }
935            else 
936            {
937              //curChange =-1;
938              if(n==firstNZPosInCG && abs(pQCoef[blkPos])==1)
939              {
940                curCost=MAX_INT ; 
941              }
942              else
943              {
944                curCost = deltaU[blkPos]; 
945                curChange =-1;
946              }
947            }
948          }
949          else
950          {
951            if(n<firstNZPosInCG)
952            {
953              UInt thisSignBit = (pCoef[blkPos]>=0?0:1);
954              if(thisSignBit != signbit )
955              {
956                curCost = MAX_INT;
957              }
958              else
959              { 
960                curCost = - (deltaU[blkPos])  ;
961                curChange = 1 ;
962              }
963            }
964            else
965            {
966              curCost = - (deltaU[blkPos])  ;
967              curChange = 1 ;
968            }
969          }
970
971          if( curCost<minCostInc)
972          {
973            minCostInc = curCost ;
974            finalChange = curChange ;
975            minPos = blkPos ;
976          }
977        } //CG loop
978
979        if(pQCoef[minPos] == 32767 || pQCoef[minPos] == -32768)
980        {
981          finalChange = -1;
982        }
983
984        if(pCoef[minPos]>=0)
985        {
986          pQCoef[minPos] += finalChange ; 
987        }
988        else 
989        { 
990          pQCoef[minPos] -= finalChange ;
991        } 
992      } // Hide
993    }
994    if(lastCG==1) 
995    {
996      lastCG=0 ;
997    }
998  } // TU loop
999
1000  return;
1001}
1002
1003Void TComTrQuant::xQuant( TComDataCU* pcCU, 
1004                          Int*        pSrc, 
1005                          TCoeff*     pDes, 
1006#if ADAPTIVE_QP_SELECTION
1007                          Int*&       pArlDes,
1008#endif
1009                          Int         iWidth, 
1010                          Int         iHeight, 
1011                          UInt&       uiAcSum, 
1012                          TextType    eTType, 
1013                          UInt        uiAbsPartIdx )
1014{
1015  Int*   piCoef    = pSrc;
1016  TCoeff* piQCoef   = pDes;
1017#if ADAPTIVE_QP_SELECTION
1018  Int*   piArlCCoef = pArlDes;
1019#endif
1020  Int   iAdd = 0;
1021 
1022  Bool useRDOQ = pcCU->getTransformSkip(uiAbsPartIdx,eTType) ? m_useRDOQTS:m_useRDOQ;
1023  if ( useRDOQ && (eTType == TEXT_LUMA || RDOQ_CHROMA))
1024  {
1025#if ADAPTIVE_QP_SELECTION
1026    xRateDistOptQuant( pcCU, piCoef, pDes, pArlDes, iWidth, iHeight, uiAcSum, eTType, uiAbsPartIdx );
1027#else
1028    xRateDistOptQuant( pcCU, piCoef, pDes, iWidth, iHeight, uiAcSum, eTType, uiAbsPartIdx );
1029#endif
1030  }
1031  else
1032  {
1033    const UInt   log2BlockSize   = g_aucConvertToBit[ iWidth ] + 2;
1034
1035    UInt scanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, iWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
1036    const UInt *scan = g_auiSigLastScan[ scanIdx ][ log2BlockSize - 1 ];
1037   
1038    Int deltaU[32*32] ;
1039
1040#if ADAPTIVE_QP_SELECTION
1041    QpParam cQpBase;
1042    Int iQpBase = pcCU->getSlice()->getSliceQpBase();
1043
1044    Int qpScaled;
1045#if REPN_FORMAT_IN_VPS
1046    Int qpBDOffset = (eTType == TEXT_LUMA)? pcCU->getSlice()->getQpBDOffsetY() : pcCU->getSlice()->getQpBDOffsetC();
1047#else
1048    Int qpBDOffset = (eTType == TEXT_LUMA)? pcCU->getSlice()->getSPS()->getQpBDOffsetY() : pcCU->getSlice()->getSPS()->getQpBDOffsetC();
1049#endif
1050
1051    if(eTType == TEXT_LUMA)
1052    {
1053      qpScaled = iQpBase + qpBDOffset;
1054    }
1055    else
1056    {
1057      Int chromaQPOffset;
1058      if(eTType == TEXT_CHROMA_U)
1059      {
1060        chromaQPOffset = pcCU->getSlice()->getPPS()->getChromaCbQpOffset() + pcCU->getSlice()->getSliceQpDeltaCb();
1061      }
1062      else
1063      {
1064        chromaQPOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();
1065      }
1066      iQpBase = iQpBase + chromaQPOffset;
1067     
1068      qpScaled = Clip3( -qpBDOffset, 57, iQpBase);
1069
1070      if(qpScaled < 0)
1071      {
1072        qpScaled = qpScaled +  qpBDOffset;
1073      }
1074      else
1075      {
1076        qpScaled = g_aucChromaScale[ qpScaled ] + qpBDOffset;
1077      }
1078    }
1079    cQpBase.setQpParam(qpScaled);
1080#endif
1081
1082    UInt uiLog2TrSize = g_aucConvertToBit[ iWidth ] + 2;
1083    Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)eTType];
1084    assert(scalingListType < 6);
1085    Int *piQuantCoeff = 0;
1086    piQuantCoeff = getQuantCoeff(scalingListType,m_cQP.m_iRem,uiLog2TrSize-2);
1087
1088    UInt uiBitDepth = eTType == TEXT_LUMA ? g_bitDepthY : g_bitDepthC;
1089    Int iTransformShift = MAX_TR_DYNAMIC_RANGE - uiBitDepth - uiLog2TrSize;  // Represents scaling through forward transform
1090
1091#if ADAPTIVE_QP_SELECTION
1092    Int iQBits = QUANT_SHIFT + cQpBase.m_iPer + iTransformShift;
1093    iAdd = (pcCU->getSlice()->getSliceType()==I_SLICE ? 171 : 85) << (iQBits-9);
1094    Int iQBitsC = QUANT_SHIFT + cQpBase.m_iPer + iTransformShift - ARL_C_PRECISION; 
1095    Int iAddC   = 1 << (iQBitsC-1);
1096#else
1097    Int iQBits = QUANT_SHIFT + m_cQP.m_iPer + iTransformShift;                // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits
1098    iAdd = (pcCU->getSlice()->getSliceType()==I_SLICE ? 171 : 85) << (iQBits-9);
1099#endif
1100
1101    Int qBits8 = iQBits-8;
1102    for( Int n = 0; n < iWidth*iHeight; n++ )
1103    {
1104      Int iLevel;
1105      Int  iSign;
1106      UInt uiBlockPos = n;
1107      iLevel  = piCoef[uiBlockPos];
1108      iSign   = (iLevel < 0 ? -1: 1);     
1109
1110#if ADAPTIVE_QP_SELECTION
1111      Int64 tmpLevel = (Int64)abs(iLevel) * piQuantCoeff[uiBlockPos];
1112      if( m_bUseAdaptQpSelect )
1113      {
1114        piArlCCoef[uiBlockPos] = (Int)((tmpLevel + iAddC ) >> iQBitsC);
1115      }
1116      iLevel = (Int)((tmpLevel + iAdd ) >> iQBits);
1117      deltaU[uiBlockPos] = (Int)((tmpLevel - (iLevel<<iQBits) )>> qBits8);
1118#else
1119      iLevel = ((Int64)abs(iLevel) * piQuantCoeff[uiBlockPos] + iAdd ) >> iQBits;
1120      deltaU[uiBlockPos] = (Int)( ((Int64)abs(piCoef[uiBlockPos]) * piQuantCoeff[uiBlockPos] - (iLevel<<iQBits) )>> qBits8 );
1121#endif
1122      uiAcSum += iLevel;
1123      iLevel *= iSign;       
1124      piQCoef[uiBlockPos] = Clip3( -32768, 32767, iLevel );
1125    } // for n
1126    if( pcCU->getSlice()->getPPS()->getSignHideFlag() )
1127    {
1128      if(uiAcSum>=2)
1129      {
1130        signBitHidingHDQ( piQCoef, piCoef, scan, deltaU, iWidth, iHeight ) ;
1131      }
1132    }
1133  } //if RDOQ
1134  //return;
1135
1136}
1137
1138Void TComTrQuant::xDeQuant(Int bitDepth, const TCoeff* pSrc, Int* pDes, Int iWidth, Int iHeight, Int scalingListType )
1139{
1140 
1141  const TCoeff* piQCoef   = pSrc;
1142  Int*   piCoef    = pDes;
1143 
1144  if ( iWidth > (Int)m_uiMaxTrSize )
1145  {
1146    iWidth  = m_uiMaxTrSize;
1147    iHeight = m_uiMaxTrSize;
1148  }
1149 
1150  Int iShift,iAdd,iCoeffQ;
1151  UInt uiLog2TrSize = g_aucConvertToBit[ iWidth ] + 2;
1152
1153  Int iTransformShift = MAX_TR_DYNAMIC_RANGE - bitDepth - uiLog2TrSize;
1154
1155  iShift = QUANT_IQUANT_SHIFT - QUANT_SHIFT - iTransformShift;
1156
1157  TCoeff clipQCoef;
1158
1159  if(getUseScalingList())
1160  {
1161    iShift += 4;
1162    Int *piDequantCoef = getDequantCoeff(scalingListType,m_cQP.m_iRem,uiLog2TrSize-2);
1163
1164    if(iShift > m_cQP.m_iPer)
1165    {
1166      iAdd = 1 << (iShift - m_cQP.m_iPer - 1);
1167     
1168      for( Int n = 0; n < iWidth*iHeight; n++ )
1169      {
1170        clipQCoef = Clip3( -32768, 32767, piQCoef[n] );
1171        iCoeffQ = ((clipQCoef * piDequantCoef[n]) + iAdd ) >> (iShift -  m_cQP.m_iPer);
1172        piCoef[n] = Clip3(-32768,32767,iCoeffQ);
1173      }
1174    }
1175    else
1176    {
1177      for( Int n = 0; n < iWidth*iHeight; n++ )
1178      {
1179        clipQCoef = Clip3( -32768, 32767, piQCoef[n] );
1180        iCoeffQ   = Clip3( -32768, 32767, clipQCoef * piDequantCoef[n] ); // Clip to avoid possible overflow in following shift left operation
1181        piCoef[n] = Clip3( -32768, 32767, iCoeffQ << ( m_cQP.m_iPer - iShift ) );
1182      }
1183    }
1184  }
1185  else
1186  {
1187    iAdd = 1 << (iShift-1);
1188    Int scale = g_invQuantScales[m_cQP.m_iRem] << m_cQP.m_iPer;
1189
1190    for( Int n = 0; n < iWidth*iHeight; n++ )
1191    {
1192      clipQCoef = Clip3( -32768, 32767, piQCoef[n] );
1193      iCoeffQ = ( clipQCoef * scale + iAdd ) >> iShift;
1194      piCoef[n] = Clip3(-32768,32767,iCoeffQ);
1195    }
1196  }
1197}
1198
1199Void TComTrQuant::init( UInt uiMaxTrSize,
1200                       Bool bUseRDOQ, 
1201                       Bool bUseRDOQTS,
1202                       Bool bEnc, Bool useTransformSkipFast
1203#if ADAPTIVE_QP_SELECTION
1204                       , Bool bUseAdaptQpSelect
1205#endif
1206                       )
1207{
1208  m_uiMaxTrSize  = uiMaxTrSize;
1209  m_bEnc         = bEnc;
1210  m_useRDOQ     = bUseRDOQ;
1211  m_useRDOQTS     = bUseRDOQTS;
1212#if ADAPTIVE_QP_SELECTION
1213  m_bUseAdaptQpSelect = bUseAdaptQpSelect;
1214#endif
1215  m_useTransformSkipFast = useTransformSkipFast;
1216}
1217
1218Void TComTrQuant::transformNxN( TComDataCU* pcCU, 
1219                               Pel*        pcResidual, 
1220                               UInt        uiStride, 
1221                               TCoeff*     rpcCoeff, 
1222#if ADAPTIVE_QP_SELECTION
1223                               Int*&       rpcArlCoeff, 
1224#endif
1225                               UInt        uiWidth, 
1226                               UInt        uiHeight, 
1227                               UInt&       uiAbsSum, 
1228                               TextType    eTType, 
1229                               UInt        uiAbsPartIdx,
1230                               Bool        useTransformSkip
1231                               )
1232{
1233  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1234  {
1235    uiAbsSum=0;
1236    for (UInt k = 0; k<uiHeight; k++)
1237    {
1238      for (UInt j = 0; j<uiWidth; j++)
1239      {
1240        rpcCoeff[k*uiWidth+j]= pcResidual[k*uiStride+j];
1241        uiAbsSum += abs(pcResidual[k*uiStride+j]);
1242      }
1243    }
1244    return;
1245  }
1246  UInt uiMode;  //luma intra pred
1247  if(eTType == TEXT_LUMA && pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA )
1248  {
1249    uiMode = pcCU->getLumaIntraDir( uiAbsPartIdx );
1250  }
1251  else
1252  {
1253    uiMode = REG_DCT;
1254  }
1255 
1256  uiAbsSum = 0;
1257  assert( (pcCU->getSlice()->getSPS()->getMaxTrSize() >= uiWidth) );
1258  Int bitDepth = eTType == TEXT_LUMA ? g_bitDepthY : g_bitDepthC;
1259  if(useTransformSkip)
1260  {
1261    xTransformSkip(bitDepth, pcResidual, uiStride, m_plTempCoeff, uiWidth, uiHeight );
1262  }
1263  else
1264  {
1265    xT(bitDepth, uiMode, pcResidual, uiStride, m_plTempCoeff, uiWidth, uiHeight );
1266  }
1267  xQuant( pcCU, m_plTempCoeff, rpcCoeff,
1268#if ADAPTIVE_QP_SELECTION
1269       rpcArlCoeff,
1270#endif
1271       uiWidth, uiHeight, uiAbsSum, eTType, uiAbsPartIdx );
1272}
1273
1274Void TComTrQuant::invtransformNxN( Bool transQuantBypass, TextType eText, UInt uiMode,Pel* rpcResidual, UInt uiStride, TCoeff*   pcCoeff, UInt uiWidth, UInt uiHeight,  Int scalingListType, Bool useTransformSkip )
1275{
1276  if(transQuantBypass)
1277  {
1278    for (UInt k = 0; k<uiHeight; k++)
1279    {
1280      for (UInt j = 0; j<uiWidth; j++)
1281      {
1282        rpcResidual[k*uiStride+j] = pcCoeff[k*uiWidth+j];
1283      }
1284    } 
1285    return;
1286  }
1287  Int bitDepth = eText == TEXT_LUMA ? g_bitDepthY : g_bitDepthC;
1288  xDeQuant(bitDepth, pcCoeff, m_plTempCoeff, uiWidth, uiHeight, scalingListType);
1289  if(useTransformSkip == true)
1290  {
1291    xITransformSkip(bitDepth, m_plTempCoeff, rpcResidual, uiStride, uiWidth, uiHeight );
1292  }
1293  else
1294  {
1295    xIT(bitDepth, uiMode, m_plTempCoeff, rpcResidual, uiStride, uiWidth, uiHeight );
1296  }
1297}
1298
1299Void TComTrQuant::invRecurTransformNxN( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eTxt, Pel* rpcResidual, UInt uiAddr, UInt uiStride, UInt uiWidth, UInt uiHeight, UInt uiMaxTrMode, UInt uiTrMode, TCoeff* rpcCoeff )
1300{
1301  if( !pcCU->getCbf(uiAbsPartIdx, eTxt, uiTrMode) )
1302  {
1303    return;
1304  } 
1305  const UInt stopTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
1306 
1307  if( uiTrMode == stopTrMode )
1308  {
1309    UInt uiDepth      = pcCU->getDepth( uiAbsPartIdx ) + uiTrMode;
1310    UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiDepth ] + 2;
1311    if( eTxt != TEXT_LUMA && uiLog2TrSize == 2 )
1312    {
1313      UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
1314      if( ( uiAbsPartIdx % uiQPDiv ) != 0 )
1315      {
1316        return;
1317      }
1318      uiWidth  <<= 1;
1319      uiHeight <<= 1;
1320    }
1321    Pel* pResi = rpcResidual + uiAddr;
1322    Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)eTxt];
1323    assert(scalingListType < 6);
1324    invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), eTxt, REG_DCT, pResi, uiStride, rpcCoeff, uiWidth, uiHeight, scalingListType, pcCU->getTransformSkip(uiAbsPartIdx, eTxt) );
1325  }
1326  else
1327  {
1328    uiTrMode++;
1329    uiWidth  >>= 1;
1330    uiHeight >>= 1;
1331    Int trWidth = uiWidth, trHeight = uiHeight;
1332    UInt uiAddrOffset = trHeight * uiStride;
1333    UInt uiCoefOffset = trWidth * trHeight;
1334    UInt uiPartOffset = pcCU->getTotalNumPart() >> ( uiTrMode << 1 );
1335    {
1336      invRecurTransformNxN( pcCU, uiAbsPartIdx, eTxt, rpcResidual, uiAddr                         , uiStride, uiWidth, uiHeight, uiMaxTrMode, uiTrMode, rpcCoeff ); rpcCoeff += uiCoefOffset; uiAbsPartIdx += uiPartOffset;
1337      invRecurTransformNxN( pcCU, uiAbsPartIdx, eTxt, rpcResidual, uiAddr + trWidth               , uiStride, uiWidth, uiHeight, uiMaxTrMode, uiTrMode, rpcCoeff ); rpcCoeff += uiCoefOffset; uiAbsPartIdx += uiPartOffset;
1338      invRecurTransformNxN( pcCU, uiAbsPartIdx, eTxt, rpcResidual, uiAddr + uiAddrOffset          , uiStride, uiWidth, uiHeight, uiMaxTrMode, uiTrMode, rpcCoeff ); rpcCoeff += uiCoefOffset; uiAbsPartIdx += uiPartOffset;
1339      invRecurTransformNxN( pcCU, uiAbsPartIdx, eTxt, rpcResidual, uiAddr + uiAddrOffset + trWidth, uiStride, uiWidth, uiHeight, uiMaxTrMode, uiTrMode, rpcCoeff );
1340    }
1341  }
1342}
1343
1344// ------------------------------------------------------------------------------------------------
1345// Logical transform
1346// ------------------------------------------------------------------------------------------------
1347
1348/** Wrapper function between HM interface and core NxN forward transform (2D)
1349 *  \param piBlkResi input data (residual)
1350 *  \param psCoeff output data (transform coefficients)
1351 *  \param uiStride stride of input residual data
1352 *  \param iSize transform size (iSize x iSize)
1353 *  \param uiMode is Intra Prediction mode used in Mode-Dependent DCT/DST only
1354 */
1355Void TComTrQuant::xT(Int bitDepth, UInt uiMode, Pel* piBlkResi, UInt uiStride, Int* psCoeff, Int iWidth, Int iHeight )
1356{
1357#if MATRIX_MULT 
1358  Int iSize = iWidth;
1359  xTr(bitDepth, piBlkResi,psCoeff,uiStride,(UInt)iSize,uiMode);
1360#else
1361  Int j;
1362  Short block[ 32 * 32 ];
1363  Short coeff[ 32 * 32 ];
1364  for (j = 0; j < iHeight; j++)
1365  {   
1366    memcpy( block + j * iWidth, piBlkResi + j * uiStride, iWidth * sizeof( Short ) );
1367  }
1368  xTrMxN(bitDepth, block, coeff, iWidth, iHeight, uiMode );
1369  for ( j = 0; j < iHeight * iWidth; j++ )
1370  {   
1371    psCoeff[ j ] = coeff[ j ];
1372  }
1373#endif 
1374}
1375
1376
1377/** Wrapper function between HM interface and core NxN inverse transform (2D)
1378 *  \param plCoef input data (transform coefficients)
1379 *  \param pResidual output data (residual)
1380 *  \param uiStride stride of input residual data
1381 *  \param iSize transform size (iSize x iSize)
1382 *  \param uiMode is Intra Prediction mode used in Mode-Dependent DCT/DST only
1383 */
1384Void TComTrQuant::xIT(Int bitDepth, UInt uiMode, Int* plCoef, Pel* pResidual, UInt uiStride, Int iWidth, Int iHeight )
1385{
1386#if MATRIX_MULT 
1387  Int iSize = iWidth;
1388  xITr(bitDepth, plCoef,pResidual,uiStride,(UInt)iSize,uiMode);
1389#else
1390  Int j;
1391  {
1392    Short block[ 32 * 32 ];
1393    Short coeff[ 32 * 32 ];
1394    for ( j = 0; j < iHeight * iWidth; j++ )
1395    {   
1396      coeff[j] = (Short)plCoef[j];
1397    }
1398    xITrMxN(bitDepth, coeff, block, iWidth, iHeight, uiMode );
1399    {
1400      for ( j = 0; j < iHeight; j++ )
1401      {   
1402        memcpy( pResidual + j * uiStride, block + j * iWidth, iWidth * sizeof(Short) );
1403      }
1404    }
1405    return ;
1406  }
1407#endif 
1408}
1409 
1410/** Wrapper function between HM interface and core 4x4 transform skipping
1411 *  \param piBlkResi input data (residual)
1412 *  \param psCoeff output data (transform coefficients)
1413 *  \param uiStride stride of input residual data
1414 *  \param iSize transform size (iSize x iSize)
1415 */
1416Void TComTrQuant::xTransformSkip(Int bitDepth, Pel* piBlkResi, UInt uiStride, Int* psCoeff, Int width, Int height )
1417{
1418  assert( width == height );
1419  UInt uiLog2TrSize = g_aucConvertToBit[ width ] + 2;
1420  Int  shift = MAX_TR_DYNAMIC_RANGE - bitDepth - uiLog2TrSize;
1421  UInt transformSkipShift;
1422  Int  j,k;
1423  if(shift >= 0)
1424  {
1425    transformSkipShift = shift;
1426    for (j = 0; j < height; j++)
1427    {   
1428      for(k = 0; k < width; k ++)
1429      {
1430        psCoeff[j*height + k] = piBlkResi[j * uiStride + k] << transformSkipShift;     
1431      }
1432    }
1433  }
1434  else
1435  {
1436    //The case when uiBitDepth > 13
1437    Int offset;
1438    transformSkipShift = -shift;
1439    offset = (1 << (transformSkipShift - 1));
1440    for (j = 0; j < height; j++)
1441    {   
1442      for(k = 0; k < width; k ++)
1443      {
1444        psCoeff[j*height + k] = (piBlkResi[j * uiStride + k] + offset) >> transformSkipShift;     
1445      }
1446    }
1447  }
1448}
1449
1450/** Wrapper function between HM interface and core NxN transform skipping
1451 *  \param plCoef input data (coefficients)
1452 *  \param pResidual output data (residual)
1453 *  \param uiStride stride of input residual data
1454 *  \param iSize transform size (iSize x iSize)
1455 */
1456Void TComTrQuant::xITransformSkip(Int bitDepth, Int* plCoef, Pel* pResidual, UInt uiStride, Int width, Int height )
1457{
1458  assert( width == height );
1459  UInt uiLog2TrSize = g_aucConvertToBit[ width ] + 2;
1460  Int  shift = MAX_TR_DYNAMIC_RANGE - bitDepth - uiLog2TrSize;
1461  UInt transformSkipShift; 
1462  Int  j,k;
1463  if(shift > 0)
1464  {
1465    Int offset;
1466    transformSkipShift = shift;
1467    offset = (1 << (transformSkipShift -1));
1468    for ( j = 0; j < height; j++ )
1469    {   
1470      for(k = 0; k < width; k ++)
1471      {
1472        pResidual[j * uiStride + k] =  (plCoef[j*width+k] + offset) >> transformSkipShift;
1473      } 
1474    }
1475  }
1476  else
1477  {
1478    //The case when uiBitDepth >= 13
1479    transformSkipShift = - shift;
1480    for ( j = 0; j < height; j++ )
1481    {   
1482      for(k = 0; k < width; k ++)
1483      {
1484        pResidual[j * uiStride + k] =  plCoef[j*width+k] << transformSkipShift;
1485      }
1486    }
1487  }
1488}
1489
1490/** RDOQ with CABAC
1491 * \param pcCU pointer to coding unit structure
1492 * \param plSrcCoeff pointer to input buffer
1493 * \param piDstCoeff reference to pointer to output buffer
1494 * \param uiWidth block width
1495 * \param uiHeight block height
1496 * \param uiAbsSum reference to absolute sum of quantized transform coefficient
1497 * \param eTType plane type / luminance or chrominance
1498 * \param uiAbsPartIdx absolute partition index
1499 * \returns Void
1500 * Rate distortion optimized quantization for entropy
1501 * coding engines using probability models like CABAC
1502 */
1503Void TComTrQuant::xRateDistOptQuant                 ( TComDataCU*                     pcCU,
1504                                                      Int*                            plSrcCoeff,
1505                                                      TCoeff*                         piDstCoeff,
1506#if ADAPTIVE_QP_SELECTION
1507                                                      Int*&                           piArlDstCoeff,
1508#endif
1509                                                      UInt                            uiWidth,
1510                                                      UInt                            uiHeight,
1511                                                      UInt&                           uiAbsSum,
1512                                                      TextType                        eTType,
1513                                                      UInt                            uiAbsPartIdx )
1514{
1515  UInt uiLog2TrSize = g_aucConvertToBit[ uiWidth ] + 2;
1516 
1517  UInt uiBitDepth = eTType == TEXT_LUMA ? g_bitDepthY : g_bitDepthC;
1518  Int iTransformShift = MAX_TR_DYNAMIC_RANGE - uiBitDepth - uiLog2TrSize;  // Represents scaling through forward transform
1519  UInt       uiGoRiceParam       = 0;
1520  Double     d64BlockUncodedCost = 0;
1521  const UInt uiLog2BlkSize       = g_aucConvertToBit[ uiWidth ] + 2;
1522  const UInt uiMaxNumCoeff       = uiWidth * uiHeight;
1523  Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)eTType];
1524  assert(scalingListType < 6);
1525 
1526  Int iQBits = QUANT_SHIFT + m_cQP.m_iPer + iTransformShift;                   // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits
1527  Double *pdErrScaleOrg = getErrScaleCoeff(scalingListType,uiLog2TrSize-2,m_cQP.m_iRem);
1528  Int *piQCoefOrg = getQuantCoeff(scalingListType,m_cQP.m_iRem,uiLog2TrSize-2);
1529  Int *piQCoef = piQCoefOrg;
1530  Double *pdErrScale = pdErrScaleOrg;
1531#if ADAPTIVE_QP_SELECTION
1532  Int iQBitsC = iQBits - ARL_C_PRECISION;
1533  Int iAddC =  1 << (iQBitsC-1);
1534#endif
1535  UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
1536 
1537#if ADAPTIVE_QP_SELECTION
1538  memset(piArlDstCoeff, 0, sizeof(Int) *  uiMaxNumCoeff);
1539#endif
1540 
1541  Double pdCostCoeff [ 32 * 32 ];
1542  Double pdCostSig   [ 32 * 32 ];
1543  Double pdCostCoeff0[ 32 * 32 ];
1544  ::memset( pdCostCoeff, 0, sizeof(Double) *  uiMaxNumCoeff );
1545  ::memset( pdCostSig,   0, sizeof(Double) *  uiMaxNumCoeff );
1546  Int rateIncUp   [ 32 * 32 ];
1547  Int rateIncDown [ 32 * 32 ];
1548  Int sigRateDelta[ 32 * 32 ];
1549  Int deltaU      [ 32 * 32 ];
1550  ::memset( rateIncUp,    0, sizeof(Int) *  uiMaxNumCoeff );
1551  ::memset( rateIncDown,  0, sizeof(Int) *  uiMaxNumCoeff );
1552  ::memset( sigRateDelta, 0, sizeof(Int) *  uiMaxNumCoeff );
1553  ::memset( deltaU,       0, sizeof(Int) *  uiMaxNumCoeff );
1554 
1555  const UInt * scanCG;
1556  {
1557    scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlkSize > 3 ? uiLog2BlkSize-2-1 : 0  ];
1558    if( uiLog2BlkSize == 3 )
1559    {
1560      scanCG = g_sigLastScan8x8[ uiScanIdx ];
1561    }
1562    else if( uiLog2BlkSize == 5 )
1563    {
1564      scanCG = g_sigLastScanCG32x32;
1565    }
1566  }
1567  const UInt uiCGSize = (1 << MLS_CG_SIZE);         // 16
1568  Double pdCostCoeffGroupSig[ MLS_GRP_NUM ];
1569  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
1570  UInt uiNumBlkSide = uiWidth / MLS_CG_SIZE;
1571  Int iCGLastScanPos = -1;
1572 
1573  UInt    uiCtxSet            = 0;
1574  Int     c1                  = 1;
1575  Int     c2                  = 0;
1576  Double  d64BaseCost         = 0;
1577  Int     iLastScanPos        = -1;
1578 
1579  UInt    c1Idx     = 0;
1580  UInt    c2Idx     = 0;
1581  Int     baseLevel;
1582 
1583  const UInt *scan = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlkSize - 1 ];
1584 
1585  ::memset( pdCostCoeffGroupSig,   0, sizeof(Double) * MLS_GRP_NUM );
1586  ::memset( uiSigCoeffGroupFlag,   0, sizeof(UInt) * MLS_GRP_NUM );
1587 
1588  UInt uiCGNum = uiWidth * uiHeight >> MLS_CG_SIZE;
1589  Int iScanPos;
1590  coeffGroupRDStats rdStats;     
1591 
1592  for (Int iCGScanPos = uiCGNum-1; iCGScanPos >= 0; iCGScanPos--)
1593  {
1594    UInt uiCGBlkPos = scanCG[ iCGScanPos ];
1595    UInt uiCGPosY   = uiCGBlkPos / uiNumBlkSide;
1596    UInt uiCGPosX   = uiCGBlkPos - (uiCGPosY * uiNumBlkSide);
1597#if MAYBE_BUGFIX
1598    rdStats.init();
1599#else
1600    ::memset( &rdStats, 0, sizeof (coeffGroupRDStats));
1601#endif
1602    const Int patternSigCtx = TComTrQuant::calcPatternSigCtx(uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiWidth, uiHeight);
1603    for (Int iScanPosinCG = uiCGSize-1; iScanPosinCG >= 0; iScanPosinCG--)
1604    {
1605      iScanPos = iCGScanPos*uiCGSize + iScanPosinCG;
1606      //===== quantization =====
1607      UInt    uiBlkPos          = scan[iScanPos];
1608      // set coeff
1609      Int uiQ  = piQCoef[uiBlkPos];
1610      Double dTemp = pdErrScale[uiBlkPos];
1611      Int lLevelDouble          = plSrcCoeff[ uiBlkPos ];
1612      lLevelDouble              = (Int)min<Int64>((Int64)abs((Int)lLevelDouble) * uiQ , MAX_INT - (1 << (iQBits - 1)));
1613#if ADAPTIVE_QP_SELECTION
1614      if( m_bUseAdaptQpSelect )
1615      {
1616        piArlDstCoeff[uiBlkPos]   = (Int)(( lLevelDouble + iAddC) >> iQBitsC );
1617      }
1618#endif
1619      UInt uiMaxAbsLevel        = (lLevelDouble + (1 << (iQBits - 1))) >> iQBits;
1620     
1621      Double dErr               = Double( lLevelDouble );
1622      pdCostCoeff0[ iScanPos ]  = dErr * dErr * dTemp;
1623      d64BlockUncodedCost      += pdCostCoeff0[ iScanPos ];
1624      piDstCoeff[ uiBlkPos ]    = uiMaxAbsLevel;
1625     
1626      if ( uiMaxAbsLevel > 0 && iLastScanPos < 0 )
1627      {
1628        iLastScanPos            = iScanPos;
1629        uiCtxSet                = (iScanPos < SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 2;
1630        iCGLastScanPos          = iCGScanPos;
1631      }
1632     
1633      if ( iLastScanPos >= 0 )
1634      {
1635        //===== coefficient level estimation =====
1636        UInt  uiLevel;
1637        UInt  uiOneCtx         = 4 * uiCtxSet + c1;
1638        UInt  uiAbsCtx         = uiCtxSet + c2;
1639       
1640        if( iScanPos == iLastScanPos )
1641        {
1642          uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ], 
1643                                                lLevelDouble, uiMaxAbsLevel, 0, uiOneCtx, uiAbsCtx, uiGoRiceParam, 
1644                                                c1Idx, c2Idx, iQBits, dTemp, 1 );
1645        }
1646        else
1647        {
1648          UInt   uiPosY        = uiBlkPos >> uiLog2BlkSize;
1649          UInt   uiPosX        = uiBlkPos - ( uiPosY << uiLog2BlkSize );
1650          UShort uiCtxSig      = getSigCtxInc( patternSigCtx, uiScanIdx, uiPosX, uiPosY, uiLog2BlkSize, eTType );
1651          uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
1652                                                lLevelDouble, uiMaxAbsLevel, uiCtxSig, uiOneCtx, uiAbsCtx, uiGoRiceParam, 
1653                                                c1Idx, c2Idx, iQBits, dTemp, 0 );
1654          sigRateDelta[ uiBlkPos ] = m_pcEstBitsSbac->significantBits[ uiCtxSig ][ 1 ] - m_pcEstBitsSbac->significantBits[ uiCtxSig ][ 0 ];
1655        }
1656        deltaU[ uiBlkPos ]        = (lLevelDouble - ((Int)uiLevel << iQBits)) >> (iQBits-8);
1657        if( uiLevel > 0 )
1658        {
1659          Int rateNow = xGetICRate( uiLevel, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx );
1660          rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx ) - rateNow;
1661          rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx ) - rateNow;
1662        }
1663        else // uiLevel == 0
1664        {
1665          rateIncUp   [ uiBlkPos ] = m_pcEstBitsSbac->m_greaterOneBits[ uiOneCtx ][ 0 ];
1666        }
1667        piDstCoeff[ uiBlkPos ] = uiLevel;
1668        d64BaseCost           += pdCostCoeff [ iScanPos ];
1669       
1670       
1671        baseLevel = (c1Idx < C1FLAG_NUMBER) ? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
1672        if( uiLevel >= baseLevel )
1673        {
1674          if(uiLevel  > 3*(1<<uiGoRiceParam))
1675          {
1676            uiGoRiceParam = min<UInt>(uiGoRiceParam+ 1, 4);
1677          }
1678        }
1679        if ( uiLevel >= 1)
1680        {
1681          c1Idx ++;
1682        }
1683       
1684        //===== update bin model =====
1685        if( uiLevel > 1 )
1686        {
1687          c1 = 0; 
1688          c2 += (c2 < 2);
1689          c2Idx ++;
1690        }
1691        else if( (c1 < 3) && (c1 > 0) && uiLevel)
1692        {
1693          c1++;
1694        }
1695       
1696        //===== context set update =====
1697        if( ( iScanPos % SCAN_SET_SIZE == 0 ) && ( iScanPos > 0 ) )
1698        {
1699          c2                = 0;
1700          uiGoRiceParam     = 0;
1701         
1702          c1Idx   = 0;
1703          c2Idx   = 0; 
1704          uiCtxSet          = (iScanPos == SCAN_SET_SIZE || eTType!=TEXT_LUMA) ? 0 : 2;
1705          if( c1 == 0 )
1706          {
1707            uiCtxSet++;
1708          }
1709          c1 = 1;
1710        }
1711      }
1712      else
1713      {
1714        d64BaseCost    += pdCostCoeff0[ iScanPos ];
1715      }
1716      rdStats.d64SigCost += pdCostSig[ iScanPos ];
1717      if (iScanPosinCG == 0 )
1718      {
1719        rdStats.d64SigCost_0 = pdCostSig[ iScanPos ];
1720      }
1721      if (piDstCoeff[ uiBlkPos ] )
1722      {
1723        uiSigCoeffGroupFlag[ uiCGBlkPos ] = 1;
1724        rdStats.d64CodedLevelandDist += pdCostCoeff[ iScanPos ] - pdCostSig[ iScanPos ];
1725        rdStats.d64UncodedDist += pdCostCoeff0[ iScanPos ];
1726        if ( iScanPosinCG != 0 )
1727        {
1728          rdStats.iNNZbeforePos0++;
1729        }
1730      }
1731    } //end for (iScanPosinCG)
1732   
1733    if (iCGLastScanPos >= 0) 
1734    {
1735      if( iCGScanPos )
1736      {
1737        if (uiSigCoeffGroupFlag[ uiCGBlkPos ] == 0)
1738        {
1739          UInt  uiCtxSig = getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiWidth, uiHeight);
1740          d64BaseCost += xGetRateSigCoeffGroup(0, uiCtxSig) - rdStats.d64SigCost;; 
1741          pdCostCoeffGroupSig[ iCGScanPos ] = xGetRateSigCoeffGroup(0, uiCtxSig); 
1742        } 
1743        else
1744        {
1745          if (iCGScanPos < iCGLastScanPos) //skip the last coefficient group, which will be handled together with last position below.
1746          {
1747            if ( rdStats.iNNZbeforePos0 == 0 ) 
1748            {
1749              d64BaseCost -= rdStats.d64SigCost_0;
1750              rdStats.d64SigCost -= rdStats.d64SigCost_0;
1751            }
1752            // rd-cost if SigCoeffGroupFlag = 0, initialization
1753            Double d64CostZeroCG = d64BaseCost;
1754           
1755            // add SigCoeffGroupFlag cost to total cost
1756            UInt  uiCtxSig = getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, uiWidth, uiHeight);
1757            if (iCGScanPos < iCGLastScanPos)
1758            {
1759              d64BaseCost  += xGetRateSigCoeffGroup(1, uiCtxSig); 
1760              d64CostZeroCG += xGetRateSigCoeffGroup(0, uiCtxSig); 
1761              pdCostCoeffGroupSig[ iCGScanPos ] = xGetRateSigCoeffGroup(1, uiCtxSig); 
1762            }
1763           
1764            // try to convert the current coeff group from non-zero to all-zero
1765            d64CostZeroCG += rdStats.d64UncodedDist;  // distortion for resetting non-zero levels to zero levels
1766            d64CostZeroCG -= rdStats.d64CodedLevelandDist;   // distortion and level cost for keeping all non-zero levels
1767            d64CostZeroCG -= rdStats.d64SigCost;     // sig cost for all coeffs, including zero levels and non-zerl levels
1768           
1769            // if we can save cost, change this block to all-zero block
1770            if ( d64CostZeroCG < d64BaseCost )     
1771            {
1772              uiSigCoeffGroupFlag[ uiCGBlkPos ] = 0;
1773              d64BaseCost = d64CostZeroCG;
1774              if (iCGScanPos < iCGLastScanPos)
1775              {
1776                pdCostCoeffGroupSig[ iCGScanPos ] = xGetRateSigCoeffGroup(0, uiCtxSig); 
1777              }
1778              // reset coeffs to 0 in this block               
1779              for (Int iScanPosinCG = uiCGSize-1; iScanPosinCG >= 0; iScanPosinCG--)
1780              {
1781                iScanPos      = iCGScanPos*uiCGSize + iScanPosinCG;
1782                UInt uiBlkPos = scan[ iScanPos ];
1783               
1784                if (piDstCoeff[ uiBlkPos ])
1785                {
1786                  piDstCoeff [ uiBlkPos ] = 0;
1787                  pdCostCoeff[ iScanPos ] = pdCostCoeff0[ iScanPos ];
1788                  pdCostSig  [ iScanPos ] = 0;
1789                }
1790              }
1791            } // end if ( d64CostAllZeros < d64BaseCost )     
1792          }
1793        } // end if if (uiSigCoeffGroupFlag[ uiCGBlkPos ] == 0)
1794      }
1795      else
1796      {
1797        uiSigCoeffGroupFlag[ uiCGBlkPos ] = 1;
1798      }
1799    }
1800  } //end for (iCGScanPos)
1801 
1802  //===== estimate last position =====
1803  if ( iLastScanPos < 0 )
1804  {
1805    return;
1806  }
1807 
1808  Double  d64BestCost         = 0;
1809  Int     ui16CtxCbf          = 0;
1810  Int     iBestLastIdxP1      = 0;
1811  if( !pcCU->isIntra( uiAbsPartIdx ) && eTType == TEXT_LUMA && pcCU->getTransformIdx( uiAbsPartIdx ) == 0 )
1812  {
1813    ui16CtxCbf   = 0;
1814    d64BestCost  = d64BlockUncodedCost + xGetICost( m_pcEstBitsSbac->blockRootCbpBits[ ui16CtxCbf ][ 0 ] );
1815    d64BaseCost += xGetICost( m_pcEstBitsSbac->blockRootCbpBits[ ui16CtxCbf ][ 1 ] );
1816  }
1817  else
1818  {
1819    ui16CtxCbf   = pcCU->getCtxQtCbf( eTType, pcCU->getTransformIdx( uiAbsPartIdx ) );
1820    ui16CtxCbf   = ( eTType ? TEXT_CHROMA : eTType ) * NUM_QT_CBF_CTX + ui16CtxCbf;
1821    d64BestCost  = d64BlockUncodedCost + xGetICost( m_pcEstBitsSbac->blockCbpBits[ ui16CtxCbf ][ 0 ] );
1822    d64BaseCost += xGetICost( m_pcEstBitsSbac->blockCbpBits[ ui16CtxCbf ][ 1 ] );
1823  }
1824 
1825  Bool bFoundLast = false;
1826  for (Int iCGScanPos = iCGLastScanPos; iCGScanPos >= 0; iCGScanPos--)
1827  {
1828    UInt uiCGBlkPos = scanCG[ iCGScanPos ];
1829   
1830    d64BaseCost -= pdCostCoeffGroupSig [ iCGScanPos ]; 
1831    if (uiSigCoeffGroupFlag[ uiCGBlkPos ])
1832    {     
1833      for (Int iScanPosinCG = uiCGSize-1; iScanPosinCG >= 0; iScanPosinCG--)
1834      {
1835        iScanPos = iCGScanPos*uiCGSize + iScanPosinCG;
1836        if (iScanPos > iLastScanPos) continue;
1837        UInt   uiBlkPos     = scan[iScanPos];
1838       
1839        if( piDstCoeff[ uiBlkPos ] )
1840        {
1841          UInt   uiPosY       = uiBlkPos >> uiLog2BlkSize;
1842          UInt   uiPosX       = uiBlkPos - ( uiPosY << uiLog2BlkSize );
1843         
1844          Double d64CostLast= uiScanIdx == SCAN_VER ? xGetRateLast( uiPosY, uiPosX ) : xGetRateLast( uiPosX, uiPosY );
1845          Double totalCost = d64BaseCost + d64CostLast - pdCostSig[ iScanPos ];
1846         
1847          if( totalCost < d64BestCost )
1848          {
1849            iBestLastIdxP1  = iScanPos + 1;
1850            d64BestCost     = totalCost;
1851          }
1852          if( piDstCoeff[ uiBlkPos ] > 1 )
1853          {
1854            bFoundLast = true;
1855            break;
1856          }
1857          d64BaseCost      -= pdCostCoeff[ iScanPos ];
1858          d64BaseCost      += pdCostCoeff0[ iScanPos ];
1859        }
1860        else
1861        {
1862          d64BaseCost      -= pdCostSig[ iScanPos ];
1863        }
1864      } //end for
1865      if (bFoundLast)
1866      {
1867        break;
1868      }
1869    } // end if (uiSigCoeffGroupFlag[ uiCGBlkPos ])
1870  } // end for
1871 
1872  for ( Int scanPos = 0; scanPos < iBestLastIdxP1; scanPos++ )
1873  {
1874    Int blkPos = scan[ scanPos ];
1875    Int level  = piDstCoeff[ blkPos ];
1876    uiAbsSum += level;
1877    piDstCoeff[ blkPos ] = ( plSrcCoeff[ blkPos ] < 0 ) ? -level : level;
1878  }
1879 
1880  //===== clean uncoded coefficients =====
1881  for ( Int scanPos = iBestLastIdxP1; scanPos <= iLastScanPos; scanPos++ )
1882  {
1883    piDstCoeff[ scan[ scanPos ] ] = 0;
1884  }
1885 
1886  if( pcCU->getSlice()->getPPS()->getSignHideFlag() && uiAbsSum>=2)
1887  {
1888    Int64 rdFactor = (Int64) (
1889                     g_invQuantScales[m_cQP.rem()] * g_invQuantScales[m_cQP.rem()] * (1<<(2*m_cQP.m_iPer))
1890                   / m_dLambda / 16 / (1<<DISTORTION_PRECISION_ADJUSTMENT(2*(uiBitDepth-8)))
1891                   + 0.5);
1892    Int lastCG = -1;
1893    Int absSum = 0 ;
1894    Int n ;
1895   
1896    for( Int subSet = (uiWidth*uiHeight-1) >> LOG2_SCAN_SET_SIZE; subSet >= 0; subSet-- )
1897    {
1898      Int  subPos     = subSet << LOG2_SCAN_SET_SIZE;
1899      Int  firstNZPosInCG=SCAN_SET_SIZE , lastNZPosInCG=-1 ;
1900      absSum = 0 ;
1901     
1902      for(n = SCAN_SET_SIZE-1; n >= 0; --n )
1903      {
1904        if( piDstCoeff[ scan[ n + subPos ]] )
1905        {
1906          lastNZPosInCG = n;
1907          break;
1908        }
1909      }
1910     
1911      for(n = 0; n <SCAN_SET_SIZE; n++ )
1912      {
1913        if( piDstCoeff[ scan[ n + subPos ]] )
1914        {
1915          firstNZPosInCG = n;
1916          break;
1917        }
1918      }
1919     
1920      for(n = firstNZPosInCG; n <=lastNZPosInCG; n++ )
1921      {
1922        absSum += piDstCoeff[ scan[ n + subPos ]];
1923      }
1924     
1925      if(lastNZPosInCG>=0 && lastCG==-1)
1926      {
1927        lastCG = 1; 
1928      } 
1929     
1930      if( lastNZPosInCG-firstNZPosInCG>=SBH_THRESHOLD )
1931      {
1932        UInt signbit = (piDstCoeff[scan[subPos+firstNZPosInCG]]>0?0:1);
1933        if( signbit!=(absSum&0x1) )  // hide but need tune
1934        {
1935          // calculate the cost
1936          Int64 minCostInc = MAX_INT64, curCost=MAX_INT64;
1937          Int minPos =-1, finalChange=0, curChange=0;
1938         
1939          for( n = (lastCG==1?lastNZPosInCG:SCAN_SET_SIZE-1) ; n >= 0; --n )
1940          {
1941            UInt uiBlkPos   = scan[ n + subPos ];
1942            if(piDstCoeff[ uiBlkPos ] != 0 )
1943            {
1944              Int64 costUp   = rdFactor * ( - deltaU[uiBlkPos] ) + rateIncUp[uiBlkPos] ;
1945              Int64 costDown = rdFactor * (   deltaU[uiBlkPos] ) + rateIncDown[uiBlkPos] 
1946              -   ( abs(piDstCoeff[uiBlkPos])==1?((1<<15)+sigRateDelta[uiBlkPos]):0 );
1947             
1948              if(lastCG==1 && lastNZPosInCG==n && abs(piDstCoeff[uiBlkPos])==1)
1949              {
1950                costDown -= (4<<15) ;
1951              }
1952             
1953              if(costUp<costDown)
1954              { 
1955                curCost = costUp;
1956                curChange =  1 ;
1957              }
1958              else               
1959              {
1960                curChange = -1 ;
1961                if(n==firstNZPosInCG && abs(piDstCoeff[uiBlkPos])==1)
1962                {
1963                  curCost = MAX_INT64 ;
1964                }
1965                else
1966                {
1967                  curCost = costDown ; 
1968                }
1969              }
1970            }
1971            else
1972            {
1973              curCost = rdFactor * ( - (abs(deltaU[uiBlkPos])) ) + (1<<15) + rateIncUp[uiBlkPos] + sigRateDelta[uiBlkPos] ; 
1974              curChange = 1 ;
1975             
1976              if(n<firstNZPosInCG)
1977              {
1978                UInt thissignbit = (plSrcCoeff[uiBlkPos]>=0?0:1);
1979                if(thissignbit != signbit )
1980                {
1981                  curCost = MAX_INT64;
1982                }
1983              }
1984            }
1985           
1986            if( curCost<minCostInc)
1987            {
1988              minCostInc = curCost ;
1989              finalChange = curChange ;
1990              minPos = uiBlkPos ;
1991            }
1992          }
1993         
1994          if(piDstCoeff[minPos] == 32767 || piDstCoeff[minPos] == -32768)
1995          {
1996            finalChange = -1;
1997          }
1998         
1999          if(plSrcCoeff[minPos]>=0)
2000          {
2001            piDstCoeff[minPos] += finalChange ;
2002          }
2003          else
2004          {
2005            piDstCoeff[minPos] -= finalChange ; 
2006          }         
2007        }
2008      }
2009     
2010      if(lastCG==1)
2011      {
2012        lastCG=0 ; 
2013      }
2014    }
2015  }
2016}
2017
2018/** Pattern decision for context derivation process of significant_coeff_flag
2019 * \param sigCoeffGroupFlag pointer to prior coded significant coeff group
2020 * \param posXCG column of current coefficient group
2021 * \param posYCG row of current coefficient group
2022 * \param width width of the block
2023 * \param height height of the block
2024 * \returns pattern for current coefficient group
2025 */
2026Int  TComTrQuant::calcPatternSigCtx( const UInt* sigCoeffGroupFlag, UInt posXCG, UInt posYCG, Int width, Int height )
2027{
2028  if( width == 4 && height == 4 ) return -1;
2029
2030  UInt sigRight = 0;
2031  UInt sigLower = 0;
2032
2033  width >>= 2;
2034  height >>= 2;
2035  if( posXCG < width - 1 )
2036  {
2037    sigRight = (sigCoeffGroupFlag[ posYCG * width + posXCG + 1 ] != 0);
2038  }
2039  if (posYCG < height - 1 )
2040  {
2041    sigLower = (sigCoeffGroupFlag[ (posYCG  + 1 ) * width + posXCG ] != 0);
2042  }
2043  return sigRight + (sigLower<<1);
2044}
2045
2046/** Context derivation process of coeff_abs_significant_flag
2047 * \param patternSigCtx pattern for current coefficient group
2048 * \param posX column of current scan position
2049 * \param posY row of current scan position
2050 * \param log2BlockSize log2 value of block size (square block)
2051 * \param width width of the block
2052 * \param height height of the block
2053 * \param textureType texture type (TEXT_LUMA...)
2054 * \returns ctxInc for current scan position
2055 */
2056Int TComTrQuant::getSigCtxInc    (
2057                                   Int                             patternSigCtx,
2058                                   UInt                            scanIdx,
2059                                   Int                             posX,
2060                                   Int                             posY,
2061                                   Int                             log2BlockSize,
2062                                   TextType                        textureType
2063                                  )
2064{
2065  const Int ctxIndMap[16] =
2066  {
2067    0, 1, 4, 5,
2068    2, 3, 4, 5,
2069    6, 6, 8, 8,
2070    7, 7, 8, 8
2071  };
2072
2073  if( posX + posY == 0 )
2074  {
2075    return 0;
2076  }
2077
2078  if ( log2BlockSize == 2 )
2079  {
2080    return ctxIndMap[ 4 * posY + posX ];
2081  }
2082
2083  Int offset = log2BlockSize == 3 ? (scanIdx==SCAN_DIAG ? 9 : 15) : (textureType == TEXT_LUMA ? 21 : 12);
2084
2085  Int posXinSubset = posX-((posX>>2)<<2);
2086  Int posYinSubset = posY-((posY>>2)<<2);
2087  Int cnt = 0;
2088  if(patternSigCtx==0)
2089  {
2090    cnt = posXinSubset+posYinSubset<=2 ? (posXinSubset+posYinSubset==0 ? 2 : 1) : 0;
2091  }
2092  else if(patternSigCtx==1)
2093  {
2094    cnt = posYinSubset<=1 ? (posYinSubset==0 ? 2 : 1) : 0;
2095  }
2096  else if(patternSigCtx==2)
2097  {
2098    cnt = posXinSubset<=1 ? (posXinSubset==0 ? 2 : 1) : 0;
2099  }
2100  else
2101  {
2102    cnt = 2;
2103  }
2104
2105  return (( textureType == TEXT_LUMA && ((posX>>2) + (posY>>2)) > 0 ) ? 3 : 0) + offset + cnt;
2106}
2107
2108/** Get the best level in RD sense
2109 * \param rd64CodedCost reference to coded cost
2110 * \param rd64CodedCost0 reference to cost when coefficient is 0
2111 * \param rd64CodedCostSig reference to cost of significant coefficient
2112 * \param lLevelDouble reference to unscaled quantized level
2113 * \param uiMaxAbsLevel scaled quantized level
2114 * \param ui16CtxNumSig current ctxInc for coeff_abs_significant_flag
2115 * \param ui16CtxNumOne current ctxInc for coeff_abs_level_greater1 (1st bin of coeff_abs_level_minus1 in AVC)
2116 * \param ui16CtxNumAbs current ctxInc for coeff_abs_level_greater2 (remaining bins of coeff_abs_level_minus1 in AVC)
2117 * \param ui16AbsGoRice current Rice parameter for coeff_abs_level_minus3
2118 * \param iQBits quantization step size
2119 * \param dTemp correction factor
2120 * \param bLast indicates if the coefficient is the last significant
2121 * \returns best quantized transform level for given scan position
2122 * This method calculates the best quantized transform level for a given scan position.
2123 */
2124__inline UInt TComTrQuant::xGetCodedLevel ( Double&                         rd64CodedCost,
2125                                            Double&                         rd64CodedCost0,
2126                                            Double&                         rd64CodedCostSig,
2127                                            Int                             lLevelDouble,
2128                                            UInt                            uiMaxAbsLevel,
2129                                            UShort                          ui16CtxNumSig,
2130                                            UShort                          ui16CtxNumOne,
2131                                            UShort                          ui16CtxNumAbs,
2132                                            UShort                          ui16AbsGoRice,
2133                                            UInt                            c1Idx,
2134                                            UInt                            c2Idx,
2135                                            Int                             iQBits,
2136                                            Double                          dTemp,
2137                                            Bool                            bLast        ) const
2138{
2139  Double dCurrCostSig   = 0; 
2140  UInt   uiBestAbsLevel = 0;
2141 
2142  if( !bLast && uiMaxAbsLevel < 3 )
2143  {
2144    rd64CodedCostSig    = xGetRateSigCoef( 0, ui16CtxNumSig ); 
2145    rd64CodedCost       = rd64CodedCost0 + rd64CodedCostSig;
2146    if( uiMaxAbsLevel == 0 )
2147    {
2148      return uiBestAbsLevel;
2149    }
2150  }
2151  else
2152  {
2153    rd64CodedCost       = MAX_DOUBLE;
2154  }
2155
2156  if( !bLast )
2157  {
2158    dCurrCostSig        = xGetRateSigCoef( 1, ui16CtxNumSig );
2159  }
2160
2161  UInt uiMinAbsLevel    = ( uiMaxAbsLevel > 1 ? uiMaxAbsLevel - 1 : 1 );
2162  for( Int uiAbsLevel  = uiMaxAbsLevel; uiAbsLevel >= uiMinAbsLevel ; uiAbsLevel-- )
2163  {
2164    Double dErr         = Double( lLevelDouble  - ( uiAbsLevel << iQBits ) );
2165    Double dCurrCost    = dErr * dErr * dTemp + xGetICRateCost( uiAbsLevel, ui16CtxNumOne, ui16CtxNumAbs, ui16AbsGoRice, c1Idx, c2Idx );
2166    dCurrCost          += dCurrCostSig;
2167
2168    if( dCurrCost < rd64CodedCost )
2169    {
2170      uiBestAbsLevel    = uiAbsLevel;
2171      rd64CodedCost     = dCurrCost;
2172      rd64CodedCostSig  = dCurrCostSig;
2173    }
2174  }
2175
2176  return uiBestAbsLevel;
2177}
2178
2179/** Calculates the cost for specific absolute transform level
2180 * \param uiAbsLevel scaled quantized level
2181 * \param ui16CtxNumOne current ctxInc for coeff_abs_level_greater1 (1st bin of coeff_abs_level_minus1 in AVC)
2182 * \param ui16CtxNumAbs current ctxInc for coeff_abs_level_greater2 (remaining bins of coeff_abs_level_minus1 in AVC)
2183 * \param ui16AbsGoRice Rice parameter for coeff_abs_level_minus3
2184 * \returns cost of given absolute transform level
2185 */
2186__inline Double TComTrQuant::xGetICRateCost  ( UInt                            uiAbsLevel,
2187                                               UShort                          ui16CtxNumOne,
2188                                               UShort                          ui16CtxNumAbs,
2189                                               UShort                          ui16AbsGoRice
2190                                            ,  UInt                            c1Idx,
2191                                               UInt                            c2Idx
2192                                               ) const
2193{
2194  Double iRate = xGetIEPRate();
2195  UInt baseLevel  =  (c1Idx < C1FLAG_NUMBER)? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
2196
2197  if ( uiAbsLevel >= baseLevel )
2198  {   
2199    UInt symbol     = uiAbsLevel - baseLevel;
2200    UInt length;
2201    if (symbol < (COEF_REMAIN_BIN_REDUCTION << ui16AbsGoRice))
2202    {
2203      length = symbol>>ui16AbsGoRice;
2204      iRate += (length+1+ui16AbsGoRice)<< 15;
2205    }
2206    else
2207    {
2208      length = ui16AbsGoRice;
2209      symbol  = symbol - ( COEF_REMAIN_BIN_REDUCTION << ui16AbsGoRice);
2210      while (symbol >= (1<<length))
2211      {
2212        symbol -=  (1<<(length++));   
2213      }
2214      iRate += (COEF_REMAIN_BIN_REDUCTION+length+1-ui16AbsGoRice+length)<< 15;
2215    }
2216    if (c1Idx < C1FLAG_NUMBER)
2217    {
2218      iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
2219
2220      if (c2Idx < C2FLAG_NUMBER)
2221      {
2222        iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 1 ];
2223      }
2224    }
2225  }
2226  else
2227  if( uiAbsLevel == 1 )
2228  {
2229    iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 0 ];
2230  }
2231  else if( uiAbsLevel == 2 )
2232  {
2233    iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
2234    iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 0 ];
2235  }
2236  else
2237  {
2238    assert (0);
2239  }
2240  return xGetICost( iRate );
2241}
2242
2243__inline Int TComTrQuant::xGetICRate  ( UInt                            uiAbsLevel,
2244                                       UShort                          ui16CtxNumOne,
2245                                       UShort                          ui16CtxNumAbs,
2246                                       UShort                          ui16AbsGoRice
2247                                     , UInt                            c1Idx,
2248                                       UInt                            c2Idx
2249                                       ) const
2250{
2251  Int iRate = 0;
2252  UInt baseLevel  =  (c1Idx < C1FLAG_NUMBER)? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
2253
2254  if ( uiAbsLevel >= baseLevel )
2255  {
2256    UInt uiSymbol     = uiAbsLevel - baseLevel;
2257    UInt uiMaxVlc     = g_auiGoRiceRange[ ui16AbsGoRice ];
2258    Bool bExpGolomb   = ( uiSymbol > uiMaxVlc );
2259
2260    if( bExpGolomb )
2261    {
2262      uiAbsLevel  = uiSymbol - uiMaxVlc;
2263      Int iEGS    = 1;  for( UInt uiMax = 2; uiAbsLevel >= uiMax; uiMax <<= 1, iEGS += 2 );
2264      iRate      += iEGS << 15;
2265      uiSymbol    = min<UInt>( uiSymbol, ( uiMaxVlc + 1 ) );
2266    }
2267
2268    UShort ui16PrefLen = UShort( uiSymbol >> ui16AbsGoRice ) + 1;
2269    UShort ui16NumBins = min<UInt>( ui16PrefLen, g_auiGoRicePrefixLen[ ui16AbsGoRice ] ) + ui16AbsGoRice;
2270
2271    iRate += ui16NumBins << 15;
2272
2273    if (c1Idx < C1FLAG_NUMBER)
2274    {
2275      iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
2276
2277      if (c2Idx < C2FLAG_NUMBER)
2278      {
2279        iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 1 ];
2280      }
2281    }
2282  }
2283  else
2284  if( uiAbsLevel == 0 )
2285  {
2286    return 0;
2287  }
2288  else if( uiAbsLevel == 1 )
2289  {
2290    iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 0 ];
2291  }
2292  else if( uiAbsLevel == 2 )
2293  {
2294    iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
2295    iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 0 ];
2296  }
2297  else
2298  {
2299    assert(0);
2300  }
2301  return iRate;
2302}
2303
2304__inline Double TComTrQuant::xGetRateSigCoeffGroup  ( UShort                    uiSignificanceCoeffGroup,
2305                                                UShort                          ui16CtxNumSig ) const
2306{
2307  return xGetICost( m_pcEstBitsSbac->significantCoeffGroupBits[ ui16CtxNumSig ][ uiSignificanceCoeffGroup ] );
2308}
2309
2310/** Calculates the cost of signaling the last significant coefficient in the block
2311 * \param uiPosX X coordinate of the last significant coefficient
2312 * \param uiPosY Y coordinate of the last significant coefficient
2313 * \returns cost of last significant coefficient
2314 */
2315/*
2316 * \param uiWidth width of the transform unit (TU)
2317*/
2318__inline Double TComTrQuant::xGetRateLast   ( const UInt                      uiPosX,
2319                                              const UInt                      uiPosY ) const
2320{
2321  UInt uiCtxX   = g_uiGroupIdx[uiPosX];
2322  UInt uiCtxY   = g_uiGroupIdx[uiPosY];
2323  Double uiCost = m_pcEstBitsSbac->lastXBits[ uiCtxX ] + m_pcEstBitsSbac->lastYBits[ uiCtxY ];
2324  if( uiCtxX > 3 )
2325  {
2326    uiCost += xGetIEPRate() * ((uiCtxX-2)>>1);
2327  }
2328  if( uiCtxY > 3 )
2329  {
2330    uiCost += xGetIEPRate() * ((uiCtxY-2)>>1);
2331  }
2332  return xGetICost( uiCost );
2333}
2334
2335 /** Calculates the cost for specific absolute transform level
2336 * \param uiAbsLevel scaled quantized level
2337 * \param ui16CtxNumOne current ctxInc for coeff_abs_level_greater1 (1st bin of coeff_abs_level_minus1 in AVC)
2338 * \param ui16CtxNumAbs current ctxInc for coeff_abs_level_greater2 (remaining bins of coeff_abs_level_minus1 in AVC)
2339 * \param ui16CtxBase current global offset for coeff_abs_level_greater1 and coeff_abs_level_greater2
2340 * \returns cost of given absolute transform level
2341 */
2342__inline Double TComTrQuant::xGetRateSigCoef  ( UShort                          uiSignificance,
2343                                                UShort                          ui16CtxNumSig ) const
2344{
2345  return xGetICost( m_pcEstBitsSbac->significantBits[ ui16CtxNumSig ][ uiSignificance ] );
2346}
2347
2348/** Get the cost for a specific rate
2349 * \param dRate rate of a bit
2350 * \returns cost at the specific rate
2351 */
2352__inline Double TComTrQuant::xGetICost        ( Double                          dRate         ) const
2353{
2354  return m_dLambda * dRate;
2355}
2356
2357/** Get the cost of an equal probable bit
2358 * \returns cost of equal probable bit
2359 */
2360__inline Double TComTrQuant::xGetIEPRate      (                                               ) const
2361{
2362  return 32768;
2363}
2364
2365/** Context derivation process of coeff_abs_significant_flag
2366 * \param uiSigCoeffGroupFlag significance map of L1
2367 * \param uiBlkX column of current scan position
2368 * \param uiBlkY row of current scan position
2369 * \param uiLog2BlkSize log2 value of block size
2370 * \returns ctxInc for current scan position
2371 */
2372UInt TComTrQuant::getSigCoeffGroupCtxInc  ( const UInt*               uiSigCoeffGroupFlag,
2373                                           const UInt                      uiCGPosX,
2374                                           const UInt                      uiCGPosY,
2375                                           Int width, Int height)
2376{
2377  UInt uiRight = 0;
2378  UInt uiLower = 0;
2379
2380  width >>= 2;
2381  height >>= 2;
2382  if( uiCGPosX < width - 1 )
2383  {
2384    uiRight = (uiSigCoeffGroupFlag[ uiCGPosY * width + uiCGPosX + 1 ] != 0);
2385  }
2386  if (uiCGPosY < height - 1 )
2387  {
2388    uiLower = (uiSigCoeffGroupFlag[ (uiCGPosY  + 1 ) * width + uiCGPosX ] != 0);
2389  }
2390  return (uiRight || uiLower);
2391
2392}
2393/** set quantized matrix coefficient for encode
2394 * \param scalingList quantaized matrix address
2395 */
2396Void TComTrQuant::setScalingList(TComScalingList *scalingList)
2397{
2398  UInt size,list;
2399  UInt qp;
2400
2401  for(size=0;size<SCALING_LIST_SIZE_NUM;size++)
2402  {
2403    for(list = 0; list < g_scalingListNum[size]; list++)
2404    {
2405      for(qp=0;qp<SCALING_LIST_REM_NUM;qp++)
2406      {
2407        xSetScalingListEnc(scalingList,list,size,qp);
2408        xSetScalingListDec(scalingList,list,size,qp);
2409        setErrScaleCoeff(list,size,qp);
2410      }
2411    }
2412  }
2413}
2414/** set quantized matrix coefficient for decode
2415 * \param scalingList quantaized matrix address
2416 */
2417Void TComTrQuant::setScalingListDec(TComScalingList *scalingList)
2418{
2419  UInt size,list;
2420  UInt qp;
2421
2422  for(size=0;size<SCALING_LIST_SIZE_NUM;size++)
2423  {
2424    for(list = 0; list < g_scalingListNum[size]; list++)
2425    {
2426      for(qp=0;qp<SCALING_LIST_REM_NUM;qp++)
2427      {
2428        xSetScalingListDec(scalingList,list,size,qp);
2429      }
2430    }
2431  }
2432}
2433/** set error scale coefficients
2434 * \param list List ID
2435 * \param uiSize Size
2436 * \param uiQP Quantization parameter
2437 */
2438Void TComTrQuant::setErrScaleCoeff(UInt list,UInt size, UInt qp)
2439{
2440
2441  UInt uiLog2TrSize = g_aucConvertToBit[ g_scalingListSizeX[size] ] + 2;
2442  Int bitDepth = (size < SCALING_LIST_32x32 && list != 0 && list != 3) ? g_bitDepthC : g_bitDepthY;
2443  Int iTransformShift = MAX_TR_DYNAMIC_RANGE - bitDepth - uiLog2TrSize;  // Represents scaling through forward transform
2444
2445  UInt i,uiMaxNumCoeff = g_scalingListSize[size];
2446  Int *piQuantcoeff;
2447  Double *pdErrScale;
2448  piQuantcoeff   = getQuantCoeff(list, qp,size);
2449  pdErrScale     = getErrScaleCoeff(list, size, qp);
2450
2451  Double dErrScale = (Double)(1<<SCALE_BITS);                              // Compensate for scaling of bitcount in Lagrange cost function
2452  dErrScale = dErrScale*pow(2.0,-2.0*iTransformShift);                     // Compensate for scaling through forward transform
2453  for(i=0;i<uiMaxNumCoeff;i++)
2454  {
2455    pdErrScale[i] = dErrScale / piQuantcoeff[i] / piQuantcoeff[i] / (1<<DISTORTION_PRECISION_ADJUSTMENT(2*(bitDepth-8)));
2456  }
2457}
2458
2459/** set quantized matrix coefficient for encode
2460 * \param scalingList quantaized matrix address
2461 * \param listId List index
2462 * \param sizeId size index
2463 * \param uiQP Quantization parameter
2464 */
2465Void TComTrQuant::xSetScalingListEnc(TComScalingList *scalingList, UInt listId, UInt sizeId, UInt qp)
2466{
2467  UInt width = g_scalingListSizeX[sizeId];
2468  UInt height = g_scalingListSizeX[sizeId];
2469  UInt ratio = g_scalingListSizeX[sizeId]/min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]);
2470  Int *quantcoeff;
2471  Int *coeff = scalingList->getScalingListAddress(sizeId,listId);
2472  quantcoeff   = getQuantCoeff(listId, qp, sizeId);
2473
2474  processScalingListEnc(coeff,quantcoeff,g_quantScales[qp]<<4,height,width,ratio,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),scalingList->getScalingListDC(sizeId,listId));
2475}
2476/** set quantized matrix coefficient for decode
2477 * \param scalingList quantaized matrix address
2478 * \param list List index
2479 * \param size size index
2480 * \param uiQP Quantization parameter
2481 */
2482Void TComTrQuant::xSetScalingListDec(TComScalingList *scalingList, UInt listId, UInt sizeId, UInt qp)
2483{
2484  UInt width = g_scalingListSizeX[sizeId];
2485  UInt height = g_scalingListSizeX[sizeId];
2486  UInt ratio = g_scalingListSizeX[sizeId]/min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]);
2487  Int *dequantcoeff;
2488  Int *coeff = scalingList->getScalingListAddress(sizeId,listId);
2489
2490  dequantcoeff = getDequantCoeff(listId, qp, sizeId);
2491  processScalingListDec(coeff,dequantcoeff,g_invQuantScales[qp],height,width,ratio,min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]),scalingList->getScalingListDC(sizeId,listId));
2492}
2493
2494/** set flat matrix value to quantized coefficient
2495 */
2496#if IL_SL_SIGNALLING_N0371
2497Void TComTrQuant::setFlatScalingList( UInt m_layerId )
2498#else
2499Void TComTrQuant::setFlatScalingList()
2500#endif
2501{
2502  UInt size,list;
2503  UInt qp;
2504
2505  for(size=0;size<SCALING_LIST_SIZE_NUM;size++)
2506  {
2507    for(list = 0; list <  g_scalingListNum[size]; list++)
2508    {
2509#if IL_SL_SIGNALLING_N0371
2510      ref_scalingListDC[m_layerId][size][list] = SCALING_LIST_DC;
2511      for(UInt i=0; i<MAX_MATRIX_COEF_NUM; i++)
2512      {
2513        ref_scalingListCoef[m_layerId][size][list][i] = SCALING_LIST_DC;
2514      }
2515#endif
2516
2517      for(qp=0;qp<SCALING_LIST_REM_NUM;qp++)
2518      {
2519        xsetFlatScalingList(list,size,qp);
2520        setErrScaleCoeff(list,size,qp);
2521      }
2522    }
2523  }
2524}
2525
2526/** set flat matrix value to quantized coefficient
2527 * \param list List ID
2528 * \param uiQP Quantization parameter
2529 * \param uiSize Size
2530 */
2531Void TComTrQuant::xsetFlatScalingList(UInt list, UInt size, UInt qp)
2532{
2533  UInt i,num = g_scalingListSize[size];
2534  Int *quantcoeff;
2535  Int *dequantcoeff;
2536  Int quantScales = g_quantScales[qp];
2537  Int invQuantScales = g_invQuantScales[qp]<<4;
2538
2539  quantcoeff   = getQuantCoeff(list, qp, size);
2540  dequantcoeff = getDequantCoeff(list, qp, size);
2541
2542  for(i=0;i<num;i++)
2543  { 
2544    *quantcoeff++ = quantScales;
2545    *dequantcoeff++ = invQuantScales;
2546  }
2547}
2548
2549/** set quantized matrix coefficient for encode
2550 * \param coeff quantaized matrix address
2551 * \param quantcoeff quantaized matrix address
2552 * \param quantScales Q(QP%6)
2553 * \param height height
2554 * \param width width
2555 * \param ratio ratio for upscale
2556 * \param sizuNum matrix size
2557 * \param dc dc parameter
2558 */
2559Void TComTrQuant::processScalingListEnc( Int *coeff, Int *quantcoeff, Int quantScales, UInt height, UInt width, UInt ratio, Int sizuNum, UInt dc)
2560{
2561  Int nsqth = (height < width) ? 4: 1; //height ratio for NSQT
2562  Int nsqtw = (width < height) ? 4: 1; //width ratio for NSQT
2563  for(UInt j=0;j<height;j++)
2564  {
2565    for(UInt i=0;i<width;i++)
2566    {
2567      quantcoeff[j*width + i] = quantScales / coeff[sizuNum * (j * nsqth / ratio) + i * nsqtw /ratio];
2568    }
2569  }
2570  if(ratio > 1)
2571  {
2572    quantcoeff[0] = quantScales / dc;
2573  }
2574}
2575/** set quantized matrix coefficient for decode
2576 * \param coeff quantaized matrix address
2577 * \param dequantcoeff quantaized matrix address
2578 * \param invQuantScales IQ(QP%6))
2579 * \param height height
2580 * \param width width
2581 * \param ratio ratio for upscale
2582 * \param sizuNum matrix size
2583 * \param dc dc parameter
2584 */
2585Void TComTrQuant::processScalingListDec( Int *coeff, Int *dequantcoeff, Int invQuantScales, UInt height, UInt width, UInt ratio, Int sizuNum, UInt dc)
2586{
2587  for(UInt j=0;j<height;j++)
2588  {
2589    for(UInt i=0;i<width;i++)
2590    {
2591      dequantcoeff[j*width + i] = invQuantScales * coeff[sizuNum * (j / ratio) + i / ratio];
2592    }
2593  }
2594  if(ratio > 1)
2595  {
2596    dequantcoeff[0] = invQuantScales * dc;
2597  }
2598}
2599
2600/** initialization process of scaling list array
2601 */
2602Void TComTrQuant::initScalingList()
2603{
2604  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2605  {
2606    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2607    {
2608      for(UInt qp = 0; qp < SCALING_LIST_REM_NUM; qp++)
2609      {
2610        m_quantCoef   [sizeId][listId][qp] = new Int [g_scalingListSize[sizeId]];
2611        m_dequantCoef [sizeId][listId][qp] = new Int [g_scalingListSize[sizeId]];
2612        m_errScale    [sizeId][listId][qp] = new Double [g_scalingListSize[sizeId]];
2613      }
2614    }
2615  }
2616  // alias list [1] as [3].
2617  for(UInt qp = 0; qp < SCALING_LIST_REM_NUM; qp++)
2618  {
2619    m_quantCoef   [SCALING_LIST_32x32][3][qp] = m_quantCoef   [SCALING_LIST_32x32][1][qp];
2620    m_dequantCoef [SCALING_LIST_32x32][3][qp] = m_dequantCoef [SCALING_LIST_32x32][1][qp];
2621    m_errScale    [SCALING_LIST_32x32][3][qp] = m_errScale    [SCALING_LIST_32x32][1][qp];
2622  }
2623}
2624/** destroy quantization matrix array
2625 */
2626Void TComTrQuant::destroyScalingList()
2627{
2628  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2629  {
2630    for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2631    {
2632      for(UInt qp = 0; qp < SCALING_LIST_REM_NUM; qp++)
2633      {
2634        if(m_quantCoef   [sizeId][listId][qp]) delete [] m_quantCoef   [sizeId][listId][qp];
2635        if(m_dequantCoef [sizeId][listId][qp]) delete [] m_dequantCoef [sizeId][listId][qp];
2636        if(m_errScale    [sizeId][listId][qp]) delete [] m_errScale    [sizeId][listId][qp];
2637      }
2638    }
2639  }
2640}
2641
2642//! \}
Note: See TracBrowser for help on using the repository browser.