/******************************************************************************
|
*
|
* Copyright (C) 2015 The Android Open Source Project
|
*
|
* 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.
|
*
|
*****************************************************************************
|
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
|
*/
|
/*****************************************************************************/
|
/* */
|
/* File Name : impeg2_idct.c */
|
/* */
|
/* Description : Contains 2d idct and invese quantization functions */
|
/* */
|
/* List of Functions : impeg2_idct_recon_dc() */
|
/* impeg2_idct_recon_dc_mismatch() */
|
/* impeg2_idct_recon() */
|
/* */
|
/* Issues / Problems : None */
|
/* */
|
/* Revision History : */
|
/* */
|
/* DD MM YYYY Author(s) Changes */
|
/* 10 09 2005 Hairsh M First Version */
|
/* */
|
/*****************************************************************************/
|
/*
|
IEEE - 1180 results for this IDCT
|
L 256 256 5 5 300 300 384 384 Thresholds
|
H 255 255 5 5 300 300 383 383
|
sign 1 -1 1 -1 1 -1 1 -1
|
Peak Error 1 1 1 1 1 1 1 1 1
|
Peak Mean Square Error 0.0191 0.0188 0.0108 0.0111 0.0176 0.0188 0.0165 0.0177 0.06
|
Overall Mean Square Error 0.01566406 0.01597656 0.0091875 0.00908906 0.01499063 0.01533281 0.01432344 0.01412344 0.02
|
Peak Mean Error 0.0027 0.0026 0.0028 0.002 0.0017 0.0033 0.0031 0.0025 0.015
|
Overall Mean Error 0.00002656 -0.00031406 0.00016875 0.00005469 -0.00003125 0.00011406 0.00009219 0.00004219 0.0015
|
*/
|
#include <stdio.h>
|
#include <string.h>
|
|
#include "iv_datatypedef.h"
|
#include "iv.h"
|
#include "impeg2_defs.h"
|
#include "impeg2_platform_macros.h"
|
|
#include "impeg2_macros.h"
|
#include "impeg2_globals.h"
|
#include "impeg2_idct.h"
|
|
|
void impeg2_idct_recon_dc(WORD16 *pi2_src,
|
WORD16 *pi2_tmp,
|
UWORD8 *pu1_pred,
|
UWORD8 *pu1_dst,
|
WORD32 i4_src_strd,
|
WORD32 i4_pred_strd,
|
WORD32 i4_dst_strd,
|
WORD32 i4_zero_cols,
|
WORD32 i4_zero_rows)
|
{
|
WORD32 i4_val, i, j;
|
|
UNUSED(pi2_tmp);
|
UNUSED(i4_src_strd);
|
UNUSED(i4_zero_cols);
|
UNUSED(i4_zero_rows);
|
|
i4_val = pi2_src[0] * gai2_impeg2_idct_q15[0];
|
i4_val = ((i4_val + IDCT_STG1_ROUND) >> IDCT_STG1_SHIFT);
|
i4_val = i4_val * gai2_impeg2_idct_q11[0];
|
i4_val = ((i4_val + IDCT_STG2_ROUND) >> IDCT_STG2_SHIFT);
|
|
for(i = 0; i < TRANS_SIZE_8; i++)
|
{
|
for(j = 0; j < TRANS_SIZE_8; j++)
|
{
|
pu1_dst[j] = CLIP_U8(i4_val + pu1_pred[j]);
|
}
|
pu1_dst += i4_dst_strd;
|
pu1_pred += i4_pred_strd;
|
}
|
}
|
void impeg2_idct_recon_dc_mismatch(WORD16 *pi2_src,
|
WORD16 *pi2_tmp,
|
UWORD8 *pu1_pred,
|
UWORD8 *pu1_dst,
|
WORD32 i4_src_strd,
|
WORD32 i4_pred_strd,
|
WORD32 i4_dst_strd,
|
WORD32 i4_zero_cols,
|
WORD32 i4_zero_rows)
|
|
{
|
WORD32 i4_val, i, j;
|
WORD32 i4_count = 0;
|
WORD32 i4_sum;
|
|
UNUSED(pi2_tmp);
|
UNUSED(i4_src_strd);
|
UNUSED(i4_zero_cols);
|
UNUSED(i4_zero_rows);
|
|
i4_val = pi2_src[0] * gai2_impeg2_idct_q15[0];
|
i4_val = ((i4_val + IDCT_STG1_ROUND) >> IDCT_STG1_SHIFT);
|
|
i4_val *= gai2_impeg2_idct_q11[0];
|
for(i = 0; i < TRANS_SIZE_8; i++)
|
{
|
for (j = 0; j < TRANS_SIZE_8; j++)
|
{
|
i4_sum = i4_val;
|
i4_sum += gai2_impeg2_mismatch_stg2_additive[i4_count];
|
i4_sum = ((i4_sum + IDCT_STG2_ROUND) >> IDCT_STG2_SHIFT);
|
i4_sum += pu1_pred[j];
|
pu1_dst[j] = CLIP_U8(i4_sum);
|
i4_count++;
|
}
|
|
pu1_dst += i4_dst_strd;
|
pu1_pred += i4_pred_strd;
|
}
|
|
}
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* This function performs Inverse transform and reconstruction for 8x8
|
* input block
|
*
|
* @par Description:
|
* Performs inverse transform and adds the prediction data and clips output
|
* to 8 bit
|
*
|
* @param[in] pi2_src
|
* Input 8x8 coefficients
|
*
|
* @param[in] pi2_tmp
|
* Temporary 8x8 buffer for storing inverse
|
*
|
* transform
|
* 1st stage output
|
*
|
* @param[in] pu1_pred
|
* Prediction 8x8 block
|
*
|
* @param[out] pu1_dst
|
* Output 8x8 block
|
*
|
* @param[in] src_strd
|
* Input stride
|
*
|
* @param[in] pred_strd
|
* Prediction stride
|
*
|
* @param[in] dst_strd
|
* Output Stride
|
*
|
* @param[in] shift
|
* Output shift
|
*
|
* @param[in] zero_cols
|
* Zero columns in pi2_src
|
*
|
* @returns Void
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void impeg2_idct_recon(WORD16 *pi2_src,
|
WORD16 *pi2_tmp,
|
UWORD8 *pu1_pred,
|
UWORD8 *pu1_dst,
|
WORD32 i4_src_strd,
|
WORD32 i4_pred_strd,
|
WORD32 i4_dst_strd,
|
WORD32 i4_zero_cols,
|
WORD32 i4_zero_rows)
|
{
|
WORD32 j, k;
|
WORD32 ai4_e[4], ai4_o[4];
|
WORD32 ai4_ee[2], ai4_eo[2];
|
WORD32 i4_add;
|
WORD32 i4_shift;
|
WORD16 *pi2_tmp_orig;
|
WORD32 i4_trans_size;
|
WORD32 i4_zero_rows_2nd_stage = i4_zero_cols;
|
WORD32 i4_row_limit_2nd_stage;
|
|
i4_trans_size = TRANS_SIZE_8;
|
|
pi2_tmp_orig = pi2_tmp;
|
|
if((i4_zero_cols & 0xF0) == 0xF0)
|
i4_row_limit_2nd_stage = 4;
|
else
|
i4_row_limit_2nd_stage = TRANS_SIZE_8;
|
|
|
if((i4_zero_rows & 0xF0) == 0xF0) /* First 4 rows of input are non-zero */
|
{
|
/************************************************************************************************/
|
/**********************************START - IT_RECON_8x8******************************************/
|
/************************************************************************************************/
|
|
/* Inverse Transform 1st stage */
|
i4_shift = IDCT_STG1_SHIFT;
|
i4_add = 1 << (i4_shift - 1);
|
|
for(j = 0; j < i4_row_limit_2nd_stage; j++)
|
{
|
/* Checking for Zero Cols */
|
if((i4_zero_cols & 1) == 1)
|
{
|
memset(pi2_tmp, 0, i4_trans_size * sizeof(WORD16));
|
}
|
else
|
{
|
/* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
|
for(k = 0; k < 4; k++)
|
{
|
ai4_o[k] = gai2_impeg2_idct_q15[1 * 8 + k] * pi2_src[i4_src_strd]
|
+ gai2_impeg2_idct_q15[3 * 8 + k]
|
* pi2_src[3 * i4_src_strd];
|
}
|
ai4_eo[0] = gai2_impeg2_idct_q15[2 * 8 + 0] * pi2_src[2 * i4_src_strd];
|
ai4_eo[1] = gai2_impeg2_idct_q15[2 * 8 + 1] * pi2_src[2 * i4_src_strd];
|
ai4_ee[0] = gai2_impeg2_idct_q15[0 * 8 + 0] * pi2_src[0];
|
ai4_ee[1] = gai2_impeg2_idct_q15[0 * 8 + 1] * pi2_src[0];
|
|
/* Combining e and o terms at each hierarchy levels to calculate the final spatial domain vector */
|
ai4_e[0] = ai4_ee[0] + ai4_eo[0];
|
ai4_e[3] = ai4_ee[0] - ai4_eo[0];
|
ai4_e[1] = ai4_ee[1] + ai4_eo[1];
|
ai4_e[2] = ai4_ee[1] - ai4_eo[1];
|
for(k = 0; k < 4; k++)
|
{
|
pi2_tmp[k] =
|
CLIP_S16(((ai4_e[k] + ai4_o[k] + i4_add) >> i4_shift));
|
pi2_tmp[k + 4] =
|
CLIP_S16(((ai4_e[3 - k] - ai4_o[3 - k] + i4_add) >> i4_shift));
|
}
|
}
|
pi2_src++;
|
pi2_tmp += i4_trans_size;
|
i4_zero_cols = i4_zero_cols >> 1;
|
}
|
|
pi2_tmp = pi2_tmp_orig;
|
|
/* Inverse Transform 2nd stage */
|
i4_shift = IDCT_STG2_SHIFT;
|
i4_add = 1 << (i4_shift - 1);
|
if((i4_zero_rows_2nd_stage & 0xF0) == 0xF0) /* First 4 rows of output of 1st stage are non-zero */
|
{
|
for(j = 0; j < i4_trans_size; j++)
|
{
|
/* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
|
for(k = 0; k < 4; k++)
|
{
|
ai4_o[k] = gai2_impeg2_idct_q11[1 * 8 + k] * pi2_tmp[i4_trans_size]
|
+ gai2_impeg2_idct_q11[3 * 8 + k] * pi2_tmp[3 * i4_trans_size];
|
}
|
ai4_eo[0] = gai2_impeg2_idct_q11[2 * 8 + 0] * pi2_tmp[2 * i4_trans_size];
|
ai4_eo[1] = gai2_impeg2_idct_q11[2 * 8 + 1] * pi2_tmp[2 * i4_trans_size];
|
ai4_ee[0] = gai2_impeg2_idct_q11[0 * 8 + 0] * pi2_tmp[0];
|
ai4_ee[1] = gai2_impeg2_idct_q11[0 * 8 + 1] * pi2_tmp[0];
|
|
/* Combining e and o terms at each hierarchy levels to calculate the final spatial domain vector */
|
ai4_e[0] = ai4_ee[0] + ai4_eo[0];
|
ai4_e[3] = ai4_ee[0] - ai4_eo[0];
|
ai4_e[1] = ai4_ee[1] + ai4_eo[1];
|
ai4_e[2] = ai4_ee[1] - ai4_eo[1];
|
for(k = 0; k < 4; k++)
|
{
|
WORD32 itrans_out;
|
itrans_out =
|
CLIP_S16(((ai4_e[k] + ai4_o[k] + i4_add) >> i4_shift));
|
pu1_dst[k] = CLIP_U8((itrans_out + pu1_pred[k]));
|
itrans_out =
|
CLIP_S16(((ai4_e[3 - k] - ai4_o[3 - k] + i4_add) >> i4_shift));
|
pu1_dst[k + 4] = CLIP_U8((itrans_out + pu1_pred[k + 4]));
|
}
|
pi2_tmp++;
|
pu1_pred += i4_pred_strd;
|
pu1_dst += i4_dst_strd;
|
}
|
}
|
else /* All rows of output of 1st stage are non-zero */
|
{
|
for(j = 0; j < i4_trans_size; j++)
|
{
|
/* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
|
for(k = 0; k < 4; k++)
|
{
|
ai4_o[k] = gai2_impeg2_idct_q11[1 * 8 + k] * pi2_tmp[i4_trans_size]
|
+ gai2_impeg2_idct_q11[3 * 8 + k]
|
* pi2_tmp[3 * i4_trans_size]
|
+ gai2_impeg2_idct_q11[5 * 8 + k]
|
* pi2_tmp[5 * i4_trans_size]
|
+ gai2_impeg2_idct_q11[7 * 8 + k]
|
* pi2_tmp[7 * i4_trans_size];
|
}
|
|
ai4_eo[0] = gai2_impeg2_idct_q11[2 * 8 + 0] * pi2_tmp[2 * i4_trans_size]
|
+ gai2_impeg2_idct_q11[6 * 8 + 0] * pi2_tmp[6 * i4_trans_size];
|
ai4_eo[1] = gai2_impeg2_idct_q11[2 * 8 + 1] * pi2_tmp[2 * i4_trans_size]
|
+ gai2_impeg2_idct_q11[6 * 8 + 1] * pi2_tmp[6 * i4_trans_size];
|
ai4_ee[0] = gai2_impeg2_idct_q11[0 * 8 + 0] * pi2_tmp[0]
|
+ gai2_impeg2_idct_q11[4 * 8 + 0] * pi2_tmp[4 * i4_trans_size];
|
ai4_ee[1] = gai2_impeg2_idct_q11[0 * 8 + 1] * pi2_tmp[0]
|
+ gai2_impeg2_idct_q11[4 * 8 + 1] * pi2_tmp[4 * i4_trans_size];
|
|
/* Combining e and o terms at each hierarchy levels to calculate the final spatial domain vector */
|
ai4_e[0] = ai4_ee[0] + ai4_eo[0];
|
ai4_e[3] = ai4_ee[0] - ai4_eo[0];
|
ai4_e[1] = ai4_ee[1] + ai4_eo[1];
|
ai4_e[2] = ai4_ee[1] - ai4_eo[1];
|
for(k = 0; k < 4; k++)
|
{
|
WORD32 itrans_out;
|
itrans_out =
|
CLIP_S16(((ai4_e[k] + ai4_o[k] + i4_add) >> i4_shift));
|
pu1_dst[k] = CLIP_U8((itrans_out + pu1_pred[k]));
|
itrans_out =
|
CLIP_S16(((ai4_e[3 - k] - ai4_o[3 - k] + i4_add) >> i4_shift));
|
pu1_dst[k + 4] = CLIP_U8((itrans_out + pu1_pred[k + 4]));
|
}
|
pi2_tmp++;
|
pu1_pred += i4_pred_strd;
|
pu1_dst += i4_dst_strd;
|
}
|
}
|
/************************************************************************************************/
|
/************************************END - IT_RECON_8x8******************************************/
|
/************************************************************************************************/
|
}
|
else /* All rows of input are non-zero */
|
{
|
/************************************************************************************************/
|
/**********************************START - IT_RECON_8x8******************************************/
|
/************************************************************************************************/
|
|
/* Inverse Transform 1st stage */
|
i4_shift = IDCT_STG1_SHIFT;
|
i4_add = 1 << (i4_shift - 1);
|
|
for(j = 0; j < i4_row_limit_2nd_stage; j++)
|
{
|
/* Checking for Zero Cols */
|
if((i4_zero_cols & 1) == 1)
|
{
|
memset(pi2_tmp, 0, i4_trans_size * sizeof(WORD16));
|
}
|
else
|
{
|
/* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
|
for(k = 0; k < 4; k++)
|
{
|
ai4_o[k] = gai2_impeg2_idct_q15[1 * 8 + k] * pi2_src[i4_src_strd]
|
+ gai2_impeg2_idct_q15[3 * 8 + k]
|
* pi2_src[3 * i4_src_strd]
|
+ gai2_impeg2_idct_q15[5 * 8 + k]
|
* pi2_src[5 * i4_src_strd]
|
+ gai2_impeg2_idct_q15[7 * 8 + k]
|
* pi2_src[7 * i4_src_strd];
|
}
|
|
ai4_eo[0] = gai2_impeg2_idct_q15[2 * 8 + 0] * pi2_src[2 * i4_src_strd]
|
+ gai2_impeg2_idct_q15[6 * 8 + 0] * pi2_src[6 * i4_src_strd];
|
ai4_eo[1] = gai2_impeg2_idct_q15[2 * 8 + 1] * pi2_src[2 * i4_src_strd]
|
+ gai2_impeg2_idct_q15[6 * 8 + 1] * pi2_src[6 * i4_src_strd];
|
ai4_ee[0] = gai2_impeg2_idct_q15[0 * 8 + 0] * pi2_src[0]
|
+ gai2_impeg2_idct_q15[4 * 8 + 0] * pi2_src[4 * i4_src_strd];
|
ai4_ee[1] = gai2_impeg2_idct_q15[0 * 8 + 1] * pi2_src[0]
|
+ gai2_impeg2_idct_q15[4 * 8 + 1] * pi2_src[4 * i4_src_strd];
|
|
/* Combining e and o terms at each hierarchy levels to calculate the final spatial domain vector */
|
ai4_e[0] = ai4_ee[0] + ai4_eo[0];
|
ai4_e[3] = ai4_ee[0] - ai4_eo[0];
|
ai4_e[1] = ai4_ee[1] + ai4_eo[1];
|
ai4_e[2] = ai4_ee[1] - ai4_eo[1];
|
for(k = 0; k < 4; k++)
|
{
|
pi2_tmp[k] =
|
CLIP_S16(((ai4_e[k] + ai4_o[k] + i4_add) >> i4_shift));
|
pi2_tmp[k + 4] =
|
CLIP_S16(((ai4_e[3 - k] - ai4_o[3 - k] + i4_add) >> i4_shift));
|
}
|
}
|
pi2_src++;
|
pi2_tmp += i4_trans_size;
|
i4_zero_cols = i4_zero_cols >> 1;
|
}
|
|
pi2_tmp = pi2_tmp_orig;
|
|
/* Inverse Transform 2nd stage */
|
i4_shift = IDCT_STG2_SHIFT;
|
i4_add = 1 << (i4_shift - 1);
|
if((i4_zero_rows_2nd_stage & 0xF0) == 0xF0) /* First 4 rows of output of 1st stage are non-zero */
|
{
|
for(j = 0; j < i4_trans_size; j++)
|
{
|
/* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
|
for(k = 0; k < 4; k++)
|
{
|
ai4_o[k] = gai2_impeg2_idct_q11[1 * 8 + k] * pi2_tmp[i4_trans_size]
|
+ gai2_impeg2_idct_q11[3 * 8 + k] * pi2_tmp[3 * i4_trans_size];
|
}
|
ai4_eo[0] = gai2_impeg2_idct_q11[2 * 8 + 0] * pi2_tmp[2 * i4_trans_size];
|
ai4_eo[1] = gai2_impeg2_idct_q11[2 * 8 + 1] * pi2_tmp[2 * i4_trans_size];
|
ai4_ee[0] = gai2_impeg2_idct_q11[0 * 8 + 0] * pi2_tmp[0];
|
ai4_ee[1] = gai2_impeg2_idct_q11[0 * 8 + 1] * pi2_tmp[0];
|
|
/* Combining e and o terms at each hierarchy levels to calculate the final spatial domain vector */
|
ai4_e[0] = ai4_ee[0] + ai4_eo[0];
|
ai4_e[3] = ai4_ee[0] - ai4_eo[0];
|
ai4_e[1] = ai4_ee[1] + ai4_eo[1];
|
ai4_e[2] = ai4_ee[1] - ai4_eo[1];
|
for(k = 0; k < 4; k++)
|
{
|
WORD32 itrans_out;
|
itrans_out =
|
CLIP_S16(((ai4_e[k] + ai4_o[k] + i4_add) >> i4_shift));
|
pu1_dst[k] = CLIP_U8((itrans_out + pu1_pred[k]));
|
itrans_out =
|
CLIP_S16(((ai4_e[3 - k] - ai4_o[3 - k] + i4_add) >> i4_shift));
|
pu1_dst[k + 4] = CLIP_U8((itrans_out + pu1_pred[k + 4]));
|
}
|
pi2_tmp++;
|
pu1_pred += i4_pred_strd;
|
pu1_dst += i4_dst_strd;
|
}
|
}
|
else /* All rows of output of 1st stage are non-zero */
|
{
|
for(j = 0; j < i4_trans_size; j++)
|
{
|
/* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
|
for(k = 0; k < 4; k++)
|
{
|
ai4_o[k] = gai2_impeg2_idct_q11[1 * 8 + k] * pi2_tmp[i4_trans_size]
|
+ gai2_impeg2_idct_q11[3 * 8 + k]
|
* pi2_tmp[3 * i4_trans_size]
|
+ gai2_impeg2_idct_q11[5 * 8 + k]
|
* pi2_tmp[5 * i4_trans_size]
|
+ gai2_impeg2_idct_q11[7 * 8 + k]
|
* pi2_tmp[7 * i4_trans_size];
|
}
|
|
ai4_eo[0] = gai2_impeg2_idct_q11[2 * 8 + 0] * pi2_tmp[2 * i4_trans_size]
|
+ gai2_impeg2_idct_q11[6 * 8 + 0] * pi2_tmp[6 * i4_trans_size];
|
ai4_eo[1] = gai2_impeg2_idct_q11[2 * 8 + 1] * pi2_tmp[2 * i4_trans_size]
|
+ gai2_impeg2_idct_q11[6 * 8 + 1] * pi2_tmp[6 * i4_trans_size];
|
ai4_ee[0] = gai2_impeg2_idct_q11[0 * 8 + 0] * pi2_tmp[0]
|
+ gai2_impeg2_idct_q11[4 * 8 + 0] * pi2_tmp[4 * i4_trans_size];
|
ai4_ee[1] = gai2_impeg2_idct_q11[0 * 8 + 1] * pi2_tmp[0]
|
+ gai2_impeg2_idct_q11[4 * 8 + 1] * pi2_tmp[4 * i4_trans_size];
|
|
/* Combining e and o terms at each hierarchy levels to calculate the final spatial domain vector */
|
ai4_e[0] = ai4_ee[0] + ai4_eo[0];
|
ai4_e[3] = ai4_ee[0] - ai4_eo[0];
|
ai4_e[1] = ai4_ee[1] + ai4_eo[1];
|
ai4_e[2] = ai4_ee[1] - ai4_eo[1];
|
for(k = 0; k < 4; k++)
|
{
|
WORD32 itrans_out;
|
itrans_out =
|
CLIP_S16(((ai4_e[k] + ai4_o[k] + i4_add) >> i4_shift));
|
pu1_dst[k] = CLIP_U8((itrans_out + pu1_pred[k]));
|
itrans_out =
|
CLIP_S16(((ai4_e[3 - k] - ai4_o[3 - k] + i4_add) >> i4_shift));
|
pu1_dst[k + 4] = CLIP_U8((itrans_out + pu1_pred[k + 4]));
|
}
|
pi2_tmp++;
|
pu1_pred += i4_pred_strd;
|
pu1_dst += i4_dst_strd;
|
}
|
}
|
/************************************************************************************************/
|
/************************************END - IT_RECON_8x8******************************************/
|
/************************************************************************************************/
|
}
|
}
|
