source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComRom.cpp

Last change on this file was 1413, checked in by tech, 6 years ago

Merged HTM-16.2-dev@1412

  • Property svn:eol-style set to native
File size: 39.9 KB
RevLine 
[5]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
[1313]4 * granted under this license.
[5]5 *
[1413]6 * Copyright (c) 2010-2017, ITU/ISO/IEC
[5]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.
[56]17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
[5]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 */
[2]33/** \file     TComRom.cpp
34    \brief    global variables & functions
35*/
36#include "TComRom.h"
37#include <memory.h>
38#include <stdlib.h>
39#include <stdio.h>
[1313]40#include <iomanip>
41#include <assert.h>
42#include "TComDataCU.h"
43#include "Debug.h"
[2]44// ====================================================================================================================
45// Initialize / destroy functions
46// ====================================================================================================================
[56]47//! \ingroup TLibCommon
48//! \{
[1386]49const TChar* nalUnitTypeToString(NalUnitType type)
[1313]50{
51  switch (type)
52  {
53  case NAL_UNIT_CODED_SLICE_TRAIL_R:    return "TRAIL_R";
54  case NAL_UNIT_CODED_SLICE_TRAIL_N:    return "TRAIL_N";
55  case NAL_UNIT_CODED_SLICE_TSA_R:      return "TSA_R";
56  case NAL_UNIT_CODED_SLICE_TSA_N:      return "TSA_N";
57  case NAL_UNIT_CODED_SLICE_STSA_R:     return "STSA_R";
58  case NAL_UNIT_CODED_SLICE_STSA_N:     return "STSA_N";
59  case NAL_UNIT_CODED_SLICE_BLA_W_LP:   return "BLA_W_LP";
60  case NAL_UNIT_CODED_SLICE_BLA_W_RADL: return "BLA_W_RADL";
61  case NAL_UNIT_CODED_SLICE_BLA_N_LP:   return "BLA_N_LP";
62  case NAL_UNIT_CODED_SLICE_IDR_W_RADL: return "IDR_W_RADL";
63  case NAL_UNIT_CODED_SLICE_IDR_N_LP:   return "IDR_N_LP";
64  case NAL_UNIT_CODED_SLICE_CRA:        return "CRA";
65  case NAL_UNIT_CODED_SLICE_RADL_R:     return "RADL_R";
66  case NAL_UNIT_CODED_SLICE_RADL_N:     return "RADL_N";
67  case NAL_UNIT_CODED_SLICE_RASL_R:     return "RASL_R";
68  case NAL_UNIT_CODED_SLICE_RASL_N:     return "RASL_N";
69  case NAL_UNIT_VPS:                    return "VPS";
70  case NAL_UNIT_SPS:                    return "SPS";
71  case NAL_UNIT_PPS:                    return "PPS";
72  case NAL_UNIT_ACCESS_UNIT_DELIMITER:  return "AUD";
73  case NAL_UNIT_EOS:                    return "EOS";
74  case NAL_UNIT_EOB:                    return "EOB";
75  case NAL_UNIT_FILLER_DATA:            return "FILLER";
76  case NAL_UNIT_PREFIX_SEI:             return "Prefix SEI";
77  case NAL_UNIT_SUFFIX_SEI:             return "Suffix SEI";
78  default:                              return "UNK";
79  }
80}
81class ScanGenerator
82{
83private:
84  UInt m_line, m_column;
85  const UInt m_blockWidth, m_blockHeight;
86  const UInt m_stride;
87  const COEFF_SCAN_TYPE m_scanType;
88public:
89  ScanGenerator(UInt blockWidth, UInt blockHeight, UInt stride, COEFF_SCAN_TYPE scanType)
90    : m_line(0), m_column(0), m_blockWidth(blockWidth), m_blockHeight(blockHeight), m_stride(stride), m_scanType(scanType)
91  { }
92  UInt GetCurrentX() const { return m_column; }
93  UInt GetCurrentY() const { return m_line; }
94  UInt GetNextIndex(UInt blockOffsetX, UInt blockOffsetY)
95  {
96    Int rtn=((m_line + blockOffsetY) * m_stride) + m_column + blockOffsetX;
97    //advance line and column to the next position
98    switch (m_scanType)
99    {
100      //------------------------------------------------
101      case SCAN_DIAG:
102        {
103          if ((m_column == (m_blockWidth - 1)) || (m_line == 0)) //if we reach the end of a rank, go diagonally down to the next one
104          {
105            m_line   += m_column + 1;
106            m_column  = 0;
107            if (m_line >= m_blockHeight) //if that takes us outside the block, adjust so that we are back on the bottom row
108            {
109              m_column += m_line - (m_blockHeight - 1);
110              m_line    = m_blockHeight - 1;
111            }
112          }
113          else
114          {
115            m_column++;
116            m_line--;
117          }
118        }
119        break;
120      //------------------------------------------------
121      case SCAN_HOR:
122        {
123          if (m_column == (m_blockWidth - 1))
124          {
125            m_line++;
126            m_column = 0;
127          }
128          else
129          {
130            m_column++;
131          }
132        }
133        break;
134      //------------------------------------------------
135      case SCAN_VER:
136        {
137          if (m_line == (m_blockHeight - 1))
138          {
139            m_column++;
140            m_line = 0;
141          }
142          else
143          {
144            m_line++;
145          }
146        }
147        break;
148      //------------------------------------------------
149      default:
150        {
151          std::cerr << "ERROR: Unknown scan type \"" << m_scanType << "\"in ScanGenerator::GetNextIndex" << std::endl;
152          exit(1);
153        }
154        break;
155    }
156    return rtn;
157  }
158};
[2]159// initialize ROM variables
160Void initROM()
161{
162  Int i, c;
163  // g_aucConvertToBit[ x ]: log2(x/4), if x=4 -> 0, x=8 -> 1, x=16 -> 2, ...
164  ::memset( g_aucConvertToBit,   -1, sizeof( g_aucConvertToBit ) );
165  c=0;
[655]166  for ( i=4; i<=MAX_CU_SIZE; i*=2 )
[2]167  {
168    g_aucConvertToBit[ i ] = c;
169    c++;
170  }
[1313]171  // initialise scan orders
172  for(UInt log2BlockHeight = 0; log2BlockHeight < MAX_CU_DEPTH; log2BlockHeight++)
[2]173  {
[1313]174    for(UInt log2BlockWidth = 0; log2BlockWidth < MAX_CU_DEPTH; log2BlockWidth++)
175    {
176      const UInt blockWidth  = 1 << log2BlockWidth;
177      const UInt blockHeight = 1 << log2BlockHeight;
178      const UInt totalValues = blockWidth * blockHeight;
179      //--------------------------------------------------------------------------------------------------
180      //non-grouped scan orders
181      for (UInt scanTypeIndex = 0; scanTypeIndex < SCAN_NUMBER_OF_TYPES; scanTypeIndex++)
182      {
183        const COEFF_SCAN_TYPE scanType = COEFF_SCAN_TYPE(scanTypeIndex);
184        g_scanOrder[SCAN_UNGROUPED][scanType][log2BlockWidth][log2BlockHeight] = new UInt[totalValues];
185        ScanGenerator fullBlockScan(blockWidth, blockHeight, blockWidth, scanType);
186        for (UInt scanPosition = 0; scanPosition < totalValues; scanPosition++)
187        {
188          g_scanOrder[SCAN_UNGROUPED][scanType][log2BlockWidth][log2BlockHeight][scanPosition] = fullBlockScan.GetNextIndex(0, 0);
189        }
190      }
191      //--------------------------------------------------------------------------------------------------
192      //grouped scan orders
193      const UInt  groupWidth           = 1           << MLS_CG_LOG2_WIDTH;
194      const UInt  groupHeight          = 1           << MLS_CG_LOG2_HEIGHT;
195      const UInt  widthInGroups        = blockWidth  >> MLS_CG_LOG2_WIDTH;
196      const UInt  heightInGroups       = blockHeight >> MLS_CG_LOG2_HEIGHT;
197      const UInt  groupSize            = groupWidth    * groupHeight;
198      const UInt  totalGroups          = widthInGroups * heightInGroups;
199      for (UInt scanTypeIndex = 0; scanTypeIndex < SCAN_NUMBER_OF_TYPES; scanTypeIndex++)
200      {
201        const COEFF_SCAN_TYPE scanType = COEFF_SCAN_TYPE(scanTypeIndex);
202        g_scanOrder[SCAN_GROUPED_4x4][scanType][log2BlockWidth][log2BlockHeight] = new UInt[totalValues];
203        ScanGenerator fullBlockScan(widthInGroups, heightInGroups, groupWidth, scanType);
204        for (UInt groupIndex = 0; groupIndex < totalGroups; groupIndex++)
205        {
206          const UInt groupPositionY  = fullBlockScan.GetCurrentY();
207          const UInt groupPositionX  = fullBlockScan.GetCurrentX();
208          const UInt groupOffsetX    = groupPositionX * groupWidth;
209          const UInt groupOffsetY    = groupPositionY * groupHeight;
210          const UInt groupOffsetScan = groupIndex     * groupSize;
211          ScanGenerator groupScan(groupWidth, groupHeight, blockWidth, scanType);
212          for (UInt scanPosition = 0; scanPosition < groupSize; scanPosition++)
213          {
214            g_scanOrder[SCAN_GROUPED_4x4][scanType][log2BlockWidth][log2BlockHeight][groupOffsetScan + scanPosition] = groupScan.GetNextIndex(groupOffsetX, groupOffsetY);
215          }
216          fullBlockScan.GetNextIndex(0,0);
217        }
218      }
219      //--------------------------------------------------------------------------------------------------
220    }
221  }
222#if NH_MV
[1386]223#if NH_MV_HLS_PTL_LIMITS
[1321]224 g_generalTierAndLevelLimits[ Level::LEVEL1   ] = TComGeneralTierAndLevelLimits(    36864,     350,  MIN_INT,   16,   1,   1 );
225 g_generalTierAndLevelLimits[ Level::LEVEL2   ] = TComGeneralTierAndLevelLimits(   122880,    1500,  MIN_INT,   16,   1,   1 );
226 g_generalTierAndLevelLimits[ Level::LEVEL2_1 ] = TComGeneralTierAndLevelLimits(   245760,    3000,  MIN_INT,   20,   1,   1 );
227 g_generalTierAndLevelLimits[ Level::LEVEL3   ] = TComGeneralTierAndLevelLimits(   552960,    6000,  MIN_INT,   30,   2,   2 );
228 g_generalTierAndLevelLimits[ Level::LEVEL3_1 ] = TComGeneralTierAndLevelLimits(   983040,   10000,  MIN_INT,   40,   3,   3 );
[1066]229 g_generalTierAndLevelLimits[ Level::LEVEL4   ] = TComGeneralTierAndLevelLimits(  2228224,   12000,    30000,   75,   5,   5 );
230 g_generalTierAndLevelLimits[ Level::LEVEL4_1 ] = TComGeneralTierAndLevelLimits(  2228224,   20000,    50000,   75,   5,   5 );
231 g_generalTierAndLevelLimits[ Level::LEVEL5   ] = TComGeneralTierAndLevelLimits(  8912896,   25000,   100000,  200,  11,  10 );
232 g_generalTierAndLevelLimits[ Level::LEVEL5_1 ] = TComGeneralTierAndLevelLimits(  8912896,   40000,   160000,  200,  11,  10 );
233 g_generalTierAndLevelLimits[ Level::LEVEL5_2 ] = TComGeneralTierAndLevelLimits(  8912896,   60000,   240000,  200,  11,  10 );
234 g_generalTierAndLevelLimits[ Level::LEVEL6   ] = TComGeneralTierAndLevelLimits( 35651584,   60000,   240000,  600,  22,  20 );
235 g_generalTierAndLevelLimits[ Level::LEVEL6_1 ] = TComGeneralTierAndLevelLimits( 35651584,  120000,   480000,  600,  22,  20 );
236 g_generalTierAndLevelLimits[ Level::LEVEL6_2 ] = TComGeneralTierAndLevelLimits( 35651584,  240000,   800000,  600,  22,  20 );
237#endif
238#endif
[2]239}
240Void destroyROM()
241{
[1313]242  for(UInt groupTypeIndex = 0; groupTypeIndex < SCAN_NUMBER_OF_GROUP_TYPES; groupTypeIndex++)
[2]243  {
[1313]244    for (UInt scanOrderIndex = 0; scanOrderIndex < SCAN_NUMBER_OF_TYPES; scanOrderIndex++)
245    {
246      for (UInt log2BlockWidth = 0; log2BlockWidth < MAX_CU_DEPTH; log2BlockWidth++)
247      {
248        for (UInt log2BlockHeight = 0; log2BlockHeight < MAX_CU_DEPTH; log2BlockHeight++)
249        {
250          delete [] g_scanOrder[groupTypeIndex][scanOrderIndex][log2BlockWidth][log2BlockHeight];
251        }
252      }
253    }
[2]254  }
[1413]255#if NH_3D
[608]256  if( !g_dmmWedgeLists.empty() ) 
[2]257  {
[1313]258    for( UInt ui = 0; ui < g_dmmWedgeLists.size(); ui++ ) { g_dmmWedgeLists[ui].clear(); }
[608]259    g_dmmWedgeLists.clear();
[2]260  }
[608]261  if( !g_dmmWedgeNodeLists.empty() )
[189]262  {
[1313]263    for( UInt ui = 0; ui < g_dmmWedgeNodeLists.size(); ui++ ) { g_dmmWedgeNodeLists[ui].clear(); }
[608]264    g_dmmWedgeNodeLists.clear();
[189]265  }
[2]266#endif
267}
268// ====================================================================================================================
269// Data structure related table & variable
270// ====================================================================================================================
[1313]271UInt g_auiZscanToRaster [ MAX_NUM_PART_IDXS_IN_CTU_WIDTH*MAX_NUM_PART_IDXS_IN_CTU_WIDTH ] = { 0, };
272UInt g_auiRasterToZscan [ MAX_NUM_PART_IDXS_IN_CTU_WIDTH*MAX_NUM_PART_IDXS_IN_CTU_WIDTH ] = { 0, };
273UInt g_auiRasterToPelX  [ MAX_NUM_PART_IDXS_IN_CTU_WIDTH*MAX_NUM_PART_IDXS_IN_CTU_WIDTH ] = { 0, };
274UInt g_auiRasterToPelY  [ MAX_NUM_PART_IDXS_IN_CTU_WIDTH*MAX_NUM_PART_IDXS_IN_CTU_WIDTH ] = { 0, };
275const UInt g_auiPUOffset[NUMBER_OF_PART_SIZES] = { 0, 8, 4, 4, 2, 10, 1, 5};
[2]276Void initZscanToRaster ( Int iMaxDepth, Int iDepth, UInt uiStartVal, UInt*& rpuiCurrIdx )
277{
278  Int iStride = 1 << ( iMaxDepth - 1 );
279  if ( iDepth == iMaxDepth )
280  {
281    rpuiCurrIdx[0] = uiStartVal;
282    rpuiCurrIdx++;
283  }
284  else
285  {
286    Int iStep = iStride >> iDepth;
287    initZscanToRaster( iMaxDepth, iDepth+1, uiStartVal,                     rpuiCurrIdx );
288    initZscanToRaster( iMaxDepth, iDepth+1, uiStartVal+iStep,               rpuiCurrIdx );
289    initZscanToRaster( iMaxDepth, iDepth+1, uiStartVal+iStep*iStride,       rpuiCurrIdx );
290    initZscanToRaster( iMaxDepth, iDepth+1, uiStartVal+iStep*iStride+iStep, rpuiCurrIdx );
291  }
292}
293Void initRasterToZscan ( UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxDepth )
294{
295  UInt  uiMinCUWidth  = uiMaxCUWidth  >> ( uiMaxDepth - 1 );
296  UInt  uiMinCUHeight = uiMaxCUHeight >> ( uiMaxDepth - 1 );
297  UInt  uiNumPartInWidth  = (UInt)uiMaxCUWidth  / uiMinCUWidth;
298  UInt  uiNumPartInHeight = (UInt)uiMaxCUHeight / uiMinCUHeight;
299  for ( UInt i = 0; i < uiNumPartInWidth*uiNumPartInHeight; i++ )
300  {
301    g_auiRasterToZscan[ g_auiZscanToRaster[i] ] = i;
302  }
303}
304Void initRasterToPelXY ( UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxDepth )
305{
306  UInt    i;
307  UInt* uiTempX = &g_auiRasterToPelX[0];
308  UInt* uiTempY = &g_auiRasterToPelY[0];
309  UInt  uiMinCUWidth  = uiMaxCUWidth  >> ( uiMaxDepth - 1 );
310  UInt  uiMinCUHeight = uiMaxCUHeight >> ( uiMaxDepth - 1 );
311  UInt  uiNumPartInWidth  = uiMaxCUWidth  / uiMinCUWidth;
312  UInt  uiNumPartInHeight = uiMaxCUHeight / uiMinCUHeight;
313  uiTempX[0] = 0; uiTempX++;
314  for ( i = 1; i < uiNumPartInWidth; i++ )
315  {
316    uiTempX[0] = uiTempX[-1] + uiMinCUWidth; uiTempX++;
317  }
318  for ( i = 1; i < uiNumPartInHeight; i++ )
319  {
320    memcpy(uiTempX, uiTempX-uiNumPartInWidth, sizeof(UInt)*uiNumPartInWidth);
321    uiTempX += uiNumPartInWidth;
322  }
323  for ( i = 1; i < uiNumPartInWidth*uiNumPartInHeight; i++ )
324  {
325    uiTempY[i] = ( i / uiNumPartInWidth ) * uiMinCUWidth;
326  }
[1313]327}
328const Int g_quantScales[SCALING_LIST_REM_NUM] =
[2]329{
[56]330  26214,23302,20560,18396,16384,14564
[1313]331};
332const Int g_invQuantScales[SCALING_LIST_REM_NUM] =
[2]333{
[56]334  40,45,51,57,64,72
[2]335};
[1313]336//--------------------------------------------------------------------------------------------------
337//structures
338#define DEFINE_DST4x4_MATRIX(a,b,c,d) \
339{ \
340  {  a,  b,  c,  d }, \
341  {  c,  c,  0, -c }, \
342  {  d, -a, -c,  b }, \
343  {  b, -d,  c, -a }, \
344}
345#define DEFINE_DCT4x4_MATRIX(a,b,c) \
346{ \
347  { a,  a,  a,  a}, \
348  { b,  c, -c, -b}, \
349  { a, -a, -a,  a}, \
350  { c, -b,  b, -c}  \
351}
352#define DEFINE_DCT8x8_MATRIX(a,b,c,d,e,f,g) \
353{ \
354  { a,  a,  a,  a,  a,  a,  a,  a}, \
355  { d,  e,  f,  g, -g, -f, -e, -d}, \
356  { b,  c, -c, -b, -b, -c,  c,  b}, \
357  { e, -g, -d, -f,  f,  d,  g, -e}, \
358  { a, -a, -a,  a,  a, -a, -a,  a}, \
359  { f, -d,  g,  e, -e, -g,  d, -f}, \
360  { c, -b,  b, -c, -c,  b, -b,  c}, \
361  { g, -f,  e, -d,  d, -e,  f, -g}  \
362}
363#define DEFINE_DCT16x16_MATRIX(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
364{ \
365  { a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a}, \
366  { h,  i,  j,  k,  l,  m,  n,  o, -o, -n, -m, -l, -k, -j, -i, -h}, \
367  { d,  e,  f,  g, -g, -f, -e, -d, -d, -e, -f, -g,  g,  f,  e,  d}, \
368  { i,  l,  o, -m, -j, -h, -k, -n,  n,  k,  h,  j,  m, -o, -l, -i}, \
369  { b,  c, -c, -b, -b, -c,  c,  b,  b,  c, -c, -b, -b, -c,  c,  b}, \
370  { j,  o, -k, -i, -n,  l,  h,  m, -m, -h, -l,  n,  i,  k, -o, -j}, \
371  { e, -g, -d, -f,  f,  d,  g, -e, -e,  g,  d,  f, -f, -d, -g,  e}, \
372  { k, -m, -i,  o,  h,  n, -j, -l,  l,  j, -n, -h, -o,  i,  m, -k}, \
373  { a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a}, \
374  { l, -j, -n,  h, -o, -i,  m,  k, -k, -m,  i,  o, -h,  n,  j, -l}, \
375  { f, -d,  g,  e, -e, -g,  d, -f, -f,  d, -g, -e,  e,  g, -d,  f}, \
376  { m, -h,  l,  n, -i,  k,  o, -j,  j, -o, -k,  i, -n, -l,  h, -m}, \
377  { c, -b,  b, -c, -c,  b, -b,  c,  c, -b,  b, -c, -c,  b, -b,  c}, \
378  { n, -k,  h, -j,  m,  o, -l,  i, -i,  l, -o, -m,  j, -h,  k, -n}, \
379  { g, -f,  e, -d,  d, -e,  f, -g, -g,  f, -e,  d, -d,  e, -f,  g}, \
380  { o, -n,  m, -l,  k, -j,  i, -h,  h, -i,  j, -k,  l, -m,  n, -o}  \
381}
382#define DEFINE_DCT32x32_MATRIX(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E) \
383{ \
384  { a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a}, \
385  { p,  q,  r,  s,  t,  u,  v,  w,  x,  y,  z,  A,  B,  C,  D,  E, -E, -D, -C, -B, -A, -z, -y, -x, -w, -v, -u, -t, -s, -r, -q, -p}, \
386  { h,  i,  j,  k,  l,  m,  n,  o, -o, -n, -m, -l, -k, -j, -i, -h, -h, -i, -j, -k, -l, -m, -n, -o,  o,  n,  m,  l,  k,  j,  i,  h}, \
387  { q,  t,  w,  z,  C, -E, -B, -y, -v, -s, -p, -r, -u, -x, -A, -D,  D,  A,  x,  u,  r,  p,  s,  v,  y,  B,  E, -C, -z, -w, -t, -q}, \
388  { d,  e,  f,  g, -g, -f, -e, -d, -d, -e, -f, -g,  g,  f,  e,  d,  d,  e,  f,  g, -g, -f, -e, -d, -d, -e, -f, -g,  g,  f,  e,  d}, \
389  { r,  w,  B, -D, -y, -t, -p, -u, -z, -E,  A,  v,  q,  s,  x,  C, -C, -x, -s, -q, -v, -A,  E,  z,  u,  p,  t,  y,  D, -B, -w, -r}, \
390  { i,  l,  o, -m, -j, -h, -k, -n,  n,  k,  h,  j,  m, -o, -l, -i, -i, -l, -o,  m,  j,  h,  k,  n, -n, -k, -h, -j, -m,  o,  l,  i}, \
391  { s,  z, -D, -w, -p, -v, -C,  A,  t,  r,  y, -E, -x, -q, -u, -B,  B,  u,  q,  x,  E, -y, -r, -t, -A,  C,  v,  p,  w,  D, -z, -s}, \
392  { b,  c, -c, -b, -b, -c,  c,  b,  b,  c, -c, -b, -b, -c,  c,  b,  b,  c, -c, -b, -b, -c,  c,  b,  b,  c, -c, -b, -b, -c,  c,  b}, \
393  { t,  C, -y, -p, -x,  D,  u,  s,  B, -z, -q, -w,  E,  v,  r,  A, -A, -r, -v, -E,  w,  q,  z, -B, -s, -u, -D,  x,  p,  y, -C, -t}, \
394  { j,  o, -k, -i, -n,  l,  h,  m, -m, -h, -l,  n,  i,  k, -o, -j, -j, -o,  k,  i,  n, -l, -h, -m,  m,  h,  l, -n, -i, -k,  o,  j}, \
395  { u, -E, -t, -v,  D,  s,  w, -C, -r, -x,  B,  q,  y, -A, -p, -z,  z,  p,  A, -y, -q, -B,  x,  r,  C, -w, -s, -D,  v,  t,  E, -u}, \
396  { e, -g, -d, -f,  f,  d,  g, -e, -e,  g,  d,  f, -f, -d, -g,  e,  e, -g, -d, -f,  f,  d,  g, -e, -e,  g,  d,  f, -f, -d, -g,  e}, \
397  { v, -B, -p, -C,  u,  w, -A, -q, -D,  t,  x, -z, -r, -E,  s,  y, -y, -s,  E,  r,  z, -x, -t,  D,  q,  A, -w, -u,  C,  p,  B, -v}, \
398  { k, -m, -i,  o,  h,  n, -j, -l,  l,  j, -n, -h, -o,  i,  m, -k, -k,  m,  i, -o, -h, -n,  j,  l, -l, -j,  n,  h,  o, -i, -m,  k}, \
399  { w, -y, -u,  A,  s, -C, -q,  E,  p,  D, -r, -B,  t,  z, -v, -x,  x,  v, -z, -t,  B,  r, -D, -p, -E,  q,  C, -s, -A,  u,  y, -w}, \
400  { a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a}, \
401  { x, -v, -z,  t,  B, -r, -D,  p, -E, -q,  C,  s, -A, -u,  y,  w, -w, -y,  u,  A, -s, -C,  q,  E, -p,  D,  r, -B, -t,  z,  v, -x}, \
402  { l, -j, -n,  h, -o, -i,  m,  k, -k, -m,  i,  o, -h,  n,  j, -l, -l,  j,  n, -h,  o,  i, -m, -k,  k,  m, -i, -o,  h, -n, -j,  l}, \
403  { y, -s, -E,  r, -z, -x,  t,  D, -q,  A,  w, -u, -C,  p, -B, -v,  v,  B, -p,  C,  u, -w, -A,  q, -D, -t,  x,  z, -r,  E,  s, -y}, \
404  { f, -d,  g,  e, -e, -g,  d, -f, -f,  d, -g, -e,  e,  g, -d,  f,  f, -d,  g,  e, -e, -g,  d, -f, -f,  d, -g, -e,  e,  g, -d,  f}, \
405  { z, -p,  A,  y, -q,  B,  x, -r,  C,  w, -s,  D,  v, -t,  E,  u, -u, -E,  t, -v, -D,  s, -w, -C,  r, -x, -B,  q, -y, -A,  p, -z}, \
406  { m, -h,  l,  n, -i,  k,  o, -j,  j, -o, -k,  i, -n, -l,  h, -m, -m,  h, -l, -n,  i, -k, -o,  j, -j,  o,  k, -i,  n,  l, -h,  m}, \
407  { A, -r,  v, -E, -w,  q, -z, -B,  s, -u,  D,  x, -p,  y,  C, -t,  t, -C, -y,  p, -x, -D,  u, -s,  B,  z, -q,  w,  E, -v,  r, -A}, \
408  { c, -b,  b, -c, -c,  b, -b,  c,  c, -b,  b, -c, -c,  b, -b,  c,  c, -b,  b, -c, -c,  b, -b,  c,  c, -b,  b, -c, -c,  b, -b,  c}, \
409  { B, -u,  q, -x,  E,  y, -r,  t, -A, -C,  v, -p,  w, -D, -z,  s, -s,  z,  D, -w,  p, -v,  C,  A, -t,  r, -y, -E,  x, -q,  u, -B}, \
410  { n, -k,  h, -j,  m,  o, -l,  i, -i,  l, -o, -m,  j, -h,  k, -n, -n,  k, -h,  j, -m, -o,  l, -i,  i, -l,  o,  m, -j,  h, -k,  n}, \
411  { C, -x,  s, -q,  v, -A, -E,  z, -u,  p, -t,  y, -D, -B,  w, -r,  r, -w,  B,  D, -y,  t, -p,  u, -z,  E,  A, -v,  q, -s,  x, -C}, \
412  { g, -f,  e, -d,  d, -e,  f, -g, -g,  f, -e,  d, -d,  e, -f,  g,  g, -f,  e, -d,  d, -e,  f, -g, -g,  f, -e,  d, -d,  e, -f,  g}, \
413  { D, -A,  x, -u,  r, -p,  s, -v,  y, -B,  E,  C, -z,  w, -t,  q, -q,  t, -w,  z, -C, -E,  B, -y,  v, -s,  p, -r,  u, -x,  A, -D}, \
414  { o, -n,  m, -l,  k, -j,  i, -h,  h, -i,  j, -k,  l, -m,  n, -o, -o,  n, -m,  l, -k,  j, -i,  h, -h,  i, -j,  k, -l,  m, -n,  o}, \
415  { E, -D,  C, -B,  A, -z,  y, -x,  w, -v,  u, -t,  s, -r,  q, -p,  p, -q,  r, -s,  t, -u,  v, -w,  x, -y,  z, -A,  B, -C,  D, -E}  \
416}
417//--------------------------------------------------------------------------------------------------
418//coefficients
419#if RExt__HIGH_PRECISION_FORWARD_TRANSFORM
420const TMatrixCoeff g_aiT4 [TRANSFORM_NUMBER_OF_DIRECTIONS][4][4]   =
[2]421{
[1313]422  DEFINE_DCT4x4_MATRIX  (16384, 21266,  9224),
423  DEFINE_DCT4x4_MATRIX  (   64,    83,    36)
[2]424};
[1313]425const TMatrixCoeff g_aiT8 [TRANSFORM_NUMBER_OF_DIRECTIONS][8][8]   =
[2]426{
[1313]427  DEFINE_DCT8x8_MATRIX  (16384, 21266,  9224, 22813, 19244, 12769,  4563),
428  DEFINE_DCT8x8_MATRIX  (   64,    83,    36,    89,    75,    50,    18)
[2]429};
[1313]430const TMatrixCoeff g_aiT16[TRANSFORM_NUMBER_OF_DIRECTIONS][16][16] =
[2]431{
[1313]432  DEFINE_DCT16x16_MATRIX(16384, 21266,  9224, 22813, 19244, 12769,  4563, 23120, 22063, 20450, 17972, 14642, 11109,  6446,  2316),
433  DEFINE_DCT16x16_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9)
[2]434};
[1313]435const TMatrixCoeff g_aiT32[TRANSFORM_NUMBER_OF_DIRECTIONS][32][32] =
[2]436{
[1313]437  DEFINE_DCT32x32_MATRIX(16384, 21266,  9224, 22813, 19244, 12769,  4563, 23120, 22063, 20450, 17972, 14642, 11109,  6446,  2316, 23106, 22852, 22445, 21848, 20995, 19810, 18601, 17143, 15718, 13853, 11749,  9846,  7908,  5573,  3281,   946),
438  DEFINE_DCT32x32_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9,    90,    90,    88,    85,    82,    78,    73,    67,    61,    54,    46,    38,    31,    22,    13,     4)
[2]439};
[1313]440const TMatrixCoeff g_as_DST_MAT_4[TRANSFORM_NUMBER_OF_DIRECTIONS][4][4] =
[2]441{
[1313]442  DEFINE_DST4x4_MATRIX( 7424, 14081, 18893, 21505),
443  DEFINE_DST4x4_MATRIX(   29,    55,    74,    84)
[2]444};
[1313]445#else
446const TMatrixCoeff g_aiT4 [TRANSFORM_NUMBER_OF_DIRECTIONS][4][4]   =
[2]447{
[1313]448  DEFINE_DCT4x4_MATRIX  (   64,    83,    36),
449  DEFINE_DCT4x4_MATRIX  (   64,    83,    36)
[2]450};
[1313]451const TMatrixCoeff g_aiT8 [TRANSFORM_NUMBER_OF_DIRECTIONS][8][8]   =
452{
453  DEFINE_DCT8x8_MATRIX  (   64,    83,    36,    89,    75,    50,    18),
454  DEFINE_DCT8x8_MATRIX  (   64,    83,    36,    89,    75,    50,    18)
455};
456const TMatrixCoeff g_aiT16[TRANSFORM_NUMBER_OF_DIRECTIONS][16][16] =
457{
458  DEFINE_DCT16x16_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9),
459  DEFINE_DCT16x16_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9)
460};
461const TMatrixCoeff g_aiT32[TRANSFORM_NUMBER_OF_DIRECTIONS][32][32] =
462{
463  DEFINE_DCT32x32_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9,    90,    90,    88,    85,    82,    78,    73,    67,    61,    54,    46,    38,    31,    22,    13,     4),
464  DEFINE_DCT32x32_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9,    90,    90,    88,    85,    82,    78,    73,    67,    61,    54,    46,    38,    31,    22,    13,     4)
465};
466const TMatrixCoeff g_as_DST_MAT_4[TRANSFORM_NUMBER_OF_DIRECTIONS][4][4] =
467{
468  DEFINE_DST4x4_MATRIX(   29,    55,    74,    84),
469  DEFINE_DST4x4_MATRIX(   29,    55,    74,    84)
470};
471#endif
472//--------------------------------------------------------------------------------------------------
473#undef DEFINE_DST4x4_MATRIX
474#undef DEFINE_DCT4x4_MATRIX
475#undef DEFINE_DCT8x8_MATRIX
476#undef DEFINE_DCT16x16_MATRIX
477#undef DEFINE_DCT32x32_MATRIX
478//--------------------------------------------------------------------------------------------------
479const UChar g_aucChromaScale[NUM_CHROMA_FORMAT][chromaQPMappingTableSize]=
480{
481  //0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57
482  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
483  { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,29,30,31,32,33,33,34,34,35,35,36,36,37,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51 },
484  { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,51,51,51,51,51,51 },
485  { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,51,51,51,51,51,51 }
486};
[2]487// ====================================================================================================================
[1313]488// Intra prediction
[2]489// ====================================================================================================================
[1313]490const UChar g_aucIntraModeNumFast_UseMPM[MAX_CU_DEPTH] =
[2]491{
492  3,  //   2x2
493  8,  //   4x4
494  8,  //   8x8
[1313]495  3,  //  16x16
496  3,  //  32x32
497  3   //  64x64
[2]498};
[1313]499const UChar g_aucIntraModeNumFast_NotUseMPM[MAX_CU_DEPTH] =
[2]500{
501  3,  //   2x2
502  9,  //   4x4
503  9,  //   8x8
504  4,  //  16x16   33
505  4,  //  32x32   33
[655]506  5   //  64x64   33
[2]507};
[1313]508const UChar g_chroma422IntraAngleMappingTable[NUM_INTRA_MODE] =
509  //0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, DM
510  { 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20, 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31, DM_CHROMA_IDX};
[1413]511#if NH_3D
[56]512// ====================================================================================================================
[608]513// Depth coding modes
[56]514// ====================================================================================================================
[608]515const WedgeResolution g_dmmWedgeResolution[6] = 
[2]516{
[608]517  HALF_PEL,    //   4x4
518  HALF_PEL,    //   8x8
519  FULL_PEL,    //  16x16
[1039]520  FULL_PEL,    //  32x32
521  FULL_PEL,    //  64x64
522  FULL_PEL     // 128x128
[2]523};
[608]524const UChar g_dmm1TabIdxBits[6] =
525{ //2x2   4x4   8x8 16x16 32x32 64x64
[1124]526     0,    7,   10,   9,    9,   13 };
[1039]527Bool g_wedgePattern[32*32];
[608]528extern std::vector< std::vector<TComWedgelet> >   g_dmmWedgeLists;
529extern std::vector< std::vector<TComWedgeNode> >  g_dmmWedgeNodeLists;
[2]530#endif
531// ====================================================================================================================
[56]532// Misc.
[2]533// ====================================================================================================================
[1386]534SChar  g_aucConvertToBit  [ MAX_CU_SIZE+1 ];
[2]535#if ENC_DEC_TRACE
[1313]536FILE*  g_hTrace = NULL; // Set to NULL to open up a file. Set to stdout to use the current output
[2]537const Bool g_bEncDecTraceEnable  = true;
538const Bool g_bEncDecTraceDisable = false;
[1413]539Bool   g_HLSTraceEnable = true;
[2]540Bool   g_bJustDoIt = false;
541UInt64 g_nSymbolCounter = 0;
[1386]542#if NH_MV_ENC_DEC_TRAC
[1066]543Bool g_traceCU = false; 
544Bool g_tracePU = false; 
545Bool g_traceTU = false; 
[1179]546Bool g_disableNumbering = false; 
[608]547Bool g_disableHLSTrace = false; 
[1321]548UInt64 g_stopAtCounter       = 4660; 
549Bool g_traceCopyBack         = false; 
550Bool g_decTraceDispDer       = false; 
551Bool g_decTraceMvFromMerge   = false; 
552Bool g_decTracePicOutput     = false; 
[1313]553Bool g_startStopTrace          = false; 
[1321]554Bool g_outputPos             = false;   
555Bool g_traceCameraParameters = false; 
556Bool g_encNumberOfWrittenBits     = false; 
[1313]557Bool g_traceEncFracBits        = false; 
558Bool g_traceIntraSearchCost    = false; 
559Bool g_traceRDCost             = false; 
560Bool g_traceSAOCost            = false; 
561Bool g_traceModeCheck          = false; 
562UInt g_indent                  = false; 
[1321]563Bool g_decNumBitsRead          = false; 
564Bool g_traceMotionInfoBeforUniPred = false; 
565Bool g_traceMergeCandListConst = false; 
566Bool g_traceBitsRead          = false; 
567Bool g_traceSubPBMotion       = false; 
[2]568#endif
[608]569#endif
[2]570// ====================================================================================================================
571// Scanning order & context model mapping
572// ====================================================================================================================
573// scanning order table
[1313]574UInt* g_scanOrder[SCAN_NUMBER_OF_GROUP_TYPES][SCAN_NUMBER_OF_TYPES][ MAX_CU_DEPTH ][ MAX_CU_DEPTH ];
575const UInt ctxIndMap4x4[4*4] =
[2]576{
[1313]577  0, 1, 4, 5,
578  2, 3, 4, 5,
579  6, 6, 8, 8,
580  7, 7, 8, 8
[2]581};
[1313]582const UInt g_uiMinInGroup[ LAST_SIGNIFICANT_GROUPS ] = {0,1,2,3,4,6,8,12,16,24};
583const UInt g_uiGroupIdx[ MAX_TU_SIZE ]   = {0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9};
[1386]584const TChar *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
[56]585{
586  {
[1313]587    "INTRA4X4_LUMA",
588    "INTRA4X4_CHROMAU",
589    "INTRA4X4_CHROMAV",
590    "INTER4X4_LUMA",
591    "INTER4X4_CHROMAU",
592    "INTER4X4_CHROMAV"
593  },
[56]594  {
[1313]595    "INTRA8X8_LUMA",
596    "INTRA8X8_CHROMAU",
597    "INTRA8X8_CHROMAV",
598    "INTER8X8_LUMA",
599    "INTER8X8_CHROMAU",
600    "INTER8X8_CHROMAV"
601  },
[56]602  {
[1313]603    "INTRA16X16_LUMA",
604    "INTRA16X16_CHROMAU",
605    "INTRA16X16_CHROMAV",
606    "INTER16X16_LUMA",
607    "INTER16X16_CHROMAU",
608    "INTER16X16_CHROMAV"
609  },
[56]610  {
[1313]611   "INTRA32X32_LUMA",
612   "INTRA32X32_CHROMAU_FROM16x16_CHROMAU",
613   "INTRA32X32_CHROMAV_FROM16x16_CHROMAV",
614   "INTER32X32_LUMA",
615   "INTER32X32_CHROMAU_FROM16x16_CHROMAU",
616   "INTER32X32_CHROMAV_FROM16x16_CHROMAV"
617  },
618};
[1386]619const TChar *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
[1313]620{
[608]621  {
[1313]622  },
[608]623  {
[1313]624  },
[2]625  {
[1313]626    "INTRA16X16_LUMA_DC",
627    "INTRA16X16_CHROMAU_DC",
628    "INTRA16X16_CHROMAV_DC",
629    "INTER16X16_LUMA_DC",
630    "INTER16X16_CHROMAU_DC",
631    "INTER16X16_CHROMAV_DC"
632  },
[56]633  {
[1313]634    "INTRA32X32_LUMA_DC",
635    "INTRA32X32_CHROMAU_DC_FROM16x16_CHROMAU",
636    "INTRA32X32_CHROMAV_DC_FROM16x16_CHROMAV",
637    "INTER32X32_LUMA_DC",
638    "INTER32X32_CHROMAU_DC_FROM16x16_CHROMAU",
639    "INTER32X32_CHROMAV_DC_FROM16x16_CHROMAV"
640  },
641};
642const Int g_quantTSDefault4x4[4*4] =
[2]643{
[608]644  16,16,16,16,
645  16,16,16,16,
646  16,16,16,16,
647  16,16,16,16
[2]648};
[1313]649const Int g_quantIntraDefault8x8[8*8] =
[56]650{
651  16,16,16,16,17,18,21,24,
652  16,16,16,16,17,19,22,25,
653  16,16,17,18,20,22,25,29,
654  16,16,18,21,24,27,31,36,
655  17,17,20,24,30,35,41,47,
656  18,19,22,27,35,44,54,65,
657  21,22,25,31,41,54,70,88,
658  24,25,29,36,47,65,88,115
659};
[1313]660const Int g_quantInterDefault8x8[8*8] =
[56]661{
662  16,16,16,16,17,18,20,24,
663  16,16,16,17,18,20,24,25,
664  16,16,17,18,20,24,25,28,
665  16,17,18,20,24,25,28,33,
666  17,18,20,24,25,28,33,41,
667  18,20,24,25,28,33,41,54,
668  20,24,25,28,33,41,54,71,
669  24,25,28,33,41,54,71,91
670};
[1313]671const UInt g_scalingListSize   [SCALING_LIST_SIZE_NUM] = {16,64,256,1024};
672const UInt g_scalingListSizeX  [SCALING_LIST_SIZE_NUM] = { 4, 8, 16,  32};
[1386]673#if NH_MV_ENC_DEC_TRAC
[608]674#if ENC_DEC_TRACE
[1386]675Void tracePSHeader( const TChar* psName, Int layerId )
[1313]676{ 
677  if ( !g_disableHLSTrace  ) 
678  {
679    fprintf( g_hTrace, "=========== ");   
680    fprintf( g_hTrace, "%s", psName );   
681    fprintf( g_hTrace, " Layer %d ===========", layerId );   
682    fprintf( g_hTrace, "\n" );   
683    fflush ( g_hTrace );   
684  }
685}
[872]686Void stopAtPos( Int poc, Int layerId, Int cuPelX, Int cuPelY, Int cuWidth, Int cuHeight )
687{
688  if ( g_outputPos ) 
689  {
690    std::cout << "POC\t"        << poc
691              << "\tLayerId\t"  << layerId
692              << "\tCuPelX\t"   << cuPelX 
693              << "\tCuPelY\t"   << cuPelY
694              << "\tCuWidth\t"  << cuWidth
695              << "\tCuHeight\t" << cuHeight
696              << std::endl; 
697  }
[1313]698  Bool startTrace = false; 
699  if ( g_startStopTrace && poc == 0 && layerId == 0 )
[1321]700  {
[1313]701    startTrace = ( cuPelX  == 0 ) && ( cuPelY  == 0 ) && ( cuWidth == 64 ) && ( cuHeight == 64 ); 
[1321]702    }
[1313]703  if ( startTrace )
704  { 
705    g_outputPos              = true; 
706    g_traceEncFracBits       = false;   
707    g_traceIntraSearchCost   = false;     
708    g_encNumberOfWrittenBits = false;     
709    g_traceRDCost            = true; 
710    g_traceModeCheck         = true; 
711    g_traceCopyBack          = false; 
[1321]712    }
[1313]713  Bool stopTrace = false; 
714  if ( g_startStopTrace && poc == 0 && layerId == 0 )
[872]715  {
[1313]716    stopTrace = ( cuPelX  == 128 ) && ( cuPelY  == 0 ) && ( cuWidth == 64 ) && ( cuHeight == 64 ); 
[872]717  }
[1313]718  if ( stopTrace )
719  { 
720    g_outputPos              = false; 
721    g_traceModeCheck         = false; 
722    g_traceEncFracBits       = false; 
723    g_traceIntraSearchCost   = false;       
724    g_encNumberOfWrittenBits = false; 
725    g_traceRDCost            = false; 
726    g_traceCopyBack          = false;     
[872]727  } 
728}
[1386]729Void writeToTraceFile( const TChar* symbolName, Int val, Bool doIt )
[608]730{
731  if ( ( ( g_nSymbolCounter >= COUNTER_START && g_nSymbolCounter <= COUNTER_END )|| g_bJustDoIt ) && doIt  ) 
732  {
[1313]733    incSymbolCounter(); 
[1179]734    if ( !g_disableNumbering )
735    { 
[1313]736      fprintf( g_hTrace, "%8lld  ", g_nSymbolCounter );
[1179]737    }
[608]738    fprintf( g_hTrace, "%-50s       : %d\n", symbolName, val );     
[1313]739    fflush ( g_hTrace );   
[608]740  }
741}
[1313]742UInt64 incSymbolCounter( )
743{
744  g_nSymbolCounter++; 
745  if ( g_stopAtCounter == g_nSymbolCounter )
746  {
747    std::cout << "Break point here." << std::endl; 
748  } 
749  return g_nSymbolCounter; 
750}
[1386]751Void writeToTraceFile( const TChar* symbolName, Bool doIt )
[608]752{
753  if ( ( ( g_nSymbolCounter >= COUNTER_START && g_nSymbolCounter <= COUNTER_END )|| g_bJustDoIt ) && doIt  ) 
754  {
[1313]755    incSymbolCounter(); 
[608]756    fprintf( g_hTrace, "%s", symbolName );   
[1313]757    fflush ( g_hTrace );   
[608]758  }
759}
[1313]760Void printStr( std::string str )
761{
762  std::cout << str << std::endl; 
763}
764Void printStrIndent( Bool b, std::string strStr )
765{
766  if ( b )
767  { 
768    std::cout << std::string(g_indent, ' ');
769    printStr( strStr );
770  }
771}
772Void prinStrIncIndent( Bool b,  std::string strStr )
773{
774  if ( b )
775  {
776    printStrIndent( true,  strStr );
777    if (g_indent < 50)
778    {
779      g_indent++;
780    }
781  } 
782}
783Void decIndent( Bool b )
784{
785  if (b && g_indent > 0)
786  {
787    g_indent--; 
788  } 
789}
[608]790#endif
791#endif
[1413]792#if NH_3D
[608]793std::vector< std::vector<TComWedgelet>  > g_dmmWedgeLists;
794std::vector< std::vector<TComWedgeNode> > g_dmmWedgeNodeLists;
[622]795Void initWedgeLists( Bool initNodeList )
[2]796{
[608]797  if( !g_dmmWedgeLists.empty() ) return;
[1313]798  for( UInt ui = g_aucConvertToBit[DMM_MIN_SIZE]; ui < (g_aucConvertToBit[DMM_MAX_SIZE]); ui++ )
[2]799  {
[1313]800    UInt uiWedgeBlockSize = ((UInt)DMM_MIN_SIZE)<<ui;
[2]801    std::vector<TComWedgelet> acWedgeList;
802    std::vector<TComWedgeRef> acWedgeRefList;
[608]803    createWedgeList( uiWedgeBlockSize, uiWedgeBlockSize, acWedgeList, acWedgeRefList, g_dmmWedgeResolution[ui] );
804    g_dmmWedgeLists.push_back( acWedgeList );
[622]805    if( initNodeList )
806    {
[655]807      // create WedgeNodeList
808      std::vector<TComWedgeNode> acWedgeNodeList;
809      for( UInt uiPos = 0; uiPos < acWedgeList.size(); uiPos++ )
[189]810      {
[655]811        if( acWedgeList[uiPos].getIsCoarse() )
812        {
813          TComWedgeNode cWedgeNode;
814          cWedgeNode.setPatternIdx( uiPos );
[608]815          UInt uiRefPos = 0;
816          for( Int iOffS = -1; iOffS <= 1; iOffS++ )
[189]817          {
[608]818            for( Int iOffE = -1; iOffE <= 1; iOffE++ )
819            {
820              if( iOffS == 0 && iOffE == 0 ) { continue; }
821              Int iSx = (Int)acWedgeList[uiPos].getStartX();
822              Int iSy = (Int)acWedgeList[uiPos].getStartY();
823              Int iEx = (Int)acWedgeList[uiPos].getEndX();
824              Int iEy = (Int)acWedgeList[uiPos].getEndY();
825              switch( acWedgeList[uiPos].getOri() )
826              {
827              case( 0 ): { iSx += iOffS; iEy += iOffE; } break;
828              case( 1 ): { iSy += iOffS; iEx -= iOffE; } break;
829              case( 2 ): { iSx -= iOffS; iEy -= iOffE; } break;
830              case( 3 ): { iSy -= iOffS; iEx += iOffE; } break;
831              case( 4 ): { iSx += iOffS; iEx += iOffE; } break;
832              case( 5 ): { iSy += iOffS; iEy += iOffE; } break;
833              default: assert( 0 );
834              }
835              for( UInt k = 0; k < acWedgeRefList.size(); k++ )
[189]836              {
[608]837                if( iSx == (Int)acWedgeRefList[k].getStartX() && 
[655]838                  iSy == (Int)acWedgeRefList[k].getStartY() && 
839                  iEx == (Int)acWedgeRefList[k].getEndX()   && 
840                  iEy == (Int)acWedgeRefList[k].getEndY()      )
[189]841                {
[608]842                  if( acWedgeRefList[k].getRefIdx() != cWedgeNode.getPatternIdx() )
843                  {
844                    Bool bNew = true;
845                    for( UInt m = 0; m < uiRefPos; m++ ) { if( acWedgeRefList[k].getRefIdx() == cWedgeNode.getRefineIdx( m ) ) { bNew = false; break; } }
846                    if( bNew ) 
847                    {
848                      cWedgeNode.setRefineIdx( acWedgeRefList[k].getRefIdx(), uiRefPos );
849                      uiRefPos++;
850                      break;
851                    }
[189]852                  }
853                }
854              }
855            }
856          }
[655]857          acWedgeNodeList.push_back( cWedgeNode );
[189]858        }
859      }
[655]860      g_dmmWedgeNodeLists.push_back( acWedgeNodeList );
[189]861    }
[2]862  }
863}
864Void createWedgeList( UInt uiWidth, UInt uiHeight, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList, WedgeResolution eWedgeRes )
865{
866  assert( uiWidth == uiHeight );
[1179]867  Int posStart = 0, posEnd = 0;
[2]868  UInt uiBlockSize = 0;
869  switch( eWedgeRes )
870  {
871  case(   FULL_PEL ): { uiBlockSize =  uiWidth;     break; }
872  case(   HALF_PEL ): { uiBlockSize = (uiWidth<<1); break; }
873  }
874  TComWedgelet cTempWedgelet( uiWidth, uiHeight );
875  for( UInt uiOri = 0; uiOri < 6; uiOri++ )
876  {
[1179]877    posEnd = (Int) racWedgeList.size();
878    if (uiOri == 0 || uiOri == 4)
879    {
[1124]880    for( Int iK = 0; iK < uiBlockSize; iK += (uiWidth>=16 ?2:1))
881    {
882      for( Int iL = 0; iL < uiBlockSize; iL += ((uiWidth>=16 && uiOri<4)?2:1) )
883      {
[1179]884        Int xS = iK;
885        Int yS = 0;
886        Int xE = (uiOri == 0) ? 0 : iL;
887        Int yE = (uiOri == 0) ? iL : uiBlockSize - 1;
888        cTempWedgelet.setWedgelet( xS, yS, xE, yE, uiOri, eWedgeRes, ((iL%2)==0 && (iK%2)==0) );
[1124]889        addWedgeletToList( cTempWedgelet, racWedgeList, racWedgeRefList );
890      }
891    }
[1179]892    }
893    else
894    {
895      for (Int pos = posStart; pos < posEnd; pos++)
896      {
897        cTempWedgelet.generateWedgePatternByRotate(racWedgeList[pos], uiOri);
898        addWedgeletToList( cTempWedgelet, racWedgeList, racWedgeRefList );
899      }
900    }
901    posStart = posEnd;
[56]902  }
903}
904Void addWedgeletToList( TComWedgelet cWedgelet, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList )
905{
906  Bool bValid = cWedgelet.checkNotPlain();
907  if( bValid )
908  {
909    for( UInt uiPos = 0; uiPos < racWedgeList.size(); uiPos++ )
910    {
911      if( cWedgelet.checkIdentical( racWedgeList[uiPos].getPattern() ) )
912      {
913        TComWedgeRef cWedgeRef;
914        cWedgeRef.setWedgeRef( cWedgelet.getStartX(), cWedgelet.getStartY(), cWedgelet.getEndX(), cWedgelet.getEndY(), uiPos );
915        racWedgeRefList.push_back( cWedgeRef );
916        bValid = false;
917        return;
[2]918      }
919    }
920  }
[56]921  if( bValid )
922  {
923    for( UInt uiPos = 0; uiPos < racWedgeList.size(); uiPos++ )
924    {
925      if( cWedgelet.checkInvIdentical( racWedgeList[uiPos].getPattern() ) )
926      {
927        TComWedgeRef cWedgeRef;
928        cWedgeRef.setWedgeRef( cWedgelet.getStartX(), cWedgelet.getStartY(), cWedgelet.getEndX(), cWedgelet.getEndY(), uiPos );
929        racWedgeRefList.push_back( cWedgeRef );
930        bValid = false;
931        return;
932      }
933    }
934  }
935  if( bValid )
936  {
937    racWedgeList.push_back( cWedgelet );
938    TComWedgeRef cWedgeRef;
939    cWedgeRef.setWedgeRef( cWedgelet.getStartX(), cWedgelet.getStartY(), cWedgelet.getEndX(), cWedgelet.getEndY(), (UInt)(racWedgeList.size()-1) );
940    racWedgeRefList.push_back( cWedgeRef );
941  }
[2]942}
[1313]943WedgeList* getWedgeListScaled( UInt blkSize ) 
944{ 
945  return &g_dmmWedgeLists[ g_aucConvertToBit[( 16 >= blkSize ) ? blkSize : 16] ]; 
946}
947WedgeNodeList* getWedgeNodeListScaled( UInt blkSize )
948{
949  return &g_dmmWedgeNodeLists[ g_aucConvertToBit[( 16 >= blkSize ) ? blkSize : 16] ]; 
950}
951#endif //NH_3D_DMM
[56]952//! \}
Note: See TracBrowser for help on using the repository browser.