675 lines
26 KiB
C++
675 lines
26 KiB
C++
/* The copyright in this software is being made available under the BSD
|
|
* License, included below. This software may be subject to other third party
|
|
* and contributor rights, including patent rights, and no such rights are
|
|
* granted under this license.
|
|
*
|
|
* Copyright (c) 2010-2014, ITU/ISO/IEC
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
|
|
* be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/** \file TComRom.cpp
|
|
\brief global variables & functions
|
|
*/
|
|
|
|
#include "TComRom.h"
|
|
#include <memory.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <iomanip>
|
|
#include <assert.h>
|
|
#include "TComDataCU.h"
|
|
#include "Debug.h"
|
|
// ====================================================================================================================
|
|
// Initialize / destroy functions
|
|
// ====================================================================================================================
|
|
|
|
//! \ingroup TLibCommon
|
|
//! \{
|
|
|
|
class ScanGenerator
|
|
{
|
|
private:
|
|
UInt m_line, m_column;
|
|
const UInt m_blockWidth, m_blockHeight;
|
|
const UInt m_stride;
|
|
const COEFF_SCAN_TYPE m_scanType;
|
|
|
|
public:
|
|
ScanGenerator(UInt blockWidth, UInt blockHeight, UInt stride, COEFF_SCAN_TYPE scanType)
|
|
: m_line(0), m_column(0), m_blockWidth(blockWidth), m_blockHeight(blockHeight), m_stride(stride), m_scanType(scanType)
|
|
{ }
|
|
|
|
UInt GetCurrentX() const { return m_column; }
|
|
UInt GetCurrentY() const { return m_line; }
|
|
|
|
UInt GetNextIndex(UInt blockOffsetX, UInt blockOffsetY)
|
|
{
|
|
Int rtn=((m_line + blockOffsetY) * m_stride) + m_column + blockOffsetX;
|
|
|
|
//advance line and column to the next position
|
|
switch (m_scanType)
|
|
{
|
|
//------------------------------------------------
|
|
|
|
case SCAN_DIAG:
|
|
{
|
|
if ((m_column == (m_blockWidth - 1)) || (m_line == 0)) //if we reach the end of a rank, go diagonally down to the next one
|
|
{
|
|
m_line += m_column + 1;
|
|
m_column = 0;
|
|
|
|
if (m_line >= m_blockHeight) //if that takes us outside the block, adjust so that we are back on the bottom row
|
|
{
|
|
m_column += m_line - (m_blockHeight - 1);
|
|
m_line = m_blockHeight - 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_column++;
|
|
m_line--;
|
|
}
|
|
}
|
|
break;
|
|
|
|
//------------------------------------------------
|
|
|
|
case SCAN_HOR:
|
|
{
|
|
if (m_column == (m_blockWidth - 1))
|
|
{
|
|
m_line++;
|
|
m_column = 0;
|
|
}
|
|
else m_column++;
|
|
}
|
|
break;
|
|
|
|
//------------------------------------------------
|
|
|
|
case SCAN_VER:
|
|
{
|
|
if (m_line == (m_blockHeight - 1))
|
|
{
|
|
m_column++;
|
|
m_line = 0;
|
|
}
|
|
else m_line++;
|
|
}
|
|
break;
|
|
|
|
//------------------------------------------------
|
|
|
|
default:
|
|
{
|
|
std::cerr << "ERROR: Unknown scan type \"" << m_scanType << "\"in ScanGenerator::GetNextIndex" << std::endl;
|
|
exit(1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return rtn;
|
|
}
|
|
};
|
|
|
|
// initialize ROM variables
|
|
Void initROM()
|
|
{
|
|
Int i, c;
|
|
|
|
// g_aucConvertToBit[ x ]: log2(x/4), if x=4 -> 0, x=8 -> 1, x=16 -> 2, ...
|
|
::memset( g_aucConvertToBit, -1, sizeof( g_aucConvertToBit ) );
|
|
c=0;
|
|
for ( i=4; i<=MAX_CU_SIZE; i*=2 )
|
|
{
|
|
g_aucConvertToBit[ i ] = c;
|
|
c++;
|
|
}
|
|
|
|
// initialise scan orders
|
|
for(UInt log2BlockHeight = 0; log2BlockHeight < MAX_CU_DEPTH; log2BlockHeight++)
|
|
{
|
|
for(UInt log2BlockWidth = 0; log2BlockWidth < MAX_CU_DEPTH; log2BlockWidth++)
|
|
{
|
|
const UInt blockWidth = 1 << log2BlockWidth;
|
|
const UInt blockHeight = 1 << log2BlockHeight;
|
|
const UInt totalValues = blockWidth * blockHeight;
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
|
|
//non-grouped scan orders
|
|
|
|
for (UInt scanTypeIndex = 0; scanTypeIndex < SCAN_NUMBER_OF_TYPES; scanTypeIndex++)
|
|
{
|
|
const COEFF_SCAN_TYPE scanType = COEFF_SCAN_TYPE(scanTypeIndex);
|
|
|
|
g_scanOrder[SCAN_UNGROUPED][scanType][log2BlockWidth][log2BlockHeight] = new UInt[totalValues];
|
|
|
|
ScanGenerator fullBlockScan(blockWidth, blockHeight, blockWidth, scanType);
|
|
|
|
for (UInt scanPosition = 0; scanPosition < totalValues; scanPosition++)
|
|
{
|
|
g_scanOrder[SCAN_UNGROUPED][scanType][log2BlockWidth][log2BlockHeight][scanPosition] = fullBlockScan.GetNextIndex(0, 0);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
|
|
//grouped scan orders
|
|
|
|
const UInt groupWidth = 1 << MLS_CG_LOG2_WIDTH;
|
|
const UInt groupHeight = 1 << MLS_CG_LOG2_HEIGHT;
|
|
const UInt widthInGroups = blockWidth >> MLS_CG_LOG2_WIDTH;
|
|
const UInt heightInGroups = blockHeight >> MLS_CG_LOG2_HEIGHT;
|
|
|
|
const UInt groupSize = groupWidth * groupHeight;
|
|
const UInt totalGroups = widthInGroups * heightInGroups;
|
|
|
|
for (UInt scanTypeIndex = 0; scanTypeIndex < SCAN_NUMBER_OF_TYPES; scanTypeIndex++)
|
|
{
|
|
const COEFF_SCAN_TYPE scanType = COEFF_SCAN_TYPE(scanTypeIndex);
|
|
|
|
g_scanOrder[SCAN_GROUPED_4x4][scanType][log2BlockWidth][log2BlockHeight] = new UInt[totalValues];
|
|
|
|
ScanGenerator fullBlockScan(widthInGroups, heightInGroups, groupWidth, scanType);
|
|
|
|
for (UInt groupIndex = 0; groupIndex < totalGroups; groupIndex++)
|
|
{
|
|
const UInt groupPositionY = fullBlockScan.GetCurrentY();
|
|
const UInt groupPositionX = fullBlockScan.GetCurrentX();
|
|
const UInt groupOffsetX = groupPositionX * groupWidth;
|
|
const UInt groupOffsetY = groupPositionY * groupHeight;
|
|
const UInt groupOffsetScan = groupIndex * groupSize;
|
|
|
|
ScanGenerator groupScan(groupWidth, groupHeight, blockWidth, scanType);
|
|
|
|
for (UInt scanPosition = 0; scanPosition < groupSize; scanPosition++)
|
|
{
|
|
g_scanOrder[SCAN_GROUPED_4x4][scanType][log2BlockWidth][log2BlockHeight][groupOffsetScan + scanPosition] = groupScan.GetNextIndex(groupOffsetX, groupOffsetY);
|
|
}
|
|
|
|
fullBlockScan.GetNextIndex(0,0);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
}
|
|
}
|
|
}
|
|
|
|
Void destroyROM()
|
|
{
|
|
for(UInt groupTypeIndex = 0; groupTypeIndex < SCAN_NUMBER_OF_GROUP_TYPES; groupTypeIndex++)
|
|
{
|
|
for (UInt scanOrderIndex = 0; scanOrderIndex < SCAN_NUMBER_OF_TYPES; scanOrderIndex++)
|
|
{
|
|
for (UInt log2BlockWidth = 0; log2BlockWidth < MAX_CU_DEPTH; log2BlockWidth++)
|
|
{
|
|
for (UInt log2BlockHeight = 0; log2BlockHeight < MAX_CU_DEPTH; log2BlockHeight++)
|
|
{
|
|
delete [] g_scanOrder[groupTypeIndex][scanOrderIndex][log2BlockWidth][log2BlockHeight];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ====================================================================================================================
|
|
// Data structure related table & variable
|
|
// ====================================================================================================================
|
|
|
|
UInt g_uiMaxCUWidth = MAX_CU_SIZE;
|
|
UInt g_uiMaxCUHeight = MAX_CU_SIZE;
|
|
UInt g_uiMaxCUDepth = MAX_CU_DEPTH;
|
|
UInt g_uiAddCUDepth = 0;
|
|
UInt g_auiZscanToRaster [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
|
|
UInt g_auiRasterToZscan [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
|
|
UInt g_auiRasterToPelX [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
|
|
UInt g_auiRasterToPelY [ MAX_NUM_SPU_W*MAX_NUM_SPU_W ] = { 0, };
|
|
|
|
UInt g_auiPUOffset[NUMBER_OF_PART_SIZES] = { 0, 8, 4, 4, 2, 10, 1, 5};
|
|
|
|
Void initZscanToRaster ( Int iMaxDepth, Int iDepth, UInt uiStartVal, UInt*& rpuiCurrIdx )
|
|
{
|
|
Int iStride = 1 << ( iMaxDepth - 1 );
|
|
|
|
if ( iDepth == iMaxDepth )
|
|
{
|
|
rpuiCurrIdx[0] = uiStartVal;
|
|
rpuiCurrIdx++;
|
|
}
|
|
else
|
|
{
|
|
Int iStep = iStride >> iDepth;
|
|
initZscanToRaster( iMaxDepth, iDepth+1, uiStartVal, rpuiCurrIdx );
|
|
initZscanToRaster( iMaxDepth, iDepth+1, uiStartVal+iStep, rpuiCurrIdx );
|
|
initZscanToRaster( iMaxDepth, iDepth+1, uiStartVal+iStep*iStride, rpuiCurrIdx );
|
|
initZscanToRaster( iMaxDepth, iDepth+1, uiStartVal+iStep*iStride+iStep, rpuiCurrIdx );
|
|
}
|
|
}
|
|
|
|
Void initRasterToZscan ( UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxDepth )
|
|
{
|
|
UInt uiMinCUWidth = uiMaxCUWidth >> ( uiMaxDepth - 1 );
|
|
UInt uiMinCUHeight = uiMaxCUHeight >> ( uiMaxDepth - 1 );
|
|
|
|
UInt uiNumPartInWidth = (UInt)uiMaxCUWidth / uiMinCUWidth;
|
|
UInt uiNumPartInHeight = (UInt)uiMaxCUHeight / uiMinCUHeight;
|
|
|
|
for ( UInt i = 0; i < uiNumPartInWidth*uiNumPartInHeight; i++ )
|
|
{
|
|
g_auiRasterToZscan[ g_auiZscanToRaster[i] ] = i;
|
|
}
|
|
}
|
|
|
|
Void initRasterToPelXY ( UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxDepth )
|
|
{
|
|
UInt i;
|
|
|
|
UInt* uiTempX = &g_auiRasterToPelX[0];
|
|
UInt* uiTempY = &g_auiRasterToPelY[0];
|
|
|
|
UInt uiMinCUWidth = uiMaxCUWidth >> ( uiMaxDepth - 1 );
|
|
UInt uiMinCUHeight = uiMaxCUHeight >> ( uiMaxDepth - 1 );
|
|
|
|
UInt uiNumPartInWidth = uiMaxCUWidth / uiMinCUWidth;
|
|
UInt uiNumPartInHeight = uiMaxCUHeight / uiMinCUHeight;
|
|
|
|
uiTempX[0] = 0; uiTempX++;
|
|
for ( i = 1; i < uiNumPartInWidth; i++ )
|
|
{
|
|
uiTempX[0] = uiTempX[-1] + uiMinCUWidth; uiTempX++;
|
|
}
|
|
for ( i = 1; i < uiNumPartInHeight; i++ )
|
|
{
|
|
memcpy(uiTempX, uiTempX-uiNumPartInWidth, sizeof(UInt)*uiNumPartInWidth);
|
|
uiTempX += uiNumPartInWidth;
|
|
}
|
|
|
|
for ( i = 1; i < uiNumPartInWidth*uiNumPartInHeight; i++ )
|
|
{
|
|
uiTempY[i] = ( i / uiNumPartInWidth ) * uiMinCUWidth;
|
|
}
|
|
}
|
|
|
|
Int g_maxTrDynamicRange[MAX_NUM_CHANNEL_TYPE];
|
|
|
|
Int g_quantScales[SCALING_LIST_REM_NUM] =
|
|
{
|
|
26214,23302,20560,18396,16384,14564
|
|
};
|
|
|
|
Int g_invQuantScales[SCALING_LIST_REM_NUM] =
|
|
{
|
|
40,45,51,57,64,72
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
|
|
//structures
|
|
|
|
#define DEFINE_DST4x4_MATRIX(a,b,c,d) \
|
|
{ \
|
|
{ a, b, c, d }, \
|
|
{ c, c, 0, -c }, \
|
|
{ d, -a, -c, b }, \
|
|
{ b, -d, c, -a }, \
|
|
}
|
|
|
|
#define DEFINE_DCT4x4_MATRIX(a,b,c) \
|
|
{ \
|
|
{ a, a, a, a}, \
|
|
{ b, c, -c, -b}, \
|
|
{ a, -a, -a, a}, \
|
|
{ c, -b, b, -c} \
|
|
}
|
|
|
|
#define DEFINE_DCT8x8_MATRIX(a,b,c,d,e,f,g) \
|
|
{ \
|
|
{ a, a, a, a, a, a, a, a}, \
|
|
{ d, e, f, g, -g, -f, -e, -d}, \
|
|
{ b, c, -c, -b, -b, -c, c, b}, \
|
|
{ e, -g, -d, -f, f, d, g, -e}, \
|
|
{ a, -a, -a, a, a, -a, -a, a}, \
|
|
{ f, -d, g, e, -e, -g, d, -f}, \
|
|
{ c, -b, b, -c, -c, b, -b, c}, \
|
|
{ g, -f, e, -d, d, -e, f, -g} \
|
|
}
|
|
|
|
#define DEFINE_DCT16x16_MATRIX(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
|
|
{ \
|
|
{ a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a}, \
|
|
{ h, i, j, k, l, m, n, o, -o, -n, -m, -l, -k, -j, -i, -h}, \
|
|
{ d, e, f, g, -g, -f, -e, -d, -d, -e, -f, -g, g, f, e, d}, \
|
|
{ i, l, o, -m, -j, -h, -k, -n, n, k, h, j, m, -o, -l, -i}, \
|
|
{ b, c, -c, -b, -b, -c, c, b, b, c, -c, -b, -b, -c, c, b}, \
|
|
{ j, o, -k, -i, -n, l, h, m, -m, -h, -l, n, i, k, -o, -j}, \
|
|
{ e, -g, -d, -f, f, d, g, -e, -e, g, d, f, -f, -d, -g, e}, \
|
|
{ k, -m, -i, o, h, n, -j, -l, l, j, -n, -h, -o, i, m, -k}, \
|
|
{ a, -a, -a, a, a, -a, -a, a, a, -a, -a, a, a, -a, -a, a}, \
|
|
{ l, -j, -n, h, -o, -i, m, k, -k, -m, i, o, -h, n, j, -l}, \
|
|
{ f, -d, g, e, -e, -g, d, -f, -f, d, -g, -e, e, g, -d, f}, \
|
|
{ m, -h, l, n, -i, k, o, -j, j, -o, -k, i, -n, -l, h, -m}, \
|
|
{ c, -b, b, -c, -c, b, -b, c, c, -b, b, -c, -c, b, -b, c}, \
|
|
{ n, -k, h, -j, m, o, -l, i, -i, l, -o, -m, j, -h, k, -n}, \
|
|
{ g, -f, e, -d, d, -e, f, -g, -g, f, -e, d, -d, e, -f, g}, \
|
|
{ o, -n, m, -l, k, -j, i, -h, h, -i, j, -k, l, -m, n, -o} \
|
|
}
|
|
|
|
#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) \
|
|
{ \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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}, \
|
|
{ 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} \
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
|
|
//coefficients
|
|
|
|
#if RExt__HIGH_PRECISION_FORWARD_TRANSFORM
|
|
const TMatrixCoeff g_aiT4 [TRANSFORM_NUMBER_OF_DIRECTIONS][4][4] =
|
|
{
|
|
DEFINE_DCT4x4_MATRIX (16384, 21266, 9224),
|
|
DEFINE_DCT4x4_MATRIX ( 64, 83, 36)
|
|
};
|
|
|
|
const TMatrixCoeff g_aiT8 [TRANSFORM_NUMBER_OF_DIRECTIONS][8][8] =
|
|
{
|
|
DEFINE_DCT8x8_MATRIX (16384, 21266, 9224, 22813, 19244, 12769, 4563),
|
|
DEFINE_DCT8x8_MATRIX ( 64, 83, 36, 89, 75, 50, 18)
|
|
};
|
|
|
|
const TMatrixCoeff g_aiT16[TRANSFORM_NUMBER_OF_DIRECTIONS][16][16] =
|
|
{
|
|
DEFINE_DCT16x16_MATRIX(16384, 21266, 9224, 22813, 19244, 12769, 4563, 23120, 22063, 20450, 17972, 14642, 11109, 6446, 2316),
|
|
DEFINE_DCT16x16_MATRIX( 64, 83, 36, 89, 75, 50, 18, 90, 87, 80, 70, 57, 43, 25, 9)
|
|
};
|
|
|
|
const TMatrixCoeff g_aiT32[TRANSFORM_NUMBER_OF_DIRECTIONS][32][32] =
|
|
{
|
|
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),
|
|
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)
|
|
};
|
|
|
|
const TMatrixCoeff g_as_DST_MAT_4[TRANSFORM_NUMBER_OF_DIRECTIONS][4][4] =
|
|
{
|
|
DEFINE_DST4x4_MATRIX( 7424, 14081, 18893, 21505),
|
|
DEFINE_DST4x4_MATRIX( 29, 55, 74, 84)
|
|
};
|
|
|
|
#else
|
|
|
|
const TMatrixCoeff g_aiT4 [TRANSFORM_NUMBER_OF_DIRECTIONS][4][4] =
|
|
{
|
|
DEFINE_DCT4x4_MATRIX ( 64, 83, 36),
|
|
DEFINE_DCT4x4_MATRIX ( 64, 83, 36)
|
|
};
|
|
|
|
const TMatrixCoeff g_aiT8 [TRANSFORM_NUMBER_OF_DIRECTIONS][8][8] =
|
|
{
|
|
DEFINE_DCT8x8_MATRIX ( 64, 83, 36, 89, 75, 50, 18),
|
|
DEFINE_DCT8x8_MATRIX ( 64, 83, 36, 89, 75, 50, 18)
|
|
};
|
|
|
|
const TMatrixCoeff g_aiT16[TRANSFORM_NUMBER_OF_DIRECTIONS][16][16] =
|
|
{
|
|
DEFINE_DCT16x16_MATRIX( 64, 83, 36, 89, 75, 50, 18, 90, 87, 80, 70, 57, 43, 25, 9),
|
|
DEFINE_DCT16x16_MATRIX( 64, 83, 36, 89, 75, 50, 18, 90, 87, 80, 70, 57, 43, 25, 9)
|
|
};
|
|
|
|
const TMatrixCoeff g_aiT32[TRANSFORM_NUMBER_OF_DIRECTIONS][32][32] =
|
|
{
|
|
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),
|
|
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)
|
|
};
|
|
|
|
const TMatrixCoeff g_as_DST_MAT_4[TRANSFORM_NUMBER_OF_DIRECTIONS][4][4] =
|
|
{
|
|
DEFINE_DST4x4_MATRIX( 29, 55, 74, 84),
|
|
DEFINE_DST4x4_MATRIX( 29, 55, 74, 84)
|
|
};
|
|
#endif
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
|
|
#undef DEFINE_DST4x4_MATRIX
|
|
#undef DEFINE_DCT4x4_MATRIX
|
|
#undef DEFINE_DCT8x8_MATRIX
|
|
#undef DEFINE_DCT16x16_MATRIX
|
|
#undef DEFINE_DCT32x32_MATRIX
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
|
|
|
|
const UChar g_aucChromaScale[NUM_CHROMA_FORMAT][chromaQPMappingTableSize]=
|
|
{
|
|
//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
|
|
{ 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 },
|
|
{ 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 },
|
|
{ 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 },
|
|
{ 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 }
|
|
};
|
|
|
|
// ====================================================================================================================
|
|
// ADI
|
|
// ====================================================================================================================
|
|
|
|
#if FAST_UDI_USE_MPM
|
|
const UChar g_aucIntraModeNumFast[MAX_CU_DEPTH] =
|
|
{
|
|
3, // 2x2
|
|
8, // 4x4
|
|
8, // 8x8
|
|
3, // 16x16
|
|
3, // 32x32
|
|
3 // 64x64
|
|
};
|
|
#else // FAST_UDI_USE_MPM
|
|
const UChar g_aucIntraModeNumFast[MAX_CU_DEPTH] =
|
|
{
|
|
3, // 2x2
|
|
9, // 4x4
|
|
9, // 8x8
|
|
4, // 16x16 33
|
|
4, // 32x32 33
|
|
5 // 64x64 33
|
|
};
|
|
#endif // FAST_UDI_USE_MPM
|
|
|
|
const UChar g_chroma422IntraAngleMappingTable[NUM_INTRA_MODE] =
|
|
//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
|
|
{ 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};
|
|
|
|
// ====================================================================================================================
|
|
// Bit-depth
|
|
// ====================================================================================================================
|
|
|
|
Int g_bitDepth [MAX_NUM_CHANNEL_TYPE] = {8, 8};
|
|
#if O0043_BEST_EFFORT_DECODING
|
|
Int g_bitDepthInStream [MAX_NUM_CHANNEL_TYPE] = {8, 8}; // In the encoder, this is the same as g_bitDepth. In the decoder, this can vary from g_bitDepth if the decoder is forced to use 'best-effort decoding' at a particular bit-depth.
|
|
#endif
|
|
Int g_PCMBitDepth[MAX_NUM_CHANNEL_TYPE] = {8, 8}; // PCM bit-depth
|
|
|
|
// ====================================================================================================================
|
|
// Misc.
|
|
// ====================================================================================================================
|
|
|
|
Char g_aucConvertToBit [ MAX_CU_SIZE+1 ];
|
|
|
|
#if ENC_DEC_TRACE
|
|
FILE* g_hTrace = NULL; // Set to NULL to open up a file. Set to stdout to use the current output
|
|
const Bool g_bEncDecTraceEnable = true;
|
|
const Bool g_bEncDecTraceDisable = false;
|
|
Bool g_HLSTraceEnable = true;
|
|
Bool g_bJustDoIt = false;
|
|
UInt64 g_nSymbolCounter = 0;
|
|
#endif
|
|
// ====================================================================================================================
|
|
// Scanning order & context model mapping
|
|
// ====================================================================================================================
|
|
|
|
// scanning order table
|
|
UInt* g_scanOrder[SCAN_NUMBER_OF_GROUP_TYPES][SCAN_NUMBER_OF_TYPES][ MAX_CU_DEPTH ][ MAX_CU_DEPTH ];
|
|
|
|
const UInt ctxIndMap4x4[4*4] =
|
|
{
|
|
0, 1, 4, 5,
|
|
2, 3, 4, 5,
|
|
6, 6, 8, 8,
|
|
7, 7, 8, 8
|
|
};
|
|
|
|
const UInt g_uiMinInGroup[ LAST_SIGNIFICANT_GROUPS ] = {0,1,2,3,4,6,8,12,16,24};
|
|
const 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};
|
|
|
|
const Char *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
|
|
{
|
|
{
|
|
"INTRA4X4_LUMA",
|
|
"INTRA4X4_CHROMAU",
|
|
"INTRA4X4_CHROMAV",
|
|
"INTER4X4_LUMA",
|
|
"INTER4X4_CHROMAU",
|
|
"INTER4X4_CHROMAV"
|
|
},
|
|
{
|
|
"INTRA8X8_LUMA",
|
|
"INTRA8X8_CHROMAU",
|
|
"INTRA8X8_CHROMAV",
|
|
"INTER8X8_LUMA",
|
|
"INTER8X8_CHROMAU",
|
|
"INTER8X8_CHROMAV"
|
|
},
|
|
{
|
|
"INTRA16X16_LUMA",
|
|
"INTRA16X16_CHROMAU",
|
|
"INTRA16X16_CHROMAV",
|
|
"INTER16X16_LUMA",
|
|
"INTER16X16_CHROMAU",
|
|
"INTER16X16_CHROMAV"
|
|
},
|
|
{
|
|
"INTRA32X32_LUMA",
|
|
"INTRA32X32_CHROMAU_FROM16x16_CHROMAU",
|
|
"INTRA32X32_CHROMAV_FROM16x16_CHROMAV",
|
|
"INTER32X32_LUMA",
|
|
"INTER32X32_CHROMAU_FROM16x16_CHROMAU",
|
|
"INTER32X32_CHROMAV_FROM16x16_CHROMAV"
|
|
},
|
|
};
|
|
|
|
const Char *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
|
|
{
|
|
{
|
|
},
|
|
{
|
|
},
|
|
{
|
|
"INTRA16X16_LUMA_DC",
|
|
"INTRA16X16_CHROMAU_DC",
|
|
"INTRA16X16_CHROMAV_DC",
|
|
"INTER16X16_LUMA_DC",
|
|
"INTER16X16_CHROMAU_DC",
|
|
"INTER16X16_CHROMAV_DC"
|
|
},
|
|
{
|
|
"INTRA32X32_LUMA_DC",
|
|
"INTRA32X32_CHROMAU_DC_FROM16x16_CHROMAU",
|
|
"INTRA32X32_CHROMAV_DC_FROM16x16_CHROMAV",
|
|
"INTER32X32_LUMA_DC",
|
|
"INTER32X32_CHROMAU_DC_FROM16x16_CHROMAU",
|
|
"INTER32X32_CHROMAV_DC_FROM16x16_CHROMAV"
|
|
},
|
|
};
|
|
|
|
Int g_quantTSDefault4x4[4*4] =
|
|
{
|
|
16,16,16,16,
|
|
16,16,16,16,
|
|
16,16,16,16,
|
|
16,16,16,16
|
|
};
|
|
|
|
Int g_quantIntraDefault8x8[8*8] =
|
|
{
|
|
16,16,16,16,17,18,21,24,
|
|
16,16,16,16,17,19,22,25,
|
|
16,16,17,18,20,22,25,29,
|
|
16,16,18,21,24,27,31,36,
|
|
17,17,20,24,30,35,41,47,
|
|
18,19,22,27,35,44,54,65,
|
|
21,22,25,31,41,54,70,88,
|
|
24,25,29,36,47,65,88,115
|
|
};
|
|
|
|
Int g_quantInterDefault8x8[8*8] =
|
|
{
|
|
16,16,16,16,17,18,20,24,
|
|
16,16,16,17,18,20,24,25,
|
|
16,16,17,18,20,24,25,28,
|
|
16,17,18,20,24,25,28,33,
|
|
17,18,20,24,25,28,33,41,
|
|
18,20,24,25,28,33,41,54,
|
|
20,24,25,28,33,41,54,71,
|
|
24,25,28,33,41,54,71,91
|
|
};
|
|
|
|
UInt g_scalingListSize [SCALING_LIST_SIZE_NUM] = {16,64,256,1024};
|
|
UInt g_scalingListSizeX [SCALING_LIST_SIZE_NUM] = { 4, 8, 16, 32};
|
|
|
|
//! \}
|