King_DuckZ/libbpg
1
0
Fork 0
forked from mirror/libbpg
Code Issues Pull requests Releases Wiki Activity
libbpg/jctvc/TLibCommon/TComRom.cpp

676 lines
26 KiB
C++
Raw Normal View History

libbpg-0.9.3
2015-01-16 12:46:18 +00:00
/* 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};
//! \}
Reference in a new issue Copy permalink