HEVC Test Model (HM)  HM-16.18
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TComTrQuant.cpp
Go to the documentation of this file.
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-2017, 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 
38 #include <stdlib.h>
39 #include <math.h>
40 #include <limits>
41 #include <memory.h>
42 #include "TComTrQuant.h"
43 #include "TComPic.h"
44 #include "ContextTables.h"
45 #include "TComTU.h"
46 #include "Debug.h"
47 
48 typedef struct
49 {
51  Double d64CodedLevelandDist; // distortion and level cost only
52  Double d64UncodedDist; // all zero coded block distortion
56 
59 
60 // ====================================================================================================================
61 // Constants
62 // ====================================================================================================================
63 
64 #define RDOQ_CHROMA 1
65 
66 
67 // ====================================================================================================================
68 // QpParam constructor
69 // ====================================================================================================================
70 
72  const ChannelType chType,
73  const Int qpBdOffset,
74  const Int chromaQPOffset,
75  const ChromaFormat chFmt )
76 {
77  Int baseQp;
78 
79  if(isLuma(chType))
80  {
81  baseQp = qpy + qpBdOffset;
82  }
83  else
84  {
85  baseQp = Clip3( -qpBdOffset, (chromaQPMappingTableSize - 1), qpy + chromaQPOffset );
86 
87  if(baseQp < 0)
88  {
89  baseQp = baseQp + qpBdOffset;
90  }
91  else
92  {
93  baseQp = getScaledChromaQP(baseQp, chFmt) + qpBdOffset;
94  }
95  }
96 
97  Qp =baseQp;
98  per=baseQp/6;
99  rem=baseQp%6;
100 }
101 
102 QpParam::QpParam(const TComDataCU &cu, const ComponentID compID)
103 {
104  Int chromaQpOffset = 0;
105 
106  if (isChroma(compID))
107  {
108  chromaQpOffset += cu.getSlice()->getPPS()->getQpOffset(compID);
109  chromaQpOffset += cu.getSlice()->getSliceChromaQpDelta(compID);
110 
111  chromaQpOffset += cu.getSlice()->getPPS()->getPpsRangeExtension().getChromaQpOffsetListEntry(cu.getChromaQpAdj(0)).u.offset[Int(compID)-1];
112  }
113 
114  *this = QpParam(cu.getQP( 0 ),
115  toChannelType(compID),
116  cu.getSlice()->getSPS()->getQpBDOffset(toChannelType(compID)),
117  chromaQpOffset,
118  cu.getPic()->getChromaFormat());
119 }
120 
121 
122 // ====================================================================================================================
123 // TComTrQuant class member functions
124 // ====================================================================================================================
125 
127 {
128  // allocate temporary buffers
130 
131  // allocate bit estimation class (for RDOQ)
133  initScalingList();
134 }
135 
137 {
138  // delete temporary buffers
139  if ( m_plTempCoeff )
140  {
141  delete [] m_plTempCoeff;
143  }
144 
145  // delete bit estimation class
146  if ( m_pcEstBitsSbac )
147  {
148  delete m_pcEstBitsSbac;
149  }
151 }
152 
153 #if ADAPTIVE_QP_SELECTION
155 {
156  // NOTE: does this work with negative QPs or when some blocks are transquant-bypass enabled?
157 
158  Int qpBase = pcSlice->getSliceQpBase();
159  Int sliceQpused = pcSlice->getSliceQp();
160  Int sliceQpnext;
161  Double alpha = qpBase < 17 ? 0.5 : 1;
162 
163  Int cnt=0;
164  for(Int u=1; u<=LEVEL_RANGE; u++)
165  {
166  cnt += m_sliceNsamples[u] ;
167  }
168 
169  if( !m_useRDOQ )
170  {
171  sliceQpused = qpBase;
172  alpha = 0.5;
173  }
174 
175  if( cnt > 120 )
176  {
177  Double sum = 0;
178  Int k = 0;
179  for(Int u=1; u<LEVEL_RANGE; u++)
180  {
181  sum += u*m_sliceSumC[u];
182  k += u*u*m_sliceNsamples[u];
183  }
184 
185  Int v;
186  Double q[MAX_QP+1] ;
187  for(v=0; v<=MAX_QP; v++)
188  {
189  q[v] = (Double)(g_invQuantScales[v%6] * (1<<(v/6)))/64 ;
190  }
191 
192  Double qnext = sum/k * q[sliceQpused] / (1<<ARL_C_PRECISION);
193 
194  for(v=0; v<MAX_QP; v++)
195  {
196  if(qnext < alpha * q[v] + (1 - alpha) * q[v+1] )
197  {
198  break;
199  }
200  }
201  sliceQpnext = Clip3(sliceQpused - 3, sliceQpused + 3, v);
202  }
203  else
204  {
205  sliceQpnext = sliceQpused;
206  }
207 
208  m_qpDelta[qpBase] = sliceQpnext - qpBase;
209 }
210 
212 {
213  for(Int qp=0; qp<=MAX_QP; qp++)
214  {
215  m_qpDelta[qp] = qp < 17 ? 0 : 1;
216  }
217 }
218 
220 {
221  memset(m_sliceSumC, 0, sizeof(Double)*(LEVEL_RANGE+1));
222  memset(m_sliceNsamples, 0, sizeof(Int)*(LEVEL_RANGE+1));
223 }
224 #endif
225 
226 
227 
228 #if MATRIX_MULT
229 
236 Void xTr(Int bitDepth, Pel *block, TCoeff *coeff, UInt uiStride, UInt uiTrSize, Bool useDST, const Int maxLog2TrDynamicRange)
237 {
238  UInt i,j,k;
239  TCoeff iSum;
241  const TMatrixCoeff *iT;
242  UInt uiLog2TrSize = g_aucConvertToBit[ uiTrSize ] + 2;
243 
244  if (uiTrSize==4)
245  {
246  iT = (useDST ? g_as_DST_MAT_4[TRANSFORM_FORWARD][0] : g_aiT4[TRANSFORM_FORWARD][0]);
247  }
248  else if (uiTrSize==8)
249  {
250  iT = g_aiT8[TRANSFORM_FORWARD][0];
251  }
252  else if (uiTrSize==16)
253  {
254  iT = g_aiT16[TRANSFORM_FORWARD][0];
255  }
256  else if (uiTrSize==32)
257  {
258  iT = g_aiT32[TRANSFORM_FORWARD][0];
259  }
260  else
261  {
262  assert(0);
263  }
264 
265  const Int TRANSFORM_MATRIX_SHIFT = g_transformMatrixShift[TRANSFORM_FORWARD];
266 
267  const Int shift_1st = (uiLog2TrSize + bitDepth + TRANSFORM_MATRIX_SHIFT) - maxLog2TrDynamicRange;
268  const Int shift_2nd = uiLog2TrSize + TRANSFORM_MATRIX_SHIFT;
269  const Int add_1st = (shift_1st>0) ? (1<<(shift_1st-1)) : 0;
270  const Int add_2nd = 1<<(shift_2nd-1);
271 
272  /* Horizontal transform */
273 
274  for (i=0; i<uiTrSize; i++)
275  {
276  for (j=0; j<uiTrSize; j++)
277  {
278  iSum = 0;
279  for (k=0; k<uiTrSize; k++)
280  {
281  iSum += iT[i*uiTrSize+k]*block[j*uiStride+k];
282  }
283  tmp[i*uiTrSize+j] = (iSum + add_1st)>>shift_1st;
284  }
285  }
286 
287  /* Vertical transform */
288  for (i=0; i<uiTrSize; i++)
289  {
290  for (j=0; j<uiTrSize; j++)
291  {
292  iSum = 0;
293  for (k=0; k<uiTrSize; k++)
294  {
295  iSum += iT[i*uiTrSize+k]*tmp[j*uiTrSize+k];
296  }
297  coeff[i*uiTrSize+j] = (iSum + add_2nd)>>shift_2nd;
298  }
299  }
300 }
301 
309 Void xITr(Int bitDepth, TCoeff *coeff, Pel *block, UInt uiStride, UInt uiTrSize, Bool useDST, const Int maxLog2TrDynamicRange)
310 {
311  UInt i,j,k;
312  TCoeff iSum;
314  const TMatrixCoeff *iT;
315 
316  if (uiTrSize==4)
317  {
318  iT = (useDST ? g_as_DST_MAT_4[TRANSFORM_INVERSE][0] : g_aiT4[TRANSFORM_INVERSE][0]);
319  }
320  else if (uiTrSize==8)
321  {
322  iT = g_aiT8[TRANSFORM_INVERSE][0];
323  }
324  else if (uiTrSize==16)
325  {
326  iT = g_aiT16[TRANSFORM_INVERSE][0];
327  }
328  else if (uiTrSize==32)
329  {
330  iT = g_aiT32[TRANSFORM_INVERSE][0];
331  }
332  else
333  {
334  assert(0);
335  }
336 
337  const Int TRANSFORM_MATRIX_SHIFT = g_transformMatrixShift[TRANSFORM_INVERSE];
338 
339  const Int shift_1st = TRANSFORM_MATRIX_SHIFT + 1; //1 has been added to shift_1st at the expense of shift_2nd
340  const Int shift_2nd = (TRANSFORM_MATRIX_SHIFT + maxLog2TrDynamicRange - 1) - bitDepth;
341  const TCoeff clipMinimum = -(1 << maxLog2TrDynamicRange);
342  const TCoeff clipMaximum = (1 << maxLog2TrDynamicRange) - 1;
343  assert(shift_2nd>=0);
344  const Int add_1st = 1<<(shift_1st-1);
345  const Int add_2nd = (shift_2nd>0) ? (1<<(shift_2nd-1)) : 0;
346 
347  /* Horizontal transform */
348  for (i=0; i<uiTrSize; i++)
349  {
350  for (j=0; j<uiTrSize; j++)
351  {
352  iSum = 0;
353  for (k=0; k<uiTrSize; k++)
354  {
355  iSum += iT[k*uiTrSize+i]*coeff[k*uiTrSize+j];
356  }
357 
358  // Clipping here is not in the standard, but is used to protect the "Pel" data type into which the inverse-transformed samples will be copied
359  tmp[i*uiTrSize+j] = Clip3<TCoeff>(clipMinimum, clipMaximum, (iSum + add_1st)>>shift_1st);
360  }
361  }
362 
363  /* Vertical transform */
364  for (i=0; i<uiTrSize; i++)
365  {
366  for (j=0; j<uiTrSize; j++)
367  {
368  iSum = 0;
369  for (k=0; k<uiTrSize; k++)
370  {
371  iSum += iT[k*uiTrSize+j]*tmp[i*uiTrSize+k];
372  }
373 
374  block[i*uiStride+j] = Clip3<TCoeff>(std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max(), (iSum + add_2nd)>>shift_2nd);
375  }
376  }
377 }
378 
379 #endif //MATRIX_MULT
380 
381 
388 Void partialButterfly4(TCoeff *src, TCoeff *dst, Int shift, Int line)
389 {
390  Int j;
391  TCoeff E[2],O[2];
392  TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
393 
394  for (j=0; j<line; j++)
395  {
396  /* E and O */
397  E[0] = src[0] + src[3];
398  O[0] = src[0] - src[3];
399  E[1] = src[1] + src[2];
400  O[1] = src[1] - src[2];
401 
402  dst[0] = (g_aiT4[TRANSFORM_FORWARD][0][0]*E[0] + g_aiT4[TRANSFORM_FORWARD][0][1]*E[1] + add)>>shift;
403  dst[2*line] = (g_aiT4[TRANSFORM_FORWARD][2][0]*E[0] + g_aiT4[TRANSFORM_FORWARD][2][1]*E[1] + add)>>shift;
404  dst[line] = (g_aiT4[TRANSFORM_FORWARD][1][0]*O[0] + g_aiT4[TRANSFORM_FORWARD][1][1]*O[1] + add)>>shift;
405  dst[3*line] = (g_aiT4[TRANSFORM_FORWARD][3][0]*O[0] + g_aiT4[TRANSFORM_FORWARD][3][1]*O[1] + add)>>shift;
406 
407  src += 4;
408  dst ++;
409  }
410 }
411 
412 // Fast DST Algorithm. Full matrix multiplication for DST and Fast DST algorithm
413 // give identical results
414 Void fastForwardDst(TCoeff *block, TCoeff *coeff, Int shift) // input block, output coeff
415 {
416  Int i;
417  TCoeff c[4];
418  TCoeff rnd_factor = (shift > 0) ? (1<<(shift-1)) : 0;
419  for (i=0; i<4; i++)
420  {
421  // Intermediate Variables
422  c[0] = block[4*i+0];
423  c[1] = block[4*i+1];
424  c[2] = block[4*i+2];
425  c[3] = block[4*i+3];
426 
427  for (Int row = 0; row < 4; row++)
428  {
429  TCoeff result = 0;
430  for (Int column = 0; column < 4; column++)
431  {
432  result += c[column] * g_as_DST_MAT_4[TRANSFORM_FORWARD][row][column]; // use the defined matrix, rather than hard-wired numbers
433  }
434 
435  coeff[(row * 4) + i] = rightShift((result + rnd_factor), shift);
436  }
437  }
438 }
439 
440 Void fastInverseDst(TCoeff *tmp, TCoeff *block, Int shift, const TCoeff outputMinimum, const TCoeff outputMaximum) // input tmp, output block
441 {
442  Int i;
443  TCoeff c[4];
444  TCoeff rnd_factor = (shift > 0) ? (1<<(shift-1)) : 0;
445  for (i=0; i<4; i++)
446  {
447  // Intermediate Variables
448  c[0] = tmp[ i];
449  c[1] = tmp[4 +i];
450  c[2] = tmp[8 +i];
451  c[3] = tmp[12+i];
452 
453  for (Int column = 0; column < 4; column++)
454  {
455  TCoeff &result = block[(i * 4) + column];
456 
457  result = 0;
458  for (Int row = 0; row < 4; row++)
459  {
460  result += c[row] * g_as_DST_MAT_4[TRANSFORM_INVERSE][row][column]; // use the defined matrix, rather than hard-wired numbers
461  }
462 
463  result = Clip3( outputMinimum, outputMaximum, rightShift((result + rnd_factor), shift));
464  }
465  }
466 }
467 
476 Void partialButterflyInverse4(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
477 {
478  Int j;
479  TCoeff E[2],O[2];
480  TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
481 
482  for (j=0; j<line; j++)
483  {
484  /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
485  O[0] = g_aiT4[TRANSFORM_INVERSE][1][0]*src[line] + g_aiT4[TRANSFORM_INVERSE][3][0]*src[3*line];
486  O[1] = g_aiT4[TRANSFORM_INVERSE][1][1]*src[line] + g_aiT4[TRANSFORM_INVERSE][3][1]*src[3*line];
487  E[0] = g_aiT4[TRANSFORM_INVERSE][0][0]*src[0] + g_aiT4[TRANSFORM_INVERSE][2][0]*src[2*line];
488  E[1] = g_aiT4[TRANSFORM_INVERSE][0][1]*src[0] + g_aiT4[TRANSFORM_INVERSE][2][1]*src[2*line];
489 
490  /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
491  dst[0] = Clip3( outputMinimum, outputMaximum, (E[0] + O[0] + add)>>shift );
492  dst[1] = Clip3( outputMinimum, outputMaximum, (E[1] + O[1] + add)>>shift );
493  dst[2] = Clip3( outputMinimum, outputMaximum, (E[1] - O[1] + add)>>shift );
494  dst[3] = Clip3( outputMinimum, outputMaximum, (E[0] - O[0] + add)>>shift );
495 
496  src ++;
497  dst += 4;
498  }
499 }
500 
507 Void partialButterfly8(TCoeff *src, TCoeff *dst, Int shift, Int line)
508 {
509  Int j,k;
510  TCoeff E[4],O[4];
511  TCoeff EE[2],EO[2];
512  TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
513 
514  for (j=0; j<line; j++)
515  {
516  /* E and O*/
517  for (k=0;k<4;k++)
518  {
519  E[k] = src[k] + src[7-k];
520  O[k] = src[k] - src[7-k];
521  }
522  /* EE and EO */
523  EE[0] = E[0] + E[3];
524  EO[0] = E[0] - E[3];
525  EE[1] = E[1] + E[2];
526  EO[1] = E[1] - E[2];
527 
528  dst[0] = (g_aiT8[TRANSFORM_FORWARD][0][0]*EE[0] + g_aiT8[TRANSFORM_FORWARD][0][1]*EE[1] + add)>>shift;
529  dst[4*line] = (g_aiT8[TRANSFORM_FORWARD][4][0]*EE[0] + g_aiT8[TRANSFORM_FORWARD][4][1]*EE[1] + add)>>shift;
530  dst[2*line] = (g_aiT8[TRANSFORM_FORWARD][2][0]*EO[0] + g_aiT8[TRANSFORM_FORWARD][2][1]*EO[1] + add)>>shift;
531  dst[6*line] = (g_aiT8[TRANSFORM_FORWARD][6][0]*EO[0] + g_aiT8[TRANSFORM_FORWARD][6][1]*EO[1] + add)>>shift;
532 
533  dst[line] = (g_aiT8[TRANSFORM_FORWARD][1][0]*O[0] + g_aiT8[TRANSFORM_FORWARD][1][1]*O[1] + g_aiT8[TRANSFORM_FORWARD][1][2]*O[2] + g_aiT8[TRANSFORM_FORWARD][1][3]*O[3] + add)>>shift;
534  dst[3*line] = (g_aiT8[TRANSFORM_FORWARD][3][0]*O[0] + g_aiT8[TRANSFORM_FORWARD][3][1]*O[1] + g_aiT8[TRANSFORM_FORWARD][3][2]*O[2] + g_aiT8[TRANSFORM_FORWARD][3][3]*O[3] + add)>>shift;
535  dst[5*line] = (g_aiT8[TRANSFORM_FORWARD][5][0]*O[0] + g_aiT8[TRANSFORM_FORWARD][5][1]*O[1] + g_aiT8[TRANSFORM_FORWARD][5][2]*O[2] + g_aiT8[TRANSFORM_FORWARD][5][3]*O[3] + add)>>shift;
536  dst[7*line] = (g_aiT8[TRANSFORM_FORWARD][7][0]*O[0] + g_aiT8[TRANSFORM_FORWARD][7][1]*O[1] + g_aiT8[TRANSFORM_FORWARD][7][2]*O[2] + g_aiT8[TRANSFORM_FORWARD][7][3]*O[3] + add)>>shift;
537 
538  src += 8;
539  dst ++;
540  }
541 }
542 
551 Void partialButterflyInverse8(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
552 {
553  Int j,k;
554  TCoeff E[4],O[4];
555  TCoeff EE[2],EO[2];
556  TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
557 
558  for (j=0; j<line; j++)
559  {
560  /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
561  for (k=0;k<4;k++)
562  {
563  O[k] = g_aiT8[TRANSFORM_INVERSE][ 1][k]*src[line] + g_aiT8[TRANSFORM_INVERSE][ 3][k]*src[3*line] +
564  g_aiT8[TRANSFORM_INVERSE][ 5][k]*src[5*line] + g_aiT8[TRANSFORM_INVERSE][ 7][k]*src[7*line];
565  }
566 
567  EO[0] = g_aiT8[TRANSFORM_INVERSE][2][0]*src[ 2*line ] + g_aiT8[TRANSFORM_INVERSE][6][0]*src[ 6*line ];
568  EO[1] = g_aiT8[TRANSFORM_INVERSE][2][1]*src[ 2*line ] + g_aiT8[TRANSFORM_INVERSE][6][1]*src[ 6*line ];
569  EE[0] = g_aiT8[TRANSFORM_INVERSE][0][0]*src[ 0 ] + g_aiT8[TRANSFORM_INVERSE][4][0]*src[ 4*line ];
570  EE[1] = g_aiT8[TRANSFORM_INVERSE][0][1]*src[ 0 ] + g_aiT8[TRANSFORM_INVERSE][4][1]*src[ 4*line ];
571 
572  /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
573  E[0] = EE[0] + EO[0];
574  E[3] = EE[0] - EO[0];
575  E[1] = EE[1] + EO[1];
576  E[2] = EE[1] - EO[1];
577  for (k=0;k<4;k++)
578  {
579  dst[ k ] = Clip3( outputMinimum, outputMaximum, (E[k] + O[k] + add)>>shift );
580  dst[ k+4 ] = Clip3( outputMinimum, outputMaximum, (E[3-k] - O[3-k] + add)>>shift );
581  }
582  src ++;
583  dst += 8;
584  }
585 }
586 
593 Void partialButterfly16(TCoeff *src, TCoeff *dst, Int shift, Int line)
594 {
595  Int j,k;
596  TCoeff E[8],O[8];
597  TCoeff EE[4],EO[4];
598  TCoeff EEE[2],EEO[2];
599  TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
600 
601  for (j=0; j<line; j++)
602  {
603  /* E and O*/
604  for (k=0;k<8;k++)
605  {
606  E[k] = src[k] + src[15-k];
607  O[k] = src[k] - src[15-k];
608  }
609  /* EE and EO */
610  for (k=0;k<4;k++)
611  {
612  EE[k] = E[k] + E[7-k];
613  EO[k] = E[k] - E[7-k];
614  }
615  /* EEE and EEO */
616  EEE[0] = EE[0] + EE[3];
617  EEO[0] = EE[0] - EE[3];
618  EEE[1] = EE[1] + EE[2];
619  EEO[1] = EE[1] - EE[2];
620 
621  dst[ 0 ] = (g_aiT16[TRANSFORM_FORWARD][ 0][0]*EEE[0] + g_aiT16[TRANSFORM_FORWARD][ 0][1]*EEE[1] + add)>>shift;
622  dst[ 8*line ] = (g_aiT16[TRANSFORM_FORWARD][ 8][0]*EEE[0] + g_aiT16[TRANSFORM_FORWARD][ 8][1]*EEE[1] + add)>>shift;
623  dst[ 4*line ] = (g_aiT16[TRANSFORM_FORWARD][ 4][0]*EEO[0] + g_aiT16[TRANSFORM_FORWARD][ 4][1]*EEO[1] + add)>>shift;
624  dst[ 12*line] = (g_aiT16[TRANSFORM_FORWARD][12][0]*EEO[0] + g_aiT16[TRANSFORM_FORWARD][12][1]*EEO[1] + add)>>shift;
625 
626  for (k=2;k<16;k+=4)
627  {
628  dst[ k*line ] = (g_aiT16[TRANSFORM_FORWARD][k][0]*EO[0] + g_aiT16[TRANSFORM_FORWARD][k][1]*EO[1] +
629  g_aiT16[TRANSFORM_FORWARD][k][2]*EO[2] + g_aiT16[TRANSFORM_FORWARD][k][3]*EO[3] + add)>>shift;
630  }
631 
632  for (k=1;k<16;k+=2)
633  {
634  dst[ k*line ] = (g_aiT16[TRANSFORM_FORWARD][k][0]*O[0] + g_aiT16[TRANSFORM_FORWARD][k][1]*O[1] +
635  g_aiT16[TRANSFORM_FORWARD][k][2]*O[2] + g_aiT16[TRANSFORM_FORWARD][k][3]*O[3] +
636  g_aiT16[TRANSFORM_FORWARD][k][4]*O[4] + g_aiT16[TRANSFORM_FORWARD][k][5]*O[5] +
637  g_aiT16[TRANSFORM_FORWARD][k][6]*O[6] + g_aiT16[TRANSFORM_FORWARD][k][7]*O[7] + add)>>shift;
638  }
639 
640  src += 16;
641  dst ++;
642 
643  }
644 }
645 
654 Void partialButterflyInverse16(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
655 {
656  Int j,k;
657  TCoeff E[8],O[8];
658  TCoeff EE[4],EO[4];
659  TCoeff EEE[2],EEO[2];
660  TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
661 
662  for (j=0; j<line; j++)
663  {
664  /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
665  for (k=0;k<8;k++)
666  {
667  O[k] = g_aiT16[TRANSFORM_INVERSE][ 1][k]*src[ line] + g_aiT16[TRANSFORM_INVERSE][ 3][k]*src[ 3*line] +
668  g_aiT16[TRANSFORM_INVERSE][ 5][k]*src[ 5*line] + g_aiT16[TRANSFORM_INVERSE][ 7][k]*src[ 7*line] +
669  g_aiT16[TRANSFORM_INVERSE][ 9][k]*src[ 9*line] + g_aiT16[TRANSFORM_INVERSE][11][k]*src[11*line] +
670  g_aiT16[TRANSFORM_INVERSE][13][k]*src[13*line] + g_aiT16[TRANSFORM_INVERSE][15][k]*src[15*line];
671  }
672  for (k=0;k<4;k++)
673  {
674  EO[k] = g_aiT16[TRANSFORM_INVERSE][ 2][k]*src[ 2*line] + g_aiT16[TRANSFORM_INVERSE][ 6][k]*src[ 6*line] +
675  g_aiT16[TRANSFORM_INVERSE][10][k]*src[10*line] + g_aiT16[TRANSFORM_INVERSE][14][k]*src[14*line];
676  }
677  EEO[0] = g_aiT16[TRANSFORM_INVERSE][4][0]*src[ 4*line ] + g_aiT16[TRANSFORM_INVERSE][12][0]*src[ 12*line ];
678  EEE[0] = g_aiT16[TRANSFORM_INVERSE][0][0]*src[ 0 ] + g_aiT16[TRANSFORM_INVERSE][ 8][0]*src[ 8*line ];
679  EEO[1] = g_aiT16[TRANSFORM_INVERSE][4][1]*src[ 4*line ] + g_aiT16[TRANSFORM_INVERSE][12][1]*src[ 12*line ];
680  EEE[1] = g_aiT16[TRANSFORM_INVERSE][0][1]*src[ 0 ] + g_aiT16[TRANSFORM_INVERSE][ 8][1]*src[ 8*line ];
681 
682  /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
683  for (k=0;k<2;k++)
684  {
685  EE[k] = EEE[k] + EEO[k];
686  EE[k+2] = EEE[1-k] - EEO[1-k];
687  }
688  for (k=0;k<4;k++)
689  {
690  E[k] = EE[k] + EO[k];
691  E[k+4] = EE[3-k] - EO[3-k];
692  }
693  for (k=0;k<8;k++)
694  {
695  dst[k] = Clip3( outputMinimum, outputMaximum, (E[k] + O[k] + add)>>shift );
696  dst[k+8] = Clip3( outputMinimum, outputMaximum, (E[7-k] - O[7-k] + add)>>shift );
697  }
698  src ++;
699  dst += 16;
700  }
701 }
702 
709 Void partialButterfly32(TCoeff *src, TCoeff *dst, Int shift, Int line)
710 {
711  Int j,k;
712  TCoeff E[16],O[16];
713  TCoeff EE[8],EO[8];
714  TCoeff EEE[4],EEO[4];
715  TCoeff EEEE[2],EEEO[2];
716  TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
717 
718  for (j=0; j<line; j++)
719  {
720  /* E and O*/
721  for (k=0;k<16;k++)
722  {
723  E[k] = src[k] + src[31-k];
724  O[k] = src[k] - src[31-k];
725  }
726  /* EE and EO */
727  for (k=0;k<8;k++)
728  {
729  EE[k] = E[k] + E[15-k];
730  EO[k] = E[k] - E[15-k];
731  }
732  /* EEE and EEO */
733  for (k=0;k<4;k++)
734  {
735  EEE[k] = EE[k] + EE[7-k];
736  EEO[k] = EE[k] - EE[7-k];
737  }
738  /* EEEE and EEEO */
739  EEEE[0] = EEE[0] + EEE[3];
740  EEEO[0] = EEE[0] - EEE[3];
741  EEEE[1] = EEE[1] + EEE[2];
742  EEEO[1] = EEE[1] - EEE[2];
743 
744  dst[ 0 ] = (g_aiT32[TRANSFORM_FORWARD][ 0][0]*EEEE[0] + g_aiT32[TRANSFORM_FORWARD][ 0][1]*EEEE[1] + add)>>shift;
745  dst[ 16*line ] = (g_aiT32[TRANSFORM_FORWARD][16][0]*EEEE[0] + g_aiT32[TRANSFORM_FORWARD][16][1]*EEEE[1] + add)>>shift;
746  dst[ 8*line ] = (g_aiT32[TRANSFORM_FORWARD][ 8][0]*EEEO[0] + g_aiT32[TRANSFORM_FORWARD][ 8][1]*EEEO[1] + add)>>shift;
747  dst[ 24*line ] = (g_aiT32[TRANSFORM_FORWARD][24][0]*EEEO[0] + g_aiT32[TRANSFORM_FORWARD][24][1]*EEEO[1] + add)>>shift;
748  for (k=4;k<32;k+=8)
749  {
750  dst[ k*line ] = (g_aiT32[TRANSFORM_FORWARD][k][0]*EEO[0] + g_aiT32[TRANSFORM_FORWARD][k][1]*EEO[1] +
751  g_aiT32[TRANSFORM_FORWARD][k][2]*EEO[2] + g_aiT32[TRANSFORM_FORWARD][k][3]*EEO[3] + add)>>shift;
752  }
753  for (k=2;k<32;k+=4)
754  {
755  dst[ k*line ] = (g_aiT32[TRANSFORM_FORWARD][k][0]*EO[0] + g_aiT32[TRANSFORM_FORWARD][k][1]*EO[1] +
756  g_aiT32[TRANSFORM_FORWARD][k][2]*EO[2] + g_aiT32[TRANSFORM_FORWARD][k][3]*EO[3] +
757  g_aiT32[TRANSFORM_FORWARD][k][4]*EO[4] + g_aiT32[TRANSFORM_FORWARD][k][5]*EO[5] +
758  g_aiT32[TRANSFORM_FORWARD][k][6]*EO[6] + g_aiT32[TRANSFORM_FORWARD][k][7]*EO[7] + add)>>shift;
759  }
760  for (k=1;k<32;k+=2)
761  {
762  dst[ k*line ] = (g_aiT32[TRANSFORM_FORWARD][k][ 0]*O[ 0] + g_aiT32[TRANSFORM_FORWARD][k][ 1]*O[ 1] +
763  g_aiT32[TRANSFORM_FORWARD][k][ 2]*O[ 2] + g_aiT32[TRANSFORM_FORWARD][k][ 3]*O[ 3] +
764  g_aiT32[TRANSFORM_FORWARD][k][ 4]*O[ 4] + g_aiT32[TRANSFORM_FORWARD][k][ 5]*O[ 5] +
765  g_aiT32[TRANSFORM_FORWARD][k][ 6]*O[ 6] + g_aiT32[TRANSFORM_FORWARD][k][ 7]*O[ 7] +
766  g_aiT32[TRANSFORM_FORWARD][k][ 8]*O[ 8] + g_aiT32[TRANSFORM_FORWARD][k][ 9]*O[ 9] +
767  g_aiT32[TRANSFORM_FORWARD][k][10]*O[10] + g_aiT32[TRANSFORM_FORWARD][k][11]*O[11] +
768  g_aiT32[TRANSFORM_FORWARD][k][12]*O[12] + g_aiT32[TRANSFORM_FORWARD][k][13]*O[13] +
769  g_aiT32[TRANSFORM_FORWARD][k][14]*O[14] + g_aiT32[TRANSFORM_FORWARD][k][15]*O[15] + add)>>shift;
770  }
771 
772  src += 32;
773  dst ++;
774  }
775 }
776 
785 Void partialButterflyInverse32(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
786 {
787  Int j,k;
788  TCoeff E[16],O[16];
789  TCoeff EE[8],EO[8];
790  TCoeff EEE[4],EEO[4];
791  TCoeff EEEE[2],EEEO[2];
792  TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
793 
794  for (j=0; j<line; j++)
795  {
796  /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
797  for (k=0;k<16;k++)
798  {
799  O[k] = g_aiT32[TRANSFORM_INVERSE][ 1][k]*src[ line ] + g_aiT32[TRANSFORM_INVERSE][ 3][k]*src[ 3*line ] +
800  g_aiT32[TRANSFORM_INVERSE][ 5][k]*src[ 5*line ] + g_aiT32[TRANSFORM_INVERSE][ 7][k]*src[ 7*line ] +
801  g_aiT32[TRANSFORM_INVERSE][ 9][k]*src[ 9*line ] + g_aiT32[TRANSFORM_INVERSE][11][k]*src[ 11*line ] +
802  g_aiT32[TRANSFORM_INVERSE][13][k]*src[ 13*line ] + g_aiT32[TRANSFORM_INVERSE][15][k]*src[ 15*line ] +
803  g_aiT32[TRANSFORM_INVERSE][17][k]*src[ 17*line ] + g_aiT32[TRANSFORM_INVERSE][19][k]*src[ 19*line ] +
804  g_aiT32[TRANSFORM_INVERSE][21][k]*src[ 21*line ] + g_aiT32[TRANSFORM_INVERSE][23][k]*src[ 23*line ] +
805  g_aiT32[TRANSFORM_INVERSE][25][k]*src[ 25*line ] + g_aiT32[TRANSFORM_INVERSE][27][k]*src[ 27*line ] +
806  g_aiT32[TRANSFORM_INVERSE][29][k]*src[ 29*line ] + g_aiT32[TRANSFORM_INVERSE][31][k]*src[ 31*line ];
807  }
808  for (k=0;k<8;k++)
809  {
810  EO[k] = g_aiT32[TRANSFORM_INVERSE][ 2][k]*src[ 2*line ] + g_aiT32[TRANSFORM_INVERSE][ 6][k]*src[ 6*line ] +
811  g_aiT32[TRANSFORM_INVERSE][10][k]*src[ 10*line ] + g_aiT32[TRANSFORM_INVERSE][14][k]*src[ 14*line ] +
812  g_aiT32[TRANSFORM_INVERSE][18][k]*src[ 18*line ] + g_aiT32[TRANSFORM_INVERSE][22][k]*src[ 22*line ] +
813  g_aiT32[TRANSFORM_INVERSE][26][k]*src[ 26*line ] + g_aiT32[TRANSFORM_INVERSE][30][k]*src[ 30*line ];
814  }
815  for (k=0;k<4;k++)
816  {
817  EEO[k] = g_aiT32[TRANSFORM_INVERSE][ 4][k]*src[ 4*line ] + g_aiT32[TRANSFORM_INVERSE][12][k]*src[ 12*line ] +
818  g_aiT32[TRANSFORM_INVERSE][20][k]*src[ 20*line ] + g_aiT32[TRANSFORM_INVERSE][28][k]*src[ 28*line ];
819  }
820  EEEO[0] = g_aiT32[TRANSFORM_INVERSE][8][0]*src[ 8*line ] + g_aiT32[TRANSFORM_INVERSE][24][0]*src[ 24*line ];
821  EEEO[1] = g_aiT32[TRANSFORM_INVERSE][8][1]*src[ 8*line ] + g_aiT32[TRANSFORM_INVERSE][24][1]*src[ 24*line ];
822  EEEE[0] = g_aiT32[TRANSFORM_INVERSE][0][0]*src[ 0 ] + g_aiT32[TRANSFORM_INVERSE][16][0]*src[ 16*line ];
823  EEEE[1] = g_aiT32[TRANSFORM_INVERSE][0][1]*src[ 0 ] + g_aiT32[TRANSFORM_INVERSE][16][1]*src[ 16*line ];
824 
825  /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
826  EEE[0] = EEEE[0] + EEEO[0];
827  EEE[3] = EEEE[0] - EEEO[0];
828  EEE[1] = EEEE[1] + EEEO[1];
829  EEE[2] = EEEE[1] - EEEO[1];
830  for (k=0;k<4;k++)
831  {
832  EE[k] = EEE[k] + EEO[k];
833  EE[k+4] = EEE[3-k] - EEO[3-k];
834  }
835  for (k=0;k<8;k++)
836  {
837  E[k] = EE[k] + EO[k];
838  E[k+8] = EE[7-k] - EO[7-k];
839  }
840  for (k=0;k<16;k++)
841  {
842  dst[k] = Clip3( outputMinimum, outputMaximum, (E[k] + O[k] + add)>>shift );
843  dst[k+16] = Clip3( outputMinimum, outputMaximum, (E[15-k] - O[15-k] + add)>>shift );
844  }
845  src ++;
846  dst += 32;
847  }
848 }
849 
860 Void xTrMxN(Int bitDepth, TCoeff *block, TCoeff *coeff, Int iWidth, Int iHeight, Bool useDST, const Int maxLog2TrDynamicRange)
861 {
862  const Int TRANSFORM_MATRIX_SHIFT = g_transformMatrixShift[TRANSFORM_FORWARD];
863 
864  const Int shift_1st = ((g_aucConvertToBit[iWidth] + 2) + bitDepth + TRANSFORM_MATRIX_SHIFT) - maxLog2TrDynamicRange;
865  const Int shift_2nd = (g_aucConvertToBit[iHeight] + 2) + TRANSFORM_MATRIX_SHIFT;
866 
867  assert(shift_1st >= 0);
868  assert(shift_2nd >= 0);
869 
870  TCoeff tmp[ MAX_TU_SIZE * MAX_TU_SIZE ];
871 
872  switch (iWidth)
873  {
874  case 4:
875  {
876  if ((iHeight == 4) && useDST) // Check for DCT or DST
877  {
878  fastForwardDst( block, tmp, shift_1st );
879  }
880  else
881  {
882  partialButterfly4 ( block, tmp, shift_1st, iHeight );
883  }
884  }
885  break;
886 
887  case 8: partialButterfly8 ( block, tmp, shift_1st, iHeight ); break;
888  case 16: partialButterfly16( block, tmp, shift_1st, iHeight ); break;
889  case 32: partialButterfly32( block, tmp, shift_1st, iHeight ); break;
890  default:
891  assert(0); exit (1); break;
892  }
893 
894  switch (iHeight)
895  {
896  case 4:
897  {
898  if ((iWidth == 4) && useDST) // Check for DCT or DST
899  {
900  fastForwardDst( tmp, coeff, shift_2nd );
901  }
902  else
903  {
904  partialButterfly4 ( tmp, coeff, shift_2nd, iWidth );
905  }
906  }
907  break;
908 
909  case 8: partialButterfly8 ( tmp, coeff, shift_2nd, iWidth ); break;
910  case 16: partialButterfly16( tmp, coeff, shift_2nd, iWidth ); break;
911  case 32: partialButterfly32( tmp, coeff, shift_2nd, iWidth ); break;
912  default:
913  assert(0); exit (1); break;
914  }
915 }
916 
917 
927 Void xITrMxN(Int bitDepth, TCoeff *coeff, TCoeff *block, Int iWidth, Int iHeight, Bool useDST, const Int maxLog2TrDynamicRange)
928 {
929  const Int TRANSFORM_MATRIX_SHIFT = g_transformMatrixShift[TRANSFORM_INVERSE];
930 
931  Int shift_1st = TRANSFORM_MATRIX_SHIFT + 1; //1 has been added to shift_1st at the expense of shift_2nd
932  Int shift_2nd = (TRANSFORM_MATRIX_SHIFT + maxLog2TrDynamicRange - 1) - bitDepth;
933  const TCoeff clipMinimum = -(1 << maxLog2TrDynamicRange);
934  const TCoeff clipMaximum = (1 << maxLog2TrDynamicRange) - 1;
935 
936  assert(shift_1st >= 0);
937  assert(shift_2nd >= 0);
938 
940 
941  switch (iHeight)
942  {
943  case 4:
944  {
945  if ((iWidth == 4) && useDST) // Check for DCT or DST
946  {
947  fastInverseDst( coeff, tmp, shift_1st, clipMinimum, clipMaximum);
948  }
949  else
950  {
951  partialButterflyInverse4 ( coeff, tmp, shift_1st, iWidth, clipMinimum, clipMaximum);
952  }
953  }
954  break;
955 
956  case 8: partialButterflyInverse8 ( coeff, tmp, shift_1st, iWidth, clipMinimum, clipMaximum); break;
957  case 16: partialButterflyInverse16( coeff, tmp, shift_1st, iWidth, clipMinimum, clipMaximum); break;
958  case 32: partialButterflyInverse32( coeff, tmp, shift_1st, iWidth, clipMinimum, clipMaximum); break;
959 
960  default:
961  assert(0); exit (1); break;
962  }
963 
964  switch (iWidth)
965  {
966  // Clipping here is not in the standard, but is used to protect the "Pel" data type into which the inverse-transformed samples will be copied
967  case 4:
968  {
969  if ((iHeight == 4) && useDST) // Check for DCT or DST
970  {
971  fastInverseDst( tmp, block, shift_2nd, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max() );
972  }
973  else
974  {
975  partialButterflyInverse4 ( tmp, block, shift_2nd, iHeight, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max());
976  }
977  }
978  break;
979 
980  case 8: partialButterflyInverse8 ( tmp, block, shift_2nd, iHeight, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
981  case 16: partialButterflyInverse16( tmp, block, shift_2nd, iHeight, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
982  case 32: partialButterflyInverse32( tmp, block, shift_2nd, iHeight, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
983 
984  default:
985  assert(0); exit (1); break;
986  }
987 }
988 
989 
990 // To minimize the distortion only. No rate is considered.
991 Void TComTrQuant::signBitHidingHDQ( TCoeff* pQCoef, TCoeff* pCoef, TCoeff* deltaU, const TUEntropyCodingParameters &codingParameters, const Int maxLog2TrDynamicRange )
992 {
993  const UInt width = codingParameters.widthInGroups << MLS_CG_LOG2_WIDTH;
994  const UInt height = codingParameters.heightInGroups << MLS_CG_LOG2_HEIGHT;
995  const UInt groupSize = 1 << MLS_CG_SIZE;
996 
997  const TCoeff entropyCodingMinimum = -(1 << maxLog2TrDynamicRange);
998  const TCoeff entropyCodingMaximum = (1 << maxLog2TrDynamicRange) - 1;
999 
1000  Int lastCG = -1;
1001  Int absSum = 0 ;
1002  Int n ;
1003 
1004  for( Int subSet = (width*height-1) >> MLS_CG_SIZE; subSet >= 0; subSet-- )
1005  {
1006  Int subPos = subSet << MLS_CG_SIZE;
1007  Int firstNZPosInCG=groupSize , lastNZPosInCG=-1 ;
1008  absSum = 0 ;
1009 
1010  for(n = groupSize-1; n >= 0; --n )
1011  {
1012  if( pQCoef[ codingParameters.scan[ n + subPos ]] )
1013  {
1014  lastNZPosInCG = n;
1015  break;
1016  }
1017  }
1018 
1019  for(n = 0; n <groupSize; n++ )
1020  {
1021  if( pQCoef[ codingParameters.scan[ n + subPos ]] )
1022  {
1023  firstNZPosInCG = n;
1024  break;
1025  }
1026  }
1027 
1028  for(n = firstNZPosInCG; n <=lastNZPosInCG; n++ )
1029  {
1030  absSum += Int(pQCoef[ codingParameters.scan[ n + subPos ]]);
1031  }
1032 
1033  if(lastNZPosInCG>=0 && lastCG==-1)
1034  {
1035  lastCG = 1 ;
1036  }
1037 
1038  if( lastNZPosInCG-firstNZPosInCG>=SBH_THRESHOLD )
1039  {
1040  UInt signbit = (pQCoef[codingParameters.scan[subPos+firstNZPosInCG]]>0?0:1) ;
1041  if( signbit!=(absSum&0x1) ) //compare signbit with sum_parity
1042  {
1043  TCoeff curCost = std::numeric_limits<TCoeff>::max();
1044  TCoeff minCostInc = std::numeric_limits<TCoeff>::max();
1045  Int minPos =-1, finalChange=0, curChange=0;
1046 
1047  for( n = (lastCG==1?lastNZPosInCG:groupSize-1) ; n >= 0; --n )
1048  {
1049  UInt blkPos = codingParameters.scan[ n+subPos ];
1050  if(pQCoef[ blkPos ] != 0 )
1051  {
1052  if(deltaU[blkPos]>0)
1053  {
1054  curCost = - deltaU[blkPos];
1055  curChange=1 ;
1056  }
1057  else
1058  {
1059  //curChange =-1;
1060  if(n==firstNZPosInCG && abs(pQCoef[blkPos])==1)
1061  {
1062  curCost = std::numeric_limits<TCoeff>::max();
1063  }
1064  else
1065  {
1066  curCost = deltaU[blkPos];
1067  curChange =-1;
1068  }
1069  }
1070  }
1071  else
1072  {
1073  if(n<firstNZPosInCG)
1074  {
1075  UInt thisSignBit = (pCoef[blkPos]>=0?0:1);
1076  if(thisSignBit != signbit )
1077  {
1078  curCost = std::numeric_limits<TCoeff>::max();
1079  }
1080  else
1081  {
1082  curCost = - (deltaU[blkPos]) ;
1083  curChange = 1 ;
1084  }
1085  }
1086  else
1087  {
1088  curCost = - (deltaU[blkPos]) ;
1089  curChange = 1 ;
1090  }
1091  }
1092 
1093  if( curCost<minCostInc)
1094  {
1095  minCostInc = curCost ;
1096  finalChange = curChange ;
1097  minPos = blkPos ;
1098  }
1099  } //CG loop
1100 
1101  if(pQCoef[minPos] == entropyCodingMaximum || pQCoef[minPos] == entropyCodingMinimum)
1102  {
1103  finalChange = -1;
1104  }
1105 
1106  if(pCoef[minPos]>=0)
1107  {
1108  pQCoef[minPos] += finalChange ;
1109  }
1110  else
1111  {
1112  pQCoef[minPos] -= finalChange ;
1113  }
1114  } // Hide
1115  }
1116  if(lastCG==1)
1117  {
1118  lastCG=0 ;
1119  }
1120  } // TU loop
1121 
1122  return;
1123 }
1124 
1125 
1127  TCoeff * pSrc,
1128  TCoeff * pDes,
1130  TCoeff *pArlDes,
1131 #endif
1132  TCoeff &uiAbsSum,
1133  const ComponentID compID,
1134  const QpParam &cQP )
1135 {
1136  const TComRectangle &rect = rTu.getRect(compID);
1137  const UInt uiWidth = rect.width;
1138  const UInt uiHeight = rect.height;
1139  TComDataCU* pcCU = rTu.getCU();
1140  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
1141  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));
1142 
1143  TCoeff* piCoef = pSrc;
1144  TCoeff* piQCoef = pDes;
1145 #if ADAPTIVE_QP_SELECTION
1146  TCoeff* piArlCCoef = pArlDes;
1147 #endif
1148 
1149  const Bool useTransformSkip = pcCU->getTransformSkip(uiAbsPartIdx, compID);
1150  const Int maxLog2TrDynamicRange = pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID));
1151 
1152  Bool useRDOQ = useTransformSkip ? m_useRDOQTS : m_useRDOQ;
1153  if ( useRDOQ && (isLuma(compID) || RDOQ_CHROMA) )
1154  {
1155  if ( !m_useSelectiveRDOQ || xNeedRDOQ( rTu, piCoef, compID, cQP ) )
1156  {
1157 #if ADAPTIVE_QP_SELECTION
1158  xRateDistOptQuant( rTu, piCoef, pDes, pArlDes, uiAbsSum, compID, cQP );
1159 #else
1160  xRateDistOptQuant( rTu, piCoef, pDes, uiAbsSum, compID, cQP );
1161 #endif
1162  }
1163  else
1164  {
1165  memset( pDes, 0, sizeof( TCoeff ) * uiWidth *uiHeight );
1166  uiAbsSum = 0;
1167  }
1168  }
1169  else
1170  {
1171  TUEntropyCodingParameters codingParameters;
1172  getTUEntropyCodingParameters(codingParameters, rTu, compID);
1173 
1174  const TCoeff entropyCodingMinimum = -(1 << maxLog2TrDynamicRange);
1175  const TCoeff entropyCodingMaximum = (1 << maxLog2TrDynamicRange) - 1;
1176 
1177  TCoeff deltaU[MAX_TU_SIZE * MAX_TU_SIZE];
1178 
1179  const UInt uiLog2TrSize = rTu.GetEquivalentLog2TrSize(compID);
1180 
1181  Int scalingListType = getScalingListType(pcCU->getPredictionMode(uiAbsPartIdx), compID);
1182  assert(scalingListType < SCALING_LIST_NUM);
1183  Int *piQuantCoeff = getQuantCoeff(scalingListType, cQP.rem, uiLog2TrSize-2);
1184 
1185  const Bool enableScalingLists = getUseScalingList(uiWidth, uiHeight, (pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0));
1186  const Int defaultQuantisationCoefficient = g_quantScales[cQP.rem];
1187 
1188  /* for 422 chroma blocks, the effective scaling applied during transformation is not a power of 2, hence it cannot be
1189  * implemented as a bit-shift (the quantised result will be sqrt(2) * larger than required). Alternatively, adjust the
1190  * uiLog2TrSize applied in iTransformShift, such that the result is 1/sqrt(2) the required result (i.e. smaller)
1191  * Then a QP+3 (sqrt(2)) or QP-3 (1/sqrt(2)) method could be used to get the required result
1192  */
1193 
1194  // Represents scaling through forward transform
1195  Int iTransformShift = getTransformShift(channelBitDepth, uiLog2TrSize, maxLog2TrDynamicRange);
1196  if (useTransformSkip && pcCU->getSlice()->getSPS()->getSpsRangeExtension().getExtendedPrecisionProcessingFlag())
1197  {
1198  iTransformShift = std::max<Int>(0, iTransformShift);
1199  }
1200 
1201  const Int iQBits = QUANT_SHIFT + cQP.per + iTransformShift;
1202  // QBits will be OK for any internal bit depth as the reduction in transform shift is balanced by an increase in Qp_per due to QpBDOffset
1203 
1204 #if ADAPTIVE_QP_SELECTION
1205  Int iQBitsC = MAX_INT;
1206  Int iAddC = MAX_INT;
1207 
1208  if (m_bUseAdaptQpSelect)
1209  {
1210  iQBitsC = iQBits - ARL_C_PRECISION;
1211  iAddC = 1 << (iQBitsC-1);
1212  }
1213 #endif
1214 
1215  const Int iAdd = (pcCU->getSlice()->getSliceType()==I_SLICE ? 171 : 85) << (iQBits-9);
1216  const Int qBits8 = iQBits - 8;
1217 
1218  for( Int uiBlockPos = 0; uiBlockPos < uiWidth*uiHeight; uiBlockPos++ )
1219  {
1220  const TCoeff iLevel = piCoef[uiBlockPos];
1221  const TCoeff iSign = (iLevel < 0 ? -1: 1);
1222 
1223  const Int64 tmpLevel = (Int64)abs(iLevel) * (enableScalingLists ? piQuantCoeff[uiBlockPos] : defaultQuantisationCoefficient);
1224 
1225 #if ADAPTIVE_QP_SELECTION
1226  if( m_bUseAdaptQpSelect )
1227  {
1228  piArlCCoef[uiBlockPos] = (TCoeff)((tmpLevel + iAddC ) >> iQBitsC);
1229  }
1230 #endif
1231 
1232  const TCoeff quantisedMagnitude = TCoeff((tmpLevel + iAdd ) >> iQBits);
1233  deltaU[uiBlockPos] = (TCoeff)((tmpLevel - (quantisedMagnitude<<iQBits) )>> qBits8);
1234 
1235  uiAbsSum += quantisedMagnitude;
1236  const TCoeff quantisedCoefficient = quantisedMagnitude * iSign;
1237 
1238  piQCoef[uiBlockPos] = Clip3<TCoeff>( entropyCodingMinimum, entropyCodingMaximum, quantisedCoefficient );
1239  } // for n
1240 
1241  if( pcCU->getSlice()->getPPS()->getSignDataHidingEnabledFlag() )
1242  {
1243  if(uiAbsSum >= 2) //this prevents TUs with only one coefficient of value 1 from being tested
1244  {
1245  signBitHidingHDQ( piQCoef, piCoef, deltaU, codingParameters, maxLog2TrDynamicRange ) ;
1246  }
1247  }
1248  } //if RDOQ
1249  //return;
1250 }
1251 
1252 Bool TComTrQuant::xNeedRDOQ( TComTU &rTu, TCoeff * pSrc, const ComponentID compID, const QpParam &cQP )
1253 {
1254  const TComRectangle &rect = rTu.getRect(compID);
1255  const UInt uiWidth = rect.width;
1256  const UInt uiHeight = rect.height;
1257  TComDataCU* pcCU = rTu.getCU();
1258  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
1259  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));
1260 
1261  TCoeff* piCoef = pSrc;
1262 
1263  const Bool useTransformSkip = pcCU->getTransformSkip(uiAbsPartIdx, compID);
1264  const Int maxLog2TrDynamicRange = pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID));
1265 
1266  const UInt uiLog2TrSize = rTu.GetEquivalentLog2TrSize(compID);
1267 
1268  Int scalingListType = getScalingListType(pcCU->getPredictionMode(uiAbsPartIdx), compID);
1269  assert(scalingListType < SCALING_LIST_NUM);
1270  Int *piQuantCoeff = getQuantCoeff(scalingListType, cQP.rem, uiLog2TrSize-2);
1271 
1272  const Bool enableScalingLists = getUseScalingList(uiWidth, uiHeight, (pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0));
1273  const Int defaultQuantisationCoefficient = g_quantScales[cQP.rem];
1274 
1275  /* for 422 chroma blocks, the effective scaling applied during transformation is not a power of 2, hence it cannot be
1276  * implemented as a bit-shift (the quantised result will be sqrt(2) * larger than required). Alternatively, adjust the
1277  * uiLog2TrSize applied in iTransformShift, such that the result is 1/sqrt(2) the required result (i.e. smaller)
1278  * Then a QP+3 (sqrt(2)) or QP-3 (1/sqrt(2)) method could be used to get the required result
1279  */
1280 
1281  // Represents scaling through forward transform
1282  Int iTransformShift = getTransformShift(channelBitDepth, uiLog2TrSize, maxLog2TrDynamicRange);
1283  if (useTransformSkip && pcCU->getSlice()->getSPS()->getSpsRangeExtension().getExtendedPrecisionProcessingFlag())
1284  {
1285  iTransformShift = std::max<Int>(0, iTransformShift);
1286  }
1287 
1288  const Int iQBits = QUANT_SHIFT + cQP.per + iTransformShift;
1289  // QBits will be OK for any internal bit depth as the reduction in transform shift is balanced by an increase in Qp_per due to QpBDOffset
1290 
1291  // iAdd is different from the iAdd used in normal quantization
1292  const Int iAdd = (compID == COMPONENT_Y ? 171 : 256) << (iQBits-9);
1293 
1294  for( Int uiBlockPos = 0; uiBlockPos < uiWidth*uiHeight; uiBlockPos++ )
1295  {
1296  const TCoeff iLevel = piCoef[uiBlockPos];
1297  const Int64 tmpLevel = (Int64)abs(iLevel) * (enableScalingLists ? piQuantCoeff[uiBlockPos] : defaultQuantisationCoefficient);
1298  const TCoeff quantisedMagnitude = TCoeff((tmpLevel + iAdd ) >> iQBits);
1299 
1300  if ( quantisedMagnitude != 0 )
1301  {
1302  return true;
1303  }
1304  } // for n
1305  return false;
1306 }
1307 
1309  const TCoeff * pSrc,
1310  TCoeff * pDes,
1311  const ComponentID compID,
1312  const QpParam &cQP )
1313 {
1314  assert(compID<MAX_NUM_COMPONENT);
1315 
1316  TComDataCU *pcCU = rTu.getCU();
1317  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
1318  const TComRectangle &rect = rTu.getRect(compID);
1319  const UInt uiWidth = rect.width;
1320  const UInt uiHeight = rect.height;
1321  const TCoeff *const piQCoef = pSrc;
1322  TCoeff *const piCoef = pDes;
1323  const UInt uiLog2TrSize = rTu.GetEquivalentLog2TrSize(compID);
1324  const UInt numSamplesInBlock = uiWidth*uiHeight;
1325  const Int maxLog2TrDynamicRange = pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID));
1326  const TCoeff transformMinimum = -(1 << maxLog2TrDynamicRange);
1327  const TCoeff transformMaximum = (1 << maxLog2TrDynamicRange) - 1;
1328  const Bool enableScalingLists = getUseScalingList(uiWidth, uiHeight, (pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0));
1329  const Int scalingListType = getScalingListType(pcCU->getPredictionMode(uiAbsPartIdx), compID);
1330 #if O0043_BEST_EFFORT_DECODING
1331  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getStreamBitDepth(toChannelType(compID));
1332 #else
1333  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));
1334 #endif
1335 
1336  assert (scalingListType < SCALING_LIST_NUM);
1337  assert ( uiWidth <= m_uiMaxTrSize );
1338 
1339  // Represents scaling through forward transform
1340  const Bool bClipTransformShiftTo0 = (pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0) && pcCU->getSlice()->getSPS()->getSpsRangeExtension().getExtendedPrecisionProcessingFlag();
1341  const Int originalTransformShift = getTransformShift(channelBitDepth, uiLog2TrSize, maxLog2TrDynamicRange);
1342  const Int iTransformShift = bClipTransformShiftTo0 ? std::max<Int>(0, originalTransformShift) : originalTransformShift;
1343 
1344  const Int QP_per = cQP.per;
1345  const Int QP_rem = cQP.rem;
1346 
1347  const Int rightShift = (IQUANT_SHIFT - (iTransformShift + QP_per)) + (enableScalingLists ? LOG2_SCALING_LIST_NEUTRAL_VALUE : 0);
1348 
1349  if(enableScalingLists)
1350  {
1351  //from the dequantisation equation:
1352  //iCoeffQ = ((Intermediate_Int(clipQCoef) * piDequantCoef[deQuantIdx]) + iAdd ) >> rightShift
1353  //(sizeof(Intermediate_Int) * 8) = inputBitDepth + dequantCoefBits - rightShift
1354  const UInt dequantCoefBits = 1 + IQUANT_SHIFT + SCALING_LIST_BITS;
1355  const UInt targetInputBitDepth = std::min<UInt>((maxLog2TrDynamicRange + 1), (((sizeof(Intermediate_Int) * 8) + rightShift) - dequantCoefBits));
1356 
1357  const Intermediate_Int inputMinimum = -(1 << (targetInputBitDepth - 1));
1358  const Intermediate_Int inputMaximum = (1 << (targetInputBitDepth - 1)) - 1;
1359 
1360  Int *piDequantCoef = getDequantCoeff(scalingListType,QP_rem,uiLog2TrSize-2);
1361 
1362  if(rightShift > 0)
1363  {
1364  const Intermediate_Int iAdd = 1 << (rightShift - 1);
1365 
1366  for( Int n = 0; n < numSamplesInBlock; n++ )
1367  {
1368  const TCoeff clipQCoef = TCoeff(Clip3<Intermediate_Int>(inputMinimum, inputMaximum, piQCoef[n]));
1369  const Intermediate_Int iCoeffQ = ((Intermediate_Int(clipQCoef) * piDequantCoef[n]) + iAdd ) >> rightShift;
1370 
1371  piCoef[n] = TCoeff(Clip3<Intermediate_Int>(transformMinimum,transformMaximum,iCoeffQ));
1372  }
1373  }
1374  else
1375  {
1376  const Int leftShift = -rightShift;
1377 
1378  for( Int n = 0; n < numSamplesInBlock; n++ )
1379  {
1380  const TCoeff clipQCoef = TCoeff(Clip3<Intermediate_Int>(inputMinimum, inputMaximum, piQCoef[n]));
1381  const Intermediate_Int iCoeffQ = (Intermediate_Int(clipQCoef) * piDequantCoef[n]) << leftShift;
1382 
1383  piCoef[n] = TCoeff(Clip3<Intermediate_Int>(transformMinimum,transformMaximum,iCoeffQ));
1384  }
1385  }
1386  }
1387  else
1388  {
1389  const Int scale = g_invQuantScales[QP_rem];
1390  const Int scaleBits = (IQUANT_SHIFT + 1) ;
1391 
1392  //from the dequantisation equation:
1393  //iCoeffQ = Intermediate_Int((Int64(clipQCoef) * scale + iAdd) >> rightShift);
1394  //(sizeof(Intermediate_Int) * 8) = inputBitDepth + scaleBits - rightShift
1395  const UInt targetInputBitDepth = std::min<UInt>((maxLog2TrDynamicRange + 1), (((sizeof(Intermediate_Int) * 8) + rightShift) - scaleBits));
1396  const Intermediate_Int inputMinimum = -(1 << (targetInputBitDepth - 1));
1397  const Intermediate_Int inputMaximum = (1 << (targetInputBitDepth - 1)) - 1;
1398 
1399  if (rightShift > 0)
1400  {
1401  const Intermediate_Int iAdd = 1 << (rightShift - 1);
1402 
1403  for( Int n = 0; n < numSamplesInBlock; n++ )
1404  {
1405  const TCoeff clipQCoef = TCoeff(Clip3<Intermediate_Int>(inputMinimum, inputMaximum, piQCoef[n]));
1406  const Intermediate_Int iCoeffQ = (Intermediate_Int(clipQCoef) * scale + iAdd) >> rightShift;
1407 
1408  piCoef[n] = TCoeff(Clip3<Intermediate_Int>(transformMinimum,transformMaximum,iCoeffQ));
1409  }
1410  }
1411  else
1412  {
1413  const Int leftShift = -rightShift;
1414 
1415  for( Int n = 0; n < numSamplesInBlock; n++ )
1416  {
1417  const TCoeff clipQCoef = TCoeff(Clip3<Intermediate_Int>(inputMinimum, inputMaximum, piQCoef[n]));
1418  const Intermediate_Int iCoeffQ = (Intermediate_Int(clipQCoef) * scale) << leftShift;
1419 
1420  piCoef[n] = TCoeff(Clip3<Intermediate_Int>(transformMinimum,transformMaximum,iCoeffQ));
1421  }
1422  }
1423  }
1424 }
1425 
1426 
1428  Bool bUseRDOQ,
1429  Bool bUseRDOQTS,
1430  Bool useSelectiveRDOQ,
1431  Bool bEnc,
1432  Bool useTransformSkipFast
1434  , Bool bUseAdaptQpSelect
1435 #endif
1436  )
1437 {
1438  m_uiMaxTrSize = uiMaxTrSize;
1439  m_bEnc = bEnc;
1440  m_useRDOQ = bUseRDOQ;
1441  m_useRDOQTS = bUseRDOQTS;
1442  m_useSelectiveRDOQ = useSelectiveRDOQ;
1443 #if ADAPTIVE_QP_SELECTION
1444  m_bUseAdaptQpSelect = bUseAdaptQpSelect;
1445 #endif
1446  m_useTransformSkipFast = useTransformSkipFast;
1447 }
1448 
1449 
1451  const ComponentID compID,
1452  Pel * pcResidual,
1453  const UInt uiStride,
1454  TCoeff * rpcCoeff,
1456  TCoeff * pcArlCoeff,
1457 #endif
1458  TCoeff & uiAbsSum,
1459  const QpParam & cQP
1460  )
1461 {
1462  const TComRectangle &rect = rTu.getRect(compID);
1463  const UInt uiWidth = rect.width;
1464  const UInt uiHeight = rect.height;
1465  TComDataCU* pcCU = rTu.getCU();
1466  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
1467  const UInt uiOrgTrDepth = rTu.GetTransformDepthRel();
1468 
1469  uiAbsSum=0;
1470 
1471  RDPCMMode rdpcmMode = RDPCM_OFF;
1472  rdpcmNxN( rTu, compID, pcResidual, uiStride, cQP, rpcCoeff, uiAbsSum, rdpcmMode );
1473 
1474  if (rdpcmMode == RDPCM_OFF)
1475  {
1476  uiAbsSum = 0;
1477  //transform and quantise
1478  if(pcCU->getCUTransquantBypass(uiAbsPartIdx))
1479  {
1480  const Bool rotateResidual = rTu.isNonTransformedResidualRotated(compID);
1481  const UInt uiSizeMinus1 = (uiWidth * uiHeight) - 1;
1482 
1483  for (UInt y = 0, coefficientIndex = 0; y<uiHeight; y++)
1484  {
1485  for (UInt x = 0; x<uiWidth; x++, coefficientIndex++)
1486  {
1487  const Pel currentSample = pcResidual[(y * uiStride) + x];
1488 
1489  rpcCoeff[rotateResidual ? (uiSizeMinus1 - coefficientIndex) : coefficientIndex] = currentSample;
1490  uiAbsSum += TCoeff(abs(currentSample));
1491  }
1492  }
1493  }
1494  else
1495  {
1496 #if DEBUG_TRANSFORM_AND_QUANTISE
1497  std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU at input to transform\n";
1498  printBlock(pcResidual, uiWidth, uiHeight, uiStride);
1499 #endif
1500 
1501  assert( (pcCU->getSlice()->getSPS()->getMaxTrSize() >= uiWidth) );
1502 
1503  if(pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0)
1504  {
1505  xTransformSkip( pcResidual, uiStride, m_plTempCoeff, rTu, compID );
1506  }
1507  else
1508  {
1509  const Int channelBitDepth=pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));
1510  xT( channelBitDepth, rTu.useDST(compID), pcResidual, uiStride, m_plTempCoeff, uiWidth, uiHeight, pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID)) );
1511  }
1512 
1513 #if DEBUG_TRANSFORM_AND_QUANTISE
1514  std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU between transform and quantiser\n";
1515  printBlock(m_plTempCoeff, uiWidth, uiHeight, uiWidth);
1516 #endif
1517 
1518  xQuant( rTu, m_plTempCoeff, rpcCoeff,
1519 
1521  pcArlCoeff,
1522 #endif
1523  uiAbsSum, compID, cQP );
1524 
1525 #if DEBUG_TRANSFORM_AND_QUANTISE
1526  std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU at output of quantiser\n";
1527  printBlock(rpcCoeff, uiWidth, uiHeight, uiWidth);
1528 #endif
1529  }
1530  }
1531 
1532  //set the CBF
1533  pcCU->setCbfPartRange((((uiAbsSum > 0) ? 1 : 0) << uiOrgTrDepth), compID, uiAbsPartIdx, rTu.GetAbsPartIdxNumParts(compID));
1534 }
1535 
1536 
1538  const ComponentID compID,
1539  Pel *pcResidual,
1540  const UInt uiStride,
1541  TCoeff * pcCoeff,
1542  const QpParam &cQP
1543  DEBUG_STRING_FN_DECLAREP(psDebug))
1544 {
1545  TComDataCU* pcCU=rTu.getCU();
1546  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
1547  const TComRectangle &rect = rTu.getRect(compID);
1548  const UInt uiWidth = rect.width;
1549  const UInt uiHeight = rect.height;
1550 
1551  if (uiWidth != uiHeight) //for intra, the TU will have been split above this level, so this condition won't be true, hence this only affects inter
1552  {
1553  //------------------------------------------------
1554 
1555  //recurse deeper
1556 
1557  TComTURecurse subTURecurse(rTu, false, TComTU::VERTICAL_SPLIT, true, compID);
1558 
1559  do
1560  {
1561  //------------------
1562 
1563  const UInt lineOffset = subTURecurse.GetSectionNumber() * subTURecurse.getRect(compID).height;
1564 
1565  Pel *subTUResidual = pcResidual + (lineOffset * uiStride);
1566  TCoeff *subTUCoefficients = pcCoeff + (lineOffset * subTURecurse.getRect(compID).width);
1567 
1568  invTransformNxN(subTURecurse, compID, subTUResidual, uiStride, subTUCoefficients, cQP DEBUG_STRING_PASS_INTO(psDebug));
1569 
1570  //------------------
1571 
1572  } while (subTURecurse.nextSection(rTu));
1573 
1574  //------------------------------------------------
1575 
1576  return;
1577  }
1578 
1579 #if DEBUG_STRING
1580  if (psDebug)
1581  {
1582  std::stringstream ss(stringstream::out);
1583  printBlockToStream(ss, (compID==0)?"###InvTran ip Ch0: " : ((compID==1)?"###InvTran ip Ch1: ":"###InvTran ip Ch2: "), pcCoeff, uiWidth, uiHeight, uiWidth);
1584  DEBUG_STRING_APPEND((*psDebug), ss.str())
1585  }
1586 #endif
1587 
1588  if(pcCU->getCUTransquantBypass(uiAbsPartIdx))
1589  {
1590  const Bool rotateResidual = rTu.isNonTransformedResidualRotated(compID);
1591  const UInt uiSizeMinus1 = (uiWidth * uiHeight) - 1;
1592 
1593  for (UInt y = 0, coefficientIndex = 0; y<uiHeight; y++)
1594  {
1595  for (UInt x = 0; x<uiWidth; x++, coefficientIndex++)
1596  {
1597  pcResidual[(y * uiStride) + x] = Pel(pcCoeff[rotateResidual ? (uiSizeMinus1 - coefficientIndex) : coefficientIndex]);
1598  }
1599  }
1600  }
1601  else
1602  {
1603 #if DEBUG_TRANSFORM_AND_QUANTISE
1604  std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU at input to dequantiser\n";
1605  printBlock(pcCoeff, uiWidth, uiHeight, uiWidth);
1606 #endif
1607 
1608  xDeQuant(rTu, pcCoeff, m_plTempCoeff, compID, cQP);
1609 
1610 #if DEBUG_TRANSFORM_AND_QUANTISE
1611  std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU between dequantiser and inverse-transform\n";
1612  printBlock(m_plTempCoeff, uiWidth, uiHeight, uiWidth);
1613 #endif
1614 
1615 #if DEBUG_STRING
1616  if (psDebug)
1617  {
1618  std::stringstream ss(stringstream::out);
1619  printBlockToStream(ss, "###InvTran deq: ", m_plTempCoeff, uiWidth, uiHeight, uiWidth);
1620  (*psDebug)+=ss.str();
1621  }
1622 #endif
1623 
1624  if(pcCU->getTransformSkip(uiAbsPartIdx, compID))
1625  {
1626  xITransformSkip( m_plTempCoeff, pcResidual, uiStride, rTu, compID );
1627 
1628 #if DEBUG_STRING
1629  if (psDebug)
1630  {
1631  std::stringstream ss(stringstream::out);
1632  printBlockToStream(ss, "###InvTran resi: ", pcResidual, uiWidth, uiHeight, uiStride);
1633  (*psDebug)+=ss.str();
1634  (*psDebug)+="(<- was a Transform-skipped block)\n";
1635  }
1636 #endif
1637  }
1638  else
1639  {
1640 #if O0043_BEST_EFFORT_DECODING
1641  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getStreamBitDepth(toChannelType(compID));
1642 #else
1643  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));
1644 #endif
1645  xIT( channelBitDepth, rTu.useDST(compID), m_plTempCoeff, pcResidual, uiStride, uiWidth, uiHeight, pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID)) );
1646 
1647 #if DEBUG_STRING
1648  if (psDebug)
1649  {
1650  std::stringstream ss(stringstream::out);
1651  printBlockToStream(ss, "###InvTran resi: ", pcResidual, uiWidth, uiHeight, uiStride);
1652  (*psDebug)+=ss.str();
1653  (*psDebug)+="(<- was a Transformed block)\n";
1654  }
1655 #endif
1656  }
1657 
1658 #if DEBUG_TRANSFORM_AND_QUANTISE
1659  std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU at output of inverse-transform\n";
1660  printBlock(pcResidual, uiWidth, uiHeight, uiStride);
1661  g_debugCounter++;
1662 #endif
1663  }
1664 
1665  invRdpcmNxN( rTu, compID, pcResidual, uiStride );
1666 }
1667 
1669  TComYuv *pResidual,
1670  TComTU &rTu)
1671 {
1672  if (!rTu.ProcessComponentSection(compID))
1673  {
1674  return;
1675  }
1676 
1677  TComDataCU* pcCU = rTu.getCU();
1678  UInt absPartIdxTU = rTu.GetAbsPartIdxTU();
1679  UInt uiTrMode=rTu.GetTransformDepthRel();
1680  if( (pcCU->getCbf(absPartIdxTU, compID, uiTrMode) == 0) && (isLuma(compID) || !pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag()) )
1681  {
1682  return;
1683  }
1684 
1685  if( uiTrMode == pcCU->getTransformIdx( absPartIdxTU ) )
1686  {
1687  const TComRectangle &tuRect = rTu.getRect(compID);
1688  const Int uiStride = pResidual->getStride( compID );
1689  Pel *rpcResidual = pResidual->getAddr( compID );
1690  UInt uiAddr = (tuRect.x0 + uiStride*tuRect.y0);
1691  Pel *pResi = rpcResidual + uiAddr;
1692  TCoeff *pcCoeff = pcCU->getCoeff(compID) + rTu.getCoefficientOffset(compID);
1693 
1694  const QpParam cQP(*pcCU, compID);
1695 
1696  if(pcCU->getCbf(absPartIdxTU, compID, uiTrMode) != 0)
1697  {
1698  DEBUG_STRING_NEW(sTemp)
1699 #if DEBUG_STRING
1700  std::string *psDebug=((DebugOptionList::DebugString_InvTran.getInt()&(pcCU->isIntra(absPartIdxTU)?1:(pcCU->isInter(absPartIdxTU)?2:4)))!=0) ? &sTemp : 0;
1701 #endif
1702 
1703  invTransformNxN( rTu, compID, pResi, uiStride, pcCoeff, cQP DEBUG_STRING_PASS_INTO(psDebug) );
1704 
1705 #if DEBUG_STRING
1706  if (psDebug != 0)
1707  {
1708  std::cout << (*psDebug);
1709  }
1710 #endif
1711  }
1712 
1713  if (isChroma(compID) && (pcCU->getCrossComponentPredictionAlpha(absPartIdxTU, compID) != 0))
1714  {
1715  const Pel *piResiLuma = pResidual->getAddr( COMPONENT_Y );
1716  const Int strideLuma = pResidual->getStride( COMPONENT_Y );
1717  const Int tuWidth = rTu.getRect( compID ).width;
1718  const Int tuHeight = rTu.getRect( compID ).height;
1719 
1720  if(pcCU->getCbf(absPartIdxTU, COMPONENT_Y, uiTrMode) != 0)
1721  {
1722  pResi = rpcResidual + uiAddr;
1723  const Pel *pResiLuma = piResiLuma + uiAddr;
1724 
1725  crossComponentPrediction( rTu, compID, pResiLuma, pResi, pResi, tuWidth, tuHeight, strideLuma, uiStride, uiStride, true );
1726  }
1727  }
1728  }
1729  else
1730  {
1731  TComTURecurse tuRecurseChild(rTu, false);
1732  do
1733  {
1734  invRecurTransformNxN( compID, pResidual, tuRecurseChild );
1735  } while (tuRecurseChild.nextSection(rTu));
1736  }
1737 }
1738 
1739 Void TComTrQuant::applyForwardRDPCM( TComTU& rTu, const ComponentID compID, Pel* pcResidual, const UInt uiStride, const QpParam& cQP, TCoeff* pcCoeff, TCoeff &uiAbsSum, const RDPCMMode mode )
1740 {
1741  TComDataCU *pcCU=rTu.getCU();
1742  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
1743 
1744  const Bool bLossless = pcCU->getCUTransquantBypass( uiAbsPartIdx );
1745  const UInt uiWidth = rTu.getRect(compID).width;
1746  const UInt uiHeight = rTu.getRect(compID).height;
1747  const Bool rotateResidual = rTu.isNonTransformedResidualRotated(compID);
1748  const UInt uiSizeMinus1 = (uiWidth * uiHeight) - 1;
1749 
1750  UInt uiX = 0;
1751  UInt uiY = 0;
1752 
1753  UInt &majorAxis = (mode == RDPCM_VER) ? uiX : uiY;
1754  UInt &minorAxis = (mode == RDPCM_VER) ? uiY : uiX;
1755  const UInt majorAxisLimit = (mode == RDPCM_VER) ? uiWidth : uiHeight;
1756  const UInt minorAxisLimit = (mode == RDPCM_VER) ? uiHeight : uiWidth;
1757 
1758  const Bool bUseHalfRoundingPoint = (mode != RDPCM_OFF);
1759 
1760  uiAbsSum = 0;
1761 
1762  for ( majorAxis = 0; majorAxis < majorAxisLimit; majorAxis++ )
1763  {
1764  TCoeff accumulatorValue = 0; // 32-bit accumulator
1765  for ( minorAxis = 0; minorAxis < minorAxisLimit; minorAxis++ )
1766  {
1767  const UInt sampleIndex = (uiY * uiWidth) + uiX;
1768  const UInt coefficientIndex = (rotateResidual ? (uiSizeMinus1-sampleIndex) : sampleIndex);
1769  const Pel currentSample = pcResidual[(uiY * uiStride) + uiX];
1770  const TCoeff encoderSideDelta = TCoeff(currentSample) - accumulatorValue;
1771 
1772  Pel reconstructedDelta;
1773  if ( bLossless )
1774  {
1775  pcCoeff[coefficientIndex] = encoderSideDelta;
1776  reconstructedDelta = (Pel) encoderSideDelta;
1777  }
1778  else
1779  {
1780  transformSkipQuantOneSample(rTu, compID, encoderSideDelta, pcCoeff, coefficientIndex, cQP, bUseHalfRoundingPoint);
1781  invTrSkipDeQuantOneSample (rTu, compID, pcCoeff[coefficientIndex], reconstructedDelta, cQP, coefficientIndex);
1782  }
1783 
1784  uiAbsSum += abs(pcCoeff[coefficientIndex]);
1785 
1786  if (mode != RDPCM_OFF)
1787  {
1788  accumulatorValue += reconstructedDelta;
1789  }
1790  }
1791  }
1792 }
1793 
1794 Void TComTrQuant::rdpcmNxN ( TComTU& rTu, const ComponentID compID, Pel* pcResidual, const UInt uiStride, const QpParam& cQP, TCoeff* pcCoeff, TCoeff &uiAbsSum, RDPCMMode& rdpcmMode )
1795 {
1796  TComDataCU *pcCU=rTu.getCU();
1797  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
1798 
1799  if (!pcCU->isRDPCMEnabled(uiAbsPartIdx) || ((pcCU->getTransformSkip(uiAbsPartIdx, compID) == 0) && !pcCU->getCUTransquantBypass(uiAbsPartIdx)))
1800  {
1801  rdpcmMode = RDPCM_OFF;
1802  }
1803  else if ( pcCU->isIntra( uiAbsPartIdx ) )
1804  {
1805  const ChromaFormat chFmt = pcCU->getPic()->getPicYuvOrg()->getChromaFormat();
1806  const ChannelType chType = toChannelType(compID);
1807  const UInt uiChPredMode = pcCU->getIntraDir( chType, uiAbsPartIdx );
1808  const TComSPS *sps=pcCU->getSlice()->getSPS();
1809  const UInt partsPerMinCU = 1<<(2*(sps->getMaxTotalCUDepth() - sps->getLog2DiffMaxMinCodingBlockSize()));
1810  const UInt uiChCodedMode = (uiChPredMode==DM_CHROMA_IDX && isChroma(compID)) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, chFmt, partsPerMinCU)) : uiChPredMode;
1811  const UInt uiChFinalMode = ((chFmt == CHROMA_422) && isChroma(compID)) ? g_chroma422IntraAngleMappingTable[uiChCodedMode] : uiChCodedMode;
1812 
1813  if (uiChFinalMode == VER_IDX || uiChFinalMode == HOR_IDX)
1814  {
1815  rdpcmMode = (uiChFinalMode == VER_IDX) ? RDPCM_VER : RDPCM_HOR;
1816  applyForwardRDPCM( rTu, compID, pcResidual, uiStride, cQP, pcCoeff, uiAbsSum, rdpcmMode );
1817  }
1818  else
1819  {
1820  rdpcmMode = RDPCM_OFF;
1821  }
1822  }
1823  else // not intra, need to select the best mode
1824  {
1825  const UInt uiWidth = rTu.getRect(compID).width;
1826  const UInt uiHeight = rTu.getRect(compID).height;
1827 
1828  RDPCMMode bestMode = NUMBER_OF_RDPCM_MODES;
1829  TCoeff bestAbsSum = std::numeric_limits<TCoeff>::max();
1830  TCoeff bestCoefficients[MAX_TU_SIZE * MAX_TU_SIZE];
1831 
1832  for (UInt modeIndex = 0; modeIndex < NUMBER_OF_RDPCM_MODES; modeIndex++)
1833  {
1834  const RDPCMMode mode = RDPCMMode(modeIndex);
1835 
1836  TCoeff currAbsSum = 0;
1837 
1838  applyForwardRDPCM( rTu, compID, pcResidual, uiStride, cQP, pcCoeff, currAbsSum, mode );
1839 
1840  if (currAbsSum < bestAbsSum)
1841  {
1842  bestMode = mode;
1843  bestAbsSum = currAbsSum;
1844  if (mode != RDPCM_OFF)
1845  {
1846  memcpy(bestCoefficients, pcCoeff, (uiWidth * uiHeight * sizeof(TCoeff)));
1847  }
1848  }
1849  }
1850 
1851  rdpcmMode = bestMode;
1852  uiAbsSum = bestAbsSum;
1853 
1854  if (rdpcmMode != RDPCM_OFF) //the TU is re-transformed and quantised if DPCM_OFF is returned, so there is no need to preserve it here
1855  {
1856  memcpy(pcCoeff, bestCoefficients, (uiWidth * uiHeight * sizeof(TCoeff)));
1857  }
1858  }
1859 
1860  pcCU->setExplicitRdpcmModePartRange(rdpcmMode, compID, uiAbsPartIdx, rTu.GetAbsPartIdxNumParts(compID));
1861 }
1862 
1863 Void TComTrQuant::invRdpcmNxN( TComTU& rTu, const ComponentID compID, Pel* pcResidual, const UInt uiStride )
1864 {
1865  TComDataCU *pcCU=rTu.getCU();
1866  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
1867 
1868  if (pcCU->isRDPCMEnabled( uiAbsPartIdx ) && ((pcCU->getTransformSkip(uiAbsPartIdx, compID ) != 0) || pcCU->getCUTransquantBypass(uiAbsPartIdx)))
1869  {
1870  const UInt uiWidth = rTu.getRect(compID).width;
1871  const UInt uiHeight = rTu.getRect(compID).height;
1872 
1873  RDPCMMode rdpcmMode = RDPCM_OFF;
1874 
1875  if ( pcCU->isIntra( uiAbsPartIdx ) )
1876  {
1877  const ChromaFormat chFmt = pcCU->getPic()->getPicYuvRec()->getChromaFormat();
1878  const ChannelType chType = toChannelType(compID);
1879  const UInt uiChPredMode = pcCU->getIntraDir( chType, uiAbsPartIdx );
1880  const TComSPS *sps=pcCU->getSlice()->getSPS();
1881  const UInt partsPerMinCU = 1<<(2*(sps->getMaxTotalCUDepth() - sps->getLog2DiffMaxMinCodingBlockSize()));
1882  const UInt uiChCodedMode = (uiChPredMode==DM_CHROMA_IDX && isChroma(compID)) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, chFmt, partsPerMinCU)) : uiChPredMode;
1883  const UInt uiChFinalMode = ((chFmt == CHROMA_422) && isChroma(compID)) ? g_chroma422IntraAngleMappingTable[uiChCodedMode] : uiChCodedMode;
1884 
1885  if (uiChFinalMode == VER_IDX || uiChFinalMode == HOR_IDX)
1886  {
1887  rdpcmMode = (uiChFinalMode == VER_IDX) ? RDPCM_VER : RDPCM_HOR;
1888  }
1889  }
1890  else // not intra case
1891  {
1892  rdpcmMode = RDPCMMode(pcCU->getExplicitRdpcmMode( compID, uiAbsPartIdx ));
1893  }
1894 
1895  const TCoeff pelMin=(TCoeff) std::numeric_limits<Pel>::min();
1896  const TCoeff pelMax=(TCoeff) std::numeric_limits<Pel>::max();
1897  if (rdpcmMode == RDPCM_VER)
1898  {
1899  for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1900  {
1901  Pel *pcCurResidual = pcResidual+uiX;
1902  TCoeff accumulator = *pcCurResidual; // 32-bit accumulator
1903  pcCurResidual+=uiStride;
1904  for( UInt uiY = 1; uiY < uiHeight; uiY++, pcCurResidual+=uiStride )
1905  {
1906  accumulator += *(pcCurResidual);
1907  *pcCurResidual = (Pel)Clip3<TCoeff>(pelMin, pelMax, accumulator);
1908  }
1909  }
1910  }
1911  else if (rdpcmMode == RDPCM_HOR)
1912  {
1913  for( UInt uiY = 0; uiY < uiHeight; uiY++ )
1914  {
1915  Pel *pcCurResidual = pcResidual+uiY*uiStride;
1916  TCoeff accumulator = *pcCurResidual;
1917  pcCurResidual++;
1918  for( UInt uiX = 1; uiX < uiWidth; uiX++, pcCurResidual++ )
1919  {
1920  accumulator += *(pcCurResidual);
1921  *pcCurResidual = (Pel)Clip3<TCoeff>(pelMin, pelMax, accumulator);
1922  }
1923  }
1924  }
1925  }
1926 }
1927 
1928 // ------------------------------------------------------------------------------------------------
1929 // Logical transform
1930 // ------------------------------------------------------------------------------------------------
1931 
1942 Void TComTrQuant::xT( const Int channelBitDepth, Bool useDST, Pel* piBlkResi, UInt uiStride, TCoeff* psCoeff, Int iWidth, Int iHeight, const Int maxLog2TrDynamicRange )
1943 {
1944 #if MATRIX_MULT
1945  if( iWidth == iHeight)
1946  {
1947  xTr(channelBitDepth, piBlkResi, psCoeff, uiStride, (UInt)iWidth, useDST, maxLog2TrDynamicRange);
1948  return;
1949  }
1950 #endif
1951 
1952  TCoeff block[ MAX_TU_SIZE * MAX_TU_SIZE ];
1953  TCoeff coeff[ MAX_TU_SIZE * MAX_TU_SIZE ];
1954 
1955  for (Int y = 0; y < iHeight; y++)
1956  {
1957  for (Int x = 0; x < iWidth; x++)
1958  {
1959  block[(y * iWidth) + x] = piBlkResi[(y * uiStride) + x];
1960  }
1961  }
1962 
1963  xTrMxN( channelBitDepth, block, coeff, iWidth, iHeight, useDST, maxLog2TrDynamicRange );
1964 
1965  memcpy(psCoeff, coeff, (iWidth * iHeight * sizeof(TCoeff)));
1966 }
1967 
1978 Void TComTrQuant::xIT( const Int channelBitDepth, Bool useDST, TCoeff* plCoef, Pel* pResidual, UInt uiStride, Int iWidth, Int iHeight, const Int maxLog2TrDynamicRange )
1979 {
1980 #if MATRIX_MULT
1981  if( iWidth == iHeight )
1982  {
1983  xITr(channelBitDepth, plCoef, pResidual, uiStride, (UInt)iWidth, useDST, maxLog2TrDynamicRange);
1984  return;
1985  }
1986 #endif
1987 
1988  TCoeff block[ MAX_TU_SIZE * MAX_TU_SIZE ];
1989  TCoeff coeff[ MAX_TU_SIZE * MAX_TU_SIZE ];
1990 
1991  memcpy(coeff, plCoef, (iWidth * iHeight * sizeof(TCoeff)));
1992 
1993  xITrMxN( channelBitDepth, coeff, block, iWidth, iHeight, useDST, maxLog2TrDynamicRange );
1994 
1995  for (Int y = 0; y < iHeight; y++)
1996  {
1997  for (Int x = 0; x < iWidth; x++)
1998  {
1999  pResidual[(y * uiStride) + x] = Pel(block[(y * iWidth) + x]);
2000  }
2001  }
2002 }
2003 
2011 Void TComTrQuant::xTransformSkip( Pel* piBlkResi, UInt uiStride, TCoeff* psCoeff, TComTU &rTu, const ComponentID component )
2012 {
2013  const TComRectangle &rect = rTu.getRect(component);
2014  const Int width = rect.width;
2015  const Int height = rect.height;
2016  const Int maxLog2TrDynamicRange = rTu.getCU()->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(component));
2017  const Int channelBitDepth = rTu.getCU()->getSlice()->getSPS()->getBitDepth(toChannelType(component));
2018 
2019  Int iTransformShift = getTransformShift(channelBitDepth, rTu.GetEquivalentLog2TrSize(component), maxLog2TrDynamicRange);
2021  {
2022  iTransformShift = std::max<Int>(0, iTransformShift);
2023  }
2024 
2025  const Bool rotateResidual = rTu.isNonTransformedResidualRotated(component);
2026  const UInt uiSizeMinus1 = (width * height) - 1;
2027 
2028  if (iTransformShift >= 0)
2029  {
2030  for (UInt y = 0, coefficientIndex = 0; y < height; y++)
2031  {
2032  for (UInt x = 0; x < width; x++, coefficientIndex++)
2033  {
2034  psCoeff[rotateResidual ? (uiSizeMinus1 - coefficientIndex) : coefficientIndex] = TCoeff(piBlkResi[(y * uiStride) + x]) << iTransformShift;
2035  }
2036  }
2037  }
2038  else //for very high bit depths
2039  {
2040  iTransformShift = -iTransformShift;
2041  const TCoeff offset = 1 << (iTransformShift - 1);
2042 
2043  for (UInt y = 0, coefficientIndex = 0; y < height; y++)
2044  {
2045  for (UInt x = 0; x < width; x++, coefficientIndex++)
2046  {
2047  psCoeff[rotateResidual ? (uiSizeMinus1 - coefficientIndex) : coefficientIndex] = (TCoeff(piBlkResi[(y * uiStride) + x]) + offset) >> iTransformShift;
2048  }
2049  }
2050  }
2051 }
2052 
2060 Void TComTrQuant::xITransformSkip( TCoeff* plCoef, Pel* pResidual, UInt uiStride, TComTU &rTu, const ComponentID component )
2061 {
2062  const TComRectangle &rect = rTu.getRect(component);
2063  const Int width = rect.width;
2064  const Int height = rect.height;
2065  const Int maxLog2TrDynamicRange = rTu.getCU()->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(component));
2066 #if O0043_BEST_EFFORT_DECODING
2067  const Int channelBitDepth = rTu.getCU()->getSlice()->getSPS()->getStreamBitDepth(toChannelType(component));
2068 #else
2069  const Int channelBitDepth = rTu.getCU()->getSlice()->getSPS()->getBitDepth(toChannelType(component));
2070 #endif
2071 
2072  Int iTransformShift = getTransformShift(channelBitDepth, rTu.GetEquivalentLog2TrSize(component), maxLog2TrDynamicRange);
2074  {
2075  iTransformShift = std::max<Int>(0, iTransformShift);
2076  }
2077 
2078  const Bool rotateResidual = rTu.isNonTransformedResidualRotated(component);
2079  const UInt uiSizeMinus1 = (width * height) - 1;
2080 
2081  if (iTransformShift >= 0)
2082  {
2083  const TCoeff offset = iTransformShift==0 ? 0 : (1 << (iTransformShift - 1));
2084 
2085  for (UInt y = 0, coefficientIndex = 0; y < height; y++)
2086  {
2087  for (UInt x = 0; x < width; x++, coefficientIndex++)
2088  {
2089  pResidual[(y * uiStride) + x] = Pel((plCoef[rotateResidual ? (uiSizeMinus1 - coefficientIndex) : coefficientIndex] + offset) >> iTransformShift);
2090  }
2091  }
2092  }
2093  else //for very high bit depths
2094  {
2095  iTransformShift = -iTransformShift;
2096 
2097  for (UInt y = 0, coefficientIndex = 0; y < height; y++)
2098  {
2099  for (UInt x = 0; x < width; x++, coefficientIndex++)
2100  {
2101  pResidual[(y * uiStride) + x] = Pel(plCoef[rotateResidual ? (uiSizeMinus1 - coefficientIndex) : coefficientIndex] << iTransformShift);
2102  }
2103  }
2104  }
2105 }
2106 
2120  TCoeff * plSrcCoeff,
2121  TCoeff * piDstCoeff,
2123  TCoeff * piArlDstCoeff,
2124 #endif
2125  TCoeff &uiAbsSum,
2126  const ComponentID compID,
2127  const QpParam &cQP )
2128 {
2129  const TComRectangle & rect = rTu.getRect(compID);
2130  const UInt uiWidth = rect.width;
2131  const UInt uiHeight = rect.height;
2132  TComDataCU * pcCU = rTu.getCU();
2133  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
2134  const ChannelType channelType = toChannelType(compID);
2135  const UInt uiLog2TrSize = rTu.GetEquivalentLog2TrSize(compID);
2136 
2137  const Bool extendedPrecision = pcCU->getSlice()->getSPS()->getSpsRangeExtension().getExtendedPrecisionProcessingFlag();
2138  const Int maxLog2TrDynamicRange = pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID));
2139  const Int channelBitDepth = rTu.getCU()->getSlice()->getSPS()->getBitDepth(channelType);
2140 
2141  /* for 422 chroma blocks, the effective scaling applied during transformation is not a power of 2, hence it cannot be
2142  * implemented as a bit-shift (the quantised result will be sqrt(2) * larger than required). Alternatively, adjust the
2143  * uiLog2TrSize applied in iTransformShift, such that the result is 1/sqrt(2) the required result (i.e. smaller)
2144  * Then a QP+3 (sqrt(2)) or QP-3 (1/sqrt(2)) method could be used to get the required result
2145  */
2146 
2147  // Represents scaling through forward transform
2148  Int iTransformShift = getTransformShift(channelBitDepth, uiLog2TrSize, maxLog2TrDynamicRange);
2149  if ((pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0) && extendedPrecision)
2150  {
2151  iTransformShift = std::max<Int>(0, iTransformShift);
2152  }
2153 
2154  const Bool bUseGolombRiceParameterAdaptation = pcCU->getSlice()->getSPS()->getSpsRangeExtension().getPersistentRiceAdaptationEnabledFlag();
2156  UInt uiGoRiceParam = initialGolombRiceParameter;
2157  Double d64BlockUncodedCost = 0;
2158  const UInt uiLog2BlockWidth = g_aucConvertToBit[ uiWidth ] + 2;
2159  const UInt uiLog2BlockHeight = g_aucConvertToBit[ uiHeight ] + 2;
2160  const UInt uiMaxNumCoeff = uiWidth * uiHeight;
2161  assert(compID<MAX_NUM_COMPONENT);
2162 
2163  Int scalingListType = getScalingListType(pcCU->getPredictionMode(uiAbsPartIdx), compID);
2164  assert(scalingListType < SCALING_LIST_NUM);
2165 
2166 #if ADAPTIVE_QP_SELECTION
2167  memset(piArlDstCoeff, 0, sizeof(TCoeff) * uiMaxNumCoeff);
2168 #endif
2169 
2170  Double pdCostCoeff [ MAX_TU_SIZE * MAX_TU_SIZE ];
2171  Double pdCostSig [ MAX_TU_SIZE * MAX_TU_SIZE ];
2172  Double pdCostCoeff0[ MAX_TU_SIZE * MAX_TU_SIZE ];
2173  memset( pdCostCoeff, 0, sizeof(Double) * uiMaxNumCoeff );
2174  memset( pdCostSig, 0, sizeof(Double) * uiMaxNumCoeff );
2175  Int rateIncUp [ MAX_TU_SIZE * MAX_TU_SIZE ];
2176  Int rateIncDown [ MAX_TU_SIZE * MAX_TU_SIZE ];
2177  Int sigRateDelta[ MAX_TU_SIZE * MAX_TU_SIZE ];
2178  TCoeff deltaU [ MAX_TU_SIZE * MAX_TU_SIZE ];
2179  memset( rateIncUp, 0, sizeof(Int ) * uiMaxNumCoeff );
2180  memset( rateIncDown, 0, sizeof(Int ) * uiMaxNumCoeff );
2181  memset( sigRateDelta, 0, sizeof(Int ) * uiMaxNumCoeff );
2182  memset( deltaU, 0, sizeof(TCoeff) * uiMaxNumCoeff );
2183 
2184  const Int iQBits = QUANT_SHIFT + cQP.per + iTransformShift; // Right shift of non-RDOQ quantizer; level = (coeff*uiQ + offset)>>q_bits
2185  const Double *const pdErrScale = getErrScaleCoeff(scalingListType, (uiLog2TrSize-2), cQP.rem);
2186  const Int *const piQCoef = getQuantCoeff(scalingListType, cQP.rem, (uiLog2TrSize-2));
2187 
2188  const Bool enableScalingLists = getUseScalingList(uiWidth, uiHeight, (pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0));
2189  const Int defaultQuantisationCoefficient = g_quantScales[cQP.rem];
2190  const Double defaultErrorScale = getErrScaleCoeffNoScalingList(scalingListType, (uiLog2TrSize-2), cQP.rem);
2191 
2192  const TCoeff entropyCodingMinimum = -(1 << maxLog2TrDynamicRange);
2193  const TCoeff entropyCodingMaximum = (1 << maxLog2TrDynamicRange) - 1;
2194 
2195 #if ADAPTIVE_QP_SELECTION
2196  Int iQBitsC = iQBits - ARL_C_PRECISION;
2197  Int iAddC = 1 << (iQBitsC-1);
2198 #endif
2199 
2200  TUEntropyCodingParameters codingParameters;
2201  getTUEntropyCodingParameters(codingParameters, rTu, compID);
2202  const UInt uiCGSize = (1 << MLS_CG_SIZE);
2203 
2204  Double pdCostCoeffGroupSig[ MLS_GRP_NUM ];
2205  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
2206  Int iCGLastScanPos = -1;
2207 
2208  UInt uiCtxSet = 0;
2209  Int c1 = 1;
2210  Int c2 = 0;
2211  Double d64BaseCost = 0;
2212  Int iLastScanPos = -1;
2213 
2214  UInt c1Idx = 0;
2215  UInt c2Idx = 0;
2216  Int baseLevel;
2217 
2218  memset( pdCostCoeffGroupSig, 0, sizeof(Double) * MLS_GRP_NUM );
2219  memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
2220 
2221  UInt uiCGNum = uiWidth * uiHeight >> MLS_CG_SIZE;
2222  Int iScanPos;
2223  coeffGroupRDStats rdStats;
2224 
2225  const UInt significanceMapContextOffset = getSignificanceMapContextOffset(compID);
2226 
2227  for (Int iCGScanPos = uiCGNum-1; iCGScanPos >= 0; iCGScanPos--)
2228  {
2229  UInt uiCGBlkPos = codingParameters.scanCG[ iCGScanPos ];
2230  UInt uiCGPosY = uiCGBlkPos / codingParameters.widthInGroups;
2231  UInt uiCGPosX = uiCGBlkPos - (uiCGPosY * codingParameters.widthInGroups);
2232 
2233  memset( &rdStats, 0, sizeof (coeffGroupRDStats));
2234 
2235  const Int patternSigCtx = TComTrQuant::calcPatternSigCtx(uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups);
2236 
2237  for (Int iScanPosinCG = uiCGSize-1; iScanPosinCG >= 0; iScanPosinCG--)
2238  {
2239  iScanPos = iCGScanPos*uiCGSize + iScanPosinCG;
2240  //===== quantization =====
2241  UInt uiBlkPos = codingParameters.scan[iScanPos];
2242  // set coeff
2243 
2244  const Int quantisationCoefficient = (enableScalingLists) ? piQCoef [uiBlkPos] : defaultQuantisationCoefficient;
2245  const Double errorScale = (enableScalingLists) ? pdErrScale[uiBlkPos] : defaultErrorScale;
2246 
2247  const Int64 tmpLevel = Int64(abs(plSrcCoeff[ uiBlkPos ])) * quantisationCoefficient;
2248 
2249  const Intermediate_Int lLevelDouble = (Intermediate_Int)min<Int64>(tmpLevel, std::numeric_limits<Intermediate_Int>::max() - (Intermediate_Int(1) << (iQBits - 1)));
2250 
2251 #if ADAPTIVE_QP_SELECTION
2252  if( m_bUseAdaptQpSelect )
2253  {
2254  piArlDstCoeff[uiBlkPos] = (TCoeff)(( lLevelDouble + iAddC) >> iQBitsC );
2255  }
2256 #endif
2257  const UInt uiMaxAbsLevel = std::min<UInt>(UInt(entropyCodingMaximum), UInt((lLevelDouble + (Intermediate_Int(1) << (iQBits - 1))) >> iQBits));
2258 
2259  const Double dErr = Double( lLevelDouble );
2260  pdCostCoeff0[ iScanPos ] = dErr * dErr * errorScale;
2261  d64BlockUncodedCost += pdCostCoeff0[ iScanPos ];
2262  piDstCoeff[ uiBlkPos ] = uiMaxAbsLevel;
2263 
2264  if ( uiMaxAbsLevel > 0 && iLastScanPos < 0 )
2265  {
2266  iLastScanPos = iScanPos;
2267  uiCtxSet = getContextSetIndex(compID, (iScanPos >> MLS_CG_SIZE), 0);
2268  iCGLastScanPos = iCGScanPos;
2269  }
2270 
2271  if ( iLastScanPos >= 0 )
2272  {
2273  //===== coefficient level estimation =====
2274  UInt uiLevel;
2275  UInt uiOneCtx = (NUM_ONE_FLAG_CTX_PER_SET * uiCtxSet) + c1;
2276  UInt uiAbsCtx = (NUM_ABS_FLAG_CTX_PER_SET * uiCtxSet) + c2;
2277 
2278  if( iScanPos == iLastScanPos )
2279  {
2280  uiLevel = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
2281  lLevelDouble, uiMaxAbsLevel, significanceMapContextOffset, uiOneCtx, uiAbsCtx, uiGoRiceParam,
2282  c1Idx, c2Idx, iQBits, errorScale, 1, extendedPrecision, maxLog2TrDynamicRange
2283  );
2284  }
2285  else
2286  {
2287  UShort uiCtxSig = significanceMapContextOffset + getSigCtxInc( patternSigCtx, codingParameters, iScanPos, uiLog2BlockWidth, uiLog2BlockHeight, channelType );
2288 
2289  uiLevel = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
2290  lLevelDouble, uiMaxAbsLevel, uiCtxSig, uiOneCtx, uiAbsCtx, uiGoRiceParam,
2291  c1Idx, c2Idx, iQBits, errorScale, 0, extendedPrecision, maxLog2TrDynamicRange
2292  );
2293 
2294  sigRateDelta[ uiBlkPos ] = m_pcEstBitsSbac->significantBits[ uiCtxSig ][ 1 ] - m_pcEstBitsSbac->significantBits[ uiCtxSig ][ 0 ];
2295  }
2296 
2297  deltaU[ uiBlkPos ] = TCoeff((lLevelDouble - (Intermediate_Int(uiLevel) << iQBits)) >> (iQBits-8));
2298 
2299  if( uiLevel > 0 )
2300  {
2301  Int rateNow = xGetICRate( uiLevel, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange );
2302  rateIncUp [ uiBlkPos ] = xGetICRate( uiLevel+1, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
2303  rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, uiOneCtx, uiAbsCtx, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
2304  }
2305  else // uiLevel == 0
2306  {
2307  rateIncUp [ uiBlkPos ] = m_pcEstBitsSbac->m_greaterOneBits[ uiOneCtx ][ 0 ];
2308  }
2309  piDstCoeff[ uiBlkPos ] = uiLevel;
2310  d64BaseCost += pdCostCoeff [ iScanPos ];
2311 
2312  baseLevel = (c1Idx < C1FLAG_NUMBER) ? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
2313  if( uiLevel >= baseLevel )
2314  {
2315  if (uiLevel > 3*(1<<uiGoRiceParam))
2316  {
2317  uiGoRiceParam = bUseGolombRiceParameterAdaptation ? (uiGoRiceParam + 1) : (std::min<UInt>((uiGoRiceParam + 1), 4));
2318  }
2319  }
2320  if ( uiLevel >= 1)
2321  {
2322  c1Idx ++;
2323  }
2324 
2325  //===== update bin model =====
2326  if( uiLevel > 1 )
2327  {
2328  c1 = 0;
2329  c2 += (c2 < 2);
2330  c2Idx ++;
2331  }
2332  else if( (c1 < 3) && (c1 > 0) && uiLevel)
2333  {
2334  c1++;
2335  }
2336 
2337  //===== context set update =====
2338  if( ( iScanPos % uiCGSize == 0 ) && ( iScanPos > 0 ) )
2339  {
2340  uiCtxSet = getContextSetIndex(compID, ((iScanPos - 1) >> MLS_CG_SIZE), (c1 == 0)); //(iScanPos - 1) because we do this **before** entering the final group
2341  c1 = 1;
2342  c2 = 0;
2343  c1Idx = 0;
2344  c2Idx = 0;
2345  uiGoRiceParam = initialGolombRiceParameter;
2346  }
2347  }
2348  else
2349  {
2350  d64BaseCost += pdCostCoeff0[ iScanPos ];
2351  }
2352  rdStats.d64SigCost += pdCostSig[ iScanPos ];
2353  if (iScanPosinCG == 0 )
2354  {
2355  rdStats.d64SigCost_0 = pdCostSig[ iScanPos ];
2356  }
2357  if (piDstCoeff[ uiBlkPos ] )
2358  {
2359  uiSigCoeffGroupFlag[ uiCGBlkPos ] = 1;
2360  rdStats.d64CodedLevelandDist += pdCostCoeff[ iScanPos ] - pdCostSig[ iScanPos ];
2361  rdStats.d64UncodedDist += pdCostCoeff0[ iScanPos ];
2362  if ( iScanPosinCG != 0 )
2363  {
2364  rdStats.iNNZbeforePos0++;
2365  }
2366  }
2367  } //end for (iScanPosinCG)
2368 
2369  if (iCGLastScanPos >= 0)
2370  {
2371  if( iCGScanPos )
2372  {
2373  if (uiSigCoeffGroupFlag[ uiCGBlkPos ] == 0)
2374  {
2375  UInt uiCtxSig = getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups );
2376  d64BaseCost += xGetRateSigCoeffGroup(0, uiCtxSig) - rdStats.d64SigCost;;
2377  pdCostCoeffGroupSig[ iCGScanPos ] = xGetRateSigCoeffGroup(0, uiCtxSig);
2378  }
2379  else
2380  {
2381  if (iCGScanPos < iCGLastScanPos) //skip the last coefficient group, which will be handled together with last position below.
2382  {
2383  if ( rdStats.iNNZbeforePos0 == 0 )
2384  {
2385  d64BaseCost -= rdStats.d64SigCost_0;
2386  rdStats.d64SigCost -= rdStats.d64SigCost_0;
2387  }
2388  // rd-cost if SigCoeffGroupFlag = 0, initialization
2389  Double d64CostZeroCG = d64BaseCost;
2390 
2391  // add SigCoeffGroupFlag cost to total cost
2392  UInt uiCtxSig = getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, uiCGPosX, uiCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups );
2393 
2394  if (iCGScanPos < iCGLastScanPos)
2395  {
2396  d64BaseCost += xGetRateSigCoeffGroup(1, uiCtxSig);
2397  d64CostZeroCG += xGetRateSigCoeffGroup(0, uiCtxSig);
2398  pdCostCoeffGroupSig[ iCGScanPos ] = xGetRateSigCoeffGroup(1, uiCtxSig);
2399  }
2400 
2401  // try to convert the current coeff group from non-zero to all-zero
2402  d64CostZeroCG += rdStats.d64UncodedDist; // distortion for resetting non-zero levels to zero levels
2403  d64CostZeroCG -= rdStats.d64CodedLevelandDist; // distortion and level cost for keeping all non-zero levels
2404  d64CostZeroCG -= rdStats.d64SigCost; // sig cost for all coeffs, including zero levels and non-zerl levels
2405 
2406  // if we can save cost, change this block to all-zero block
2407  if ( d64CostZeroCG < d64BaseCost )
2408  {
2409  uiSigCoeffGroupFlag[ uiCGBlkPos ] = 0;
2410  d64BaseCost = d64CostZeroCG;
2411  if (iCGScanPos < iCGLastScanPos)
2412  {
2413  pdCostCoeffGroupSig[ iCGScanPos ] = xGetRateSigCoeffGroup(0, uiCtxSig);
2414  }
2415  // reset coeffs to 0 in this block
2416  for (Int iScanPosinCG = uiCGSize-1; iScanPosinCG >= 0; iScanPosinCG--)
2417  {
2418  iScanPos = iCGScanPos*uiCGSize + iScanPosinCG;
2419  UInt uiBlkPos = codingParameters.scan[ iScanPos ];
2420 
2421  if (piDstCoeff[ uiBlkPos ])
2422  {
2423  piDstCoeff [ uiBlkPos ] = 0;
2424  pdCostCoeff[ iScanPos ] = pdCostCoeff0[ iScanPos ];
2425  pdCostSig [ iScanPos ] = 0;
2426  }
2427  }
2428  } // end if ( d64CostAllZeros < d64BaseCost )
2429  }
2430  } // end if if (uiSigCoeffGroupFlag[ uiCGBlkPos ] == 0)
2431  }
2432  else
2433  {
2434  uiSigCoeffGroupFlag[ uiCGBlkPos ] = 1;
2435  }
2436  }
2437  } //end for (iCGScanPos)
2438 
2439  //===== estimate last position =====
2440  if ( iLastScanPos < 0 )
2441  {
2442  return;
2443  }
2444 
2445  Double d64BestCost = 0;
2446  Int ui16CtxCbf = 0;
2447  Int iBestLastIdxP1 = 0;
2448  if( !pcCU->isIntra( uiAbsPartIdx ) && isLuma(compID) && pcCU->getTransformIdx( uiAbsPartIdx ) == 0 )
2449  {
2450  ui16CtxCbf = 0;
2451  d64BestCost = d64BlockUncodedCost + xGetICost( m_pcEstBitsSbac->blockRootCbpBits[ ui16CtxCbf ][ 0 ] );
2452  d64BaseCost += xGetICost( m_pcEstBitsSbac->blockRootCbpBits[ ui16CtxCbf ][ 1 ] );
2453  }
2454  else
2455  {
2456  ui16CtxCbf = pcCU->getCtxQtCbf( rTu, channelType );
2457  ui16CtxCbf += getCBFContextOffset(compID);
2458  d64BestCost = d64BlockUncodedCost + xGetICost( m_pcEstBitsSbac->blockCbpBits[ ui16CtxCbf ][ 0 ] );
2459  d64BaseCost += xGetICost( m_pcEstBitsSbac->blockCbpBits[ ui16CtxCbf ][ 1 ] );
2460  }
2461 
2462 
2463  Bool bFoundLast = false;
2464  for (Int iCGScanPos = iCGLastScanPos; iCGScanPos >= 0; iCGScanPos--)
2465  {
2466  UInt uiCGBlkPos = codingParameters.scanCG[ iCGScanPos ];
2467 
2468  d64BaseCost -= pdCostCoeffGroupSig [ iCGScanPos ];
2469  if (uiSigCoeffGroupFlag[ uiCGBlkPos ])
2470  {
2471  for (Int iScanPosinCG = uiCGSize-1; iScanPosinCG >= 0; iScanPosinCG--)
2472  {
2473  iScanPos = iCGScanPos*uiCGSize + iScanPosinCG;
2474 
2475  if (iScanPos > iLastScanPos)
2476  {
2477  continue;
2478  }
2479  UInt uiBlkPos = codingParameters.scan[iScanPos];
2480 
2481  if( piDstCoeff[ uiBlkPos ] )
2482  {
2483  UInt uiPosY = uiBlkPos >> uiLog2BlockWidth;
2484  UInt uiPosX = uiBlkPos - ( uiPosY << uiLog2BlockWidth );
2485 
2486  Double d64CostLast= codingParameters.scanType == SCAN_VER ? xGetRateLast( uiPosY, uiPosX, compID ) : xGetRateLast( uiPosX, uiPosY, compID );
2487  Double totalCost = d64BaseCost + d64CostLast - pdCostSig[ iScanPos ];
2488 
2489  if( totalCost < d64BestCost )
2490  {
2491  iBestLastIdxP1 = iScanPos + 1;
2492  d64BestCost = totalCost;
2493  }
2494  if( piDstCoeff[ uiBlkPos ] > 1 )
2495  {
2496  bFoundLast = true;
2497  break;
2498  }
2499  d64BaseCost -= pdCostCoeff[ iScanPos ];
2500  d64BaseCost += pdCostCoeff0[ iScanPos ];
2501  }
2502  else
2503  {
2504  d64BaseCost -= pdCostSig[ iScanPos ];
2505  }
2506  } //end for
2507  if (bFoundLast)
2508  {
2509  break;
2510  }
2511  } // end if (uiSigCoeffGroupFlag[ uiCGBlkPos ])
2512  } // end for
2513 
2514 
2515  for ( Int scanPos = 0; scanPos < iBestLastIdxP1; scanPos++ )
2516  {
2517  Int blkPos = codingParameters.scan[ scanPos ];
2518  TCoeff level = piDstCoeff[ blkPos ];
2519  uiAbsSum += level;
2520  piDstCoeff[ blkPos ] = ( plSrcCoeff[ blkPos ] < 0 ) ? -level : level;
2521  }
2522 
2523  //===== clean uncoded coefficients =====
2524  for ( Int scanPos = iBestLastIdxP1; scanPos <= iLastScanPos; scanPos++ )
2525  {
2526  piDstCoeff[ codingParameters.scan[ scanPos ] ] = 0;
2527  }
2528 
2529 
2530  if( pcCU->getSlice()->getPPS()->getSignDataHidingEnabledFlag() && uiAbsSum>=2)
2531  {
2532  const Double inverseQuantScale = Double(g_invQuantScales[cQP.rem]);
2533  Int64 rdFactor = (Int64)(inverseQuantScale * inverseQuantScale * (1 << (2 * cQP.per))
2534  / m_dLambda / 16 / (1 << (2 * DISTORTION_PRECISION_ADJUSTMENT(channelBitDepth - 8)))
2535  + 0.5);
2536 
2537  Int lastCG = -1;
2538  Int absSum = 0 ;
2539  Int n ;
2540 
2541  for( Int subSet = (uiWidth*uiHeight-1) >> MLS_CG_SIZE; subSet >= 0; subSet-- )
2542  {
2543  Int subPos = subSet << MLS_CG_SIZE;
2544  Int firstNZPosInCG=uiCGSize , lastNZPosInCG=-1 ;
2545  absSum = 0 ;
2546 
2547  for(n = uiCGSize-1; n >= 0; --n )
2548  {
2549  if( piDstCoeff[ codingParameters.scan[ n + subPos ]] )
2550  {
2551  lastNZPosInCG = n;
2552  break;
2553  }
2554  }
2555 
2556  for(n = 0; n <uiCGSize; n++ )
2557  {
2558  if( piDstCoeff[ codingParameters.scan[ n + subPos ]] )
2559  {
2560  firstNZPosInCG = n;
2561  break;
2562  }
2563  }
2564 
2565  for(n = firstNZPosInCG; n <=lastNZPosInCG; n++ )
2566  {
2567  absSum += Int(piDstCoeff[ codingParameters.scan[ n + subPos ]]);
2568  }
2569 
2570  if(lastNZPosInCG>=0 && lastCG==-1)
2571  {
2572  lastCG = 1;
2573  }
2574 
2575  if( lastNZPosInCG-firstNZPosInCG>=SBH_THRESHOLD )
2576  {
2577  UInt signbit = (piDstCoeff[codingParameters.scan[subPos+firstNZPosInCG]]>0?0:1);
2578  if( signbit!=(absSum&0x1) ) // hide but need tune
2579  {
2580  // calculate the cost
2581  Int64 minCostInc = std::numeric_limits<Int64>::max(), curCost = std::numeric_limits<Int64>::max();
2582  Int minPos = -1, finalChange = 0, curChange = 0;
2583 
2584  for( n = (lastCG==1?lastNZPosInCG:uiCGSize-1) ; n >= 0; --n )
2585  {
2586  UInt uiBlkPos = codingParameters.scan[ n + subPos ];
2587  if(piDstCoeff[ uiBlkPos ] != 0 )
2588  {
2589  Int64 costUp = rdFactor * ( - deltaU[uiBlkPos] ) + rateIncUp[uiBlkPos];
2590  Int64 costDown = rdFactor * ( deltaU[uiBlkPos] ) + rateIncDown[uiBlkPos]
2591  - ((abs(piDstCoeff[uiBlkPos]) == 1) ? sigRateDelta[uiBlkPos] : 0);
2592 
2593  if(lastCG==1 && lastNZPosInCG==n && abs(piDstCoeff[uiBlkPos])==1)
2594  {
2595  costDown -= (4<<15);
2596  }
2597 
2598  if(costUp<costDown)
2599  {
2600  curCost = costUp;
2601  curChange = 1;
2602  }
2603  else
2604  {
2605  curChange = -1;
2606  if(n==firstNZPosInCG && abs(piDstCoeff[uiBlkPos])==1)
2607  {
2608  curCost = std::numeric_limits<Int64>::max();
2609  }
2610  else
2611  {
2612  curCost = costDown;
2613  }
2614  }
2615  }
2616  else
2617  {
2618  curCost = rdFactor * ( - (abs(deltaU[uiBlkPos])) ) + (1<<15) + rateIncUp[uiBlkPos] + sigRateDelta[uiBlkPos] ;
2619  curChange = 1 ;
2620 
2621  if(n<firstNZPosInCG)
2622  {
2623  UInt thissignbit = (plSrcCoeff[uiBlkPos]>=0?0:1);
2624  if(thissignbit != signbit )
2625  {
2626  curCost = std::numeric_limits<Int64>::max();
2627  }
2628  }
2629  }
2630 
2631  if( curCost<minCostInc)
2632  {
2633  minCostInc = curCost;
2634  finalChange = curChange;
2635  minPos = uiBlkPos;
2636  }
2637  }
2638 
2639  if(piDstCoeff[minPos] == entropyCodingMaximum || piDstCoeff[minPos] == entropyCodingMinimum)
2640  {
2641  finalChange = -1;
2642  }
2643 
2644  if(plSrcCoeff[minPos]>=0)
2645  {
2646  piDstCoeff[minPos] += finalChange ;
2647  }
2648  else
2649  {
2650  piDstCoeff[minPos] -= finalChange ;
2651  }
2652  }
2653  }
2654 
2655  if(lastCG==1)
2656  {
2657  lastCG=0 ;
2658  }
2659  }
2660  }
2661 }
2662 
2663 
2672 Int TComTrQuant::calcPatternSigCtx( const UInt* sigCoeffGroupFlag, UInt uiCGPosX, UInt uiCGPosY, UInt widthInGroups, UInt heightInGroups )
2673 {
2674  if ((widthInGroups <= 1) && (heightInGroups <= 1))
2675  {
2676  return 0;
2677  }
2678 
2679  const Bool rightAvailable = uiCGPosX < (widthInGroups - 1);
2680  const Bool belowAvailable = uiCGPosY < (heightInGroups - 1);
2681 
2682  UInt sigRight = 0;
2683  UInt sigLower = 0;
2684 
2685  if (rightAvailable)
2686  {
2687  sigRight = ((sigCoeffGroupFlag[ (uiCGPosY * widthInGroups) + uiCGPosX + 1 ] != 0) ? 1 : 0);
2688  }
2689  if (belowAvailable)
2690  {
2691  sigLower = ((sigCoeffGroupFlag[ (uiCGPosY + 1) * widthInGroups + uiCGPosX ] != 0) ? 1 : 0);
2692  }
2693 
2694  return sigRight + (sigLower << 1);
2695 }
2696 
2697 
2708  const TUEntropyCodingParameters &codingParameters,
2709  const Int scanPosition,
2710  const Int log2BlockWidth,
2711  const Int log2BlockHeight,
2712  const ChannelType chanType)
2713 {
2715  {
2716  //single context mode
2718  }
2719 
2720  const UInt rasterPosition = codingParameters.scan[scanPosition];
2721  const UInt posY = rasterPosition >> log2BlockWidth;
2722  const UInt posX = rasterPosition - (posY << log2BlockWidth);
2723 
2724  if ((posX + posY) == 0)
2725  {
2726  return 0; //special case for the DC context variable
2727  }
2728 
2729  Int offset = MAX_INT;
2730 
2731  if ((log2BlockWidth == 2) && (log2BlockHeight == 2)) //4x4
2732  {
2733  offset = ctxIndMap4x4[ (4 * posY) + posX ];
2734  }
2735  else
2736  {
2737  Int cnt = 0;
2738 
2739  switch (patternSigCtx)
2740  {
2741  //------------------
2742 
2743  case 0: //neither neighbouring group is significant
2744  {
2745  const Int posXinSubset = posX & ((1 << MLS_CG_LOG2_WIDTH) - 1);
2746  const Int posYinSubset = posY & ((1 << MLS_CG_LOG2_HEIGHT) - 1);
2747  const Int posTotalInSubset = posXinSubset + posYinSubset;
2748 
2749  //first N coefficients in scan order use 2; the next few use 1; the rest use 0.
2750  const UInt context1Threshold = NEIGHBOURHOOD_00_CONTEXT_1_THRESHOLD_4x4;
2751  const UInt context2Threshold = NEIGHBOURHOOD_00_CONTEXT_2_THRESHOLD_4x4;
2752 
2753  cnt = (posTotalInSubset >= context1Threshold) ? 0 : ((posTotalInSubset >= context2Threshold) ? 1 : 2);
2754  }
2755  break;
2756 
2757  //------------------
2758 
2759  case 1: //right group is significant, below is not
2760  {
2761  const Int posYinSubset = posY & ((1 << MLS_CG_LOG2_HEIGHT) - 1);
2762  const Int groupHeight = 1 << MLS_CG_LOG2_HEIGHT;
2763 
2764  cnt = (posYinSubset >= (groupHeight >> 1)) ? 0 : ((posYinSubset >= (groupHeight >> 2)) ? 1 : 2); //top quarter uses 2; second-from-top quarter uses 1; bottom half uses 0
2765  }
2766  break;
2767 
2768  //------------------
2769 
2770  case 2: //below group is significant, right is not
2771  {
2772  const Int posXinSubset = posX & ((1 << MLS_CG_LOG2_WIDTH) - 1);
2773  const Int groupWidth = 1 << MLS_CG_LOG2_WIDTH;
2774 
2775  cnt = (posXinSubset >= (groupWidth >> 1)) ? 0 : ((posXinSubset >= (groupWidth >> 2)) ? 1 : 2); //left quarter uses 2; second-from-left quarter uses 1; right half uses 0
2776  }
2777  break;
2778 
2779  //------------------
2780 
2781  case 3: //both neighbouring groups are significant
2782  {
2783  cnt = 2;
2784  }
2785  break;
2786 
2787  //------------------
2788 
2789  default:
2790  std::cerr << "ERROR: Invalid patternSigCtx \"" << Int(patternSigCtx) << "\" in getSigCtxInc" << std::endl;
2791  exit(1);
2792  break;
2793  }
2794 
2795  //------------------------------------------------
2796 
2797  const Bool notFirstGroup = ((posX >> MLS_CG_LOG2_WIDTH) + (posY >> MLS_CG_LOG2_HEIGHT)) > 0;
2798 
2799  offset = (notFirstGroup ? notFirstGroupNeighbourhoodContextOffset[chanType] : 0) + cnt;
2800  }
2801 
2802  return codingParameters.firstSignificanceMapContext + offset;
2803 }
2804 
2805 
2812 __inline UInt TComTrQuant::xGetCodedLevel ( Double& rd64CodedCost, //< reference to coded cost
2813  Double& rd64CodedCost0, //< reference to cost when coefficient is 0
2814  Double& rd64CodedCostSig, //< rd64CodedCostSig reference to cost of significant coefficient
2815  Intermediate_Int lLevelDouble, //< reference to unscaled quantized level
2816  UInt uiMaxAbsLevel, //< scaled quantized level
2817  UShort ui16CtxNumSig, //< current ctxInc for coeff_abs_significant_flag
2818  UShort ui16CtxNumOne, //< current ctxInc for coeff_abs_level_greater1 (1st bin of coeff_abs_level_minus1 in AVC)
2819  UShort ui16CtxNumAbs, //< current ctxInc for coeff_abs_level_greater2 (remaining bins of coeff_abs_level_minus1 in AVC)
2820  UShort ui16AbsGoRice, //< current Rice parameter for coeff_abs_level_minus3
2821  UInt c1Idx, //<
2822  UInt c2Idx, //<
2823  Int iQBits, //< quantization step size
2824  Double errorScale, //<
2825  Bool bLast, //< indicates if the coefficient is the last significant
2826  Bool useLimitedPrefixLength, //<
2827  const Int maxLog2TrDynamicRange //<
2828  ) const
2829 {
2830  Double dCurrCostSig = 0;
2831  UInt uiBestAbsLevel = 0;
2832 
2833  if( !bLast && uiMaxAbsLevel < 3 )
2834  {
2835  rd64CodedCostSig = xGetRateSigCoef( 0, ui16CtxNumSig );
2836  rd64CodedCost = rd64CodedCost0 + rd64CodedCostSig;
2837  if( uiMaxAbsLevel == 0 )
2838  {
2839  return uiBestAbsLevel;
2840  }
2841  }
2842  else
2843  {
2844  rd64CodedCost = MAX_DOUBLE;
2845  }
2846 
2847  if( !bLast )
2848  {
2849  dCurrCostSig = xGetRateSigCoef( 1, ui16CtxNumSig );
2850  }
2851 
2852  UInt uiMinAbsLevel = ( uiMaxAbsLevel > 1 ? uiMaxAbsLevel - 1 : 1 );
2853  for( Int uiAbsLevel = uiMaxAbsLevel; uiAbsLevel >= uiMinAbsLevel ; uiAbsLevel-- )
2854  {
2855  Double dErr = Double( lLevelDouble - ( Intermediate_Int(uiAbsLevel) << iQBits ) );
2856  Double dCurrCost = dErr * dErr * errorScale + xGetICost( xGetICRate( uiAbsLevel, ui16CtxNumOne, ui16CtxNumAbs, ui16AbsGoRice, c1Idx, c2Idx, useLimitedPrefixLength, maxLog2TrDynamicRange ) );
2857  dCurrCost += dCurrCostSig;
2858 
2859  if( dCurrCost < rd64CodedCost )
2860  {
2861  uiBestAbsLevel = uiAbsLevel;
2862  rd64CodedCost = dCurrCost;
2863  rd64CodedCostSig = dCurrCostSig;
2864  }
2865  }
2866 
2867  return uiBestAbsLevel;
2868 }
2869 
2881 __inline Int TComTrQuant::xGetICRate ( const UInt uiAbsLevel,
2882  const UShort ui16CtxNumOne,
2883  const UShort ui16CtxNumAbs,
2884  const UShort ui16AbsGoRice,
2885  const UInt c1Idx,
2886  const UInt c2Idx,
2887  const Bool useLimitedPrefixLength,
2888  const Int maxLog2TrDynamicRange
2889  ) const
2890 {
2891  Int iRate = Int(xGetIEPRate()); // cost of sign bit
2892  UInt baseLevel = (c1Idx < C1FLAG_NUMBER) ? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
2893 
2894  if ( uiAbsLevel >= baseLevel )
2895  {
2896  UInt symbol = uiAbsLevel - baseLevel;
2897  UInt length;
2898  if (symbol < (COEF_REMAIN_BIN_REDUCTION << ui16AbsGoRice))
2899  {
2900  length = symbol>>ui16AbsGoRice;
2901  iRate += (length+1+ui16AbsGoRice)<< 15;
2902  }
2903  else if (useLimitedPrefixLength)
2904  {
2905  const UInt maximumPrefixLength = (32 - (COEF_REMAIN_BIN_REDUCTION + maxLog2TrDynamicRange));
2906 
2907  UInt prefixLength = 0;
2908  UInt suffix = (symbol >> ui16AbsGoRice) - COEF_REMAIN_BIN_REDUCTION;
2909 
2910  while ((prefixLength < maximumPrefixLength) && (suffix > ((2 << prefixLength) - 2)))
2911  {
2912  prefixLength++;
2913  }
2914 
2915  const UInt suffixLength = (prefixLength == maximumPrefixLength) ? (maxLog2TrDynamicRange - ui16AbsGoRice) : (prefixLength + 1/*separator*/);
2916 
2917  iRate += (COEF_REMAIN_BIN_REDUCTION + prefixLength + suffixLength + ui16AbsGoRice) << 15;
2918  }
2919  else
2920  {
2921  length = ui16AbsGoRice;
2922  symbol = symbol - ( COEF_REMAIN_BIN_REDUCTION << ui16AbsGoRice);
2923  while (symbol >= (1<<length))
2924  {
2925  symbol -= (1<<(length++));
2926  }
2927  iRate += (COEF_REMAIN_BIN_REDUCTION+length+1-ui16AbsGoRice+length)<< 15;
2928  }
2929 
2930  if (c1Idx < C1FLAG_NUMBER)
2931  {
2932  iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
2933 
2934  if (c2Idx < C2FLAG_NUMBER)
2935  {
2936  iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 1 ];
2937  }
2938  }
2939  }
2940  else if( uiAbsLevel == 1 )
2941  {
2942  iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 0 ];
2943  }
2944  else if( uiAbsLevel == 2 )
2945  {
2946  iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
2947  iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 0 ];
2948  }
2949  else
2950  {
2951  iRate = 0;
2952  }
2953 
2954  return iRate;
2955 }
2956 
2957 __inline Double TComTrQuant::xGetRateSigCoeffGroup ( UShort uiSignificanceCoeffGroup,
2958  UShort ui16CtxNumSig ) const
2959 {
2960  return xGetICost( m_pcEstBitsSbac->significantCoeffGroupBits[ ui16CtxNumSig ][ uiSignificanceCoeffGroup ] );
2961 }
2962 
2969 /*
2970  * \param uiWidth width of the transform unit (TU)
2971 */
2972 __inline Double TComTrQuant::xGetRateLast ( const UInt uiPosX,
2973  const UInt uiPosY,
2974  const ComponentID component ) const
2975 {
2976  UInt uiCtxX = g_uiGroupIdx[uiPosX];
2977  UInt uiCtxY = g_uiGroupIdx[uiPosY];
2978 
2979  Double uiCost = m_pcEstBitsSbac->lastXBits[toChannelType(component)][ uiCtxX ] + m_pcEstBitsSbac->lastYBits[toChannelType(component)][ uiCtxY ];
2980 
2981  if( uiCtxX > 3 )
2982  {
2983  uiCost += xGetIEPRate() * ((uiCtxX-2)>>1);
2984  }
2985  if( uiCtxY > 3 )
2986  {
2987  uiCost += xGetIEPRate() * ((uiCtxY-2)>>1);
2988  }
2989  return xGetICost( uiCost );
2990 }
2991 
2992 __inline Double TComTrQuant::xGetRateSigCoef ( UShort uiSignificance,
2993  UShort ui16CtxNumSig ) const
2994 {
2995  return xGetICost( m_pcEstBitsSbac->significantBits[ ui16CtxNumSig ][ uiSignificance ] );
2996 }
2997 
3002 __inline Double TComTrQuant::xGetICost ( Double dRate ) const
3003 {
3004  return m_dLambda * dRate;
3005 }
3006 
3011 {
3012  return 32768;
3013 }
3014 
3023 UInt TComTrQuant::getSigCoeffGroupCtxInc (const UInt* uiSigCoeffGroupFlag,
3024  const UInt uiCGPosX,
3025  const UInt uiCGPosY,
3026  const UInt widthInGroups,
3027  const UInt heightInGroups)
3028 {
3029  UInt sigRight = 0;
3030  UInt sigLower = 0;
3031 
3032  if (uiCGPosX < (widthInGroups - 1))
3033  {
3034  sigRight = ((uiSigCoeffGroupFlag[ (uiCGPosY * widthInGroups) + uiCGPosX + 1 ] != 0) ? 1 : 0);
3035  }
3036  if (uiCGPosY < (heightInGroups - 1))
3037  {
3038  sigLower = ((uiSigCoeffGroupFlag[ (uiCGPosY + 1) * widthInGroups + uiCGPosX ] != 0) ? 1 : 0);
3039  }
3040 
3041  return ((sigRight + sigLower) != 0) ? 1 : 0;
3042 }
3043 
3044 
3051 Void TComTrQuant::setScalingList(TComScalingList *scalingList, const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths)
3052 {
3053  const Int minimumQp = 0;
3054  const Int maximumQp = SCALING_LIST_REM_NUM;
3055 
3056  for(UInt size = 0; size < SCALING_LIST_SIZE_NUM; size++)
3057  {
3058  for(UInt list = 0; list < SCALING_LIST_NUM; list++)
3059  {
3060  for(Int qp = minimumQp; qp < maximumQp; qp++)
3061  {
3062  xSetScalingListEnc(scalingList,list,size,qp);
3063  xSetScalingListDec(*scalingList,list,size,qp);
3064  setErrScaleCoeff(list,size,qp,maxLog2TrDynamicRange, bitDepths);
3065  }
3066  }
3067  }
3068 }
3074 {
3075  const Int minimumQp = 0;
3076  const Int maximumQp = SCALING_LIST_REM_NUM;
3077 
3078  for(UInt size = 0; size < SCALING_LIST_SIZE_NUM; size++)
3079  {
3080  for(UInt list = 0; list < SCALING_LIST_NUM; list++)
3081  {
3082  for(Int qp = minimumQp; qp < maximumQp; qp++)
3083  {
3084  xSetScalingListDec(scalingList,list,size,qp);
3085  }
3086  }
3087  }
3088 }
3096 Void TComTrQuant::setErrScaleCoeff(UInt list, UInt size, Int qp, const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths)
3097 {
3098  const UInt uiLog2TrSize = g_aucConvertToBit[ g_scalingListSizeX[size] ] + 2;
3099  const ChannelType channelType = ((list == 0) || (list == MAX_NUM_COMPONENT)) ? CHANNEL_TYPE_LUMA : CHANNEL_TYPE_CHROMA;
3100 
3101  const Int channelBitDepth = bitDepths.recon[channelType];
3102  const Int iTransformShift = getTransformShift(channelBitDepth, uiLog2TrSize, maxLog2TrDynamicRange[channelType]); // Represents scaling through forward transform
3103 
3104  UInt i,uiMaxNumCoeff = g_scalingListSize[size];
3105  Int *piQuantcoeff;
3106  Double *pdErrScale;
3107  piQuantcoeff = getQuantCoeff(list, qp,size);
3108  pdErrScale = getErrScaleCoeff(list, size, qp);
3109 
3110  Double dErrScale = (Double)(1<<SCALE_BITS); // Compensate for scaling of bitcount in Lagrange cost function
3111  dErrScale = dErrScale*pow(2.0,(-2.0*iTransformShift)); // Compensate for scaling through forward transform
3112 
3113  for(i=0;i<uiMaxNumCoeff;i++)
3114  {
3115  pdErrScale[i] = dErrScale / piQuantcoeff[i] / piQuantcoeff[i] / (1 << DISTORTION_PRECISION_ADJUSTMENT(2 * (bitDepths.recon[channelType] - 8)));
3116  }
3117 
3118  getErrScaleCoeffNoScalingList(list, size, qp) = dErrScale / g_quantScales[qp] / g_quantScales[qp] / (1 << DISTORTION_PRECISION_ADJUSTMENT(2 * (bitDepths.recon[channelType] - 8)));
3119 }
3120 
3129 {
3130  UInt width = g_scalingListSizeX[sizeId];
3131  UInt height = g_scalingListSizeX[sizeId];
3132  UInt ratio = g_scalingListSizeX[sizeId]/min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]);
3133  Int *quantcoeff;
3134  Int *coeff = scalingList->getScalingListAddress(sizeId,listId);
3135  quantcoeff = getQuantCoeff(listId, qp, sizeId);
3136 
3137  Int quantScales = g_quantScales[qp];
3138 
3139  processScalingListEnc(coeff,
3140  quantcoeff,
3141  (quantScales << LOG2_SCALING_LIST_NEUTRAL_VALUE),
3142  height, width, ratio,
3144  scalingList->getScalingListDC(sizeId,listId));
3145 }
3146 
3154 Void TComTrQuant::xSetScalingListDec(const TComScalingList &scalingList, UInt listId, UInt sizeId, Int qp)
3155 {
3156  UInt width = g_scalingListSizeX[sizeId];
3157  UInt height = g_scalingListSizeX[sizeId];
3158  UInt ratio = g_scalingListSizeX[sizeId]/min(MAX_MATRIX_SIZE_NUM,(Int)g_scalingListSizeX[sizeId]);
3159  Int *dequantcoeff;
3160  const Int *coeff = scalingList.getScalingListAddress(sizeId,listId);
3161 
3162  dequantcoeff = getDequantCoeff(listId, qp, sizeId);
3163 
3164  Int invQuantScale = g_invQuantScales[qp];
3165 
3166  processScalingListDec(coeff,
3167  dequantcoeff,
3168  invQuantScale,
3169  height, width, ratio,
3171  scalingList.getScalingListDC(sizeId,listId));
3172 }
3173 
3176 Void TComTrQuant::setFlatScalingList(const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths)
3177 {
3178  const Int minimumQp = 0;
3179  const Int maximumQp = SCALING_LIST_REM_NUM;
3180 
3181  for(UInt size = 0; size < SCALING_LIST_SIZE_NUM; size++)
3182  {
3183  for(UInt list = 0; list < SCALING_LIST_NUM; list++)
3184  {
3185  for(Int qp = minimumQp; qp < maximumQp; qp++)
3186  {
3187  xsetFlatScalingList(list,size,qp);
3188  setErrScaleCoeff(list,size,qp,maxLog2TrDynamicRange, bitDepths);
3189  }
3190  }
3191  }
3192 }
3193 
3201 {
3202  UInt i,num = g_scalingListSize[size];
3203  Int *quantcoeff;
3204  Int *dequantcoeff;
3205 
3206  Int quantScales = g_quantScales [qp];
3207  Int invQuantScales = g_invQuantScales[qp] << 4;
3208 
3209  quantcoeff = getQuantCoeff(list, qp, size);
3210  dequantcoeff = getDequantCoeff(list, qp, size);
3211 
3212  for(i=0;i<num;i++)
3213  {
3214  *quantcoeff++ = quantScales;
3215  *dequantcoeff++ = invQuantScales;
3216  }
3217 }
3218 
3229 Void TComTrQuant::processScalingListEnc( Int *coeff, Int *quantcoeff, Int quantScales, UInt height, UInt width, UInt ratio, Int sizuNum, UInt dc)
3230 {
3231  for(UInt j=0;j<height;j++)
3232  {
3233  for(UInt i=0;i<width;i++)
3234  {
3235  quantcoeff[j*width + i] = quantScales / coeff[sizuNum * (j / ratio) + i / ratio];
3236  }
3237  }
3238 
3239  if(ratio > 1)
3240  {
3241  quantcoeff[0] = quantScales / dc;
3242  }
3243 }
3244 
3255 Void TComTrQuant::processScalingListDec( const Int *coeff, Int *dequantcoeff, Int invQuantScales, UInt height, UInt width, UInt ratio, Int sizuNum, UInt dc)
3256 {
3257  for(UInt j=0;j<height;j++)
3258  {
3259  for(UInt i=0;i<width;i++)
3260  {
3261  dequantcoeff[j*width + i] = invQuantScales * coeff[sizuNum * (j / ratio) + i / ratio];
3262  }
3263  }
3264 
3265  if(ratio > 1)
3266  {
3267  dequantcoeff[0] = invQuantScales * dc;
3268  }
3269 }
3270 
3274 {
3275  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3276  {
3277  for(UInt qp = 0; qp < SCALING_LIST_REM_NUM; qp++)
3278  {
3279  for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
3280  {
3281  m_quantCoef [sizeId][listId][qp] = new Int [g_scalingListSize[sizeId]];
3282  m_dequantCoef [sizeId][listId][qp] = new Int [g_scalingListSize[sizeId]];
3283  m_errScale [sizeId][listId][qp] = new Double [g_scalingListSize[sizeId]];
3284  } // listID loop
3285  }
3286  }
3287 }
3288 
3292 {
3293  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3294  {
3295  for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
3296  {
3297  for(UInt qp = 0; qp < SCALING_LIST_REM_NUM; qp++)
3298  {
3299  if(m_quantCoef[sizeId][listId][qp])
3300  {
3301  delete [] m_quantCoef[sizeId][listId][qp];
3302  }
3303  if(m_dequantCoef[sizeId][listId][qp])
3304  {
3305  delete [] m_dequantCoef[sizeId][listId][qp];
3306  }
3307  if(m_errScale[sizeId][listId][qp])
3308  {
3309  delete [] m_errScale[sizeId][listId][qp];
3310  }
3311  }
3312  }
3313  }
3314 }
3315 
3316 Void TComTrQuant::transformSkipQuantOneSample(TComTU &rTu, const ComponentID compID, const TCoeff resiDiff, TCoeff* pcCoeff, const UInt uiPos, const QpParam &cQP, const Bool bUseHalfRoundingPoint)
3317 {
3318  TComDataCU *pcCU = rTu.getCU();
3319  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
3320  const TComRectangle &rect = rTu.getRect(compID);
3321  const UInt uiWidth = rect.width;
3322  const UInt uiHeight = rect.height;
3323  const Int maxLog2TrDynamicRange = pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID));
3324  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));
3325  const Int iTransformShift = getTransformShift(channelBitDepth, rTu.GetEquivalentLog2TrSize(compID), maxLog2TrDynamicRange);
3326  const Int scalingListType = getScalingListType(pcCU->getPredictionMode(uiAbsPartIdx), compID);
3327  const Bool enableScalingLists = getUseScalingList(uiWidth, uiHeight, true);
3328  const Int defaultQuantisationCoefficient = g_quantScales[cQP.rem];
3329 
3330  assert( scalingListType < SCALING_LIST_NUM );
3331  const Int *const piQuantCoeff = getQuantCoeff( scalingListType, cQP.rem, (rTu.GetEquivalentLog2TrSize(compID)-2) );
3332 
3333 
3334  /* for 422 chroma blocks, the effective scaling applied during transformation is not a power of 2, hence it cannot be
3335  * implemented as a bit-shift (the quantised result will be sqrt(2) * larger than required). Alternatively, adjust the
3336  * uiLog2TrSize applied in iTransformShift, such that the result is 1/sqrt(2) the required result (i.e. smaller)
3337  * Then a QP+3 (sqrt(2)) or QP-3 (1/sqrt(2)) method could be used to get the required result
3338  */
3339 
3340  const Int iQBits = QUANT_SHIFT + cQP.per + iTransformShift;
3341  // QBits will be OK for any internal bit depth as the reduction in transform shift is balanced by an increase in Qp_per due to QpBDOffset
3342 
3343  const Int iAdd = ( bUseHalfRoundingPoint ? 256 : (pcCU->getSlice()->getSliceType() == I_SLICE ? 171 : 85) ) << (iQBits - 9);
3344 
3345  TCoeff transformedCoefficient;
3346 
3347  // transform-skip
3348  if (iTransformShift >= 0)
3349  {
3350  transformedCoefficient = resiDiff << iTransformShift;
3351  }
3352  else // for very high bit depths
3353  {
3354  const Int iTrShiftNeg = -iTransformShift;
3355  const Int offset = 1 << (iTrShiftNeg - 1);
3356  transformedCoefficient = ( resiDiff + offset ) >> iTrShiftNeg;
3357  }
3358 
3359  // quantization
3360  const TCoeff iSign = (transformedCoefficient < 0 ? -1: 1);
3361 
3362  const Int quantisationCoefficient = enableScalingLists ? piQuantCoeff[uiPos] : defaultQuantisationCoefficient;
3363 
3364  const Int64 tmpLevel = (Int64)abs(transformedCoefficient) * quantisationCoefficient;
3365 
3366  const TCoeff quantisedCoefficient = (TCoeff((tmpLevel + iAdd ) >> iQBits)) * iSign;
3367 
3368  const TCoeff entropyCodingMinimum = -(1 << maxLog2TrDynamicRange);
3369  const TCoeff entropyCodingMaximum = (1 << maxLog2TrDynamicRange) - 1;
3370  pcCoeff[ uiPos ] = Clip3<TCoeff>( entropyCodingMinimum, entropyCodingMaximum, quantisedCoefficient );
3371 }
3372 
3373 
3374 Void TComTrQuant::invTrSkipDeQuantOneSample( TComTU &rTu, ComponentID compID, TCoeff inSample, Pel &reconSample, const QpParam &cQP, UInt uiPos )
3375 {
3376  TComDataCU *pcCU = rTu.getCU();
3377  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
3378  const TComRectangle &rect = rTu.getRect(compID);
3379  const UInt uiWidth = rect.width;
3380  const UInt uiHeight = rect.height;
3381  const Int QP_per = cQP.per;
3382  const Int QP_rem = cQP.rem;
3383  const Int maxLog2TrDynamicRange = pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID));
3384 #if O0043_BEST_EFFORT_DECODING
3385  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getStreamBitDepth(toChannelType(compID));
3386 #else
3387  const Int channelBitDepth = pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));
3388 #endif
3389  const Int iTransformShift = getTransformShift(channelBitDepth, rTu.GetEquivalentLog2TrSize(compID), maxLog2TrDynamicRange);
3390  const Int scalingListType = getScalingListType(pcCU->getPredictionMode(uiAbsPartIdx), compID);
3391  const Bool enableScalingLists = getUseScalingList(uiWidth, uiHeight, true);
3392  const UInt uiLog2TrSize = rTu.GetEquivalentLog2TrSize(compID);
3393 
3394  assert( scalingListType < SCALING_LIST_NUM );
3395 
3396  const Int rightShift = (IQUANT_SHIFT - (iTransformShift + QP_per)) + (enableScalingLists ? LOG2_SCALING_LIST_NEUTRAL_VALUE : 0);
3397 
3398  const TCoeff transformMinimum = -(1 << maxLog2TrDynamicRange);
3399  const TCoeff transformMaximum = (1 << maxLog2TrDynamicRange) - 1;
3400 
3401  // Dequantisation
3402 
3403  TCoeff dequantisedSample;
3404 
3405  if(enableScalingLists)
3406  {
3407  const UInt dequantCoefBits = 1 + IQUANT_SHIFT + SCALING_LIST_BITS;
3408  const UInt targetInputBitDepth = std::min<UInt>((maxLog2TrDynamicRange + 1), (((sizeof(Intermediate_Int) * 8) + rightShift) - dequantCoefBits));
3409 
3410  const Intermediate_Int inputMinimum = -(1 << (targetInputBitDepth - 1));
3411  const Intermediate_Int inputMaximum = (1 << (targetInputBitDepth - 1)) - 1;
3412 
3413  Int *piDequantCoef = getDequantCoeff(scalingListType,QP_rem,uiLog2TrSize-2);
3414 
3415  if(rightShift > 0)
3416  {
3417  const Intermediate_Int iAdd = 1 << (rightShift - 1);
3418  const TCoeff clipQCoef = TCoeff(Clip3<Intermediate_Int>(inputMinimum, inputMaximum, inSample));
3419  const Intermediate_Int iCoeffQ = ((Intermediate_Int(clipQCoef) * piDequantCoef[uiPos]) + iAdd ) >> rightShift;
3420 
3421  dequantisedSample = TCoeff(Clip3<Intermediate_Int>(transformMinimum,transformMaximum,iCoeffQ));
3422  }
3423  else
3424  {
3425  const Int leftShift = -rightShift;
3426  const TCoeff clipQCoef = TCoeff(Clip3<Intermediate_Int>(inputMinimum, inputMaximum, inSample));
3427  const Intermediate_Int iCoeffQ = (Intermediate_Int(clipQCoef) * piDequantCoef[uiPos]) << leftShift;
3428 
3429  dequantisedSample = TCoeff(Clip3<Intermediate_Int>(transformMinimum,transformMaximum,iCoeffQ));
3430  }
3431  }
3432  else
3433  {
3434  const Int scale = g_invQuantScales[QP_rem];
3435  const Int scaleBits = (IQUANT_SHIFT + 1) ;
3436 
3437  const UInt targetInputBitDepth = std::min<UInt>((maxLog2TrDynamicRange + 1), (((sizeof(Intermediate_Int) * 8) + rightShift) - scaleBits));
3438  const Intermediate_Int inputMinimum = -(1 << (targetInputBitDepth - 1));
3439  const Intermediate_Int inputMaximum = (1 << (targetInputBitDepth - 1)) - 1;
3440 
3441  if (rightShift > 0)
3442  {
3443  const Intermediate_Int iAdd = 1 << (rightShift - 1);
3444  const TCoeff clipQCoef = TCoeff(Clip3<Intermediate_Int>(inputMinimum, inputMaximum, inSample));
3445  const Intermediate_Int iCoeffQ = (Intermediate_Int(clipQCoef) * scale + iAdd) >> rightShift;
3446 
3447  dequantisedSample = TCoeff(Clip3<Intermediate_Int>(transformMinimum,transformMaximum,iCoeffQ));
3448  }
3449  else
3450  {
3451  const Int leftShift = -rightShift;
3452  const TCoeff clipQCoef = TCoeff(Clip3<Intermediate_Int>(inputMinimum, inputMaximum, inSample));
3453  const Intermediate_Int iCoeffQ = (Intermediate_Int(clipQCoef) * scale) << leftShift;
3454 
3455  dequantisedSample = TCoeff(Clip3<Intermediate_Int>(transformMinimum,transformMaximum,iCoeffQ));
3456  }
3457  }
3458 
3459  // Inverse transform-skip
3460 
3461  if (iTransformShift >= 0)
3462  {
3463  const TCoeff offset = iTransformShift==0 ? 0 : (1 << (iTransformShift - 1));
3464  reconSample = Pel(( dequantisedSample + offset ) >> iTransformShift);
3465  }
3466  else //for very high bit depths
3467  {
3468  const Int iTrShiftNeg = -iTransformShift;
3469  reconSample = Pel(dequantisedSample << iTrShiftNeg);
3470  }
3471 }
3472 
3473 
3475  const ComponentID compID,
3476  const Pel * piResiL,
3477  const Pel * piResiC,
3478  Pel * piResiT,
3479  const Int width,
3480  const Int height,
3481  const Int strideL,
3482  const Int strideC,
3483  const Int strideT,
3484  const Bool reverse )
3485 {
3486  const Pel *pResiL = piResiL;
3487  const Pel *pResiC = piResiC;
3488  Pel *pResiT = piResiT;
3489 
3490  TComDataCU *pCU = rTu.getCU();
3491  const Int alpha = pCU->getCrossComponentPredictionAlpha( rTu.GetAbsPartIdxTU( compID ), compID );
3492  const Int diffBitDepth = pCU->getSlice()->getSPS()->getDifferentialLumaChromaBitDepth();
3493 
3494  for( Int y = 0; y < height; y++ )
3495  {
3496  if (reverse)
3497  {
3498  // A constraint is to be added to the HEVC Standard to limit the size of pResiL and pResiC at this point.
3499  // The likely form of the constraint is to either restrict the values to CoeffMin to CoeffMax,
3500  // or to be representable in a bitDepthY+4 or bitDepthC+4 signed integer.
3501  // The result of the constraint is that for 8/10/12bit profiles, the input values
3502  // can be represented within a 16-bit Pel-type.
3503 #if RExt__HIGH_BIT_DEPTH_SUPPORT
3504  for( Int x = 0; x < width; x++ )
3505  {
3506  pResiT[x] = pResiC[x] + (( alpha * rightShift( pResiL[x], diffBitDepth) ) >> 3);
3507  }
3508 #else
3509  const Int minPel=std::numeric_limits<Pel>::min();
3510  const Int maxPel=std::numeric_limits<Pel>::max();
3511  for( Int x = 0; x < width; x++ )
3512  {
3513  pResiT[x] = Clip3<Int>(minPel, maxPel, pResiC[x] + (( alpha * rightShift<Int>(Int(pResiL[x]), diffBitDepth) ) >> 3));
3514  }
3515 #endif
3516  }
3517  else
3518  {
3519  // Forward does not need clipping. Pel type should always be big enough.
3520  for( Int x = 0; x < width; x++ )
3521  {
3522  pResiT[x] = pResiC[x] - (( alpha * rightShift<Int>(Int(pResiL[x]), diffBitDepth) ) >> 3);
3523  }
3524  }
3525 
3526  pResiL += strideL;
3527  pResiC += strideC;
3528  pResiT += strideT;
3529  }
3530 }
3531 
SChar g_aucConvertToBit[MAX_CU_SIZE+1]
Definition: TComRom.cpp:572
const Int g_quantScales[SCALING_LIST_REM_NUM]
Definition: TComRom.cpp:354
Bool xNeedRDOQ(TComTU &rTu, TCoeff *pSrc, const ComponentID compID, const QpParam &cQP)
static const Int SCALING_LIST_REM_NUM
Definition: CommonDef.h:226
Bool getCrossComponentPredictionEnabledFlag() const
Definition: TComSlice.h:1001
Int * m_dequantCoef[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM][SCALING_LIST_REM_NUM]
array of dequantization matrix coefficient 4x4
Definition: TComTrQuant.h:228
Int m_sliceNsamples[LEVEL_RANGE+1]
Definition: TComTrQuant.h:204
static const Int SCALING_LIST_NUM
list number for quantization matrix
Definition: CommonDef.h:232
static Int getScalingListType(const PredMode predMode, const ComponentID compID)
Void partialButterflyInverse8(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
UInt m_uiMaxTrSize
Definition: TComTrQuant.h:215
Bool getPersistentRiceAdaptationEnabledFlag() const
Definition: TComSlice.h:732
ValueType leftShift(const ValueType value, const Int shift)
Definition: CommonDef.h:280
static Int getScaledChromaQP(Int unscaledChromaQP, const ChromaFormat chFmt)
unsigned short UShort
Definition: TypeDef.h:210
static const Int g_transformMatrixShift[TRANSFORM_NUMBER_OF_DIRECTIONS]
Definition: TComRom.h:82
static const Int ARL_C_PRECISION
G382: 7-bit arithmetic precision.
Definition: CommonDef.h:174
static Int getSigCtxInc(Int patternSigCtx, const TUEntropyCodingParameters &codingParameters, const Int scanPosition, const Int log2BlockWidth, const Int log2BlockHeight, const ChannelType chanType)
Bool m_useRDOQ
Definition: TComTrQuant.h:217
static const UInt notFirstGroupNeighbourhoodContextOffset[MAX_NUM_CHANNEL_TYPE]
Definition: ContextTables.h:88
Void xTrMxN(Int bitDepth, TCoeff *block, TCoeff *coeff, Int iWidth, Int iHeight, Bool useDST, const Int maxLog2TrDynamicRange)
Int * getScalingListAddress(UInt sizeId, UInt listId)
get matrix coefficient
Definition: TComSlice.h:155
SliceType getSliceType() const
Definition: TComSlice.h:1353
CU data structure class.
Definition: TComDataCU.h:64
Void destroyScalingList()
static UInt getChromasCorrespondingPULumaIdx(const UInt lumaZOrderIdxInCtu, const ChromaFormat chFmt, const Int partsPerMinCU)
ChannelType
Definition: TypeDef.h:301
Void setScalingList(TComScalingList *scalingList, const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths)
Bool useDST(const ComponentID compID)
Definition: TComTU.cpp:227
Int lastYBits[MAX_NUM_CHANNEL_TYPE][LAST_SIGNIFICANT_GROUPS]
Definition: TComTrQuant.h:65
Double * m_errScale[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM][SCALING_LIST_REM_NUM]
array of quantization matrix coefficient 4x4
Definition: TComTrQuant.h:229
static const Int HOR_IDX
index for intra HORIZONTAL mode
Definition: CommonDef.h:185
const TMatrixCoeff g_aiT16[TRANSFORM_NUMBER_OF_DIRECTIONS][16][16]
Definition: TComRom.cpp:501
Int m_qpDelta[MAX_QP+1]
Definition: TComTrQuant.h:203
#define NEIGHBOURHOOD_00_CONTEXT_2_THRESHOLD_4x4
Definition: ContextTables.h:93
Void setFlatScalingList(const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths)
void Void
Definition: TypeDef.h:203
Void xITrMxN(Int bitDepth, TCoeff *coeff, TCoeff *block, Int iWidth, Int iHeight, Bool useDST, const Int maxLog2TrDynamicRange)
UChar * getExplicitRdpcmMode(ComponentID component)
Definition: TComDataCU.h:286
const TComPPSRExt & getPpsRangeExtension() const
Definition: TComSlice.h:1197
static const Int DM_CHROMA_IDX
chroma mode index for derived from luma intra mode
Definition: CommonDef.h:188
const TComSPSRExt & getSpsRangeExtension() const
Definition: TComSlice.h:941
SChar * getCrossComponentPredictionAlpha(ComponentID compID)
Definition: TComDataCU.h:242
#define DEBUG_STRING_FN_DECLAREP(name)
Definition: TypeDef.h:183
static const Int MAX_TU_SIZE
Definition: CommonDef.h:224
estBitsSbacStruct * m_pcEstBitsSbac
Definition: TComTrQuant.h:155
static Void crossComponentPrediction(TComTU &rTu, const ComponentID compID, const Pel *piResiL, const Pel *piResiC, Pel *piResiT, const Int width, const Int height, const Int strideL, const Int strideC, const Int strideT, const Bool reverse)
UChar * getTransformIdx()
Definition: TComDataCU.h:277
const TMatrixCoeff g_aiT4[TRANSFORM_NUMBER_OF_DIRECTIONS][4][4]
Definition: TComRom.cpp:489
Int lastXBits[MAX_NUM_CHANNEL_TYPE][LAST_SIGNIFICANT_GROUPS]
Definition: TComTrQuant.h:64
__inline Double xGetICost(Double dRate) const
Void applyForwardRDPCM(TComTU &rTu, const ComponentID compID, Pel *pcResidual, const UInt uiStride, const QpParam &cQP, TCoeff *pcCoeff, TCoeff &uiAbsSum, const RDPCMMode mode)
Double d64CodedLevelandDist
Definition: TComTrQuant.cpp:51
#define NULL
Definition: CommonDef.h:107
Bool m_useTransformSkipFast
Definition: TComTrQuant.h:223
QpParam(const Int qpy, const ChannelType chType, const Int qpBdOffset, const Int chromaQPOffset, const ChromaFormat chFmt)
Definition: TComTrQuant.cpp:71
Int blockCbpBits[2 *5][2]
Definition: TComTrQuant.h:69
const ChromaQpAdj & getChromaQpOffsetListEntry(Int cuChromaQpOffsetIdxPlus1) const
Definition: TComSlice.h:1012
static const Int MLS_GRP_NUM
Max number of coefficient groups, max(16, 64)
Definition: CommonDef.h:168
Void partialButterfly16(TCoeff *src, TCoeff *dst, Int shift, Int line)
unsigned int UInt
Definition: TypeDef.h:212
Double m_sliceSumC[LEVEL_RANGE+1]
Definition: TComTrQuant.h:205
SChar * getPredictionMode()
Definition: TComDataCU.h:237
Void setExplicitRdpcmModePartRange(UInt rdpcmMode, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes)
static const Int LEVEL_RANGE
G382: max coefficient level in statistics collection.
Definition: CommonDef.h:175
Void xQuant(TComTU &rTu, TCoeff *pSrc, TCoeff *pDes, TCoeff *pArlDes, TCoeff &uiAbsSum, const ComponentID compID, const QpParam &cQP)
Void partialButterflyInverse32(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
Short Pel
pixel type
Definition: TypeDef.h:249
SCALING_LIST class.
Definition: TComSlice.h:150
Void xITransformSkip(TCoeff *plCoef, Pel *pResidual, UInt uiStride, TComTU &rTu, const ComponentID component)
Int blockRootCbpBits[4][2]
Definition: TComTrQuant.h:70
Int * getDequantCoeff(UInt list, Int qp, UInt size)
get Quant Coefficent
Definition: TComTrQuant.h:179
Void setCbfPartRange(UInt uiCbf, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes)
static const Int SCALING_LIST_BITS
bit depth of scaling list entries
Definition: CommonDef.h:237
static const Int MAX_MATRIX_SIZE_NUM
max size number for quantization matrix
Definition: CommonDef.h:236
__inline Int xGetICRate(const UInt uiAbsLevel, const UShort ui16CtxNumOne, const UShort ui16CtxNumAbs, const UShort ui16AbsGoRice, const UInt c1Idx, const UInt c2Idx, const Bool useLimitedPrefixLength, const Int maxLog2TrDynamicRange) const
UInt getStride(const ComponentID id) const
Definition: TComYuv.h:199
Int * getQuantCoeff(UInt list, Int qp, UInt size)
get Error Scale Coefficent
Definition: TComTrQuant.h:178
UInt GetTransformDepthRel() const
Definition: TComTU.h:108
static const Int IQUANT_SHIFT
Definition: CommonDef.h:229
picture class (header)
Void init(UInt uiMaxTrSize, Bool useRDOQ=false, Bool useRDOQTS=false, Bool useSelectiveRDOQ=false, Bool bEnc=false, Bool useTransformSkipFast=false, Bool bUseAdaptQpSelect=false)
UChar getCbf(UInt uiIdx, ComponentID eType) const
Definition: TComDataCU.h:307
QP struct.
Definition: TComTrQuant.h:80
Bool nextSection(const TComTU &parent)
Definition: TComTU.cpp:178
Int getScalingListDC(UInt sizeId, UInt listId) const
get DC value
Definition: TComSlice.h:166
Void xDeQuant(TComTU &rTu, const TCoeff *pSrc, TCoeff *pDes, const ComponentID compID, const QpParam &cQP)
Int recon[MAX_NUM_CHANNEL_TYPE]
the bit depth as indicated in the SPS
Definition: TypeDef.h:793
Int rem
Definition: TComTrQuant.h:84
UInt GetSectionNumber() const
Definition: TComTU.h:101
UInt getMaxTrSize() const
Definition: TComSlice.h:891
Bool getSignDataHidingEnabledFlag() const
Definition: TComSlice.h:1168
static UInt getSigCoeffGroupCtxInc(const UInt *uiSigCoeffGroupFlag, const UInt uiCGPosX, const UInt uiCGPosY, const UInt widthInGroups, const UInt heightInGroups)
Int m_greaterOneBits[((4 *4)+(4 *2))][2]
Definition: TComTrQuant.h:66
Bool isInter(UInt uiPartIdx) const
Definition: TComDataCU.h:451
TComPicYuv * getPicYuvRec()
Definition: TComPic.h:120
UInt GetAbsPartIdxTU() const
Definition: TComTU.h:119
const UInt * scanCG
Definition: TypeDef.h:811
RDPCMMode
Definition: TypeDef.h:267
#define NUM_ONE_FLAG_CTX_PER_SET
number of context models for greater than 1 flag in a set
Short TMatrixCoeff
transform matrix coefficient
Definition: TypeDef.h:251
Void partialButterfly8(TCoeff *src, TCoeff *dst, Int shift, Int line)
UInt getMaxTotalCUDepth() const
Definition: TComSlice.h:861
#define NEIGHBOURHOOD_00_CONTEXT_1_THRESHOLD_4x4
Definition: ContextTables.h:92
Int significantBits[(28+16)][2]
Definition: TComTrQuant.h:63
TCoeff * m_plTempCoeff
Definition: TComTrQuant.h:207
Void storeSliceQpNext(TComSlice *pcSlice)
Double m_dLambda
Definition: TComTrQuant.h:213
UChar * getIntraDir(const ChannelType channelType) const
Definition: TComDataCU.h:342
Int Intermediate_Int
used as intermediate value in calculations
Definition: TypeDef.h:253
static UInt getCBFContextOffset(const ComponentID component)
Int offset[2]
Definition: TComSlice.h:431
UInt getGolombRiceStatisticsIndex(const ComponentID compID)
Definition: TComTU.cpp:245
Int golombRiceAdaptationStatistics[RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS]
Definition: TComTrQuant.h:72
static const Int QUANT_SHIFT
Q(4) = 2^14.
Definition: CommonDef.h:228
general YUV buffer class
Definition: TComYuv.h:54
Int getQpBDOffset(ChannelType type) const
Definition: TComSlice.h:904
Double & getErrScaleCoeffNoScalingList(UInt list, UInt size, Int qp)
get Error Scale Coefficent
Definition: TComTrQuant.h:177
Double * getErrScaleCoeff(UInt list, UInt size, Int qp)
Definition: TComTrQuant.h:176
static const Int MLS_CG_LOG2_WIDTH
Definition: CommonDef.h:169
bool Bool
Definition: TypeDef.h:204
Void transformSkipQuantOneSample(TComTU &rTu, const ComponentID compID, const TCoeff resiDiff, TCoeff *pcCoeff, const UInt uiPos, const QpParam &cQP, const Bool bUseHalfRoundingPoint)
Bool isIntra(UInt uiPartIdx) const
Definition: TComDataCU.h:450
Void invRdpcmNxN(TComTU &rTu, const ComponentID compID, Pel *pcResidual, const UInt uiStride)
long long Int64
Definition: TypeDef.h:232
Void initScalingList()
#define ADAPTIVE_QP_SELECTION
G382: Adaptive reconstruction levels, non-normative part for adaptive QP selection.
Definition: TypeDef.h:112
static const Int VER_IDX
index for intra VERTICAL mode
Definition: CommonDef.h:184
Bool m_bUseAdaptQpSelect
Definition: TComTrQuant.h:221
__inline Double xGetRateLast(const UInt uiPosX, const UInt uiPosY, const ComponentID component) const
static const Int RExt__GOLOMB_RICE_INCREMENT_DIVISOR
Definition: CommonDef.h:214
Void processScalingListDec(const Int *coeff, Int *dequantcoeff, Int invQuantScales, UInt height, UInt width, UInt ratio, Int sizuNum, UInt dc)
Bool isRDPCMEnabled(UInt uiAbsPartIdx) const
Definition: TComDataCU.h:290
static const Int C2FLAG_NUMBER
Definition: CommonDef.h:161
UInt GetEquivalentLog2TrSize(const ComponentID compID) const
Definition: TComTU.cpp:221
static const Int MAX_INT
max. value of signed 32-bit integer
Definition: CommonDef.h:115
Void getTUEntropyCodingParameters(TUEntropyCodingParameters &result, TComTU &rTu, const ComponentID component)
static const Int LOG2_SCALING_LIST_NEUTRAL_VALUE
log2 of the value that, when used in a scaling list, has no effect on quantisation ...
Definition: CommonDef.h:238
static ChannelType toChannelType(const ComponentID id)
Void partialButterfly32(TCoeff *src, TCoeff *dst, Int shift, Int line)
T Clip3(const T minVal, const T maxVal, const T a)
general min/max clip
Definition: CommonDef.h:252
Defines constants and tables for SBAC.
#define DEBUG_STRING_APPEND(str1, str2)
Definition: TypeDef.h:186
TComPicYuv * getPicYuvOrg()
Definition: TComPic.h:119
Int getBitDepth(ChannelType type) const
Definition: TComSlice.h:894
ValueType rightShift(const ValueType value, const Int shift)
Definition: CommonDef.h:281
Int TCoeff
transform coefficient
Definition: TypeDef.h:250
Int * m_quantCoef[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM][SCALING_LIST_REM_NUM]
array of quantization matrix coefficient 4x4
Definition: TComTrQuant.h:227
Int getDifferentialLumaChromaBitDepth() const
Definition: TComSlice.h:903
Pel * getAddr(const ComponentID id)
Definition: TComYuv.h:150
__inline Double xGetRateSigCoeffGroup(UShort uiSignificanceCoeffGroup, UShort ui16CtxNumSig) const
Void partialButterflyInverse4(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
Int getSliceQpBase() const
Definition: TComSlice.h:1360
Void xSetScalingListEnc(TComScalingList *scalingList, UInt list, UInt size, Int qp)
Void fastInverseDst(TCoeff *tmp, TCoeff *block, Int shift, const TCoeff outputMinimum, const TCoeff outputMaximum)
ChromaFormat
chroma formats (according to semantics of chroma_format_idc)
Definition: TypeDef.h:292
const Int g_invQuantScales[SCALING_LIST_REM_NUM]
Definition: TComRom.cpp:359
UInt getCoefficientOffset(const ComponentID compID) const
Definition: TComTU.h:94
Int per
Definition: TComTrQuant.h:83
__inline Double xGetRateSigCoef(UShort uiSignificance, UShort ui16CtxNumSig) const
const TComRectangle & getRect(const ComponentID compID) const
Definition: TComTU.h:96
Int getMaxLog2TrDynamicRange(ChannelType channelType) const
Definition: TComSlice.h:901
Void partialButterflyInverse16(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
const UInt g_scalingListSize[SCALING_LIST_SIZE_NUM]
Definition: TComRom.cpp:692
const TComPPS * getPPS() const
Definition: TComSlice.h:1332
static const UInt significanceMapContextSetStart[MAX_NUM_CHANNEL_TYPE][CONTEXT_NUMBER_OF_TYPES]
Definition: ContextTables.h:85
#define DEBUG_STRING_PASS_INTO(name)
Definition: TypeDef.h:180
Void signBitHidingHDQ(TCoeff *pQCoef, TCoeff *pCoef, TCoeff *deltaU, const TUEntropyCodingParameters &codingParameters, const Int maxLog2TrDynamicRange)
Bool getUseScalingList(const UInt width, const UInt height, const Bool isTransformSkip)
Definition: TComTrQuant.h:181
UChar * getTransformSkip(ComponentID compID)
Definition: TComDataCU.h:281
ChromaFormat getChromaFormat() const
Definition: TComPic.h:139
__inline Double xGetIEPRate() const
TComDataCU * getCU()
Definition: TComTU.h:126
Void setErrScaleCoeff(UInt list, UInt size, Int qp, const Int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths)
Void rdpcmNxN(TComTU &rTu, const ComponentID compID, Pel *pcResidual, const UInt uiStride, const QpParam &cQP, TCoeff *pcCoeff, TCoeff &uiAbsSum, RDPCMMode &rdpcmMode)
Bool ProcessComponentSection(const ComponentID compID) const
Definition: TComTU.h:99
Void invTrSkipDeQuantOneSample(TComTU &rTu, ComponentID compID, TCoeff pcCoeff, Pel &reconSample, const QpParam &cQP, UInt uiPos)
Void invTransformNxN(TComTU &rTu, const ComponentID compID, Pel *pcResidual, const UInt uiStride, TCoeff *pcCoeff, const QpParam &cQP)
const TMatrixCoeff g_aiT32[TRANSFORM_NUMBER_OF_DIRECTIONS][32][32]
Definition: TComRom.cpp:507
COEFF_SCAN_TYPE scanType
Definition: TypeDef.h:812
Int getLog2DiffMaxMinCodingBlockSize() const
Definition: TComSlice.h:853
const TMatrixCoeff g_aiT8[TRANSFORM_NUMBER_OF_DIRECTIONS][8][8]
Definition: TComRom.cpp:495
Bool * getCUTransquantBypass()
Definition: TComDataCU.h:245
__inline UInt xGetCodedLevel(Double &rd64CodedCost, Double &rd64CodedCost0, Double &rd64CodedCostSig, Intermediate_Int lLevelDouble, UInt uiMaxAbsLevel, UShort ui16CtxNumSig, UShort ui16CtxNumOne, UShort ui16CtxNumAbs, UShort ui16AbsGoRice, UInt c1Idx, UInt c2Idx, Int iQBits, Double errorScale, Bool bLast, Bool useLimitedPrefixLength, const Int maxLog2TrDynamicRange) const
Void xTransformSkip(Pel *piBlkResi, UInt uiStride, TCoeff *psCoeff, TComTU &rTu, const ComponentID component)
UInt GetAbsPartIdxNumParts() const
Definition: TComTU.h:121
TComPic * getPic()
Definition: TComDataCU.h:200
Void initSliceQpDelta()
Definition: TComTU.h:48
#define RDOQ_CHROMA
use of RDOQ in chroma
Definition: TComTrQuant.cpp:64
Void processScalingListEnc(Int *coeff, Int *quantcoeff, Int quantScales, UInt height, UInt width, UInt ratio, Int sizuNum, UInt dc)
const UChar g_chroma422IntraAngleMappingTable[NUM_INTRA_MODE]
Definition: TComRom.cpp:564
const UInt g_uiGroupIdx[MAX_TU_SIZE]
Definition: TComRom.cpp:598
const UInt ctxIndMap4x4[4 *4]
Definition: TComRom.cpp:589
static const Int MAX_CU_SIZE
= 1&lt;&lt;(MAX_CU_DEPTH)
Definition: CommonDef.h:221
Int getQpOffset(ComponentID compID) const
Definition: TComSlice.h:1124
const TMatrixCoeff g_as_DST_MAT_4[TRANSFORM_NUMBER_OF_DIRECTIONS][4][4]
Definition: TComRom.cpp:513
static const Int SCALE_BITS
For fractional bit estimates in RDOQ.
Definition: CommonDef.h:230
static const Double MAX_DOUBLE
max. value of Double-type value
Definition: CommonDef.h:116
static Int calcPatternSigCtx(const UInt *sigCoeffGroupFlag, UInt uiCGPosX, UInt uiCGPosY, UInt widthInGroups, UInt heightInGroups)
Void xIT(const Int channelBitDepth, Bool useDST, TCoeff *plCoef, Pel *pResidual, UInt uiStride, Int iWidth, Int iHeight, const Int maxLog2TrDynamicRange)
Int significantCoeffGroupBits[2][2]
Definition: TComTrQuant.h:62
UInt getCtxQtCbf(TComTU &rTu, const ChannelType chType) const
static UInt getSignificanceMapContextOffset(const ComponentID component)
static const Int MLS_CG_SIZE
Coefficient group size of 4x4; = MLS_CG_LOG2_WIDTH + MLS_CG_LOG2_HEIGHT.
Definition: CommonDef.h:171
Bool m_useSelectiveRDOQ
Definition: TComTrQuant.h:219
#define DISTORTION_PRECISION_ADJUSTMENT(x)
Definition: TypeDef.h:164
Void clearSliceARLCnt()
UInt g_debugCounter
Definition: Debug.cpp:193
const UInt g_scalingListSizeX[SCALING_LIST_SIZE_NUM]
Definition: TComRom.cpp:693
static const Int chromaQPMappingTableSize
Definition: TComRom.h:94
TCoeff * getCoeff(ComponentID component)
Definition: TComDataCU.h:300
Void xsetFlatScalingList(UInt list, UInt size, Int qp)
static const Int MLS_CG_LOG2_HEIGHT
Definition: CommonDef.h:170
int Int
Definition: TypeDef.h:211
Int m_levelAbsBits[((1 *4)+(1 *2))][2]
Definition: TComTrQuant.h:67
static Bool isChroma(const ComponentID id)
static Int getTransformShift(const Int channelBitDepth, const UInt uiLog2TrSize, const Int maxLog2TrDynamicRange)
Void partialButterfly4(TCoeff *src, TCoeff *dst, Int shift, Int line)
ComponentID
Definition: TypeDef.h:308
Int getSliceChromaQpDelta(ComponentID compID) const
Definition: TComSlice.h:1363
Int getSliceQp() const
Definition: TComSlice.h:1355
Void xRateDistOptQuant(TComTU &rTu, TCoeff *plSrcCoeff, TCoeff *piDstCoeff, TCoeff *piArlDstCoeff, TCoeff &uiAbsSum, const ComponentID compID, const QpParam &cQP)
transform and quantization class (header)
SChar * getQP()
Definition: TComDataCU.h:258
Bool isNonTransformedResidualRotated(const ComponentID compID)
Definition: TComTU.cpp:236
Void invRecurTransformNxN(const ComponentID compID, TComYuv *pResidual, TComTU &rTu)
Void printBlock(const ValueType *const source, const UInt width, const UInt height, const UInt stride, const UInt outputValueWidth=0, const Bool onlyPrintEdges=false, const Bool printInZScan=false, const Int shiftLeftBy=0, const Bool printAverage=false, std::ostream &stream=std::cout)
Definition: Debug.h:158
double Double
Definition: TypeDef.h:213
static UInt getContextSetIndex(const ComponentID component, const UInt subsetIndex, const Bool foundACoefficientGreaterThan1)
vertical first scan
Definition: TypeDef.h:477
slice header class
Definition: TComSlice.h:1225
Void setScalingListDec(const TComScalingList &scalingList)
static const Int MAX_QP
Definition: CommonDef.h:126
Void transformNxN(TComTU &rTu, const ComponentID compID, Pel *pcResidual, const UInt uiStride, TCoeff *rpcCoeff, TCoeff *rpcArlCoeff, TCoeff &uiAbsSum, const QpParam &cQP)
UChar * getChromaQpAdj()
array of chroma QP adjustments (indexed). when value = 0, cu_chroma_qp_offset_flag=0; when value&gt;0...
Definition: TComDataCU.h:268
Void fastForwardDst(TCoeff *block, TCoeff *coeff, Int shift)
static const Int COEF_REMAIN_BIN_REDUCTION
indicates the level at which the VLC transitions from Golomb-Rice to TU+EG(k)
Definition: CommonDef.h:153
Int Qp
Definition: TComTrQuant.h:82
#define NUM_ABS_FLAG_CTX_PER_SET
number of context models for greater than 2 flag in a set
#define DEBUG_STRING_NEW(name)
Definition: TypeDef.h:184
Void printBlockToStream(std::ostream &ss, const TChar *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross, const UInt numSubBlocksUp, const UInt defWidth)
Definition: Debug.cpp:422
Defines types and objects for environment-variable-based debugging and feature control.
Void xSetScalingListDec(const TComScalingList &scalingList, UInt list, UInt size, Int qp)
Void xT(const Int channelBitDepth, Bool useDST, Pel *piBlkResi, UInt uiStride, TCoeff *psCoeff, Int iWidth, Int iHeight, const Int maxLog2TrDynamicRange)
Bool getExtendedPrecisionProcessingFlag() const
Definition: TComSlice.h:723
static Bool isLuma(const ComponentID id)
TComSlice * getSlice()
Definition: TComDataCU.h:202
Bool m_useRDOQTS
Definition: TComTrQuant.h:218
const TComSPS * getSPS() const
Definition: TComSlice.h:1329
SPS class.
Definition: TComSlice.h:740
static const Int SBH_THRESHOLD
value of the fixed SBH controlling threshold
Definition: CommonDef.h:158
static const Int C1FLAG_NUMBER
Definition: CommonDef.h:160
ChromaFormat getChromaFormat() const
Definition: TComPicYuv.h:118