ref: bb4b01a1f96ee6576fb0ccc8237cf635e89a01ec
dir: h264bsd/src/h264bsd_transform.c
/*
* Copyright (C) 2009 The Android Open Source Project
* Modified for use by h264bsd standalone library
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*------------------------------------------------------------------------------
Table of contents
1. Include headers
2. External compiler flags
3. Module defines
4. Local function prototypes
5. Functions
h264bsdProcessBlock
h264bsdProcessLumaDc
h264bsdProcessChromaDc
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
1. Include headers
------------------------------------------------------------------------------*/
#include "basetype.h"
#include "h264bsd_transform.h"
#include "h264bsd_util.h"
/*------------------------------------------------------------------------------
2. External compiler flags
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
3. Module defines
------------------------------------------------------------------------------*/
/* Switch off the following Lint messages for this file:
* Info 701: Shift left of signed quantity (int)
* Info 702: Shift right of signed quantity (int)
*/
/*lint -e701 -e702 */
/* LevelScale function */
static const i32 levelScale[6][3] = {
{10,13,16}, {11,14,18}, {13,16,20}, {14,18,23}, {16,20,25}, {18,23,29}};
/* qp % 6 as a function of qp */
static const u8 qpMod6[52] = {0,1,2,3,4,5,0,1,2,3,4,5,0,1,2,3,4,5,0,1,2,3,4,5,
0,1,2,3,4,5,0,1,2,3,4,5,0,1,2,3,4,5,0,1,2,3,4,5,0,1,2,3};
/* qp / 6 as a function of qp */
static const u8 qpDiv6[52] = {0,0,0,0,0,0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,
4,4,4,4,4,4,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8,8,8,8};
/*------------------------------------------------------------------------------
4. Local function prototypes
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
Function: h264bsdProcessBlock
Functional description:
Function performs inverse zig-zag scan, inverse scaling and
inverse transform for a luma or a chroma residual block
Inputs:
data pointer to data to be processed
qp quantization parameter
skip skip processing of data[0], set to non-zero value
if dc coeff hanled separately
coeffMap 16 lsb's indicate which coeffs are non-zero,
bit 0 (lsb) for coeff 0, bit 1 for coeff 1 etc.
Outputs:
data processed data
Returns:
HANTRO_OK success
HANTRO_NOK processed data not in valid range [-512, 511]
------------------------------------------------------------------------------*/
u32 h264bsdProcessBlock(i32 *data, u32 qp, u32 skip, u32 coeffMap)
{
/* Variables */
i32 tmp0, tmp1, tmp2, tmp3;
i32 d1, d2, d3;
u32 row,col;
u32 qpDiv;
i32 *ptr;
/* Code */
qpDiv = qpDiv6[qp];
tmp1 = levelScale[qpMod6[qp]][0] << qpDiv;
tmp2 = levelScale[qpMod6[qp]][1] << qpDiv;
tmp3 = levelScale[qpMod6[qp]][2] << qpDiv;
if (!skip)
data[0] = (data[0] * tmp1);
/* at least one of the rows 1, 2 or 3 contain non-zero coeffs, mask takes
* the scanning order into account */
if (coeffMap & 0xFF9C)
{
/* do the zig-zag scan and inverse quantization */
d1 = data[1];
d2 = data[14];
d3 = data[15];
data[1] = (d1 * tmp2);
data[14] = (d2 * tmp2);
data[15] = (d3 * tmp3);
d1 = data[2];
d2 = data[5];
d3 = data[4];
data[4] = (d1 * tmp2);
data[2] = (d2 * tmp1);
data[5] = (d3 * tmp3);
d1 = data[8];
d2 = data[3];
d3 = data[6];
tmp0 = (d1 * tmp2);
data[8] = (d2 * tmp1);
data[3] = (d3 * tmp2);
d1 = data[7];
d2 = data[12];
d3 = data[9];
data[6] = (d1 * tmp2);
data[7] = (d2 * tmp3);
data[12] = (d3 * tmp2);
data[9] = tmp0;
d1 = data[10];
d2 = data[11];
d3 = data[13];
data[13] = (d1 * tmp3);
data[10] = (d2 * tmp1);
data[11] = (d3 * tmp2);
/* horizontal transform */
for (row = 4, ptr = data; row--; ptr += 4)
{
tmp0 = ptr[0] + ptr[2];
tmp1 = ptr[0] - ptr[2];
tmp2 = (ptr[1] >> 1) - ptr[3];
tmp3 = ptr[1] + (ptr[3] >> 1);
ptr[0] = tmp0 + tmp3;
ptr[1] = tmp1 + tmp2;
ptr[2] = tmp1 - tmp2;
ptr[3] = tmp0 - tmp3;
}
/*lint +e661 +e662*/
/* then vertical transform */
for (col = 4; col--; data++)
{
tmp0 = data[0] + data[8];
tmp1 = data[0] - data[8];
tmp2 = (data[4] >> 1) - data[12];
tmp3 = data[4] + (data[12] >> 1);
data[0 ] = (tmp0 + tmp3 + 32)>>6;
data[4 ] = (tmp1 + tmp2 + 32)>>6;
data[8 ] = (tmp1 - tmp2 + 32)>>6;
data[12] = (tmp0 - tmp3 + 32)>>6;
/* check that each value is in the range [-512,511] */
if (((u32)(data[0] + 512) > 1023) ||
((u32)(data[4] + 512) > 1023) ||
((u32)(data[8] + 512) > 1023) ||
((u32)(data[12] + 512) > 1023) )
return(HANTRO_NOK);
}
}
else /* rows 1, 2 and 3 are zero */
{
/* only dc-coeff is non-zero, i.e. coeffs at original positions
* 1, 5 and 6 are zero */
if ((coeffMap & 0x62) == 0)
{
tmp0 = (data[0] + 32) >> 6;
/* check that value is in the range [-512,511] */
if ((u32)(tmp0 + 512) > 1023)
return(HANTRO_NOK);
data[0] = data[1] = data[2] = data[3] = data[4] = data[5] =
data[6] = data[7] = data[8] = data[9] = data[10] =
data[11] = data[12] = data[13] = data[14] = data[15] =
tmp0;
}
else /* at least one of the coeffs 1, 5 or 6 is non-zero */
{
data[1] = (data[1] * tmp2);
data[2] = (data[5] * tmp1);
data[3] = (data[6] * tmp2);
tmp0 = data[0] + data[2];
tmp1 = data[0] - data[2];
tmp2 = (data[1] >> 1) - data[3];
tmp3 = data[1] + (data[3] >> 1);
data[0] = (tmp0 + tmp3 + 32)>>6;
data[1] = (tmp1 + tmp2 + 32)>>6;
data[2] = (tmp1 - tmp2 + 32)>>6;
data[3] = (tmp0 - tmp3 + 32)>>6;
data[4] = data[8] = data[12] = data[0];
data[5] = data[9] = data[13] = data[1];
data[6] = data[10] = data[14] = data[2];
data[7] = data[11] = data[15] = data[3];
/* check that each value is in the range [-512,511] */
if (((u32)(data[0] + 512) > 1023) ||
((u32)(data[1] + 512) > 1023) ||
((u32)(data[2] + 512) > 1023) ||
((u32)(data[3] + 512) > 1023) )
return(HANTRO_NOK);
}
}
return(HANTRO_OK);
}
/*------------------------------------------------------------------------------
Function: h264bsdProcessLumaDc
Functional description:
Function performs inverse zig-zag scan, inverse transform and
inverse scaling for a luma DC coefficients block
Inputs:
data pointer to data to be processed
qp quantization parameter
Outputs:
data processed data
Returns:
none
------------------------------------------------------------------------------*/
void h264bsdProcessLumaDc(i32 *data, u32 qp)
{
/* Variables */
i32 tmp0, tmp1, tmp2, tmp3;
u32 row,col;
u32 qpMod, qpDiv;
i32 levScale;
i32 *ptr;
/* Code */
qpMod = qpMod6[qp];
qpDiv = qpDiv6[qp];
/* zig-zag scan */
tmp0 = data[2];
data[2] = data[5];
data[5] = data[4];
data[4] = tmp0;
tmp0 = data[8];
data[8] = data[3];
data[3] = data[6];
data[6] = data[7];
data[7] = data[12];
data[12] = data[9];
data[9] = tmp0;
tmp0 = data[10];
data[10] = data[11];
data[11] = data[13];
data[13] = tmp0;
/* horizontal transform */
for (row = 4, ptr = data; row--; ptr += 4)
{
tmp0 = ptr[0] + ptr[2];
tmp1 = ptr[0] - ptr[2];
tmp2 = ptr[1] - ptr[3];
tmp3 = ptr[1] + ptr[3];
ptr[0] = tmp0 + tmp3;
ptr[1] = tmp1 + tmp2;
ptr[2] = tmp1 - tmp2;
ptr[3] = tmp0 - tmp3;
}
/*lint +e661 +e662*/
/* then vertical transform and inverse scaling */
levScale = levelScale[ qpMod ][0];
if (qp >= 12)
{
levScale <<= (qpDiv-2);
for (col = 4; col--; data++)
{
tmp0 = data[0] + data[8 ];
tmp1 = data[0] - data[8 ];
tmp2 = data[4] - data[12];
tmp3 = data[4] + data[12];
data[0 ] = ((tmp0 + tmp3)*levScale);
data[4 ] = ((tmp1 + tmp2)*levScale);
data[8 ] = ((tmp1 - tmp2)*levScale);
data[12] = ((tmp0 - tmp3)*levScale);
}
}
else
{
i32 tmp;
tmp = ((1 - qpDiv) == 0) ? 1 : 2;
for (col = 4; col--; data++)
{
tmp0 = data[0] + data[8 ];
tmp1 = data[0] - data[8 ];
tmp2 = data[4] - data[12];
tmp3 = data[4] + data[12];
data[0 ] = ((tmp0 + tmp3)*levScale+tmp) >> (2-qpDiv);
data[4 ] = ((tmp1 + tmp2)*levScale+tmp) >> (2-qpDiv);
data[8 ] = ((tmp1 - tmp2)*levScale+tmp) >> (2-qpDiv);
data[12] = ((tmp0 - tmp3)*levScale+tmp) >> (2-qpDiv);
}
}
}
/*------------------------------------------------------------------------------
Function: h264bsdProcessChromaDc
Functional description:
Function performs inverse transform and inverse scaling for a
chroma DC coefficients block
Inputs:
data pointer to data to be processed
qp quantization parameter
Outputs:
data processed data
Returns:
none
------------------------------------------------------------------------------*/
void h264bsdProcessChromaDc(i32 *data, u32 qp)
{
/* Variables */
i32 tmp0, tmp1, tmp2, tmp3;
u32 qpDiv;
i32 levScale;
u32 levShift;
/* Code */
qpDiv = qpDiv6[qp];
levScale = levelScale[ qpMod6[qp] ][0];
if (qp >= 6)
{
levScale <<= (qpDiv-1);
levShift = 0;
}
else
{
levShift = 1;
}
tmp0 = data[0] + data[2];
tmp1 = data[0] - data[2];
tmp2 = data[1] - data[3];
tmp3 = data[1] + data[3];
data[0] = ((tmp0 + tmp3) * levScale) >> levShift;
data[1] = ((tmp0 - tmp3) * levScale) >> levShift;
data[2] = ((tmp1 + tmp2) * levScale) >> levShift;
data[3] = ((tmp1 - tmp2) * levScale) >> levShift;
tmp0 = data[4] + data[6];
tmp1 = data[4] - data[6];
tmp2 = data[5] - data[7];
tmp3 = data[5] + data[7];
data[4] = ((tmp0 + tmp3) * levScale) >> levShift;
data[5] = ((tmp0 - tmp3) * levScale) >> levShift;
data[6] = ((tmp1 + tmp2) * levScale) >> levShift;
data[7] = ((tmp1 - tmp2) * levScale) >> levShift;
}
/*lint +e701 +e702 */